mirror of
https://github.com/VSadov/Satori.git
synced 2025-06-12 02:30:29 +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:
parent
01f039ce1d
commit
5c4e2a301e
240 changed files with 559 additions and 5127 deletions
|
@ -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()
|
||||||
|
|
|
@ -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}
|
||||||
|
|
|
@ -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})
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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))
|
||||||
|
|
|
@ -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})
|
||||||
|
|
||||||
|
|
|
@ -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++)
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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++)
|
||||||
|
|
|
@ -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++)
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -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>
|
||||||
|
|
||||||
|
|
|
@ -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];
|
||||||
|
|
|
@ -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];
|
||||||
|
|
|
@ -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>
|
||||||
|
|
||||||
|
|
|
@ -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()
|
||||||
{
|
{
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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;
|
||||||
|
|
3
src/coreclr/gc/env/common.h
vendored
3
src/coreclr/gc/env/common.h
vendored
|
@ -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>
|
||||||
|
|
9
src/coreclr/gc/env/gcenv.base.h
vendored
9
src/coreclr/gc/env/gcenv.base.h
vendored
|
@ -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
|
||||||
|
|
||||||
// -----------------------------------------------------------------------------------------------------------
|
// -----------------------------------------------------------------------------------------------------------
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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>
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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>
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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!!!!
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
{}
|
{}
|
||||||
|
|
|
@ -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
|
|
|
@ -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
|
|
|
@ -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
|
|
|
@ -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
|
|
|
@ -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
|
|
|
@ -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"
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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>
|
||||||
|
|
||||||
|
|
|
@ -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>
|
||||||
|
|
||||||
|
|
|
@ -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[]
|
||||||
|
|
|
@ -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>
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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();
|
||||||
|
|
|
@ -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)
|
||||||
{
|
{
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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)
|
||||||
{
|
{
|
||||||
|
|
|
@ -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);
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
{
|
{
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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));
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -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
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
|
||||||
{
|
{
|
||||||
|
|
|
@ -5,7 +5,7 @@
|
||||||
|
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include "clr_std/type_traits"
|
#include <type_traits>
|
||||||
|
|
||||||
namespace jitstd
|
namespace jitstd
|
||||||
{
|
{
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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()));
|
||||||
}
|
}
|
||||||
|
|
||||||
//-------------------------------------------------------------------------
|
//-------------------------------------------------------------------------
|
||||||
|
|
|
@ -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))
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
|
|
||||||
//------------------------------------------------------------------------
|
//------------------------------------------------------------------------
|
||||||
|
|
|
@ -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();
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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"
|
||||||
|
|
|
@ -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) {
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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))
|
||||||
|
|
|
@ -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_
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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__
|
||||||
|
|
|
@ -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>
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
//-------------------------------------------------------------------------------------------------
|
//-------------------------------------------------------------------------------------------------
|
||||||
|
|
|
@ -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++)
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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
|
||||||
|
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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"
|
|
|
@ -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"
|
|
|
@ -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"
|
|
|
@ -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__
|
|
|
@ -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"
|
|
|
@ -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"
|
|
|
@ -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"
|
|
|
@ -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
Loading…
Add table
Add a link
Reference in a new issue