// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

#include "stdafx.h" // Precompiled header key.

#include "loaderheap.h"

#include "ex.h"

#include "pedecoder.h"

#define DONOT_DEFINE_ETW_CALLBACK

#include "eventtracebase.h"

#ifndef DACCESS_COMPILE

INDEBUG(DWORD UnlockedLoaderHeap::s_dwNumInstancesOfLoaderHeaps = 0;)

#ifdef RANDOMIZE_ALLOC

#include <time.h>

static class Random

{

public:

Random() { seed = (unsigned int)time(NULL); }

unsigned int Next()

{

return ((seed = seed * 214013L + 2531011L) >> 16) & 0x7fff;

}

private:

unsigned int seed;

} s_random;

#endif

namespace

{

#if !defined(SELF_NO_HOST) // ETW available only in the runtime

inline void EtwAllocRequest(UnlockedLoaderHeap * const pHeap, void* ptr, size_t dwSize)

{

FireEtwAllocRequest(pHeap, ptr, static_cast<unsigned int>(dwSize), 0, 0, GetClrInstanceId());

}

#else

#define EtwAllocRequest(pHeap, ptr, dwSize) ((void)0)

#endif // SELF_NO_HOST

}

//

// RangeLists are constructed so they can be searched from multiple

// threads without locking. They do require locking in order to

// be safely modified, though.

//

RangeList::RangeList()

{

WRAPPER_NO_CONTRACT;

InitBlock(&m_starterBlock);

m_firstEmptyBlock = &m_starterBlock;

m_firstEmptyRange = 0;

}

RangeList::~RangeList()

{

LIMITED_METHOD_CONTRACT;

RangeListBlock *b = m_starterBlock.next;

while (b != NULL)

{

RangeListBlock *bNext = b->next;

delete b;

b = bNext;

}

}

void RangeList::InitBlock(RangeListBlock *b)

{

LIMITED_METHOD_CONTRACT;

Range *r = b->ranges;

Range *rEnd = r + RANGE_COUNT;

while (r < rEnd)

r++->id = (TADDR)NULL;

b->next = NULL;

}

BOOL RangeList::AddRangeWorker(const BYTE *start, const BYTE *end, void *id)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

INJECT_FAULT(return FALSE;);

}

CONTRACTL_END

_ASSERTE(id != NULL);

RangeListBlock *b = m_firstEmptyBlock;

Range *r = b->ranges + m_firstEmptyRange;

Range *rEnd = b->ranges + RANGE_COUNT;

while (TRUE)

{

while (r < rEnd)

{

if (r->id == (TADDR)NULL)

{

r->start = (TADDR)start;

r->end = (TADDR)end;

r->id = (TADDR)id;

r++;

m_firstEmptyBlock = b;

m_firstEmptyRange = r - b->ranges;

return TRUE;

}

r++;

}

//

// If there are no more blocks, allocate a

// new one.

//

if (b->next == NULL)

{

RangeListBlock *newBlock = new (nothrow) RangeListBlock;

if (newBlock == NULL)

{

m_firstEmptyBlock = b;

m_firstEmptyRange = r - b->ranges;

return FALSE;

}

InitBlock(newBlock);

newBlock->next = NULL;

b->next = newBlock;

}

//

// Next block

//

b = b->next;

r = b->ranges;

rEnd = r + RANGE_COUNT;

}

}

void RangeList::RemoveRangesWorker(void *id)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

}

CONTRACTL_END

RangeListBlock *b = &m_starterBlock;

Range *r = b->ranges;

Range *rEnd = r + RANGE_COUNT;

//

// Find the first free element, & mark it.

//

while (TRUE)

{

//

// Clear entries in this block.

//

while (r < rEnd)

{

if (r->id == (TADDR)id)

{

r->id = (TADDR)NULL;

}

r++;

}

//

// If there are no more blocks, we're done.

//

if (b->next == NULL)

{

m_firstEmptyRange = 0;

m_firstEmptyBlock = &m_starterBlock;

return;

}

//

// Next block.

//

b = b->next;

r = b->ranges;

rEnd = r + RANGE_COUNT;

}

}

#endif // #ifndef DACCESS_COMPILE

BOOL RangeList::IsInRangeWorker(TADDR address)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

FORBID_FAULT;

GC_NOTRIGGER;

}

CONTRACTL_END

SUPPORTS_DAC;

for (const RangeListBlock* b = &m_starterBlock; b != nullptr; b = b->next)

{

for (const Range r : b->ranges)

{

if (r.id != (TADDR)nullptr && address >= r.start && address < r.end)

return TRUE;

}

}

return FALSE;

}

#ifdef DACCESS_COMPILE

void

RangeList::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)

{

SUPPORTS_DAC;

WRAPPER_NO_CONTRACT;

// This class is almost always contained in something

// else so there's no enumeration of 'this'.

RangeListBlock* block = &m_starterBlock;

block->EnumMemoryRegions(flags);

while (block->next.IsValid())

{

block->next.EnumMem();

block = block->next;

block->EnumMemoryRegions(flags);

}

}

void

RangeList::RangeListBlock::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)

{

WRAPPER_NO_CONTRACT;

Range* range;

TADDR BADFOOD;

TSIZE_T size;

int i;

// The code below iterates each range stored in the RangeListBlock and

// dumps the memory region represented by each range.

// It is too much memory for a mini-dump, so we just bail out for mini-dumps.

if (flags == CLRDATA_ENUM_MEM_MINI || flags == CLRDATA_ENUM_MEM_TRIAGE)

{

return;

}

BIT64_ONLY( BADFOOD = 0xbaadf00dbaadf00d; );

NOT_BIT64( BADFOOD = 0xbaadf00d; );

for (i=0; i<RANGE_COUNT; i++)

{

range = &(this->ranges[i]);

if (range->id == (TADDR)NULL || range->start == (TADDR)NULL || range->end == (TADDR)NULL ||

// just looking at the lower 4bytes is good enough on WIN64

range->start == BADFOOD || range->end == BADFOOD)

{

break;

}

size = range->end - range->start;

_ASSERTE( size < UINT32_MAX ); // ranges should be less than 4gig!

// We can't be sure this entire range is mapped. For example, the code:StubLinkStubManager

// keeps track of all ranges in the code:LoaderAllocator::m_pStubHeap LoaderHeap, and

// code:LoaderHeap::UnlockedReservePages adds a range for the entire reserved region, instead

// of updating the RangeList when pages are committed. But in that case, the committed region of

// memory will be enumerated by the LoaderHeap anyway, so it's OK if this fails

EMEM_OUT(("MEM: RangeListBlock %p - %p\n", range->start, range->end));

DacEnumMemoryRegion(range->start, size, false);

}

}

#endif // #ifdef DACCESS_COMPILE

//=====================================================================================

// In DEBUG builds only, we tag live blocks with the requested size and the type of

// allocation (AllocMem, AllocAlignedMem, AllocateOntoReservedMem). This is strictly

// to validate that those who call Backout* are passing in the right values.

//

// For simplicity, we'll use one LoaderHeapValidationTag structure for all types even

// though not all fields are applicable to all types.

//=====================================================================================

#ifdef _DEBUG

enum AllocationType

{

kAllocMem = 1,

kFreedMem = 4,

};

struct LoaderHeapValidationTag

{

size_t m_dwRequestedSize; // What the caller requested (not what was actually allocated)

AllocationType m_allocationType; // Which api allocated this block.

const char * m_szFile; // Who allocated me

int m_lineNum; // Who allocated me

};

#endif //_DEBUG

//=====================================================================================

// These classes do detailed loaderheap sniffing to help in debugging heap crashes

//=====================================================================================

#ifdef _DEBUG

// This structure logs the results of an Alloc or Free call. They are stored in reverse time order

// with UnlockedLoaderHeap::m_pEventList pointing to the most recent event.

struct LoaderHeapEvent

{

LoaderHeapEvent *m_pNext;

AllocationType m_allocationType; //Which api was called

const char *m_szFile; //Caller Id

int m_lineNum; //Caller Id

const char *m_szAllocFile; //(BackoutEvents): Who allocated the block?

int m_allocLineNum; //(BackoutEvents): Who allocated the block?

void *m_pMem; //Starting address of block

size_t m_dwRequestedSize; //Requested size of block

size_t m_dwSize; //Actual size of block (including validation tags, padding, everything)

void Describe(SString *pSString)

{

CONTRACTL

{

INSTANCE_CHECK;

DISABLED(NOTHROW);

GC_NOTRIGGER;

}

CONTRACTL_END

pSString->AppendASCII("\n");

{

StackSString buf;

if (m_allocationType == kFreedMem)

{

buf.Printf(" Freed at: %s (line %d)\n", m_szFile, m_lineNum);

buf.Printf(" (block originally allocated at %s (line %d)\n", m_szAllocFile, m_allocLineNum);

}

else

{

buf.Printf(" Allocated at: %s (line %d)\n", m_szFile, m_lineNum);

}

pSString->Append(buf);

}

if (!QuietValidate())

{

pSString->AppendASCII(" *** THIS BLOCK HAS BEEN CORRUPTED ***\n");

}

{

StackSString buf;

buf.Printf(" Type: ");

switch (m_allocationType)

{

case kAllocMem:

buf.AppendASCII("AllocMem()\n");

break;

case kFreedMem:

buf.AppendASCII("Free\n");

break;

default:

break;

}

pSString->Append(buf);

}

{

StackSString buf;

buf.Printf(" Start of block: 0x%p\n", m_pMem);

pSString->Append(buf);

}

{

StackSString buf;

buf.Printf(" End of block: 0x%p\n", ((BYTE*)m_pMem) + m_dwSize - 1);

pSString->Append(buf);

}

{

StackSString buf;

buf.Printf(" Requested size: %lu (0x%lx)\n", (ULONG)m_dwRequestedSize, (ULONG)m_dwRequestedSize);

pSString->Append(buf);

}

{

StackSString buf;

buf.Printf(" Actual size: %lu (0x%lx)\n", (ULONG)m_dwSize, (ULONG)m_dwSize);

pSString->Append(buf);

}

pSString->AppendASCII("\n");

}

BOOL QuietValidate();

};

class LoaderHeapSniffer

{

public:

static DWORD InitDebugFlags()

{

WRAPPER_NO_CONTRACT;

DWORD dwDebugFlags = 0;

if (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_LoaderHeapCallTracing))

{

dwDebugFlags |= UnlockedLoaderHeap::kCallTracing;

}

return dwDebugFlags;

}

static VOID RecordEvent(UnlockedLoaderHeap *pHeap,

AllocationType allocationType,

_In_ const char *szFile,

int lineNum,

_In_ const char *szAllocFile,

int allocLineNum,

void *pMem,

size_t dwRequestedSize,

size_t dwSize

);

static VOID ClearEvents(UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_FORBID_FAULT;

LoaderHeapEvent *pEvent = pHeap->m_pEventList;

while (pEvent)

{

LoaderHeapEvent *pNext = pEvent->m_pNext;

delete pEvent;

pEvent = pNext;

}

pHeap->m_pEventList = NULL;

}

static VOID CompactEvents(UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_FORBID_FAULT;

LoaderHeapEvent **ppEvent = &(pHeap->m_pEventList);

while (*ppEvent)

{

LoaderHeapEvent *pEvent = *ppEvent;

if (pEvent->m_allocationType != kFreedMem)

{

ppEvent = &(pEvent->m_pNext);

}

else

{

LoaderHeapEvent **ppWalk = &(pEvent->m_pNext);

BOOL fMatchFound = FALSE;

while (*ppWalk && !fMatchFound)

{

LoaderHeapEvent *pWalk = *ppWalk;

if (pWalk->m_allocationType != kFreedMem &&

pWalk->m_pMem == pEvent->m_pMem &&

pWalk->m_dwRequestedSize == pEvent->m_dwRequestedSize)

{

// Delete matched pairs

// Order is important here - updating *ppWalk may change pEvent->m_pNext, and we want

// to get the updated value when we unlink pEvent.

*ppWalk = pWalk->m_pNext;

*ppEvent = pEvent->m_pNext;

delete pEvent;

delete pWalk;

fMatchFound = TRUE;

}

else

{

ppWalk = &(pWalk->m_pNext);

}

}

if (!fMatchFound)

{

ppEvent = &(pEvent->m_pNext);

}

}

}

}

static VOID PrintEvents(UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_FORBID_FAULT;

minipal_log_print_info("\n------------- LoaderHeapEvents (in reverse time order!) --------------------");

StackSString buf;

LoaderHeapEvent *pEvent = pHeap->m_pEventList;

while (pEvent)

{

minipal_log_print_info("\n");

switch (pEvent->m_allocationType)

{

case kAllocMem: buf.AppendUTF8("AllocMem "); break;

case kFreedMem: buf.AppendUTF8("BackoutMem "); break;

}

buf.AppendPrintf(" ptr = 0x%-8p", pEvent->m_pMem);

buf.AppendPrintf(" rqsize = 0x%-8x", (DWORD)pEvent->m_dwRequestedSize);

buf.AppendPrintf(" actsize = 0x%-8x", (DWORD)pEvent->m_dwSize);

buf.AppendPrintf(" (at %s@%d)", pEvent->m_szFile, pEvent->m_lineNum);

if (pEvent->m_allocationType == kFreedMem)

{

buf.AppendPrintf(" (original allocation at %s@%d)", pEvent->m_szAllocFile, pEvent->m_allocLineNum);

}

minipal_log_print_info(buf.GetUTF8());

buf.Clear();

pEvent = pEvent->m_pNext;

}

minipal_log_print_info("\n------------- End of LoaderHeapEvents --------------------------------------\n");

}

static VOID PitchSniffer(SString *pSString)

{

WRAPPER_NO_CONTRACT;

pSString->AppendASCII("\n"

"\nBecause call-tracing wasn't turned on, we couldn't provide details about who last owned the affected memory block. To get more precise diagnostics,"

"\nset the following registry DWORD value:"

"\n"

"\n HKLM\\Software\\Microsoft\\.NETFramework\\LoaderHeapCallTracing = 1"

"\n"

"\nand rerun the scenario that crashed."

"\n"

"\n");

}

static LoaderHeapEvent *FindEvent(UnlockedLoaderHeap *pHeap, void *pAddr)

{

LIMITED_METHOD_CONTRACT;

LoaderHeapEvent *pEvent = pHeap->m_pEventList;

while (pEvent)

{

if (pAddr >= pEvent->m_pMem && pAddr <= ( ((BYTE*)pEvent->m_pMem) + pEvent->m_dwSize - 1))

{

return pEvent;

}

pEvent = pEvent->m_pNext;

}

return NULL;

}

static void ValidateFreeList(UnlockedLoaderHeap *pHeap);

static void WeGotAFaultNowWhat(UnlockedLoaderHeap *pHeap)

{

WRAPPER_NO_CONTRACT;

ValidateFreeList(pHeap);

//If none of the above popped up an assert, pop up a generic one.

_ASSERTE(!("Unexpected AV inside LoaderHeap. The usual reason is that someone overwrote the end of a block or wrote into a freed block.\n"));

}

};

#endif

#ifdef _DEBUG

#define LOADER_HEAP_BEGIN_TRAP_FAULT BOOL __faulted = FALSE; EX_TRY {

#define LOADER_HEAP_END_TRAP_FAULT } EX_CATCH {__faulted = TRUE; } EX_END_CATCH(SwallowAllExceptions) if (__faulted) LoaderHeapSniffer::WeGotAFaultNowWhat(pHeap);

#else

#define LOADER_HEAP_BEGIN_TRAP_FAULT

#define LOADER_HEAP_END_TRAP_FAULT

#endif

//=====================================================================================

// This freelist implementation is a first cut and probably needs to be tuned.

// It should be tuned with the following assumptions:

//

// - Freeing LoaderHeap memory is done primarily for OOM backout. LoaderHeaps

// weren't designed to be general purpose heaps and shouldn't be used that way.

//

// - And hence, when memory is freed, expect it to be freed in large clumps and in a

// LIFO order. Since the LoaderHeap normally hands out memory with sequentially

// increasing addresses, blocks will typically be freed with sequentially decreasing

// addresses.

//

// The first cut of the freelist is a single-linked list of free blocks using first-fit.

// Assuming the above alloc-free pattern holds, the list will end up mostly sorted

// in increasing address order. When a block is freed, we'll attempt to coalesce it

// with the first block in the list. We could also choose to be more aggressive about

// sorting and coalescing but this should probably catch most cases in practice.

//=====================================================================================

// When a block is freed, we place this structure on the first bytes of the freed block (Allocations

// are bumped in size if necessary to make sure there's room.)

struct LoaderHeapFreeBlock

{

public:

LoaderHeapFreeBlock *m_pNext; // Pointer to next block on free list

size_t m_dwSize; // Total size of this block

void *m_pBlockAddress; // Virtual address of the block

#ifndef DACCESS_COMPILE

static void InsertFreeBlock(LoaderHeapFreeBlock **ppHead, void *pMem, size_t dwTotalSize, UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

// The new "nothrow" below failure is handled in a non-fault way, so

// make sure that callers with FORBID_FAULT can call this method without

// firing the contract violation assert.

PERMANENT_CONTRACT_VIOLATION(FaultViolation, ReasonContractInfrastructure);

LOADER_HEAP_BEGIN_TRAP_FAULT

// It's illegal to insert a free block that's smaller than the minimum sized allocation -

// it may stay stranded on the freelist forever.

#ifdef _DEBUG

if (!(dwTotalSize >= pHeap->AllocMem_TotalSize(1)))

{

LoaderHeapSniffer::ValidateFreeList(pHeap);

_ASSERTE(dwTotalSize >= pHeap->AllocMem_TotalSize(1));

}

if (!(0 == (dwTotalSize & ALLOC_ALIGN_CONSTANT)))

{

LoaderHeapSniffer::ValidateFreeList(pHeap);

_ASSERTE(0 == (dwTotalSize & ALLOC_ALIGN_CONSTANT));

}

#endif

#ifdef DEBUG

if (!pHeap->IsInterleaved())

{

void* pMemRW = pMem;

ExecutableWriterHolderNoLog<void> memWriterHolder;

if (pHeap->IsExecutable())

{

memWriterHolder.AssignExecutableWriterHolder(pMem, dwTotalSize);

pMemRW = memWriterHolder.GetRW();

}

memset(pMemRW, 0xcc, dwTotalSize);

}

else

{

memset((BYTE*)pMem + GetStubCodePageSize(), 0xcc, dwTotalSize);

}

#endif // DEBUG

LoaderHeapFreeBlock *pNewBlock = new (nothrow) LoaderHeapFreeBlock;

// If we fail allocating the LoaderHeapFreeBlock, ignore the failure and don't insert the free block at all.

if (pNewBlock != NULL)

{

pNewBlock->m_pNext = *ppHead;

pNewBlock->m_dwSize = dwTotalSize;

pNewBlock->m_pBlockAddress = pMem;

*ppHead = pNewBlock;

MergeBlock(pNewBlock, pHeap);

}

LOADER_HEAP_END_TRAP_FAULT

}

static void *AllocFromFreeList(LoaderHeapFreeBlock **ppHead, size_t dwSize, UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

INCONTRACT(_ASSERTE_IMPL(!ARE_FAULTS_FORBIDDEN()));

void *pResult = NULL;

LOADER_HEAP_BEGIN_TRAP_FAULT

LoaderHeapFreeBlock **ppWalk = ppHead;

while (*ppWalk)

{

LoaderHeapFreeBlock *pCur = *ppWalk;

size_t dwCurSize = pCur->m_dwSize;

if (dwCurSize == dwSize)

{

pResult = pCur->m_pBlockAddress;

// Exact match. Hooray!

*ppWalk = pCur->m_pNext;

delete pCur;

break;

}

else if (dwCurSize > dwSize && (dwCurSize - dwSize) >= pHeap->AllocMem_TotalSize(1))

{

// Partial match. Ok...

pResult = pCur->m_pBlockAddress;

*ppWalk = pCur->m_pNext;

InsertFreeBlock(ppWalk, ((BYTE*)pCur->m_pBlockAddress) + dwSize, dwCurSize - dwSize, pHeap );

delete pCur;

break;

}

// Either block is too small or splitting the block would leave a remainder that's smaller than

// the minimum block size. Onto next one.

ppWalk = &( pCur->m_pNext );

}

if (pResult)

{

void *pResultRW = pResult;

ExecutableWriterHolderNoLog<void> resultWriterHolder;

if (pHeap->IsExecutable())

{

resultWriterHolder.AssignExecutableWriterHolder(pResult, dwSize);

pResultRW = resultWriterHolder.GetRW();

}

// Callers of loaderheap assume allocated memory is zero-inited so we must preserve this invariant!

memset(pResultRW, 0, dwSize);

}

LOADER_HEAP_END_TRAP_FAULT

return pResult;

}

private:

// Try to merge pFreeBlock with its immediate successor. Return TRUE if a merge happened. FALSE if no merge happened.

static BOOL MergeBlock(LoaderHeapFreeBlock *pFreeBlock, UnlockedLoaderHeap *pHeap)

{

STATIC_CONTRACT_NOTHROW;

BOOL result = FALSE;

LOADER_HEAP_BEGIN_TRAP_FAULT

LoaderHeapFreeBlock *pNextBlock = pFreeBlock->m_pNext;

size_t dwSize = pFreeBlock->m_dwSize;

if (pNextBlock == NULL || ((BYTE*)pNextBlock->m_pBlockAddress) != (((BYTE*)pFreeBlock->m_pBlockAddress) + dwSize))

{

result = FALSE;

}

else

{

size_t dwCombinedSize = dwSize + pNextBlock->m_dwSize;

LoaderHeapFreeBlock *pNextNextBlock = pNextBlock->m_pNext;

void *pMemRW = pFreeBlock->m_pBlockAddress;

ExecutableWriterHolderNoLog<void> memWriterHolder;

if (pHeap->IsExecutable())

{

memWriterHolder.AssignExecutableWriterHolder(pFreeBlock->m_pBlockAddress, dwCombinedSize);

pMemRW = memWriterHolder.GetRW();

}

INDEBUG(memset(pMemRW, 0xcc, dwCombinedSize);)

pFreeBlock->m_pNext = pNextNextBlock;

pFreeBlock->m_dwSize = dwCombinedSize;

delete pNextBlock;

result = TRUE;

}

LOADER_HEAP_END_TRAP_FAULT

return result;

}

#endif // DACCESS_COMPILE

};

//=====================================================================================

// These helpers encapsulate the actual layout of a block allocated by AllocMem

// and UnlockedAllocMem():

//

// ==> Starting address is always pointer-aligned.

//

// - x bytes of user bytes (where "x" is the actual dwSize passed into AllocMem)

//

// - y bytes of "EE" (DEBUG-ONLY) (where "y" == LOADER_HEAP_DEBUG_BOUNDARY (normally 0))

// - z bytes of pad (DEBUG-ONLY) (where "z" is just enough to pointer-align the following byte)

// - a bytes of tag (DEBUG-ONLY) (where "a" is sizeof(LoaderHeapValidationTag)

//

// - b bytes of pad (where "b" is just enough to pointer-align the following byte)

//

// ==> Following address is always pointer-aligned

//=====================================================================================

// Convert the requested size into the total # of bytes we'll actually allocate (including padding)

size_t UnlockedLoaderHeap::AllocMem_TotalSize(size_t dwRequestedSize)

{

LIMITED_METHOD_CONTRACT;

size_t dwSize = dwRequestedSize;

// Interleaved heap cannot ad any extra to the requested size

if (!IsInterleaved())

{

#ifdef _DEBUG

dwSize += LOADER_HEAP_DEBUG_BOUNDARY;

dwSize = ((dwSize + ALLOC_ALIGN_CONSTANT) & (~ALLOC_ALIGN_CONSTANT));

#endif

if (!m_fExplicitControl)

{

#ifdef _DEBUG

dwSize += sizeof(LoaderHeapValidationTag);

#endif

}

dwSize = ((dwSize + ALLOC_ALIGN_CONSTANT) & (~ALLOC_ALIGN_CONSTANT));

}

return dwSize;

}

#ifdef _DEBUG

LoaderHeapValidationTag *AllocMem_GetTag(LPVOID pBlock, size_t dwRequestedSize)

{

LIMITED_METHOD_CONTRACT;

size_t dwSize = dwRequestedSize;

dwSize += LOADER_HEAP_DEBUG_BOUNDARY;

dwSize = ((dwSize + ALLOC_ALIGN_CONSTANT) & (~ALLOC_ALIGN_CONSTANT));

return (LoaderHeapValidationTag *)( ((BYTE*)pBlock) + dwSize );

}

#endif

//=====================================================================================

// UnlockedLoaderHeap methods

//=====================================================================================

#ifndef DACCESS_COMPILE

UnlockedLoaderHeap::UnlockedLoaderHeap(DWORD dwReserveBlockSize,

DWORD dwCommitBlockSize,

const BYTE* dwReservedRegionAddress,

SIZE_T dwReservedRegionSize,

RangeList *pRangeList,

HeapKind kind,

void (*codePageGenerator)(BYTE* pageBase, BYTE* pageBaseRX, SIZE_T size),

DWORD dwGranularity)

{

CONTRACTL

{

CONSTRUCTOR_CHECK;

NOTHROW;

FORBID_FAULT;

}

CONTRACTL_END;

m_pFirstBlock = NULL;

m_dwReserveBlockSize = dwReserveBlockSize;

m_dwCommitBlockSize = dwCommitBlockSize;

m_pPtrToEndOfCommittedRegion = NULL;

m_pEndReservedRegion = NULL;

m_pAllocPtr = NULL;

m_pRangeList = pRangeList;

// Round to VIRTUAL_ALLOC_RESERVE_GRANULARITY

m_dwTotalAlloc = 0;

_ASSERTE((GetStubCodePageSize() % GetOsPageSize()) == 0); // Stub code page size MUST be in increments of the page size. (Really it must be a power of 2 as well, but this is good enough)

m_dwGranularity = dwGranularity;

#ifdef _DEBUG

m_dwDebugWastedBytes = 0;

s_dwNumInstancesOfLoaderHeaps++;

m_pEventList = NULL;

m_dwDebugFlags = LoaderHeapSniffer::InitDebugFlags();

#endif

m_kind = kind;

_ASSERTE((kind != HeapKind::Interleaved) || (codePageGenerator != NULL));

m_codePageGenerator = codePageGenerator;

m_pFirstFreeBlock = NULL;

if (dwReservedRegionAddress != NULL && dwReservedRegionSize > 0)

{

m_reservedBlock.Init((void *)dwReservedRegionAddress, dwReservedRegionSize, FALSE);

}

}

// ~LoaderHeap is not synchronised (obviously)

UnlockedLoaderHeap::~UnlockedLoaderHeap()

{

CONTRACTL

{

DESTRUCTOR_CHECK;

NOTHROW;

FORBID_FAULT;

}

CONTRACTL_END

if (m_pRangeList != NULL)

m_pRangeList->RemoveRanges((void *) this);

LoaderHeapBlock *pSearch, *pNext;

for (pSearch = m_pFirstBlock; pSearch; pSearch = pNext)

{

void * pVirtualAddress;

BOOL fReleaseMemory;

pVirtualAddress = pSearch->pVirtualAddress;

fReleaseMemory = pSearch->m_fReleaseMemory;

pNext = pSearch->pNext;

if (fReleaseMemory)

{

ExecutableAllocator::Instance()->Release(pVirtualAddress);

}

delete pSearch;

}

if (m_reservedBlock.m_fReleaseMemory)

{

ExecutableAllocator::Instance()->Release(m_reservedBlock.pVirtualAddress);

}

INDEBUG(s_dwNumInstancesOfLoaderHeaps --;)

}

void UnlockedLoaderHeap::UnlockedSetReservedRegion(BYTE* dwReservedRegionAddress, SIZE_T dwReservedRegionSize, BOOL fReleaseMemory)

{

WRAPPER_NO_CONTRACT;

_ASSERTE(m_reservedBlock.pVirtualAddress == NULL);

m_reservedBlock.Init((void *)dwReservedRegionAddress, dwReservedRegionSize, fReleaseMemory);

}

#endif // #ifndef DACCESS_COMPILE

#if 0

// Disables access to all pages in the heap - useful when trying to determine if someone is

// accessing something in the low frequency heap

void UnlockedLoaderHeap::DebugGuardHeap()

{

WRAPPER_NO_CONTRACT;

LoaderHeapBlock *pSearch, *pNext;

for (pSearch = m_pFirstBlock; pSearch; pSearch = pNext)

{

void * pResult;