ZapBlobWithRelocs * ZapBlobWithRelocs::NewBlob(ZapWriter * pWriter, PVOID pData, SIZE_T cbSize)
{
S_SIZE_T cbAllocSize = S_SIZE_T(sizeof(ZapBlobWithRelocs)) + S_SIZE_T(cbSize);
if(cbAllocSize.IsOverflow())
ThrowHR(COR_E_OVERFLOW);
void * pMemory = new (pWriter->GetHeap()) BYTE[cbAllocSize.Value()];
ZapBlobWithRelocs * pZapBlobWithRelocs = new (pMemory) ZapBlobWithRelocs(cbSize);
if (pData != NULL)
memcpy((void*)(pZapBlobWithRelocs + 1), pData, cbSize);
return pZapBlobWithRelocs;
}
//------------------------------------------------------------------------
// ArenaAllocator::alloateMemory:
// Allocates memory using an `ArenaAllocator`.
//
// Arguments:
// size - The number of bytes to allocate.
//
// Return Value:
// A pointer to the allocated memory.
//
// Note:
// This is the DEBUG-only version of `allocateMemory`; the release
// version of this method is defined in the corresponding header file.
// This version of the method has some abilities that the release
// version does not: it may inject faults into the allocator and
// seeds all allocations with a specified pattern to help catch
// use-before-init problems.
void* ArenaAllocator::allocateMemory(size_t size)
{
assert(size != 0 && (size & (sizeof(int) - 1)) == 0);
// Ensure that we always allocate in pointer sized increments.
size = (size_t)roundUp(size, sizeof(size_t));
if (JitConfig.ShouldInjectFault() != 0)
{
// Force the underlying memory allocator (either the OS or the CLR hoster)
// to allocate the memory. Any fault injection will kick in.
void* p = ClrAllocInProcessHeap(0, S_SIZE_T(1));
if (p != nullptr)
{
ClrFreeInProcessHeap(0, p);
}
else
{
NOMEM(); // Throw!
}
}
void* block = m_nextFreeByte;
m_nextFreeByte += size;
if (m_nextFreeByte > m_lastFreeByte)
{
block = allocateNewPage(size);
}
memset(block, UninitializedWord<char>(), size);
return block;
}
static ZapBlobWithRelocs * NewBlob(ZapWriter * pWriter, PVOID pData, SIZE_T cbSize)
{
S_SIZE_T cbAllocSize = S_SIZE_T(sizeof(ZapAlignedBlobWithRelocsConst<alignment>)) + S_SIZE_T(cbSize);
if(cbAllocSize.IsOverflow())
ThrowHR(COR_E_OVERFLOW);
void * pMemory = new (pWriter->GetHeap()) BYTE[cbAllocSize.Value()];
ZapAlignedBlobWithRelocsConst<alignment> * pZapBlob = new (pMemory) ZapAlignedBlobWithRelocsConst<alignment>(cbSize);
if (pData != NULL)
memcpy((void*)(pZapBlob + 1), pData, cbSize);
return pZapBlob;
}
//------------------------------------------------------------------------
// ArenaAllocator::allocateHostMemory:
// Allocates memory from the host (or the OS if `bypassHostAllocator()`
// returns `true`).
//
// Arguments:
// size - The number of bytes to allocate.
//
// Return Value:
// A pointer to the allocated memory.
void* ArenaAllocator::allocateHostMemory(size_t size)
{
#if defined(DEBUG)
if (bypassHostAllocator())
{
return ::HeapAlloc(GetProcessHeap(), 0, size);
}
else
{
return ClrAllocInProcessHeap(0, S_SIZE_T(size));
}
#else // defined(DEBUG)
return m_memoryManager->ClrVirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
#endif // !defined(DEBUG)
}
DWORD dwNumBuckets,
AllocMemTracker *pamTracker)
{
CONTRACTL
{
STANDARD_VM_CHECK;
PRECONDITION(CheckPointer(pHeap));
}
CONTRACTL_END;
size_t size = sizeof(PendingTypeLoadTable);
BYTE * pMem;
PendingTypeLoadTable * pThis;
_ASSERT( dwNumBuckets >= 0 );
S_SIZE_T allocSize = S_SIZE_T( dwNumBuckets )
* S_SIZE_T( sizeof(PendingTypeLoadTable::TableEntry*) )
+ S_SIZE_T( size );
if( allocSize.IsOverflow() )
{
ThrowHR(E_INVALIDARG);
}
pMem = (BYTE *) pamTracker->Track(pHeap->AllocMem( allocSize ));
pThis = (PendingTypeLoadTable *) pMem;
#ifdef _DEBUG
pThis->m_dwDebugMemory = (DWORD)(size + dwNumBuckets*sizeof(PendingTypeLoadTable::TableEntry*));
#endif
pThis->m_dwNumBuckets = dwNumBuckets;
void * operator new[](size_t size, ZapHeap * pHeap)
{
return ((LoaderHeap*)pHeap)->AllocMem(S_SIZE_T(size));
}
void *SecurityProperties::operator new(size_t size, LoaderHeap *pHeap)
{
WRAPPER_NO_CONTRACT;
return pHeap->AllocMem(S_SIZE_T(size));
}
STANDARD_VM_CHECK;
PRECONDITION(CheckPointer(pSigModule, NULL_NOT_OK));
PRECONDITION(CheckPointer(ppNewSig, NULL_NOT_OK));
PRECONDITION(CheckPointer(pcbNewSig, NULL_NOT_OK));
}
CONTRACTL_END;
SigPointer sigPtr(pSig, cbSig);
SigBuilder sigBuilder;
sigPtr.ConvertToInternalSignature(pSigModule, pTypeContext, &sigBuilder);
DWORD cbNewSig;
PVOID pConvertedSig = sigBuilder.GetSignature(&cbNewSig);
PVOID pNewSig = pamTracker->Track(pCreationHeap->AllocMem(S_SIZE_T(cbNewSig)));
memcpy(pNewSig, pConvertedSig, cbNewSig);
*ppNewSig = (PCCOR_SIGNATURE)pNewSig;
*pcbNewSig = cbNewSig;
}
// static
MethodDesc* ILStubCache::CreateAndLinkNewILStubMethodDesc(LoaderAllocator* pAllocator, MethodTable* pMT, DWORD dwStubFlags,
Module* pSigModule, PCCOR_SIGNATURE pSig, DWORD cbSig, SigTypeContext *pTypeContext,
ILStubLinker* pStubLinker)
{
CONTRACT (MethodDesc*)
{
STANDARD_VM_CHECK;
PRECONDITION(CheckPointer(pMT, NULL_NOT_OK));
