native.arm.features.ccm

// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include <cstdint>
#include <cstddef>
#if defined(__APPLE__)
#include <cerrno>
#include <sys/sysctl.h>
#elif defined(__linux__)
#include <cerrno>
#include <sys/auxv.h>
#include <asm/hwcap.h>
#elif defined(_WIN32)
#ifndef NOMINMAX
#define NOMINMAX
#endif
// Import only the SDK contract used here. The full umbrella also declares UI
// APIs with anonymous parameter types that cannot be merged after a BMI import.
// Standalone SDK headers require the architecture marker normally set by windows.h.
#if defined(_M_ARM64) && !defined(_ARM64_)
#define _ARM64_
#endif
#include <processthreadsapi.h>
#endif
 
export module native.arm.features;
export import native.isa;
 
export namespace native {

  struct arm_capabilities {
    isa<arm> present{};
    isa<arm> observed{};
    struct raw_observations {
      bool baseline_observed = false;
      bool fp = false;
      bool asimd = false;
      bool fp16_observed = false;
      bool scalar_fp16 = false;
      bool vector_fp16 = false;
      bool bf16_observed = false;
      bool bf16 = false;
      bool ebf16_observed = false;
      bool ebf16 = false;
      isa<arm> extra_observed{}, extra_features{};
    };

    raw_observations raw{};
  };

  arm_capabilities observe_arm_capabilities() noexcept;
}
 
namespace native {
  arm_capabilities observe_arm_capabilities() noexcept {
    arm_capabilities result;
#if defined(__APPLE__)
    auto query=[](char const * key, bool & value) noexcept {
      int data=0; std::size_t size=sizeof(data);
      if(sysctlbyname(key,&data,&size,nullptr,0)!=0) return errno==ENOENT ? 0 : -1;
      if(size!=sizeof(data)) return -1;
      value=data!=0; return 1;
    };
    bool baseline=false, half=false;
    result.raw.baseline_observed=query("hw.optional.neon",baseline)==1;
    result.raw.fp=result.raw.asimd=baseline;
    auto status=query("hw.optional.arm.FEAT_FP16",half);
    if(status==0) status=query("hw.optional.neon_fp16",half);
    result.raw.fp16_observed=status==1;
    result.raw.scalar_fp16=result.raw.vector_fp16=half;
    result.raw.bf16_observed=query("hw.optional.arm.FEAT_BF16",result.raw.bf16)==1;
    result.raw.ebf16_observed=query("hw.optional.arm.FEAT_EBF16",result.raw.ebf16)==1;
    auto extra=[&](arm_feature f,char const * first,char const * second=nullptr) {
      bool a=false,b=true;
      auto observed=query(first,a)==1;
      if(second) observed=(query(second,b)==1)&&observed;
      if(observed) result.raw.extra_observed.set(f,true);
      if(observed && a && b) result.raw.extra_features.set(f,true);
    };
    extra(arm_feature::aes,"hw.optional.arm.FEAT_AES");
    extra(arm_feature::pmull,"hw.optional.arm.FEAT_PMULL");
    extra(arm_feature::sha1,"hw.optional.arm.FEAT_SHA1");
    extra(arm_feature::sha2,"hw.optional.arm.FEAT_SHA256");
    extra(arm_feature::sha3,"hw.optional.arm.FEAT_SHA3");
    extra(arm_feature::sha512,"hw.optional.arm.FEAT_SHA512");
    extra(arm_feature::sm3,"hw.optional.arm.FEAT_SM3");
    extra(arm_feature::sm4,"hw.optional.arm.FEAT_SM4");
    extra(arm_feature::crc,"hw.optional.armv8_crc32");
    extra(arm_feature::lse,"hw.optional.arm.FEAT_LSE");
    extra(arm_feature::rdm,"hw.optional.arm.FEAT_RDM");
    extra(arm_feature::fp16fml,"hw.optional.arm.FEAT_FHM");
    extra(arm_feature::dotprod,"hw.optional.arm.FEAT_DotProd");
    extra(arm_feature::complxnum,"hw.optional.arm.FEAT_FCMA");
    extra(arm_feature::jsconv,"hw.optional.arm.FEAT_JSCVT");
    extra(arm_feature::rcpc,"hw.optional.arm.FEAT_LRCPC");
    extra(arm_feature::pauth,"hw.optional.arm.FEAT_PAuth");
    extra(arm_feature::i8mm,"hw.optional.arm.FEAT_I8MM");
#elif defined(__linux__)
    errno=0;
    auto hwcap=getauxval(AT_HWCAP);
    if(hwcap==0 && errno!=0) return result;
    result.raw.baseline_observed=result.raw.fp16_observed=true;
    result.raw.fp=(hwcap&HWCAP_FP)!=0;
    result.raw.asimd=(hwcap&HWCAP_ASIMD)!=0;
    result.raw.scalar_fp16=(hwcap&HWCAP_FPHP)!=0;
    result.raw.vector_fp16=(hwcap&HWCAP_ASIMDHP)!=0;
    auto extra=[&](arm_feature f,unsigned long mask) {
      result.raw.extra_observed.set(f,true);
      if((hwcap&mask)==mask) result.raw.extra_features.set(f,true);
    };
    extra(arm_feature::aes,HWCAP_AES);
    extra(arm_feature::pmull,HWCAP_PMULL);
    extra(arm_feature::sha1,HWCAP_SHA1);
    extra(arm_feature::sha2,HWCAP_SHA2);
    extra(arm_feature::crc,HWCAP_CRC32);
    extra(arm_feature::lse,HWCAP_ATOMICS);
#ifdef HWCAP_ASIMDRDM
    extra(arm_feature::rdm,HWCAP_ASIMDRDM);
#endif
#ifdef HWCAP_ASIMDFHM
    extra(arm_feature::fp16fml,HWCAP_ASIMDFHM);
#endif
#ifdef HWCAP_ASIMDDP
    extra(arm_feature::dotprod,HWCAP_ASIMDDP);
#endif
#ifdef HWCAP_FCMA
    extra(arm_feature::complxnum,HWCAP_FCMA);
#endif
#ifdef HWCAP_JSCVT
    extra(arm_feature::jsconv,HWCAP_JSCVT);
#endif
#ifdef HWCAP_LRCPC
    extra(arm_feature::rcpc,HWCAP_LRCPC);
#endif
#ifdef HWCAP_SHA3
    extra(arm_feature::sha3,HWCAP_SHA3);
#endif
#ifdef HWCAP_SHA512
    extra(arm_feature::sha512,HWCAP_SHA512);
#endif
#ifdef HWCAP_SM3
    extra(arm_feature::sm3,HWCAP_SM3);
#endif
#ifdef HWCAP_SM4
    extra(arm_feature::sm4,HWCAP_SM4);
#endif
#if defined(HWCAP_PACA) && defined(HWCAP_PACG)
    extra(arm_feature::pauth,HWCAP_PACA|HWCAP_PACG);
#endif
    errno=0;
    auto hwcap2=getauxval(AT_HWCAP2);
    if(hwcap2!=0 || errno==0) {
#ifdef HWCAP2_I8MM
      result.raw.extra_observed.set(arm_feature::i8mm,true);
      result.raw.extra_features.set(arm_feature::i8mm,(hwcap2&HWCAP2_I8MM)!=0);
#endif
#ifdef HWCAP2_BF16
      result.raw.bf16_observed=true;
      result.raw.bf16=(hwcap2&HWCAP2_BF16)!=0;
#endif
#ifdef HWCAP2_EBF16
      result.raw.ebf16_observed=true;
      result.raw.ebf16=(hwcap2&HWCAP2_EBF16)!=0;
#endif
    }
#elif defined(_WIN32)
    result.raw.baseline_observed=result.raw.fp16_observed=true;
    result.raw.fp=IsProcessorFeaturePresent(PF_ARM_V8_INSTRUCTIONS_AVAILABLE)!=0;
    result.raw.asimd=IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE)!=0;
    // Documented SDK 26100 selector; older HALs return false for unknown features.
    constexpr DWORD fp16_feature=67; // PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE
    result.raw.scalar_fp16=result.raw.vector_fp16=IsProcessorFeaturePresent(fp16_feature)!=0;
    constexpr DWORD bf16_feature=68; // PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE
    constexpr DWORD ebf16_feature=69; // PF_ARM_V86_EBF16_INSTRUCTIONS_AVAILABLE
    result.raw.bf16_observed=result.raw.ebf16_observed=true;
    result.raw.bf16=IsProcessorFeaturePresent(bf16_feature)!=0;
    result.raw.ebf16=IsProcessorFeaturePresent(ebf16_feature)!=0;
    auto extra=[&](arm_feature f,DWORD selector) {
      result.raw.extra_observed.set(f,true);
      if(IsProcessorFeaturePresent(selector)) result.raw.extra_features.set(f,true);
    };
    // A positive bundle establishes every component. A negative bundle cannot
    // distinguish absent components from independently available ones.
    constexpr arm_feature crypto[]{arm_feature::aes,arm_feature::pmull,arm_feature::sha1,arm_feature::sha2};
    if(IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE))
      for(auto feature:crypto) {
        result.raw.extra_observed.set(feature,true);
        result.raw.extra_features.set(feature,true);
      }
    extra(arm_feature::crc,PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE);
    extra(arm_feature::lse,PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE);
    extra(arm_feature::dotprod,43); // PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE
    extra(arm_feature::jsconv,44); // PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE
    extra(arm_feature::rcpc,45); // PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE
    extra(arm_feature::sha3,64); // PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE
    extra(arm_feature::sha512,65); // PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE
    extra(arm_feature::i8mm,66); // PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE
    // Windows exposes no selectors for the remaining catalog entries here;
    // leave them unobserved, even if a CPU model is usually known to have them.
#endif
    auto features=detail::decode_arm_features(result.raw);
    result.present=features.present;
    result.observed=features.observed;
    return result;
  }
}