}
else
{
- if (pFlags && pMTD->bIsShared)
- {
- BYTE flags;
- DWORD_PTR pTargetFlags = (DWORD_PTR) pDLMD->pClassData + RidFromToken(pMTD->cl) - 1;
- move_xp (flags, pTargetFlags);
-
- *pFlags = flags;
- }
-
-
*pOutPtr = dwTmp;
}
return;
ExtOut(" <<\n");
}
-void DisplayThreadStatic (DacpModuleData* pModule, DacpMethodTableData* pMT, DacpFieldDescData *pFD, BOOL fIsShared)
+void DisplayThreadStatic(DacpModuleData* pModule, DacpMethodTableData* pMT, DacpFieldDescData *pFD)
{
SIZE_T dwModuleIndex = (SIZE_T)pModule->dwModuleIndex;
SIZE_T dwModuleDomainID = (SIZE_T)pModule->dwModuleID;
// It's annoying that we have to issue one request for
// domain-neutral modules and domain-specific modules.
DacpDomainLocalModuleData vDomainLocalModule;
- if (fIsShared)
- {
- if (g_sos->GetDomainLocalModuleDataFromAppDomain(appDomainAddr, (int)dwModuleDomainID, &vDomainLocalModule) != S_OK)
- {
- // Not initialized, go to next thread
- // and continue looping
- CurThread = vThread.nextThread;
- continue;
- }
- }
- else
+ if (g_sos->GetDomainLocalModuleDataFromModule(pMT->Module, &vDomainLocalModule) != S_OK)
{
- if (g_sos->GetDomainLocalModuleDataFromModule(pMT->Module, &vDomainLocalModule) != S_OK)
- {
- // Not initialized, go to next thread
- // and continue looping
- CurThread = vThread.nextThread;
- continue;
- }
+ // Not initialized, go to next thread
+ // and continue looping
+ CurThread = vThread.nextThread;
+ continue;
}
// Get the TLM
numInstanceFields = 0;
}
- BOOL fIsShared = pMTD->bIsShared;
-
if (pMTD->ParentMethodTable)
{
DacpMethodTableData vParentMethTable;
dwAddr = vFieldDesc.NextField;
DWORD offset = vFieldDesc.dwOffset;
- if(!((vFieldDesc.bIsThreadLocal || fIsShared) && vFieldDesc.bIsStatic))
+ if(!(vFieldDesc.bIsThreadLocal && vFieldDesc.bIsStatic))
{
if (!bValueClass)
{
if (vFieldDesc.bIsStatic && vFieldDesc.bIsThreadLocal)
{
numStaticFields ++;
- if (fIsShared)
- ExtOut("%8s %" POINTERSIZE "s", "shared", vFieldDesc.bIsThreadLocal ? "TLstatic" : "CLstatic");
- else
- ExtOut("%8s ", vFieldDesc.bIsThreadLocal ? "TLstatic" : "CLstatic");
+ ExtOut("%8s ", vFieldDesc.bIsThreadLocal ? "TLstatic" : "CLstatic");
NameForToken_s(TokenFromRid(vFieldDesc.mb, mdtFieldDef), pImport, g_mdName, mdNameLen, false);
ExtOut(" %S\n", g_mdName);
DacpModuleData vModule;
if (vModule.Request(g_sos,pMTD->Module) == S_OK)
{
- DisplayThreadStatic(&vModule, pMTD, &vFieldDesc, fIsShared);
+ DisplayThreadStatic(&vModule, pMTD, &vFieldDesc);
}
}
}
{
numStaticFields ++;
- if (fIsShared)
- {
- ExtOut("%8s %" POINTERSIZE "s", "shared", "static");
+ ExtOut("%8s ", "static");
- NameForToken_s(TokenFromRid(vFieldDesc.mb, mdtFieldDef), pImport, g_mdName, mdNameLen, false);
- ExtOut(" %S\n", g_mdName);
+ DacpDomainLocalModuleData vDomainLocalModule;
- if (IsMiniDumpFile())
- {
- ExtOut(" <no information>\n");
- }
- else
- {
- DacpModuleData vModule;
- if (vModule.Request(g_sos,pMTD->Module) == S_OK)
- {
- DisplaySharedStatic(vModule.dwModuleID, pMTD, &vFieldDesc);
- }
- }
+ // The MethodTable isn't shared, so the module must not be loaded domain neutral. We can
+ // get the specific DomainLocalModule instance without needing to know the AppDomain in advance.
+ if (g_sos->GetDomainLocalModuleDataFromModule(pMTD->Module, &vDomainLocalModule) != S_OK)
+ {
+ ExtOut(" <no information>\n");
}
else
{
- ExtOut("%8s ", "static");
-
- DacpDomainLocalModuleData vDomainLocalModule;
-
- // The MethodTable isn't shared, so the module must not be loaded domain neutral. We can
- // get the specific DomainLocalModule instance without needing to know the AppDomain in advance.
- if (g_sos->GetDomainLocalModuleDataFromModule(pMTD->Module, &vDomainLocalModule) != S_OK)
- {
- ExtOut(" <no information>\n");
- }
- else
- {
- DWORD_PTR dwTmp;
- GetStaticFieldPTR(&dwTmp, &vDomainLocalModule, pMTD, &vFieldDesc);
- DisplayDataMember(&vFieldDesc, dwTmp);
+ DWORD_PTR dwTmp;
+ GetStaticFieldPTR(&dwTmp, &vDomainLocalModule, pMTD, &vFieldDesc);
+ DisplayDataMember(&vFieldDesc, dwTmp);
- NameForToken_s(TokenFromRid(vFieldDesc.mb, mdtFieldDef), pImport, g_mdName, mdNameLen, false);
- ExtOut(" %S\n", g_mdName);
- }
+ NameForToken_s(TokenFromRid(vFieldDesc.mb, mdtFieldDef), pImport, g_mdName, mdNameLen, false);
+ ExtOut(" %S\n", g_mdName);
}
}
else
MTData->cl = pMT->GetCl();
MTData->dwAttrClass = pMT->GetAttrClass();
MTData->bContainsPointers = pMT->ContainsPointers();
- MTData->bIsShared = (pMT->IsDomainNeutral() ? TRUE : FALSE); // flags & enum_flag_DomainNeutral
+ MTData->bIsShared = FALSE;
MTData->bIsDynamic = pMT->IsDynamicStatics();
}
}
assemblyData->ParentDomain = HOST_CDADDR(pAssembly->GetDomain());
assemblyData->isDynamic = pAssembly->IsDynamic();
assemblyData->ModuleCount = 0;
- assemblyData->isDomainNeutral = pAssembly->IsDomainNeutral();
+ assemblyData->isDomainNeutral = FALSE;
- if (pAssembly->GetManifestFile())
- {
-
- }
+ pAssembly->GetManifestFile();
ModuleIterator mi = pAssembly->IterateModules();
while (mi.Next())
SOSDacEnter();
Module* pModule = PTR_Module(TO_TADDR(addr));
- if( pModule->GetAssembly()->IsDomainNeutral() )
+ DomainLocalModule* pLocalModule = PTR_DomainLocalModule(pModule->GetDomainLocalModule(NULL));
+ if (!pLocalModule)
{
- // The module is loaded domain-neutral, then we need to know the specific AppDomain in order to
- // choose a DomainLocalModule instance. Rather than try and guess an AppDomain (eg. based on
- // whatever the current debugger thread is in), we'll fail and force the debugger to explicitly use
- // a specific AppDomain.
hr = E_INVALIDARG;
}
else
- {
- DomainLocalModule* pLocalModule = PTR_DomainLocalModule(pModule->GetDomainLocalModule(NULL));
- if (!pLocalModule)
- {
- hr = E_INVALIDARG;
- }
- else
- {
- pLocalModuleData->pGCStaticDataStart = TO_CDADDR(PTR_TO_TADDR(pLocalModule->GetPrecomputedGCStaticsBasePointer()));
- pLocalModuleData->pNonGCStaticDataStart = TO_CDADDR(pLocalModule->GetPrecomputedNonGCStaticsBasePointer());
- pLocalModuleData->pDynamicClassTable = PTR_CDADDR(pLocalModule->m_pDynamicClassTable.Load());
- pLocalModuleData->pClassData = (TADDR) (PTR_HOST_MEMBER_TADDR(DomainLocalModule, pLocalModule, m_pDataBlob));
- }
+ {
+ pLocalModuleData->pGCStaticDataStart = TO_CDADDR(PTR_TO_TADDR(pLocalModule->GetPrecomputedGCStaticsBasePointer()));
+ pLocalModuleData->pNonGCStaticDataStart = TO_CDADDR(pLocalModule->GetPrecomputedNonGCStaticsBasePointer());
+ pLocalModuleData->pDynamicClassTable = PTR_CDADDR(pLocalModule->m_pDynamicClassTable.Load());
+ pLocalModuleData->pClassData = (TADDR) (PTR_HOST_MEMBER_TADDR(DomainLocalModule, pLocalModule, m_pDataBlob));
}
SOSDacLeave();
if (m_pModules != NULL)
{
- if (pModule->GetAssembly()->IsDomainNeutral())
- {
- // We have to make sure to lookup the module with the app domain parameter if the module lives in a shared assembly
- dmod = m_pModules->GetModule(pModule, pAppDomain);
- }
- else
- {
- dmod = m_pModules->GetModule(pModule);
- }
+ dmod = m_pModules->GetModule(pModule);
}
// If it doesn't exist, create it.
// Remove all patches that apply to this module/AppDomain combination
AppDomain* domainToRemovePatchesIn = NULL; // all domains by default
- if( pRuntimeModule->GetAssembly()->IsDomainNeutral() )
- {
- // Deactivate all the patches specific to the AppDomain being unloaded
- domainToRemovePatchesIn = pAppDomain;
- }
+
// Note that we'll explicitly NOT delete DebuggerControllers, so that
// the Right Side can delete them later.
DebuggerController::RemovePatchesFromModule(pRuntimeModule, domainToRemovePatchesIn);
// Deactive all JMC functions in this module. We don't do this for shared assemblies
// because JMC status is not maintained on a per-AppDomain basis and we don't
// want to change the JMC behavior of the module in other domains.
- if( !pRuntimeModule->GetAssembly()->IsDomainNeutral() )
+ LOG((LF_CORDB, LL_EVERYTHING, "Setting all JMC methods to false:\n"));
+ DebuggerDataLockHolder debuggerDataLockHolder(this);
+ DebuggerMethodInfoTable * pTable = GetMethodInfoTable();
+ if (pTable != NULL)
{
- LOG((LF_CORDB, LL_EVERYTHING, "Setting all JMC methods to false:\n"));
- DebuggerDataLockHolder debuggerDataLockHolder(this);
- DebuggerMethodInfoTable * pTable = GetMethodInfoTable();
- if (pTable != NULL)
- {
- HASHFIND info;
+ HASHFIND info;
- for (DebuggerMethodInfo *dmi = pTable->GetFirstMethodInfo(&info);
- dmi != NULL;
- dmi = pTable->GetNextMethodInfo(&info))
+ for (DebuggerMethodInfo *dmi = pTable->GetFirstMethodInfo(&info);
+ dmi != NULL;
+ dmi = pTable->GetNextMethodInfo(&info))
+ {
+ if (dmi->m_module == pRuntimeModule)
{
- if (dmi->m_module == pRuntimeModule)
- {
- dmi->SetJMCStatus(false);
- }
+ dmi->SetJMCStatus(false);
}
}
- LOG((LF_CORDB, LL_EVERYTHING, "Done clearing JMC methods!\n"));
}
+ LOG((LF_CORDB, LL_EVERYTHING, "Done clearing JMC methods!\n"));
// Delete the Left Side representation of the module.
if (m_pModules != NULL)
if (m->GetRuntimeModule() == this->GetRuntimeModule())
{
// Make sure we're picking another primary module.
- if (m->GetPrimaryModule() == m)
- {
- // If we find another one, it must be domain neutral
- _ASSERTE( m_pRuntimeModule->GetAssembly()->IsDomainNeutral() );
-
- m_pPrimaryModule = m;
- LOG((LF_CORDB, LL_INFO100000, "DM::PickPrimaryModule, this=0x%p, primary=0x%p\n", this, m));
- return;
- }
+ _ASSERTE(m->GetPrimaryModule() != m);
}
} // end for
}
CONTRACTL_END;
- _ASSERTE(module != NULL);
- _ASSERTE(ThreadHoldsLock());
-
- DebuggerModule * pDeletedModule = NULL;
-
- LOG((LF_CORDB, LL_EVERYTHING, "DMT::RM: mod:0x%x AD:0x%x neutral:0x%x\n",
- module, pAppDomain, module->GetAssembly()->IsDomainNeutral() ));
-
// If this is a domain neutral module, then scan the complete list of DebuggerModules looking
// for the one with a matching appdomain id.
// Note: we have to make sure to lookup the module with the app domain parameter if the module lives in a shared
// assembly or the system assembly. <BUGNUM>Bugs 65943 & 81728.</BUGNUM>
- _ASSERTE( SystemDomain::SystemAssembly()->IsDomainNeutral() );
- if (module->GetAssembly()->IsDomainNeutral())
- {
- // This module is being unloaded from a specific AppDomain, but may still exist in other AppDomains
-
- HASHFIND findmodule;
- DebuggerModuleEntry *moduleentry;
-
- for (moduleentry = (DebuggerModuleEntry*) FindFirstEntry(&findmodule);
- moduleentry != NULL;
- moduleentry = (DebuggerModuleEntry*) FindNextEntry(&findmodule))
- {
- DebuggerModule *pModule = moduleentry->module;
-
- if ((pModule->GetRuntimeModule() == module) &&
- (pModule->GetAppDomain() == pAppDomain))
- {
- LOG((LF_CORDB, LL_EVERYTHING, "DMT::RM: found 0x%x (DM:0x%x)\n",
- moduleentry, moduleentry->module));
-
- pDeletedModule = pModule;
-
- // Remove from table
- Delete(HASH(module), (HASHENTRY *)moduleentry);
-
- break;
- }
- }
- // we should always find the module!!
- _ASSERTE (moduleentry != NULL);
- }
- else
- {
- // This module is not shared among multiple AppDomains
+ _ASSERTE( FALSE );
- DebuggerModuleEntry *entry
- = (DebuggerModuleEntry *) Find(HASH(module), KEY(module));
-
- _ASSERTE(entry != NULL); // it had better be in there!
-
- if (entry != NULL) // if its not, we fail gracefully in a free build
- {
- LOG((LF_CORDB, LL_EVERYTHING, "DMT::RM: found 0x%x (DM:0x%x)\n",
- entry, entry->module));
-
- pDeletedModule = entry->module;
-
- // Remove from table
- Delete(HASH(module), (HASHENTRY *)entry);
-
- // There should not be any other entry in the table for the same module
- _ASSERTE( Find(HASH(module), KEY(module)) == NULL );
- }
- }
-
- _ASSERTE(pDeletedModule != NULL);
-
- // Update the primary module pointers. If any other module had this as a
- // primary module, then we have to update that pointer (since we can't
- // have our primary module be deleted!)
- {
- HASHFIND findmodule;
- DebuggerModuleEntry *moduleentry;
-
- DebuggerModule * pNewPrimary = NULL;
-
- for (moduleentry = (DebuggerModuleEntry*) FindFirstEntry(&findmodule);
- moduleentry != NULL;
- moduleentry = (DebuggerModuleEntry*) FindNextEntry(&findmodule))
- {
- DebuggerModule *pOther = moduleentry->module;
- _ASSERTE(pOther != NULL);
- _ASSERTE(pOther != pDeletedModule);
-
- // If pOther's primary was just deleted, then update it.
- if (pOther->GetPrimaryModule() == pDeletedModule)
- {
- if (pNewPrimary == NULL)
- {
- pNewPrimary = pOther;
- LOG((LF_CORDB, LL_INFO1000, "DMT::RM changed primary module from 0x%p to 0x%p\n", pDeletedModule, pNewPrimary));
- }
- pOther->SetPrimaryModule(pNewPrimary);
- }
- } // end for
- }
-
- DeleteInteropSafe(pDeletedModule);
}
DWORD ComponentSize;
mdTypeDef cl; // Metadata token
DWORD dwAttrClass; // cached metadata
- BOOL bIsShared; // flags & enum_flag_DomainNeutral
+ BOOL bIsShared; // Always false, preserved for backward compatibility
BOOL bIsDynamic;
BOOL bContainsPointers;
BOOL isDynamic;
UINT ModuleCount;
UINT LoadContext;
- BOOL isDomainNeutral;
+ BOOL isDomainNeutral; // Always false, preserved for backward compatibility
DWORD dwLocationFlags;
HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr, CLRDATA_ADDRESS baseDomainPtr)
while (i.Next(pDomainAssembly.This()))
{
Assembly * assembly = pDomainAssembly->m_pAssembly;
- if ((assembly != NULL) && !assembly->IsDomainNeutral())
+ if ((assembly != NULL))
assembly->DeleteNativeCodeRanges();
}
}
// loaded to at least the FILE_LOAD_ALLOCATE level. Since domain shutdown can take place
// asynchronously this property cannot be guaranteed. Access the m_pAssembly field directly instead.
Assembly * assembly = pDomainAssembly->m_pAssembly;
- if (assembly && !assembly->IsDomainNeutral())
+ if (assembly)
assembly->Terminate();
}
}
else
{
- if (!pAsm->GetCurrentAssembly()->IsDomainNeutral())
- pAsm->ReleaseFiles();
+ pAsm->ReleaseFiles();
}
}
} // AppDomain::ReleaseFiles
}
else
{
- if (!IsDomainNeutral())
+ if (!IsCollectible())
{
- 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;
- }
+ // 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); // pLoaderAllocator may only be non-null for collectible types
- // use global loader heaps
- m_pLoaderAllocator = SystemDomain::GetGlobalLoaderAllocator();
+ _ASSERTE(pLoaderAllocator != NULL); // ppLoaderAllocator must be non-null for collectible assemblies
+
+ m_pLoaderAllocator = pLoaderAllocator;
}
}
_ASSERTE(m_pLoaderAllocator != NULL);
OBJECTHANDLE GetLoaderAllocatorObjectHandle() { WRAPPER_NO_CONTRACT; return GetLoaderAllocator()->GetLoaderAllocatorObjectHandle(); }
#endif // FEATURE_COLLECTIBLE_TYPES
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
-
BOOL IsSIMDVectorAssembly() { LIMITED_METHOD_DAC_CONTRACT; return m_fIsSIMDVectorAssembly; }
#ifdef FEATURE_PREJIT
// Shared or collectible assemblies should not be used for the parent in the
// late-bound case.
- if (pRefAssembly && (!pRefAssembly->IsDomainNeutral()) && (!pRefAssembly->IsCollectible()))
+ if (pRefAssembly && (!pRefAssembly->IsCollectible()))
{
pParentAssembly= pRefAssembly->GetDomainAssembly();
}
#ifdef DEBUGGING_SUPPORTED
BOOL setEnC = ((newBits & DACF_ENC_ENABLED) != 0) && IsEditAndContinueCapable();
- // IsEditAndContinueCapable should already check !GetAssembly()->IsDomainNeutral
- _ASSERTE(!setEnC || !GetAssembly()->IsDomainNeutral());
-
// The only way can change Enc is through debugger override.
if (setEnC)
{
#ifdef EnC_SUPPORTED
if (IsEditAndContinueCapable(pAssembly, file))
{
- // IsEditAndContinueCapable should already check !pAssembly->IsDomainNeutral
- _ASSERTE(!pAssembly->IsDomainNeutral());
-
// if file is EnCCapable, always create an EnC-module, but EnC won't necessarily be enabled.
// Debugger enables this by calling SetJITCompilerFlags on LoadModule callback.
// Some modules are never EnC-capable
return ! (pAssembly->GetDebuggerInfoBits() & DACF_ALLOW_JIT_OPTS ||
- pAssembly->IsDomainNeutral() ||
file->IsSystem() ||
file->IsResource() ||
file->HasNativeImage() ||
MODE_ANY;
}
CONTRACTL_END;
- if (GetAssembly()->IsDomainNeutral())
- {
- // We do not recycle ModuleIndexes used by domain neutral Modules.
- }
- else
+ if (m_ModuleID != NULL)
{
- if (m_ModuleID != NULL)
- {
- // Module's m_ModuleID should not contain the ID, it should
- // contain a pointer to the DLM
- _ASSERTE(!Module::IsEncodedModuleIndex((SIZE_T)m_ModuleID));
- _ASSERTE(m_ModuleIndex == m_ModuleID->GetModuleIndex());
+ // Module's m_ModuleID should not contain the ID, it should
+ // contain a pointer to the DLM
+ _ASSERTE(!Module::IsEncodedModuleIndex((SIZE_T)m_ModuleID));
+ _ASSERTE(m_ModuleIndex == m_ModuleID->GetModuleIndex());
#ifndef CROSSGEN_COMPILE
- if (IsCollectible())
+ if (IsCollectible())
+ {
+ ThreadStoreLockHolder tsLock;
+ Thread *pThread = NULL;
+ while ((pThread = ThreadStore::GetThreadList(pThread)) != NULL)
{
- ThreadStoreLockHolder tsLock;
- Thread *pThread = NULL;
- while ((pThread = ThreadStore::GetThreadList(pThread)) != NULL)
- {
- pThread->DeleteThreadStaticData(m_ModuleIndex);
- }
+ pThread->DeleteThreadStaticData(m_ModuleIndex);
}
+ }
#endif // CROSSGEN_COMPILE
- // Get the ModuleIndex from the DLM and free it
- Module::FreeModuleIndex(m_ModuleIndex);
- }
- else
- {
- // This was an empty, short-lived Module object that
- // was never assigned a ModuleIndex...
- }
+ // Get the ModuleIndex from the DLM and free it
+ Module::FreeModuleIndex(m_ModuleIndex);
+ }
+ else
+ {
+ // This was an empty, short-lived Module object that
+ // was never assigned a ModuleIndex...
}
}
PRECONDITION(CheckPointer(pModule));
PRECONDITION(pModule != this);
PRECONDITION(!IsSystem());
- PRECONDITION(!GetAssembly()->IsDomainNeutral() || pModule->GetAssembly()->IsDomainNeutral() || GetAppDomain()->IsDefaultDomain());
// Postcondition about activation
}
CONTRACT_END;
// for now, Module::IsReflection is equivalent to m_file->IsDynamic,
// which is checked by IsEditAndContinueCapable(m_pAssembly, m_file)
- _ASSERTE(!isEnCCapable || (!this->IsReflection() && !GetAssembly()->IsDomainNeutral()));
+ _ASSERTE(!isEnCCapable || (!this->IsReflection()));
return isEnCCapable;
}
#endif // FEATURE_PREJIT
#endif // #ifndef DACCESS_COMPILE
- Module *pFirstNonSharedLoaderModule = NULL;
- Module *pFirstNonSystemSharedModule = NULL;
Module *pLoaderModule = NULL;
if (pDefinitionModule)
{
if (pDefinitionModule->IsCollectible())
goto ComputeCollectibleLoaderModule;
- if (!pDefinitionModule->GetAssembly()->IsDomainNeutral())
- {
- pFirstNonSharedLoaderModule = pDefinitionModule;
- }
- else
- if (!pDefinitionModule->IsSystem())
- {
- pFirstNonSystemSharedModule = pDefinitionModule;
- }
+ pLoaderModule = pDefinitionModule;
}
for (DWORD i = 0; i < classInst.GetNumArgs(); i++)
Module* pModule = classArg.GetLoaderModule();
if (pModule->IsCollectible())
goto ComputeCollectibleLoaderModule;
- if (!pModule->GetAssembly()->IsDomainNeutral())
- {
- if (pFirstNonSharedLoaderModule == NULL)
- pFirstNonSharedLoaderModule = pModule;
- }
- else
- if (!pModule->IsSystem())
- {
- if (pFirstNonSystemSharedModule == NULL)
- pFirstNonSystemSharedModule = pModule;
- }
+ if (pLoaderModule == NULL)
+ pLoaderModule = pModule;
}
for (DWORD i = 0; i < methodInst.GetNumArgs(); i++)
Module *pModule = methodArg.GetLoaderModule();
if (pModule->IsCollectible())
goto ComputeCollectibleLoaderModule;
- if (!pModule->GetAssembly()->IsDomainNeutral())
- {
- if (pFirstNonSharedLoaderModule == NULL)
- pFirstNonSharedLoaderModule = pModule;
- }
- else
- if (!pModule->IsSystem())
- {
- if (pFirstNonSystemSharedModule == NULL)
- pFirstNonSystemSharedModule = pModule;
- }
+ if (pLoaderModule == NULL)
+ pLoaderModule = pModule;
}
- // RULE: Prefer modules in non-shared assemblies.
- // This ensures safety of app-domain unloading.
- if (pFirstNonSharedLoaderModule != NULL)
- {
- pLoaderModule = pFirstNonSharedLoaderModule;
- }
- else if (pFirstNonSystemSharedModule != NULL)
- {
- // Use pFirstNonSystemSharedModule just so C<object> ends up in module C - it
- // shouldn't actually matter at all though.
- pLoaderModule = pFirstNonSystemSharedModule;
- }
- else
+ if (pLoaderModule == NULL)
{
CONSISTENCY_CHECK(MscorlibBinder::GetModule() && MscorlibBinder::GetModule()->IsSystem());
Assembly* pAssembly = pModule->GetAssembly();
DomainAssembly* pDomainAssembly = pAssembly->GetDomainAssembly();
- // Dynamic assemblies should be 1:1 with DomainAssemblies.
- _ASSERTE(!pAssembly->IsDomainNeutral());
-
DWORD actualFlags;
actualFlags = ((DWORD)pDomainAssembly->GetDebuggerInfoBits() & mask) | flags;
pDomainAssembly->SetDebuggerInfoBits((DebuggerAssemblyControlFlags)actualFlags);
pEntryKey->m_Instantiation = Instantiation(
(TypeHandle *) (pEntryKey->m_strCookie + pEntryKey->m_cCookieStrBytes),
pKey->GetMarshalerInstantiation().GetNumArgs());
- pEntryKey->m_bSharedHelper = pKey->IsSharedHelper();
memcpy((void*)pEntryKey->m_strMarshalerTypeName, pKey->GetMarshalerTypeName(), pKey->GetMarshalerTypeNameByteCount());
memcpy((void*)pEntryKey->m_strCookie, pKey->GetCookieString(), pKey->GetCookieStringByteCount());
memcpy((void*)pEntryKey->m_Instantiation.GetRawArgs(), pKey->GetMarshalerInstantiation().GetRawArgs(),
pEntryKey->m_cCookieStrBytes = pKey->GetCookieStringByteCount();
pEntryKey->m_strCookie = pKey->GetCookieString();
pEntryKey->m_Instantiation = Instantiation(pKey->GetMarshalerInstantiation());
- pEntryKey->m_bSharedHelper = pKey->IsSharedHelper();
}
return pEntry;
EECMHelperHashtableKey *pEntryKey = (EECMHelperHashtableKey *) pEntry->Key;
- if (pEntryKey->IsSharedHelper() != pKey->IsSharedHelper())
- return FALSE;
-
if (pEntryKey->GetMarshalerTypeNameByteCount() != pKey->GetMarshalerTypeNameByteCount())
return FALSE;
return (DWORD)
(HashBytes((const BYTE *) pKey->GetMarshalerTypeName(), pKey->GetMarshalerTypeNameByteCount()) +
HashBytes((const BYTE *) pKey->GetCookieString(), pKey->GetCookieStringByteCount()) +
- HashBytes((const BYTE *) pKey->GetMarshalerInstantiation().GetRawArgs(), pKey->GetMarshalerInstantiation().GetNumArgs() * sizeof(LPVOID)) +
- (pKey->IsSharedHelper() ? 1 : 0));
+ HashBytes((const BYTE *) pKey->GetMarshalerInstantiation().GetRawArgs(), pKey->GetMarshalerInstantiation().GetNumArgs() * sizeof(LPVOID)));
}
class EECMHelperHashtableKey
{
public:
- EECMHelperHashtableKey(DWORD cMarshalerTypeNameBytes, LPCSTR strMarshalerTypeName, DWORD cCookieStrBytes, LPCSTR strCookie, Instantiation instantiation, BOOL bSharedHelper)
+ EECMHelperHashtableKey(DWORD cMarshalerTypeNameBytes, LPCSTR strMarshalerTypeName, DWORD cCookieStrBytes, LPCSTR strCookie, Instantiation instantiation)
: m_cMarshalerTypeNameBytes(cMarshalerTypeNameBytes)
, m_strMarshalerTypeName(strMarshalerTypeName)
, m_cCookieStrBytes(cCookieStrBytes)
, m_strCookie(strCookie)
, m_Instantiation(instantiation)
- , m_bSharedHelper(bSharedHelper)
{
LIMITED_METHOD_CONTRACT;
}
LIMITED_METHOD_CONTRACT;
return m_Instantiation;
}
- inline BOOL IsSharedHelper() const
- {
- LIMITED_METHOD_CONTRACT;
- return m_bSharedHelper;
- }
-
DWORD m_cMarshalerTypeNameBytes;
LPCSTR m_strMarshalerTypeName;
DWORD m_cCookieStrBytes;
LPCSTR m_strCookie;
Instantiation m_Instantiation;
- BOOL m_bSharedHelper;
};
SetProfilerNotified();
#ifdef PROFILING_SUPPORTED
- if (GetCurrentModule() != NULL
- && !GetCurrentModule()->GetAssembly()->IsDomainNeutral())
+ if (GetCurrentModule() != NULL)
{
// Only send errors for non-shared assemblies; other assemblies might be successfully completed
// in another app domain later.
delete i.GetDomainFile();
}
- if (m_pAssembly != NULL && !m_pAssembly->IsDomainNeutral())
+ if (m_pAssembly != NULL)
{
delete m_pAssembly;
}
}
#endif // FEATURE_PREJIT
-// This is where the decision whether an assembly is DomainNeutral (shared) nor not is made.
void DomainAssembly::Allocate()
{
CONTRACTL
EnCAddedField *pEntry = new EnCAddedField;
pEntry->m_pFieldDesc = pFD;
- _ASSERTE(!pFD->GetApproxEnclosingMethodTable()->IsDomainNeutral());
AppDomain *pDomain = (AppDomain*) pFD->GetApproxEnclosingMethodTable()->GetDomain();
// We need to associate the contents of the new field with the object it is attached to
}
CONTRACTL_END;
- _ASSERTE(!pFD->GetEnclosingMethodTable()->IsDomainNeutral());
AppDomain *pDomain = (AppDomain*) pFD->GetApproxEnclosingMethodTable()->GetDomain();
// Compute the size of the fieldData entry
PCWSTR szDtraceOutput1=W("");
BOOL bIsDynamicAssembly = pAssembly->IsDynamic();
BOOL bIsCollectibleAssembly = pAssembly->IsCollectible();
- BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral() ;
BOOL bHasNativeImage = pAssembly->GetManifestFile()->HasNativeImage();
BOOL bIsReadyToRun = pAssembly->GetManifestFile()->IsILImageReadyToRun();
ULONGLONG ullAssemblyId = (ULONGLONG)pAssembly;
ULONGLONG ullDomainId = (ULONGLONG)pAssembly->GetDomain();
ULONGLONG ullBindingID = 0;
- ULONG ulAssemblyFlags = ((bIsDomainNeutral ? ETW::LoaderLog::LoaderStructs::DomainNeutralAssembly : 0) |
- (bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicAssembly : 0) |
+ ULONG ulAssemblyFlags = ((bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicAssembly : 0) |
(bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeAssembly : 0) |
(bIsCollectibleAssembly ? ETW::LoaderLog::LoaderStructs::CollectibleAssembly : 0) |
(bIsReadyToRun ? ETW::LoaderLog::LoaderStructs::ReadyToRunAssembly : 0));
ULONGLONG ullAppDomainId = 0; // This is used only with DomainModule events
ULONGLONG ullModuleId = (ULONGLONG)(TADDR) pModule;
ULONGLONG ullAssemblyId = (ULONGLONG)pModule->GetAssembly();
- BOOL bIsDomainNeutral = pModule->GetAssembly()->IsDomainNeutral();
BOOL bIsIbcOptimized = FALSE;
if(bHasNativeImage)
{
}
BOOL bIsReadyToRun = pModule->IsReadyToRun();
ULONG ulReservedFlags = 0;
- ULONG ulFlags = ((bIsDomainNeutral ? ETW::LoaderLog::LoaderStructs::DomainNeutralModule : 0) |
- (bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeModule : 0) |
+ ULONG ulFlags = ((bHasNativeImage ? ETW::LoaderLog::LoaderStructs::NativeModule : 0) |
(bIsDynamicAssembly ? ETW::LoaderLog::LoaderStructs::DynamicModule : 0) |
(bIsManifestModule ? ETW::LoaderLog::LoaderStructs::ManifestModule : 0) |
(bIsIbcOptimized ? ETW::LoaderLog::LoaderStructs::IbcOptimized : 0) |
while (assemblyIterator.Next(pDomainAssembly.This()))
{
CollectibleAssemblyHolder<Assembly *> pAssembly = pDomainAssembly->GetLoadedAssembly();
- BOOL bIsDomainNeutral = pAssembly->IsDomainNeutral();
- if (bIsDomainNeutral)
- continue;
if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart)
{
ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions);
while (!domainAssemblyIt.end())
{
Assembly *pAssembly = domainAssemblyIt->GetAssembly(); // TODO: handle iterator
- _ASSERTE(!pAssembly->IsDomainNeutral()); // Collectible Assemblies are not domain neutral.
DomainModuleIterator domainModuleIterator = domainAssemblyIt->IterateModules(kModIterIncludeLoaded);
while (domainModuleIterator.Next())
// Check we've set up the flags correctly on the new method table
_ASSERTE(!fContainsGenericVariables == !pMT->ContainsGenericVariables());
_ASSERTE(!fHasGenericsStaticsInfo == !pMT->HasGenericsStaticsInfo());
- _ASSERTE(!pLoaderModule->GetAssembly()->IsDomainNeutral() == !pMT->IsDomainNeutral());
#ifdef FEATURE_COMINTEROP
_ASSERTE(!fHasDynamicInterfaceMap == !pMT->HasDynamicInterfaceMap());
_ASSERTE(!fHasRCWPerTypeData == !pMT->HasRCWPerTypeData());
fieldAccessor = intrinsicAccessor;
}
else
- if (// Domain neutral access.
- m_pMethodBeingCompiled->IsDomainNeutral() || m_pMethodBeingCompiled->IsZapped() || IsCompilingForNGen() ||
+ if (m_pMethodBeingCompiled->IsZapped() || IsCompilingForNGen() ||
// Static fields are not pinned in collectible types. We will always access
// them using a helper since the address cannot be embeded into the code.
pFieldMT->Collectible() ||
MethodDesc *methodBeingCompiled = m_pMethodBeingCompiled;
- BOOL fMethodDomainNeutral = methodBeingCompiled->IsDomainNeutral() || methodBeingCompiled->IsZapped() || IsCompilingForNGen();
+ BOOL fMethodZappedOrNGen = methodBeingCompiled->IsZapped() || IsCompilingForNGen();
MethodTable *pTypeToInitMT = typeToInitTH.AsMethodTable();
// This should be the most common early-out case.
- if (fMethodDomainNeutral)
+ if (fMethodZappedOrNGen)
{
if (pTypeToInitMT->IsClassPreInited())
{
}
}
- if (fMethodDomainNeutral)
+ if (fMethodZappedOrNGen)
{
// Well, because of code sharing we can't do anything at coge generation time.
// We have to do it at runtime.
else
{
OBJECTREF* pRef = GetDomain()->AllocateObjRefPtrsInLargeTable(1);
- SetObjectReference(pRef, gc.value, IsDomainNeutral() ? NULL : GetDomain()->AsAppDomain());
+ SetObjectReference(pRef, gc.value, GetDomain()->AsAppDomain());
retVal = (((UINT_PTR)pRef) + 1);
}
gc.previous = *ptr;
if ((*ptr) == gc.compare)
{
- SetObjectReference(ptr, gc.value, IsDomainNeutral() ? NULL : GetDomain()->AsAppDomain());
+ SetObjectReference(ptr, gc.value, GetDomain()->AsAppDomain());
}
}
else
if ((((UINT_PTR)handle) & 1) != 0)
{
OBJECTREF *ptr = (OBJECTREF *)(((UINT_PTR)handle) - 1);
- SetObjectReference(ptr, value, IsDomainNeutral() ? NULL : GetDomain()->AsAppDomain());
+ SetObjectReference(ptr, value, GetDomain()->AsAppDomain());
}
else
{
virtual ~LoaderAllocator();
BaseDomain *GetDomain() { LIMITED_METHOD_CONTRACT; return m_pDomain; }
virtual BOOL CanUnload() = 0;
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
void Init(BaseDomain *pDomain, BYTE *pExecutableHeapMemory = NULL);
void Terminate();
virtual void ReleaseManagedAssemblyLoadContext() {}
// and the loader allocator in the current domain for non-collectable types
LoaderAllocator * GetDomainSpecificLoaderAllocator();
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
-
Module* GetLoaderModule();
Module* GetZapModule();
EnsureWritablePages(pWriteableData, sizeof(MethodTableWriteableData) + sizeof(CrossModuleGenericsStaticsInfo));
- if (IsDomainNeutral())
- {
- // If we are domain neutral, we have to use constituent of the instantiation to store
- // statics. We need to ensure that we can create DomainModule in all domains
- // that this instantiations may get activated in. PZM is good approximation of such constituent.
- Module * pModuleForStatics = Module::GetPreferredZapModuleForMethodTable(this);
-
- pInfo->m_pModuleForStatics = pModuleForStatics;
- pInfo->m_DynamicTypeID = pModuleForStatics->AllocateDynamicEntry(this);
- }
- else
- {
- pInfo->m_pModuleForStatics = GetLoaderModule();
- }
+ pInfo->m_pModuleForStatics = GetLoaderModule();
}
LOG((LF_ZAP, LL_INFO10000,
PTR_DomainLocalModule GetDomainLocalModule();
#endif
- // Return whether the type lives in the shared domain.
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
-
MethodTable *LoadEnclosingMethodTable(ClassLoadLevel targetLevel = CLASS_DEPENDENCIES_LOADED);
LPCWSTR GetPathForErrorMessages();
EEMarshalingData *pMarshalingData = NULL;
- // Retrieve the marshalling data for the current app domain.
- if (pAssembly->IsDomainNeutral())
- {
- // If the assembly is shared, then it should only reference other domain neutral assemblies.
- // This assumption MUST be true for the current custom marshaling scheme to work.
- // This implies that the type of the managed parameter must be a shared type.
- _ASSERTE(hndManagedType.GetAssembly()->IsDomainNeutral());
-
- // The assembly is shared so we need to use the system domain's marshaling data.
- pMarshalingData = SystemDomain::System()->GetMarshalingData();
- }
- else
- {
- // The assembly is not shared so we use the current app domain's marshaling data.
- pMarshalingData = GetThread()->GetDomain()->GetMarshalingData();
- }
+ // The assembly is not shared so we use the current app domain's marshaling data.
+ pMarshalingData = GetThread()->GetDomain()->GetMarshalingData();
// Retrieve the custom marshaler helper from the EE marshaling data.
RETURN pMarshalingData->GetCustomMarshalerHelper(pAssembly, hndManagedType, strMarshalerTypeName, cMarshalerTypeNameBytes, strCookie, cCookieStrBytes);
CustomMarshalerHelper* pNewCMHelper = NULL;
NewHolder<CustomMarshalerInfo> pNewCMInfo(NULL);
- BOOL bSharedHelper = pAssembly->IsDomainNeutral();
TypeHandle hndCustomMarshalerType;
// Create the key that will be used to lookup in the hashtable.
- EECMHelperHashtableKey Key(cMarshalerTypeNameBytes, strMarshalerTypeName, cCookieStrBytes, strCookie, hndManagedType.GetInstantiation(), bSharedHelper);
+ EECMHelperHashtableKey Key(cMarshalerTypeNameBytes, strMarshalerTypeName, cCookieStrBytes, strCookie, hndManagedType.GetInstantiation());
// Lookup the custom marshaler helper in the hashtable.
if (m_CMHelperHashtable.GetValue(&Key, (HashDatum*)&pCMHelper))
pAssembly = NULL;
- if (bSharedHelper)
- {
- // Create the custom marshaler helper in the specified heap.
- pNewCMHelper = new (m_pHeap) SharedCustomMarshalerHelper(pAssembly, hndManagedType, strMarshalerTypeName, cMarshalerTypeNameBytes, strCookie, cCookieStrBytes);
- }
- else
- {
- // Create the custom marshaler info in the specified heap.
- pNewCMInfo = new (m_pHeap) CustomMarshalerInfo(m_pDomain, hndCustomMarshalerType, hndManagedType, strCookie, cCookieStrBytes);
+ // Create the custom marshaler info in the specified heap.
+ pNewCMInfo = new (m_pHeap) CustomMarshalerInfo(m_pDomain, hndCustomMarshalerType, hndManagedType, strCookie, cCookieStrBytes);
- // Create the custom marshaler helper in the specified heap.
- pNewCMHelper = new (m_pHeap) NonSharedCustomMarshalerHelper(pNewCMInfo);
- }
+ // Create the custom marshaler helper in the specified heap.
+ pNewCMHelper = new (m_pHeap) NonSharedCustomMarshalerHelper(pNewCMInfo);
}
// Take the app domain lock before we insert the custom marshaler info into the hashtable.
CONTRACTL_END;
#ifndef _DEBUG
- if (!GetMethodTable()->IsDomainNeutral())
- {
- //
- // If we have a per-app-domain method table, we can
- // infer the app domain from the method table, so
- // there is no reason to mark the object.
- //
- // But we don't do this in a debug build, because
- // we want to be able to detect the case when the
- // domain was unloaded from underneath an object (and
- // the MethodTable will be toast in that case.)
- //
-
- _ASSERTE(pDomain == GetMethodTable()->GetDomain());
- }
- else
+ //
+ // If we have a per-app-domain method table, we can
+ // infer the app domain from the method table, so
+ // there is no reason to mark the object.
+ //
+ // But we don't do this in a debug build, because
+ // we want to be able to detect the case when the
+ // domain was unloaded from underneath an object (and
+ // the MethodTable will be toast in that case.)
+ //
+ _ASSERTE(pDomain == GetMethodTable()->GetDomain());
+#else
+ ADIndex index = pDomain->GetIndex();
+ GetHeader()->SetAppDomainIndex(index);
#endif
- {
- ADIndex index = pDomain->GetIndex();
- GetHeader()->SetAppDomainIndex(index);
- }
_ASSERTE(GetHeader()->GetAppDomainIndex().m_dwIndex != 0);
}
}
CONTRACTL_END;
#ifndef _DEBUG
- if (!GetMethodTable()->IsDomainNeutral())
- return (AppDomain*) GetMethodTable()->GetDomain();
+ return (AppDomain*) GetMethodTable()->GetDomain();
#endif
ADIndex index = GetHeader()->GetAppDomainIndex();
WRAPPER_NO_CONTRACT;
#ifndef _DEBUG
// ok to cast to AppDomain because we know it's a real AppDomain if it's not shared
- if (!GetGCSafeMethodTable()->IsDomainNeutral())
- return (dac_cast<PTR_AppDomain>(GetGCSafeMethodTable()->GetDomain())->GetIndex());
+ return (dac_cast<PTR_AppDomain>(GetGCSafeMethodTable()->GetDomain())->GetIndex());
#endif
- return GetHeader()->GetAppDomainIndex();
+ return GetHeader()->GetAppDomainIndex();
}
inline DWORD Object::GetNumComponents()
_ASSERTE(pDomainAssembly != NULL);
_ASSERTE(pDomainAssembly->GetAssembly() != NULL);
- // We're only adding unshared assemblies / modules
- if (pDomainAssembly->GetAssembly()->IsDomainNeutral())
- {
- continue;
- }
-
// #ProfilerEnumModules (See also code:#ProfilerEnumGeneral)
//
// When enumerating modules, ensure this timeline:
if (!pMD->IsStatic() && !pMD->HasMethodInstantiation() && !pMD->IsInterface())
return FALSE;
- // We need to activate each time for domain neutral types
- if (pMD->IsDomainNeutral())
- return TRUE;
-
// We need to activate the instance at least once
pMD->EnsureActive();
return FALSE;
//but thread ID doesn't have to be valid because the lock could be orphanend
ASSERT_AND_CHECK (lockThreadId != 0 || recursionLevel == 0 );
+#ifndef _DEBUG
DWORD adIndex = (bits >> SBLK_APPDOMAIN_SHIFT) & SBLK_MASK_APPDOMAININDEX;
- if (adIndex!= 0)
- {
-#ifndef _DEBUG
- //in non debug build, only objects of domain neutral type have appdomain index in header
- ASSERT_AND_CHECK (obj->GetGCSafeMethodTable()->IsDomainNeutral());
+ //in non debug build, objects do not have appdomain index in header
+ ASSERT_AND_CHECK (adIndex == 0);
#endif //!_DEBUG
- //todo: validate the AD index.
- //The trick here is agile objects could have a invalid AD index. Ideally we should call
- //Object::GetAppDomain to do all the agile validation but it has side effects like mark the object to
- //be agile and it only does the check if g_pConfig->AppDomainLeaks() is on
- }
}
return TRUE;
m_State = (ThreadState) (m_State | TS_GCOnTransitions);
}
- //m_pSharedStaticData = NULL;
- //m_pUnsharedStaticData = NULL;
- //m_pStaticDataHash = NULL;
- //m_pSDHCrst = NULL;
-
- m_fSecurityStackwalk = FALSE;
-
m_AbortType = EEPolicy::TA_None;
m_AbortInfo = 0;
m_AbortEndTime = MAXULONGLONG;
// ClearContext are to be called only during shutdown
void ClearContext();
- // Used by security to prevent recursive stackwalking.
- BOOL IsSecurityStackwalkInProgess()
- {
- LIMITED_METHOD_CONTRACT;
- return m_fSecurityStackwalk;
- }
-
- void SetSecurityStackwalkInProgress(BOOL fSecurityStackwalk)
- {
- LIMITED_METHOD_CONTRACT;
- m_fSecurityStackwalk = fSecurityStackwalk;
- }
-
private:
void ReturnToContextAndThrow(ContextTransitionFrame* pFrame, EEException* pEx, BOOL* pContextSwitched);
void ReturnToContextAndOOM(ContextTransitionFrame* pFrame);
// don't ever call these except when creating thread!!!!!
void InitContext();
- BOOL m_fSecurityStackwalk;
-
public:
PTR_AppDomain GetDomain(INDEBUG(BOOL fMidContextTransitionOK = FALSE))
{
Frame *IsRunningIn(AppDomain* pDomain, int *count);
Frame *GetFirstTransitionInto(AppDomain *pDomain, int *count);
- // Get outermost (oldest) AppDomain for this thread.
- AppDomain *GetInitialDomain();
-
//---------------------------------------------------------------
// Track use of the thread block. See the general comments on
// thread destruction in threads.cpp, for details.
// i.e. are domain-bound. If any of the parts are domain-bound
// then they will all belong to the same domain.
PTR_BaseDomain GetDomain();
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
PTR_LoaderAllocator GetLoaderAllocator()
{
PTR_LoaderAllocator GetLoaderAllocator() const;
- BOOL IsDomainNeutral() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; }
-
// Get the class token, assuming the type handle represents a named type,
// i.e. a class, a value type, a generic instantiation etc.
inline mdTypeDef GetCl() const;
{
spec.SetHostBinder(pPrivHostBinder);
}
- else if (pRequestingAssembly && (!pRequestingAssembly->IsDomainNeutral()) && (!pRequestingAssembly->IsCollectible()))
+ else if (pRequestingAssembly && (!pRequestingAssembly->IsCollectible()))
{
GCX_PREEMP();
spec.SetParentAssembly(pRequestingAssembly->GetDomainAssembly());
projects / platform / upstream / coreclr.git / commitdiff