1
0
Fork 0
mirror of https://github.com/VSadov/Satori.git synced 2025-06-11 10:18:21 +09:00

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)
This commit is contained in:
Jeremy Koritzinsky 2024-04-03 20:31:21 -07:00 committed by GitHub
parent 01f039ce1d
commit 5c4e2a301e
Signed by: github
GPG key ID: B5690EEEBB952194
240 changed files with 559 additions and 5127 deletions

View file

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

View file

@ -220,6 +220,12 @@ endfunction(convert_to_absolute_path)
function(preprocess_file inputFilename outputFilename) function(preprocess_file inputFilename outputFilename)
get_compile_definitions(PREPROCESS_DEFINITIONS) get_compile_definitions(PREPROCESS_DEFINITIONS)
get_include_directories(PREPROCESS_INCLUDE_DIRECTORIES) 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) if (MSVC)
add_custom_command( add_custom_command(
OUTPUT ${outputFilename} OUTPUT ${outputFilename}

View file

@ -202,11 +202,12 @@ if(CLR_CMAKE_HOST_UNIX)
add_subdirectory(debug/createdump) 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)) 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) set (NATIVE_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/nativeresources)
include_directories(${NATIVE_RESOURCE_DIR}) 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 # given Windows .rc file. The target C++ file path is returned in the
# variable specified by the TARGET_FILE parameter. # variable specified by the TARGET_FILE parameter.
function(build_resources SOURCE TARGET_NAME TARGET_FILE) 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) set(PREPROCESSED_SOURCE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.rc.i)
preprocess_file(${SOURCE} ${PREPROCESSED_SOURCE}) preprocess_file(${SOURCE} ${PREPROCESSED_SOURCE})

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -768,7 +768,7 @@ public:
// //
// Operators to emulate Pointer semantics. // 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() static VMPTR_This NullPtr()
{ {

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -3113,7 +3113,7 @@ void gc_history_global::print()
uint32_t limit_time_to_uint32 (uint64_t time) 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; 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]; 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 = 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)); 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. // 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)) (n_heaps != dynamic_heap_count_data.last_n_heaps))
{ {
int spin_count = 1024; 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) 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) 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 #endif //MULTIPLE_HEAPS
#ifdef USE_REGIONS #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); set_region_gen_num (seg, gen_num_for_region);
heap_segment_plan_gen_num (seg) = gen_num_for_region; heap_segment_plan_gen_num (seg) = gen_num_for_region;
heap_segment_swept_in_plan (seg) = false; heap_segment_swept_in_plan (seg) = false;
@ -13300,7 +13300,7 @@ void gc_heap::distribute_free_regions()
const int i = 0; const int i = 0;
const int n_heaps = 1; const int n_heaps = 1;
#endif //MULTIPLE_HEAPS #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; int kind = gen >= loh_generation;
size_t budget_gen_in_region_units = (budget_gen + (region_size[kind] - 1)) / region_size[kind]; 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)); 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) if (ephemeral_elapsed >= DECOMMIT_TIME_STEP_MILLISECONDS)
{ {
gc_last_ephemeral_decommit_time = dd_time_clock (dd0); 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); 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); size_t aligned_limit = align_on_segment_hard_limit (limit);
uint32_t nhp_oh = (uint32_t)(aligned_limit / min_segment_size_hard_limit); uint32_t nhp_oh = (uint32_t)(aligned_limit / min_segment_size_hard_limit);
nhp = min (nhp_oh, nhp); nhp = min (nhp_oh, nhp);
return (max (nhp, 1)); return (max (nhp, 1u));
} }
uint32_t gc_heap::adjust_heaps_hard_limit (uint32_t nhp) uint32_t gc_heap::adjust_heaps_hard_limit (uint32_t nhp)
@ -14300,7 +14300,7 @@ gc_heap::init_semi_shared()
#endif //!USE_REGIONS #endif //!USE_REGIONS
#ifdef MULTIPLE_HEAPS #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 #ifdef DYNAMIC_HEAP_COUNT
if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes)
{ {
@ -14322,7 +14322,7 @@ gc_heap::init_semi_shared()
} }
#else //MULTIPLE_HEAPS #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_total_size = mark_list_size;
g_mark_list = make_mark_list (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)) 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; 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_mem_load = current_memory_load;
bgc_tuning::last_stepping_bgc_count = 0; bgc_tuning::last_stepping_bgc_count = 0;
dprintf (BGC_TUNING_LOG, ("current ml: %d, %d to goal, interval: %d", 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", dprintf (GTC_LOG, ("min av: %zd, 10%% gen2: %zd, 3%% mem: %zd",
min_mem_based_on_available, ten_percent_size, three_percent_mem)); min_mem_based_on_available, ten_percent_size, three_percent_mem));
#endif //SIMPLE_DPRINTF #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 inline
uint64_t gc_heap::min_high_fragmentation_threshold(uint64_t available_mem, uint32_t num_heaps) 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 { 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, // to avoid spikes in mem usage due to short terms fluctuations in survivorship,
// apply some smoothing. // 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 desired_total = desired_per_heap * n_heaps;
size_t new_smoothed_desired_total = desired_total / smoothing + ((smoothed_desired_total[gen] / smoothing) * (smoothing - 1)); 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. //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); generation* gn = generation_of (gen_number);
if (settings.compaction) if (settings.compaction)
@ -22371,7 +22371,7 @@ void gc_heap::gc1()
if (alloc_contexts_used >= 1) if (alloc_contexts_used >= 1)
{ {
allocation_quantum = Align (min ((size_t)CLR_SIZE, 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)); get_alignment_constant(FALSE));
dprintf (3, ("New allocation quantum: %zd(0x%zx)", allocation_quantum, allocation_quantum)); dprintf (3, ("New allocation quantum: %zd(0x%zx)", allocation_quantum, allocation_quantum));
} }
@ -28594,7 +28594,7 @@ recheck:
if (grow_mark_array_p) if (grow_mark_array_p)
{ {
// Try to grow the array. // 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) if ((new_size * sizeof(mark)) > 100*1024)
{ {
@ -28934,7 +28934,7 @@ recheck:
overflow_p = TRUE; overflow_p = TRUE;
// Try to grow the array. // Try to grow the array.
size_t new_size = 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) 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; gc_heap* hp = pGenGCHeap;
#endif //MULTIPLE_HEAPS #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 older_gen_size = dd_current_size (dd) + (dd_desired_allocation (dd) - dd_new_allocation (dd));
size_t promoted = hp->total_promoted_bytes; 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_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)); 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)); assert (gen_num == heap_segment_gen_num (region));
int plan_gen_num = heap_segment_plan_gen_num (region); int plan_gen_num = heap_segment_plan_gen_num (region);
bool is_demoted = (region->flags & heap_segment_flags_demoted) != 0; 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)) 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); generation_allocator (older_gen)->copy_to_alloc_list (r_free_list);
r_free_list_space = generation_free_list_space (older_gen); 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(); reset_pinned_queue_bos();
#ifndef USE_REGIONS #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); generation* gen = generation_of (gen_number);
uint8_t* low = generation_allocation_start (generation_of (gen_number-1)); uint8_t* low = generation_allocation_start (generation_of (gen_number-1));
uint8_t* high = heap_segment_allocated (ephemeral_heap_segment); uint8_t* high = heap_segment_allocated (ephemeral_heap_segment);
@ -42454,8 +42454,8 @@ adjust:
#endif // SEG_REUSE_STATS #endif // SEG_REUSE_STATS
if (free_space_items) 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 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, memcpy (ordered_free_space_indices,
saved_ordered_free_space_indices, saved_ordered_free_space_indices,
sizeof(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)); 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 = size_t gen0_max_size =
#ifdef MULTIPLE_HEAPS #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 #else //MULTIPLE_HEAPS
( (
#ifdef BACKGROUND_GC #ifdef BACKGROUND_GC
gc_can_use_concurrent ? gc_can_use_concurrent ?
6*1024*1024 : 6*1024*1024 :
#endif //BACKGROUND_GC #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 #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. // TODO: gen0_max_size has a 200mb cap; gen1_max_size should also have a cap.
size_t gen1_max_size = (size_t) size_t gen1_max_size = (size_t)
#ifdef MULTIPLE_HEAPS #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 #else //MULTIPLE_HEAPS
( (
#ifdef BACKGROUND_GC #ifdef BACKGROUND_GC
gc_can_use_concurrent ? gc_can_use_concurrent ?
6*1024*1024 : 6*1024*1024 :
#endif //BACKGROUND_GC #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 #endif //MULTIPLE_HEAPS
@ -43562,7 +43562,7 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd,
} }
else 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)); 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; size_t survivors = out;
cst = float (survivors) / float (dd_begin_data_size (dd)); cst = float (survivors) / float (dd_begin_data_size (dd));
f = surv_to_growth (cst, limit, max_limit); 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, new_allocation = linear_allocation_model (allocation_fraction, new_allocation,
dd_desired_allocation (dd), time_since_previous_collection_secs); 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; return result;
#else //USE_REGIONS #else //USE_REGIONS
if (0 == gen_number) 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))), generation_plan_allocation_start (generation_of (gen_number))),
(int)Align (min_obj_size)); (ptrdiff_t)Align (min_obj_size));
else else
{ {
generation* gen = generation_of (gen_number); generation* gen = generation_of (gen_number);
@ -43751,9 +43751,9 @@ size_t gc_heap::generation_size (int gen_number)
return result; return result;
#else //USE_REGIONS #else //USE_REGIONS
if (0 == gen_number) 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))), generation_allocation_start (generation_of (gen_number))),
(int)Align (min_obj_size)); (ptrdiff_t)Align (min_obj_size));
else else
{ {
generation* gen = generation_of (gen_number); generation* gen = generation_of (gen_number);
@ -43835,7 +43835,7 @@ size_t gc_heap::trim_youngest_desired (uint32_t memory_load,
} }
else 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); 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); dynamic_data* dd0 = dynamic_data_of (0);
ptrdiff_t desired_allocation = dd_new_allocation (dd0) + 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; loh_size_threshold;
size_t slack_space = 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 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 // 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); decommit_size = min (decommit_size, max_decommit_size);
slack_space = heap_segment_committed (ephemeral_heap_segment) - heap_segment_allocated (ephemeral_heap_segment) - 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; soh_withheld_budget = soh_withheld_budget / gc_heap::n_heaps;
loh_withheld_budget = loh_withheld_budget / gc_heap::n_heaps; loh_withheld_budget = loh_withheld_budget / gc_heap::n_heaps;
#endif #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)); soh_withheld_budget = Align(soh_withheld_budget, get_alignment_constant (TRUE));
loh_withheld_budget = Align(loh_withheld_budget, get_alignment_constant (FALSE)); loh_withheld_budget = Align(loh_withheld_budget, get_alignment_constant (FALSE));
#ifdef MULTIPLE_HEAPS #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 (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!", 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), 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 = ((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 ? gc_heap::gc_thread_no_affinitize_p = (gc_heap::heap_hard_limit ?
!affinity_config_specified_p : (GCConfig::GetNoAffinitize() != 0)); !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. * 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 - * 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. * 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 #ifdef FEATURE_STRUCTALIGN
/* /*
* The above assumed FEATURE_STRUCTALIGN is not turned on for platforms where USE_REGIONS is supported, otherwise it is possible * 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. * function.
* *
* Note that ComputeMaxStructAlignPad is defined to be 0 if FEATURE_STRUCTALIGN is turned off. * 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.inc_recheck_threshold = 5;
gc_heap::dynamic_heap_count_data.dec_failure_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. // 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)); 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", 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; gc_heap* hpt = 0;
#endif //MULTIPLE_HEAPS #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); dynamic_data* dd = hpt->dynamic_data_of (generation);
#ifdef BACKGROUND_GC #ifdef BACKGROUND_GC
@ -49907,7 +49907,7 @@ size_t
GCHeap::GarbageCollectTry (int generation, BOOL low_memory_p, int mode) GCHeap::GarbageCollectTry (int generation, BOOL low_memory_p, int mode)
{ {
int gen = (generation < 0) ? int gen = (generation < 0) ?
max_generation : min (generation, max_generation); max_generation : min (generation, (int)max_generation);
gc_reason reason = reason_empty; gc_reason reason = reason_empty;
@ -51262,11 +51262,11 @@ size_t gc_heap::get_gen0_min_size()
#ifdef SERVER_GC #ifdef SERVER_GC
// performance data seems to indicate halving the size results // performance data seems to indicate halving the size results
// in optimal perf. Ask for adjusted gen0 size. // 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. // 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. // 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", dprintf (1, ("cache: %zd-%zd",
GCToOSInterface::GetCacheSizePerLogicalCpu(FALSE), GCToOSInterface::GetCacheSizePerLogicalCpu(FALSE),
GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE))); GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE)));
@ -51274,8 +51274,8 @@ size_t gc_heap::get_gen0_min_size()
int n_heaps = gc_heap::n_heaps; int n_heaps = gc_heap::n_heaps;
#else //SERVER_GC #else //SERVER_GC
size_t trueSize = GCToOSInterface::GetCacheSizePerLogicalCpu(TRUE); 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; int n_heaps = 1;
#endif //SERVER_GC #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 (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes)
{ {
// if we are asked to be stingy with memory, limit gen 0 size // 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 #endif //DYNAMIC_HEAP_COUNT
@ -51904,7 +51904,7 @@ CFinalize::UpdatePromotedGenerations (int gen, BOOL gen_0_empty_p)
// it was promoted or not // it was promoted or not
if (gen_0_empty_p) 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)]; 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) if (is_initialization)
#endif //USE_REGIONS #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(); uint32_t highmem_th_from_config = (uint32_t)GCConfig::GetGCHighMemPercent();
if (highmem_th_from_config) 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 #ifdef FEATURE_EVENT_TRACE
high_mem_percent_from_config = highmem_th_from_config; high_mem_percent_from_config = highmem_th_from_config;
#endif //FEATURE_EVENT_TRACE #endif //FEATURE_EVENT_TRACE

View file

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

View file

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

View file

@ -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. // GC expects the size of ObjHeader (extra void*) to be included in the size.
baseSize = baseSize + sizeof(ObjHeader); baseSize = baseSize + sizeof(ObjHeader);
// Add padding as necessary. GC requires the object size to be at least MIN_OBJECT_SIZE. // 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_componentSize = 0; // Array component size
My_MethodTable.m_MT.m_flags = MTFlag_ContainsPointers; My_MethodTable.m_MT.m_flags = MTFlag_ContainsPointers;

View file

@ -51,7 +51,7 @@
<PrecompiledHeader>Use</PrecompiledHeader> <PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel> <WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization> <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> <SDLCheck>true</SDLCheck>
<PrecompiledHeaderFile>common.h</PrecompiledHeaderFile> <PrecompiledHeaderFile>common.h</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories>
@ -68,7 +68,7 @@
<Optimization>MaxSpeed</Optimization> <Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions> <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> <SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>.;..;..\env</AdditionalIncludeDirectories>
</ClCompile> </ClCompile>
@ -109,4 +109,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets"> <ImportGroup Label="ExtensionTargets">
</ImportGroup> </ImportGroup>
</Project> </Project>

View file

@ -45,16 +45,6 @@
#define NOINLINE __attribute__((noinline)) #define NOINLINE __attribute__((noinline))
#endif #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 #endif // VXSORT_DEFS_H

View file

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

View file

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

View file

@ -1914,7 +1914,7 @@ BYTE* PrettyPrintCABlobValue(PCCOR_SIGNATURE &typePtr,
for(n=0; n < numElements; n++) for(n=0; n < numElements; n++)
{ {
if(n) appendStr(out," "); 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); float df = (float)atof(str);
// Must compare as underlying bytes, not floating point otherwise optimizer will // 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!!!! // 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," "); if(n) appendStr(out," ");
char *pch; char *pch;
_gcvt_s(str,64,*((double*)dataPtr), 17); sprintf_s(str, 64, "%.*g", 17, *((double*)dataPtr));
double df = strtod(str, &pch); double df = strtod(str, &pch);
// Must compare as underlying bytes, not floating point otherwise optimizer will // 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!!!! // 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: case ELEMENT_TYPE_R4:
{ {
char szf[32]; 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); float df = (float)atof(szf);
// Must compare as underlying bytes, not floating point otherwise optimizer will // 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!!!! // 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: case ELEMENT_TYPE_R8:
{ {
char szf[32], *pch; 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); double df = strtod(szf, &pch); //atof(szf);
szf[31]=0; szf[31]=0;
// Must compare as underlying bytes, not floating point otherwise optimizer will // Must compare as underlying bytes, not floating point otherwise optimizer will

View file

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

View file

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

View file

@ -23,7 +23,16 @@
#ifndef AllocaCheck_h #ifndef AllocaCheck_h
#define 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) #if defined(assert) && !defined(_ASSERTE)
#define _ASSERTE assert #define _ASSERTE assert

View file

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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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

View file

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

View file

@ -352,7 +352,7 @@ inline void DbgStateLockData::LockTaken(DbgStateLockType dbgStateLockType,
// Remember as many of these new entrances in m_rgTakenLockInfos as we can // Remember as many of these new entrances in m_rgTakenLockInfos as we can
for (UINT i = cCombinedLocks; for (UINT i = cCombinedLocks;
i < min (ARRAY_SIZE(m_rgTakenLockInfos), cCombinedLocks + cTakes); i < std::min (ARRAY_SIZE(m_rgTakenLockInfos), (size_t)(cCombinedLocks + cTakes));
i++) i++)
{ {
m_rgTakenLockInfos[i].m_pvLock = pvLock; 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 // 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 // make sure we're releasing locks in reverse order of how we took them
for (UINT i = cCombinedLocks - cReleases; for (UINT i = cCombinedLocks - cReleases;
i < min (ARRAY_SIZE(m_rgTakenLockInfos), cCombinedLocks); i < std::min (ARRAY_SIZE(m_rgTakenLockInfos), (size_t)cCombinedLocks);
i++) i++)
{ {
if (m_rgTakenLockInfos[i].m_pvLock != pvLock) 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 // m_cLocksEnteringCannotRetakeLock records the number of locks that were taken
// when CANNOT_RETAKE_LOCK contract was constructed. // when CANNOT_RETAKE_LOCK contract was constructed.
for (UINT i = 0; 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) ++i)
{ {
if (m_pLockData->m_rgTakenLockInfos[i].m_pvLock == pvLock) if (m_pLockData->m_rgTakenLockInfos[i].m_pvLock == pvLock)

View file

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

View file

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

View file

@ -467,7 +467,7 @@ struct MSLAYOUT DacpAssemblyData
HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr) 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( return sos->GetMethodDescData(
addr, addr,
NULL, // IP address 0, // IP address
this, this,
0, // cRejitData 0, // cRejitData
NULL, // rejitData[] NULL, // rejitData[]

View file

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

View file

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

View file

@ -24,7 +24,7 @@
// Forbid the use of srand()/rand(), as these are globally shared facilities and our use of them would // 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. // 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 #ifdef srand
#undef srand #undef srand
@ -36,7 +36,7 @@
#endif #endif
#define rand Do_not_use_rand #define rand Do_not_use_rand
#endif //!DO_NOT_DISABLE_RAND && !USE_STL #endif //!DO_NOT_DISABLE_RAND
class CLRRandom class CLRRandom

View file

@ -31,11 +31,11 @@
#include "static_assert.h" #include "static_assert.h"
#ifdef PAL_STDCPP_COMPAT
#include <type_traits> #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 // Semantics: if val can be represented as the exact same value

View file

@ -10,14 +10,16 @@
#ifndef __UtilCode_h__ #ifndef __UtilCode_h__
#define __UtilCode_h__ #define __UtilCode_h__
#include <type_traits>
#include <algorithm>
#include <stdio.h>
#include <limits.h>
#include "crtwrap.h" #include "crtwrap.h"
#include "winwrap.h" #include "winwrap.h"
#include <wchar.h> #include <wchar.h>
#include <stdio.h>
#include <malloc.h>
#include <ole2.h> #include <ole2.h>
#include <oleauto.h> #include <oleauto.h>
#include <limits.h>
#include "clrtypes.h" #include "clrtypes.h"
#include "safewrap.h" #include "safewrap.h"
#include "volatile.h" #include "volatile.h"
@ -29,12 +31,6 @@
#include "safemath.h" #include "safemath.h"
#include "new.hpp" #include "new.hpp"
#ifdef PAL_STDCPP_COMPAT
#include <type_traits>
#else
#include "clr_std/type_traits"
#endif
#include "contract.h" #include "contract.h"
#include <minipal/utils.h> #include <minipal/utils.h>
@ -224,7 +220,7 @@ typedef LPSTR LPUTF8;
#define MAKE_UTF8PTR_FROMWIDE_NOTHROW(ptrname, widestr) \ #define MAKE_UTF8PTR_FROMWIDE_NOTHROW(ptrname, widestr) \
CQuickBytes __qb##ptrname; \ CQuickBytes __qb##ptrname; \
int __l##ptrname = (int)u16_strlen(widestr); \ int __l##ptrname = (int)u16_strlen(widestr); \
LPUTF8 ptrname = 0; \ LPUTF8 ptrname = NULL; \
if (__l##ptrname <= MAKE_MAX_LENGTH) { \ if (__l##ptrname <= MAKE_MAX_LENGTH) { \
__l##ptrname = (int)((__l##ptrname + 1) * 2 * sizeof(char)); \ __l##ptrname = (int)((__l##ptrname + 1) * 2 * sizeof(char)); \
ptrname = (LPUTF8) __qb##ptrname.AllocNoThrow(__l##ptrname); \ 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) { \ if (WszWideCharToMultiByte(CP_UTF8, 0, widestr, -1, ptrname, __lsize##ptrname, NULL, NULL) != 0) { \
ptrname[__l##ptrname] = 0; \ ptrname[__l##ptrname] = 0; \
} else { \ } else { \
ptrname = 0; \ ptrname = NULL; \
} \ } \
} \ } \
} \ } \
else { \ else { \
ptrname = 0; \ ptrname = NULL; \
} \ } \
} \ } \
} \ } \
@ -255,7 +251,7 @@ typedef LPSTR LPUTF8;
#define MAKE_WIDEPTR_FROMUTF8N_NOTHROW(ptrname, utf8str, n8chrs) \ #define MAKE_WIDEPTR_FROMUTF8N_NOTHROW(ptrname, utf8str, n8chrs) \
CQuickBytes __qb##ptrname; \ CQuickBytes __qb##ptrname; \
int __l##ptrname; \ int __l##ptrname; \
LPWSTR ptrname = 0; \ LPWSTR ptrname = NULL; \
__l##ptrname = WszMultiByteToWideChar(CP_UTF8, 0, utf8str, n8chrs, 0, 0); \ __l##ptrname = WszMultiByteToWideChar(CP_UTF8, 0, utf8str, n8chrs, 0, 0); \
if (__l##ptrname <= MAKE_MAX_LENGTH) { \ if (__l##ptrname <= MAKE_MAX_LENGTH) { \
ptrname = (LPWSTR) __qb##ptrname.AllocNoThrow((__l##ptrname+1)*sizeof(WCHAR)); \ 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) { \ if (WszMultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8str, n8chrs, ptrname, __l##ptrname) != 0) { \
ptrname[__l##ptrname] = 0; \ ptrname[__l##ptrname] = 0; \
} else { \ } else { \
ptrname = 0; \ ptrname = NULL; \
} \ } \
} \ } \
} }
@ -302,28 +298,6 @@ inline WCHAR* FormatInteger(WCHAR* str, size_t strCount, const char* fmt, I v)
return str; 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 */ /* portability helpers */
@ -1920,7 +1894,7 @@ public:
~CHashTableAndData() ~CHashTableAndData()
{ {
WRAPPER_NO_CONTRACT; WRAPPER_NO_CONTRACT;
if (m_pcEntries != NULL) if (m_pcEntries != (TADDR)NULL)
MemMgr::Free((BYTE*)m_pcEntries, MemMgr::RoundSize(m_iEntries * m_iEntrySize)); 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 iCurSize; // Current size in bytes.
int iEntries; // New # of entries. int iEntries; // New # of entries.
_ASSERTE(m_pcEntries != NULL); _ASSERTE(m_pcEntries != (TADDR)NULL);
_ASSERTE(m_iFree == UINT32_MAX); _ASSERTE(m_iFree == UINT32_MAX);
// Compute the current size and new # of entries. // Compute the current size and new # of entries.
@ -3934,37 +3908,6 @@ inline T* InterlockedCompareExchangeT(
return InterlockedCompareExchangeT(destination, exchange, static_cast<T*>(comparand)); 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 #undef InterlockedExchangePointer
#define InterlockedExchangePointer Use_InterlockedExchangeT #define InterlockedExchangePointer Use_InterlockedExchangeT
#undef InterlockedCompareExchangePointer #undef InterlockedCompareExchangePointer

View file

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

View file

@ -673,7 +673,7 @@ void Compiler::optAssertionInit(bool isLocalProp)
// Local assertion prop keeps mappings from each local var to the assertions about that var. // Local assertion prop keeps mappings from each local var to the assertions about that var.
// //
optAssertionDep = 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) if (optCrossBlockLocalAssertionProp)
{ {

View file

@ -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 // spDelta is negative in the prolog, positive in the epilog, but we always tell the unwind codes the positive
// value. // value.
ssize_t spDeltaAbs = abs(spDelta); ssize_t spDeltaAbs = std::abs(spDelta);
unsigned unwindSpDelta = (unsigned)spDeltaAbs; unsigned unwindSpDelta = (unsigned)spDeltaAbs;
assert((ssize_t)unwindSpDelta == spDeltaAbs); // make sure that it fits in a unsigned assert((ssize_t)unwindSpDelta == spDeltaAbs); // make sure that it fits in a unsigned

View file

@ -2815,6 +2815,12 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* assigned location, in the function prolog. * 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_ #ifdef _PREFAST_
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 21000) // Suppress PREFast warning about overly large function #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 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 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]) // 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; unsigned varNum;
LclVarDsc* varDsc; LclVarDsc* varDsc;

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -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 // Our stack level should be always greater than the bytes of arguments we push. Just
// a sanity test. // 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. // Trim out any callee-trashed registers from the live set.
regMaskTP savedSet = emitGetGCRegsSavedOrModified(methHnd); regMaskTP savedSet = emitGetGCRegsSavedOrModified(methHnd);

View file

@ -2467,7 +2467,7 @@ bool Compiler::fgOptimizeUncondBranchToSimpleCond(BasicBlock* block, BasicBlock*
// //
weight_t targetWeight = target->bbWeight; weight_t targetWeight = target->bbWeight;
weight_t blockWeight = block->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, JITDUMP("Decreased " FMT_BB " profile weight from " FMT_WT " to " FMT_WT "\n", target->bbNum, targetWeight,
target->bbWeight); target->bbWeight);
} }
@ -3047,7 +3047,7 @@ bool Compiler::fgOptimizeSwitchJumps()
blockToTargetEdge->setEdgeWeights(blockToTargetWeight, blockToTargetWeight, dominantTarget); blockToTargetEdge->setEdgeWeights(blockToTargetWeight, blockToTargetWeight, dominantTarget);
blockToTargetEdge->setLikelihood(fraction); blockToTargetEdge->setLikelihood(fraction);
blockToNewBlockEdge->setEdgeWeights(blockToNewBlockWeight, blockToNewBlockWeight, block); 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 // 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 // one edge in the flowgraph. So we need to subtract off the profile data that now flows

View file

@ -1353,7 +1353,7 @@ void ProfileSynthesis::GaussSeidelSolver()
for (unsigned j = m_dfsTree->GetPostOrderCount(); j != 0; j--) for (unsigned j = m_dfsTree->GetPostOrderCount(); j != 0; j--)
{ {
BasicBlock* const block = dfs->GetPostOrder(j - 1); 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); m_approximate = !converged || (m_cappedCyclicProbabilities > 0);

View file

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

View file

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

View file

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

View file

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

View file

@ -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 // 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, // 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. // 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 noway_assert(compHndBBtabAllocCount < newHndBBtabAllocCount); // check for overflow
if (newHndBBtabAllocCount > MAX_XCPTN_INDEX) if (newHndBBtabAllocCount > MAX_XCPTN_INDEX)

View file

@ -11,7 +11,15 @@
#include <string.h> #include <string.h>
#include <float.h> #include <float.h>
#include <cstdlib> #include <cstdlib>
#include <cmath>
#include <intrin.h> #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 // 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 // `BitOperations::BitScan*` functions have their name mapped, which is confusing and messes up

View file

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

View file

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

View file

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

View file

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

View file

@ -7153,7 +7153,7 @@ bool Lowering::TryLowerConstIntDivOrMod(GenTree* node, GenTree** nextNode)
} }
size_t absDivisorValue = 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)) 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", 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); 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"); JITDUMP(" ..and they are amenable to ldp optimization\n");
if (TryMakeIndirsAdjacent(prevIndir, ind)) if (TryMakeIndirsAdjacent(prevIndir, ind))

View file

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

View file

@ -86,10 +86,11 @@ ABIPassingInformation Arm64Classifier::Classify(Compiler* comp,
} }
else 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); m_stackArgSize += roundUp(structLayout->GetSize(), alignment);
// After passing any float value on the stack, we should not enregister more float values. // After passing any float value on the stack, we should not enregister more float values.
m_floatRegs.Clear(); m_floatRegs.Clear();

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -89,16 +89,6 @@ inline bool IS_ALIGNED(T* val, uintptr_t alignment);
#define ZeroMemory(_dst, _size) memset((_dst), 0, (_size)) #define ZeroMemory(_dst, _size) memset((_dst), 0, (_size))
#endif #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 #endif // !DACCESS_COMPILE
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------

View file

@ -230,7 +230,7 @@ void SpinWait(int iteration, int usecLimit)
int64_t ticksPerSecond = PalQueryPerformanceFrequency(); int64_t ticksPerSecond = PalQueryPerformanceFrequency();
int64_t endTicks = startTicks + (usecLimit * ticksPerSecond) / 1000000; 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 i = 0; i < l; i++)
{ {
for (int j = 0; j < (1 << i); j++) for (int j = 0; j < (1 << i); j++)

View file

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

View file

@ -33,7 +33,6 @@ Abstract:
#ifndef __PAL_H__ #ifndef __PAL_H__
#define __PAL_H__ #define __PAL_H__
#ifdef PAL_STDCPP_COMPAT
#include <float.h> #include <float.h>
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
@ -42,12 +41,22 @@ Abstract:
#include <stdarg.h> #include <stdarg.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <math.h>
#include <strings.h> #include <strings.h>
#include <errno.h> #include <errno.h>
#include <ctype.h> #include <ctype.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <wctype.h>
#ifdef __cplusplus
extern "C++"
{
#include <new>
}
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
@ -175,77 +184,13 @@ extern bool g_arm64_atomics_present;
#define __has_cpp_attribute(x) (0) #define __has_cpp_attribute(x) (0)
#endif #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 *****************************/ /******************* PAL-Specific Entrypoints *****************************/
@ -256,44 +201,6 @@ BOOL
PALAPI PALAPI
PAL_IsDebuggerPresent(); 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_PROCESS_ATTACH 1
#define DLL_THREAD_ATTACH 2 #define DLL_THREAD_ATTACH 2
#define DLL_THREAD_DETACH 3 #define DLL_THREAD_DETACH 3
@ -3934,31 +3841,6 @@ PAL_GetCurrentThreadAffinitySet(SIZE_T size, UINT_PTR* data);
#endif //FEATURE_PAL_ANSI #endif //FEATURE_PAL_ANSI
/******************* C Runtime Entrypoints *******************************/ /******************* 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 #ifndef _CONST_RETURN
#ifdef __cplusplus #ifdef __cplusplus
#define _CONST_RETURN const #define _CONST_RETURN const
@ -3971,134 +3853,16 @@ int vprintf(const char *, va_list);
/* For backwards compatibility */ /* For backwards compatibility */
#define _WConst_return _CONST_RETURN #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 */ /* _TRUNCATE */
#if !defined(_TRUNCATE) #if !defined(_TRUNCATE)
#define _TRUNCATE ((size_t)-1) #define _TRUNCATE ((size_t)-1)
#endif #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 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 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 DLLEXPORT int __cdecl _wcsicmp(const WCHAR *, const WCHAR*);
PALIMPORT int __cdecl _wcsnicmp(const WCHAR *, const WCHAR *, size_t); 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); 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 errno_t __cdecl _wcslwr_s(WCHAR *, size_t sz);
PALIMPORT DLLEXPORT errno_t __cdecl _i64tow_s(long long, WCHAR *, size_t, int); PALIMPORT DLLEXPORT errno_t __cdecl _i64tow_s(long long, WCHAR *, size_t, int);
PALIMPORT int __cdecl _wtoi(const WCHAR *); PALIMPORT int __cdecl _wtoi(const WCHAR *);
#ifndef DEFINE_DUMMY_FILE_TYPE
PALIMPORT FILE * __cdecl _wfopen(const WCHAR *, const WCHAR *); PALIMPORT FILE * __cdecl _wfopen(const WCHAR *, const WCHAR *);
#endif
inline int _stricmp(const char* a, const char* b) inline int _stricmp(const char* a, const char* b)
{ {
@ -4145,6 +3906,10 @@ inline char* _strdup(const char* a)
return strdup(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 #ifdef __cplusplus
extern "C++" { extern "C++" {
inline WCHAR *PAL_wcschr(WCHAR* S, WCHAR 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) #endif // !__has_builtin(_rotl)
// On 64 bit unix, make the long an int.
#ifdef HOST_64BIT
#define _lrotl _rotl
#endif
#if !__has_builtin(_rotr) #if !__has_builtin(_rotr)
/*++ /*++
@ -4205,137 +3965,7 @@ unsigned int __cdecl _rotr(unsigned int value, int shift)
#endif // !__has_builtin(_rotr) #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 *); PALIMPORT DLLEXPORT int __cdecl _putenv(const char *);
#define ERANGE 34 #define ERANGE 34
@ -4366,15 +3996,7 @@ PALAPI
PAL_GetCpuTickCount(); PAL_GetCpuTickCount();
#endif // PAL_PERF #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 #ifdef __cplusplus

View file

@ -64,13 +64,15 @@ extern "C" {
#define _cdecl #define _cdecl
#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__) #endif // !defined(__i386__)
@ -101,7 +103,9 @@ extern "C" {
#else #else
#define PALIMPORT #define PALIMPORT
#ifndef DLLEXPORT
#define DLLEXPORT __attribute__((visibility("default"))) #define DLLEXPORT __attribute__((visibility("default")))
#endif
#define PAL_NORETURN __attribute__((noreturn)) #define PAL_NORETURN __attribute__((noreturn))
#endif #endif
@ -206,21 +210,6 @@ extern "C" {
#endif // _MSC_VER #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 #ifndef _MSC_VER
@ -229,7 +218,6 @@ typedef long double LONG_DOUBLE;
#endif #endif
#endif // _MSC_VER #endif // _MSC_VER
#endif // !PAL_STDCPP_COMPAT
typedef void VOID; 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) #define SSIZE_T_MIN (ssize_t)I64(0x8000000000000000)
#endif #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; 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; 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 DWORD LCID;
typedef PDWORD PLCID; typedef PDWORD PLCID;
typedef WORD LANGID; typedef WORD LANGID;

View file

@ -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"

View file

@ -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"

View file

@ -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"

View file

@ -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__

View file

@ -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"

View file

@ -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"

View file

@ -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"

View file

@ -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"

Some files were not shown because too many files have changed in this diff Show more