native.x86.features.ccm

// SPDX-FileCopyrightText: 2024 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include <array>
#include <cstdint>
#include <string_view>
#include "native/attributes.h"
#if defined(_MSC_VER)
#include <intrin.h>
#else
#include <cpuid.h>
#endif
 
export module native.x86.features;
export import native.isa;
 
export namespace native {

  struct native_nodiscard cpuid_t {
    std::int32_t eax, ebx, ecx, edx;
  };

  cpuid_t cpuid(std::int32_t eax, std::int32_t ecx) noexcept;

  enum class native_nodiscard cpu_vendor : std::uint8_t {
    intel = 0, 
    amd = 1, 
    unknown = 2 
  };
 

  struct x86_capabilities {
    isa<x86> present{};
    isa<x86> observed{};
    std::uint64_t xcr0 = 0;
    bool xcr0_observed = false;
    struct raw_observations {
      std::uint32_t max_basic_leaf = 0;
      std::uint32_t leaf1_ecx = 0, leaf1_edx = 0, leaf7_ebx = 0;
      std::uint32_t max_leaf7_subleaf = 0;
      std::uint32_t leaf7_1_eax = 0;
      std::uint32_t leaf7_edx = 0;
      std::uint32_t leaf7_ecx = 0;
      std::uint32_t max_extended_leaf = 0, extended1_ecx = 0;
      std::uint32_t leaf7_1_edx = 0;
    };

    raw_observations raw{};
    std::array<char,13> vendor_id{};
    enum cpu_vendor vendor = cpu_vendor::unknown;
  };

  x86_capabilities observe_x86_capabilities() noexcept;

  extern const enum cpu_vendor cpu_vendor;
}
 
namespace native {
  namespace detail {
    constexpr std::array<char,13> vendor_identifier(cpuid_t leaf) noexcept {
      std::array<char,13> result{};
      std::uint32_t words[]{std::uint32_t(leaf.ebx),std::uint32_t(leaf.edx),std::uint32_t(leaf.ecx)};
      for(unsigned word=0;word!=3;++word)
        for(unsigned byte=0;byte!=4;++byte)
          result[4*word+byte]=char((words[word]>>(8*byte))&0xff);
      return result;
    }
    constexpr enum cpu_vendor identify_vendor(std::array<char,13> const & id) noexcept {
      std::string_view name{id.data(),12};
      if(name=="GenuineIntel") return cpu_vendor::intel;
      if(name=="AuthenticAMD") return cpu_vendor::amd;
      return cpu_vendor::unknown;
    }
    static_assert(identify_vendor(vendor_identifier({0,0x756e6547,0x6c65746e,0x49656e69}))==cpu_vendor::intel);
    static_assert(identify_vendor(vendor_identifier({0,0x68747541,0x444d4163,0x69746e65}))==cpu_vendor::amd);
    static_assert(identify_vendor(vendor_identifier({}))==cpu_vendor::unknown);
  }
 
  cpuid_t cpuid(std::int32_t eax, std::int32_t ecx) noexcept {
#if defined(_MSC_VER)
    int registers[4];
    __cpuidex(registers, eax, ecx);
    return {registers[0], registers[1], registers[2], registers[3]};
#else
    cpuid_t result;
    __cpuid_count(eax, ecx, result.eax, result.ebx, result.ecx, result.edx);
    return result;
#endif
  }
 
 
  x86_capabilities observe_x86_capabilities() noexcept {
    x86_capabilities result;
    auto identity=cpuid(0,0);
    result.raw.max_basic_leaf = std::uint32_t(identity.eax);
    result.vendor_id=detail::vendor_identifier(identity);
    result.vendor=detail::identify_vendor(result.vendor_id);
    if (result.raw.max_basic_leaf >= 1) {
      auto leaf = cpuid(1, 0);
      result.raw.leaf1_ecx = std::uint32_t(leaf.ecx);
      result.raw.leaf1_edx = std::uint32_t(leaf.edx);
      constexpr auto xsave = (1u << 26) | (1u << 27);
      if ((result.raw.leaf1_ecx & xsave) == xsave) {
#if defined(_MSC_VER)
        result.xcr0 = _xgetbv(0);
#else
        std::uint32_t low, high;
        __asm__("xgetbv" : "=a"(low), "=d"(high) : "c"(0));
        result.xcr0 = std::uint64_t(low) | (std::uint64_t(high) << 32);
#endif
        result.xcr0_observed = true;
      }
    }
    if (result.raw.max_basic_leaf >= 7) {
      auto leaf = cpuid(7, 0);
      result.raw.leaf7_ebx = std::uint32_t(leaf.ebx);
      result.raw.leaf7_ecx = std::uint32_t(leaf.ecx);
      result.raw.leaf7_edx = std::uint32_t(leaf.edx);
      result.raw.max_leaf7_subleaf = std::uint32_t(leaf.eax);
      if (result.raw.max_leaf7_subleaf >= 1) {
        auto subleaf = cpuid(7, 1);
        result.raw.leaf7_1_eax = std::uint32_t(subleaf.eax);
        result.raw.leaf7_1_edx = std::uint32_t(subleaf.edx);
      }
    }
    result.raw.max_extended_leaf=std::uint32_t(cpuid(std::int32_t(0x80000000u),0).eax);
    if(result.raw.max_extended_leaf>=0x80000001u)
      result.raw.extended1_ecx=std::uint32_t(cpuid(std::int32_t(0x80000001u),0).ecx);
    auto features=detail::decode_x86_features(result.raw);
    result.present=features.present;
    result.observed=features.observed;
    return result;
  }
 
  const enum cpu_vendor cpu_vendor = [] static noexcept {
    return detail::identify_vendor(detail::vendor_identifier(cpuid(0,0)));
  }();
}