Delete -fms-extensions from coreclr native build

eng/native/configurecompiler.cmake

@@ -520,11 +520,6 @@ if (CLR_CMAKE_HOST_UNIX)
   # Disable frame pointer optimizations so profilers can get better call stacks
   add_compile_options(-fno-omit-frame-pointer)
 
-  # The -fms-extensions enable the stuff like __declspec(uuid()), etc.
-  add_compile_options(-fms-extensions)
-  #-fms-compatibility      Enable full Microsoft Visual C++ compatibility
-  #-fms-extensions         Accept some non-standard constructs supported by the Microsoft compiler
-
   # Make signed arithmetic overflow of addition, subtraction, and multiplication wrap around
   # using twos-complement representation (this is normally undefined according to the C++ spec).
   add_compile_options(-fwrapv)

src/coreclr/binder/bindertracing.cpp

@@ -82,7 +82,7 @@ namespace
 
     void PopulateBindRequest(/*inout*/ BinderTracing::AssemblyBindOperation::BindRequest &request)
     {
-        AssemblySpec *spec = request.AssemblySpec;
+        AssemblySpec *spec = request.AssemblySpecPtr;
         _ASSERTE(spec != nullptr);
 
         if (spec->GetName() != nullptr)
@@ -172,7 +172,7 @@ namespace BinderTracing
 
         // ActivityTracker or EventSource may have triggered the system satellite load, or load of System.Private.CoreLib
         // Don't track such bindings to avoid potential infinite recursion.
-        m_ignoreBind = t_AssemblyLoadStartInProgress && (m_bindRequest.AssemblySpec->IsCoreLib() || m_bindRequest.AssemblySpec->IsCoreLibSatellite());
+        m_ignoreBind = t_AssemblyLoadStartInProgress && (m_bindRequest.AssemblySpecPtr->IsCoreLib() || m_bindRequest.AssemblySpecPtr->IsCoreLibSatellite());
         m_checkedIgnoreBind = true;
         return m_ignoreBind;
     }
@@ -234,12 +234,12 @@ namespace BinderTracing
             bool isLastAttempt = appAssembliesAttempt == nullptr;
             TraceStage(Stage::FindInLoadContext,
                 isLastAttempt && FAILED(m_hr) && SUCCEEDED(inContextAttempt->HResult) ? m_hr : inContextAttempt->HResult,
-                inContextAttempt->Assembly,
+                inContextAttempt->AssemblyHolder,
                 mvidMismatch && isLastAttempt ? errorMsg.GetUnicode() : nullptr);
         }
 
         if (appAssembliesAttempt != nullptr)
-            TraceStage(Stage::ApplicationAssemblies, FAILED(m_hr) && SUCCEEDED(appAssembliesAttempt->HResult) ? m_hr : appAssembliesAttempt->HResult, appAssembliesAttempt->Assembly, mvidMismatch ? errorMsg.GetUnicode() : nullptr);
+            TraceStage(Stage::ApplicationAssemblies, FAILED(m_hr) && SUCCEEDED(appAssembliesAttempt->HResult) ? m_hr : appAssembliesAttempt->HResult, appAssembliesAttempt->AssemblyHolder, mvidMismatch ? errorMsg.GetUnicode() : nullptr);
     }
 
     void ResolutionAttemptedOperation::TraceStage(Stage stage, HRESULT hr, BINDER_SPACE::Assembly *resultAssembly, const WCHAR *customError)

src/coreclr/binder/inc/bindertracing.h

@@ -34,7 +34,7 @@ namespace BinderTracing
 
         struct BindRequest
         {
-            AssemblySpec *AssemblySpec;
+            AssemblySpec *AssemblySpecPtr;
             SString AssemblyName;
             SString AssemblyPath;
             SString RequestingAssembly;

src/coreclr/binder/inc/bindresult.hpp

@@ -39,14 +39,14 @@ namespace BINDER_SPACE
         struct AttemptResult
         {
             HRESULT HResult;
-            ReleaseHolder<Assembly> Assembly;
+            ReleaseHolder<Assembly> AssemblyHolder;
             bool Attempted = false;
 
             void Set(const AttemptResult *result);
 
             void Reset()
             {
-                Assembly = nullptr;
+                AssemblyHolder = nullptr;
                 Attempted = false;
             }
         };

src/coreclr/binder/inc/bindresult.inl

@@ -99,7 +99,7 @@ void BindResult::SetAttemptResult(HRESULT hr, Assembly *pAssembly, bool isInCont
         pAssembly->AddRef();
 
     BindResult::AttemptResult &result = isInContext ? m_inContextAttempt : m_applicationAssembliesAttempt;
-    result.Assembly = pAssembly;
+    result.AssemblyHolder = pAssembly;
     result.HResult = hr;
     result.Attempted = true;
 }
@@ -112,11 +112,11 @@ const BindResult::AttemptResult* BindResult::GetAttempt(bool foundInContext) con
 
 void BindResult::AttemptResult::Set(const BindResult::AttemptResult *result)
 {
-    BINDER_SPACE::Assembly *assembly = result->Assembly;
+    BINDER_SPACE::Assembly *assembly = result->AssemblyHolder;
     if (assembly != nullptr)
         assembly->AddRef();
 
-    Assembly = assembly;
+    AssemblyHolder = assembly;
     HResult = result->HResult;
     Attempted = result->Attempted;
 }

src/coreclr/debug/createdump/dumpwritermacho.cpp

@@ -93,7 +93,7 @@ DumpWriter::BuildSegmentLoadCommands()
     for (const MemoryRegion& memoryRegion : m_crashInfo.MemoryRegions())
     {
         uint64_t size = memoryRegion.Size();
-        uint32_t prot = ConvertFlags(memoryRegion.Permissions());
+        int32_t prot = ConvertFlags(memoryRegion.Permissions());
 
         segment_command_64 segment = {
             LC_SEGMENT_64,                  // uint32_t cmd;
@@ -240,8 +240,8 @@ DumpWriter::WriteSegments()
             // Write the header
             SpecialThreadInfoHeader header = {
                 {SPECIAL_THREADINFO_SIGNATURE},
-                m_crashInfo.Pid(),
-                m_crashInfo.Threads().size()
+                static_cast<uint32_t>(m_crashInfo.Pid()),
+                static_cast<uint32_t>(m_crashInfo.Threads().size())
             };
 
             if (!WriteData(&header, sizeof(header))) {
@@ -252,7 +252,7 @@ DumpWriter::WriteSegments()
             for (const ThreadInfo* thread : m_crashInfo.Threads())
             {
                 SpecialThreadInfoEntry entry = {
-                    thread->Tid(),
+                    static_cast<uint32_t>(thread->Tid()),
                     thread->GetStackPointer()
                 };
 

src/coreclr/debug/daccess/daccess.cpp

@@ -7913,7 +7913,7 @@ void DacStackReferenceWalker::WalkStack()
     // Setup GCCONTEXT structs for the stackwalk.
     GCCONTEXT gcctx = {0};
     DacScanContext dsc(this, &mList, mResolvePointers);
-    dsc.pEnumFunc = DacStackReferenceWalker::GCEnumCallback;
+    dsc.pEnumFunc = DacStackReferenceWalker::GCEnumCallbackFunc;
     gcctx.f = DacStackReferenceWalker::GCReportCallback;
     gcctx.sc = &dsc;
 
@@ -7960,7 +7960,7 @@ CLRDATA_ADDRESS DacStackReferenceWalker::ReadPointer(TADDR addr)
 }
 
 
-void DacStackReferenceWalker::GCEnumCallback(LPVOID hCallback, OBJECTREF *pObject, uint32_t flags, DacSlotLocation loc)
+void DacStackReferenceWalker::GCEnumCallbackFunc(LPVOID hCallback, OBJECTREF *pObject, uint32_t flags, DacSlotLocation loc)
 {
     GCCONTEXT *gcctx = (GCCONTEXT *)hCallback;
     DacScanContext *dsc = (DacScanContext*)gcctx->sc;

src/coreclr/debug/daccess/dacimpl.h

@@ -2057,7 +2057,7 @@ class DacStackReferenceWalker : public DefaultCOMImpl<ISOSStackRefEnum, IID_ISOS
 
 private:
     static StackWalkAction Callback(CrawlFrame *pCF, VOID *pData);
-    static void GCEnumCallback(LPVOID hCallback, OBJECTREF *pObject, uint32_t flags, DacSlotLocation loc);
+    static void GCEnumCallbackFunc(LPVOID hCallback, OBJECTREF *pObject, uint32_t flags, DacSlotLocation loc);
     static void GCReportCallback(PTR_PTR_Object ppObj, ScanContext *sc, uint32_t flags);
 
     CLRDATA_ADDRESS ReadPointer(TADDR addr);

src/coreclr/debug/di/rsthread.cpp

@@ -1503,7 +1503,11 @@ void CordbThread::Get32bitFPRegisters(CONTEXT * pContext)
     for (i = 0; i <= floatStackTop; i++)
     {
         double td = 0.0;
+#ifdef _MSC_VER
         __asm fstp td // copy out the double
+#else
+        __asm("fstpl %0" : "=m" (td));
+#endif
         m_floatValues[i] = td;
     }
 

src/coreclr/debug/di/valuehome.cpp

@@ -518,11 +518,19 @@ void FloatRegValueHome::SetEnregisteredValue(MemoryRange newValue,
 
     while (i <= m_floatIndex)
     {
+        #ifdef _MSC_VER
         __asm fstp td
+        #else
+        __asm("fstpl %0" : "=m" (td));
+        #endif
         popArea[i++] = td;
     }
 
+    #ifdef _MSC_VER
     __asm fld newVal; // push on the new value.
+    #else
+    __asm("fldl %0" : "=m" (newVal));
+    #endif
 
     // Push any values that we popled off back onto the stack,
     // _except_ the last one, which was the one we changed.
@@ -531,7 +539,11 @@ void FloatRegValueHome::SetEnregisteredValue(MemoryRange newValue,
     while (i > 0)
     {
         td = popArea[--i];
+        #ifdef _MSC_VER
         __asm fld td
+        #else
+        __asm("fldl %0" : "=m" (td));
+        #endif
     }
 
     // Save out the modified float area.

src/coreclr/debug/ee/debugger.cpp

@@ -13962,7 +13962,11 @@ void GenericHijackFuncHelper()
 // must be naked.
 //
 #if defined(TARGET_X86)
+#ifdef TARGET_WINDOWS
 __declspec(naked)
+#else
+__attribute__((naked))
+#endif
 #endif // defined (_x86_)
 void Debugger::GenericHijackFunc(void)
 {

src/coreclr/debug/ee/stdafx.h

@@ -36,4 +36,3 @@
 #include "frameinfo.h"
 #include <corerror.h>
 #include "../inc/common.h"
-

src/coreclr/inc/check.h

@@ -162,7 +162,6 @@ class CHECK
 #endif
 };
 
-
 //--------------------------------------------------------------------------------
 // These CHECK macros are the correct way to propagate an assertion.  These
 // routines are designed for use inside "Check" routines.  Such routines may
@@ -535,11 +534,9 @@ CHECK CheckValue(TYPENAME &val)
 
 #endif // _PREFAST_ || _PREFIX_
 
-
 #define COMPILER_ASSUME(_condition) \
     COMPILER_ASSUME_MSG(_condition, "")
 
-
 //--------------------------------------------------------------------------------
 // PREFIX_ASSUME_MSG and PREFAST_ASSUME_MSG are just another name
 // for COMPILER_ASSUME_MSG
@@ -576,18 +573,17 @@ CHECK CheckValue(TYPENAME &val)
 #define UNREACHABLE() \
     UNREACHABLE_MSG("")
 
-#ifdef __llvm__
-
-// LLVM complains if a function does not return what it says.
-#define UNREACHABLE_RET() do { UNREACHABLE(); return 0; } while (0)
-#define UNREACHABLE_MSG_RET(_message) UNREACHABLE_MSG(_message); return 0;
-
-#else // __llvm__
+#define UNREACHABLE_RET() \
+  do {                    \
+    UNREACHABLE();        \
+    return 0;             \
+  } while (0)
 
-#define UNREACHABLE_RET() UNREACHABLE()
-#define UNREACHABLE_MSG_RET(_message) UNREACHABLE_MSG(_message)
-
-#endif // __llvm__ else
+#define UNREACHABLE_MSG_RET(_message) \
+  do {                                \
+    UNREACHABLE_MSG(_message);        \
+    return 0;                         \
+  } while (0)
 
 #ifdef _DEBUG_IMPL
 
@@ -606,7 +602,6 @@ CHECK CheckValue(TYPENAME &val)
 
 #endif
 
-
 //--------------------------------------------------------------------------------
 // STRESS_CHECK represents a check which is included in a free build
 // @todo: behavior on trigger
@@ -704,8 +699,6 @@ CHECK CheckValue(TYPENAME &val)
 
 #endif
 
-
-
 //--------------------------------------------------------------------------------
 // Common base level checks
 //--------------------------------------------------------------------------------

src/coreclr/jit/codegenarmarch.cpp

@@ -2120,10 +2120,10 @@ class ProducingStreamBaseInstrs
     }
 
 private:
-    const regNumber intReg1;
-    const regNumber intReg2;
-    const regNumber addrReg;
-    emitter* const  emitter;
+    const regNumber      intReg1;
+    const regNumber      intReg2;
+    const regNumber      addrReg;
+    class emitter* const emitter;
 };
 
 class ProducingStream
@@ -2213,11 +2213,11 @@ class ProducingStream
     }
 
 private:
-    const regNumber intReg1;
-    const regNumber simdReg1;
-    const regNumber simdReg2;
-    const regNumber addrReg;
-    emitter* const  emitter;
+    const regNumber      intReg1;
+    const regNumber      simdReg1;
+    const regNumber      simdReg2;
+    const regNumber      addrReg;
+    class emitter* const emitter;
 };
 
 class BlockUnrollHelper

src/coreclr/jit/gentree.h

@@ -4668,7 +4668,7 @@ struct NewCallArg
     // The class handle if SignatureType == TYP_STRUCT.
     CORINFO_CLASS_HANDLE SignatureClsHnd = NO_CLASS_HANDLE;
     // The type of well known arg
-    WellKnownArg WellKnownArg = ::WellKnownArg::None;
+    enum class WellKnownArg WellKnownArg = ::WellKnownArg::None;
 
     NewCallArg WellKnown(::WellKnownArg type) const
     {

src/coreclr/jit/inductionvariableopts.cpp

@@ -39,7 +39,7 @@ class LoopLocalOccurrences
     struct Occurrence
     {
         BasicBlock*          Block;
-        Statement*           Statement;
+        struct Statement*    Statement;
         GenTreeLclVarCommon* Node;
         Occurrence*          Next;
     };

src/coreclr/jit/jitstd/allocator.h

@@ -24,7 +24,7 @@ class allocator<void>
     template <typename U>
     struct rebind
     {
-        typedef allocator<U> allocator;
+        typedef class allocator<U> allocator;
     };
 
 private:
@@ -105,7 +105,7 @@ class allocator
     template <typename U>
     struct rebind
     {
-        typedef allocator<U> allocator;
+        typedef class allocator<U> allocator;
     };
 
 private:

src/coreclr/jit/lclmorph.cpp

@@ -2115,7 +2115,7 @@ bool Compiler::fgExposeUnpropagatedLocals(bool propagatedAny, LocalEqualsLocalAd
 
     struct Store
     {
-        Statement*           Statement;
+        struct Statement*    Statement;
         GenTreeLclVarCommon* Tree;
     };
 

src/coreclr/jit/utils.cpp

@@ -1216,8 +1216,8 @@ void NodeCounts::record(genTreeOps oper)
 
 struct DumpOnShutdownEntry
 {
-    const char* Name;
-    Dumpable*   Dumpable;
+    const char*     Name;
+    class Dumpable* Dumpable;
 };
 
 static DumpOnShutdownEntry s_dumpOnShutdown[16];

src/coreclr/nativeaot/Runtime/eventpipe/ds-rt-aot.cpp

@@ -56,7 +56,7 @@ aot_ipc_get_process_id_disambiguation_key(
 	// since the start of the Unix epoch).
 	struct kinfo_proc info = {};
 	size_t size = sizeof (info);
-	int mib [4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process_id };
+	int mib [4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, (int)process_id };
 
 	const int result_sysctl = sysctl (mib, sizeof(mib)/sizeof(*mib), &info, &size, NULL, 0);
 	if (result_sysctl == 0) {

src/coreclr/nativeaot/Runtime/stressLog.cpp

@@ -45,7 +45,15 @@ GPTR_IMPL(StressLog, g_pStressLog /*, &StressLog::theLog*/);
    variable-speed CPUs (for power management), this is not accurate, but may
    be good enough.
 */
-inline __declspec(naked) uint64_t getTimeStamp() {
+
+inline
+#ifdef TARGET_WINDOWS
+__declspec(naked)
+#else
+__attribute__((naked))
+#endif
+uint64_t getTimeStamp()
+{
 
    __asm {
         RDTSC   // read time stamp counter