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

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

/*============================================================

**

** Header: Assembly.cpp

**

**

** Purpose: Implements assembly (loader domain) architecture

**

**

===========================================================*/

#include "common.h"

#include <stdlib.h>

#include "assembly.hpp"

#include "appdomain.hpp"

#include "eeprofinterfaces.h"

#include "reflectclasswriter.h"

#include "comdynamic.h"

#include "sha1.h"

#include "eeconfig.h"

#include "assemblynative.hpp"

#include "threadsuspend.h"

#include "appdomainnative.hpp"

#include "customattribute.h"

#include "winnls.h"

#include "caparser.h"

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

#include "peimagelayout.inl"

// Define these macro's to do strict validation for jit lock and class init entry leaks.

// This defines determine if the asserts that verify for these leaks are defined or not.

// These asserts can sometimes go off even if no entries have been leaked so this defines

// should be used with caution.

//

// If we are inside a .cctor when the application shut's down then the class init lock's

// head will be set and this will cause the assert to go off.,

//

// If we are jitting a method when the application shut's down then the jit lock's head

// will be set causing the assert to go off.

//#define STRICT_JITLOCK_ENTRY_LEAK_DETECTION

//#define STRICT_CLSINITLOCK_ENTRY_LEAK_DETECTION

#ifndef DACCESS_COMPILE

volatile uint32_t g_cAssemblies = 0;

static CrstStatic g_friendAssembliesCrst;

namespace

{

void DefineEmitScope(GUID iid, void** ppEmit)

{

CONTRACT_VOID

{

PRECONDITION(CheckPointer(ppEmit));

POSTCONDITION(CheckPointer(*ppEmit));

THROWS;

GC_TRIGGERS;

MODE_ANY;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACT_END;

SafeComHolder<IMetaDataDispenserEx> pDispenser;

// Get the Dispenser interface.

MetaDataGetDispenser(

CLSID_CorMetaDataDispenser,

IID_IMetaDataDispenserEx,

(void**)&pDispenser);

if (pDispenser == NULL)

{

ThrowOutOfMemory();

}

// Set the option on the dispenser turn on duplicate check for TypeDef and moduleRef

VARIANT varOption;

V_VT(&varOption) = VT_UI4;

V_I4(&varOption) = MDDupDefault | MDDupTypeDef | MDDupModuleRef | MDDupExportedType | MDDupAssemblyRef | MDDupPermission | MDDupFile;

IfFailThrow(pDispenser->SetOption(MetaDataCheckDuplicatesFor, &varOption));

// Set minimal MetaData size

V_VT(&varOption) = VT_UI4;

V_I4(&varOption) = MDInitialSizeMinimal;

IfFailThrow(pDispenser->SetOption(MetaDataInitialSize, &varOption));

// turn on the thread safety!

V_I4(&varOption) = MDThreadSafetyOn;

IfFailThrow(pDispenser->SetOption(MetaDataThreadSafetyOptions, &varOption));

IfFailThrow(pDispenser->DefineScope(CLSID_CorMetaDataRuntime, 0, iid, (IUnknown**)ppEmit));

RETURN;

}

}

void Assembly::Initialize()

{

g_friendAssembliesCrst.Init(CrstLeafLock);

}

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

// The ctor's job is to initialize the Assembly enough so that the dtor can safely run.

// It cannot do any allocations or operations that might fail. Those operations should be done

// in Assembly::Init()

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

Assembly::Assembly(BaseDomain *pDomain, PEAssembly* pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, BOOL fIsCollectible) :

m_pDomain(pDomain),

m_pClassLoader(NULL),

m_pEntryPoint(NULL),

m_pModule(NULL),

m_pPEAssembly(clr::SafeAddRef(pPEAssembly)),

m_pFriendAssemblyDescriptor(NULL),

m_isDynamic(false),

#ifdef FEATURE_COLLECTIBLE_TYPES

m_isCollectible(fIsCollectible),

#endif

m_pLoaderAllocator(NULL),

#ifdef FEATURE_COMINTEROP

m_pITypeLib(NULL),

#endif // FEATURE_COMINTEROP

#ifdef FEATURE_COMINTEROP

m_InteropAttributeStatus(INTEROP_ATTRIBUTE_UNSET),

#endif

m_debuggerFlags(debuggerFlags),

m_fTerminated(FALSE),

#if FEATURE_READYTORUN

m_isInstrumentedStatus(IS_INSTRUMENTED_UNSET)

#endif // FEATURE_READYTORUN

{

STANDARD_VM_CONTRACT;

}

// This name needs to stay in sync with AssemblyBuilder.ManifestModuleName

// which is used in AssemblyBuilder.InitManifestModule

#define REFEMIT_MANIFEST_MODULE_NAME W("RefEmit_InMemoryManifestModule")

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

// Does most Assembly initialization tasks. It can assume the ctor has already run

// and the assembly is safely destructable. Whether this function throws or succeeds,

// it must leave the Assembly in a safely destructable state.

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

void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator)

{

STANDARD_VM_CONTRACT;

if (IsSystem())

{

_ASSERTE(pLoaderAllocator == NULL); // pLoaderAllocator may only be non-null for collectible types

m_pLoaderAllocator = SystemDomain::GetGlobalLoaderAllocator();

}

else

{

if (!IsCollectible())

{

// pLoaderAllocator will only be non-null for reflection emit assemblies

_ASSERTE((pLoaderAllocator == NULL) || (pLoaderAllocator == GetDomain()->AsAppDomain()->GetLoaderAllocator()));

m_pLoaderAllocator = GetDomain()->AsAppDomain()->GetLoaderAllocator();

}

else

{

_ASSERTE(pLoaderAllocator != NULL); // ppLoaderAllocator must be non-null for collectible assemblies

m_pLoaderAllocator = pLoaderAllocator;

}

}

_ASSERTE(m_pLoaderAllocator != NULL);

m_pClassLoader = new ClassLoader(this);

m_pClassLoader->Init(pamTracker);

PEAssembly* pPEAssembly = GetPEAssembly();

// "Module::Create" will initialize R2R support, if there is an R2R header.

// make sure the PE is loaded or R2R will be disabled.

pPEAssembly->EnsureLoaded();

if (pPEAssembly->IsDynamic())

// manifest modules of dynamic assemblies are always transient

m_pModule = ReflectionModule::Create(this, pPEAssembly, pamTracker, REFEMIT_MANIFEST_MODULE_NAME);

else

m_pModule = Module::Create(this, mdFileNil, pPEAssembly, pamTracker);

InterlockedIncrement((LONG*)&g_cAssemblies);

PrepareModuleForAssembly(m_pModule, pamTracker);

if (!m_pModule->IsReadyToRun())

CacheManifestExportedTypes(pamTracker);

// We'll load the friend assembly information lazily. For the ngen case we should avoid

// loading it entirely.

//CacheFriendAssemblyInfo();

if (IsCollectible() && !pPEAssembly->IsDynamic())

{

COUNT_T size;

BYTE* start = (BYTE*)pPEAssembly->GetLoadedImageContents(&size);

// We should have the content loaded at this time. There will be no other attempt to associate memory.

_ASSERTE(start != NULL);

GCX_COOP();

LoaderAllocator::AssociateMemoryWithLoaderAllocator(start, start + size, m_pLoaderAllocator);

}

{

CANNOTTHROWCOMPLUSEXCEPTION();

FAULT_FORBID();

//Cannot fail after this point.

PublishModuleIntoAssembly(m_pModule);

return; // Explicit return to let you know you are NOT welcome to add code after the CANNOTTHROW/FAULT_FORBID expires

}

}

Assembly::~Assembly()

{

CONTRACTL

{

NOTHROW;

GC_TRIGGERS;

DISABLED(FORBID_FAULT); //Must clean up some profiler stuff

}

CONTRACTL_END

Terminate();

if (m_pFriendAssemblyDescriptor != NULL)

m_pFriendAssemblyDescriptor->Release();

if (m_pPEAssembly)

{

m_pPEAssembly->Release();

}

#ifdef FEATURE_COMINTEROP

if (m_pITypeLib != nullptr && m_pITypeLib != Assembly::InvalidTypeLib)

{

m_pITypeLib->Release();

}

#endif // FEATURE_COMINTEROP

}

#ifdef PROFILING_SUPPORTED

void ProfilerCallAssemblyUnloadStarted(Assembly* assemblyUnloaded)

{

WRAPPER_NO_CONTRACT;

{

BEGIN_PROFILER_CALLBACK(CORProfilerPresent());

GCX_PREEMP();

(&g_profControlBlock)->AssemblyUnloadStarted((AssemblyID)assemblyUnloaded);

END_PROFILER_CALLBACK();

}

}

void ProfilerCallAssemblyUnloadFinished(Assembly* assemblyUnloaded)

{

WRAPPER_NO_CONTRACT;

{

BEGIN_PROFILER_CALLBACK(CORProfilerPresent());

GCX_PREEMP();

(&g_profControlBlock)->AssemblyUnloadFinished((AssemblyID) assemblyUnloaded, S_OK);

END_PROFILER_CALLBACK();

}

}

#endif

void Assembly::StartUnload()

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_TRIGGERS;

STATIC_CONTRACT_FORBID_FAULT;

#ifdef PROFILING_SUPPORTED

if (CORProfilerTrackAssemblyLoads())

{

ProfilerCallAssemblyUnloadStarted(this);

}

#endif

}

void Assembly::Terminate( BOOL signalProfiler )

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_TRIGGERS;

STRESS_LOG1(LF_LOADER, LL_INFO100, "Assembly::Terminate (this = 0x%p)\n", reinterpret_cast<void *>(this));

if (this->m_fTerminated)

return;

if (m_pClassLoader != NULL)

{

GCX_PREEMP();

delete m_pClassLoader;

m_pClassLoader = NULL;

}

InterlockedDecrement((LONG*)&g_cAssemblies);

#ifdef PROFILING_SUPPORTED

if (CORProfilerTrackAssemblyLoads())

{

ProfilerCallAssemblyUnloadFinished(this);

}

#endif // PROFILING_SUPPORTED

this->m_fTerminated = TRUE;

}

Assembly * Assembly::Create(

BaseDomain * pDomain,

PEAssembly * pPEAssembly,

DebuggerAssemblyControlFlags debuggerFlags,

BOOL fIsCollectible,

AllocMemTracker * pamTracker,

LoaderAllocator * pLoaderAllocator)

{

STANDARD_VM_CONTRACT;

NewHolder<Assembly> pAssembly (new Assembly(pDomain, pPEAssembly, debuggerFlags, fIsCollectible));

#ifdef PROFILING_SUPPORTED

{

BEGIN_PROFILER_CALLBACK(CORProfilerTrackAssemblyLoads());

GCX_COOP();

(&g_profControlBlock)->AssemblyLoadStarted((AssemblyID)(Assembly *) pAssembly);

END_PROFILER_CALLBACK();

}

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

EX_TRY

#endif

{

pAssembly->Init(pamTracker, pLoaderAllocator);

}

#ifdef PROFILING_SUPPORTED

EX_HOOK

{

{

BEGIN_PROFILER_CALLBACK(CORProfilerTrackAssemblyLoads());

GCX_COOP();

(&g_profControlBlock)->AssemblyLoadFinished((AssemblyID)(Assembly *) pAssembly,

GET_EXCEPTION()->GetHR());

END_PROFILER_CALLBACK();

}

}

EX_END_HOOK;

#endif

pAssembly.SuppressRelease();

return pAssembly;

} // Assembly::Create

Assembly *Assembly::CreateDynamic(AssemblyBinder* pBinder, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, LOADERALLOCATORREF* pKeepAlive)

{

// WARNING: not backout clean

CONTRACT(Assembly *)

{

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

MODE_COOPERATIVE;

}

CONTRACT_END;

// This must be before creation of the AllocMemTracker so that the destructor for the AllocMemTracker happens before the destructor for pLoaderAllocator.

// That is necessary as the allocation of Assembly objects and other related details is done on top of heaps located in

// the loader allocator objects.

NewHolder<LoaderAllocator> pLoaderAllocator;

AllocMemTracker amTracker;

AllocMemTracker *pamTracker = &amTracker;

Assembly *pRetVal = NULL;

// First, we set up a pseudo-manifest file for the assembly.

// Set up the assembly name

if (pAssemblyNameParts->_pName == NULL || pAssemblyNameParts->_pName[0] == '\0')

COMPlusThrow(kArgumentException, W("ArgumentNull_AssemblyNameName"));

if (COMCharacter::nativeIsWhiteSpace(pAssemblyNameParts->_pName[0])

|| wcschr(pAssemblyNameParts->_pName, '\\') != NULL

|| wcschr(pAssemblyNameParts->_pName, ':') != NULL

|| wcschr(pAssemblyNameParts->_pName, '/') != NULL)

{

COMPlusThrow(kArgumentException, W("InvalidAssemblyName"));

}

// Set up the assembly manifest metadata

// When we create dynamic assembly, we always use a working copy of IMetaDataAssemblyEmit

// to store temporary runtime assembly information. This is to preserve the invariant that

// an assembly must have a PEAssembly with proper metadata.

// This working copy of IMetaDataAssemblyEmit will store every AssemblyRef as a simple name

// reference as we must have an instance of Assembly(can be dynamic assembly) before we can

// add such a reference. Also because the referenced assembly if dynamic strong name, it may

// not be ready to be hashed!

SafeComHolder<IMetaDataAssemblyEmit> pAssemblyEmit;

DefineEmitScope(

IID_IMetaDataAssemblyEmit,

&pAssemblyEmit);

// Now create a dynamic PE file out of the name & metadata

PEAssemblyHolder pPEAssembly;

{

GCX_PREEMP();

ASSEMBLYMETADATA assemData;

memset(&assemData, 0, sizeof(assemData));

assemData.usMajorVersion = pAssemblyNameParts->_major;

assemData.usMinorVersion = pAssemblyNameParts->_minor;

assemData.usBuildNumber = pAssemblyNameParts->_build;

assemData.usRevisionNumber = pAssemblyNameParts->_revision;

assemData.szLocale = (LPWSTR)pAssemblyNameParts->_pCultureName;

if (hashAlgorithm == 0)

hashAlgorithm = CALG_SHA1;

mdAssembly ma;

IfFailThrow(pAssemblyEmit->DefineAssembly(pAssemblyNameParts->_pPublicKeyOrToken, pAssemblyNameParts->_cbPublicKeyOrToken, hashAlgorithm,

pAssemblyNameParts->_pName, &assemData, pAssemblyNameParts->_flags,

&ma));

pPEAssembly = PEAssembly::Create(pAssemblyEmit);

// Set it as the fallback load context binder for the dynamic assembly being created

pPEAssembly->SetFallbackBinder(pBinder);

}

AppDomain* pDomain = GetAppDomain();

NewHolder<DomainAssembly> pDomainAssembly;

BOOL createdNewAssemblyLoaderAllocator = FALSE;

{

GCX_PREEMP();

AssemblyLoaderAllocator* pBinderLoaderAllocator = nullptr;

if (pBinder != nullptr)

{

pBinderLoaderAllocator = pBinder->GetLoaderAllocator();

}

// Create a new LoaderAllocator if appropriate

if ((access & ASSEMBLY_ACCESS_COLLECT) != 0)

{

AssemblyLoaderAllocator *pCollectibleLoaderAllocator = new AssemblyLoaderAllocator();

pCollectibleLoaderAllocator->SetCollectible();

pLoaderAllocator = pCollectibleLoaderAllocator;

// Some of the initialization functions are not virtual. Call through the derived class

// to prevent calling the base class version.

pCollectibleLoaderAllocator->Init(pDomain);

// Setup the managed proxy now, but do not actually transfer ownership to it.

// Once everything is setup and nothing can fail anymore, the ownership will be

// atomically transferred by call to LoaderAllocator::ActivateManagedTracking().

pCollectibleLoaderAllocator->SetupManagedTracking(pKeepAlive);

createdNewAssemblyLoaderAllocator = TRUE;

if(pBinderLoaderAllocator != nullptr)

{

pCollectibleLoaderAllocator->EnsureReference(pBinderLoaderAllocator);

}

}

else

{

pLoaderAllocator = pBinderLoaderAllocator == nullptr ? pDomain->GetLoaderAllocator() : pBinderLoaderAllocator;

}

if (!createdNewAssemblyLoaderAllocator)

{

pLoaderAllocator.SuppressRelease();

}

// Create a domain assembly

pDomainAssembly = new DomainAssembly(pDomain, pPEAssembly, pLoaderAllocator);

if (pDomainAssembly->IsCollectible())

{

// We add the assembly to the LoaderAllocator only when we are sure that it can be added

// and won't be deleted in case of a concurrent load from the same ALC

((AssemblyLoaderAllocator *)(LoaderAllocator *)pLoaderAllocator)->AddDomainAssembly(pDomainAssembly);

}

}

// Start loading process

{

// Create a concrete assembly

// (!Do not remove scoping brace: order is important here: the Assembly holder must destruct before the AllocMemTracker!)

NewHolder<Assembly> pAssem;

{

GCX_PREEMP();

// Assembly::Create will call SuppressRelease on the NewHolder that holds the LoaderAllocator when it transfers ownership

pAssem = Assembly::Create(pDomain, pPEAssembly, pDomainAssembly->GetDebuggerInfoBits(), pLoaderAllocator->IsCollectible(), pamTracker, pLoaderAllocator);

ReflectionModule* pModule = (ReflectionModule*) pAssem->GetModule();

if (createdNewAssemblyLoaderAllocator)

{

// Initializing the virtual call stub manager is delayed to remove the need for the LoaderAllocator destructor to properly handle

// uninitializing the VSD system. (There is a need to suspend the runtime, and that's tricky)

pLoaderAllocator->InitVirtualCallStubManager(pDomain);

}

}

pAssem->m_isDynamic = true;

//we need to suppress release for pAssem to avoid double release

pAssem.SuppressRelease ();

{

GCX_PREEMP();

// Finish loading process

// <TODO> would be REALLY nice to unify this with main loading loop </TODO>

pDomainAssembly->Begin();

pDomainAssembly->SetAssembly(pAssem);

pDomainAssembly->m_level = FILE_LOAD_ALLOCATE;

pDomainAssembly->DeliverSyncEvents();

pDomainAssembly->DeliverAsyncEvents();

pDomainAssembly->FinishLoad();

pDomainAssembly->ClearLoading();

pDomainAssembly->m_level = FILE_ACTIVE;

}

{

CANNOTTHROWCOMPLUSEXCEPTION();

FAULT_FORBID();

//Cannot fail after this point

pDomainAssembly.SuppressRelease(); // This also effectively suppresses the release of the pAssem

pamTracker->SuppressRelease();

// Once we reach this point, the loader allocator lifetime is controlled by the Assembly object.

if (createdNewAssemblyLoaderAllocator)

{

// Atomically transfer ownership to the managed heap

pLoaderAllocator->ActivateManagedTracking();

pLoaderAllocator.SuppressRelease();

}

pAssem->SetIsTenured();

pRetVal = pAssem;

}

}

RETURN pRetVal;

} // Assembly::CreateDynamic

void Assembly::SetDomainAssembly(DomainAssembly *pDomainAssembly)

{

CONTRACTL

{

PRECONDITION(CheckPointer(pDomainAssembly));

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

}

CONTRACTL_END;

GetModule()->SetDomainAssembly(pDomainAssembly);

} // Assembly::SetDomainAssembly

#endif // #ifndef DACCESS_COMPILE

DomainAssembly *Assembly::GetDomainAssembly()

{

LIMITED_METHOD_DAC_CONTRACT;

return GetModule()->GetDomainAssembly();

}

PTR_LoaderHeap Assembly::GetLowFrequencyHeap()

{

WRAPPER_NO_CONTRACT;

return GetLoaderAllocator()->GetLowFrequencyHeap();

}

PTR_LoaderHeap Assembly::GetHighFrequencyHeap()

{

WRAPPER_NO_CONTRACT;

return GetLoaderAllocator()->GetHighFrequencyHeap();

}

PTR_LoaderHeap Assembly::GetStubHeap()

{

WRAPPER_NO_CONTRACT;

return GetLoaderAllocator()->GetStubHeap();

}

PTR_BaseDomain Assembly::GetDomain()

{

LIMITED_METHOD_CONTRACT;

SUPPORTS_DAC;

_ASSERTE(m_pDomain);

return (m_pDomain);

}

#ifndef DACCESS_COMPILE

void Assembly::SetParent(BaseDomain* pParent)

{

LIMITED_METHOD_CONTRACT;

m_pDomain = pParent;

}

#endif // !DACCCESS_COMPILE

mdFile Assembly::GetManifestFileToken(LPCSTR name)

{

return mdFileNil;

}

mdFile Assembly::GetManifestFileToken(IMDInternalImport *pImport, mdFile kFile)

{

WRAPPER_NO_CONTRACT;

SUPPORTS_DAC;

LPCSTR name;

if ((TypeFromToken(kFile) != mdtFile) ||

!pImport->IsValidToken(kFile))

{

BAD_FORMAT_NOTHROW_ASSERT(!"Invalid File token");

return mdTokenNil;

}

if (FAILED(pImport->GetFileProps(kFile, &name, NULL, NULL, NULL)))

{

BAD_FORMAT_NOTHROW_ASSERT(!"Invalid File token");

return mdTokenNil;

}

return GetManifestFileToken(name);

}

Module *Assembly::FindModuleByExportedType(mdExportedType mdType,

Loader::LoadFlag loadFlag,

mdTypeDef mdNested,

mdTypeDef* pCL)

{

CONTRACT(Module *)

{

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;

POSTCONDITION(CheckPointer(RETVAL, loadFlag==Loader::Load ? NULL_NOT_OK : NULL_OK));

SUPPORTS_DAC;

}

CONTRACT_END

mdToken mdLinkRef;

mdToken mdBinding;

IMDInternalImport *pMDImport = GetMDImport();

IfFailThrow(pMDImport->GetExportedTypeProps(

mdType,

NULL,

NULL,

&mdLinkRef, // Impl

&mdBinding, // Hint

NULL)); // dwflags

// Don't trust the returned tokens.

if (!pMDImport->IsValidToken(mdLinkRef))

{

if (loadFlag != Loader::Load)

{

RETURN NULL;

}

else

{

ThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN);

}

}

switch(TypeFromToken(mdLinkRef)) {

case mdtAssemblyRef:

{

*pCL = mdTypeDefNil; // We don't trust the mdBinding token

Assembly *pAssembly = NULL;

switch(loadFlag)

{

case Loader::Load:

{

#ifndef DACCESS_COMPILE

// LoadAssembly never returns NULL

DomainAssembly * pDomainAssembly =

GetModule()->LoadAssembly(mdLinkRef);

PREFIX_ASSUME(pDomainAssembly != NULL);

RETURN pDomainAssembly->GetModule();

#else

_ASSERTE(!"DAC shouldn't attempt to trigger loading");

return NULL;

#endif // !DACCESS_COMPILE

};

case Loader::DontLoad:

pAssembly = GetModule()->GetAssemblyIfLoaded(mdLinkRef);

break;

case Loader::SafeLookup:

pAssembly = GetModule()->LookupAssemblyRef(mdLinkRef);

break;

default:

_ASSERTE(FALSE);

}

if (pAssembly)

RETURN pAssembly->GetModule();

else

RETURN NULL;

}

case mdtFile:

{

// We may not want to trust this TypeDef token, since it

// was saved in a scope other than the one it was defined in

if (mdNested == mdTypeDefNil)

*pCL = mdBinding;

else

*pCL = mdNested;

// Note that we don't want to attempt a LoadModule if a GetModuleIfLoaded will

// succeed, because it has a stronger contract.

Module *pModule = GetModule()->GetModuleIfLoaded(mdLinkRef);

#ifdef DACCESS_COMPILE

return pModule;

#else

if (pModule != NULL)

RETURN pModule;

if(loadFlag==Loader::SafeLookup)

return NULL;

// We should never get here in the GC case - the above should have succeeded.

CONSISTENCY_CHECK(!FORBIDGC_LOADER_USE_ENABLED());

DomainAssembly* pDomainModule = NULL;

if (loadFlag == Loader::Load)

{

pDomainModule = GetModule()->LoadModule(mdLinkRef);

}

if (pDomainModule == NULL)

RETURN NULL;

else

{

pModule = pDomainModule->GetModule();

if (pModule == NULL)

{

_ASSERTE(loadFlag!=Loader::Load);

}

RETURN pModule;

}

#endif // DACCESS_COMPILE

}

case mdtExportedType:

// Only override the nested type token if it hasn't been set yet.

if (mdNested != mdTypeDefNil)

mdBinding = mdNested;

RETURN FindModuleByExportedType(mdLinkRef, loadFlag, mdBinding, pCL);

default:

ThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN_TYPE);

}

} // Assembly::FindModuleByExportedType

// The returned Module is non-NULL unless you prevented the load by setting loadFlag=Loader::DontLoad.

/* static */

Module * Assembly::FindModuleByTypeRef(

ModuleBase * pModule,

mdTypeRef tkType,

Loader::LoadFlag loadFlag,

BOOL * pfNoResolutionScope)

{

CONTRACT(Module *)

{

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;

PRECONDITION(CheckPointer(pModule));

PRECONDITION(TypeFromToken(tkType) == mdtTypeRef);

PRECONDITION(CheckPointer(pfNoResolutionScope));

POSTCONDITION( CheckPointer(RETVAL, loadFlag==Loader::Load ? NULL_NOT_OK : NULL_OK) );

SUPPORTS_DAC;

}

CONTRACT_END

// WARNING! Correctness of the type forwarder detection algorithm in code:ClassLoader::ResolveTokenToTypeDefThrowing

// relies on this function not performing any form of type forwarding itself.

IMDInternalImport * pImport;

mdTypeRef tkTopLevelEncloserTypeRef;

pImport = pModule->GetMDImport();

if (TypeFromToken(tkType) != mdtTypeRef)

{

ThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN_TYPE);

}

{

// Find the top level encloser

GCX_NOTRIGGER();

// If nested, get top level encloser's impl

int iter = 0;

int maxIter = 1000;

do

{

_ASSERTE(TypeFromToken(tkType) == mdtTypeRef);

tkTopLevelEncloserTypeRef = tkType;

if (!pImport->IsValidToken(tkType) || iter >= maxIter)

{

break;

}

IfFailThrow(pImport->GetResolutionScopeOfTypeRef(tkType, &tkType));

// nil-scope TR okay if there's an ExportedType

// Return manifest file

if (IsNilToken(tkType))

{

*pfNoResolutionScope = TRUE;

if (!pModule->IsFullModule())

{

// The ModuleBase scenarios should never need this

COMPlusThrowHR(COR_E_BADIMAGEFORMAT);

}

RETURN(static_cast<Module*>(pModule));

}

iter++;

}

while (TypeFromToken(tkType) == mdtTypeRef);

}

*pfNoResolutionScope = FALSE;

#ifndef DACCESS_COMPILE

if (!pImport->IsValidToken(tkType)) // redundant check only when invalid token already found.

{

THROW_BAD_FORMAT(BFA_BAD_TYPEREF_TOKEN, pModule);

}

#endif //!DACCESS_COMPILE

switch (TypeFromToken(tkType))

{

case mdtModule:

{

if (!pModule->IsFullModule())

{

// The ModuleBase scenarios should never need this

COMPlusThrowHR(COR_E_BADIMAGEFORMAT);

}

// Type is in the referencing module.

GCX_NOTRIGGER();

CANNOTTHROWCOMPLUSEXCEPTION();

RETURN( static_cast<Module*>(pModule) );

}

case mdtModuleRef:

{

if ((loadFlag != Loader::Load) || IsGCThread() || IsStackWalkerThread())

{

// Either we're not supposed to load, or we're doing a GC or stackwalk

// in which case we shouldn't need to load. So just look up the module

// and return what we find.

RETURN(pModule->LookupModule(tkType));

}

#ifndef DACCESS_COMPILE

if (loadFlag == Loader::Load)

{

DomainAssembly* pActualDomainAssembly = pModule->LoadModule(tkType);

RETURN(pActualDomainAssembly->GetModule());

}

else

{

RETURN NULL;

}

#else //DACCESS_COMPILE

_ASSERTE(loadFlag!=Loader::Load);

DacNotImpl();

RETURN NULL;

#endif //DACCESS_COMPILE

}

break;

case mdtAssemblyRef:

{

if(IsAfContentType_WindowsRuntime(pModule->GetAssemblyRefFlags(tkType)))

{

ThrowHR(COR_E_PLATFORMNOTSUPPORTED);

}

// Do this first because it has a strong contract

Assembly * pAssembly = NULL;

if (loadFlag == Loader::SafeLookup)

{

pAssembly = pModule->LookupAssemblyRef(tkType);

}

else

{

pAssembly = pModule->GetAssemblyIfLoaded(tkType);

}

if (pAssembly != NULL)

{

RETURN pAssembly->m_pModule;

}

#ifdef DACCESS_COMPILE

RETURN NULL;

#else

if (loadFlag != Loader::Load)

{

RETURN NULL;

}

DomainAssembly * pDomainAssembly = pModule->LoadAssembly(tkType);

if (pDomainAssembly == NULL)

RETURN NULL;

pAssembly = pDomainAssembly->GetAssembly();

if (pAssembly == NULL)

{

RETURN NULL;

}

else

{

RETURN pAssembly->m_pModule;

}

#endif //!DACCESS_COMPILE

}

default:

ThrowHR(COR_E_BADIMAGEFORMAT, BFA_INVALID_TOKEN_TYPE);

}

} // Assembly::FindModuleByTypeRef

#ifndef DACCESS_COMPILE

Module *Assembly::FindModuleByName(LPCSTR pszModuleName)

{

CONTRACT(Module *)

{

THROWS;

GC_TRIGGERS;

INJECT_FAULT(COMPlusThrowOM(););

MODE_ANY;

POSTCONDITION(CheckPointer(RETVAL));