features.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
 
// Include intrinsics headers for CPU feature detection
#if defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)
    #if defined(_MSC_VER)
        #include <intrin.h>
    #elif defined(__GNUC__) || defined(__clang__)
        #include <cpuid.h>
        #include <immintrin.h>
    #endif
    #define TRLC_HAS_X86_INTRINSICS 1
#else
    #define TRLC_HAS_X86_INTRINSICS 0
#endif
 
#if defined(__ARM_NEON) || defined(__aarch64__)
    #if defined(__GNUC__) || defined(__clang__)
        #include <arm_neon.h>
    #endif
    #define TRLC_HAS_ARM_INTRINSICS 1
#else
    #define TRLC_HAS_ARM_INTRINSICS 0
#endif
 
namespace trlc {
namespace platform {
 
enum class LanguageFeature : int {
    exceptions = 0,               
    rtti,                         
    threads,                      
    atomic_operations,            
    inline_assembly,              
    vector_intrinsics,            
    stack_protection,             
    address_sanitizer,            
    thread_sanitizer,             
    memory_sanitizer,             
    undefined_behavior_sanitizer  
};
 
enum class RuntimeFeature : int {
    sse = 0,         
    sse2,            
    sse3,            
    sse4_1,          
    sse4_2,          
    avx,             
    avx2,            
    avx512f,         
    neon,            
    hardware_aes,    
    hardware_random  
};
 
struct FeatureSet {
    // Language features (compile-time determined)
    bool has_exceptions;                    
    bool has_rtti;                          
    bool has_threads;                       
    bool has_atomic;                        
    bool has_inline_asm;                    
    bool has_vector_intrinsics;             
    bool has_stack_protection;              
    bool has_address_sanitizer;             
    bool has_thread_sanitizer;              
    bool has_memory_sanitizer;              
    bool has_undefined_behavior_sanitizer;  
 
    // Runtime features (may require runtime detection)
    bool has_sse;              
    bool has_sse2;             
    bool has_sse3;             
    bool has_sse4_1;           
    bool has_sse4_2;           
    bool has_avx;              
    bool has_avx2;             
    bool has_avx512f;          
    bool has_neon;             
    bool has_hardware_aes;     
    bool has_hardware_random;  
 
    constexpr bool hasLanguageFeature(LanguageFeature feature) const noexcept {
        switch (feature) {
            case LanguageFeature::exceptions:
                return has_exceptions;
            case LanguageFeature::rtti:
                return has_rtti;
            case LanguageFeature::threads:
                return has_threads;
            case LanguageFeature::atomic_operations:
                return has_atomic;
            case LanguageFeature::inline_assembly:
                return has_inline_asm;
            case LanguageFeature::vector_intrinsics:
                return has_vector_intrinsics;
            case LanguageFeature::stack_protection:
                return has_stack_protection;
            case LanguageFeature::address_sanitizer:
                return has_address_sanitizer;
            case LanguageFeature::thread_sanitizer:
                return has_thread_sanitizer;
            case LanguageFeature::memory_sanitizer:
                return has_memory_sanitizer;
            case LanguageFeature::undefined_behavior_sanitizer:
                return has_undefined_behavior_sanitizer;
            default:
                return false;
        }
    }
 
    bool hasRuntimeFeature(RuntimeFeature feature) const noexcept {
        switch (feature) {
            case RuntimeFeature::sse:
                return has_sse;
            case RuntimeFeature::sse2:
                return has_sse2;
            case RuntimeFeature::sse3:
                return has_sse3;
            case RuntimeFeature::sse4_1:
                return has_sse4_1;
            case RuntimeFeature::sse4_2:
                return has_sse4_2;
            case RuntimeFeature::avx:
                return has_avx;
            case RuntimeFeature::avx2:
                return has_avx2;
            case RuntimeFeature::avx512f:
                return has_avx512f;
            case RuntimeFeature::neon:
                return has_neon;
            case RuntimeFeature::hardware_aes:
                return has_hardware_aes;
            case RuntimeFeature::hardware_random:
                return has_hardware_random;
            default:
                return false;
        }
    }
};
 
//
// Language feature detection functions
//
 
constexpr bool hasExceptions() noexcept {
#ifdef __cpp_exceptions
    return true;
#elif defined(__EXCEPTIONS) || defined(_CPPUNWIND)
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasRtti() noexcept {
#ifdef __cpp_rtti
    return true;
#elif defined(__GXX_RTTI) || defined(_CPPRTTI)
    return true;
#elif defined(__has_feature)
    #if __has_feature(cxx_rtti)
    return true;
    #else
    return false;
    #endif
#else
    return true;  // Assume available by default
#endif
}
 
constexpr bool hasThreads() noexcept {
#ifdef __STDCPP_THREADS__
    return __STDCPP_THREADS__ == 1;
#elif defined(_REENTRANT) || defined(_MT)
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasAtomicOperations() noexcept {
#ifdef __cpp_lib_atomic_shared_ptr
    return true;
#elif defined(__ATOMIC_RELAXED)
    return true;
#elif defined(_MSC_VER)
    return true;  // MSVC has atomic support
#else
    return true;  // Assume available in C++17+
#endif
}
 
constexpr bool hasInlineAssembly() noexcept {
#if defined(__GNUC__) || defined(__clang__)
    return true;
#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasVectorIntrinsics() noexcept {
    return TRLC_HAS_X86_INTRINSICS || TRLC_HAS_ARM_INTRINSICS;
}
 
constexpr bool hasStackProtection() noexcept {
#ifdef __STACK_CHK_FAIL
    return true;
#elif defined(__SSP__) || defined(__SSP_ALL__)
    return true;
#elif defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasAddressSanitizer() noexcept {
#ifdef __has_feature
    #if __has_feature(address_sanitizer)
    return true;
    #endif
#endif
#ifdef __SANITIZE_ADDRESS__
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasThreadSanitizer() noexcept {
#ifdef __has_feature
    #if __has_feature(thread_sanitizer)
    return true;
    #endif
#endif
#ifdef __SANITIZE_THREAD__
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasMemorySanitizer() noexcept {
#ifdef __has_feature
    #if __has_feature(memory_sanitizer)
    return true;
    #endif
#endif
#ifdef __SANITIZE_MEMORY__
    return true;
#else
    return false;
#endif
}
 
constexpr bool hasUndefinedBehaviorSanitizer() noexcept {
#ifdef __has_feature
    #if __has_feature(undefined_behavior_sanitizer)
    return true;
    #endif
#endif
#ifdef __SANITIZE_UNDEFINED__
    return true;
#else
    return false;
#endif
}
 
//
// Runtime feature detection functions
//
 
#if TRLC_HAS_X86_INTRINSICS
 
namespace detail {
 
inline void cpuid(uint32_t leaf, uint32_t subleaf, uint32_t regs[4]) noexcept {
    #if defined(_MSC_VER)
    __cpuidex(reinterpret_cast<int*>(regs), static_cast<int>(leaf), static_cast<int>(subleaf));
    #elif defined(__GNUC__) || defined(__clang__)
    __cpuid_count(leaf, subleaf, regs[0], regs[1], regs[2], regs[3]);
    #else
    regs[0] = regs[1] = regs[2] = regs[3] = 0;
    #endif
}
 
inline bool checkCpuFeature(uint32_t leaf, uint32_t subleaf, int reg, int bit) noexcept {
    uint32_t regs[4];
    cpuid(leaf, subleaf, regs);
    return (regs[reg] & (1u << bit)) != 0;
}
 
}  // namespace detail
 
#endif  // TRLC_HAS_X86_INTRINSICS
 
inline bool hasSseSupport() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 3, 25);  // EDX bit 25
#else
    return false;
#endif
}
 
inline bool hasSse2Support() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 3, 26);  // EDX bit 26
#else
    return false;
#endif
}
 
inline bool hasSse3Support() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 0);  // ECX bit 0
#else
    return false;
#endif
}
 
inline bool hasSse41Support() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 19);  // ECX bit 19
#else
    return false;
#endif
}
 
inline bool hasSse42Support() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 20);  // ECX bit 20
#else
    return false;
#endif
}
 
inline bool hasAvxSupport() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 28);  // ECX bit 28
#else
    return false;
#endif
}
 
inline bool hasAvx2Support() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(7, 0, 1, 5);  // EBX bit 5
#else
    return false;
#endif
}
 
inline bool hasAvx512fSupport() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(7, 0, 1, 16);  // EBX bit 16
#else
    return false;
#endif
}
 
inline bool hasNeonSupport() noexcept {
#if TRLC_HAS_ARM_INTRINSICS
    #ifdef __ARM_NEON
    return true;
    #elif defined(__aarch64__)
    return true;  // NEON is mandatory on AArch64
    #else
    return false;
    #endif
#else
    return false;
#endif
}
 
inline bool hasHardwareAes() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 25);  // ECX bit 25
#elif TRLC_HAS_ARM_INTRINSICS && defined(__ARM_FEATURE_AES)
    return true;
#else
    return false;
#endif
}
 
inline bool hasHardwareRandom() noexcept {
#if TRLC_HAS_X86_INTRINSICS
    return detail::checkCpuFeature(1, 0, 2, 30);  // ECX bit 30 (RDRAND)
#else
    return false;
#endif
}
 
//
// Unified feature detection functions
//
 
constexpr FeatureSet getFeatureSet() noexcept {
    return FeatureSet{
        // Language features (compile-time) - must match order in struct
        hasExceptions(),
        hasRtti(),
        hasThreads(),
        hasAtomicOperations(),
        hasInlineAssembly(),
        hasVectorIntrinsics(),
        hasStackProtection(),
        hasAddressSanitizer(),
        hasThreadSanitizer(),
        hasMemorySanitizer(),
        hasUndefinedBehaviorSanitizer(),
 
        // Runtime features (initialized to false, require runtime detection)
        false,  // has_sse
        false,  // has_sse2
        false,  // has_sse3
        false,  // has_sse4_1
        false,  // has_sse4_2
        false,  // has_avx
        false,  // has_avx2
        false,  // has_avx512f
        false,  // has_neon
        false,  // has_hardware_aes
        false   // has_hardware_random
    };
}
 
constexpr bool hasLanguageFeature(LanguageFeature feature) noexcept {
    switch (feature) {
        case LanguageFeature::exceptions:
            return hasExceptions();
        case LanguageFeature::rtti:
            return hasRtti();
        case LanguageFeature::threads:
            return hasThreads();
        case LanguageFeature::atomic_operations:
            return hasAtomicOperations();
        case LanguageFeature::inline_assembly:
            return hasInlineAssembly();
        case LanguageFeature::vector_intrinsics:
            return hasVectorIntrinsics();
        case LanguageFeature::stack_protection:
            return hasStackProtection();
        case LanguageFeature::address_sanitizer:
            return hasAddressSanitizer();
        case LanguageFeature::thread_sanitizer:
            return hasThreadSanitizer();
        case LanguageFeature::memory_sanitizer:
            return hasMemorySanitizer();
        case LanguageFeature::undefined_behavior_sanitizer:
            return hasUndefinedBehaviorSanitizer();
        default:
            return false;
    }
}
 
inline bool hasRuntimeFeature(RuntimeFeature feature) noexcept {
    switch (feature) {
        case RuntimeFeature::sse:
            return hasSseSupport();
        case RuntimeFeature::sse2:
            return hasSse2Support();
        case RuntimeFeature::sse3:
            return hasSse3Support();
        case RuntimeFeature::sse4_1:
            return hasSse41Support();
        case RuntimeFeature::sse4_2:
            return hasSse42Support();
        case RuntimeFeature::avx:
            return hasAvxSupport();
        case RuntimeFeature::avx2:
            return hasAvx2Support();
        case RuntimeFeature::avx512f:
            return hasAvx512fSupport();
        case RuntimeFeature::neon:
            return hasNeonSupport();
        case RuntimeFeature::hardware_aes:
            return hasHardwareAes();
        case RuntimeFeature::hardware_random:
            return hasHardwareRandom();
        default:
            return false;
    }
}
 
template <LanguageFeature TFeature>
constexpr bool hasFeature() noexcept {
    return hasLanguageFeature(TFeature);
}
 
}  // namespace platform
}  // namespace trlc
 
//
// Convenience macros for compile-time features
//
 
#define TRLC_HAS_EXCEPTIONS (trlc::platform::hasExceptions())
 
#define TRLC_HAS_RTTI (trlc::platform::hasRtti())
 
#define TRLC_HAS_THREADS (trlc::platform::hasThreads())
 
#define TRLC_HAS_ATOMIC (trlc::platform::hasAtomicOperations())
 
#define TRLC_HAS_INLINE_ASM (trlc::platform::hasInlineAssembly())
 
#define TRLC_HAS_VECTOR_INTRINSICS (trlc::platform::hasVectorIntrinsics())
 
#define TRLC_HAS_STACK_PROTECTION (trlc::platform::hasStackProtection())
 
#define TRLC_HAS_ADDRESS_SANITIZER (trlc::platform::hasAddressSanitizer())
 
#define TRLC_HAS_THREAD_SANITIZER (trlc::platform::hasThreadSanitizer())
 
#define TRLC_HAS_MEMORY_SANITIZER (trlc::platform::hasMemorySanitizer())
 
#define TRLC_HAS_UNDEFINED_BEHAVIOR_SANITIZER (trlc::platform::hasUndefinedBehaviorSanitizer())
 
#define TRLC_HAS_FEATURE(X) (trlc::platform::hasFeature<trlc::platform::LanguageFeature::X>())
 
//
// Runtime feature macros (non-constexpr)
//
 
#define TRLC_HAS_SSE_RUNTIME() (trlc::platform::hasSseSupport())
 
#define TRLC_HAS_SSE2_RUNTIME() (trlc::platform::hasSse2Support())
 
#define TRLC_HAS_SSE3_RUNTIME() (trlc::platform::hasSse3Support())
 
#define TRLC_HAS_SSE41_RUNTIME() (trlc::platform::hasSse41Support())
 
#define TRLC_HAS_SSE42_RUNTIME() (trlc::platform::hasSse42Support())
 
#define TRLC_HAS_AVX_RUNTIME() (trlc::platform::hasAvxSupport())
 
#define TRLC_HAS_AVX2_RUNTIME() (trlc::platform::hasAvx2Support())
 
#define TRLC_HAS_AVX512F_RUNTIME() (trlc::platform::hasAvx512fSupport())
 
#define TRLC_HAS_NEON_RUNTIME() (trlc::platform::hasNeonSupport())
 
#define TRLC_HAS_HARDWARE_AES_RUNTIME() (trlc::platform::hasHardwareAes())
 
#define TRLC_HAS_HARDWARE_RANDOM_RUNTIME() (trlc::platform::hasHardwareRandom())
 
//
// Conditional compilation helpers
//
 
#ifdef __cpp_exceptions
    #define TRLC_IF_EXCEPTIONS(code) code
#elif defined(__EXCEPTIONS) || defined(_CPPUNWIND)
    #define TRLC_IF_EXCEPTIONS(code) code
#else
    #define TRLC_IF_EXCEPTIONS(code) ((void)0)
#endif
 
#ifdef __cpp_rtti
    #define TRLC_IF_RTTI(code) code
#elif defined(__GXX_RTTI) || defined(_CPPRTTI)
    #define TRLC_IF_RTTI(code) code
#else
    #define TRLC_IF_RTTI(code) ((void)0)
#endif
 
#ifdef __STDCPP_THREADS__
    #if __STDCPP_THREADS__ == 1
        #define TRLC_IF_THREADS(code) code
    #else
        #define TRLC_IF_THREADS(code) ((void)0)
    #endif
#elif defined(_REENTRANT) || defined(_MT)
    #define TRLC_IF_THREADS(code) code
#else
    #define TRLC_IF_THREADS(code) ((void)0)
#endif