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));