// 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: clsload.cpp

//

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

#include "common.h"

#include "winwrap.h"

#include "ceeload.h"

#include "siginfo.hpp"

#include "vars.hpp"

#include "clsload.hpp"

#include "classhash.inl"

#include "class.h"

#include "method.hpp"

#include "ecall.h"

#include "stublink.h"

#include "object.h"

#include "excep.h"

#include "threads.h"

#include "comsynchronizable.h"

#include "threads.h"

#include "dllimport.h"

#include "dbginterface.h"

#include "log.h"

#include "eeconfig.h"

#include "fieldmarshaler.h"

#include "jitinterface.h"

#include "vars.hpp"

#include "assembly.hpp"

#include "eeprofinterfaces.h"

#include "eehash.h"

#include "typehash.h"

#include "comdelegate.h"

#include "array.h"

#include "posterror.h"

#include "wrappers.h"

#include "generics.h"

#include "typestring.h"

#include "typedesc.h"

#include "cgencpu.h"

#include "eventtrace.h"

#include "typekey.h"

#include "pendingload.h"

#include "proftoeeinterfaceimpl.h"

#include "virtualcallstub.h"

#include "stringarraylist.h"

// This method determines the "loader module" for an instantiated type

// or method. The rule must ensure that any types involved in the

// instantiated type or method do not outlive the loader module itself

// with respect to app-domain unloading (e.g. MyList<MyType> can't be

// put in the module of MyList if MyList's assembly is

// app-domain-neutral but MyType's assembly is app-domain-specific).

// The rule we use is:

//

// * Pick the first type in the class instantiation, followed by

// method instantiation, whose loader module is non-shared (app-domain-bound)

// * If no type is app-domain-bound, return the module containing the generic type itself

//

// Some useful effects of this rule (for ngen purposes) are:

//

// * G<object,...,object> lives in the module defining G

// * non-mscorlib instantiations of mscorlib-defined generic types live in the module

// of the instantiation (when only one module is invloved in the instantiation)

//

/* static */

PTR_Module ClassLoader::ComputeLoaderModuleWorker(

Module * pDefinitionModule, // the module that declares the generic type or method

mdToken token, // method or class token for this item

Instantiation classInst, // the type arguments to the type (if any)

Instantiation methodInst) // the type arguments to the method (if any)

{

CONTRACT(Module*)

{

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

MODE_ANY;

PRECONDITION(CheckPointer(pDefinitionModule, NULL_OK));

POSTCONDITION(CheckPointer(RETVAL));

SUPPORTS_DAC;

}

CONTRACT_END

if (classInst.IsEmpty() && methodInst.IsEmpty())

RETURN PTR_Module(pDefinitionModule);

#ifndef DACCESS_COMPILE

#ifdef FEATURE_NATIVE_IMAGE_GENERATION

//

// Use special loader module placement during compilation of fragile native images.

//

// ComputeLoaderModuleForCompilation algorithm assumes that we are using fragile native image

// for CoreLib (or compiling CoreLib itself). It is not the case for ReadyToRun compilation because

// CoreLib as always treated as IL there (see code:PEFile::ShouldTreatNIAsMSIL for details).

//

if (IsCompilationProcess() && !IsReadyToRunCompilation())

{

RETURN(ComputeLoaderModuleForCompilation(pDefinitionModule, token, classInst, methodInst));

}

#endif // FEATURE_PREJIT

#endif // #ifndef DACCESS_COMPILE

Module *pLoaderModule = NULL;

if (pDefinitionModule)

{

if (pDefinitionModule->IsCollectible())

goto ComputeCollectibleLoaderModule;

pLoaderModule = pDefinitionModule;

}

for (DWORD i = 0; i < classInst.GetNumArgs(); i++)

{

TypeHandle classArg = classInst[i];

_ASSERTE(!classArg.IsEncodedFixup());

Module* pModule = classArg.GetLoaderModule();

if (pModule->IsCollectible())

goto ComputeCollectibleLoaderModule;

if (pLoaderModule == NULL)

pLoaderModule = pModule;

}

for (DWORD i = 0; i < methodInst.GetNumArgs(); i++)

{

TypeHandle methodArg = methodInst[i];

_ASSERTE(!methodArg.IsEncodedFixup());

Module *pModule = methodArg.GetLoaderModule();

if (pModule->IsCollectible())

goto ComputeCollectibleLoaderModule;

if (pLoaderModule == NULL)

pLoaderModule = pModule;

}

if (pLoaderModule == NULL)

{

CONSISTENCY_CHECK(MscorlibBinder::GetModule() && MscorlibBinder::GetModule()->IsSystem());

pLoaderModule = MscorlibBinder::GetModule();

}

if (FALSE)

{

ComputeCollectibleLoaderModule:

LoaderAllocator *pLoaderAllocatorOfDefiningType = NULL;

LoaderAllocator *pOldestLoaderAllocator = NULL;

Module *pOldestLoaderModule = NULL;

UINT64 oldestFoundAge = 0;

DWORD classArgsCount = classInst.GetNumArgs();

DWORD totalArgsCount = classArgsCount + methodInst.GetNumArgs();

if (pDefinitionModule != NULL) pLoaderAllocatorOfDefiningType = pDefinitionModule->GetLoaderAllocator();

for (DWORD i = 0; i < totalArgsCount; i++) {

TypeHandle arg;

if (i < classArgsCount)

arg = classInst[i];

else

arg = methodInst[i - classArgsCount];

Module *pModuleCheck = arg.GetLoaderModule();

LoaderAllocator *pLoaderAllocatorCheck = pModuleCheck->GetLoaderAllocator();

if (pLoaderAllocatorCheck != pLoaderAllocatorOfDefiningType &&

pLoaderAllocatorCheck->IsCollectible() &&

pLoaderAllocatorCheck->GetCreationNumber() > oldestFoundAge)

{

pOldestLoaderModule = pModuleCheck;

pOldestLoaderAllocator = pLoaderAllocatorCheck;

oldestFoundAge = pLoaderAllocatorCheck->GetCreationNumber();

}

}

// Only if we didn't find a different loader allocator than the defining loader allocator do we

// use the defining loader allocator

if (pOldestLoaderModule != NULL)

pLoaderModule = pOldestLoaderModule;

else

pLoaderModule = pDefinitionModule;

}

RETURN PTR_Module(pLoaderModule);

}

#ifndef DACCESS_COMPILE

#ifdef FEATURE_NATIVE_IMAGE_GENERATION

/* static */

PTR_Module ClassLoader::ComputeLoaderModuleForCompilation(

Module * pDefinitionModule, // the module that declares the generic type or method

mdToken token, // method or class token for this item

Instantiation classInst, // the type arguments to the type (if any)

Instantiation methodInst) // the type arguments to the method (if any)

{

CONTRACT(Module*)

{

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

MODE_ANY;

PRECONDITION(CheckPointer(pDefinitionModule, NULL_OK));

POSTCONDITION(CheckPointer(RETVAL));

}

CONTRACT_END

// The NGEN rule for compiling constructed types and instantiated methods

// into modules other than their "natural" LoaderModule. This is at the heart of

// "full generics NGEN".

//

// If this instantiation doesn't have a unique home then use the ngen module

// OK, we're certainly NGEN'ing. And if we're NGEN'ing then we're not on the debugger thread.

CONSISTENCY_CHECK(((GetThread() && GetAppDomain()) || IsGCThread()) &&

"unexpected: running a load on debug thread but IsCompilationProcess() returned TRUE");

// Save it into its PreferredZapModule if it's always going to be saved there.

// This is a stable choice - no need to record it in the table (as we do for others below)

if (Module::IsAlwaysSavedInPreferredZapModule(classInst, methodInst))

{

RETURN (Module::ComputePreferredZapModule(pDefinitionModule, classInst, methodInst));

}

// Check if this compilation process has already decided on an adjustment. Once we decide

// on the LoaderModule for an item it must be stable for the duration of a

// compilation process, no matter how many modules get NGEN'd.

ZapperLoaderModuleTableKey key(pDefinitionModule,

token,

classInst,

methodInst);

Module * pZapperLoaderModule = g_pCEECompileInfo->LookupZapperLoaderModule(&key);

if (pZapperLoaderModule != NULL)

{

RETURN (pZapperLoaderModule);

}

// OK, we need to compute a non-standard zapping module.

Module * pPreferredZapModule = Module::ComputePreferredZapModule(pDefinitionModule, classInst, methodInst);

// Check if we're NGEN'ing but where perhaps the compilation domain

// isn't set up yet. This can happen in following situations:

// - Managed code running during startup before compilation domain is setup.

// - Exceptions (e.g. invalid program exceptions) thrown from compilation domain and caught in default domain

// We're a little stuck - we can't force the item into an NGEN image at this point. So just bail out

// and use the loader module we've computed without recording the choice. The loader module should always

// be mscorlib in this case.

AppDomain * pAppDomain = GetAppDomain();

if (!pAppDomain->IsCompilationDomain() ||

!pAppDomain->ToCompilationDomain()->GetTargetModule())

{

_ASSERTE(pPreferredZapModule->IsSystem() || IsNgenPDBCompilationProcess());

RETURN (pPreferredZapModule);

}

Module * pTargetModule = pAppDomain->ToCompilationDomain()->GetTargetModule();

// If it is multi-module assembly and we have not saved PZM yet, do not create

// speculative instantiation - just save it in PZM.

if (pTargetModule->GetAssembly() == pPreferredZapModule->GetAssembly() &&

!pPreferredZapModule->IsModuleSaved())

{

pZapperLoaderModule = pPreferredZapModule;

}

else

{

// Everything else can be saved into the current module.

pZapperLoaderModule = pTargetModule;

}

// If generating WinMD resilient code and we so far choose to use the target module,

// we need to check if the definition module or any of the instantiation type can

// cause version resilient problems.

if (g_fNGenWinMDResilient && pZapperLoaderModule == pTargetModule)

{

if (pDefinitionModule != NULL && !pDefinitionModule->IsInCurrentVersionBubble())

{

pZapperLoaderModule = pDefinitionModule;

goto ModuleAdjustedForVersionResiliency;

}

for (DWORD i = 0; i < classInst.GetNumArgs(); i++)

{

Module * pModule = classInst[i].GetLoaderModule();

if (!pModule->IsInCurrentVersionBubble())

{

pZapperLoaderModule = pModule;

goto ModuleAdjustedForVersionResiliency;

}

}

for (DWORD i = 0; i < methodInst.GetNumArgs(); i++)

{

Module * pModule = methodInst[i].GetLoaderModule();

if (!pModule->IsInCurrentVersionBubble())

{

pZapperLoaderModule = pModule;

goto ModuleAdjustedForVersionResiliency;

}

}

ModuleAdjustedForVersionResiliency: ;

}

// Record this choice just in case we're NGEN'ing multiple modules

// to make sure we always do the same thing if we're asked to compute

// the loader module again.

// Note this whole code path only happens while NGEN'ing, so this violation

// is not so bad. It is needed since we allocate stuff on the heap.

CONTRACT_VIOLATION(ThrowsViolation|FaultViolation);

// Copy the instantiation arrays so they can escape the scope of this method.

// Since this is a permanent entry in a table for this compilation process

// we do not need to collect these. If we did have to we would do it when we deleteed the

// ZapperLoaderModuleTable.

NewArrayHolder<TypeHandle> pClassArgs = NULL;

if (!classInst.IsEmpty())

{

pClassArgs = new TypeHandle[classInst.GetNumArgs()];

for (unsigned int i = 0; i < classInst.GetNumArgs(); i++)

pClassArgs[i] = classInst[i];

}

NewArrayHolder<TypeHandle> pMethodArgs = NULL;

if (!methodInst.IsEmpty())

{

pMethodArgs = new TypeHandle[methodInst.GetNumArgs()];

for (unsigned int i = 0; i < methodInst.GetNumArgs(); i++)

pMethodArgs[i] = methodInst[i];

}

ZapperLoaderModuleTableKey key2(pDefinitionModule,

token,

Instantiation(pClassArgs, classInst.GetNumArgs()),

Instantiation(pMethodArgs, methodInst.GetNumArgs()));

g_pCEECompileInfo->RecordZapperLoaderModule(&key2, pZapperLoaderModule);

pClassArgs.SuppressRelease();

pMethodArgs.SuppressRelease();

RETURN (pZapperLoaderModule);

}

#endif // FEATURE_NATIVE_IMAGE_GENERATION

#endif // #ifndef DACCESS_COMPILE

/*static*/

Module * ClassLoader::ComputeLoaderModule(MethodTable * pMT,

mdToken token,

Instantiation methodInst)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

SUPPORTS_DAC;

}

CONTRACTL_END;

return ComputeLoaderModuleWorker(pMT->GetModule(),

token,

pMT->GetInstantiation(),

methodInst);

}

/*static*/

Module *ClassLoader::ComputeLoaderModule(TypeKey *typeKey)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

SUPPORTS_DAC;

}

CONTRACTL_END;

if (typeKey->GetKind() == ELEMENT_TYPE_CLASS)

return ComputeLoaderModuleWorker(typeKey->GetModule(),

typeKey->GetTypeToken(),

typeKey->GetInstantiation(),

Instantiation());

else if (typeKey->GetKind() == ELEMENT_TYPE_FNPTR)

return ComputeLoaderModuleForFunctionPointer(typeKey->GetRetAndArgTypes(), typeKey->GetNumArgs() + 1);

else

return ComputeLoaderModuleForParamType(typeKey->GetElementType());

}

/*static*/

BOOL ClassLoader::IsTypicalInstantiation(Module *pModule, mdToken token, Instantiation inst)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

FORBID_FAULT;

PRECONDITION(CheckPointer(pModule));

PRECONDITION(TypeFromToken(token) == mdtTypeDef || TypeFromToken(token) == mdtMethodDef);

SUPPORTS_DAC;

}

CONTRACTL_END

for (DWORD i = 0; i < inst.GetNumArgs(); i++)

{

TypeHandle thArg = inst[i];

if (thArg.IsGenericVariable())

{

TypeVarTypeDesc* tyvar = thArg.AsGenericVariable();

PREFIX_ASSUME(tyvar!=NULL);

if ((tyvar->GetTypeOrMethodDef() != token) ||

(tyvar->GetModule() != dac_cast<PTR_Module>(pModule)) ||

(tyvar->GetIndex() != i))

return FALSE;

}

else

{

return FALSE;

}

}

return TRUE;

}

// External class loader entry point: load a type by name

/*static*/

TypeHandle ClassLoader::LoadTypeByNameThrowing(Assembly *pAssembly,

LPCUTF8 nameSpace,

LPCUTF8 name,

NotFoundAction fNotFound,

ClassLoader::LoadTypesFlag fLoadTypes,

ClassLoadLevel level)

{

CONTRACT(TypeHandle)

{

if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;

if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;

if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }

MODE_ANY;

if (FORBIDGC_LOADER_USE_ENABLED() || fLoadTypes != LoadTypes) { LOADS_TYPE(CLASS_LOAD_BEGIN); } else { LOADS_TYPE(level); }

PRECONDITION(CheckPointer(pAssembly));

PRECONDITION(level > CLASS_LOAD_BEGIN && level <= CLASS_LOADED);

POSTCONDITION(CheckPointer(RETVAL,

(fNotFound == ThrowIfNotFound && fLoadTypes == LoadTypes )? NULL_NOT_OK : NULL_OK));

POSTCONDITION(RETVAL.IsNull() || RETVAL.CheckLoadLevel(level));

SUPPORTS_DAC;

#ifdef DACCESS_COMPILE

PRECONDITION((fNotFound == ClassLoader::ReturnNullIfNotFound) && (fLoadTypes == DontLoadTypes));

#endif

}

CONTRACT_END

NameHandle nameHandle(nameSpace, name);

if (fLoadTypes == DontLoadTypes)

nameHandle.SetTokenNotToLoad(tdAllTypes);

if (fNotFound == ThrowIfNotFound)

RETURN pAssembly->GetLoader()->LoadTypeHandleThrowIfFailed(&nameHandle, level);

else

RETURN pAssembly->GetLoader()->LoadTypeHandleThrowing(&nameHandle, level);

}

#ifndef DACCESS_COMPILE

#define DAC_LOADS_TYPE(level, expression) \

if (FORBIDGC_LOADER_USE_ENABLED() || (expression)) \

{ LOADS_TYPE(CLASS_LOAD_BEGIN); } else { LOADS_TYPE(level); }

#else

#define DAC_LOADS_TYPE(level, expression) { LOADS_TYPE(CLASS_LOAD_BEGIN); }

#endif // #ifndef DACCESS_COMPILE

//

// Find a class given name, using the classloader's global list of known classes.

// If the type is found, it will be restored unless pName->GetTokenNotToLoad() prohibits that

// Returns NULL if class not found AND pName->OKToLoad returns false

TypeHandle ClassLoader::LoadTypeHandleThrowIfFailed(NameHandle* pName, ClassLoadLevel level,

Module* pLookInThisModuleOnly/*=NULL*/)

{

CONTRACT(TypeHandle)

{

INSTANCE_CHECK;

if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;

if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;

if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }

DAC_LOADS_TYPE(level, !pName->OKToLoad());

MODE_ANY;

PRECONDITION(CheckPointer(pName));

PRECONDITION(level > CLASS_LOAD_BEGIN && level <= CLASS_LOADED);

POSTCONDITION(CheckPointer(RETVAL, pName->OKToLoad() ? NULL_NOT_OK : NULL_OK));

POSTCONDITION(RETVAL.IsNull() || RETVAL.CheckLoadLevel(level));

SUPPORTS_DAC;

}

CONTRACT_END;

// Lookup in the classes that this class loader knows about

TypeHandle typeHnd = LoadTypeHandleThrowing(pName, level, pLookInThisModuleOnly);

if(typeHnd.IsNull()) {

if ( pName->OKToLoad() ) {

#ifdef _DEBUG_IMPL

{

LPCUTF8 szName = pName->GetName();

if (szName == NULL)

szName = "<UNKNOWN>";

StackSString codeBase;

GetAssembly()->GetCodeBase(codeBase);

LOG((LF_CLASSLOADER, LL_INFO10, "Failed to find class \"%s\" in the manifest for assembly \"%ws\"\n", szName, (LPCWSTR)codeBase));

}

#endif

#ifndef DACCESS_COMPILE

m_pAssembly->ThrowTypeLoadException(pName, IDS_CLASSLOAD_GENERAL);

#else

DacNotImpl();

#endif

}

}

RETURN(typeHnd);

}

#ifndef DACCESS_COMPILE

//<TODO>@TODO: Need to allow exceptions to be thrown when classloader is cleaned up</TODO>

EEClassHashEntry_t* ClassLoader::InsertValue(EEClassHashTable *pClassHash, EEClassHashTable *pClassCaseInsHash, LPCUTF8 pszNamespace, LPCUTF8 pszClassName, HashDatum Data, EEClassHashEntry_t *pEncloser, AllocMemTracker *pamTracker)

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_NOTRIGGER;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END

LPUTF8 pszLowerCaseNS = NULL;

LPUTF8 pszLowerCaseName = NULL;

EEClassHashEntry_t *pCaseInsEntry = NULL;

EEClassHashEntry_t *pEntry = pClassHash->AllocNewEntry(pamTracker);

if (pClassCaseInsHash) {

CreateCanonicallyCasedKey(pszNamespace, pszClassName, &pszLowerCaseNS, &pszLowerCaseName);

pCaseInsEntry = pClassCaseInsHash->AllocNewEntry(pamTracker);

}

{

// ! We cannot fail after this point.

CANNOTTHROWCOMPLUSEXCEPTION();

FAULT_FORBID();

pClassHash->InsertValueUsingPreallocatedEntry(pEntry, pszNamespace, pszClassName, Data, pEncloser);

//If we're keeping a table for case-insensitive lookup, keep that up to date

if (pClassCaseInsHash)

pClassCaseInsHash->InsertValueUsingPreallocatedEntry(pCaseInsEntry, pszLowerCaseNS, pszLowerCaseName, pEntry, pEncloser);

return pEntry;

}

}

#endif // #ifndef DACCESS_COMPILE

BOOL ClassLoader::CompareNestedEntryWithExportedType(IMDInternalImport * pImport,

mdExportedType mdCurrent,

EEClassHashTable * pClassHash,

PTR_EEClassHashEntry pEntry)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

FORBID_FAULT;

SUPPORTS_DAC;

}

CONTRACTL_END;

LPCUTF8 Key[2];

do

{

if (FAILED(pImport->GetExportedTypeProps(

mdCurrent,

&Key[0],

&Key[1],

&mdCurrent,

NULL, //binding (type def)

NULL))) //flags

{

return FALSE;

}

if (pClassHash->CompareKeys(pEntry, Key))

{

// Reached top level class for mdCurrent - return whether

// or not pEntry is a top level class

// (pEntry is a top level class if its pEncloser is NULL)

if ((TypeFromToken(mdCurrent) != mdtExportedType) ||

(mdCurrent == mdExportedTypeNil))

{

return pEntry->GetEncloser() == NULL;

}

}

else // Keys don't match - wrong entry

{

return FALSE;

}

}

while ((pEntry = pEntry->GetEncloser()) != NULL);

// Reached the top level class for pEntry, but mdCurrent is nested

return FALSE;

}

BOOL ClassLoader::CompareNestedEntryWithTypeDef(IMDInternalImport * pImport,

mdTypeDef mdCurrent,

EEClassHashTable * pClassHash,

PTR_EEClassHashEntry pEntry)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

FORBID_FAULT;

SUPPORTS_DAC;

}

CONTRACTL_END;

LPCUTF8 Key[2];

do {

if (FAILED(pImport->GetNameOfTypeDef(mdCurrent, &Key[1], &Key[0])))

{

return FALSE;

}

if (pClassHash->CompareKeys(pEntry, Key)) {

// Reached top level class for mdCurrent - return whether

// or not pEntry is a top level class

// (pEntry is a top level class if its pEncloser is NULL)

if (FAILED(pImport->GetNestedClassProps(mdCurrent, &mdCurrent)))

return pEntry->GetEncloser() == NULL;

}

else // Keys don't match - wrong entry

return FALSE;

}

while ((pEntry = pEntry->GetEncloser()) != NULL);

// Reached the top level class for pEntry, but mdCurrent is nested

return FALSE;

}

BOOL ClassLoader::CompareNestedEntryWithTypeRef(IMDInternalImport * pImport,

mdTypeRef mdCurrent,

EEClassHashTable * pClassHash,

PTR_EEClassHashEntry pEntry)

{

CONTRACTL

{

INSTANCE_CHECK;

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

FORBID_FAULT;

SUPPORTS_DAC;

}

CONTRACTL_END;

LPCUTF8 Key[2];

do {

if (FAILED(pImport->GetNameOfTypeRef(mdCurrent, &Key[0], &Key[1])))

{

return FALSE;

}

if (pClassHash->CompareKeys(pEntry, Key))

{

if (FAILED(pImport->GetResolutionScopeOfTypeRef(mdCurrent, &mdCurrent)))

{

return FALSE;

}

// Reached top level class for mdCurrent - return whether

// or not pEntry is a top level class

// (pEntry is a top level class if its pEncloser is NULL)

if ((TypeFromToken(mdCurrent) != mdtTypeRef) ||

(mdCurrent == mdTypeRefNil))

return pEntry->GetEncloser() == NULL;

}

else // Keys don't match - wrong entry

return FALSE;

}

while ((pEntry = pEntry->GetEncloser())!=NULL);

// Reached the top level class for pEntry, but mdCurrent is nested

return FALSE;

}

/*static*/

BOOL ClassLoader::IsNested(Module *pModule, mdToken token, mdToken *mdEncloser)

{

CONTRACTL

{

if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;

if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;

if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }

MODE_ANY;

SUPPORTS_DAC;

}

CONTRACTL_END;

switch(TypeFromToken(token)) {

case mdtTypeDef:

return (SUCCEEDED(pModule->GetMDImport()->GetNestedClassProps(token, mdEncloser)));

case mdtTypeRef:

IfFailThrow(pModule->GetMDImport()->GetResolutionScopeOfTypeRef(token, mdEncloser));

return ((TypeFromToken(*mdEncloser) == mdtTypeRef) &&

(*mdEncloser != mdTypeRefNil));

case mdtExportedType:

IfFailThrow(pModule->GetAssembly()->GetManifestImport()->GetExportedTypeProps(

token,

NULL, // namespace

NULL, // name

mdEncloser,

NULL, //binding (type def)

NULL)); //flags

return ((TypeFromToken(*mdEncloser) == mdtExportedType) &&

(*mdEncloser != mdExportedTypeNil));

default:

ThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN_TYPE);

}

}

BOOL ClassLoader::IsNested(const NameHandle* pName, mdToken *mdEncloser)

{

CONTRACTL

{

INSTANCE_CHECK;

if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;

if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;

if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }

MODE_ANY;

SUPPORTS_DAC;

}

CONTRACTL_END;

if (pName->GetTypeModule()) {

if (TypeFromToken(pName->GetTypeToken()) == mdtBaseType)

{

if (!pName->GetBucket().IsNull())

return TRUE;

return FALSE;

}

else

return IsNested(pName->GetTypeModule(), pName->GetTypeToken(), mdEncloser);

}

else

return FALSE;

}

void ClassLoader::GetClassValue(NameHandleTable nhTable,

const NameHandle *pName,

HashDatum *pData,

EEClassHashTable **ppTable,

Module* pLookInThisModuleOnly,

HashedTypeEntry* pFoundEntry,

Loader::LoadFlag loadFlag,

BOOL& needsToBuildHashtable)

{

CONTRACTL

{

INSTANCE_CHECK;

MODE_ANY;

if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;

if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;

if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }

PRECONDITION(CheckPointer(pName));

SUPPORTS_DAC;

}

CONTRACTL_END

mdToken mdEncloser;

EEClassHashEntry_t *pBucket = NULL;

needsToBuildHashtable = FALSE;

#if _DEBUG

if (pName->GetName()) {

if (pName->GetNameSpace() == NULL)

LOG((LF_CLASSLOADER, LL_INFO1000, "Looking up %s by name.\n",

pName->GetName()));

else

LOG((LF_CLASSLOADER, LL_INFO1000, "Looking up %s.%s by name.\n",

pName->GetNameSpace(), pName->GetName()));

}

#endif

BOOL isNested = IsNested(pName, &mdEncloser);

PTR_Assembly assembly = GetAssembly();

PREFIX_ASSUME(assembly != NULL);

ModuleIterator i = assembly->IterateModules();

while (i.Next())

{

Module * pCurrentClsModule = i.GetModule();

PREFIX_ASSUME(pCurrentClsModule != NULL);

if (pCurrentClsModule->IsResource())

continue;

if (pLookInThisModuleOnly && (pCurrentClsModule != pLookInThisModuleOnly))

continue;

#ifdef FEATURE_READYTORUN

if (nhTable == nhCaseSensitive && pCurrentClsModule->IsReadyToRun() && pCurrentClsModule->GetReadyToRunInfo()->HasHashtableOfTypes() &&

pCurrentClsModule->GetAvailableClassHash() == NULL)

{

// For R2R modules, we only search the hashtable of token types stored in the module's image, and don't fallback

// to searching m_pAvailableClasses or m_pAvailableClassesCaseIns (in fact, we don't even allocate them for R2R modules).

// Also note that type lookups in R2R modules only support case sensitive lookups.

mdToken mdFoundTypeToken;

if (pCurrentClsModule->GetReadyToRunInfo()->TryLookupTypeTokenFromName(pName, &mdFoundTypeToken))

{

if (TypeFromToken(mdFoundTypeToken) == mdtExportedType)

{

mdToken mdUnused;

Module * pTargetModule = GetAssembly()->FindModuleByExportedType(mdFoundTypeToken, loadFlag, mdTypeDefNil, &mdUnused);

pFoundEntry->SetTokenBasedEntryValue(mdFoundTypeToken, pTargetModule);

}

else

{

pFoundEntry->SetTokenBasedEntryValue(mdFoundTypeToken, pCurrentClsModule);

}

return; // Return on the first success

}

}

else

#endif

{

EEClassHashTable* pTable = NULL;

if (nhTable == nhCaseSensitive)

{

*ppTable = pTable = pCurrentClsModule->GetAvailableClassHash();

#ifdef FEATURE_READYTORUN

if (pTable == NULL && pCurrentClsModule->IsReadyToRun() && !pCurrentClsModule->GetReadyToRunInfo()->HasHashtableOfTypes())

{

// Old R2R image generated without the hashtable of types.

// We fallback to the slow path of creating the hashtable dynamically

// at execution time in that scenario. The caller will handle

pFoundEntry->SetClassHashBasedEntryValue(NULL);

needsToBuildHashtable = TRUE;

return;

}

#endif

}

else

{

// currently we expect only these two kinds--for DAC builds, nhTable will be nhCaseSensitive

_ASSERTE(nhTable == nhCaseInsensitive);

*ppTable = pTable = pCurrentClsModule->GetAvailableClassCaseInsHash();

if (pTable == NULL)

{

// We have not built the table yet - the caller will handle

pFoundEntry->SetClassHashBasedEntryValue(NULL);

needsToBuildHashtable = TRUE;

return;

}

}

_ASSERTE(pTable);

if (isNested)

{

Module *pNameModule = pName->GetTypeModule();

PREFIX_ASSUME(pNameModule != NULL);

EEClassHashTable::LookupContext sContext;

if ((pBucket = pTable->GetValue(pName, pData, TRUE, &sContext)) != NULL)

{

switch (TypeFromToken(pName->GetTypeToken()))

{

case mdtTypeDef:

while ((!CompareNestedEntryWithTypeDef(pNameModule->GetMDImport(),

mdEncloser,

pCurrentClsModule->GetAvailableClassHash(),

pBucket->GetEncloser())) &&

(pBucket = pTable->FindNextNestedClass(pName, pData, &sContext)) != NULL);

break;

case mdtTypeRef:

while ((!CompareNestedEntryWithTypeRef(pNameModule->GetMDImport(),

mdEncloser,

pCurrentClsModule->GetAvailableClassHash(),

pBucket->GetEncloser())) &&

(pBucket = pTable->FindNextNestedClass(pName, pData, &sContext)) != NULL);

break;

case mdtExportedType:

while ((!CompareNestedEntryWithExportedType(pNameModule->GetAssembly()->GetManifestImport(),

mdEncloser,

pCurrentClsModule->GetAvailableClassHash(),

pBucket->GetEncloser())) &&

(pBucket = pTable->FindNextNestedClass(pName, pData, &sContext)) != NULL);

break;

default:

while ((pBucket->GetEncloser() != pName->GetBucket().GetClassHashBasedEntryValue()) &&

(pBucket = pTable->FindNextNestedClass(pName, pData, &sContext)) != NULL);

}

}

}

else

{

pBucket = pTable->GetValue(pName, pData, FALSE, NULL);

}

if (pBucket) // Return on the first success

{

pFoundEntry->SetClassHashBasedEntryValue(pBucket);

return;

}

}

}

// No results found: default to a NULL EEClassHashEntry_t result

pFoundEntry->SetClassHashBasedEntryValue(NULL);

}

#ifndef DACCESS_COMPILE

VOID ClassLoader::PopulateAvailableClassHashTable(Module* pModule,

AllocMemTracker *pamTracker)

{

CONTRACTL

{

INSTANCE_CHECK;

THROWS;

GC_TRIGGERS;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END;

mdTypeDef td;

HENUMInternal hTypeDefEnum;

IMDInternalImport * pImport = pModule->GetMDImport();

LPCSTR szWinRtNamespacePrefix = NULL;

DWORD cchWinRtNamespacePrefix = 0;

#ifdef FEATURE_COMINTEROP

SString ssFileName;

StackScratchBuffer ssFileNameBuffer;

if (pModule->GetAssembly()->IsWinMD())

{ // WinMD file in execution context (not ReflectionOnly context) - use its file name as WinRT namespace prefix

// (Windows requirement)

// Note: Reflection can work on 'unfinished' WinMD files where the types are in 'wrong' WinMD file (i.e.

// type namespace does not start with the file name)

_ASSERTE(pModule->GetFile()->IsAssembly()); // No multi-module WinMD file support

_ASSERTE(!pModule->GetFile()->GetPath().IsEmpty());

SplitPath(

pModule->GetFile()->GetPath(),

NULL, // Drive

NULL, // Directory

&ssFileName,

NULL); // Extension

szWinRtNamespacePrefix = ssFileName.GetUTF8(ssFileNameBuffer);

cchWinRtNamespacePrefix = (DWORD)strlen(szWinRtNamespacePrefix);