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);
}