More GNUC Fixes (#22687)

* Replace __sync_swap with __atomic_exchange_n

__sync_swap() is a clang specific function.

* Remove multiline comment

* Add paranthesis around sum

src/md/hotdata/../inc/streamutil.h:73:34: warning: suggest parentheses around ‘+’ in operand of ‘&’ [-Wparentheses]
     UINT32 aligned = *totalBytes + 3 & ~3;

* Define __int64

* Define windows types for tests

* Remove undefined has_builtin defines and define alloca and inline for GNUC

* Remove __clang__ where possible

* Add implicit casting to help compiler find WCHAR* variant

src/binder/assembly.cpp:294:73: error: no matching function for call to ‘SString::SString(SString)’
         return (pAsmName == nullptr ? nullptr : pAsmName->GetSimpleName());
                                                                         ^
In file included from src/inc/sstring.h:1082:0,
                 from src/inc/ex.h:19,
                 from src/inc/stgpool.h:28,
                 from src/inc/../md/inc/metamodel.h:18,
                 from src/inc/../md/inc/metamodelro.h:19,
                 from src/inc/metadata.h:17,
                 from src/binder/../vm/util.hpp:19,
                 from src/binder/../vm/common.h:110,
                 from src/binder/assembly.cpp:14:
src/inc/sstring.inl:73:8: note: candidate: SString::SString(void*, COUNT_T)
 inline SString::SString(void *buffer, COUNT_T size)
        ^
src/inc/sstring.inl:73:8: note:   candidate expects 2 arguments, 1 provided
src/inc/sstring.inl:436:8: note: candidate: SString::SString(SString::tagLiteral, const WCHAR*, COUNT_T)
 inline SString::SString(tagLiteral dummytag, const WCHAR *literal, COUNT_T count)
        ^
src/inc/sstring.inl:436:8: note:   candidate expects 3 arguments, 1 provided
src/inc/sstring.inl:418:8: note: candidate: SString::SString(SString::tagLiteral, const WCHAR*)
 inline SString::SString(tagLiteral dummytag, const WCHAR *literal)
        ^
src/inc/sstring.inl:418:8: note:   candidate expects 2 arguments, 1 provided
src/inc/sstring.inl:401:8: note: candidate: SString::SString(SString::tagUTF8Literal, const UTF8*)
 inline SString::SString(tagUTF8Literal dummytag, const UTF8 *literal)
        ^
src/inc/sstring.inl:401:8: note:   candidate expects 2 arguments, 1 provided
src/inc/sstring.inl:382:8: note: candidate: SString::SString(SString::tagLiteral, const CHAR*)
 inline SString::SString(tagLiteral dummytag, const ASCII *literal)

* Reorder DLLEXPORT and STDAPI

GNUC wants extern "C" <attribute> format.

* Abstract __FUNCSIG__

* Abstract __debugbreak()

* Move common compiler options out of clang and add Wno-unused-value

* Add paranthesis around || and &&

src/gc/gc.cpp:9084:38: warning: suggest parentheses around ‘&&’ within ‘||’ [-Wparentheses]
                     (!chosen_power2) && (i < free_space_count));

* Set Wno-delete-non-virtual-dtor for CXX files only

* Don't warn on unterminated endif labels

* Suppress unused functions

* Use 0x syntax rather than h syntax on GNU asm files

* Correct constructor call directly

src/ToolBox/superpmi/superpmi-shared/logging.cpp:301:27:   required from here
src/inc/clr_std/string:58:9: error: cannot call constructor ‘std::basic_string<char>::basic_string’ directly
         this->basic_string::basic_string(_Ptr, c_len(_Ptr));

* Suppress NULL used in arithmetic warnings

2 files changed, 26 insertions, 8 deletions

diff --git a/src/gc/env/gcenv.base.h b/src/gc/env/gcenv.base.h
index 351f4f300a..e99149eb6f 100644
--- a/src/gc/env/gcenv.base.h
+++ b/src/gc/env/gcenv.base.h
@@ -14,13 +14,17 @@
 #define REDHAWK_PALIMPORT extern "C"
 #define REDHAWK_PALAPI __stdcall
 
+#if !defined(_MSC_VER)
+#define _alloca alloca
+#endif //_MSC_VER
+
 #ifndef _MSC_VER
 #define __stdcall
-#ifdef __clang__
+#ifdef __GNUC__
 #define __forceinline __attribute__((always_inline)) inline
-#else // __clang__
+#else // __GNUC__
 #define __forceinline inline
-#endif // __clang__
+#endif // __GNUC__
 // [LOCALGC TODO] is there a better place for this?
 #define NOINLINE __attribute__((noinline))
 #else // !_MSC_VER
@@ -178,18 +182,26 @@ typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(void* lpThreadParameter);
  #endif
 #else // _MSC_VER
 
+#ifdef __llvm__
+#define HAS_IA32_PAUSE __has_builtin(__builtin_ia32_pause)
+#define HAS_IA32_MFENCE __has_builtin(__builtin_ia32_mfence)
+#else
+#define HAS_IA32_PAUSE 0
+#define HAS_IA32_MFENCE 0
+#endif
+
 // Only clang defines __has_builtin, so we first test for a GCC define
 // before using __has_builtin.
 
 #if defined(__i386__) || defined(__x86_64__)
 
-#if (__GNUC__ > 4 && __GNUC_MINOR > 7) || __has_builtin(__builtin_ia32_pause)
+#if (__GNUC__ > 4 && __GNUC_MINOR > 7) || HAS_IA32_PAUSE
  // clang added this intrinsic in 3.8
  // gcc added this intrinsic by 4.7.1
  #define YieldProcessor __builtin_ia32_pause
 #endif // __has_builtin(__builtin_ia32_pause)
 
-#if defined(__GNUC__) || __has_builtin(__builtin_ia32_mfence)
+#if defined(__GNUC__) || HAS_IA32_MFENCE
  // clang has had this intrinsic since at least 3.0
  // gcc has had this intrinsic since forever
  #define MemoryBarrier __builtin_ia32_mfence
@@ -455,7 +467,13 @@ typedef DPTR(uint8_t)   PTR_uint8_t;
 
 #define DATA_ALIGNMENT sizeof(uintptr_t)
 #define RAW_KEYWORD(x) x
+
+#ifdef _MSC_VER
 #define DECLSPEC_ALIGN(x)   __declspec(align(x))
+#else
+#define DECLSPEC_ALIGN(x)   __attribute__((aligned(x)))
+#endif
+
 #ifndef _ASSERTE
 #define _ASSERTE(_expr) ASSERT(_expr)
 #endif
diff --git a/src/gc/env/gcenv.interlocked.inl b/src/gc/env/gcenv.interlocked.inl
index 3eaaa3ae59..1df2700d7f 100644
--- a/src/gc/env/gcenv.interlocked.inl
+++ b/src/gc/env/gcenv.interlocked.inl
@@ -70,7 +70,7 @@ __forceinline T Interlocked::Exchange(T volatile *destination, T value)
     static_assert(sizeof(long) == sizeof(T), "Size of long must be the same as size of T");
     return _InterlockedExchange((long*)destination, value);
 #else
-    T result = __sync_swap(destination, value);
+    T result = __atomic_exchange_n(destination, value, __ATOMIC_ACQ_REL);
     ArmInterlockedOperationBarrier();
     return result;
 #endif
@@ -164,7 +164,7 @@ __forceinline T Interlocked::ExchangePointer(T volatile * destination, T value)
     return (T)(TADDR)_InterlockedExchange((long volatile *)(void* volatile *)destination, (long)(void*)value);
 #endif
 #else
-    T result = (T)(TADDR)__sync_swap((void* volatile *)destination, value);
+    T result = (T)(TADDR)__atomic_exchange_n((void* volatile *)destination, value, __ATOMIC_ACQ_REL);
     ArmInterlockedOperationBarrier();
     return result;
 #endif
@@ -180,7 +180,7 @@ __forceinline T Interlocked::ExchangePointer(T volatile * destination, std::null
     return (T)(TADDR)_InterlockedExchange((long volatile *)(void* volatile *)destination, (long)(void*)value);
 #endif
 #else
-    T result = (T)(TADDR)__sync_swap((void* volatile *)destination, value);
+    T result = (T)(TADDR)__atomic_exchange_n((void* volatile *)destination, value, __ATOMIC_ACQ_REL);
     ArmInterlockedOperationBarrier();
     return result;
 #endif