DenormalGuard.h

Go to the documentation of this file.

// DSPark - Professional Audio DSP Framework
// Copyright (c) 2026 Cristian Moresi - MIT License
 
#pragma once
 
#include <cstdint>
 
// Capability gates: a branch is enabled only when the architecture AND the
// toolchain/FPU features it needs are all present; every other target
// compiles as a safe no-op (denormals stay enabled - a performance matter,
// never a correctness one).
//
// - x86/x64 needs SSE for LDMXCSR/STMXCSR. Always present on x64; assumed on
//   32-bit MSVC (every Windows-supported x86 CPU has SSE); on 32-bit
//   GCC/Clang only with -msse (__SSE__) - without it the SSE builtins do not
//   even compile.
// - AArch64 GCC/Clang (including clang-cl) uses mrs/msr inline assembly.
//   MSVC has no inline assembly on ARM64 and uses the status-register
//   intrinsics instead.
// - 32-bit ARM vmrs/vmsr are VFP instructions: only available with a
//   hardware FPU (__ARM_FP, per ACLE). Soft-float targets (e.g. Cortex-M0/M3)
//   get the no-op.
#if defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86) \
    || (defined(__i386__) && defined(__SSE__))
    #define DSPARK_DENORMAL_X86 1
    #include <immintrin.h>
#elif (defined(__aarch64__) || defined(_M_ARM64)) && (defined(__GNUC__) || defined(__clang__))
    #define DSPARK_DENORMAL_ARM64_ASM 1
#elif defined(_M_ARM64) && defined(_MSC_VER)
    #define DSPARK_DENORMAL_ARM64_MSVC 1
    #include <intrin.h>   // _ReadStatusReg / _WriteStatusReg
#elif defined(__arm__) && defined(__ARM_FP) && (defined(__GNUC__) || defined(__clang__))
    #define DSPARK_DENORMAL_ARM32 1
#endif
 
namespace dspark {
 
class [[nodiscard]] DenormalGuard
{
public:
    DenormalGuard() noexcept
    {
#if defined(DSPARK_DENORMAL_X86)
        previousState_ = _mm_getcsr();
        // 0x8040u = FTZ (bit 15) | DAZ (bit 6)
        _mm_setcsr(static_cast<unsigned int>(previousState_) | 0x8040u);
 
#elif defined(DSPARK_DENORMAL_ARM64_ASM)
        unsigned long long fpcr;
        __asm__ __volatile__("mrs %0, fpcr" : "=r"(fpcr));
        previousState_ = fpcr;
        fpcr |= (1ULL << 24); // FZ bit
        __asm__ __volatile__("msr fpcr, %0" : : "r"(fpcr));
 
#elif defined(DSPARK_DENORMAL_ARM64_MSVC)
        const long long fpcr = _ReadStatusReg(ARM64_FPCR);
        previousState_ = static_cast<uint64_t>(fpcr);
        _WriteStatusReg(ARM64_FPCR, fpcr | (1LL << 24)); // FZ bit
 
#elif defined(DSPARK_DENORMAL_ARM32)
        unsigned int fpscr;
        __asm__ __volatile__("vmrs %0, fpscr" : "=r"(fpscr));
        previousState_ = fpscr;
        fpscr |= (1u << 24); // FZ bit
        __asm__ __volatile__("vmsr fpscr, %0" : : "r"(fpscr));
 
#else
        // No-op fallback: WebAssembly (no FTZ mode exists), 32-bit MSVC ARM,
        // x86/ARM builds without the required SSE/FPU features, and any
        // architecture not listed above.
        previousState_ = 0;
#endif
    }
 
    ~DenormalGuard() noexcept
    {
#if defined(DSPARK_DENORMAL_X86)
        _mm_setcsr(static_cast<unsigned int>(previousState_));
 
#elif defined(DSPARK_DENORMAL_ARM64_ASM)
        const unsigned long long fpcr = static_cast<unsigned long long>(previousState_);
        __asm__ __volatile__("msr fpcr, %0" : : "r"(fpcr));
 
#elif defined(DSPARK_DENORMAL_ARM64_MSVC)
        _WriteStatusReg(ARM64_FPCR, static_cast<long long>(previousState_));
 
#elif defined(DSPARK_DENORMAL_ARM32)
        const unsigned int fpscr = static_cast<unsigned int>(previousState_);
        __asm__ __volatile__("vmsr fpscr, %0" : : "r"(fpscr));
#endif
    }
 
    [[nodiscard]] static constexpr bool isActive() noexcept
    {
#if defined(DSPARK_DENORMAL_X86) || defined(DSPARK_DENORMAL_ARM64_ASM) \
    || defined(DSPARK_DENORMAL_ARM64_MSVC) || defined(DSPARK_DENORMAL_ARM32)
        return true;
#else
        return false;
#endif
    }
 
    // A scope guard is tied to its constructing scope and thread: neither
    // copyable nor movable.
    DenormalGuard(const DenormalGuard&) = delete;
    DenormalGuard& operator=(const DenormalGuard&) = delete;
    DenormalGuard(DenormalGuard&&) = delete;
    DenormalGuard& operator=(DenormalGuard&&) = delete;
 
private:
    uint64_t previousState_ = 0;
};
 
} // namespace dspark
 
#undef DSPARK_DENORMAL_X86
#undef DSPARK_DENORMAL_ARM64_ASM
#undef DSPARK_DENORMAL_ARM64_MSVC
#undef DSPARK_DENORMAL_ARM32