Remove remaining CRT PAL wrappers and enable including standard headers in the CoreCLR build (#98336)

- Remove malloc-family PAL and update callsites that might get passed 0 to bump up to 1.
- Move `getenv` usage to use the `PAL` function directly when on non-Windows (to preserve the existing behavior).
- Remove other remaining CRT PAL shims
- Remove header shims and enable building with the CRT and STL headers across the product, with various build fixes required (mostly around using the standard min/max definitions)

eng/native/configurecompiler.cmake

@@ -28,7 +28,6 @@ if (CLR_CMAKE_HOST_UNIX)
         add_compile_options(-Wno-null-conversion)
         add_compile_options(-glldb)
     else()
-        add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Werror=conversion-null>)
         add_compile_options(-g)
     endif()
 endif()

eng/native/functions.cmake

@@ -220,6 +220,12 @@ endfunction(convert_to_absolute_path)
 function(preprocess_file inputFilename outputFilename)
   get_compile_definitions(PREPROCESS_DEFINITIONS)
   get_include_directories(PREPROCESS_INCLUDE_DIRECTORIES)
+  get_source_file_property(SOURCE_FILE_DEFINITIONS ${inputFilename} COMPILE_DEFINITIONS)
+  
+  foreach(DEFINITION IN LISTS SOURCE_FILE_DEFINITIONS)
+    list(APPEND PREPROCESS_DEFINITIONS -D${DEFINITION})
+  endforeach()
+
   if (MSVC)
     add_custom_command(
         OUTPUT ${outputFilename}

src/coreclr/CMakeLists.txt

@@ -202,11 +202,12 @@ if(CLR_CMAKE_HOST_UNIX)
     add_subdirectory(debug/createdump)
   endif(CLR_CMAKE_HOST_OSX OR (CLR_CMAKE_HOST_LINUX AND NOT CLR_CMAKE_HOST_UNIX_X86 AND NOT CLR_CMAKE_HOST_ANDROID))
 
-  # Include the dummy c++ include files
+  # The CoreCLR PAL used to redefine NULL, which caused a number of null conversion and arithmetic
-  include_directories("pal/inc/rt/cpp")
+  # warnings and errors to be suppressed.
-
+  # Suppress these warnings here to avoid breaking the build.
-  # This prevents inclusion of standard C compiler headers
+  add_compile_options($<$<COMPILE_LANG_AND_ID:CXX,Clang,AppleClang>:-Wno-null-arithmetic>)
-  add_compile_options(-nostdinc)
+  add_compile_options($<$<COMPILE_LANG_AND_ID:CXX,GNU>:-Wno-conversion-null>)
+  add_compile_options($<$<COMPILE_LANG_AND_ID:CXX,GNU>:-Wno-pointer-arith>)
 
   set (NATIVE_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/nativeresources)
   include_directories(${NATIVE_RESOURCE_DIR})
@@ -218,7 +219,7 @@ if(CLR_CMAKE_HOST_UNIX)
   # given Windows .rc file. The target C++ file path is returned in the
   # variable specified by the TARGET_FILE parameter.
   function(build_resources SOURCE TARGET_NAME TARGET_FILE)
-
+    set_property(SOURCE ${SOURCE} APPEND PROPERTY COMPILE_DEFINITIONS "RC_INVOKED")
     set(PREPROCESSED_SOURCE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.rc.i)
 
     preprocess_file(${SOURCE} ${PREPROCESSED_SOURCE})

src/coreclr/binder/assemblyname.cpp

@@ -11,10 +11,10 @@
 //
 // ============================================================
 
+#include "common.h"
 #include "assemblyname.hpp"
 #include "assemblybindercommon.hpp"
 
-#include "common.h"
 #include "utils.hpp"
 
 #include "textualidentityparser.hpp"

src/coreclr/clrdefinitions.cmake

@@ -53,6 +53,7 @@ if(CLR_CMAKE_HOST_WIN32)
   add_definitions(-D_WIN32_WINNT=0x0602)
   add_definitions(-DWIN32_LEAN_AND_MEAN)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  add_compile_definitions(NOMINMAX)
 endif(CLR_CMAKE_HOST_WIN32)
 
 if (NOT (CLR_CMAKE_TARGET_ARCH_I386 AND CLR_CMAKE_TARGET_UNIX))

src/coreclr/debug/createdump/CMakeLists.txt

@@ -56,8 +56,6 @@ else(CLR_CMAKE_HOST_WIN32)
       endif(CLR_CMAKE_HOST_OSX)
     endif (CORECLR_SET_RPATH)
 
-    add_definitions(-DPAL_STDCPP_COMPAT)
-
     # This is so we can include "version.c"
     include_directories(${CMAKE_BINARY_DIR})
 

src/coreclr/debug/daccess/daccess.cpp

@@ -5793,7 +5793,7 @@ ClrDataAccess::RawGetMethodName(
             SIZE_T maxPrecodeSize = sizeof(StubPrecode);
 
 #ifdef HAS_THISPTR_RETBUF_PRECODE
-            maxPrecodeSize = max(maxPrecodeSize, sizeof(ThisPtrRetBufPrecode));
+            maxPrecodeSize = max((size_t)maxPrecodeSize, sizeof(ThisPtrRetBufPrecode));
 #endif
 
             for (SIZE_T i = 0; i < maxPrecodeSize / PRECODE_ALIGNMENT; i++)

src/coreclr/debug/dbgutil/CMakeLists.txt

@@ -9,8 +9,6 @@ if(CLR_CMAKE_HOST_WIN32 OR CLR_CMAKE_HOST_OSX)
   include_directories(${CLR_DIR}/inc/llvm)
 endif(CLR_CMAKE_HOST_WIN32 OR CLR_CMAKE_HOST_OSX)
 
-add_definitions(-DPAL_STDCPP_COMPAT)
-
 if(CLR_CMAKE_TARGET_LINUX_MUSL)
     add_definitions(-DTARGET_LINUX_MUSL)
 endif(CLR_CMAKE_TARGET_LINUX_MUSL)

src/coreclr/debug/debug-pal/CMakeLists.txt

@@ -2,8 +2,6 @@ include_directories(../inc)
 include_directories(../../pal/inc)
 include_directories(${EP_GENERATED_HEADER_PATH})
 
-add_definitions(-DPAL_STDCPP_COMPAT)
-
 set(SHARED_EVENTPIPE_SOURCE_PATH ${CLR_SRC_NATIVE_DIR}/eventpipe)
 add_definitions(-DFEATURE_CORECLR)
 add_definitions(-DFEATURE_PERFTRACING)

src/coreclr/debug/di/rspriv.h

@@ -3975,9 +3975,9 @@ public:
 
     // CORDB_ADDRESS's are UINT_PTR's (64 bit under HOST_64BIT, 32 bit otherwise)
 #if defined(TARGET_64BIT)
-#define MAX_ADDRESS     (_UI64_MAX)
+#define MAX_ADDRESS     (UINT64_MAX)
 #else
-#define MAX_ADDRESS     (_UI32_MAX)
+#define MAX_ADDRESS     (UINT32_MAX)
 #endif
 #define MIN_ADDRESS     (0x0)
     CORDB_ADDRESS       m_minPatchAddr; //smallest patch in table

src/coreclr/debug/di/rsthread.cpp

@@ -5122,7 +5122,7 @@ HRESULT CordbValueEnum::Next(ULONG celt, ICorDebugValue *values[], ULONG *pceltF
 
     HRESULT hr = S_OK;
 
-    int iMax = min( m_iMax, m_iCurrent+celt);
+    int iMax = (int)min( (ULONG)m_iMax, m_iCurrent+celt);
     int i;
     for (i = m_iCurrent; i< iMax;i++)
     {
@@ -8186,7 +8186,7 @@ HRESULT CordbJITILFrame::FabricateNativeInfo(DWORD dwIndex,
             // first argument, but thereafter we have to decrement it
             // before getting the variable's location from it.  So increment
             // it here to be consistent later.
-            rpCur += max(cbType, cbArchitectureMin);
+            rpCur += max((ULONG)cbType, cbArchitectureMin);
 #endif
 
             // Grab the IL code's function's method signature so we can see if it's static.
@@ -8219,7 +8219,7 @@ HRESULT CordbJITILFrame::FabricateNativeInfo(DWORD dwIndex,
                 IfFailThrow(pArgType->GetUnboxedObjectSize(&cbType));
 
 #if defined(TARGET_X86) // STACK_GROWS_DOWN_ON_ARGS_WALK
-                rpCur -= max(cbType, cbArchitectureMin);
+                rpCur -= max((ULONG)cbType, cbArchitectureMin);
                 m_rgNVI[i].loc.vlFixedVarArg.vlfvOffset =
                     (unsigned)(m_FirstArgAddr - rpCur);
 
@@ -8229,7 +8229,7 @@ HRESULT CordbJITILFrame::FabricateNativeInfo(DWORD dwIndex,
 #else // STACK_GROWS_UP_ON_ARGS_WALK
                 m_rgNVI[i].loc.vlFixedVarArg.vlfvOffset =
                     (unsigned)(rpCur - m_FirstArgAddr);
-                rpCur += max(cbType, cbArchitectureMin);
+                rpCur += max((ULONG)cbType, cbArchitectureMin);
                 AlignAddressForType(pArgType, rpCur);
 #endif
 
@@ -10877,7 +10877,7 @@ HRESULT CordbCodeEnum::Next(ULONG celt, ICorDebugCode *values[], ULONG *pceltFet
 
     HRESULT hr = S_OK;
 
-    int iMax = min( m_iMax, m_iCurrent+celt);
+    int iMax = (int)min( (ULONG)m_iMax, m_iCurrent+celt);
     int i;
 
     for (i = m_iCurrent; i < iMax; i++)

src/coreclr/debug/di/rstype.cpp

@@ -2898,7 +2898,7 @@ HRESULT CordbTypeEnum::Next(ULONG celt, ICorDebugType *values[], ULONG *pceltFet
 
     HRESULT hr = S_OK;
 
-    int iMax = min( m_iMax, m_iCurrent+celt);
+    int iMax = (int)min( (ULONG)m_iMax, m_iCurrent+celt);
     int i;
 
     for (i = m_iCurrent; i < iMax; i++)

src/coreclr/debug/di/shimcallback.cpp

@@ -1408,7 +1408,7 @@ HRESULT ShimProxyCallback::DataBreakpoint(ICorDebugProcess* pProcess, ICorDebugT
             this->m_pThread.Assign(pThread);
 
             _ASSERTE(contextSize == sizeof(CONTEXT));
-            this->m_contextSize = min(contextSize, sizeof(CONTEXT));
+            this->m_contextSize = min(contextSize, (ULONG32)sizeof(CONTEXT));
             memcpy(&(this->m_context), pContext, this->m_contextSize);
         }
 

src/coreclr/debug/di/stdafx.h

@@ -10,6 +10,9 @@
 #include <stdio.h>
 #include <windows.h>
 #include <winnt.h>
+#include <algorithm>
+using std::min;
+using std::max;
 
 #include <dbgtargetcontext.h>
 

src/coreclr/debug/ee/debugger.cpp

@@ -3029,7 +3029,7 @@ HRESULT Debugger::GetILToNativeMappingIntoArrays(
     if (pDJI == NULL)
         return E_FAIL;
 
-    ULONG32 cMap = min(cMapMax, pDJI->GetSequenceMapCount());
+    ULONG32 cMap = min((ULONG32)cMapMax, pDJI->GetSequenceMapCount());
     DebuggerILToNativeMap * rgMapInt = pDJI->GetSequenceMap();
 
     NewArrayHolder<UINT> rguiILOffsetTemp = new (nothrow) UINT[cMap];

src/coreclr/debug/ee/funceval.cpp

@@ -2806,7 +2806,7 @@ void PackArgumentArray(DebuggerEval *pDE,
 
 #ifdef FEATURE_HFA
         // The buffer for HFAs has to be always ENREGISTERED_RETURNTYPE_MAXSIZE
-        size = max(size, ENREGISTERED_RETURNTYPE_MAXSIZE);
+        size = max(size, (unsigned)ENREGISTERED_RETURNTYPE_MAXSIZE);
 #endif
 
         BYTE * pTemp = new (interopsafe) BYTE[ALIGN_UP(sizeof(ValueClassInfo), 8) + size];

src/coreclr/debug/ee/stdafx.h

@@ -12,6 +12,8 @@
 #include <stdint.h>
 #include <wchar.h>
 #include <stdio.h>
+#include <algorithm>
+#include <cmath>
 
 #include <windows.h>
 

src/coreclr/debug/inc/dbgipcevents.h

@@ -768,7 +768,7 @@ public:
     //
     // Operators to emulate Pointer semantics.
     //
-    bool IsNull() { SUPPORTS_DAC; return m_addr == NULL; }
+    bool IsNull() { SUPPORTS_DAC; return m_addr == (TADDR)0; }
 
     static VMPTR_This NullPtr()
     {

src/coreclr/debug/shared/dbgtransportsession.cpp

@@ -1949,7 +1949,7 @@ void DbgTransportSession::TransportWorker()
                     DWORD   cbBytesToRead = sReceiveHeader.TypeSpecificData.MemoryAccess.m_cbLeftSideBuffer;
                     while (cbBytesToRead)
                     {
-                        DWORD cbTransfer = min(cbBytesToRead, sizeof(rgDummy));
+                        DWORD cbTransfer = min(cbBytesToRead, (DWORD)sizeof(rgDummy));
                         if (!ReceiveBlock(rgDummy, cbTransfer))
                             HANDLE_TRANSIENT_ERROR();
                         cbBytesToRead -= cbTransfer;

src/coreclr/dlls/mscordac/mscordac_unixexports.src

@@ -22,15 +22,10 @@ nativeStringResourceTable_mscorrc
 ; All the # exports are prefixed with DAC_
 #PAL_CatchHardwareExceptionHolderEnter
 #PAL_CatchHardwareExceptionHolderExit
-#PAL_bsearch
 #PAL_CopyModuleData
-#PAL_errno
-#PAL_free
 #PAL_GetLogicalCpuCountFromOS
 #PAL_GetTotalCpuCount
 #PAL_GetUnwindInfoSize
-#PAL_stdout
-#PAL_stderr
 #PAL_GetApplicationGroupId
 #PAL_GetTransportName
 #PAL_GetCurrentThread
@@ -47,9 +42,6 @@ nativeStringResourceTable_mscorrc
 #PAL_ReadProcessMemory
 #PAL_ProbeMemory
 #PAL_Random
-#PAL_malloc
-#PAL_realloc
-#PAL_qsort
 #PAL__wcstoui64
 #PAL_wcstoul
 #PAL_wcstod

src/coreclr/dlls/mscorpe/stdafx.h

@@ -11,6 +11,7 @@
 #include <assert.h>
 #include <stdio.h>
 #include <stddef.h>
+#include <algorithm>
 
 #define FEATURE_NO_HOST     // Do not use host interface
 #include <utilcode.h>
@@ -21,3 +22,6 @@
 #include "ceegen.h"
 #include "ceefilegenwriter.h"
 #include "ceesectionstring.h"
+
+using std::min;
+using std::max;

src/coreclr/gc/env/common.h

@@ -25,6 +25,9 @@
 #include <math.h>
 
 #include <new>
+#include <type_traits>
+#include <limits>
+#include <algorithm>
 
 #ifdef TARGET_UNIX
 #include <pthread.h>

src/coreclr/gc/env/gcenv.base.h

@@ -100,14 +100,6 @@ inline HRESULT HRESULT_FROM_WIN32(unsigned long x)
 
 #define ZeroMemory(Destination,Length) memset((Destination),0,(Length))
 
-#ifndef min
-#define min(a,b) (((a) < (b)) ? (a) : (b))
-#endif
-
-#ifndef max
-#define max(a,b) (((a) > (b)) ? (a) : (b))
-#endif
-
 #define C_ASSERT(cond) static_assert( cond, #cond )
 
 #define UNREFERENCED_PARAMETER(P)          (void)(P)
@@ -393,7 +385,6 @@ typedef struct _PROCESSOR_NUMBER {
     uint8_t Number;
     uint8_t Reserved;
 } PROCESSOR_NUMBER, *PPROCESSOR_NUMBER;
-
 #endif // _INC_WINDOWS
 
 // -----------------------------------------------------------------------------------------------------------

src/coreclr/gc/gc.cpp

@@ -3113,7 +3113,7 @@ void gc_history_global::print()
 
 uint32_t limit_time_to_uint32 (uint64_t time)
 {
-    time = min (time, UINT32_MAX);
+    time = min (time, (uint64_t)UINT32_MAX);
     return (uint32_t)time;
 }
 
@@ -6972,7 +6972,7 @@ void gc_heap::gc_thread_function ()
 
                 dynamic_heap_count_data_t::sample& sample = dynamic_heap_count_data.samples[dynamic_heap_count_data.sample_index];
                 wait_time = min (wait_time, (uint32_t)(sample.elapsed_between_gcs / 1000 / 3));
-                wait_time = max (wait_time, 1);
+                wait_time = max (wait_time, 1u);
 
                 dprintf (6666, ("gc#0 thread waiting for %d ms (betwen GCs %I64d)", wait_time, sample.elapsed_between_gcs));
             }
@@ -7022,7 +7022,7 @@ void gc_heap::gc_thread_function ()
             }
 
             // wait till the threads that should have gone idle at least reached the place where they are about to wait on the idle event.
-            if ((gc_heap::dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) && 
+            if ((gc_heap::dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) &&
                 (n_heaps != dynamic_heap_count_data.last_n_heaps))
             {
                 int spin_count = 1024;
@@ -12141,7 +12141,7 @@ void gc_heap::clear_region_demoted (heap_segment* region)
 
 int gc_heap::get_plan_gen_num (int gen_number)
 {
-    return ((settings.promotion) ? min ((gen_number + 1), max_generation) : gen_number);
+    return ((settings.promotion) ? min ((gen_number + 1), (int)max_generation) : gen_number);
 }
 
 uint8_t* gc_heap::get_uoh_start_object (heap_segment* region, generation* gen)
@@ -12280,7 +12280,7 @@ void gc_heap::init_heap_segment (heap_segment* seg, gc_heap* hp
 #endif //MULTIPLE_HEAPS
 
 #ifdef USE_REGIONS
-    int gen_num_for_region = min (gen_num, max_generation);
+    int gen_num_for_region = min (gen_num, (int)max_generation);
     set_region_gen_num (seg, gen_num_for_region);
     heap_segment_plan_gen_num (seg) = gen_num_for_region;
     heap_segment_swept_in_plan (seg) = false;
@@ -13300,7 +13300,7 @@ void gc_heap::distribute_free_regions()
             const int i = 0;
             const int n_heaps = 1;
 #endif //MULTIPLE_HEAPS
-            ptrdiff_t budget_gen = max (hp->estimate_gen_growth (gen), 0);
+            ptrdiff_t budget_gen = max (hp->estimate_gen_growth (gen), (ptrdiff_t)0);
             int kind = gen >= loh_generation;
             size_t budget_gen_in_region_units = (budget_gen + (region_size[kind] - 1)) / region_size[kind];
             dprintf (REGIONS_LOG, ("h%2d gen %d has an estimated growth of %zd bytes (%zd regions)", i, gen, budget_gen, budget_gen_in_region_units));
@@ -13520,7 +13520,7 @@ void gc_heap::distribute_free_regions()
     if (ephemeral_elapsed >= DECOMMIT_TIME_STEP_MILLISECONDS)
     {
         gc_last_ephemeral_decommit_time = dd_time_clock (dd0);
-        size_t decommit_step_milliseconds = min (ephemeral_elapsed, (10*1000));
+        size_t decommit_step_milliseconds = min (ephemeral_elapsed, (size_t)(10*1000));
 
         decommit_step (decommit_step_milliseconds);
     }
@@ -13896,7 +13896,7 @@ uint32_t adjust_heaps_hard_limit_worker (uint32_t nhp, size_t limit)
     size_t aligned_limit =  align_on_segment_hard_limit (limit);
     uint32_t nhp_oh = (uint32_t)(aligned_limit / min_segment_size_hard_limit);
     nhp = min (nhp_oh, nhp);
-    return (max (nhp, 1));
+    return (max (nhp, 1u));
 }
 
 uint32_t gc_heap::adjust_heaps_hard_limit (uint32_t nhp)
@@ -14300,7 +14300,7 @@ gc_heap::init_semi_shared()
 #endif //!USE_REGIONS
 
 #ifdef MULTIPLE_HEAPS
-    mark_list_size = min (100*1024, max (8192, soh_segment_size/(2*10*32)));
+    mark_list_size = min ((size_t)100*1024, max ((size_t)8192, soh_segment_size/(2*10*32)));
 #ifdef DYNAMIC_HEAP_COUNT
     if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes)
     {
@@ -14322,7 +14322,7 @@ gc_heap::init_semi_shared()
     }
 #else //MULTIPLE_HEAPS
 
-    mark_list_size = min(100*1024, max (8192, soh_segment_size/(64*32)));
+    mark_list_size = min((size_t)100*1024, max ((size_t)8192, soh_segment_size/(64*32)));
     g_mark_list_total_size = mark_list_size;
     g_mark_list = make_mark_list (mark_list_size);
 
@@ -14444,7 +14444,7 @@ gc_heap::init_semi_shared()
     if (bgc_tuning::enable_fl_tuning && (current_memory_load < bgc_tuning::memory_load_goal))
     {
         uint32_t distance_to_goal = bgc_tuning::memory_load_goal - current_memory_load;
-        bgc_tuning::stepping_interval = max (distance_to_goal / 10, 1);
+        bgc_tuning::stepping_interval = max (distance_to_goal / 10, 1u);
         bgc_tuning::last_stepping_mem_load = current_memory_load;
         bgc_tuning::last_stepping_bgc_count = 0;
         dprintf (BGC_TUNING_LOG, ("current ml: %d, %d to goal, interval: %d",
@@ -21815,13 +21815,13 @@ size_t gc_heap::min_reclaim_fragmentation_threshold (uint32_t num_heaps)
     dprintf (GTC_LOG, ("min av: %zd, 10%% gen2: %zd, 3%% mem: %zd",
         min_mem_based_on_available, ten_percent_size, three_percent_mem));
 #endif //SIMPLE_DPRINTF
-    return (size_t)(min (min_mem_based_on_available, min (ten_percent_size, three_percent_mem)));
+    return (size_t)(min ((uint64_t)min_mem_based_on_available, min ((uint64_t)ten_percent_size, three_percent_mem)));
 }
 
 inline
 uint64_t gc_heap::min_high_fragmentation_threshold(uint64_t available_mem, uint32_t num_heaps)
 {
-    return min (available_mem, (256*1024*1024)) / num_heaps;
+    return min (available_mem, (uint64_t)(256*1024*1024)) / num_heaps;
 }
 
 enum {
@@ -22082,7 +22082,7 @@ size_t gc_heap::exponential_smoothing (int gen, size_t collection_count, size_t
 {
     // to avoid spikes in mem usage due to short terms fluctuations in survivorship,
     // apply some smoothing.
-    size_t smoothing = min(3, collection_count);
+    size_t smoothing = min((size_t)3, collection_count);
 
     size_t desired_total = desired_per_heap * n_heaps;
     size_t new_smoothed_desired_total = desired_total / smoothing + ((smoothed_desired_total[gen] / smoothing) * (smoothing - 1));
@@ -22191,7 +22191,7 @@ void gc_heap::gc1()
     }
 
     //adjust the allocation size from the pinned quantities.
-    for (int gen_number = 0; gen_number <= min (max_generation,n+1); gen_number++)
+    for (int gen_number = 0; gen_number <= min ((int)max_generation,n+1); gen_number++)
     {
         generation* gn = generation_of (gen_number);
         if (settings.compaction)
@@ -22371,7 +22371,7 @@ void gc_heap::gc1()
         if (alloc_contexts_used >= 1)
         {
             allocation_quantum = Align (min ((size_t)CLR_SIZE,
-                                            (size_t)max (1024, get_new_allocation (0) / (2 * alloc_contexts_used))),
+                                            (size_t)max ((size_t)1024, get_new_allocation (0) / (2 * alloc_contexts_used))),
                                             get_alignment_constant(FALSE));
             dprintf (3, ("New allocation quantum: %zd(0x%zx)", allocation_quantum, allocation_quantum));
         }
@@ -28594,7 +28594,7 @@ recheck:
         if (grow_mark_array_p)
         {
             // Try to grow the array.
-            size_t new_size = max (MARK_STACK_INITIAL_LENGTH, 2*background_mark_stack_array_length);
+            size_t new_size = max ((size_t)MARK_STACK_INITIAL_LENGTH, 2*background_mark_stack_array_length);
 
             if ((new_size * sizeof(mark)) > 100*1024)
             {
@@ -28934,7 +28934,7 @@ recheck:
         overflow_p = TRUE;
         // Try to grow the array.
         size_t new_size =
-            max (MARK_STACK_INITIAL_LENGTH, 2*mark_stack_array_length);
+            max ((size_t)MARK_STACK_INITIAL_LENGTH, 2*mark_stack_array_length);
 
         if ((new_size * sizeof(mark)) > 100*1024)
         {
@@ -29237,7 +29237,7 @@ BOOL gc_heap::decide_on_promotion_surv (size_t threshold)
     {
         gc_heap* hp = pGenGCHeap;
 #endif //MULTIPLE_HEAPS
-        dynamic_data* dd = hp->dynamic_data_of (min ((settings.condemned_generation + 1), max_generation));
+        dynamic_data* dd = hp->dynamic_data_of (min ((int)(settings.condemned_generation + 1), (int)max_generation));
         size_t older_gen_size = dd_current_size (dd) + (dd_desired_allocation (dd) - dd_new_allocation (dd));
 
         size_t promoted = hp->total_promoted_bytes;
@@ -29313,7 +29313,7 @@ void gc_heap::verify_region_to_generation_map()
                 }
                 size_t region_index_start = get_basic_region_index_for_address (get_region_start (region));
                 size_t region_index_end = get_basic_region_index_for_address (heap_segment_reserved (region));
-                int gen_num = min (gen_number, soh_gen2);
+                int gen_num = min (gen_number, (int)soh_gen2);
                 assert (gen_num == heap_segment_gen_num (region));
                 int plan_gen_num = heap_segment_plan_gen_num (region);
                 bool is_demoted = (region->flags & heap_segment_flags_demoted) != 0;
@@ -32546,7 +32546,7 @@ void gc_heap::plan_phase (int condemned_gen_number)
 
     if ((condemned_gen_number < max_generation))
     {
-        older_gen = generation_of (min (max_generation, 1 + condemned_gen_number));
+        older_gen = generation_of (min ((int)max_generation, 1 + condemned_gen_number));
         generation_allocator (older_gen)->copy_to_alloc_list (r_free_list);
 
         r_free_list_space = generation_free_list_space (older_gen);
@@ -34117,7 +34117,7 @@ void gc_heap::plan_phase (int condemned_gen_number)
         {
             reset_pinned_queue_bos();
 #ifndef USE_REGIONS
-            unsigned int  gen_number = min (max_generation, 1 + condemned_gen_number);
+            unsigned int  gen_number = (unsigned int)min ((int)max_generation, 1 + condemned_gen_number);
             generation*  gen = generation_of (gen_number);
             uint8_t*  low = generation_allocation_start (generation_of (gen_number-1));
             uint8_t*  high =  heap_segment_allocated (ephemeral_heap_segment);
@@ -42454,8 +42454,8 @@ adjust:
 #endif // SEG_REUSE_STATS
         if (free_space_items)
         {
-            max_free_space_items = min (MAX_NUM_FREE_SPACES, free_space_items * 2);
+            max_free_space_items = min ((size_t)MAX_NUM_FREE_SPACES, free_space_items * 2);
-            max_free_space_items = max (max_free_space_items, MIN_NUM_FREE_SPACES);
+            max_free_space_items = max (max_free_space_items, (size_t)MIN_NUM_FREE_SPACES);
         }
         else
         {
@@ -42686,8 +42686,8 @@ BOOL gc_heap::can_expand_into_p (heap_segment* seg, size_t min_free_size, size_t
                 memcpy (ordered_free_space_indices,
                         saved_ordered_free_space_indices,
                         sizeof(ordered_free_space_indices));
-                max_free_space_items = max (MIN_NUM_FREE_SPACES, free_space_items * 3 / 2);
+                max_free_space_items = max ((size_t)MIN_NUM_FREE_SPACES, free_space_items * 3 / 2);
-                max_free_space_items = min (MAX_NUM_FREE_SPACES, max_free_space_items);
+                max_free_space_items = min ((size_t)MAX_NUM_FREE_SPACES, max_free_space_items);
                 dprintf (SEG_REUSE_LOG_0, ("could fit! %zd free spaces, %zd max", free_space_items, max_free_space_items));
             }
 
@@ -43371,14 +43371,14 @@ void gc_heap::init_static_data()
 
     size_t gen0_max_size =
 #ifdef MULTIPLE_HEAPS
-        max (6*1024*1024, min ( Align(soh_segment_size/2), 200*1024*1024));
+        max ((size_t)6*1024*1024, min ( Align(soh_segment_size/2), (size_t)200*1024*1024));
 #else //MULTIPLE_HEAPS
         (
 #ifdef BACKGROUND_GC
             gc_can_use_concurrent ?
             6*1024*1024 :
 #endif //BACKGROUND_GC
-            max (6*1024*1024,  min ( Align(soh_segment_size/2), 200*1024*1024))
+            max ((size_t)6*1024*1024,  min ( Align(soh_segment_size/2), (size_t)200*1024*1024))
         );
 #endif //MULTIPLE_HEAPS
 
@@ -43408,14 +43408,14 @@ void gc_heap::init_static_data()
     // TODO: gen0_max_size has a 200mb cap; gen1_max_size should also have a cap.
     size_t gen1_max_size = (size_t)
 #ifdef MULTIPLE_HEAPS
-        max (6*1024*1024, Align(soh_segment_size/2));
+        max ((size_t)6*1024*1024, Align(soh_segment_size/2));
 #else //MULTIPLE_HEAPS
         (
 #ifdef BACKGROUND_GC
             gc_can_use_concurrent ?
             6*1024*1024 :
 #endif //BACKGROUND_GC
-            max (6*1024*1024, Align(soh_segment_size/2))
+            max ((size_t)6*1024*1024, Align(soh_segment_size/2))
         );
 #endif //MULTIPLE_HEAPS
 
@@ -43562,7 +43562,7 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd,
             }
             else
             {
-                new_size = (size_t) min (max ( (f * current_size), min_gc_size), max_size);
+                new_size = (size_t) min (max ( (size_t)(f * current_size), min_gc_size), max_size);
             }
 
             assert ((new_size >= current_size) || (new_size == max_size));
@@ -43634,7 +43634,7 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd,
             size_t survivors = out;
             cst = float (survivors) / float (dd_begin_data_size (dd));
             f = surv_to_growth (cst, limit, max_limit);
-            new_allocation = (size_t) min (max ((f * (survivors)), min_gc_size), max_size);
+            new_allocation = (size_t) min (max ((size_t)(f * (survivors)), min_gc_size), max_size);
 
             new_allocation = linear_allocation_model (allocation_fraction, new_allocation,
                                                       dd_desired_allocation (dd), time_since_previous_collection_secs);
@@ -43700,9 +43700,9 @@ size_t gc_heap::generation_plan_size (int gen_number)
     return result;
 #else //USE_REGIONS
     if (0 == gen_number)
-        return max((heap_segment_plan_allocated (ephemeral_heap_segment) -
+        return (size_t)max((heap_segment_plan_allocated (ephemeral_heap_segment) -
                     generation_plan_allocation_start (generation_of (gen_number))),
-                   (int)Align (min_obj_size));
+                   (ptrdiff_t)Align (min_obj_size));
     else
     {
         generation* gen = generation_of (gen_number);
@@ -43751,9 +43751,9 @@ size_t gc_heap::generation_size (int gen_number)
     return result;
 #else //USE_REGIONS
     if (0 == gen_number)
-        return max((heap_segment_allocated (ephemeral_heap_segment) -
+        return (size_t)max((heap_segment_allocated (ephemeral_heap_segment) -
                     generation_allocation_start (generation_of (gen_number))),
-                   (int)Align (min_obj_size));
+                   (ptrdiff_t)Align (min_obj_size));
     else
     {
         generation* gen = generation_of (gen_number);
@@ -43835,7 +43835,7 @@ size_t gc_heap::trim_youngest_desired (uint32_t memory_load,
     }
     else
     {
-        size_t total_max_allocation = max (mem_one_percent, total_min_allocation);
+        size_t total_max_allocation = max ((size_t)mem_one_percent, total_min_allocation);
         return min (total_new_allocation, total_max_allocation);
     }
 }
@@ -44170,7 +44170,7 @@ void gc_heap::decommit_ephemeral_segment_pages()
     dynamic_data* dd0 = dynamic_data_of (0);
 
     ptrdiff_t desired_allocation = dd_new_allocation (dd0) +
-                                   max (estimate_gen_growth (soh_gen1), 0) +
+                                   max (estimate_gen_growth (soh_gen1), (ptrdiff_t)0) +
                                    loh_size_threshold;
 
     size_t slack_space =
@@ -44219,7 +44219,7 @@ void gc_heap::decommit_ephemeral_segment_pages()
 
     // we do a max of DECOMMIT_SIZE_PER_MILLISECOND per millisecond of elapsed time since the last GC
     // we limit the elapsed time to 10 seconds to avoid spending too much time decommitting
-    ptrdiff_t max_decommit_size = min (ephemeral_elapsed, (10*1000)) * DECOMMIT_SIZE_PER_MILLISECOND;
+    ptrdiff_t max_decommit_size = min (ephemeral_elapsed, (size_t)(10*1000)) * DECOMMIT_SIZE_PER_MILLISECOND;
     decommit_size = min (decommit_size, max_decommit_size);
 
     slack_space = heap_segment_committed (ephemeral_heap_segment) - heap_segment_allocated (ephemeral_heap_segment) - decommit_size;
@@ -47199,7 +47199,7 @@ enable_no_gc_region_callback_status gc_heap::enable_no_gc_callback(NoGCRegionCal
                 soh_withheld_budget = soh_withheld_budget / gc_heap::n_heaps;
                 loh_withheld_budget = loh_withheld_budget / gc_heap::n_heaps;
 #endif
-                soh_withheld_budget = max(soh_withheld_budget, 1);
+                soh_withheld_budget = max(soh_withheld_budget, (size_t)1);
                 soh_withheld_budget = Align(soh_withheld_budget, get_alignment_constant (TRUE));
                 loh_withheld_budget = Align(loh_withheld_budget, get_alignment_constant (FALSE));
 #ifdef MULTIPLE_HEAPS
@@ -47614,7 +47614,7 @@ void gc_heap::verify_regions (int gen_number, bool can_verify_gen_num, bool can_
         }
         if (can_verify_gen_num)
         {
-            if (heap_segment_gen_num (seg_in_gen) != min (gen_number, max_generation))
+            if (heap_segment_gen_num (seg_in_gen) != min (gen_number, (int)max_generation))
             {
                 dprintf (REGIONS_LOG, ("h%d gen%d region %p(%p) gen is %d!",
                     heap_number, gen_number, seg_in_gen, heap_segment_mem (seg_in_gen),
@@ -48464,7 +48464,7 @@ HRESULT GCHeap::Initialize()
 
     nhp = ((nhp_from_config == 0) ? g_num_active_processors : nhp_from_config);
 
-    nhp = min (nhp, MAX_SUPPORTED_CPUS);
+    nhp = min (nhp, (uint32_t)MAX_SUPPORTED_CPUS);
 
     gc_heap::gc_thread_no_affinitize_p = (gc_heap::heap_hard_limit ?
         !affinity_config_specified_p : (GCConfig::GetNoAffinitize() != 0));
@@ -48613,7 +48613,7 @@ HRESULT GCHeap::Initialize()
     /*
      * Allocation requests less than loh_size_threshold will be allocated on the small object heap.
      *
-     * An object cannot span more than one region and regions in small object heap are of the same size - gc_region_size. 
+     * An object cannot span more than one region and regions in small object heap are of the same size - gc_region_size.
      * However, the space available for actual allocations is reduced by the following implementation details -
      *
      * 1.) heap_segment_mem is set to the new pages + sizeof(aligned_plug_and_gap) in make_heap_segment.
@@ -48629,7 +48629,7 @@ HRESULT GCHeap::Initialize()
 #ifdef FEATURE_STRUCTALIGN
     /*
      * The above assumed FEATURE_STRUCTALIGN is not turned on for platforms where USE_REGIONS is supported, otherwise it is possible
-     * that the allocation size is inflated by ComputeMaxStructAlignPad in GCHeap::Alloc and we have to compute an upper bound of that 
+     * that the allocation size is inflated by ComputeMaxStructAlignPad in GCHeap::Alloc and we have to compute an upper bound of that
      * function.
      *
      * Note that ComputeMaxStructAlignPad is defined to be 0 if FEATURE_STRUCTALIGN is turned off.
@@ -48838,7 +48838,7 @@ HRESULT GCHeap::Initialize()
             gc_heap::dynamic_heap_count_data.inc_recheck_threshold = 5;
             gc_heap::dynamic_heap_count_data.dec_failure_recheck_threshold = 5;
             // This should really be set as part of computing static data and should take conserve_mem_setting into consideration.
-            gc_heap::dynamic_heap_count_data.max_gen0_new_allocation = min (dd_max_size (gc_heap::g_heaps[0]->dynamic_data_of (0)), (64 * 1024 * 1024));
+            gc_heap::dynamic_heap_count_data.max_gen0_new_allocation = min (dd_max_size (gc_heap::g_heaps[0]->dynamic_data_of (0)), (size_t)(64 * 1024 * 1024));
             gc_heap::dynamic_heap_count_data.min_gen0_new_allocation = dd_min_size (gc_heap::g_heaps[0]->dynamic_data_of (0));
 
             dprintf (6666, ("datas max gen0 budget %Id, min %Id",
@@ -49809,7 +49809,7 @@ GCHeap::GarbageCollect (int generation, bool low_memory_p, int mode)
     gc_heap* hpt = 0;
 #endif //MULTIPLE_HEAPS
 
-    generation = (generation < 0) ? max_generation : min (generation, max_generation);
+    generation = (generation < 0) ? max_generation : min (generation, (int)max_generation);
     dynamic_data* dd = hpt->dynamic_data_of (generation);
 
 #ifdef BACKGROUND_GC
@@ -49907,7 +49907,7 @@ size_t
 GCHeap::GarbageCollectTry (int generation, BOOL low_memory_p, int mode)
 {
     int gen = (generation < 0) ?
-               max_generation : min (generation, max_generation);
+               max_generation : min (generation, (int)max_generation);
 
     gc_reason reason = reason_empty;
 
@@ -51262,11 +51262,11 @@ size_t gc_heap::get_gen0_min_size()
 #ifdef SERVER_GC
         // performance data seems to indicate halving the size results
         // in optimal perf.  Ask for adjusted gen0 size.
-        gen0size = max(GCToOSInterface::GetCacheSizePerLogicalCpu(FALSE),(256*1024));
+        gen0size = max(GCToOSInterface::GetCacheSizePerLogicalCpu(FALSE), (size_t)(256*1024));
 
         // if gen0 size is too large given the available memory, reduce it.
         // Get true cache size, as we don't want to reduce below this.
-        size_t trueSize = max(GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE),(256*1024));
+        size_t trueSize = max(GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE), (size_t)(256*1024));
         dprintf (1, ("cache: %zd-%zd",
             GCToOSInterface::GetCacheSizePerLogicalCpu(FALSE),
             GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE)));
@@ -51274,8 +51274,8 @@ size_t gc_heap::get_gen0_min_size()
         int n_heaps = gc_heap::n_heaps;
 #else //SERVER_GC
         size_t trueSize = GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE);
-        gen0size = max((4*trueSize/5),(256*1024));
+        gen0size = max((4*trueSize/5),(size_t)(256*1024));
-        trueSize = max(trueSize, (256*1024));
+        trueSize = max(trueSize, (size_t)(256*1024));
         int n_heaps = 1;
 #endif //SERVER_GC
 
@@ -51283,7 +51283,7 @@ size_t gc_heap::get_gen0_min_size()
         if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes)
         {
             // if we are asked to be stingy with memory, limit gen 0 size
-            gen0size = min (gen0size, (4*1024*1024));
+            gen0size = min (gen0size, (size_t)(4*1024*1024));
         }
 #endif //DYNAMIC_HEAP_COUNT
 
@@ -51904,7 +51904,7 @@ CFinalize::UpdatePromotedGenerations (int gen, BOOL gen_0_empty_p)
     // it was promoted or not
     if (gen_0_empty_p)
     {
-        for (int i = min (gen+1, max_generation); i > 0; i--)
+        for (int i = min (gen+1, (int)max_generation); i > 0; i--)
         {
             m_FillPointers [gen_segment(i)] = m_FillPointers [gen_segment(i-1)];
         }
@@ -52807,7 +52807,7 @@ bool gc_heap::compute_memory_settings(bool is_initialization, uint32_t& nhp, uin
             if (is_initialization)
 #endif //USE_REGIONS
             {
-                heap_hard_limit = (size_t)max ((20 * 1024 * 1024), physical_mem_for_gc);
+                heap_hard_limit = (size_t)max ((uint64_t)(20 * 1024 * 1024), physical_mem_for_gc);
             }
         }
     }
@@ -52855,8 +52855,8 @@ bool gc_heap::compute_memory_settings(bool is_initialization, uint32_t& nhp, uin
     uint32_t highmem_th_from_config = (uint32_t)GCConfig::GetGCHighMemPercent();
     if (highmem_th_from_config)
     {
-        high_memory_load_th = min (99, highmem_th_from_config);
+        high_memory_load_th = min (99u, highmem_th_from_config);
-        v_high_memory_load_th = min (99, (highmem_th_from_config + 7));
+        v_high_memory_load_th = min (99u, (highmem_th_from_config + 7));
 #ifdef FEATURE_EVENT_TRACE
         high_mem_percent_from_config = highmem_th_from_config;
 #endif //FEATURE_EVENT_TRACE

src/coreclr/gc/gcpriv.h

@@ -3345,8 +3345,8 @@ private:
         size_t new_current_total_committed);
 
 #ifdef USE_REGIONS
-    PER_HEAP_ISOLATED_METHOD void compute_committed_bytes(size_t& total_committed, size_t& committed_decommit, size_t& committed_free, 
+    PER_HEAP_ISOLATED_METHOD void compute_committed_bytes(size_t& total_committed, size_t& committed_decommit, size_t& committed_free,
-                                  size_t& committed_bookkeeping, size_t& new_current_total_committed, size_t& new_current_total_committed_bookkeeping, 
+                                  size_t& committed_bookkeeping, size_t& new_current_total_committed, size_t& new_current_total_committed_bookkeeping,
                                   size_t* new_committed_by_oh);
 #endif
 
@@ -4226,7 +4226,7 @@ private:
 
 #ifdef DYNAMIC_HEAP_COUNT
     // Sample collection -
-    // 
+    //
     // For every GC, we collect the msl wait time + GC pause duration info and use both to calculate the
     // throughput cost percentage. We will also be using the wait time and the GC pause duration separately
     // for other purposes in the future.
@@ -6019,3 +6019,6 @@ public:
 #else
 #define THIS_ARG
 #endif // FEATURE_CARD_MARKING_STEALING
+
+using std::min;
+using std::max;

src/coreclr/gc/sample/CMakeLists.txt

@@ -53,6 +53,7 @@ if(CLR_CMAKE_TARGET_WIN32)
     list(APPEND SOURCES
         ../windows/gcenv.windows.cpp)
     add_definitions(-DUNICODE)
+    add_compile_definitions(NOMINMAX)
 else()
     list(APPEND SOURCES
         ../gcenv.unix.cpp)

src/coreclr/gc/sample/GCSample.cpp

@@ -176,7 +176,7 @@ int __cdecl main(int argc, char* argv[])
     // GC expects the size of ObjHeader (extra void*) to be included in the size.
     baseSize = baseSize + sizeof(ObjHeader);
     // Add padding as necessary. GC requires the object size to be at least MIN_OBJECT_SIZE.
-    My_MethodTable.m_MT.m_baseSize = max(baseSize, MIN_OBJECT_SIZE);
+    My_MethodTable.m_MT.m_baseSize = max(baseSize, (uint32_t)MIN_OBJECT_SIZE);
 
     My_MethodTable.m_MT.m_componentSize = 0;    // Array component size
     My_MethodTable.m_MT.m_flags = MTFlag_ContainsPointers;

src/coreclr/gc/sample/GCSample.vcxproj

@@ -51,7 +51,7 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;HOST_X86;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;HOST_X86;NOMINMAX;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <PrecompiledHeaderFile>common.h</PrecompiledHeaderFile>
       <AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories>
@@ -68,7 +68,7 @@
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>WIN32;HOST_X86;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;HOST_X86;NOMINMAX;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
       <AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories>
     </ClCompile>
@@ -109,4 +109,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

src/coreclr/gc/vxsort/defs.h

@@ -45,16 +45,6 @@
 #define NOINLINE __attribute__((noinline))
 #endif
 
-#include <limits>
+using std::max;
-
+using std::min;
-#ifndef max
-template <typename T>
-T max(T a, T b) {
-    if (a > b)
-        return a;
-    else
-        return b;
-}
-#endif
-
 #endif  // VXSORT_DEFS_H

src/coreclr/gc/windows/gcenv.windows.cpp

@@ -290,8 +290,8 @@ static size_t GetRestrictedPhysicalMemoryLimit()
                 (job_process_memory_limit != (size_t)UINTPTR_MAX) ||
                 (job_workingset_limit != (size_t)UINTPTR_MAX))
             {
-                job_physical_memory_limit = min (job_memory_limit, job_process_memory_limit);
+                job_physical_memory_limit = std::min (job_memory_limit, job_process_memory_limit);
-                job_physical_memory_limit = min (job_physical_memory_limit, job_workingset_limit);
+                job_physical_memory_limit = std::min (job_physical_memory_limit, job_workingset_limit);
 
                 MEMORYSTATUSEX ms;
                 ::GetProcessMemoryLoad(&ms);
@@ -299,7 +299,7 @@ static size_t GetRestrictedPhysicalMemoryLimit()
                 total_physical = ms.ullAvailPhys;
 
                 // A sanity check in case someone set a larger limit than there is actual physical memory.
-                job_physical_memory_limit = (size_t) min (job_physical_memory_limit, ms.ullTotalPhys);
+                job_physical_memory_limit = (size_t) std::min (job_physical_memory_limit, (size_t)ms.ullTotalPhys);
             }
         }
     }
@@ -1139,7 +1139,7 @@ bool GCToOSInterface::GetNumaInfo(uint16_t* total_nodes, uint32_t* max_procs_per
                     mask &= mask - 1;
                 }
 
-                currentProcsOnNode = max(currentProcsOnNode, procsOnNode);
+                currentProcsOnNode = std::max(currentProcsOnNode, procsOnNode);
             }
             *max_procs_per_node = currentProcsOnNode;
             *total_nodes = (uint16_t)g_nNodes;
@@ -1163,7 +1163,7 @@ bool GCToOSInterface::GetCPUGroupInfo(uint16_t* total_groups, uint32_t* max_proc
         DWORD currentProcsInGroup = 0;
         for (WORD i = 0; i < g_nGroups; i++)
         {
-            currentProcsInGroup = max(currentProcsInGroup, g_CPUGroupInfoArray[i].nr_active);
+            currentProcsInGroup = std::max(currentProcsInGroup, (DWORD)g_CPUGroupInfoArray[i].nr_active);
         }
         *max_procs_per_group = currentProcsInGroup;
         return true;

src/coreclr/hosts/coreshim/CoreShim.h

@@ -5,7 +5,6 @@
 #define _CORESHIM_H_
 
 // Platform
-#define NOMINMAX
 #include <Windows.h>
 #include <combaseapi.h>
 

src/coreclr/ildasm/dasm.cpp

@@ -1914,7 +1914,7 @@ BYTE* PrettyPrintCABlobValue(PCCOR_SIGNATURE &typePtr,
                 for(n=0; n < numElements; n++)
                 {
                     if(n) appendStr(out," ");
-                    _gcvt_s(str,64,*((float*)dataPtr), 8);
+                    sprintf_s(str, 64, "%.*g", 8, (double)(*((float*)dataPtr)));
                     float df = (float)atof(str);
                     // Must compare as underlying bytes, not floating point otherwise optimizer will
                     // try to enregister and compare 80-bit precision number with 32-bit precision number!!!!
@@ -1933,7 +1933,7 @@ BYTE* PrettyPrintCABlobValue(PCCOR_SIGNATURE &typePtr,
                 {
                     if(n) appendStr(out," ");
                     char *pch;
-                    _gcvt_s(str,64,*((double*)dataPtr), 17);
+                    sprintf_s(str, 64, "%.*g", 17, *((double*)dataPtr));
                     double df = strtod(str, &pch);
                     // Must compare as underlying bytes, not floating point otherwise optimizer will
                     // try to enregister and compare 80-bit precision number with 64-bit precision number!!!!
@@ -2605,7 +2605,7 @@ void DumpDefaultValue(mdToken tok, __inout __nullterminated char* szString, void
         case ELEMENT_TYPE_R4:
             {
                 char szf[32];
-                _gcvt_s(szf,32,MDDV.m_fltValue, 8);
+                sprintf_s(szf, 32, "%.*g", 8, (double)MDDV.m_fltValue);
                 float df = (float)atof(szf);
                 // Must compare as underlying bytes, not floating point otherwise optimizer will
                 // try to enregister and compare 80-bit precision number with 32-bit precision number!!!!
@@ -2619,7 +2619,7 @@ void DumpDefaultValue(mdToken tok, __inout __nullterminated char* szString, void
         case ELEMENT_TYPE_R8:
             {
                 char szf[32], *pch;
-                _gcvt_s(szf,32,MDDV.m_dblValue, 17);
+                sprintf_s(szf, 32, "%.*g", 17, MDDV.m_dblValue);
                 double df = strtod(szf, &pch); //atof(szf);
                 szf[31]=0;
                 // Must compare as underlying bytes, not floating point otherwise optimizer will

src/coreclr/ildasm/dis.cpp

@@ -1573,7 +1573,7 @@ BOOL Disassemble(IMDInternalImport *pImport, BYTE *ILHeader, void *GUICookie, md
                 if(f==0.0)
                     strcpy_s(szf,32,((v>>24)==0)? "0.0" : "-0.0");
                 else
-                    _gcvt_s(szf,32,(double)f, 8);
+                    sprintf_s(szf, 32, "%.*g", 8, (double)f);
                 float fd = (float)atof(szf);
                 // Must compare as underlying bytes, not floating point otherwise optimizer will
                 // try to enregister and compare 80-bit precision number with 32-bit precision number!!!!
@@ -1612,7 +1612,7 @@ BOOL Disassemble(IMDInternalImport *pImport, BYTE *ILHeader, void *GUICookie, md
                 if(d==0.0)
                     strcpy_s(szf,32,((v>>56)==0)? "0.0" : "-0.0");
                 else
-                    _gcvt_s(szf,32,d, 17);
+                    sprintf_s(szf, 32, "%.*g", 17, d);
                 double df = strtod(szf, &pch); //atof(szf);
                 // Must compare as underlying bytes, not floating point otherwise optimizer will
                 // try to enregister and compare 80-bit precision number with 64-bit precision number!!!!

src/coreclr/ildasm/ildasmpch.h

@@ -12,6 +12,10 @@
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
+#include <algorithm>
+
+using std::min;
+using std::max;
 
 #ifndef Debug_ReportError
 #define Debug_ReportError(strMessage)

src/coreclr/inc/allocacheck.h

@@ -23,7 +23,16 @@
 
 #ifndef AllocaCheck_h
 #define AllocaCheck_h
-#include <malloc.h>			// for alloca itself
+
+#if defined(HOST_WINDOWS)
+#include <malloc.h> // for alloca itself
+#else
+#if defined(__has_include)
+#if __has_include(<alloca.h>)
+#include <alloca.h>
+#endif // __has_include(alloca.h)
+#endif // defined(__has_include)
+#endif // defined(HOST_WINDOWS)
 
 #if defined(assert) && !defined(_ASSERTE)
 #define _ASSERTE assert

src/coreclr/inc/check.h

@@ -111,7 +111,7 @@ public: // !!! NOTE: Called from macros only!!!
 #ifdef _DEBUG
               , m_condition (NULL)
               , m_file(NULL)
-              , m_line(NULL)
+              , m_line(0)
               , m_pCount(NULL)
 #endif
     {}

src/coreclr/inc/clr_std/algorithm

@@ -1,118 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// clr_std/algorithm
-//
-// Copy of some key Standard Template Library functionality
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#ifdef USE_STL
-#include <algorithm>
-#else
-#ifndef __clr_std_algorithm_h__
-#define __clr_std_algorithm_h__
-
-namespace std
-{
-    template<class iter, class CompareFunc>
-    iter find_if ( iter first, iter last, CompareFunc comp )
-    {
-        for ( ; first!=last ; first++ )
-            if ( comp(*first) )
-                break;
-        return first;
-    }
-
-    template<class iter, class T>
-    iter find(iter first, iter last, const T& val)
-    {
-        for (;first != last; first++)
-        {
-            if (*first == val)
-                break;
-        }
-        return first;
-    }
-
-    template <class iter, class comp>
-    iter qsort_partition( iter first, iter last, iter pivot, comp compare )
-    {
-        iter lastMinusOne = last - 1;
-        swap(pivot, lastMinusOne);
-
-        // Pivot is at end
-        pivot = last - 1;
-
-        iter partitionLoc = first;
-
-        for (iter partitionWalk = first; partitionWalk != pivot; ++partitionWalk)
-        {
-            if (compare(*partitionWalk, *pivot))
-            {
-                swap(*partitionWalk, *partitionLoc);
-                partitionLoc++;
-            }
-        }
-        swap(*pivot, *partitionLoc);
-
-        return partitionLoc;
-    }
-
-    template <class iter, class comp>
-    void sort_worker ( iter first, iter last, comp compare )
-    {
-        typename iter::difference_type RangeSize = last - first;
-
-        // When down to a list of size 1, be done
-        if (RangeSize < 2)
-            return;
-
-        // Pick pivot
-
-        // Use simple pick middle algorithm
-        iter pivotLoc = first + (RangeSize / 2);
-
-        // Partition
-        pivotLoc = qsort_partition(first, last, pivotLoc, compare);
-
-        // Sort first array
-        sort_worker(first, pivotLoc, compare);
-
-        // Sort second array
-        sort_worker(pivotLoc + 1, last, compare);
-    }
-
-    template <class iter, class comp>
-    void sort ( iter first, iter last, comp compare )
-    {
-        sort_worker(first, last, compare);
-        if (first != last)
-        {
-            for (iter i = first; i < (last - 1); i++)
-            {
-                // Assert that the sort function works.
-                assert(!compare(*(i+1), *i));
-            }
-        }
-    }
-
-    template<class InIter, class OutIter, class Fn1>
-    OutIter transform( InIter first, InIter last, OutIter dest, Fn1 func )
-    {
-        for ( ; first!=last ; ++first, ++dest )
-            *dest = func(*first);
-        return dest;
-    }
-
-} // namespace std
-
-#endif /* __clr_std_algorithm_h__ */
-
-#endif // !USE_STL
-
-// Help the VIM editor figure out what kind of file this no-extension file is.
-// vim: filetype=cpp

src/coreclr/inc/clr_std/string

@@ -1,425 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// clr_std/string
-//
-// Copy of some key Standard Template Library functionality
-//
-// This was created for use with SuperPMI. It has the minimal functionality needed by SuperPMI. It hasn't
-// been tested elsewhere.
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#ifdef USE_STL
-#include <string>
-#else
-#ifndef __clr_std_string_h__
-#define __clr_std_string_h__
-
-#include "clr_std/vector"
-
-namespace std
-{
-
-template<class T>
-class basic_string
-{
-public:
-    typedef T value_type;
-    typedef size_t size_type;
-    typedef typename vector<T>::iterator iterator;
-    typedef typename vector<T>::const_iterator const_iterator;
-
-    basic_string()
-        : m_string(1) // start with a string of length 1 for null terminator
-    {
-        m_string[0] = T();
-    }
-
-    basic_string(const basic_string<T>& _Right)
-    {
-        assign(_Right);
-    }
-
-    // Initialize a string with _Count characters from the string pointed at by _Ptr.
-    // If you want to include the trailing null character, _Count needs to include that.
-    basic_string(const value_type* _Ptr, size_type _Count)
-        : m_string(_Count + 1) // add 1 for a null terminator
-    {
-        copy(_Ptr, _Count);
-    }
-
-    basic_string(const value_type* _Ptr) : basic_string(_Ptr, c_len(_Ptr))
-    {
-    }
-
-    void reserve(size_t newcapacity)
-    {
-        m_string.reserve(newcapacity + 1); // add 1 for the null terminator
-    }
-
-    //
-    // Assignment
-    //
-
-    basic_string<T>& operator=(const basic_string<T>& _Right)
-    {
-        if (this != &_Right)
-        {
-            assign(_Right);
-        }
-        return (*this);
-    }
-
-    basic_string<T>& assign(const basic_string<T>& _Right)
-    {
-        m_string.resize(_Right.size() + 1); // +1 for null terminator
-        copy(_Right);
-        return (*this);
-    }
-
-    //
-    // Basic data copying
-    //
-
-    void copy(const basic_string<T>& _Right)
-    {
-        assert(size() >= _Right.size());
-        size_type i;
-        for (i = 0; i < _Right.size(); i++)
-        {
-            m_string[i] = _Right.m_string[i];
-        }
-        m_string[i] = T();
-    }
-
-    void copy(const value_type* _Ptr, size_type _Count)
-    {
-        assert(size() >= _Count);
-        size_type i;
-        for (i = 0; i < _Count; i++)
-        {
-            m_string[i] = _Ptr[i];
-        }
-        m_string[i] = T();
-    }
-
-    //
-    // Appending
-    //
-
-    // Append a C-style string to the string.
-    basic_string<T>& operator+=(const value_type* _Ptr)
-    {
-        size_type oldsize = size();         // doesn't include null terminator
-        size_type addsize = c_len(_Ptr);    // doesn't include null terminator
-        size_type newsize = oldsize + addsize + 1;
-        m_string.resize(newsize);
-        size_type i;
-        for (i = oldsize; i < newsize - 1; i++)
-        {
-            m_string[i] = *_Ptr++;
-        }
-        m_string[i] = T();
-        return (*this);
-    }
-
-    basic_string<T>& operator+=(const basic_string<T>& _Right)
-    {
-        size_type oldsize = size();         // doesn't include null terminator
-        size_type addsize = _Right.size();  // doesn't include null terminator
-        size_type newsize = oldsize + addsize + 1;
-        m_string.resize(newsize);
-        size_type new_index = oldsize, right_index = 0;
-        while (right_index < addsize)
-        {
-            m_string[new_index] = _Right.m_string[right_index];
-            ++new_index;
-            ++right_index;
-        }
-        m_string[new_index] = T();
-        return (*this);
-    }
-
-    basic_string<T>& operator+=(value_type _Ch)
-    {
-        size_type oldsize = size();         // doesn't include null terminator
-        m_string[oldsize] = _Ch; // Replace the null terminator with the new symbol.
-        m_string.push_back(T()); // Return the replaced terminator again.
-        return (*this);
-    }
-
-    ~basic_string()
-    {
-        // vector destructor does all the work
-    }
-
-    size_t size() const
-    {
-        assert(m_string.size() > 0);
-        return m_string.size() - 1;      // Don't report the null terminator.
-    }
-
-    size_t length() const
-    {
-        return size();
-    }
-
-    T& operator[](size_t iIndex)
-    {
-        assert(iIndex < size() + 1);    // allow looking at the null terminator
-        return m_string[iIndex];
-    }
-
-    const T* c_str() const
-    {
-        return m_string.data();
-    }
-
-    iterator begin()
-    {
-        return m_string.begin();
-    }
-
-    iterator end()
-    {
-        return m_string.end();
-    }
-
-    const_iterator cbegin() const
-    {
-        return m_string.cbegin();
-    }
-
-    const_iterator cend() const
-    {
-        return m_string.cend();
-    }
-
-    basic_string<T> substr(size_type _Off = 0, size_type _Count = npos) const
-    {
-        size_type cursize = size();
-        if (_Off >= cursize)
-        {
-            // result will be empty
-            return basic_string<T>();
-        }
-        else
-        {
-            if ((_Count == npos) ||     // No count specified; take the whole string suffix
-                (_Off + _Count > cursize)) // Count specified is too many characters; just take the whole suffix
-            {
-                _Count = cursize - _Off;
-            }
-            return basic_string<T>(m_string.data() + _Off, _Count);
-        }
-    }
-
-    size_type find_last_of(value_type _Ch) const
-    {
-        for (size_type _Off = size(); _Off != 0; _Off--)
-        {
-            if (m_string[_Off - 1] == _Ch)
-            {
-                return _Off - 1;
-            }
-        }
-        return npos;
-    }
-
-    bool empty() const
-    {
-        return size() == 0;
-    }
-
-    int compare(const basic_string<T>& _Str) const
-    {
-        size_type i;
-        size_type compareSize = size();
-        if (_Str.size() < compareSize)
-        {
-            // This string is longer; compare character-by-character only as many characters as we have.
-            compareSize = _Str.size();
-        }
-        for (i = 0; i < compareSize; i++)
-        {
-            if (m_string[i] != _Str.m_string[i])
-            {
-                if (m_string[i] < _Str.m_string[i])
-                {
-                    return -1;
-                }
-                else
-                {
-                    return 1;
-                }
-            }
-        }
-
-        // All the characters we compared were identical, but one string might be longer than the other.
-        if (size() == _Str.size())
-        {
-            // We compared everything.
-            return 0;
-        }
-        else if (size() < _Str.size())
-        {
-            // _Str has more characters than this.
-            return -1;
-        }
-        else
-        {
-            // this has more characters than _Str
-            return 1;
-        }
-    }
-
-    static const size_type npos = size_type(-1);
-
-private:
-
-    // Compute the length in characters of a null-terminated C-style string, not including the trailing null character.
-    // _Ptr must not be nullptr.
-    size_type c_len(const value_type* _Ptr)
-    {
-        size_type count;
-        for (count = 0; *_Ptr != T(); _Ptr++)
-        {
-            count++;
-        }
-        return count;
-    }
-
-    vector<T>   m_string;   // use a vector<> to represent the string, to avoid reimplementing similar functionality
-
-}; // class basic_string
-
-//
-// String class instantiations
-//
-
-typedef basic_string<char> string;
-
-//
-// Numeric conversions
-//
-
-// convert integer T to string
-template<class T> inline
-string _IntToString(const char *_Fmt, T _Val)
-{
-    const size_t MaxIntBufSize = 21; /* can hold -2^63 and 2^64 - 1, plus NUL */
-	char buf[MaxIntBufSize];
-	int len = sprintf_s(buf, MaxIntBufSize, _Fmt, _Val);
-	return (string(buf, len));
-}
-
-inline string to_string(int _Val)
-{
-	return (_IntToString("%d", _Val));
-}
-
-inline string to_string(unsigned int _Val)
-{
-	return (_IntToString("%u", _Val));
-}
-
-inline string to_string(long _Val)
-{
-	return (_IntToString("%ld", _Val));
-}
-
-inline string to_string(unsigned long _Val)
-{
-	return (_IntToString("%lu", _Val));
-}
-
-inline string to_string(long long _Val)
-{
-	return (_IntToString("%lld", _Val));
-}
-
-inline string to_string(unsigned long long _Val)
-{
-	return (_IntToString("%llu", _Val));
-}
-
-//
-// Comparisons
-//
-
-template<class T> inline
-bool operator==(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (_Left.compare(_Right) == 0);
-}
-
-template<class T> inline
-bool operator!=(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (!(_Left == _Right));
-}
-
-template<class T> inline
-bool operator<(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (_Left.compare(_Right) < 0);
-}
-
-template<class T> inline
-bool operator>(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (_Right < _Left);
-}
-
-template<class T> inline
-bool operator<=(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (!(_Right < _Left));
-}
-
-template<class T> inline
-bool operator>=(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    return (!(_Left < _Right));
-}
-
-//
-// String concatenation and other string operations
-//
-
-template<class T> inline
-basic_string<T> operator+(
-    const basic_string<T>& _Left,
-    const basic_string<T>& _Right)
-{
-    basic_string<T> ret;
-    ret.reserve(_Left.size() + _Right.size());
-    ret += _Left;
-    ret += _Right;
-    return ret;
-}
-
-}; // namespace std
-
-#endif /* __clr_std_string_h__ */
-
-#endif // !USE_STL
-
-// Help the VIM editor figure out what kind of file this no-extension file is.
-// vim: filetype=cpp

src/coreclr/inc/clr_std/type_traits

@@ -1,627 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// clr_std/utility
-//
-// Copy of some key Standard Template Library functionality.
-// See http://msdn.microsoft.com/en-us/library/bb982077.aspx for documentation.
-//
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#ifndef __clr_std_type_traits_h__
-#define __clr_std_type_traits_h__
-
-#ifdef USE_STL
-
-#include <type_traits>
-
-#else
-
-namespace std
-{
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS remove_const
-    template<class _Ty>
-    struct remove_const
-    {   // remove top level const qualifier
-        typedef _Ty type;
-    };
-
-    template<class _Ty>
-    struct remove_const<const _Ty>
-    {   // remove top level const qualifier
-        typedef _Ty type;
-    };
-
-    template<class _Ty>
-    struct remove_const<const _Ty[]>
-    {   // remove top level const qualifier
-        typedef _Ty type[];
-    };
-
-    template<class _Ty, unsigned int _Nx>
-    struct remove_const<const _Ty[_Nx]>
-    {   // remove top level const qualifier
-        typedef _Ty type[_Nx];
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS remove_volatile
-    template<class _Ty>
-    struct remove_volatile
-    {   // remove top level volatile qualifier
-        typedef _Ty type;
-    };
-
-    template<class _Ty>
-    struct remove_volatile<volatile _Ty>
-    {   // remove top level volatile qualifier
-        typedef _Ty type;
-    };
-
-    template<class _Ty>
-    struct remove_volatile<volatile _Ty[]>
-    {   // remove top level volatile qualifier
-        typedef _Ty type[];
-    };
-
-    template<class _Ty, unsigned int _Nx>
-    struct remove_volatile<volatile _Ty[_Nx]>
-    {   // remove top level volatile qualifier
-        typedef _Ty type[_Nx];
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS remove_cv
-    template<class _Ty>
-    struct remove_cv
-    {   // remove top level const and volatile qualifiers
-        typedef typename remove_const<typename remove_volatile<_Ty>::type>::type type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE remove_reference
-    template<class T>
-    struct remove_reference
-    {   // remove reference
-        typedef T type;
-    };
-
-    template<class T>
-    struct remove_reference<T&>
-    {   // remove reference
-        typedef T type;
-    };
-
-    template<class T>
-    struct remove_reference<T&&>
-    {   // remove rvalue reference
-        typedef T type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE remove_pointer
-    template<class T>
-    struct remove_pointer
-    {   // remove pointer
-        typedef T type;
-    };
-
-    template<class T>
-    struct remove_pointer<T*>
-    {   // remove pointer
-        typedef T type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE FUNCTION identity
-    template<class T>
-    struct identity
-    {   // map T to type unchanged
-        typedef T type;
-
-        inline
-        const T& operator()(const T& left) const
-        {   // apply identity operator to operand
-            return (left);
-        }
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS integral_constant
-    template<class _Ty, _Ty _Val>
-    struct integral_constant
-    {   // convenient template for integral constant types
-        static const _Ty value = _Val;
-
-        typedef _Ty value_type;
-        typedef integral_constant<_Ty, _Val> type;
-    };
-
-    typedef integral_constant<bool, true> true_type;
-    typedef integral_constant<bool, false> false_type;
-
-    // TEMPLATE CLASS _Cat_base
-    template<bool>
-    struct _Cat_base
-        : false_type
-    {    // base class for type predicates
-    };
-
-    template<>
-    struct _Cat_base<true>
-        : true_type
-    {    // base class for type predicates
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS enable_if
-    template<bool _Test, class _Type = void>
-    struct enable_if
-    {   // type is undefined for assumed !_Test
-    };
-
-    template<class _Type>
-    struct enable_if<true, _Type>
-    {   // type is _Type for _Test
-        typedef _Type type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS conditional
-    template<bool _Test, class _Ty1, class _Ty2>
-    struct conditional
-    {   // type is _Ty2 for assumed !_Test
-        typedef _Ty2 type;
-    };
-
-    template<class _Ty1, class _Ty2>
-    struct conditional<true, _Ty1, _Ty2>
-    {   // type is _Ty1 for _Test
-        typedef _Ty1 type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS make_unsigned
-    template<typename Type1>
-    struct make_unsigned
-    {
-    };
-
-    template<>
-    struct make_unsigned<int>
-    {
-        typedef unsigned int type;
-    };
-
-#ifndef HOST_UNIX
-
-    template<>
-    struct make_unsigned<long>
-    {
-        typedef unsigned long type;
-    };
-
-#endif // !HOST_UNIX
-
-    template<>
-    struct make_unsigned<__int64>
-    {
-        typedef unsigned __int64 type;
-    };
-
-    template<>
-    struct make_unsigned<size_t>
-    {
-        typedef size_t type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS make_signed
-    template<typename Type1>
-    struct make_signed
-    {
-    };
-
-    template<>
-    struct make_signed<unsigned int>
-    {
-        typedef signed int type;
-    };
-
-#ifndef HOST_UNIX
-
-    template<>
-    struct make_signed<unsigned long>
-    {
-        typedef signed long type;
-    };
-
-#endif // !HOST_UNIX
-
-    template<>
-    struct make_signed<unsigned __int64>
-    {
-        typedef signed __int64 type;
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_lvalue_reference
-    template<class _Ty>
-    struct is_lvalue_reference
-        : false_type
-    {   // determine whether _Ty is an lvalue reference
-    };
-
-    template<class _Ty>
-    struct is_lvalue_reference<_Ty&>
-        : true_type
-    {   // determine whether _Ty is an lvalue reference
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_rvalue_reference
-    template<class _Ty>
-    struct is_rvalue_reference
-        : false_type
-    {   // determine whether _Ty is an rvalue reference
-    };
-
-    template<class _Ty>
-    struct is_rvalue_reference<_Ty&&>
-        : true_type
-    {   // determine whether _Ty is an rvalue reference
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_reference
-    template<class _Ty>
-    struct is_reference
-        : conditional<
-            is_lvalue_reference<_Ty>::value || is_rvalue_reference<_Ty>::value,
-            true_type,
-            false_type>::type
-    {   // determine whether _Ty is a reference
-    };
-
-    // TEMPLATE CLASS is_pointer
-    template<class _Ty>
-    struct is_pointer
-        : false_type
-    {   // determine whether _Ty is a pointer
-    };
-
-    template<class _Ty>
-    struct is_pointer<_Ty *>
-        : true_type
-    {   // determine whether _Ty is a pointer
-    };
-
-    // TEMPLATE CLASS _Is_integral
-    template<class _Ty>
-    struct _Is_integral
-        : false_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<bool>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<char>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<unsigned char>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<signed char>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<unsigned short>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<signed short>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<unsigned int>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<signed int>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-// On Unix 'long' is a 64-bit type (same as __int64) and the following two definitions
-// conflict with _Is_integral<unsigned __int64> and _Is_integral<signed __int64>.
-#if !defined(HOST_UNIX) || defined(__APPLE__)
-    template<>
-    struct _Is_integral<unsigned long>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<signed long>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-#endif /* !HOST_UNIX || __APPLE__ */
-
- #if _HAS_CHAR16_T_LANGUAGE_SUPPORT
-    template<>
-    struct _Is_integral<char16_t>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<char32_t>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
- #endif /* _HAS_CHAR16_T_LANGUAGE_SUPPORT */
-
-    template<>
-    struct _Is_integral<unsigned __int64>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    template<>
-    struct _Is_integral<signed __int64>
-        : true_type
-    {    // determine whether _Ty is integral
-    };
-
-    // TEMPLATE CLASS is_integral
-    template<class _Ty>
-    struct is_integral
-        : _Is_integral<typename remove_cv<_Ty>::type>
-    {    // determine whether _Ty is integral
-    };
-
-    // TEMPLATE CLASS _Is_floating_point
-    template<class _Ty>
-    struct _Is_floating_point
-        : false_type
-    {    // determine whether _Ty is floating point
-    };
-
-    template<>
-    struct _Is_floating_point<float>
-        : true_type
-    {    // determine whether _Ty is floating point
-    };
-
-    template<>
-    struct _Is_floating_point<double>
-        : true_type
-    {    // determine whether _Ty is floating point
-    };
-
-// In PAL, we define long as int and so this becomes int double,
-// which is a nonsense
-#ifndef HOST_UNIX
-    template<>
-    struct _Is_floating_point<long double>
-        : true_type
-    {    // determine whether _Ty is floating point
-    };
-#endif
-
-    // TEMPLATE CLASS is_floating_point
-    template<class _Ty>
-    struct is_floating_point
-        : _Is_floating_point<typename remove_cv<_Ty>::type>
-    {    // determine whether _Ty is floating point
-    };
-
-    // TEMPLATE CLASS is_arithmetic
-    template<class _Ty>
-    struct is_arithmetic
-    : _Cat_base<is_integral<_Ty>::value
-        || is_floating_point<_Ty>::value>
-    {    // determine whether _Ty is an arithmetic type
-    };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_signed
-    template <typename T>
-    struct is_signed : conditional<
-        static_cast<typename remove_const<T>::type>(-1) < 0, true_type, false_type>::type {};
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_same
-    template<class T1, class T2>
-    struct is_same : false_type { };
-
-    //-----------------------------------------------------------------------------------------
-    template<class T1>
-    struct is_same<T1, T1> : true_type { };
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE CLASS is_base_of
-#ifdef _MSC_VER
-
-    template <typename TBase, typename TDerived>
-    struct is_base_of :
-        conditional<__is_base_of( TBase, TDerived), true_type, false_type>::type {};
-
-#else
-    namespace detail
-    {
-        //-------------------------------------------------------------------------------------
-        // Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big)
-        //
-
-        template <class T, class U>
-        struct conversion_helper
-        {
-            typedef char Small;
-            struct Big { char dummy[2]; };
-            static Big   Test(...);
-            static Small Test(U);
-            static T MakeT();
-        };
-
-        //-------------------------------------------------------------------------------------
-        // class template conversion
-        // Figures out the conversion relationships between two types
-        // Invocations (T and U are types):
-        // a) conversion<T, U>::exists
-        // returns (at compile time) true if there is an implicit conversion from T
-        // to U (example: Derived to Base)
-        // b) conversion<T, U>::exists2Way
-        // returns (at compile time) true if there are both conversions from T
-        // to U and from U to T (example: int to char and back)
-        // c) conversion<T, U>::sameType
-        // returns (at compile time) true if T and U represent the same type
-        //
-        // NOTE: might not work if T and U are in a private inheritance hierarchy.
-        //
-
-        template <class T, class U>
-        struct conversion
-        {
-            typedef detail::conversion_helper<T, U> H;
-            static const bool exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT())));
-            static const bool exists2Way = exists && conversion<U, T>::exists;
-            static const bool sameType = false;
-        };
-
-        template <class T>
-        struct conversion<T, T>
-        {
-            static const bool exists = true;
-            static const bool exists2Way = true;
-            static const bool sameType = true;
-        };
-
-        template <class T>
-        struct conversion<void, T>
-        {
-            static const bool exists = false;
-            static const bool exists2Way = false;
-            static const bool sameType = false;
-        };
-
-        template <class T>
-        struct conversion<T, void>
-        {
-            static const bool exists = false;
-            static const bool exists2Way = false;
-            static const bool sameType = false;
-        };
-
-        template <>
-        struct conversion<void, void>
-        {
-            static const bool exists = true;
-            static const bool exists2Way = true;
-            static const bool sameType = true;
-        };
-    } // detail
-
-    // Note that we need to compare pointer types here, since conversion of types by-value
-    // just tells us whether or not an implicit conversion constructor exists. We handle
-    // type parameters that are already pointers specially; see below.
-    template <typename TBase, typename TDerived>
-    struct is_base_of :
-        conditional<detail::conversion<TDerived *, TBase *>::exists, true_type, false_type>::type {};
-
-    // Specialization to handle type parameters that are already pointers.
-    template <typename TBase, typename TDerived>
-    struct is_base_of<TBase *, TDerived *> :
-        conditional<detail::conversion<TDerived *, TBase *>::exists, true_type, false_type>::type {};
-
-    // Specialization to handle invalid mixing of pointer types.
-    template <typename TBase, typename TDerived>
-    struct is_base_of<TBase *, TDerived> :
-        false_type {};
-
-    // Specialization to handle invalid mixing of pointer types.
-    template <typename TBase, typename TDerived>
-    struct is_base_of<TBase, TDerived *> :
-        false_type {};
-
-#endif
-
-    namespace detail
-    {
-        template <typename...>
-        using void_t = void;
-    }
-    // Always false dependent-value for static_asserts.
-    template <typename...>
-    struct _Always_false
-    {
-        const bool value = false;
-    };
-
-    template <class _Ty, class = void>
-    struct _Add_reference { // add reference (non-referenceable type)
-        using _Lvalue = _Ty;
-        using _Rvalue = _Ty;
-    };
-
-    template <class _Ty>
-    struct _Add_reference<_Ty, detail::void_t<_Ty&>> { // (referenceable type)
-        using _Lvalue = _Ty&;
-        using _Rvalue = _Ty&&;
-    };
-
-    template <class _Ty>
-    struct add_lvalue_reference {
-        using type = typename _Add_reference<_Ty>::_Lvalue;
-    };
-
-    template <class _Ty>
-    struct add_rvalue_reference {
-        using type = typename _Add_reference<_Ty>::_Rvalue;
-    };
-
-    template<typename _Ty>
-    typename add_rvalue_reference<_Ty>::type declval() noexcept
-    {
-        static_assert(_Always_false<_Ty>::value, "Calling declval is ill-formed, see N4892 [declval]/2.");
-    }
-} // namespace std
-
-#endif // !USE_STL
-
-#define REM_CONST(T)    typename std::remove_const< T >::type
-#define REM_CV(T)       typename std::remove_cv< T >::type
-#define REM_REF(T)      typename std::remove_reference< T >::type
-
-#define REF_T(T)        REM_REF(T) &
-#define REF_CT(T)       REM_REF(REM_CONST(T)) const &
-
-#endif // __clr_std_type_traits_h__
-
-// Help the VIM editor figure out what kind of file this no-extension file is.
-// vim: filetype=cpp

src/coreclr/inc/clr_std/utility

@@ -1,253 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// clr_std/utility
-//
-// Copy of some key Standard Template Library functionality
-// See http://msdn.microsoft.com/en-us/library/bb982077.aspx for documentation.
-//
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#ifdef USE_STL
-#include <utility>
-#else
-#ifndef __clr_std_utility_h__
-#define __clr_std_utility_h__
-
-#include "clr_std/type_traits"
-
-namespace std
-{
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE FUNCTION move
-    template<class T> inline
-    typename remove_reference<T>::type&&
-    move(T&& arg)
-    {   // forward _Arg as movable
-        return ((typename remove_reference<T>::type&&)arg);
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE FUNCTION swap (from <algorithm>)
-    template<class T> inline
-    void swap(T& left, T& right)
-    {   // exchange values stored at left and right
-        T tmp = std::move(left);
-        left = std::move(right);
-        right = std::move(tmp);
-    }
-
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE FUNCTION forward
-    template<class T> inline
-    T&&
-    forward(typename identity<T>::type& _Arg)
-    {   // forward _Arg, given explicitly specified type parameter
-        return ((T&&)_Arg);
-    }
-}
-
-namespace std
-{
-    //-----------------------------------------------------------------------------------------
-    // TEMPLATE STRUCT pair
-    template<class _Ty1, class _Ty2>
-    struct pair
-    {   // store a pair of values
-        typedef pair<_Ty1, _Ty2> _Myt;
-        typedef _Ty1 first_type;
-        typedef _Ty2 second_type;
-
-        pair()
-            : first(_Ty1()), second(_Ty2())
-        {   // construct from defaults
-        }
-
-        pair(const _Ty1& _Val1, const _Ty2& _Val2)
-            : first(_Val1.first), second(_Val2.second)
-        {   // construct from specified values
-        }
-
-        template<class _Other1, class _Other2>
-        pair(pair<_Other1, _Other2>& _Right)
-            : first(_Right.first), second(_Right.second)
-        {   // construct from compatible pair
-        }
-
-        template<class _Other1, class _Other2>
-        pair(const pair<_Other1, _Other2>& _Right)
-            : first(_Right.first), second(_Right.second)
-        {   // construct from compatible pair
-        }
-
-        void swap(_Myt& _Right)
-        {   // exchange contents with _Right
-            if (this != &_Right)
-            {   // different, worth swapping
-                swap(this->first, _Right.first);
-                swap(this->second, _Right.second);
-            }
-        }
-
-        _Myt& operator=(const _Myt& _Right)
-        {   // assign from copied pair
-            this->first = _Right.first;
-            this->second = _Right.second;
-            return (*this);
-        }
-
-        typedef typename remove_reference<_Ty1>::type _Ty1x;
-        typedef typename remove_reference<_Ty2>::type _Ty2x;
-
-        pair(_Ty1x&& _Val1, _Ty2x&& _Val2)
-            : first(std::move(_Val1)),
-              second(std::move(_Val2))
-        {   // construct from specified values
-        }
-
-        pair(const _Ty1x& _Val1, _Ty2x&& _Val2)
-            : first(_Val1),
-              second(std::move(_Val2))
-        {   // construct from specified values
-        }
-
-        pair(_Ty1x&& _Val1, const _Ty2x& _Val2)
-            : first(std::move(_Val1)),
-              second(_Val2)
-        {   // construct from specified values
-        }
-
-        template<class _Other1, class _Other2>
-        pair(_Other1&& _Val1, _Other2&& _Val2)
-            : first(std::move(_Val1)),
-              second(std::move(_Val2))
-        {   // construct from moved values
-        }
-
-        template<class _Other1, class _Other2>
-        pair(pair<_Other1, _Other2>&& _Right)
-            : first(std::move(_Right.first)),
-              second(std::move(_Right.second))
-        {   // construct from moved compatible pair
-        }
-
-        pair& operator=(pair<_Ty1, _Ty2>&& _Right)
-        {   // assign from moved pair
-            this->first = std::move(_Right.first);
-            this->second = std::move(_Right.second);
-            return (*this);
-        }
-
-        void swap(_Myt&& _Right)
-        {   // exchange contents with _Right
-            if (this != &_Right)
-            {   // different, worth swapping
-                this->first = std::move(_Right.first);
-                this->second = std::move(_Right.second);
-            }
-        }
-
-        _Ty1 first;     // the first stored value
-        _Ty2 second;    // the second stored value
-    }; // struct pair
-
-    //-----------------------------------------------------------------------------------------
-    // pair TEMPLATE FUNCTIONS
-
-    template<class _Ty1, class _Ty2> inline
-    void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right)
-    {   // swap _Left and _Right pairs
-        _Left.swap(_Right);
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>&& _Right)
-    {   // swap _Left and _Right pairs
-        typedef pair<_Ty1, _Ty2> _Myt;
-        _Left.swap(std::forward<_Myt>(_Right));
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    void swap(
-        pair<_Ty1, _Ty2>&& _Left,
-        pair<_Ty1, _Ty2>& _Right)
-    {   // swap _Left and _Right pairs
-        typedef pair<_Ty1, _Ty2> _Myt;
-        _Right.swap(std::forward<_Myt>(_Left));
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    bool operator==(
-        const pair<_Ty1, _Ty2>& _Left,
-        const pair<_Ty1, _Ty2>& _Right)
-    {   // test for pair equality
-        return (_Left.first == _Right.first && _Left.second == _Right.second);
-    }
-
-    template<class _Ty1, class _Ty2> inline
-        bool operator!=(
-            const pair<_Ty1, _Ty2>& _Left,
-            const pair<_Ty1, _Ty2>& _Right)
-    {   // test for pair inequality
-        return (!(_Left == _Right));
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    bool operator<(
-        const pair<_Ty1, _Ty2>& _Left,
-        const pair<_Ty1, _Ty2>& _Right)
-    {   // test if _Left < _Right for pairs
-        return (_Left.first < _Right.first ||
-            (!(_Right.first < _Left.first) && _Left.second < _Right.second));
-    }
-
-    template<class _Ty1, class _Ty2> inline
-        bool operator>(
-            const pair<_Ty1, _Ty2>& _Left,
-            const pair<_Ty1, _Ty2>& _Right)
-    {   // test if _Left > _Right for pairs
-        return (_Right < _Left);
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    bool operator<=(
-        const pair<_Ty1, _Ty2>& _Left,
-        const pair<_Ty1, _Ty2>& _Right)
-    {   // test if _Left <= _Right for pairs
-        return (!(_Right < _Left));
-    }
-
-    template<class _Ty1, class _Ty2> inline
-    bool operator>=(
-        const pair<_Ty1, _Ty2>& _Left,
-        const pair<_Ty1, _Ty2>& _Right)
-    {   // test if _Left >= _Right for pairs
-        return (!(_Left < _Right));
-    }
-
-    template<class _InIt> inline
-    _InIt begin(
-        const pair<_InIt, _InIt>& _Pair)
-    {   // return first element of pair
-        return (_Pair.first);
-    }
-
-    template<class _InIt> inline
-    _InIt end(
-        const pair<_InIt, _InIt>& _Pair)
-    {   // return second element of pair
-        return (_Pair.second);
-    }
-
-} // namespace std
-
-#endif /* __clr_std_utility_h__ */
-
-#endif // !USE_STL
-
-// Help the VIM editor figure out what kind of file this no-extension file is.
-// vim: filetype=cpp

src/coreclr/inc/clr_std/vector

@@ -1,462 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// clr_std/vector
-//
-// Copy of some key Standard Template Library functionality
-//
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#ifdef USE_STL
-#include <vector>
-#else
-#ifndef __clr_std_vector_h__
-#define __clr_std_vector_h__
-
-// This is defined in the debugmacrosext.h header, but don't take a dependency on that.
-#ifndef INDEBUG
-#ifdef _DEBUG
-#define INDEBUG(x)          x
-#else
-#define INDEBUG(x)
-#endif
-#endif // !def INDEBUG
-
-namespace std
-{
-    template <class T>
-    class vector
-    {
-        public:
-            class const_iterator;
-
-            class iterator
-            {
-                friend class std::vector<T>::const_iterator;
-            public:
-                typedef T         value_type;
-                typedef ptrdiff_t difference_type;
-                typedef T*        pointer;
-                typedef T&        reference;
-
-                typedef class vector<T>::iterator _MyIter;
-
-                _MyIter &operator++()
-                {
-                    m_ptr++;
-                    return *this;
-                }
-
-                _MyIter operator++(int)
-                {
-                    // post-increment ++
-                    _MyIter myiter(m_ptr);
-                    m_ptr++;
-                    return myiter;
-                }
-
-                _MyIter &operator--()
-                {
-                    m_ptr--;
-                    return *this;
-                }
-
-                _MyIter operator--(int)
-                {
-                    // post-decrement --
-                    _MyIter myiter(m_ptr);
-                    m_ptr--;
-                    return myiter;
-                }
-
-                _MyIter operator- (ptrdiff_t n)
-                {
-                    _MyIter myiter(m_ptr);
-                    myiter.m_ptr -= n;
-                    return myiter;
-                }
-
-                ptrdiff_t operator- (_MyIter right)
-                {
-                    _MyIter myiter(m_ptr);
-                    return myiter.m_ptr - right.m_ptr;
-                }
-
-                _MyIter operator+ (ptrdiff_t n)
-                {
-                    _MyIter myiter(m_ptr);
-                    myiter.m_ptr += n;
-                    return myiter;
-                }
-
-                T* operator->() const
-                {
-                    return m_ptr;
-                }
-
-                T & operator*() const
-                {
-                    return *m_ptr;
-                }
-
-                bool operator==(const _MyIter& _Right) const
-                {
-                    bool equals = this->m_ptr == _Right.m_ptr;
-                    return equals;
-                }
-
-                bool operator!=(const _MyIter& _Right) const
-                {
-                    bool equals = this->m_ptr == _Right.m_ptr;
-                    return !equals;
-                }
-
-                bool operator<(const _MyIter& _Right) const
-                {
-                    return this->m_ptr < _Right.m_ptr;
-                }
-
-                bool operator>(const _MyIter& _Right) const
-                {
-                    return this->m_ptr > _Right.m_ptr;
-                }
-            public:
-                explicit iterator(T* ptr)
-                {
-                    m_ptr = ptr;
-                }
-
-                private:
-                    T* m_ptr;
-            }; // class iterator
-
-            class const_iterator
-            {
-            public:
-                typedef class vector<T>::const_iterator _MyIter;
-                typedef class vector<T>::iterator _MyNonConstIter;
-
-                _MyIter &operator++()
-                {
-                    m_ptr++;
-                    return *this;
-                }
-
-                _MyIter operator++(int)
-                {
-                    // post-increment ++
-                    _MyIter myiter(m_ptr);
-                    m_ptr++;
-                    return myiter;
-                }
-
-                const T* operator->() const
-                {
-                    return m_ptr;
-                }
-
-                const T & operator*() const
-                {
-                    return *m_ptr;
-                }
-
-                bool operator==(const _MyIter& _Right) const
-                {
-                    bool equals = this->m_ptr == _Right.m_ptr;
-                    return equals;
-                }
-
-                bool operator!=(const _MyIter& _Right) const
-                {
-                    bool equals = this->m_ptr == _Right.m_ptr;
-                    return !equals;
-                }
-
-            public:
-                explicit const_iterator(T* ptr)
-                {
-                    m_ptr = ptr;
-                }
-                const_iterator(const _MyNonConstIter &nonConstIterator)
-                {
-                    m_ptr = nonConstIterator.m_ptr;
-                }
-
-            private:
-                T* m_ptr;
-            }; // class const iterator
-
-
-        public:
-            explicit vector(size_t n = 0)
-            {
-                m_size = 0;
-                m_capacity = 0;
-                m_pelements = NULL;
-                m_isBufferOwner = true;
-                resize(n);
-            }
-
-            ~vector()
-            {
-                if (m_isBufferOwner)
-                {
-                    erase(m_pelements, 0, m_size);
-                    delete [] (BYTE*)m_pelements; // cast to BYTE* as we don't want this delete to invoke T's dtor
-                }
-                else
-                {
-                    m_size = 0;
-                    m_capacity = 0;
-                }
-            }
-
-            vector(const vector<T>&) = delete;
-            vector<T>& operator=(const vector<T>&) = delete;
-
-            vector(vector<T>&& v) noexcept
-                : m_size(v.m_size)
-                , m_capacity(v.m_capacity)
-                , m_pelements(v.m_pelements)
-                , m_isBufferOwner(v.m_isBufferOwner)
-            {
-                v.m_isBufferOwner = false;
-            }
-
-            vector<T>& operator=(vector<T>&& v) noexcept
-            {
-                if (m_isBufferOwner)
-                {
-                    erase(m_pelements, 0, m_size);
-                    delete [] (BYTE*)m_pelements;
-                }
-
-                m_size = v.m_size;
-                m_capacity = v.m_capacity;
-                m_pelements = v.m_pelements;
-                m_isBufferOwner = v.m_isBufferOwner;
-                v.m_isBufferOwner = false;
-                return *this;
-            }
-
-            size_t size() const
-            {
-                return m_size;
-            }
-
-            T & operator[](size_t iIndex)
-            {
-                assert(iIndex < m_size);
-                return m_pelements[iIndex];
-            }
-
-            T & operator[](size_t iIndex) const
-            {
-                assert(iIndex < m_size);
-                return m_pelements[iIndex];
-            }
-
-            void resize(size_t newsize)
-            {
-                assert(m_isBufferOwner);
-                size_t oldsize = this->size();
-                resize_noinit(newsize);
-                if (newsize > oldsize)
-                {
-                    fill_uninitialized_with_default_value(m_pelements, oldsize, newsize);
-                }
-            }
-
-            void clear()
-            {
-                assert(m_isBufferOwner);
-                resize(0);
-            }
-
-            void resize(size_t newsize, T c)
-            {
-                assert(m_isBufferOwner);
-                size_t oldsize = this->size();
-                resize_noinit(newsize);
-                if (newsize > oldsize)
-                {
-                    for (size_t i = oldsize; i < newsize; i++)
-                    {
-                        m_pelements[i] = c;
-                    }
-                }
-            }
-
-            void wrap(size_t numElements, T* pElements)
-            {
-                m_size = numElements;
-                m_pelements = pElements;
-                m_isBufferOwner = false;
-            }
-
-            void resize_noinit(size_t newsize)
-            {
-                assert(m_isBufferOwner);
-                size_t oldsize = this->size();
-                if (newsize < oldsize)
-                {
-                    // Shrink
-                    erase(m_pelements, newsize, oldsize);
-                }
-                else if (newsize > oldsize)
-                {
-                    // Grow
-                    reserve(newsize);
-                }
-                m_size = newsize;
-            }
-
-            void push_back(const T & val)
-            {
-                assert(m_isBufferOwner);
-                if (m_size + 1 < m_size)
-                {
-                    assert("push_back: overflow");
-                    // @todo: how to throw.
-                }
-                resize(m_size + 1, val);
-            }
-
-            void reserve(size_t newcapacity)
-            {
-                assert(m_isBufferOwner);
-                if (newcapacity > m_capacity)
-                {
-                    // To avoid resizing for every element that gets added to a vector, we
-                    // allocate at least twice the old capacity, or 16 elements, whichever is greater.
-                    newcapacity = max(newcapacity, max(m_capacity * 2, 16));
-
-                    size_t bytesNeeded = newcapacity * sizeof(T);
-                    if (bytesNeeded / sizeof(T) != newcapacity)
-                    {
-                        assert("resize: overflow");
-                        // @todo: how to throw something here?
-                    }
-
-
-                    T *pelements = (T*)(new BYTE[bytesNeeded]);  // Allocate as BYTE array to avoid automatic construction
-                    INDEBUG(memset(pelements, 0xcc, bytesNeeded));
-                    for (size_t i = 0; i < m_size; i++)
-                    {
-                        pelements[i] = m_pelements[i];
-                    }
-
-                    erase(m_pelements, 0, m_size);
-                    delete [] (BYTE*)m_pelements; // cast to BYTE* as we don't want this delete to invoke T's dtor
-
-                    m_pelements = pelements;
-                    m_capacity = newcapacity;
-                }
-            }
-
-            iterator begin()
-            {
-                return iterator(m_pelements);
-            }
-
-            iterator end()
-            {
-                return iterator(m_pelements + m_size);
-            }
-
-            const_iterator cbegin() const
-            {
-                return const_iterator(m_pelements);
-            }
-
-            const_iterator cend() const
-            {
-                return const_iterator(m_pelements + m_size);
-            }
-
-            iterator erase(iterator position)
-            {
-                assert(m_isBufferOwner);
-                assert((position > begin() || position == begin()) && position < end());
-                ptrdiff_t index = position - begin();
-                erase(m_pelements, index, index + 1);
-                memcpy(&m_pelements[index], &m_pelements[index + 1], sizeof(T) * (m_size - index - 1));
-                --m_size;
-                return iterator(m_pelements + (position - begin()));
-            }
-
-            iterator erase(iterator position, iterator positionEnd)
-            {
-                assert(m_isBufferOwner);
-                assert((position > begin() || position == begin()) && position < end());
-                ptrdiff_t index = position - begin();
-                ptrdiff_t elements = positionEnd - position;
-                erase(m_pelements, index, index + elements);
-                memcpy(&m_pelements[index], &m_pelements[index + elements], sizeof(T) * (m_size - index - elements));
-                m_size -= elements;
-                return iterator(m_pelements + (position - begin()));
-            }
-            
-            T* data()
-            {
-                return m_pelements;
-            }
-
-            const T* data() const
-            {
-                return m_pelements;
-            }
-
-         private:
-            // Transition a subset of the array from uninitialized to initialized with default value for T.
-            static void fill_uninitialized_with_default_value(T* pelements, size_t startIdx, size_t endIdx)
-            {
-                assert(startIdx <= endIdx);
-                assert(pelements != NULL || startIdx == endIdx);
-                for (size_t i = startIdx; i < endIdx; i++)
-                {
-                    INDEBUG(assert(0xcc == *((BYTE*)&pelements[i])));
-                    pelements[i] = T();
-                }
-            }
-
-            // Transition a subset of the array from a valid value of T to uninitialized.
-            static void erase(T* pelements, size_t startIdx, size_t endIdx)
-            {
-                assert(startIdx <= endIdx);
-                assert(pelements != NULL || startIdx == endIdx);
-                for (size_t i = startIdx; i < endIdx; i++)
-                {
-                    pelements[i].~T();
-                }
-
-                INDEBUG(memset(&pelements[startIdx], 0xcc, (endIdx - startIdx) * sizeof(T)));
-            }
-
-         private:
-            size_t    m_size;       //# of elements
-            size_t    m_capacity;   //# of elements allocated
-            T        *m_pelements;  //actual array
-                                    //  invariants:
-                                    //    dimensions == m_capacity
-                                    //    elements 0 thru m_size-1 always contain constructed T values.
-                                    //    elements from m_size thru m_capacity - 1 contain memory garbage (0xcc in DEBUG).
-            bool    m_isBufferOwner; // indicate if this vector creates its own buffer, or wraps an existing buffer.
-
-
-
-
-    };  // class vector
-
-}; // namespace std
-
-#endif /* __clr_std_vector_h__ */
-
-#endif // !USE_STL
-
-// Help the VIM editor figure out what kind of file this no-extension file is.
-// vim: filetype=cpp

src/coreclr/inc/contract.h

@@ -232,7 +232,6 @@
 
 #include "specstrings.h"
 #include "clrtypes.h"
-#include "malloc.h"
 #include "check.h"
 #include "debugreturn.h"
 #include "staticcontract.h"

src/coreclr/inc/contract.inl

@@ -352,7 +352,7 @@ inline void DbgStateLockData::LockTaken(DbgStateLockType dbgStateLockType,
 
     // Remember as many of these new entrances in m_rgTakenLockInfos as we can
     for (UINT i = cCombinedLocks;
-         i < min (ARRAY_SIZE(m_rgTakenLockInfos), cCombinedLocks + cTakes);
+         i < std::min (ARRAY_SIZE(m_rgTakenLockInfos), (size_t)(cCombinedLocks + cTakes));
          i++)
     {
         m_rgTakenLockInfos[i].m_pvLock = pvLock;
@@ -377,7 +377,7 @@ inline void DbgStateLockData::LockReleased(DbgStateLockType dbgStateLockType, UI
     // If lock count is within range of our m_rgTakenLockInfos buffer size, then
     // make sure we're releasing locks in reverse order of how we took them
     for (UINT i = cCombinedLocks - cReleases;
-         i < min (ARRAY_SIZE(m_rgTakenLockInfos), cCombinedLocks);
+         i < std::min (ARRAY_SIZE(m_rgTakenLockInfos), (size_t)cCombinedLocks);
          i++)
     {
         if (m_rgTakenLockInfos[i].m_pvLock != pvLock)
@@ -443,7 +443,7 @@ inline BOOL DbgStateLockState::IsLockRetaken(void * pvLock)
     // m_cLocksEnteringCannotRetakeLock records the number of locks that were taken
     // when CANNOT_RETAKE_LOCK contract was constructed.
     for (UINT i = 0;
-        i < min(ARRAY_SIZE(m_pLockData->m_rgTakenLockInfos), m_cLocksEnteringCannotRetakeLock);
+        i < std::min(ARRAY_SIZE(m_pLockData->m_rgTakenLockInfos), (size_t)m_cLocksEnteringCannotRetakeLock);
         ++i)
     {
         if (m_pLockData->m_rgTakenLockInfos[i].m_pvLock == pvLock)

src/coreclr/inc/crtwrap.h

@@ -11,11 +11,11 @@
 #define __CrtWrap_h__
 
 #include <stdint.h>
+#include <stddef.h>
 #include <windows.h>
 #include <objbase.h>
 #include "debugmacros.h"
 #include <stdlib.h>
-#include <malloc.h>
 #include <wchar.h>
 #include <stdio.h>
 

src/coreclr/inc/daccess.h

@@ -561,6 +561,10 @@
 #ifndef NATIVEAOT
 #include <stdint.h>
 
+#if !defined(HOST_WINDOWS)
+#include <pal_mstypes.h>
+#endif
+
 #include "switches.h"
 #include "safemath.h"
 #include "corerror.h"
@@ -568,12 +572,8 @@
 // Keep in sync with the definitions in dbgutil.cpp and createdump.h
 #define DACCESS_TABLE_SYMBOL "g_dacTable"
 
-#ifdef PAL_STDCPP_COMPAT
 #include <type_traits>
-#else
-#include "clr_std/type_traits"
 #include "crosscomp.h"
-#endif
 
 #include <dn-u16.h>
 

src/coreclr/inc/dacprivate.h

@@ -467,7 +467,7 @@ struct MSLAYOUT DacpAssemblyData
 
     HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr)
     {
-        return Request(sos, addr, NULL);
+        return Request(sos, addr, 0);
     }
 };
 
@@ -577,7 +577,7 @@ struct MSLAYOUT DacpMethodDescData
     {
         return sos->GetMethodDescData(
             addr,
-            NULL,   // IP address
+            0,      // IP address
             this,
             0,      // cRejitData
             NULL,   // rejitData[]

src/coreclr/inc/holder.h

@@ -11,13 +11,8 @@
 #include "volatile.h"
 #include "palclr.h"
 
-#ifdef PAL_STDCPP_COMPAT
 #include <utility>
 #include <type_traits>
-#else
-#include "clr_std/utility"
-#include "clr_std/type_traits"
-#endif
 
 #if defined(FEATURE_COMINTEROP) && !defined(STRIKE)
 #include <Activation.h>

src/coreclr/inc/loaderheap.h

@@ -158,7 +158,7 @@ struct LoaderHeapEvent;
 inline UINT32 GetStubCodePageSize()
 {
 #if defined(TARGET_ARM64) && defined(TARGET_UNIX)
-    return max(16*1024, GetOsPageSize());
+    return max(16*1024u, GetOsPageSize());
 #elif defined(TARGET_ARM)
     return 4096; // ARM is special as the 32bit instruction set does not easily permit a 16KB offset
 #else

src/coreclr/inc/random.h

@@ -24,7 +24,7 @@
 // Forbid the use of srand()/rand(), as these are globally shared facilities and our use of them would
 // interfere with native user code in the same process. This override is not compatible with stl headers.
 //
-#if !defined(DO_NOT_DISABLE_RAND) && !defined(USE_STL)
+#if !defined(DO_NOT_DISABLE_RAND)
 
 #ifdef srand
 #undef srand
@@ -36,7 +36,7 @@
 #endif
 #define rand Do_not_use_rand
 
-#endif //!DO_NOT_DISABLE_RAND && !USE_STL
+#endif //!DO_NOT_DISABLE_RAND
 
 
 class CLRRandom

src/coreclr/inc/safemath.h

@@ -31,11 +31,11 @@
 
 #include "static_assert.h"
 
-#ifdef PAL_STDCPP_COMPAT
 #include <type_traits>
-#else
+
-#include "clr_std/type_traits"
+#ifdef FEATURE_PAL
-#endif
+#include "pal_mstypes.h"
+#endif // FEATURE_PAL
 
 //==================================================================
 // Semantics: if val can be represented as the exact same value

src/coreclr/inc/utilcode.h

@@ -10,14 +10,16 @@
 #ifndef __UtilCode_h__
 #define __UtilCode_h__
 
+#include <type_traits>
+#include <algorithm>
+#include <stdio.h>
+#include <limits.h>
+
 #include "crtwrap.h"
 #include "winwrap.h"
 #include <wchar.h>
-#include <stdio.h>
-#include <malloc.h>
 #include <ole2.h>
 #include <oleauto.h>
-#include <limits.h>
 #include "clrtypes.h"
 #include "safewrap.h"
 #include "volatile.h"
@@ -29,12 +31,6 @@
 #include "safemath.h"
 #include "new.hpp"
 
-#ifdef PAL_STDCPP_COMPAT
-#include <type_traits>
-#else
-#include "clr_std/type_traits"
-#endif
-
 #include "contract.h"
 
 #include <minipal/utils.h>
@@ -224,7 +220,7 @@ typedef LPSTR   LPUTF8;
 #define MAKE_UTF8PTR_FROMWIDE_NOTHROW(ptrname, widestr) \
     CQuickBytes __qb##ptrname; \
     int __l##ptrname = (int)u16_strlen(widestr); \
-    LPUTF8 ptrname = 0; \
+    LPUTF8 ptrname = NULL; \
     if (__l##ptrname <= MAKE_MAX_LENGTH) { \
         __l##ptrname = (int)((__l##ptrname + 1) * 2 * sizeof(char)); \
         ptrname = (LPUTF8) __qb##ptrname.AllocNoThrow(__l##ptrname); \
@@ -240,12 +236,12 @@ typedef LPSTR   LPUTF8;
                     if (WszWideCharToMultiByte(CP_UTF8, 0, widestr, -1, ptrname, __lsize##ptrname, NULL, NULL) != 0) { \
                         ptrname[__l##ptrname] = 0; \
                     } else { \
-                        ptrname = 0; \
+                        ptrname = NULL; \
                     } \
                 } \
             } \
             else { \
-                ptrname = 0; \
+                ptrname = NULL; \
             } \
         } \
     } \
@@ -255,7 +251,7 @@ typedef LPSTR   LPUTF8;
 #define MAKE_WIDEPTR_FROMUTF8N_NOTHROW(ptrname, utf8str, n8chrs) \
     CQuickBytes __qb##ptrname; \
     int __l##ptrname; \
-    LPWSTR ptrname = 0; \
+    LPWSTR ptrname = NULL; \
     __l##ptrname = WszMultiByteToWideChar(CP_UTF8, 0, utf8str, n8chrs, 0, 0); \
     if (__l##ptrname <= MAKE_MAX_LENGTH) { \
         ptrname = (LPWSTR) __qb##ptrname.AllocNoThrow((__l##ptrname+1)*sizeof(WCHAR));  \
@@ -263,7 +259,7 @@ typedef LPSTR   LPUTF8;
             if (WszMultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8str, n8chrs, ptrname, __l##ptrname) != 0) { \
                 ptrname[__l##ptrname] = 0; \
             } else { \
-                ptrname = 0; \
+                ptrname = NULL; \
             } \
         } \
     }
@@ -302,28 +298,6 @@ inline WCHAR* FormatInteger(WCHAR* str, size_t strCount, const char* fmt, I v)
     return str;
 }
 
-//*****************************************************************************
-// Placement new is used to new and object at an exact location.  The pointer
-// is simply returned to the caller without actually using the heap.  The
-// advantage here is that you cause the ctor() code for the object to be run.
-// This is ideal for heaps of C++ objects that need to get init'd multiple times.
-// Example:
-//      void        *pMem = GetMemFromSomePlace();
-//      Foo *p = new (pMem) Foo;
-//      DoSomething(p);
-//      p->~Foo();
-//*****************************************************************************
-#ifndef __PLACEMENT_NEW_INLINE
-#define __PLACEMENT_NEW_INLINE
-inline void *__cdecl operator new(size_t, void *_P)
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-
-    return (_P);
-}
-#endif // __PLACEMENT_NEW_INLINE
-
-
 /********************************************************************************/
 /* portability helpers */
 
@@ -1920,7 +1894,7 @@ public:
     ~CHashTableAndData()
     {
         WRAPPER_NO_CONTRACT;
-        if (m_pcEntries != NULL)
+        if (m_pcEntries != (TADDR)NULL)
             MemMgr::Free((BYTE*)m_pcEntries, MemMgr::RoundSize(m_iEntries * m_iEntrySize));
     }
 
@@ -2100,7 +2074,7 @@ int CHashTableAndData<MemMgr>::Grow()   // 1 if successful, 0 if not.
     int         iCurSize;               // Current size in bytes.
     int         iEntries;               // New # of entries.
 
-    _ASSERTE(m_pcEntries != NULL);
+    _ASSERTE(m_pcEntries != (TADDR)NULL);
     _ASSERTE(m_iFree == UINT32_MAX);
 
     // Compute the current size and new # of entries.
@@ -3934,37 +3908,6 @@ inline T* InterlockedCompareExchangeT(
     return InterlockedCompareExchangeT(destination, exchange, static_cast<T*>(comparand));
 }
 
-// NULL pointer variants of the above to avoid having to cast NULL
-// to the appropriate pointer type.
-template <typename T>
-inline T* InterlockedExchangeT(
-    T* volatile *   target,
-    int             value) // When NULL is provided as argument.
-{
-    //STATIC_ASSERT(value == 0);
-    return InterlockedExchangeT(target, nullptr);
-}
-
-template <typename T>
-inline T* InterlockedCompareExchangeT(
-    T* volatile *   destination,
-    int             exchange,  // When NULL is provided as argument.
-    T*              comparand)
-{
-    //STATIC_ASSERT(exchange == 0);
-    return InterlockedCompareExchangeT(destination, nullptr, comparand);
-}
-
-template <typename T>
-inline T* InterlockedCompareExchangeT(
-    T* volatile *   destination,
-    T*              exchange,
-    int             comparand) // When NULL is provided as argument.
-{
-    //STATIC_ASSERT(comparand == 0);
-    return InterlockedCompareExchangeT(destination, exchange, nullptr);
-}
-
 #undef InterlockedExchangePointer
 #define InterlockedExchangePointer Use_InterlockedExchangeT
 #undef InterlockedCompareExchangePointer

src/coreclr/jit/alloc.cpp

@@ -156,7 +156,11 @@ void* ArenaAllocator::allocateHostMemory(size_t size, size_t* pActualSize)
     if (bypassHostAllocator())
     {
         *pActualSize = size;
-        void* p      = malloc(size);
+        if (size == 0)
+        {
+            size = 1;
+        }
+        void* p = malloc(size);
         if (p == nullptr)
         {
             NOMEM();

src/coreclr/jit/assertionprop.cpp

@@ -673,7 +673,7 @@ void Compiler::optAssertionInit(bool isLocalProp)
         // Local assertion prop keeps mappings from each local var to the assertions about that var.
         //
         optAssertionDep =
-            new (this, CMK_AssertionProp) JitExpandArray<ASSERT_TP>(getAllocator(CMK_AssertionProp), max(1, lvaCount));
+            new (this, CMK_AssertionProp) JitExpandArray<ASSERT_TP>(getAllocator(CMK_AssertionProp), max(1u, lvaCount));
 
         if (optCrossBlockLocalAssertionProp)
         {

src/coreclr/jit/codegenarm64.cpp

@@ -432,7 +432,7 @@ void CodeGen::genStackPointerAdjustment(ssize_t spDelta, regNumber tmpReg, bool*
     {
         // spDelta is negative in the prolog, positive in the epilog, but we always tell the unwind codes the positive
         // value.
-        ssize_t  spDeltaAbs    = abs(spDelta);
+        ssize_t  spDeltaAbs    = std::abs(spDelta);
         unsigned unwindSpDelta = (unsigned)spDeltaAbs;
         assert((ssize_t)unwindSpDelta == spDeltaAbs); // make sure that it fits in a unsigned
 

src/coreclr/jit/codegencommon.cpp

@@ -2815,6 +2815,12 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  *  assigned location, in the function prolog.
  */
 
+// std::max isn't constexpr until C++14 and we're still on C++11
+constexpr size_t const_max(size_t a, size_t b)
+{
+    return a > b ? a : b;
+}
+
 #ifdef _PREFAST_
 #pragma warning(push)
 #pragma warning(disable : 21000) // Suppress PREFast warning about overly large function
@@ -2908,7 +2914,7 @@ void CodeGen::genFnPrologCalleeRegArgs(regNumber xtraReg, bool* pXtraRegClobbere
         bool circular;     // true if this register participates in a circular dependency loop.
         bool hfaConflict;  // arg is part of an HFA that will end up in the same register
                            // but in a different slot (eg arg in s3 = v3.s[0], needs to end up in v3.s[3])
-    } regArgTab[max(MAX_REG_ARG + 1, MAX_FLOAT_REG_ARG)] = {};
+    } regArgTab[const_max(MAX_REG_ARG + 1, MAX_FLOAT_REG_ARG)] = {};
 
     unsigned   varNum;
     LclVarDsc* varDsc;

src/coreclr/jit/compiler.cpp

@@ -5659,7 +5659,7 @@ void Compiler::SplitTreesRandomly()
     rng.Init(info.compMethodHash() ^ 0x077cc4d4);
 
     // Splitting creates a lot of new locals. Set a limit on how many we end up creating here.
-    unsigned maxLvaCount = max(lvaCount * 2, 50000);
+    unsigned maxLvaCount = max(lvaCount * 2, 50000u);
 
     for (BasicBlock* block : Blocks())
     {
@@ -5721,7 +5721,7 @@ void Compiler::SplitTreesRandomly()
 void Compiler::SplitTreesRemoveCommas()
 {
     // Splitting creates a lot of new locals. Set a limit on how many we end up creating here.
-    unsigned maxLvaCount = max(lvaCount * 2, 50000);
+    unsigned maxLvaCount = max(lvaCount * 2, 50000u);
 
     for (BasicBlock* block : Blocks())
     {
@@ -7532,7 +7532,7 @@ void Compiler::compInitVarScopeMap()
     compVarScopeMap = new (getAllocator()) VarNumToScopeDscMap(getAllocator());
 
     // 599 prime to limit huge allocations; for ex: duplicated scopes on single var.
-    compVarScopeMap->Reallocate(min(info.compVarScopesCount, 599));
+    compVarScopeMap->Reallocate(min(info.compVarScopesCount, 599u));
 
     for (unsigned i = 0; i < info.compVarScopesCount; ++i)
     {

src/coreclr/jit/compiler.h

@@ -350,7 +350,7 @@ class SsaDefArray
     void GrowArray(CompAllocator alloc)
     {
         unsigned oldSize = m_arraySize;
-        unsigned newSize = max(2, oldSize * 2);
+        unsigned newSize = max(2u, oldSize * 2);
 
         T* newArray = alloc.allocate<T>(newSize);
 

src/coreclr/jit/compiler.hpp

@@ -2600,7 +2600,8 @@ inline
 #else
                 int outGoingArgSpaceSize = 0;
 #endif
-                varOffset = outGoingArgSpaceSize + max(-varNum * TARGET_POINTER_SIZE, (int)lvaGetMaxSpillTempSize());
+                varOffset =
+                    outGoingArgSpaceSize + max(-varNum * (int)TARGET_POINTER_SIZE, (int)lvaGetMaxSpillTempSize());
             }
             else
             {

src/coreclr/jit/emit.cpp

@@ -6243,10 +6243,10 @@ void emitter::emitLoopAlignAdjustments()
                 {
 
 #if defined(TARGET_XARCH)
-                    unsigned newPadding = min(paddingToAdj, MAX_ENCODED_SIZE);
+                    unsigned newPadding = min(paddingToAdj, (unsigned)MAX_ENCODED_SIZE);
                     alignInstrToAdj->idCodeSize(newPadding);
 #elif defined(TARGET_ARM64)
-                    unsigned newPadding = min(paddingToAdj, INSTR_ENCODED_SIZE);
+                    unsigned newPadding = min(paddingToAdj, (unsigned)INSTR_ENCODED_SIZE);
                     if (newPadding == 0)
                     {
                         alignInstrToAdj->idInsOpt(INS_OPTS_NONE);

src/coreclr/jit/emitarm.cpp

@@ -6504,7 +6504,7 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** dp)
                 code |= (immHi << 16);
                 code |= immLo;
 
-                disp = abs(disp);
+                disp = std::abs(disp);
                 assert((disp & 0x00fffffe) == disp);
 
                 callInstrSize = SafeCvtAssert<unsigned char>(emitOutput_Thumb2Instr(dst, code));

src/coreclr/jit/emitarm64.cpp

@@ -8964,7 +8964,7 @@ void emitter::emitIns_Call(EmitCallType          callType,
 
     // Our stack level should be always greater than the bytes of arguments we push. Just
     // a sanity test.
-    assert((unsigned)abs(argSize) <= codeGen->genStackLevel);
+    assert((unsigned)std::abs(argSize) <= codeGen->genStackLevel);
 
     // Trim out any callee-trashed registers from the live set.
     regMaskTP savedSet = emitGetGCRegsSavedOrModified(methHnd);

src/coreclr/jit/fgopt.cpp

@@ -2467,7 +2467,7 @@ bool Compiler::fgOptimizeUncondBranchToSimpleCond(BasicBlock* block, BasicBlock*
         //
         weight_t targetWeight = target->bbWeight;
         weight_t blockWeight  = block->bbWeight;
-        target->setBBProfileWeight(max(0, targetWeight - blockWeight));
+        target->setBBProfileWeight(max(0.0, targetWeight - blockWeight));
         JITDUMP("Decreased " FMT_BB " profile weight from " FMT_WT " to " FMT_WT "\n", target->bbNum, targetWeight,
                 target->bbWeight);
     }
@@ -3047,7 +3047,7 @@ bool Compiler::fgOptimizeSwitchJumps()
         blockToTargetEdge->setEdgeWeights(blockToTargetWeight, blockToTargetWeight, dominantTarget);
         blockToTargetEdge->setLikelihood(fraction);
         blockToNewBlockEdge->setEdgeWeights(blockToNewBlockWeight, blockToNewBlockWeight, block);
-        blockToNewBlockEdge->setLikelihood(max(0, 1.0 - fraction));
+        blockToNewBlockEdge->setLikelihood(max(0.0, 1.0 - fraction));
 
         // There may be other switch cases that lead to this same block, but there's just
         // one edge in the flowgraph. So we need to subtract off the profile data that now flows

src/coreclr/jit/fgprofilesynthesis.cpp

@@ -1353,7 +1353,7 @@ void ProfileSynthesis::GaussSeidelSolver()
     for (unsigned j = m_dfsTree->GetPostOrderCount(); j != 0; j--)
     {
         BasicBlock* const block = dfs->GetPostOrder(j - 1);
-        block->setBBProfileWeight(max(0, countVector[block->bbNum]));
+        block->setBBProfileWeight(max(0.0, countVector[block->bbNum]));
     }
 
     m_approximate = !converged || (m_cappedCyclicProbabilities > 0);

src/coreclr/jit/gentree.cpp

@@ -5745,7 +5745,7 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree)
                     {
                         // Store to an enregistered local.
                         costEx = op1->GetCostEx();
-                        costSz = max(3, op1->GetCostSz()); // 3 is an estimate for a reg-reg move.
+                        costSz = max(3, (int)op1->GetCostSz()); // 3 is an estimate for a reg-reg move.
                         goto DONE;
                     }
 
@@ -26906,7 +26906,7 @@ void ReturnTypeDesc::InitializeStructReturnType(Compiler*                comp,
             assert(varTypeIsValidHfaType(hfaType));
 
             // Note that the retail build issues a warning about a potential divsion by zero without this "max",
-            unsigned elemSize = max(1, genTypeSize(hfaType));
+            unsigned elemSize = max(1u, genTypeSize(hfaType));
 
             // The size of this struct should be evenly divisible by elemSize
             assert((structSize % elemSize) == 0);

src/coreclr/jit/hashbv.cpp

@@ -824,7 +824,7 @@ void hashBv::setAll(indexType numToSet)
     for (unsigned int i = 0; i < numToSet; i += BITS_PER_NODE)
     {
         hashBvNode* node        = getOrAddNodeForIndex(i);
-        indexType   bits_to_set = min(BITS_PER_NODE, numToSet - i);
+        indexType   bits_to_set = min((indexType)BITS_PER_NODE, numToSet - i);
         node->setLowest(bits_to_set);
     }
 }

src/coreclr/jit/inline.h

@@ -1049,7 +1049,7 @@ public:
     enum
     {
         ALWAYS_INLINE_SIZE              = 16,
-        IMPLEMENTATION_MAX_INLINE_SIZE  = _UI16_MAX,
+        IMPLEMENTATION_MAX_INLINE_SIZE  = UINT16_MAX,
         IMPLEMENTATION_MAX_INLINE_DEPTH = 1000
     };
 

src/coreclr/jit/jit.h

@@ -702,19 +702,19 @@ inline unsigned int roundUp(unsigned size, unsigned mult)
 
 inline unsigned int unsigned_abs(int x)
 {
-    return ((unsigned int)abs(x));
+    return ((unsigned int)std::abs(x));
 }
 
 #ifdef TARGET_64BIT
 inline size_t unsigned_abs(ssize_t x)
 {
-    return ((size_t)abs((__int64)x));
+    return ((size_t)std::abs((__int64)x));
 }
 
 #ifdef __APPLE__
 inline size_t unsigned_abs(__int64 x)
 {
-    return ((size_t)abs(x));
+    return ((size_t)std::abs(x));
 }
 #endif // __APPLE__
 #endif // TARGET_64BIT

src/coreclr/jit/jiteh.cpp

@@ -1554,7 +1554,7 @@ EHblkDsc* Compiler::fgAddEHTableEntry(unsigned XTnum)
         // Double the table size. For stress, we could use +1. Note that if the table isn't allocated
         // yet, such as when we add an EH region for synchronized methods that don't already have one,
         // we start at zero, so we need to make sure the new table has at least one entry.
-        unsigned newHndBBtabAllocCount = max(1, compHndBBtabAllocCount * 2);
+        unsigned newHndBBtabAllocCount = max(1u, compHndBBtabAllocCount * 2);
         noway_assert(compHndBBtabAllocCount < newHndBBtabAllocCount); // check for overflow
 
         if (newHndBBtabAllocCount > MAX_XCPTN_INDEX)

src/coreclr/jit/jitpch.h

@@ -11,7 +11,15 @@
 #include <string.h>
 #include <float.h>
 #include <cstdlib>
+#include <cmath>
 #include <intrin.h>
+#ifdef HOST_WINDOWS
+#include <malloc.h>
+#endif
+#include <algorithm>
+
+using std::max;
+using std::min;
 
 // Don't allow using the windows.h #defines for the BitScan* APIs. Using the #defines means our
 // `BitOperations::BitScan*` functions have their name mapped, which is confusing and messes up

src/coreclr/jit/jitstd/list.h

@@ -14,7 +14,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 
 #include "iterator.h"
 #include "functional.h"
-#include "clr_std/utility"
+#include <utility>
 
 namespace jitstd
 {

src/coreclr/jit/jitstd/utility.h

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include "clr_std/type_traits"
+#include <type_traits>
 
 namespace jitstd
 {

src/coreclr/jit/lclvars.cpp

@@ -622,7 +622,7 @@ void Compiler::lvaInitUserArgs(InitVarDscInfo* varDscInfo, unsigned skipArgs, un
     const unsigned argSigLen = info.compMethodInfo->args.numArgs;
 
     // We will process at most takeArgs arguments from the signature after skipping skipArgs arguments
-    const int64_t numUserArgs = min(takeArgs, (argSigLen - (int64_t)skipArgs));
+    const int64_t numUserArgs = min((int64_t)takeArgs, (argSigLen - (int64_t)skipArgs));
 
     // If there are no user args or less than skipArgs args, return here since there's no work to do.
     if (numUserArgs <= 0)
@@ -2000,7 +2000,7 @@ bool Compiler::StructPromotionHelper::CanPromoteStructType(CORINFO_CLASS_HANDLE
 #if defined(FEATURE_SIMD)
     // getMaxVectorByteLength() represents the size of the largest primitive type that we can struct promote.
     const unsigned maxSize =
-        MAX_NumOfFieldsInPromotableStruct * max(compiler->getMaxVectorByteLength(), sizeof(double));
+        MAX_NumOfFieldsInPromotableStruct * max(compiler->getMaxVectorByteLength(), (uint32_t)sizeof(double));
 #else  // !FEATURE_SIMD
     // sizeof(double) represents the size of the largest primitive type that we can struct promote.
     const unsigned maxSize = MAX_NumOfFieldsInPromotableStruct * sizeof(double);

src/coreclr/jit/loopcloning.cpp

@@ -2073,7 +2073,7 @@ void Compiler::optCloneLoop(FlowGraphNaturalLoop* loop, LoopCloneContext* contex
     FlowEdge* const falseEdge = fgAddRefPred(fastPreheader, condLast);
     condLast->SetFalseEdge(falseEdge);
     FlowEdge* const trueEdge = condLast->GetTrueEdge();
-    falseEdge->setLikelihood(max(0, 1.0 - trueEdge->getLikelihood()));
+    falseEdge->setLikelihood(max(0.0, 1.0 - trueEdge->getLikelihood()));
 }
 
 //-------------------------------------------------------------------------

src/coreclr/jit/lower.cpp

@@ -7153,7 +7153,7 @@ bool Lowering::TryLowerConstIntDivOrMod(GenTree* node, GenTree** nextNode)
     }
 
     size_t absDivisorValue =
-        (divisorValue == SSIZE_T_MIN) ? static_cast<size_t>(divisorValue) : static_cast<size_t>(abs(divisorValue));
+        (divisorValue == SSIZE_T_MIN) ? static_cast<size_t>(divisorValue) : static_cast<size_t>(std::abs(divisorValue));
 
     if (!isPow2(absDivisorValue))
     {
@@ -8950,7 +8950,7 @@ bool Lowering::OptimizeForLdp(GenTreeIndir* ind)
 
         JITDUMP("[%06u] and [%06u] are indirs off the same base with offsets +%03u and +%03u\n",
                 Compiler::dspTreeID(ind), Compiler::dspTreeID(prevIndir), (unsigned)offs, (unsigned)prev.Offset);
-        if (abs(offs - prev.Offset) == genTypeSize(ind))
+        if (std::abs(offs - prev.Offset) == genTypeSize(ind))
         {
             JITDUMP("  ..and they are amenable to ldp optimization\n");
             if (TryMakeIndirsAdjacent(prevIndir, ind))

src/coreclr/jit/morph.cpp

@@ -2934,7 +2934,7 @@ void CallArgs::AddFinalArgsAndDetermineABIInfo(Compiler* comp, GenTreeCall* call
 #ifdef WINDOWS_AMD64_ABI
                             // Whenever we pass an integer register argument
                             // we skip the corresponding floating point register argument
-                            intArgRegNum = min(intArgRegNum + size, MAX_REG_ARG);
+                            intArgRegNum = min(intArgRegNum + size, (unsigned)MAX_REG_ARG);
 #endif // WINDOWS_AMD64_ABI
        // No supported architecture supports partial structs using float registers.
                             assert(fltArgRegNum <= MAX_FLOAT_REG_ARG);
@@ -2945,7 +2945,7 @@ void CallArgs::AddFinalArgsAndDetermineABIInfo(Compiler* comp, GenTreeCall* call
                             intArgRegNum += size;
 
 #ifdef WINDOWS_AMD64_ABI
-                            fltArgRegNum = min(fltArgRegNum + size, MAX_FLOAT_REG_ARG);
+                            fltArgRegNum = min(fltArgRegNum + size, (unsigned)MAX_FLOAT_REG_ARG);
 #endif // WINDOWS_AMD64_ABI
                         }
                     }
@@ -3019,7 +3019,7 @@ void CallArgs::AddFinalArgsAndDetermineABIInfo(Compiler* comp, GenTreeCall* call
 unsigned CallArgs::OutgoingArgsStackSize() const
 {
     unsigned aligned = Compiler::GetOutgoingArgByteSize(m_nextStackByteOffset);
-    return max(aligned, MIN_ARG_AREA_FOR_CALL);
+    return max(aligned, (unsigned)MIN_ARG_AREA_FOR_CALL);
 }
 
 //------------------------------------------------------------------------

src/coreclr/jit/targetarm64.cpp

@@ -86,10 +86,11 @@ ABIPassingInformation Arm64Classifier::Classify(Compiler*    comp,
             }
             else
             {
-                unsigned alignment = compAppleArm64Abi() ? min(elemSize, TARGET_POINTER_SIZE) : TARGET_POINTER_SIZE;
+                unsigned alignment =
-                m_stackArgSize     = roundUp(m_stackArgSize, alignment);
+                    compAppleArm64Abi() ? min(elemSize, (unsigned)TARGET_POINTER_SIZE) : TARGET_POINTER_SIZE;
-                info = ABIPassingInformation::FromSegment(comp, ABIPassingSegment::OnStack(m_stackArgSize, 0,
+                m_stackArgSize = roundUp(m_stackArgSize, alignment);
-                                                                                           structLayout->GetSize()));
+                info           = ABIPassingInformation::FromSegment(comp, ABIPassingSegment::OnStack(m_stackArgSize, 0,
+                                                                                                     structLayout->GetSize()));
                 m_stackArgSize += roundUp(structLayout->GetSize(), alignment);
                 // After passing any float value on the stack, we should not enregister more float values.
                 m_floatRegs.Clear();

src/coreclr/jit/utils.cpp

@@ -4050,7 +4050,7 @@ T GetSignedMagic(T denom, int* shift /*out*/)
     UT  t;
     T   result_magic;
 
-    absDenom = abs(denom);
+    absDenom = std::abs(denom);
     t        = two_nminus1 + (UT(denom) >> bits_minus_1);
     absNc    = t - 1 - (t % absDenom);        // absolute value of nc
     p        = bits_minus_1;                  // initialize p

src/coreclr/jit/utils.h

@@ -16,7 +16,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #define _UTILS_H_
 
 #include "safemath.h"
-#include "clr_std/type_traits"
+#include <type_traits>
 #include "iallocator.h"
 #include "hostallocator.h"
 #include "cycletimer.h"

src/coreclr/md/ceefilegen/blobfetcher.cpp

@@ -211,7 +211,7 @@ char* CBlobFetcher::MakeNewBlock(unsigned len, unsigned align) {
     pChRet = m_pIndex[m_nIndexUsed].MakeNewBlock(len + pad, 0);
 
     // Did we run out of memory?
-    if (pChRet == NULL &&  m_pIndex[m_nIndexUsed].GetDataLen() == NULL)
+    if (pChRet == NULL &&  m_pIndex[m_nIndexUsed].GetDataLen() == 0)
         return NULL;
 
     if (pChRet == NULL) {

src/coreclr/md/ceefilegen/stdafx.h

@@ -17,6 +17,7 @@
 #include <stdlib.h>		// for qsort
 #include <windows.h>
 #include <time.h>
+#include <algorithm>
 
 #include <corerror.h>
 #include <utilcode.h>
@@ -27,3 +28,6 @@
 
 #include "ceegen.h"
 #include "ceesectionstring.h"
+
+using std::min;
+using std::max;

src/coreclr/md/compiler/import.cpp

@@ -2172,7 +2172,7 @@ STDMETHODIMP RegMeta::GetUserString(          // S_OK or error.
         memcpy(
             wszString,
             userString.GetDataPointer(),
-            min(userString.GetSize(), cbStringSize));
+            min((ULONG)userString.GetSize(), cbStringSize));
         if (cbStringSize < userString.GetSize())
         {
             if ((wszString != NULL) && (cchStringSize > 0))

src/coreclr/md/compiler/stdafx.h

@@ -13,6 +13,7 @@
 
 #include <crtwrap.h>
 #include <winwrap.h>
+#include <algorithm>
 #include <utilcode.h>
 
 #include <cor.h>
@@ -25,4 +26,7 @@
 
 #include "utsem.h"
 
+using std::min;
+using std::max;
+
 #endif  // __STDAFX_H_

src/coreclr/md/enc/rwutil.cpp

@@ -230,7 +230,7 @@ HRESULT HENUMInternal::EnumWithCount(
     }
 
     // we can only fill the minimum of what caller asked for or what we have left
-    cTokens = min ( (pEnum->u.m_ulEnd - pEnum->u.m_ulCur), cMax);
+    cTokens = min ( (ULONG)(pEnum->u.m_ulEnd - pEnum->u.m_ulCur), cMax);
 
     if (pEnum->m_EnumType == MDSimpleEnum)
     {
@@ -296,7 +296,7 @@ HRESULT HENUMInternal::EnumWithCount(
     _ASSERTE(! ((pEnum->u.m_ulEnd - pEnum->u.m_ulCur) % 2) );
 
     // we can only fill the minimum of what caller asked for or what we have left
-    cTokens = min ( (pEnum->u.m_ulEnd - pEnum->u.m_ulCur), cMax * 2);
+    cTokens = min ( (ULONG)(pEnum->u.m_ulEnd - pEnum->u.m_ulCur), cMax * 2);
 
     // get the embedded dynamic array
     TOKENLIST       *pdalist = (TOKENLIST *)&(pEnum->m_cursor);

src/coreclr/md/enc/stdafx.h

@@ -13,6 +13,7 @@
 
 #include <crtwrap.h>
 #include <winwrap.h>
+#include <algorithm>
 #include <utilcode.h>
 
 #include <cor.h>
@@ -26,4 +27,7 @@
 
 #include "utsem.h"
 
+using std::min;
+using std::max;
+
 #endif  // __STDAFX_H__

src/coreclr/md/runtime/stdafx.h

@@ -13,6 +13,7 @@
 
 #include <crtwrap.h>
 #include <winwrap.h>
+#include <algorithm>
 #include <utilcode.h>
 
 #include <cor.h>

src/coreclr/nativeaot/CMakeLists.txt

@@ -1,5 +1,6 @@
 if(WIN32)
   add_definitions(-DUNICODE=1)
+  add_compile_definitions(NOMINMAX)
 endif (WIN32)
 
 if(MSVC)

src/coreclr/nativeaot/Runtime/CMakeLists.txt

@@ -131,7 +131,6 @@ else()
   include_directories(unix)
 
   # sal.h, pshpack/poppack.h
-  add_definitions(-DPAL_STDCPP_COMPAT)
   include_directories(../../pal/inc/rt)
 
   include(CheckIncludeFiles)

src/coreclr/nativeaot/Runtime/CommonMacros.h

@@ -89,16 +89,6 @@ inline bool IS_ALIGNED(T* val, uintptr_t alignment);
 #define ZeroMemory(_dst, _size) memset((_dst), 0, (_size))
 #endif
 
-//-------------------------------------------------------------------------------------------------
-// min/max
-
-#ifndef min
-#define min(_a, _b) ((_a) < (_b) ? (_a) : (_b))
-#endif
-#ifndef max
-#define max(_a, _b) ((_a) < (_b) ? (_b) : (_a))
-#endif
-
 #endif // !DACCESS_COMPILE
 
 //-------------------------------------------------------------------------------------------------

src/coreclr/nativeaot/Runtime/threadstore.cpp

@@ -230,7 +230,7 @@ void SpinWait(int iteration, int usecLimit)
     int64_t ticksPerSecond = PalQueryPerformanceFrequency();
     int64_t endTicks = startTicks + (usecLimit * ticksPerSecond) / 1000000;
 
-    int l = min((unsigned)iteration, 30);
+    int l = iteration >= 0 ? min(iteration, 30): 30;
     for (int i = 0; i < l; i++)
     {
         for (int j = 0; j < (1 << i); j++)

src/coreclr/pal/CMakeLists.txt

@@ -7,7 +7,6 @@ include_directories(${COREPAL_SOURCE_DIR}/src)
 include_directories(${COREPAL_SOURCE_DIR}/../inc)
 
 add_compile_options(-fexceptions)
-add_definitions(-DUSE_STL)
 
 add_subdirectory(src)
 add_subdirectory(tests)

src/coreclr/pal/inc/pal.h

@@ -33,7 +33,6 @@ Abstract:
 #ifndef __PAL_H__
 #define __PAL_H__
 
-#ifdef PAL_STDCPP_COMPAT
 #include <float.h>
 #include <limits.h>
 #include <stddef.h>
@@ -42,12 +41,22 @@ Abstract:
 #include <stdarg.h>
 #include <stdint.h>
 #include <string.h>
+#include <math.h>
 #include <strings.h>
 #include <errno.h>
 #include <ctype.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <wctype.h>
+
+#ifdef __cplusplus
+extern "C++"
+{
+
+#include <new>
+
+}
 #endif
 
 #ifdef  __cplusplus
@@ -175,77 +184,13 @@ extern bool g_arm64_atomics_present;
 #define __has_cpp_attribute(x) (0)
 #endif
 
-#ifndef PAL_STDCPP_COMPAT
+#ifndef FALLTHROUGH
-
+#if __has_cpp_attribute(fallthrough)
-#if __GNUC__
+#define FALLTHROUGH [[fallthrough]]
-
+#else // __has_cpp_attribute(fallthrough)
-typedef __builtin_va_list va_list;
+#define FALLTHROUGH
-
+#endif // __has_cpp_attribute(fallthrough)
-/* We should consider if the va_arg definition here is actually necessary.
+#endif // FALLTHROUGH
-   Could we use the standard va_arg definition? */
-
-#define va_start    __builtin_va_start
-#define va_arg      __builtin_va_arg
-
-#define va_copy     __builtin_va_copy
-#define va_end      __builtin_va_end
-
-#define VOID void
-
-#else // __GNUC__
-
-typedef char * va_list;
-
-#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
-
-#if _MSC_VER >= 1400
-
-#ifdef  __cplusplus
-#define _ADDRESSOF(v)   ( &reinterpret_cast<const char &>(v) )
-#else
-#define _ADDRESSOF(v)   ( &(v) )
-#endif
-
-#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
-#define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
-#define _crt_va_end(ap)      ( ap = (va_list)0 )
-
-#define va_start _crt_va_start
-#define va_arg _crt_va_arg
-#define va_end _crt_va_end
-
-#else  // _MSC_VER
-
-#define va_start(ap,v)    (ap = (va_list) (&(v)) + _INTSIZEOF(v))
-#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
-#define va_end(ap)
-
-#endif // _MSC_VER
-
-#define va_copy(dest,src) (dest = src)
-
-#endif // __GNUC__
-
-#define CHAR_BIT      8
-
-#define SCHAR_MIN   (-128)
-#define SCHAR_MAX     127
-#define UCHAR_MAX     0xff
-
-#define SHRT_MIN    (-32768)
-#define SHRT_MAX      32767
-#define USHRT_MAX     0xffff
-
-#define INT_MIN     (-2147483647 - 1)
-#define INT_MAX       2147483647
-#define UINT_MAX      0xffffffff
-
-// LONG_MIN, LONG_MAX, ULONG_MAX -- use INT32_MIN etc. instead.
-
-#define FLT_MAX 3.402823466e+38F
-#define DBL_MAX 1.7976931348623157e+308
-
-#endif // !PAL_STDCPP_COMPAT
 
 /******************* PAL-Specific Entrypoints *****************************/
 
@@ -256,44 +201,6 @@ BOOL
 PALAPI
 PAL_IsDebuggerPresent();
 
-/* minimum signed 64 bit value */
-#define _I64_MIN    (I64(-9223372036854775807) - 1)
-/* maximum signed 64 bit value */
-#define _I64_MAX      I64(9223372036854775807)
-/* maximum unsigned 64 bit value */
-#define _UI64_MAX     UI64(0xffffffffffffffff)
-
-#define _I8_MAX   SCHAR_MAX
-#define _I8_MIN   SCHAR_MIN
-#define _I16_MAX  SHRT_MAX
-#define _I16_MIN  SHRT_MIN
-#define _I32_MAX  INT_MAX
-#define _I32_MIN  INT_MIN
-#define _UI8_MAX  UCHAR_MAX
-#define _UI8_MIN  UCHAR_MIN
-#define _UI16_MAX USHRT_MAX
-#define _UI16_MIN USHRT_MIN
-#define _UI32_MAX UINT_MAX
-#define _UI32_MIN UINT_MIN
-
-#undef NULL
-
-#if defined(__cplusplus)
-#define NULL    0
-#else
-#define NULL    ((PVOID)0)
-#endif
-
-#if defined(PAL_STDCPP_COMPAT) && !defined(__cplusplus)
-#define nullptr NULL
-#endif // defined(PAL_STDCPP_COMPAT) && !defined(__cplusplus)
-
-#ifndef PAL_STDCPP_COMPAT
-
-typedef __int64 time_t;
-#define _TIME_T_DEFINED
-#endif // !PAL_STDCPP_COMPAT
-
 #define DLL_PROCESS_ATTACH 1
 #define DLL_THREAD_ATTACH  2
 #define DLL_THREAD_DETACH  3
@@ -3934,31 +3841,6 @@ PAL_GetCurrentThreadAffinitySet(SIZE_T size, UINT_PTR* data);
 #endif //FEATURE_PAL_ANSI
 /******************* C Runtime Entrypoints *******************************/
 
-/* Some C runtime functions needs to be reimplemented by the PAL.
-   To avoid name collisions, those functions have been renamed using
-   defines */
-#ifndef PAL_STDCPP_COMPAT
-#define exit          PAL_exit
-#define realloc       PAL_realloc
-#define rand          PAL_rand
-#define time          PAL_time
-#define getenv        PAL_getenv
-#define qsort         PAL_qsort
-#define bsearch       PAL_bsearch
-#define malloc        PAL_malloc
-#define free          PAL_free
-
-#ifdef HOST_AMD64
-#define _mm_getcsr    PAL__mm_getcsr
-#define _mm_setcsr    PAL__mm_setcsr
-#endif // HOST_AMD64
-
-// Forward declare functions that are in header files we can't include yet
-int printf(const char *, ...);
-int vprintf(const char *, va_list);
-
-#endif // !PAL_STDCPP_COMPAT
-
 #ifndef _CONST_RETURN
 #ifdef  __cplusplus
 #define _CONST_RETURN  const
@@ -3971,134 +3853,16 @@ int vprintf(const char *, va_list);
 /* For backwards compatibility */
 #define _WConst_return _CONST_RETURN
 
-#define EOF     (-1)
-
-typedef int errno_t;
-
-#if defined(__WINT_TYPE__)
-typedef __WINT_TYPE__ wint_t;
-#else
-typedef unsigned int wint_t;
-#endif
-
-#ifndef PAL_STDCPP_COMPAT
-PALIMPORT void * __cdecl memcpy(void *, const void *, size_t);
-PALIMPORT int    __cdecl memcmp(const void *, const void *, size_t);
-PALIMPORT void * __cdecl memset(void *, int, size_t);
-PALIMPORT void * __cdecl memmove(void *, const void *, size_t);
-PALIMPORT void * __cdecl memchr(const void *, int, size_t);
-PALIMPORT long long int __cdecl atoll(const char *) MATH_THROW_DECL;
-PALIMPORT size_t __cdecl strlen(const char *);
-PALIMPORT int __cdecl strcmp(const char*, const char *);
-PALIMPORT int __cdecl strncmp(const char*, const char *, size_t);
-PALIMPORT int __cdecl strncasecmp(const char *, const char *, size_t);
-PALIMPORT char * __cdecl strcat(char *, const char *);
-PALIMPORT char * __cdecl strncat(char *, const char *, size_t);
-PALIMPORT char * __cdecl strcpy(char *, const char *);
-PALIMPORT char * __cdecl strncpy(char *, const char *, size_t);
-PALIMPORT char * __cdecl strchr(const char *, int);
-PALIMPORT char * __cdecl strrchr(const char *, int);
-PALIMPORT char * __cdecl strpbrk(const char *, const char *);
-PALIMPORT char * __cdecl strstr(const char *, const char *);
-PALIMPORT char * __cdecl strtok_r(char *, const char *, char **);
-PALIMPORT char * __cdecl strdup(const char*);
-PALIMPORT int __cdecl atoi(const char *);
-PALIMPORT unsigned long __cdecl strtoul(const char *, char **, int);
-PALIMPORT ULONGLONG __cdecl strtoull(const char *, char **, int);
-PALIMPORT double __cdecl atof(const char *);
-PALIMPORT double __cdecl strtod(const char *, char **);
-PALIMPORT size_t strnlen(const char *, size_t);
-PALIMPORT int __cdecl isprint(int);
-PALIMPORT int __cdecl isspace(int);
-PALIMPORT int __cdecl isalpha(int);
-PALIMPORT int __cdecl isalnum(int);
-PALIMPORT int __cdecl isdigit(int);
-PALIMPORT int __cdecl isxdigit(int);
-PALIMPORT int __cdecl tolower(int);
-PALIMPORT int __cdecl toupper(int);
-PALIMPORT int __cdecl iswalpha(wint_t);
-PALIMPORT int __cdecl iswdigit(wint_t);
-PALIMPORT int __cdecl iswupper(wint_t);
-PALIMPORT int __cdecl iswprint(wint_t);
-PALIMPORT int __cdecl iswspace(wint_t);
-PALIMPORT int __cdecl iswxdigit(wint_t);
-PALIMPORT wint_t __cdecl towupper(wint_t);
-PALIMPORT wint_t __cdecl towlower(wint_t);
-PALIMPORT int remove(const char*);
-
-#define SEEK_SET    0
-#define SEEK_CUR    1
-#define SEEK_END    2
-
-/* Locale categories */
-#define LC_ALL          0
-#define LC_COLLATE      1
-#define LC_CTYPE        2
-#define LC_MONETARY     3
-#define LC_NUMERIC      4
-#define LC_TIME         5
-
-#define _IOFBF  0       /* setvbuf should set fully buffered */
-#define _IOLBF  1       /* setvbuf should set line buffered */
-#define _IONBF  2       /* setvbuf should set unbuffered */
-
-struct _FILE;
-
-#ifdef DEFINE_DUMMY_FILE_TYPE
-#define FILE _PAL_FILE
-struct _PAL_FILE;
-#else
-typedef _FILE FILE;
-#endif // DEFINE_DUMMY_FILE_TYPE
-
-PALIMPORT int __cdecl fclose(FILE *);
-PALIMPORT int __cdecl fflush(FILE *);
-PALIMPORT size_t __cdecl fwrite(const void *, size_t, size_t, FILE *);
-PALIMPORT size_t __cdecl fread(void *, size_t, size_t, FILE *);
-PALIMPORT char * __cdecl fgets(char *, int, FILE *);
-PALIMPORT int __cdecl fputs(const char *, FILE *);
-PALIMPORT int __cdecl fprintf(FILE *, const char *, ...);
-PALIMPORT int __cdecl vfprintf(FILE *, const char *, va_list);
-PALIMPORT int __cdecl fseek(FILE *, LONG, int);
-PALIMPORT LONG __cdecl ftell(FILE *);
-PALIMPORT int __cdecl ferror(FILE *);
-PALIMPORT FILE * __cdecl fopen(const char *, const char *);
-PALIMPORT int __cdecl setvbuf(FILE *stream, char *, int, size_t);
-
-// We need a PAL shim for errno and the standard streams as it's not possible to replicate these definition from the standard library
-// in all cases. Instead, we shim it and implement the PAL function where we can include the standard headers.
-// When we allow people to include the standard headers, then we can remove this.
-
-PALIMPORT DLLEXPORT int * __cdecl PAL_errno();
-#define errno  (*PAL_errno())
-
-// Only provide a prototype for the PAL forwarders for the standard streams if we are not including the standard headers.
-#ifndef DEFINE_DUMMY_FILE_TYPE
-
-extern "C" PALIMPORT DLLEXPORT FILE* __cdecl PAL_stdout();
-extern "C" PALIMPORT DLLEXPORT FILE* __cdecl PAL_stdin();
-extern "C" PALIMPORT DLLEXPORT FILE* __cdecl PAL_stderr();
-#define stdout PAL_stdout()
-#define stdin PAL_stdin()
-#define stderr PAL_stderr()
-
-#endif
-
-#ifdef DEFINE_DUMMY_FILE_TYPE
-#undef FILE
-#endif
-#endif // PAL_STDCPP_COMPAT
-
 /* _TRUNCATE */
 #if !defined(_TRUNCATE)
 #define _TRUNCATE ((size_t)-1)
 #endif
 
+// errno_t is only defined when the Secure CRT Extensions library is available (which no standard library that we build with implements anyway)
+typedef int errno_t;
+
 PALIMPORT DLLEXPORT errno_t __cdecl memcpy_s(void *, size_t, const void *, size_t) THROW_DECL;
 PALIMPORT errno_t __cdecl memmove_s(void *, size_t, const void *, size_t);
-PALIMPORT DLLEXPORT int __cdecl strcasecmp(const char *, const char *);
-PALIMPORT char * __cdecl _gcvt_s(char *, int, double, int);
-PALIMPORT int __cdecl __iscsym(int);
 PALIMPORT DLLEXPORT int __cdecl _wcsicmp(const WCHAR *, const WCHAR*);
 PALIMPORT int __cdecl _wcsnicmp(const WCHAR *, const WCHAR *, size_t);
 PALIMPORT DLLEXPORT int __cdecl _vsnprintf_s(char *, size_t, size_t, const char *, va_list);
@@ -4125,10 +3889,7 @@ PALIMPORT DLLEXPORT double __cdecl PAL_wcstod(const WCHAR *, WCHAR **);
 PALIMPORT errno_t __cdecl _wcslwr_s(WCHAR *, size_t sz);
 PALIMPORT DLLEXPORT errno_t __cdecl _i64tow_s(long long, WCHAR *, size_t, int);
 PALIMPORT int __cdecl _wtoi(const WCHAR *);
-
-#ifndef DEFINE_DUMMY_FILE_TYPE
 PALIMPORT FILE * __cdecl _wfopen(const WCHAR *, const WCHAR *);
-#endif
 
 inline int _stricmp(const char* a, const char* b)
 {
@@ -4145,6 +3906,10 @@ inline char* _strdup(const char* a)
     return strdup(a);
 }
 
+// Define the MSVC implementation of the alloca concept.
+// As this allocates on the current stack frame, use a macro instead of an inline function.
+#define _alloca(x) alloca(x)
+
 #ifdef __cplusplus
 extern "C++" {
 inline WCHAR *PAL_wcschr(WCHAR* S, WCHAR C)
@@ -4178,11 +3943,6 @@ unsigned int __cdecl _rotl(unsigned int value, int shift)
 }
 #endif // !__has_builtin(_rotl)
 
-// On 64 bit unix, make the long an int.
-#ifdef HOST_64BIT
-#define _lrotl _rotl
-#endif
-
 #if !__has_builtin(_rotr)
 
 /*++
@@ -4205,137 +3965,7 @@ unsigned int __cdecl _rotr(unsigned int value, int shift)
 
 #endif // !__has_builtin(_rotr)
 
-PALIMPORT int __cdecl abs(int);
+PALIMPORT DLLEXPORT char * __cdecl PAL_getenv(const char *);
-// clang complains if this is declared with __int64
-PALIMPORT long long __cdecl llabs(long long);
-#ifndef PAL_STDCPP_COMPAT
-
-PALIMPORT double __cdecl copysign(double, double);
-PALIMPORT double __cdecl acos(double);
-PALIMPORT double __cdecl acosh(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl asin(double);
-PALIMPORT double __cdecl asinh(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl atan(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl atanh(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl atan2(double, double);
-PALIMPORT double __cdecl cbrt(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl ceil(double);
-PALIMPORT double __cdecl cos(double);
-PALIMPORT double __cdecl cosh(double);
-PALIMPORT double __cdecl exp(double);
-PALIMPORT double __cdecl fabs(double);
-PALIMPORT double __cdecl floor(double);
-PALIMPORT double __cdecl fmod(double, double);
-PALIMPORT double __cdecl fma(double, double, double) MATH_THROW_DECL;
-PALIMPORT int __cdecl ilogb(double);
-PALIMPORT double __cdecl log(double);
-PALIMPORT double __cdecl log2(double) MATH_THROW_DECL;
-PALIMPORT double __cdecl log10(double);
-PALIMPORT double __cdecl modf(double, double*);
-PALIMPORT double __cdecl pow(double, double);
-PALIMPORT double __cdecl sin(double);
-PALIMPORT void __cdecl sincos(double, double*, double*);
-#ifdef __APPLE__
-PALIMPORT void __cdecl __sincos(double, double*, double*);
-#endif
-PALIMPORT double __cdecl sinh(double);
-PALIMPORT double __cdecl sqrt(double);
-PALIMPORT double __cdecl tan(double);
-PALIMPORT double __cdecl tanh(double);
-PALIMPORT double __cdecl trunc(double);
-
-PALIMPORT float __cdecl copysignf(float, float);
-PALIMPORT float __cdecl acosf(float);
-PALIMPORT float __cdecl acoshf(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl asinf(float);
-PALIMPORT float __cdecl asinhf(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl atanf(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl atanhf(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl atan2f(float, float);
-PALIMPORT float __cdecl cbrtf(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl ceilf(float);
-PALIMPORT float __cdecl cosf(float);
-PALIMPORT float __cdecl coshf(float);
-PALIMPORT float __cdecl expf(float);
-PALIMPORT float __cdecl fabsf(float);
-PALIMPORT float __cdecl floorf(float);
-PALIMPORT float __cdecl fmodf(float, float);
-PALIMPORT float __cdecl fmaf(float, float, float) MATH_THROW_DECL;
-PALIMPORT int __cdecl ilogbf(float);
-PALIMPORT float __cdecl logf(float);
-PALIMPORT float __cdecl log2f(float) MATH_THROW_DECL;
-PALIMPORT float __cdecl log10f(float);
-PALIMPORT float __cdecl modff(float, float*);
-PALIMPORT float __cdecl powf(float, float);
-PALIMPORT float __cdecl sinf(float);
-PALIMPORT void __cdecl sincosf(float, float*, float*);
-#ifdef __APPLE__
-PALIMPORT void __cdecl __sincosf(float, float*, float*);
-#endif
-PALIMPORT float __cdecl sinhf(float);
-PALIMPORT float __cdecl sqrtf(float);
-PALIMPORT float __cdecl tanf(float);
-PALIMPORT float __cdecl tanhf(float);
-PALIMPORT float __cdecl truncf(float);
-#endif // !PAL_STDCPP_COMPAT
-
-#ifndef PAL_STDCPP_COMPAT
-
-#ifdef __cplusplus
-extern "C++" {
-
-inline __int64 abs(__int64 _X) {
-    return llabs(_X);
-}
-
-#ifdef __APPLE__
-inline __int64 abs(SSIZE_T _X) {
-    return llabs((__int64)_X);
-}
-#endif
-
-}
-#endif
-
-PALIMPORT DLLEXPORT void * __cdecl malloc(size_t);
-PALIMPORT DLLEXPORT void   __cdecl free(void *);
-PALIMPORT DLLEXPORT void * __cdecl realloc(void *, size_t);
-
-#if defined(_MSC_VER)
-#define alloca _alloca
-#else
-#define _alloca alloca
-#endif //_MSC_VER
-
-#define alloca  __builtin_alloca
-
-#define max(a, b) (((a) > (b)) ? (a) : (b))
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-
-#endif // !PAL_STDCPP_COMPAT
-
-PALIMPORT PAL_NORETURN void __cdecl exit(int);
-
-#ifndef PAL_STDCPP_COMPAT
-
-PALIMPORT DLLEXPORT void __cdecl qsort(void *, size_t, size_t, int(__cdecl *)(const void *, const void *));
-PALIMPORT DLLEXPORT void * __cdecl bsearch(const void *, const void *, size_t, size_t,
-    int(__cdecl *)(const void *, const void *));
-
-PALIMPORT time_t __cdecl time(time_t *);
-
-#endif // !PAL_STDCPP_COMPAT
-
-/* Maximum value that can be returned by the rand function. */
-
-#ifndef PAL_STDCPP_COMPAT
-#define RAND_MAX 0x7fff
-#endif // !PAL_STDCPP_COMPAT
-
-PALIMPORT int __cdecl rand(void);
-PALIMPORT void __cdecl srand(unsigned int);
-
-PALIMPORT DLLEXPORT char * __cdecl getenv(const char *);
 PALIMPORT DLLEXPORT int __cdecl _putenv(const char *);
 
 #define ERANGE          34
@@ -4366,15 +3996,7 @@ PALAPI
 PAL_GetCpuTickCount();
 #endif // PAL_PERF
 
-/******************* PAL functions for SIMD extensions *****************/
+/******************* PAL functions for exceptions *******/
-
-PALIMPORT
-unsigned int _mm_getcsr(void);
-
-PALIMPORT
-void _mm_setcsr(unsigned int i);
-
-/******************* PAL functions for CPU capability detection *******/
 
 #ifdef __cplusplus
 

src/coreclr/pal/inc/pal_mstypes.h

@@ -64,13 +64,15 @@ extern "C" {
 #define _cdecl
 #define CDECL
 
-// On ARM __fastcall is ignored and causes a compile error
+// Some platforms (such as FreeBSD) define the __fastcall macro
-#if !defined(PAL_STDCPP_COMPAT) || defined(__arm__)
+// on all targets, even when using it will fail.
-#  undef __fastcall
+// Undefine it here so we can use it on all platforms without error.
-#  undef _fastcall
+#ifdef __fastcall
-#  define __fastcall
+#undef __fastcall
-#  define _fastcall
+#endif
-#endif // !defined(PAL_STDCPP_COMPAT) || defined(__arm__)
+
+#define __fastcall
+#define _fastcall
 
 #endif  // !defined(__i386__)
 
@@ -101,7 +103,9 @@ extern "C" {
 #else
 
 #define PALIMPORT
+#ifndef DLLEXPORT
 #define DLLEXPORT __attribute__((visibility("default")))
+#endif
 #define PAL_NORETURN    __attribute__((noreturn))
 
 #endif
@@ -206,21 +210,6 @@ extern "C" {
 
 #endif // _MSC_VER
 
-#ifndef PAL_STDCPP_COMPAT
-// Defined in gnu's types.h. For non PAL_IMPLEMENTATION system
-// includes are not included, so we need to define them.
-#ifndef PAL_IMPLEMENTATION
-
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-
-#endif // PAL_IMPLEMENTATION
 
 #ifndef _MSC_VER
 
@@ -229,7 +218,6 @@ typedef long double LONG_DOUBLE;
 #endif
 
 #endif // _MSC_VER
-#endif // !PAL_STDCPP_COMPAT
 
 typedef void VOID;
 
@@ -565,49 +553,10 @@ static_assert(sizeof(SSIZE_T) == sizeof(void*), "SSIZE_T should be pointer sized
 #define SSIZE_T_MIN (ssize_t)I64(0x8000000000000000)
 #endif
 
-#ifndef PAL_STDCPP_COMPAT
-#ifdef HOST_64BIT
-typedef unsigned long size_t;
-typedef long ssize_t;
-typedef long ptrdiff_t;
-#else // !HOST_64BIT
-typedef unsigned int size_t;
-typedef int ptrdiff_t;
-#endif // !HOST_64BIT
-#endif // !PAL_STDCPP_COMPAT
-#define _SIZE_T_DEFINED
-
 typedef LONG_PTR LPARAM;
 
-#define _PTRDIFF_T_DEFINED
-#ifdef _MINGW_
-// We need to define _PTRDIFF_T to make sure ptrdiff_t doesn't get defined
-// again by system headers - but only for MinGW.
-#define _PTRDIFF_T
-#endif
-
 typedef char16_t WCHAR;
 
-#ifndef PAL_STDCPP_COMPAT
-
-#if defined(__linux__)
-#ifdef HOST_64BIT
-typedef long int intptr_t;
-typedef unsigned long int uintptr_t;
-#else // !HOST_64BIT
-typedef int intptr_t;
-typedef unsigned int uintptr_t;
-#endif // !HOST_64BIT
-#else
-typedef long int intptr_t;
-typedef unsigned long int uintptr_t;
-#endif
-
-#endif // PAL_STDCPP_COMPAT
-
-#define _INTPTR_T_DEFINED
-#define _UINTPTR_T_DEFINED
-
 typedef DWORD LCID;
 typedef PDWORD PLCID;
 typedef WORD LANGID;

src/coreclr/pal/inc/rt/cpp/assert.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File:  assert.h
-//
-// ===========================================================================
-// dummy assert.h for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/cstdlib

@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//
-// <OWNER>clrosdev</OWNER>
-//
-// ===========================================================================
-// File: cstdlib
-//
-// ===========================================================================
-// dummy cstdlib for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/ctype.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File: ctype.h
-//
-// ===========================================================================
-// dummy ctype.h for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/emmintrin.h

@@ -1,128 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-// From llvm-3.9/clang-3.9.1 emmintrin.h:
-
-/*===---- emmintrin.h - SSE2 intrinsics ------------------------------------===
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- *===-----------------------------------------------------------------------===
- */
-
-#include "palrt.h"
-#ifdef __GNUC__
-#ifndef __EMMINTRIN_H
-#define __IMMINTRIN_H
-
-typedef long long __m128i __attribute__((__vector_size__(16)));
-
-typedef unsigned long long __v2du __attribute__ ((__vector_size__ (16)));
-typedef short __v8hi __attribute__((__vector_size__(16)));
-typedef char __v16qi __attribute__((__vector_size__(16)));
-
-
-/* Define the default attribute for the functions in this file. */
-#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, NODEBUG_ATTRIBUTE))
-
-/// \brief Performs a bitwise OR of two 128-bit integer vectors.
-///
-/// \headerfile <x86intrin.h>
-///
-/// This intrinsic corresponds to the \c VPOR / POR instruction.
-///
-/// \param __a
-///    A 128-bit integer vector containing one of the source operands.
-/// \param __b
-///    A 128-bit integer vector containing one of the source operands.
-/// \returns A 128-bit integer vector containing the bitwise OR of the values
-///    in both operands.
-static __inline__ __m128i __DEFAULT_FN_ATTRS
-_mm_or_si128(__m128i __a, __m128i __b)
-{
-  return (__m128i)((__v2du)__a | (__v2du)__b);
-}
-
-/// \brief Compares each of the corresponding 16-bit values of the 128-bit
-///    integer vectors for equality. Each comparison yields 0h for false, FFFFh
-///    for true.
-///
-/// \headerfile <x86intrin.h>
-///
-/// This intrinsic corresponds to the \c VPCMPEQW / PCMPEQW instruction.
-///
-/// \param __a
-///    A 128-bit integer vector.
-/// \param __b
-///    A 128-bit integer vector.
-/// \returns A 128-bit integer vector containing the comparison results.
-static __inline__ __m128i __DEFAULT_FN_ATTRS
-_mm_cmpeq_epi16(__m128i __a, __m128i __b)
-{
-  return (__m128i)((__v8hi)__a == (__v8hi)__b);
-}
-
-/// \brief Moves packed integer values from an unaligned 128-bit memory location
-///    to elements in a 128-bit integer vector.
-///
-/// \headerfile <x86intrin.h>
-///
-/// This intrinsic corresponds to the \c VMOVDQU / MOVDQU instruction.
-///
-/// \param __p
-///    A pointer to a memory location containing integer values.
-/// \returns A 128-bit integer vector containing the moved values.
-static __inline__ __m128i __DEFAULT_FN_ATTRS
-_mm_loadu_si128(__m128i const *__p)
-{
-  struct __loadu_si128 {
-    __m128i __v;
-  } __attribute__((__packed__, __may_alias__));
-  return ((struct __loadu_si128*)__p)->__v;
-}
-
-/// \brief Initializes all values in a 128-bit vector of [8 x i16] with the
-///    specified 16-bit value.
-///
-/// \headerfile <x86intrin.h>
-///
-/// This intrinsic is a utility function and does not correspond to a specific
-///    instruction.
-///
-/// \param __w
-///    A 16-bit value used to initialize the elements of the destination integer
-///    vector.
-/// \returns An initialized 128-bit vector of [8 x i16] with all elements
-///    containing the value provided in the operand.
-static __inline__ __m128i __DEFAULT_FN_ATTRS
-_mm_set1_epi16(short __w)
-{
-  return (__m128i)(__v8hi){ __w, __w, __w, __w, __w, __w, __w, __w };
-}
-
-static __inline__ int __DEFAULT_FN_ATTRS
-_mm_movemask_epi8(__m128i __a)
-{
-  return __builtin_ia32_pmovmskb128((__v16qi)__a);
-}
-
-#undef __DEFAULT_FN_ATTRS
-
-#endif /* __EMMINTRIN_H */
-#endif // __GNUC__

src/coreclr/pal/inc/rt/cpp/fcntl.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File: fcntl.h
-//
-// ===========================================================================
-// dummy fcntl.h for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/float.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File: float.h
-//
-// ===========================================================================
-// dummy float.h for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/limits.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File: limits.h
-//
-// ===========================================================================
-// dummy limits.h for PAL
-
-#include "palrt.h"

src/coreclr/pal/inc/rt/cpp/malloc.h

@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-
-//
-// ===========================================================================
-// File: malloc.h
-//
-// ===========================================================================
-// dummy malloc.h for PAL
-
-#include "palrt.h"