Skip to content

Commit 85c1a73

Browse files
elinor-fungelinor-fung
authored
Move exposed module object from DomainAssembly to Module (#105901)
`DomainAssembly` currently has the exposed object corresponding to its `Module` and `Module` gets it from its `DomainAssembly` - move it to be stored `Module` instead. `Module::LoadModule` was returning `DomainAssembly` and the common thing callers immediately did was get its `Module` - make it return the `Module` instead.
1 parent 53a500e commit 85c1a73

File tree

10 files changed

+97
-130
lines changed

10 files changed

+97
-130
lines changed

‎src/coreclr/vm/assembly.cpp‎

Lines changed: 6 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -705,24 +705,10 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType,
705705
// We should never get here in the GC case - the above should have succeeded.
706706
CONSISTENCY_CHECK(!FORBIDGC_LOADER_USE_ENABLED());
707707

708-
DomainAssembly* pDomainModule = NULL;
709-
if (loadFlag == Loader::Load)
710-
{
711-
pDomainModule = GetModule()->LoadModule(mdLinkRef);
712-
}
713-
714-
if (pDomainModule == NULL)
715-
RETURN NULL;
716-
else
717-
{
718-
pModule = pDomainModule->GetModule();
719-
if (pModule == NULL)
720-
{
721-
_ASSERTE(loadFlag!=Loader::Load);
722-
}
708+
if (loadFlag != Loader::Load)
709+
return NULL;
723710

724-
RETURN pModule;
725-
}
711+
return GetModule()->LoadModule(mdLinkRef);
726712
#endif // DACCESS_COMPILE
727713
}
728714

@@ -849,8 +835,8 @@ Module * Assembly::FindModuleByTypeRef(
849835
#ifndef DACCESS_COMPILE
850836
if (loadFlag == Loader::Load)
851837
{
852-
DomainAssembly* pActualDomainAssembly = pModule->LoadModule(tkType);
853-
RETURN(pActualDomainAssembly->GetModule());
838+
Module* pActualModule = pModule->LoadModule(tkType);
839+
RETURN(pActualModule);
854840
}
855841
else
856842
{
@@ -1493,7 +1479,7 @@ MethodDesc* Assembly::GetEntryPoint()
14931479
Module *pModule = NULL;
14941480
switch(TypeFromToken(mdEntry)) {
14951481
case mdtFile:
1496-
pModule = m_pModule->LoadModule(mdEntry)->GetModule();
1482+
pModule = m_pModule->LoadModule(mdEntry);
14971483

14981484
mdEntry = pModule->GetEntryPointToken();
14991485
if ( (TypeFromToken(mdEntry) != mdtMethodDef) ||

‎src/coreclr/vm/assemblynative.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -707,16 +707,16 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
707707
HENUMInternalHolder phEnum(pAssembly->GetMDImport());
708708
phEnum.EnumInit(mdtFile, mdTokenNil);
709709

710-
InlineSArray<DomainAssembly *, 8> modules;
710+
InlineSArray<Module *, 8> modules;
711711

712-
modules.Append(pAssembly);
712+
modules.Append(pAssembly->GetModule());
713713

714714
mdFile mdFile;
715715
while (pAssembly->GetMDImport()->EnumNext(&phEnum, &mdFile))
716716
{
717717
if (fLoadIfNotFound)
718718
{
719-
DomainAssembly* pModule = pAssembly->GetModule()->LoadModule(mdFile);
719+
Module* pModule = pAssembly->GetModule()->LoadModule(mdFile);
720720
modules.Append(pModule);
721721
}
722722
}
@@ -733,9 +733,9 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
733733

734734
for(COUNT_T i = 0; i < modules.GetCount(); i++)
735735
{
736-
DomainAssembly * pModule = modules[i];
736+
Module * pModule = modules[i];
737737

738-
OBJECTREF o = pModule->GetExposedModuleObject();
738+
OBJECTREF o = pModule->GetExposedObject();
739739
orModules->SetAt(i, o);
740740
}
741741

‎src/coreclr/vm/ceeload.cpp‎

Lines changed: 72 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -329,6 +329,10 @@ void Module::NotifyEtwLoadFinished(HRESULT hr)
329329
// It cannot throw or fail.
330330
//
331331
Module::Module(Assembly *pAssembly, PEAssembly *pPEAssembly)
332+
: m_pPEAssembly{pPEAssembly}
333+
, m_dwTransientFlags{CLASSES_FREED}
334+
, m_pAssembly{pAssembly}
335+
, m_hExposedObject{}
332336
{
333337
CONTRACTL
334338
{
@@ -338,15 +342,12 @@ Module::Module(Assembly *pAssembly, PEAssembly *pPEAssembly)
338342
}
339343
CONTRACTL_END
340344

341-
PREFIX_ASSUME(pAssembly != NULL);
345+
PREFIX_ASSUME(m_pAssembly != NULL);
342346

343347
m_loaderAllocator = NULL;
344-
m_pAssembly = pAssembly;
345-
m_pPEAssembly = pPEAssembly;
346-
m_dwTransientFlags = CLASSES_FREED;
347348
m_pDynamicMetadata = (TADDR)NULL;
348349

349-
pPEAssembly->AddRef();
350+
m_pPEAssembly->AddRef();
350351
}
351352

352353
uint32_t Module::GetNativeMetadataAssemblyCount()
@@ -1147,6 +1148,11 @@ void Module::SetDomainAssembly(DomainAssembly *pDomainAssembly)
11471148
m_pDomainAssembly = pDomainAssembly;
11481149
}
11491150

1151+
//---------------------------------------------------------------------------------------
1152+
//
1153+
// Returns managed representation of the module (Module or ModuleBuilder).
1154+
// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
1155+
//
11501156
OBJECTREF Module::GetExposedObject()
11511157
{
11521158
CONTRACT(OBJECTREF)
@@ -1159,7 +1165,62 @@ OBJECTREF Module::GetExposedObject()
11591165
}
11601166
CONTRACT_END;
11611167

1162-
RETURN GetDomainAssembly()->GetExposedModuleObject();
1168+
LoaderAllocator * pLoaderAllocator = GetLoaderAllocator();
1169+
1170+
if (m_hExposedObject == (LOADERHANDLE)NULL)
1171+
{
1172+
// Atomically create a handle
1173+
LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL);
1174+
1175+
InterlockedCompareExchangeT(&m_hExposedObject, handle, static_cast<LOADERHANDLE>(0));
1176+
}
1177+
1178+
if (pLoaderAllocator->GetHandleValue(m_hExposedObject) == NULL)
1179+
{
1180+
REFLECTMODULEBASEREF refClass = NULL;
1181+
1182+
// Will be true only if LoaderAllocator managed object was already collected and therefore we should
1183+
// return NULL
1184+
bool fIsLoaderAllocatorCollected = false;
1185+
1186+
GCPROTECT_BEGIN(refClass);
1187+
1188+
refClass = (REFLECTMODULEBASEREF) AllocateObject(CoreLibBinder::GetClass(CLASS__MODULE));
1189+
refClass->SetModule(this);
1190+
1191+
// Attach the reference to the assembly to keep the LoaderAllocator for this collectible type
1192+
// alive as long as a reference to the module is kept alive.
1193+
if (GetAssembly() != NULL)
1194+
{
1195+
OBJECTREF refAssembly = GetAssembly()->GetExposedObject();
1196+
if ((refAssembly == NULL) && GetAssembly()->IsCollectible())
1197+
{
1198+
fIsLoaderAllocatorCollected = true;
1199+
}
1200+
refClass->SetAssembly(refAssembly);
1201+
}
1202+
1203+
pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedObject, (OBJECTREF)refClass, NULL);
1204+
GCPROTECT_END();
1205+
1206+
if (fIsLoaderAllocatorCollected)
1207+
{ // The LoaderAllocator managed object was already collected, we cannot re-create it
1208+
// Note: We did not publish the allocated Module/ModuleBuilder object, it will get collected
1209+
// by GC
1210+
return NULL;
1211+
}
1212+
}
1213+
1214+
RETURN pLoaderAllocator->GetHandleValue(m_hExposedObject);
1215+
}
1216+
1217+
OBJECTREF Module::GetExposedObjectIfExists()
1218+
{
1219+
LIMITED_METHOD_CONTRACT;
1220+
1221+
OBJECTREF objRet = NULL;
1222+
GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedObject, &objRet);
1223+
return objRet;
11631224
}
11641225

11651226
//
@@ -2411,6 +2472,9 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
24112472

24122473
ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();
24132474

2475+
if (kFile == mdFileNil)
2476+
return this;
2477+
24142478
// Handle the module ref case
24152479
if (TypeFromToken(kFile) == mdtModuleRef)
24162480
{
@@ -2423,19 +2487,14 @@ Module *Module::GetModuleIfLoaded(mdFile kFile)
24232487
RETURN GetAssembly()->GetModule()->GetModuleIfLoaded(mdFileNil);
24242488
}
24252489

2426-
if (kFile == mdFileNil)
2427-
{
2428-
return this;
2429-
}
2430-
24312490
RETURN NULL;
24322491
}
24332492

24342493
#ifndef DACCESS_COMPILE
24352494

2436-
DomainAssembly *ModuleBase::LoadModule(mdFile kFile)
2495+
Module *ModuleBase::LoadModule(mdFile kFile)
24372496
{
2438-
CONTRACT(DomainAssembly *)
2497+
CONTRACT(Module *)
24392498
{
24402499
INSTANCE_CHECK;
24412500
THROWS;

‎src/coreclr/vm/ceeload.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -547,7 +547,7 @@ class ModuleBase
547547
virtual PTR_Module LookupModule(mdToken kFile) { return NULL; }; //wrapper over GetModuleIfLoaded, takes modulerefs as well
548548
virtual Module *GetModuleIfLoaded(mdFile kFile) { return NULL; };
549549
#ifndef DACCESS_COMPILE
550-
virtual DomainAssembly *LoadModule(mdFile kFile);
550+
virtual Module *LoadModule(mdFile kFile);
551551
#endif
552552
DWORD GetAssemblyRefFlags(mdAssemblyRef tkAssemblyRef);
553553

@@ -897,6 +897,7 @@ class Module : public ModuleBase
897897
void SetDomainAssembly(DomainAssembly *pDomainAssembly);
898898

899899
OBJECTREF GetExposedObject();
900+
OBJECTREF GetExposedObjectIfExists();
900901

901902
ClassLoader *GetClassLoader();
902903
#ifdef FEATURE_CODE_VERSIONING
@@ -1601,6 +1602,8 @@ class Module : public ModuleBase
16011602

16021603
PTR_Assembly *m_NativeMetadataAssemblyRefMap;
16031604

1605+
LOADERHANDLE m_hExposedObject;
1606+
16041607
// Buffer of Metadata storage for dynamic modules. May be NULL. This provides a reasonable way for
16051608
// the debugger to get metadata of dynamic modules from out of process.
16061609
// A dynamic module will eagerly serialize its metadata to this buffer.

‎src/coreclr/vm/domainassembly.cpp‎

Lines changed: 0 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,6 @@ DomainAssembly::DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoader
3333
m_pLoaderAllocator(pLoaderAllocator),
3434
m_level(FILE_LOAD_CREATE),
3535
m_loading(TRUE),
36-
m_hExposedModuleObject{},
3736
m_hExposedAssemblyObject{},
3837
m_pError(NULL),
3938
m_bDisableActivationCheck(FALSE),
@@ -310,71 +309,6 @@ BOOL DomainAssembly::IsVisibleToDebugger()
310309

311310
#ifndef DACCESS_COMPILE
312311

313-
//---------------------------------------------------------------------------------------
314-
//
315-
// Returns managed representation of the module (Module or ModuleBuilder).
316-
// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
317-
//
318-
OBJECTREF DomainAssembly::GetExposedModuleObject()
319-
{
320-
CONTRACTL
321-
{
322-
INSTANCE_CHECK;
323-
THROWS;
324-
MODE_COOPERATIVE;
325-
GC_TRIGGERS;
326-
}
327-
CONTRACTL_END;
328-
329-
LoaderAllocator * pLoaderAllocator = GetLoaderAllocator();
330-
331-
if (m_hExposedModuleObject == (LOADERHANDLE)NULL)
332-
{
333-
// Atomically create a handle
334-
LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL);
335-
336-
InterlockedCompareExchangeT(&m_hExposedModuleObject, handle, static_cast<LOADERHANDLE>(0));
337-
}
338-
339-
if (pLoaderAllocator->GetHandleValue(m_hExposedModuleObject) == NULL)
340-
{
341-
REFLECTMODULEBASEREF refClass = NULL;
342-
343-
// Will be true only if LoaderAllocator managed object was already collected and therefore we should
344-
// return NULL
345-
bool fIsLoaderAllocatorCollected = false;
346-
347-
GCPROTECT_BEGIN(refClass);
348-
349-
refClass = (REFLECTMODULEBASEREF) AllocateObject(CoreLibBinder::GetClass(CLASS__MODULE));
350-
refClass->SetModule(GetModule());
351-
352-
// Attach the reference to the assembly to keep the LoaderAllocator for this collectible type
353-
// alive as long as a reference to the module is kept alive.
354-
if (GetModule()->GetAssembly() != NULL)
355-
{
356-
OBJECTREF refAssembly = GetModule()->GetAssembly()->GetExposedObject();
357-
if ((refAssembly == NULL) && GetModule()->GetAssembly()->IsCollectible())
358-
{
359-
fIsLoaderAllocatorCollected = true;
360-
}
361-
refClass->SetAssembly(refAssembly);
362-
}
363-
364-
pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedModuleObject, (OBJECTREF)refClass, NULL);
365-
GCPROTECT_END();
366-
367-
if (fIsLoaderAllocatorCollected)
368-
{ // The LoaderAllocator managed object was already collected, we cannot re-create it
369-
// Note: We did not publish the allocated Module/ModuleBuilder object, it will get collected
370-
// by GC
371-
return NULL;
372-
}
373-
}
374-
375-
return pLoaderAllocator->GetHandleValue(m_hExposedModuleObject);
376-
}
377-
378312
BOOL DomainAssembly::DoIncrementalLoad(FileLoadLevel level)
379313
{
380314
STANDARD_VM_CONTRACT;

‎src/coreclr/vm/domainassembly.h‎

Lines changed: 0 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -112,17 +112,6 @@ class DomainAssembly final
112112
// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases).
113113
OBJECTREF GetExposedAssemblyObject();
114114

115-
OBJECTREF GetExposedModuleObjectIfExists()
116-
{
117-
LIMITED_METHOD_CONTRACT;
118-
119-
OBJECTREF objRet = NULL;
120-
GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedModuleObject, &objRet);
121-
return objRet;
122-
}
123-
124-
OBJECTREF GetExposedModuleObject();
125-
126115
BOOL IsSystem()
127116
{
128117
WRAPPER_NO_CONTRACT;
@@ -409,7 +398,6 @@ class DomainAssembly final
409398
FileLoadLevel m_level;
410399
BOOL m_loading;
411400

412-
LOADERHANDLE m_hExposedModuleObject;
413401
LOADERHANDLE m_hExposedAssemblyObject;
414402

415403
ExInfo* m_pError;

‎src/coreclr/vm/jitinterface.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -959,10 +959,10 @@ void CEEInfo::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken
959959
ThrowBadTokenException(pResolvedToken);
960960

961961
{
962-
DomainAssembly *pTargetModule = pModule->LoadModule(metaTOK);
962+
Module *pTargetModule = pModule->LoadModule(metaTOK);
963963
if (pTargetModule == NULL)
964964
COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
965-
th = TypeHandle(pTargetModule->GetModule()->GetGlobalMethodTable());
965+
th = TypeHandle(pTargetModule->GetGlobalMethodTable());
966966
if (th.IsNull())
967967
COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
968968
}

‎src/coreclr/vm/memberload.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -292,10 +292,10 @@ void MemberLoader::GetDescFromMemberRef(ModuleBase * pModule,
292292
{
293293
case mdtModuleRef:
294294
{
295-
DomainAssembly *pTargetModule = pModule->LoadModule(parent);
295+
Module *pTargetModule = pModule->LoadModule(parent);
296296
if (pTargetModule == NULL)
297297
COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
298-
typeHnd = TypeHandle(pTargetModule->GetModule()->GetGlobalMethodTable());
298+
typeHnd = TypeHandle(pTargetModule->GetGlobalMethodTable());
299299
if (typeHnd.IsNull())
300300
COMPlusThrowHR(COR_E_BADIMAGEFORMAT);
301301
}

0 commit comments

Comments
 (0)