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

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

// See the LICENSE file in the project root for more information.

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

// File: CEELOAD.CPP

//

//

// CEELOAD reads in the PE file format using LoadLibrary

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

#include "common.h"

#include "array.h"

#include "ceeload.h"

#include "hash.h"

#include "vars.hpp"

#include "reflectclasswriter.h"

#include "method.hpp"

#include "stublink.h"

#include "cgensys.h"

#include "excep.h"

#include "dbginterface.h"

#include "dllimport.h"

#include "eeprofinterfaces.h"

#include "encee.h"

#include "jitinterface.h"

#include "eeconfig.h"

#include "dllimportcallback.h"

#include "contractimpl.h"

#include "typehash.h"

#include "instmethhash.h"

#include "virtualcallstub.h"

#include "typestring.h"

#include "stringliteralmap.h"

#include <formattype.h>

#include "fieldmarshaler.h"

#include "sigbuilder.h"

#include "metadataexports.h"

#include "inlinetracking.h"

#include "threads.h"

#ifdef FEATURE_PREJIT

#include "exceptionhandling.h"

#include "corcompile.h"

#include "compile.h"

#include "nibblestream.h"

#include "zapsig.h"

#endif //FEATURE_PREJIT

#ifdef FEATURE_COMINTEROP

#include "runtimecallablewrapper.h"

#include "comcallablewrapper.h"

#endif //FEATURE_COMINTEROP

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable:4724)

#endif // _MSC_VER

#include "ngenhash.inl"

#ifdef _MSC_VER

#pragma warning(pop)

#endif // _MSC_VER

#include "perflog.h"

#include "ecall.h"

#include "../md/compiler/custattr.h"

#include "typekey.h"

#include "peimagelayout.inl"

#include "ildbsymlib.h"

#if defined(PROFILING_SUPPORTED)

#include "profilermetadataemitvalidator.h"

#endif

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable:4244)

#endif // _MSC_VER

#ifdef _TARGET_64BIT_

#define COR_VTABLE_PTRSIZED COR_VTABLE_64BIT

#define COR_VTABLE_NOT_PTRSIZED COR_VTABLE_32BIT

#else // !_TARGET_64BIT_

#define COR_VTABLE_PTRSIZED COR_VTABLE_32BIT

#define COR_VTABLE_NOT_PTRSIZED COR_VTABLE_64BIT

#endif // !_TARGET_64BIT_

#define CEE_FILE_GEN_GROWTH_COLLECTIBLE 2048

#define NGEN_STATICS_ALLCLASSES_WERE_LOADED -1

BOOL Module::HasNativeOrReadyToRunInlineTrackingMap()

{

LIMITED_METHOD_DAC_CONTRACT;

#ifdef FEATURE_READYTORUN

if (IsReadyToRun() && GetReadyToRunInfo()->GetInlineTrackingMap() != NULL)

{

return TRUE;

}

#endif

return (m_pPersistentInlineTrackingMapNGen != NULL);

}

COUNT_T Module::GetNativeOrReadyToRunInliners(PTR_Module inlineeOwnerMod, mdMethodDef inlineeTkn, COUNT_T inlinersSize, MethodInModule inliners[], BOOL *incompleteData)

{

WRAPPER_NO_CONTRACT;

#ifdef FEATURE_READYTORUN

if(IsReadyToRun() && GetReadyToRunInfo()->GetInlineTrackingMap() != NULL)

{

return GetReadyToRunInfo()->GetInlineTrackingMap()->GetInliners(inlineeOwnerMod, inlineeTkn, inlinersSize, inliners, incompleteData);

}

#endif

if(m_pPersistentInlineTrackingMapNGen != NULL)

{

return m_pPersistentInlineTrackingMapNGen->GetInliners(inlineeOwnerMod, inlineeTkn, inlinersSize, inliners, incompleteData);

}

return 0;

}

#if defined(PROFILING_SUPPORTED) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)

BOOL Module::HasJitInlineTrackingMap()

{

LIMITED_METHOD_CONTRACT;

return m_pJitInlinerTrackingMap != NULL;

}

void Module::AddInlining(MethodDesc *inliner, MethodDesc *inlinee)

{

STANDARD_VM_CONTRACT;

_ASSERTE(inliner != NULL && inlinee != NULL);

_ASSERTE(inlinee->GetModule() == this);

if (m_pJitInlinerTrackingMap != NULL)

{

m_pJitInlinerTrackingMap->AddInlining(inliner, inlinee);

}

}

#endif // defined(PROFILING_SUPPORTED) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)

#ifndef DACCESS_COMPILE

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

// Module

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

//---------------------------------------------------------------------------------------------------

// This wrapper just invokes the real initialization inside a try/hook.

// szName is not null only for dynamic modules

//---------------------------------------------------------------------------------------------------

void Module::DoInit(AllocMemTracker *pamTracker, LPCWSTR szName)

{

CONTRACTL

{

INSTANCE_CHECK;

STANDARD_VM_CHECK;

}

CONTRACTL_END;

#ifdef PROFILING_SUPPORTED

{

BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());

GCX_COOP();

g_profControlBlock.pProfInterface->ModuleLoadStarted((ModuleID) this);

END_PIN_PROFILER();

}

// Need TRY/HOOK instead of holder so we can get HR of exception thrown for profiler callback

EX_TRY

#endif

{

Initialize(pamTracker, szName);

}

#ifdef PROFILING_SUPPORTED

EX_HOOK

{

{

BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());

g_profControlBlock.pProfInterface->ModuleLoadFinished((ModuleID) this, GET_EXCEPTION()->GetHR());

END_PIN_PROFILER();

}

}

EX_END_HOOK;

#endif

}

// Set the given bit on m_dwTransientFlags. Return true if we won the race to set the bit.

BOOL Module::SetTransientFlagInterlocked(DWORD dwFlag)

{

LIMITED_METHOD_CONTRACT;

for (;;)

{

DWORD dwTransientFlags = m_dwTransientFlags;

if ((dwTransientFlags & dwFlag) != 0)

return FALSE;

if ((DWORD)FastInterlockCompareExchange((LONG*)&m_dwTransientFlags, dwTransientFlags | dwFlag, dwTransientFlags) == dwTransientFlags)

return TRUE;

}

}

#if PROFILING_SUPPORTED

void Module::UpdateNewlyAddedTypes()

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END

DWORD countTypesAfterProfilerUpdate = GetMDImport()->GetCountWithTokenKind(mdtTypeDef);

DWORD countExportedTypesAfterProfilerUpdate = GetMDImport()->GetCountWithTokenKind(mdtExportedType);

DWORD countCustomAttributeCount = GetMDImport()->GetCountWithTokenKind(mdtCustomAttribute);

// R2R pre-computes an export table and tries to avoid populating a class hash at runtime. However the profiler can

// still add new types on the fly by calling here. If that occurs we fallback to the slower path of creating the

// in memory hashtable as usual.

if (!IsResource() && GetAvailableClassHash() == NULL)

{

// This call will populate the hash tables with anything that is in metadata already.

GetClassLoader()->LazyPopulateCaseSensitiveHashTablesDontHaveLock();

}

else

{

// If the hash tables already exist (either R2R and we've previously populated the ) we need to manually add the types.

// typeDefs rids 0 and 1 aren't included in the count, thus X typeDefs before means rid X+1 was valid and our incremental addition should start at X+2

for (DWORD typeDefRid = m_dwTypeCount + 2; typeDefRid < countTypesAfterProfilerUpdate + 2; typeDefRid++)

{

GetAssembly()->AddType(this, TokenFromRid(typeDefRid, mdtTypeDef));

}

// exportedType rid 0 isn't included in the count, thus X exportedTypes before means rid X was valid and our incremental addition should start at X+1

for (DWORD exportedTypeDef = m_dwExportedTypeCount + 1; exportedTypeDef < countExportedTypesAfterProfilerUpdate + 1; exportedTypeDef++)

{

GetAssembly()->AddExportedType(TokenFromRid(exportedTypeDef, mdtExportedType));

}

if ((countCustomAttributeCount != m_dwCustomAttributeCount) && IsReadyToRun())

{

// Set of custom attributes has changed. Disable the cuckoo filter from ready to run, and do normal custom attribute parsing

GetReadyToRunInfo()->DisableCustomAttributeFilter();

}

}

m_dwTypeCount = countTypesAfterProfilerUpdate;

m_dwExportedTypeCount = countExportedTypesAfterProfilerUpdate;

m_dwCustomAttributeCount = countCustomAttributeCount;

}

void Module::NotifyProfilerLoadFinished(HRESULT hr)

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM());

MODE_ANY;

}

CONTRACTL_END;

// Note that in general we wil reuse shared modules. So we need to make sure we only notify

// the profiler once.

if (SetTransientFlagInterlocked(IS_PROFILER_NOTIFIED))

{

// Record how many types are already present

if (!IsResource())

{

m_dwTypeCount = GetMDImport()->GetCountWithTokenKind(mdtTypeDef);

m_dwExportedTypeCount = GetMDImport()->GetCountWithTokenKind(mdtExportedType);

m_dwCustomAttributeCount = GetMDImport()->GetCountWithTokenKind(mdtCustomAttribute);

}

// Notify the profiler, this may cause metadata to be updated

{

BEGIN_PIN_PROFILER(CORProfilerTrackModuleLoads());

{

GCX_PREEMP();

g_profControlBlock.pProfInterface->ModuleLoadFinished((ModuleID) this, hr);

if (SUCCEEDED(hr))

{

g_profControlBlock.pProfInterface->ModuleAttachedToAssembly((ModuleID) this,

(AssemblyID)m_pAssembly);

}

}

END_PIN_PROFILER();

}

// If there are more types than before, add these new types to the

// assembly

if (!IsResource())

{

UpdateNewlyAddedTypes();

}

{

BEGIN_PIN_PROFILER(CORProfilerTrackAssemblyLoads());

if (IsManifest())

{

GCX_COOP();

g_profControlBlock.pProfInterface->AssemblyLoadFinished((AssemblyID) m_pAssembly, hr);

}

END_PIN_PROFILER();

}

}

}

#ifndef CROSSGEN_COMPILE

IMetaDataEmit *Module::GetValidatedEmitter()

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_NOTRIGGER;

INJECT_FAULT(COMPlusThrowOM());

MODE_ANY;

}

CONTRACTL_END;

if (m_pValidatedEmitter.Load() == NULL)

{

// In the past profilers could call any API they wanted on the the IMetaDataEmit interface and we didn't

// verify anything. To ensure we don't break back-compat the verifications are not enabled by default.

// Right now I have only added verifications for NGEN images, but in the future we might want verifications

// for all modules.

IMetaDataEmit* pEmit = NULL;

if (CLRConfig::GetConfigValue(CLRConfig::UNSUPPORTED_ProfAPI_ValidateNGENInstrumentation) && HasNativeImage())

{

ProfilerMetadataEmitValidator* pValidator = new ProfilerMetadataEmitValidator(GetEmitter());

pValidator->QueryInterface(IID_IMetaDataEmit, (void**)&pEmit);

}

else

{

pEmit = GetEmitter();

pEmit->AddRef();

}

// Atomically swap it into the field (release it if we lose the race)

if (FastInterlockCompareExchangePointer(&m_pValidatedEmitter, pEmit, NULL) != NULL)

{

pEmit->Release();

}

}

return m_pValidatedEmitter.Load();

}

#endif // CROSSGEN_COMPILE

#endif // PROFILING_SUPPORTED

void Module::NotifyEtwLoadFinished(HRESULT hr)

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

}

CONTRACTL_END

// we report only successful loads

if (SUCCEEDED(hr) &&

ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context,

TRACE_LEVEL_INFORMATION,

KEYWORDZERO))

{

BOOL fSharedModule = !SetTransientFlagInterlocked(IS_ETW_NOTIFIED);

ETW::LoaderLog::ModuleLoad(this, fSharedModule);

}

}

// Module initialization occurs in two phases: the constructor phase and the Initialize phase.

//

// The constructor phase initializes just enough so that Destruct() can be safely called.

// It cannot throw or fail.

//

Module::Module(Assembly *pAssembly, mdFile moduleRef, PEFile *file)

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

FORBID_FAULT;

}

CONTRACTL_END

PREFIX_ASSUME(pAssembly != NULL);

m_pAssembly = pAssembly;

m_moduleRef = moduleRef;

m_file = file;

m_dwTransientFlags = CLASSES_FREED;

if (!m_file->HasNativeImage())

{

// Memory allocated on LoaderHeap is zero-filled. Spot-check it here.

_ASSERTE(m_pBinder == NULL);

_ASSERTE(m_symbolFormat == eSymbolFormatNone);

}

file->AddRef();

}

void Module::InitializeForProfiling()

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_TRIGGERS;

MODE_PREEMPTIVE;

PRECONDITION(HasNativeOrReadyToRunImage());

}

CONTRACTL_END;

COUNT_T cbProfileList = 0;

m_nativeImageProfiling = FALSE;

#ifdef FEATURE_PREJIT

if (HasNativeImage())

{

PEImageLayout * pNativeImage = GetNativeImage();

CORCOMPILE_VERSION_INFO * pNativeVersionInfo = pNativeImage->GetNativeVersionInfoMaybeNull();

if ((pNativeVersionInfo != NULL) && (pNativeVersionInfo->wConfigFlags & CORCOMPILE_CONFIG_INSTRUMENTATION))

{

m_nativeImageProfiling = GetAssembly()->IsInstrumented();

}

// Link the module to the profile data list if available.

m_methodProfileList = pNativeImage->GetNativeProfileDataList(&cbProfileList);

}

else // ReadyToRun image

#endif

{

#ifdef FEATURE_READYTORUN

// We already setup the m_methodProfileList in the ReadyToRunInfo constructor

if (m_methodProfileList != nullptr)

{

ReadyToRunInfo * pInfo = GetReadyToRunInfo();

PEImageLayout * pImage = pInfo->GetImage();

// Enable profiling if the ZapBBInstr value says to

m_nativeImageProfiling = GetAssembly()->IsInstrumented();

}

#endif

}

}

#ifdef FEATURE_PREJIT

void Module::InitializeNativeImage(AllocMemTracker* pamTracker)

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_TRIGGERS;

MODE_PREEMPTIVE;

PRECONDITION(HasNativeImage());

}

CONTRACTL_END;

PEImageLayout * pNativeImage = GetNativeImage();

ExecutionManager::AddNativeImageRange(dac_cast<TADDR>(pNativeImage->GetBase()), pNativeImage->GetVirtualSize(), this);

#ifndef CROSSGEN_COMPILE

LoadTokenTables();

LoadHelperTable();

#endif // CROSSGEN_COMPILE

#if defined(HAVE_GCCOVER)

if (GCStress<cfg_instr_ngen>::IsEnabled())

{

// Setting up gc coverage requires the base system classes

// to be initialized. So we must defer this for mscorlib.

if(!IsSystem())

{

SetupGcCoverageForNativeImage(this);

}

}

#endif // defined(HAVE_GCCOVER)

}

#else // FEATURE_PREJIT

BOOL Module::IsPersistedObject(void *address)

{

LIMITED_METHOD_CONTRACT;

return FALSE;

}

#endif // FEATURE_PREJIT

void Module::SetNativeMetadataAssemblyRefInCache(DWORD rid, PTR_Assembly pAssembly)

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

MODE_ANY;

}

CONTRACTL_END;

if (m_NativeMetadataAssemblyRefMap == NULL)

{

IMDInternalImport* pImport = GetNativeAssemblyImport();

DWORD dwMaxRid = pImport->GetCountWithTokenKind(mdtAssemblyRef);

_ASSERTE(dwMaxRid > 0);

S_SIZE_T dwAllocSize = S_SIZE_T(sizeof(PTR_Assembly)) * S_SIZE_T(dwMaxRid);

AllocMemTracker amTracker;

PTR_Assembly* NativeMetadataAssemblyRefMap = (PTR_Assembly*)amTracker.Track(GetLoaderAllocator()->GetLowFrequencyHeap()->AllocMem(dwAllocSize));

// Note: Memory allocated on loader heap is zero filled

if (InterlockedCompareExchangeT<PTR_Assembly*>(&m_NativeMetadataAssemblyRefMap, NativeMetadataAssemblyRefMap, NULL) == NULL)

amTracker.SuppressRelease();

}

_ASSERTE(m_NativeMetadataAssemblyRefMap != NULL);

_ASSERTE(rid <= GetNativeAssemblyImport()->GetCountWithTokenKind(mdtAssemblyRef));

m_NativeMetadataAssemblyRefMap[rid - 1] = pAssembly;

}

// Module initialization occurs in two phases: the constructor phase and the Initialize phase.

//

// The Initialize() phase completes the initialization after the constructor has run.

// It can throw exceptions but whether it throws or succeeds, it must leave the Module

// in a state where Destruct() can be safely called.

//

// szName is only used by dynamic modules, see ReflectionModule::Initialize

//

//

void Module::Initialize(AllocMemTracker *pamTracker, LPCWSTR szName)

{

CONTRACTL

{

INSTANCE_CHECK;

STANDARD_VM_CHECK;

PRECONDITION(szName == NULL);

}

CONTRACTL_END;

m_pSimpleName = m_file->GetSimpleName();

m_Crst.Init(CrstModule);

m_LookupTableCrst.Init(CrstModuleLookupTable, CrstFlags(CRST_UNSAFE_ANYMODE | CRST_DEBUGGER_THREAD));

m_FixupCrst.Init(CrstModuleFixup, (CrstFlags)(CRST_HOST_BREAKABLE|CRST_REENTRANCY));

m_InstMethodHashTableCrst.Init(CrstInstMethodHashTable, CRST_REENTRANCY);

m_ISymUnmanagedReaderCrst.Init(CrstISymUnmanagedReader, CRST_DEBUGGER_THREAD);

if (!m_file->HasNativeImage())

{

AllocateMaps();

if (IsSystem() ||

(strcmp(m_pSimpleName, "System") == 0) ||

(strcmp(m_pSimpleName, "System.Core") == 0) ||

(strcmp(m_pSimpleName, "Windows.Foundation") == 0))

{

FastInterlockOr(&m_dwPersistedFlags, LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME);

}

}

m_dwTransientFlags &= ~((DWORD)CLASSES_FREED); // Set flag indicating LookupMaps are now in a consistent and destructable state

#ifdef FEATURE_COLLECTIBLE_TYPES

if (GetAssembly()->IsCollectible())

{

FastInterlockOr(&m_dwPersistedFlags, COLLECTIBLE_MODULE);

}

#endif // FEATURE_COLLECTIBLE_TYPES

#ifdef FEATURE_READYTORUN

if (!HasNativeImage() && !IsResource())

{

if ((m_pReadyToRunInfo = ReadyToRunInfo::Initialize(this, pamTracker)) != NULL)

{

COUNT_T cMeta = 0;

if (GetFile()->GetOpenedILimage()->GetNativeManifestMetadata(&cMeta) != NULL)

{

// Load the native assembly import

GetNativeAssemblyImport(TRUE /* loadAllowed */);

}

}

}

#endif

// Initialize the instance fields that we need for all non-Resource Modules

if (!IsResource())

{

if (m_pAvailableClasses == NULL && !IsReadyToRun())

{

m_pAvailableClasses = EEClassHashTable::Create(this,

GetAssembly()->IsCollectible() ? AVAILABLE_CLASSES_HASH_BUCKETS_COLLECTIBLE : AVAILABLE_CLASSES_HASH_BUCKETS,

FALSE /* bCaseInsensitive */, pamTracker);

}

if (m_pAvailableParamTypes == NULL)

{

m_pAvailableParamTypes = EETypeHashTable::Create(GetLoaderAllocator(), this, PARAMTYPES_HASH_BUCKETS, pamTracker);

}

if (m_pInstMethodHashTable == NULL)

{

m_pInstMethodHashTable = InstMethodHashTable::Create(GetLoaderAllocator(), this, PARAMMETHODS_HASH_BUCKETS, pamTracker);

}

if(m_pMemberRefToDescHashTable == NULL)

{

if (IsReflection())

{

m_pMemberRefToDescHashTable = MemberRefToDescHashTable::Create(this, MEMBERREF_MAP_INITIAL_SIZE, pamTracker);

}

else

{

IMDInternalImport * pImport = GetMDImport();

// Get #MemberRefs and create memberrefToDesc hash table

m_pMemberRefToDescHashTable = MemberRefToDescHashTable::Create(this, pImport->GetCountWithTokenKind(mdtMemberRef)+1, pamTracker);

}

}

#if defined(FEATURE_COMINTEROP) && defined(FEATURE_PREJIT)

if (IsCompilationProcess() && m_pGuidToTypeHash == NULL)

{

// only allocate this during NGEN-ing

m_pGuidToTypeHash = GuidToMethodTableHashTable::Create(this, GUID_TO_TYPE_HASH_BUCKETS, pamTracker);

}

#endif // FEATURE_COMINTEROP

}

// this will be initialized a bit later.

m_ModuleID = NULL;

m_ModuleIndex.m_dwIndex = (SIZE_T)-1;

// These will be initialized in NotifyProfilerLoadFinished, set them to

// a safe initial value now.

m_dwTypeCount = 0;

m_dwExportedTypeCount = 0;

m_dwCustomAttributeCount = 0;

// Prepare statics that are known at module load time

AllocateStatics(pamTracker);

#ifdef FEATURE_PREJIT

// Set up native image

if (HasNativeImage())

{

InitializeNativeImage(pamTracker);

}

#endif // FEATURE_PREJIT

if (HasNativeOrReadyToRunImage())

{

InitializeForProfiling();

}

#ifdef FEATURE_NATIVE_IMAGE_GENERATION

if (g_CorCompileVerboseLevel)

m_pNgenStats = new NgenStats();

#endif

if (!IsResource() && (m_AssemblyRefByNameTable == NULL))

{

Module::CreateAssemblyRefByNameTable(pamTracker);

}

// If the program has the "ForceEnc" env variable set we ensure every eligible

// module has EnC turned on.

if (g_pConfig->ForceEnc() && IsEditAndContinueCapable())

EnableEditAndContinue();

#if defined(PROFILING_SUPPORTED) && !defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)

m_pJitInlinerTrackingMap = NULL;

if (ReJitManager::IsReJITInlineTrackingEnabled())

{

m_pJitInlinerTrackingMap = new JITInlineTrackingMap(GetLoaderAllocator());

}

#endif // defined (PROFILING_SUPPORTED) &&!defined(DACCESS_COMPILE) && !defined(CROSSGEN_COMPILE)

LOG((LF_CLASSLOADER, LL_INFO10, "Loaded pModule: \"%ws\".\n", GetDebugName()));

}

#endif // DACCESS_COMPILE

#ifdef FEATURE_COMINTEROP

#ifndef DACCESS_COMPILE

// static

GuidToMethodTableHashTable* GuidToMethodTableHashTable::Create(Module* pModule, DWORD cInitialBuckets,

AllocMemTracker *pamTracker)

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

PRECONDITION(!FORBIDGC_LOADER_USE_ENABLED());

}

CONTRACTL_END;

LoaderHeap *pHeap = pModule->GetAssembly()->GetLowFrequencyHeap();

GuidToMethodTableHashTable *pThis = (GuidToMethodTableHashTable*)pamTracker->Track(pHeap->AllocMem((S_SIZE_T)sizeof(GuidToMethodTableHashTable)));

// The base class get initialized through chaining of constructors. We allocated the hash instance via the

// loader heap instead of new so use an in-place new to call the constructors now.

new (pThis) GuidToMethodTableHashTable(pModule, pHeap, cInitialBuckets);

return pThis;

}

GuidToMethodTableEntry *GuidToMethodTableHashTable::InsertValue(PTR_GUID pGuid, PTR_MethodTable pMT,

BOOL bReplaceIfFound, AllocMemTracker *pamTracker)

{

CONTRACTL

{

THROWS;

GC_NOTRIGGER;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

PRECONDITION(!FORBIDGC_LOADER_USE_ENABLED());

}

CONTRACTL_END;

GuidToMethodTableEntry *pEntry = NULL;

if (bReplaceIfFound)

{

pEntry = FindItem(pGuid, NULL);

}

if (pEntry != NULL)

{

pEntry->m_pMT = pMT;

}

else

{

pEntry = BaseAllocateEntry(pamTracker);

pEntry->m_Guid = pGuid;

pEntry->m_pMT = pMT;

DWORD hash = Hash(pGuid);

BaseInsertEntry(hash, pEntry);

}

return pEntry;

}

#endif // !DACCESS_COMPILE

PTR_MethodTable GuidToMethodTableHashTable::GetValue(const GUID * pGuid, LookupContext *pContext)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

SUPPORTS_DAC;

PRECONDITION(CheckPointer(pGuid));

}

CONTRACTL_END;

GuidToMethodTableEntry * pEntry = FindItem(pGuid, pContext);

if (pEntry != NULL)

{

return pEntry->m_pMT;

}

return NULL;

}

GuidToMethodTableEntry *GuidToMethodTableHashTable::FindItem(const GUID * pGuid, LookupContext *pContext)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

SUPPORTS_DAC;

PRECONDITION(CheckPointer(pGuid));

}

CONTRACTL_END;

// It's legal for the caller not to pass us a LookupContext, but we might need to iterate

// internally (since we lookup via hash and hashes may collide). So substitute our own

// private context if one was not provided.

LookupContext sAltContext;

if (pContext == NULL)

pContext = &sAltContext;

// The base class provides the ability to enumerate all entries with the same hash code.

// We further check which of these entries actually match the full key.

PTR_GuidToMethodTableEntry pSearch = BaseFindFirstEntryByHash(Hash(pGuid), pContext);

while (pSearch)

{

if (CompareKeys(pSearch, pGuid))

{

return pSearch;

}

pSearch = BaseFindNextEntryByHash(pContext);

}

return NULL;

}

BOOL GuidToMethodTableHashTable::CompareKeys(PTR_GuidToMethodTableEntry pEntry, const GUID * pGuid)

{

LIMITED_METHOD_DAC_CONTRACT;

return *pGuid == *(pEntry->m_Guid);

}

DWORD GuidToMethodTableHashTable::Hash(const GUID * pGuid)

{

LIMITED_METHOD_DAC_CONTRACT;

static_assert_no_msg(sizeof(GUID) % sizeof(DWORD) == 0);

static_assert_no_msg(sizeof(GUID) / sizeof(DWORD) == 4);

DWORD * pSlice = (DWORD*) pGuid;

return pSlice[0] ^ pSlice[1] ^ pSlice[2] ^ pSlice[3];

}

BOOL GuidToMethodTableHashTable::FindNext(Iterator *it, GuidToMethodTableEntry **ppEntry)

{

LIMITED_METHOD_DAC_CONTRACT;

if (!it->m_fIterating)

{

BaseInitIterator(&it->m_sIterator);

it->m_fIterating = true;

}

*ppEntry = it->m_sIterator.Next();

return *ppEntry ? TRUE : FALSE;

}

DWORD GuidToMethodTableHashTable::GetCount()

{

LIMITED_METHOD_DAC_CONTRACT;

return BaseGetElementCount();

}

#if defined(FEATURE_NATIVE_IMAGE_GENERATION) && !defined(DACCESS_COMPILE)

void GuidToMethodTableHashTable::Save(DataImage *pImage, CorProfileData *pProfileData)

{

WRAPPER_NO_CONTRACT;

Base_t::BaseSave(pImage, pProfileData);

}

void GuidToMethodTableHashTable::Fixup(DataImage *pImage)

{

WRAPPER_NO_CONTRACT;

Base_t::BaseFixup(pImage);

}

bool GuidToMethodTableHashTable::SaveEntry(DataImage *pImage, CorProfileData *pProfileData,

GuidToMethodTableEntry *pOldEntry, GuidToMethodTableEntry *pNewEntry,

EntryMappingTable *pMap)

{

LIMITED_METHOD_CONTRACT;

return false;

}

void GuidToMethodTableHashTable::FixupEntry(DataImage *pImage, GuidToMethodTableEntry *pEntry, void *pFixupBase, DWORD cbFixupOffset)

{

WRAPPER_NO_CONTRACT;

pImage->FixupField(pFixupBase, cbFixupOffset + offsetof(GuidToMethodTableEntry, m_pMT), pEntry->m_pMT);

pImage->FixupField(pFixupBase, cbFixupOffset + offsetof(GuidToMethodTableEntry, m_Guid), pEntry->m_Guid);

}

#endif // FEATURE_NATIVE_IMAGE_GENERATION && !DACCESS_COMPILE

#ifdef FEATURE_PREJIT

#ifndef DACCESS_COMPILE

BOOL Module::CanCacheWinRTTypeByGuid(MethodTable *pMT)

{

CONTRACTL

{

THROWS;

GC_NOTRIGGER;

MODE_ANY;

PRECONDITION(IsCompilationProcess());

}

CONTRACTL_END;

// Don't cache WinRT types in collectible modules.

if (IsCollectible())

{

return FALSE;

}

// Don't cache mscorlib-internal declarations of WinRT types.

if (IsSystem() && pMT->IsProjectedFromWinRT())

return FALSE;

// Don't cache redirected WinRT types.

if (WinRTTypeNameConverter::IsRedirectedWinRTSourceType(pMT))

return FALSE;

#ifdef FEATURE_NATIVE_IMAGE_GENERATION

// Don't cache in a module that's not the NGen target, since the result

// won't be saved, and since the such a module might be read-only.

if (GetAppDomain()->ToCompilationDomain()->GetTargetModule() != this)

return FALSE;

#endif

return TRUE;

}

void Module::CacheWinRTTypeByGuid(PTR_MethodTable pMT, PTR_GuidInfo pgi /*= NULL*/)

{

CONTRACTL

{

STANDARD_VM_CHECK;

PRECONDITION(CheckPointer(pMT));

PRECONDITION(pMT->IsLegalNonArrayWinRTType());

PRECONDITION(pgi != NULL || pMT->GetGuidInfo() != NULL);

PRECONDITION(IsCompilationProcess());

}

CONTRACTL_END;

if (pgi == NULL)

{

pgi = pMT->GetGuidInfo();

}

AllocMemTracker amt;

m_pGuidToTypeHash->InsertValue(&pgi->m_Guid, pMT, TRUE, &amt);

amt.SuppressRelease();

}

#endif // !DACCESS_COMPILE

PTR_MethodTable Module::LookupTypeByGuid(const GUID & guid)

{

WRAPPER_NO_CONTRACT;

// Triton ni images do not have this hash.

if (m_pGuidToTypeHash != NULL)

return m_pGuidToTypeHash->GetValue(&guid, NULL);

else

return NULL;

}

void Module::GetCachedWinRTTypes(SArray<PTR_MethodTable> * pTypes, SArray<GUID> * pGuids)

{

CONTRACTL

{

STANDARD_VM_CHECK;

SUPPORTS_DAC;

}

CONTRACTL_END;

// Triton ni images do not have this hash.

if (m_pGuidToTypeHash != NULL)

{

GuidToMethodTableHashTable::Iterator it(m_pGuidToTypeHash);

GuidToMethodTableEntry *pEntry;

while (m_pGuidToTypeHash->FindNext(&it, &pEntry))

{

pTypes->Append(pEntry->m_pMT);

pGuids->Append(*pEntry->m_Guid);

}

}

}

#endif // FEATURE_PREJIT

#endif // FEATURE_COMINTEROP

#ifndef DACCESS_COMPILE

MemberRefToDescHashTable* MemberRefToDescHashTable::Create(Module *pModule, DWORD cInitialBuckets, AllocMemTracker *pamTracker)

{

CONTRACTL

{

THROWS;

GC_TRIGGERS;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

PRECONDITION(!FORBIDGC_LOADER_USE_ENABLED());

}

CONTRACTL_END;

LoaderHeap *pHeap = pModule->GetAssembly()->GetLowFrequencyHeap();

MemberRefToDescHashTable *pThis = (MemberRefToDescHashTable*)pamTracker->Track(pHeap->AllocMem((S_SIZE_T)sizeof(MemberRefToDescHashTable)));