VS2022 Compatibility

[UnlimitedChild]

Hello,

the latest visual studio 2022 got the following error: Severity Code Description Project File Line Suppression State Error no matching function for call to 'atomic_store_explicit' TinyDBR E:\TinyDBR-master\TinyDBR\tinydbr.cpp 229

template <typename T>
void TinyDBR::CommitValueAtomicT(ModuleInfo* module, size_t start_offset)
{
    static_assert(std::is_integral_v<T> && sizeof(T) <= sizeof(uint64_t));

    T           value = *reinterpret_cast<T*>(module->instrumented_code_local + start_offset);
    _Atomic(T)* ptr   = reinterpret_cast<_Atomic(T)*>(module->instrumented_code_remote + start_offset);

    if ((uintptr_t)ptr % sizeof(T) != 0)
    {
        FATAL("pointer not aligned.");
    }

    atomic_store_explicit(ptr, value, std::memory_order_relaxed);
}

atomic_store_explicit(ptr, value, std::memory_order_relaxed); Clang Diagnostic Error: no matching function for call to atomic_store_explicit

Severity    Code    Description Project File    Line    Suppression State
Error (active)  E0059   function call is not allowed in a constant expression   ShellcodeSample C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Tools\Llvm\x64\lib\clang\15.0.1\include\xmmintrin.h 3014    

/* Ugly hack for backwards-compatibility (compatible with gcc) */
#if defined(__SSE2__) && !__building_module(_Builtin_intrinsics)
#include <emmintrin.h>
#endif

[Inori]

This is a compatibility bug between MSVC and CLang header files. Currently you can comment out atomic_store_explicit in stdatomic.h or so..

[UnlimitedChild]

memory.h

_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store_explicit

_EXPORT_STD template <class _Ty>
_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store_explicit(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
    // store _Other to *_Ptr atomically
    _Shared_ptr_spin_lock _Lock;
    _Ptr->swap(_Other);
}

atomic

_EXPORT_STD template <class _Ty>
void atomic_store_explicit(
    volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    _Mem->store(_Value, _Order);
}

_EXPORT_STD template <class _Ty>
void atomic_store_explicit(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    _Mem->store(_Value, _Order);
}