diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs index 3e8bd014fb0aa3..e146d3a5853d42 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/AssemblyBuilder.cs @@ -1,29 +1,13 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -// For each dynamic assembly there will be two AssemblyBuilder objects: the "internal" -// AssemblyBuilder object and the "external" AssemblyBuilder object. -// 1. The "internal" object is the real assembly object that the VM creates and knows about. However, -// you can perform RefEmit operations on it only if you have its granted permission. From the AppDomain -// and other "internal" objects like the "internal" ModuleBuilders and runtime types, you can only -// get the "internal" objects. This is to prevent low-trust code from getting a hold of the dynamic -// AssemblyBuilder/ModuleBuilder/TypeBuilder/MethodBuilder/etc other people have created by simply -// enumerating the AppDomain and inject code in it. -// 2. The "external" object is merely an wrapper of the "internal" object and all operations on it -// are directed to the internal object. This is the one you get by calling DefineDynamicAssembly -// on AppDomain and the one you can always perform RefEmit operations on. You can get other "external" -// objects from the "external" AssemblyBuilder, ModuleBuilder, TypeBuilder, MethodBuilder, etc. Note -// that VM doesn't know about this object. So every time we call into the VM we need to pass in the -// "internal" object. -// -// "internal" and "external" ModuleBuilders are similar - using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Diagnostics.SymbolStore; using System.Globalization; using System.IO; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Loader; @@ -75,7 +59,7 @@ internal ModuleBuilder GetModuleBuilder(RuntimeModule module) internal AssemblyBuilder(AssemblyName name, AssemblyBuilderAccess access, - ref StackCrawlMark stackMark, + Assembly? callingAssembly, AssemblyLoadContext? assemblyLoadContext, IEnumerable? unsafeAssemblyAttributes) { @@ -87,6 +71,16 @@ internal AssemblyBuilder(AssemblyName name, { throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)access), nameof(access)); } + if (callingAssembly == null) + { + // Called either from interop or async delegate invocation. Rejecting because we don't + // know how to set the correct context of the new dynamic assembly. + throw new InvalidOperationException(); + } + if (assemblyLoadContext == null) + { + assemblyLoadContext = AssemblyLoadContext.GetLoadContext(callingAssembly); + } // Clone the name in case the caller modifies it underneath us. name = (AssemblyName)name.Clone(); @@ -104,7 +98,6 @@ internal AssemblyBuilder(AssemblyName name, RuntimeAssembly? retAssembly = null; CreateDynamicAssembly(ObjectHandleOnStack.Create(ref name), - new StackCrawlMarkHandle(ref stackMark), (int)access, ObjectHandleOnStack.Create(ref assemblyLoadContext), ObjectHandleOnStack.Create(ref retAssembly)); @@ -150,39 +143,31 @@ private void InitManifestModule() #region DefineDynamicAssembly - /// - /// If an AssemblyName has a public key specified, the assembly is assumed - /// to have a strong name and a hash will be computed when the assembly - /// is saved. - /// - [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod. + [DynamicSecurityMethod] // Required to make Assembly.GetCallingAssembly reliable. public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access) { - StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; return InternalDefineDynamicAssembly(name, access, - ref stackMark, + Assembly.GetCallingAssembly(), AssemblyLoadContext.CurrentContextualReflectionContext, null); } - [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod. + [DynamicSecurityMethod] // Required to make Assembly.GetCallingAssembly reliable. public static AssemblyBuilder DefineDynamicAssembly( AssemblyName name, AssemblyBuilderAccess access, IEnumerable? assemblyAttributes) { - StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; return InternalDefineDynamicAssembly(name, access, - ref stackMark, + Assembly.GetCallingAssembly(), AssemblyLoadContext.CurrentContextualReflectionContext, assemblyAttributes); } [GeneratedDllImport(RuntimeHelpers.QCall, EntryPoint = "AppDomain_CreateDynamicAssembly")] private static partial void CreateDynamicAssembly(ObjectHandleOnStack name, - StackCrawlMarkHandle stackMark, int access, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly); @@ -192,7 +177,7 @@ private static partial void CreateDynamicAssembly(ObjectHandleOnStack name, internal static AssemblyBuilder InternalDefineDynamicAssembly( AssemblyName name, AssemblyBuilderAccess access, - ref StackCrawlMark stackMark, + Assembly? callingAssembly, AssemblyLoadContext? assemblyLoadContext, IEnumerable? unsafeAssemblyAttributes) { @@ -201,7 +186,7 @@ internal static AssemblyBuilder InternalDefineDynamicAssembly( // We can only create dynamic assemblies in the current domain return new AssemblyBuilder(name, access, - ref stackMark, + callingAssembly, assemblyLoadContext, unsafeAssemblyAttributes); } @@ -215,7 +200,6 @@ internal static AssemblyBuilder InternalDefineDynamicAssembly( /// modules within an Assembly with the same name. This dynamic module is /// a transient module. /// - [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod. public ModuleBuilder DefineDynamicModule(string name) { lock (SyncRoot) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs index c98d78da4c84bf..b971f07e8f9811 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs @@ -5,6 +5,7 @@ using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Runtime.CompilerServices; +using System.Runtime.Loader; using System.Text; using System.Threading; @@ -234,12 +235,11 @@ private static RuntimeModule GetDynamicMethodsModule() return s_anonymouslyHostedDynamicMethodsModule; AssemblyName assemblyName = new AssemblyName("Anonymously Hosted DynamicMethods Assembly"); - StackCrawlMark stackMark = StackCrawlMark.LookForMe; AssemblyBuilder assembly = AssemblyBuilder.InternalDefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run, - ref stackMark, + typeof(object).Assembly, null, null); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index 7eed453959c668..11a0aa3afa1a71 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -88,12 +88,22 @@ public override string? CodeBase { get { - var codeBase = GetCodeBase(); + if (IsDynamic) + { + throw new NotSupportedException(SR.NotSupported_DynamicAssembly); + } + + string? codeBase = GetCodeBase(); if (codeBase is null) { - // Not supported if the assembly was loaded from memory + // Not supported if the assembly was loaded from single-file bundle. throw new NotSupportedException(SR.NotSupported_CodeBase); } + if (codeBase.Length == 0) + { + // For backward compatibility, return CoreLib codebase for assemblies loaded from memory. + codeBase = typeof(object).Assembly.CodeBase; + } return codeBase; } } diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index cafda33dd69e0c..49374e80767e6b 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -16,7 +16,7 @@ using namespace clr::fs; // static -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyName, QCall::StackCrawlMarkHandle stackMark, INT32 access, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyName, INT32 access, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly) { QCALL_CONTRACT; @@ -36,16 +36,14 @@ extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnS args.loaderAllocator = NULL; args.access = access; - args.stackMark = stackMark; Assembly* pAssembly = nullptr; AssemblyBinder* pBinder = nullptr; - if (assemblyLoadContext.Get() != NULL) - { - INT_PTR nativeAssemblyBinder = ((ASSEMBLYLOADCONTEXTREF)assemblyLoadContext.Get())->GetNativeAssemblyBinder(); - pBinder = reinterpret_cast(nativeAssemblyBinder); - } + _ASSERTE(assemblyLoadContext.Get() != NULL); + + INT_PTR nativeAssemblyBinder = ((ASSEMBLYLOADCONTEXTREF)assemblyLoadContext.Get())->GetNativeAssemblyBinder(); + pBinder = reinterpret_cast(nativeAssemblyBinder); pAssembly = Assembly::CreateDynamic(GetAppDomain(), pBinder, &args); diff --git a/src/coreclr/vm/appdomainnative.hpp b/src/coreclr/vm/appdomainnative.hpp index 4e3b114be30b1e..8bc9f753a63387 100644 --- a/src/coreclr/vm/appdomainnative.hpp +++ b/src/coreclr/vm/appdomainnative.hpp @@ -23,6 +23,6 @@ class AppDomainNative static FCDECL1(Object*, GetOrInternString, StringObject* pStringUNSAFE); static FCDECL1(Object*, IsStringInterned, StringObject* pString); }; -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyName, QCall::StackCrawlMarkHandle stackMark, INT32 access, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyName, INT32 access, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly); #endif diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp index 83840af5b51387..70dc1da724298e 100644 --- a/src/coreclr/vm/assembly.cpp +++ b/src/coreclr/vm/assembly.cpp @@ -393,15 +393,6 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C Assembly *pRetVal = NULL; - MethodDesc *pmdEmitter = SystemDomain::GetCallersMethod(args->stackMark); - - // Called either from interop or async delegate invocation. Rejecting because we don't - // know how to set the correct permission on the new dynamic assembly. - if (!pmdEmitter) - COMPlusThrow(kInvalidOperationException); - - Assembly *pCallerAssembly = pmdEmitter->GetAssembly(); - // First, we set up a pseudo-manifest file for the assembly. // Set up the assembly name @@ -510,48 +501,10 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C IfFailThrow(pAssemblyEmit->DefineAssembly(publicKey, publicKey.GetSize(), ulHashAlgId, name, &assemData, dwFlags, &ma)); - pPEAssembly = PEAssembly::Create(pCallerAssembly->GetPEAssembly(), pAssemblyEmit); - - AssemblyBinder* pFallbackBinder = pBinder; - - // If ALC is not specified - if (pFallbackBinder == nullptr) - { - // Dynamically created modules (aka RefEmit assemblies) do not have a LoadContext associated with them since they are not bound - // using an actual binder. As a result, we will assume the same binding/loadcontext information for the dynamic assembly as its - // caller/creator to ensure that any assembly loads triggered by the dynamic assembly are resolved using the intended load context. - // - // If the creator assembly has a HostAssembly associated with it, then use it for binding. Otherwise, the creator is dynamic - // and will have a fallback load context binder associated with it. - - // There is always a manifest file - wehther working with static or dynamic assemblies. - PEAssembly* pCallerAssemblyManifestFile = pCallerAssembly->GetPEAssembly(); - _ASSERTE(pCallerAssemblyManifestFile != NULL); - - if (!pCallerAssemblyManifestFile->IsDynamic()) - { - // Static assemblies with do not have fallback load context - _ASSERTE(pCallerAssemblyManifestFile->GetFallbackBinder() == nullptr); - - // Fetch the binder from the host assembly - PTR_BINDER_SPACE_Assembly pCallerAssemblyHostAssembly = pCallerAssemblyManifestFile->GetHostAssembly(); - _ASSERTE(pCallerAssemblyHostAssembly != nullptr); - - pFallbackBinder = pCallerAssemblyHostAssembly->GetBinder(); - } - else - { - // Creator assembly is dynamic too, so use its fallback load context for the one - // we are creating. - pFallbackBinder = pCallerAssemblyManifestFile->GetFallbackBinder(); - } - } - - // At this point, we should have a fallback load context binder to work with - _ASSERTE(pFallbackBinder != nullptr); + pPEAssembly = PEAssembly::Create(pAssemblyEmit); // Set it as the fallback load context binder for the dynamic assembly being created - pPEAssembly->SetFallbackBinder(pFallbackBinder); + pPEAssembly->SetFallbackBinder(pBinder); } NewHolder pDomainAssembly; @@ -620,8 +573,6 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, AssemblyBinder* pBinder, C pAssem = Assembly::Create(pDomain, pPEAssembly, pDomainAssembly->GetDebuggerInfoBits(), pLoaderAllocator->IsCollectible(), pamTracker, pLoaderAllocator); ReflectionModule* pModule = (ReflectionModule*) pAssem->GetModule(); - pModule->SetCreatingAssembly( pCallerAssembly ); - if (createdNewAssemblyLoaderAllocator) { diff --git a/src/coreclr/vm/assembly.hpp b/src/coreclr/vm/assembly.hpp index 8c72128f3e4f6c..9da7d368b52021 100644 --- a/src/coreclr/vm/assembly.hpp +++ b/src/coreclr/vm/assembly.hpp @@ -53,7 +53,6 @@ struct CreateDynamicAssemblyArgsGC struct CreateDynamicAssemblyArgs : CreateDynamicAssemblyArgsGC { INT32 access; - StackCrawlMark* stackMark; }; // An assembly is the unit of deployment for managed code. diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index dba5110590717c..b2663d4b310cba 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -142,7 +142,6 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma // Set the caller's assembly to be CoreLib DomainAssembly *pCallersAssembly = SystemDomain::System()->SystemAssembly()->GetDomainAssembly(); - PEAssembly *pParentAssembly = pCallersAssembly->GetPEAssembly(); // Initialize the AssemblySpec AssemblySpec spec; @@ -168,7 +167,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma COMPlusThrowHR(COR_E_FILELOAD, dwMessageID, name); } - PEAssemblyHolder pPEAssembly(PEAssembly::Open(pParentAssembly, pAssembly->GetPEImage(), pAssembly)); + PEAssemblyHolder pPEAssembly(PEAssembly::Open(pAssembly->GetPEImage(), pAssembly)); bindOperation.SetResult(pPEAssembly.GetValue()); DomainAssembly *pDomainAssembly = pCurDomain->LoadDomainAssembly(&spec, pPEAssembly, FILE_LOADED); diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp index 5344eb22dc9144..3349107bdf5ca6 100644 --- a/src/coreclr/vm/ceeload.cpp +++ b/src/coreclr/vm/ceeload.cpp @@ -6925,7 +6925,6 @@ ReflectionModule::ReflectionModule(Assembly *pAssembly, mdFile token, PEAssembly m_pInMemoryWriter = NULL; m_sdataSection = NULL; - m_pCreatingAssembly = NULL; m_pCeeFileGen = NULL; m_pDynamicMetadata = NULL; } diff --git a/src/coreclr/vm/ceeload.h b/src/coreclr/vm/ceeload.h index a97be226fb9fba..9c2adf378c866f 100644 --- a/src/coreclr/vm/ceeload.h +++ b/src/coreclr/vm/ceeload.h @@ -2174,7 +2174,6 @@ class ReflectionModule : public Module protected: ICeeGenInternal * m_pCeeFileGen; private: - Assembly *m_pCreatingAssembly; RefClassWriter *m_pInMemoryWriter; @@ -2211,20 +2210,6 @@ class ReflectionModule : public Module virtual TADDR GetIL(RVA target); virtual PTR_VOID GetRvaField(RVA rva); - Assembly* GetCreatingAssembly( void ) - { - LIMITED_METHOD_CONTRACT; - - return m_pCreatingAssembly; - } - - void SetCreatingAssembly( Assembly* assembly ) - { - LIMITED_METHOD_CONTRACT; - - m_pCreatingAssembly = assembly; - } - ICeeGenInternal *GetCeeGen() {LIMITED_METHOD_CONTRACT; return m_pCeeFileGen; } RefClassWriter *GetClassWriter() diff --git a/src/coreclr/vm/peassembly.cpp b/src/coreclr/vm/peassembly.cpp index 7926fa8b85bf8c..95ceb1564a19b1 100644 --- a/src/coreclr/vm/peassembly.cpp +++ b/src/coreclr/vm/peassembly.cpp @@ -658,7 +658,6 @@ ULONG PEAssembly::GetPEImageTimeDateStamp() PEAssembly::PEAssembly( BINDER_SPACE::Assembly* pBindResultInfo, IMetaDataEmit* pEmit, - PEAssembly *creator, BOOL isSystem, PEImage * pPEImage /*= NULL*/, BINDER_SPACE::Assembly * pHostAssembly /*= NULL*/) @@ -667,13 +666,11 @@ PEAssembly::PEAssembly( { CONSTRUCTOR_CHECK; PRECONDITION(CheckPointer(pEmit, NULL_OK)); - PRECONDITION(CheckPointer(creator, NULL_OK)); PRECONDITION(pBindResultInfo == NULL || pPEImage == NULL); STANDARD_VM_CHECK; } CONTRACTL_END; - m_creator = clr::SafeAddRef(creator); #if _DEBUG m_pDebugName = NULL; #endif @@ -747,7 +744,6 @@ PEAssembly::PEAssembly( PEAssembly *PEAssembly::Open( - PEAssembly * pParent, PEImage * pPEImageIL, BINDER_SPACE::Assembly * pHostAssembly) { @@ -756,7 +752,6 @@ PEAssembly *PEAssembly::Open( PEAssembly * pPEAssembly = new PEAssembly( nullptr, // BindResult nullptr, // IMetaDataEmit - pParent, // PEAssembly creator FALSE, // isSystem pPEImageIL, pHostAssembly); @@ -777,8 +772,6 @@ PEAssembly::~PEAssembly() CONTRACTL_END; GCX_PREEMP(); - if (m_creator != NULL) - m_creator->Release(); if (m_pImporter != NULL) { @@ -844,21 +837,19 @@ PEAssembly *PEAssembly::DoOpenSystem() ReleaseHolder pBoundAssembly; IfFailThrow(GetAppDomain()->GetDefaultBinder()->BindToSystem(&pBoundAssembly)); - RETURN new PEAssembly(pBoundAssembly, NULL, NULL, TRUE); + RETURN new PEAssembly(pBoundAssembly, NULL, TRUE); } PEAssembly* PEAssembly::Open(BINDER_SPACE::Assembly* pBindResult) { - return new PEAssembly(pBindResult,NULL,NULL, /*isSystem*/ false); + return new PEAssembly(pBindResult,NULL,/*isSystem*/ false); }; /* static */ -PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly, - IMetaDataAssemblyEmit *pAssemblyEmit) +PEAssembly *PEAssembly::Create(IMetaDataAssemblyEmit *pAssemblyEmit) { CONTRACT(PEAssembly *) { - PRECONDITION(CheckPointer(pParentAssembly)); PRECONDITION(CheckPointer(pAssemblyEmit)); STANDARD_VM_CHECK; POSTCONDITION(CheckPointer(RETVAL)); @@ -869,7 +860,7 @@ PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly, // we have.) SafeComHolder pEmit; pAssemblyEmit->QueryInterface(IID_IMetaDataEmit, (void **)&pEmit); - RETURN new PEAssembly(NULL, pEmit, pParentAssembly, FALSE); + RETURN new PEAssembly(NULL, pEmit, FALSE); } #endif // #ifndef DACCESS_COMPILE @@ -877,41 +868,7 @@ PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly, #ifndef DACCESS_COMPILE -// ------------------------------------------------------------ -// Descriptive strings -// ------------------------------------------------------------ - -// Effective path is the path of nearest parent (creator) assembly which has a nonempty path. - -const SString &PEAssembly::GetEffectivePath() -{ - CONTRACTL - { - INSTANCE_CHECK; - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - } - CONTRACTL_END; - - PEAssembly* pPEAssembly = this; - - while (pPEAssembly->m_PEImage == NULL - || pPEAssembly->m_PEImage->GetPath().IsEmpty()) - { - if (pPEAssembly->m_creator) - pPEAssembly = pPEAssembly->m_creator; - else // Unmanaged exe which loads byte[]/IStream assemblies - return SString::Empty(); - } - - return pPEAssembly->m_PEImage->GetPath(); -} - - -// Codebase is the fusion codebase or path for the assembly. It is in URL format. -// Note this may be obtained from the parent PEAssembly if we don't have a path or fusion -// assembly. +// Supports implementation of the legacy Assembly.CodeBase property. // Returns false if the assembly was loaded from a bundle, true otherwise BOOL PEAssembly::GetCodeBase(SString &result) { @@ -926,10 +883,10 @@ BOOL PEAssembly::GetCodeBase(SString &result) CONTRACTL_END; PEImage* ilImage = GetPEImage(); - if (ilImage == NULL || !ilImage->IsInBundle()) + if (ilImage != NULL && !ilImage->IsInBundle()) { // All other cases use the file path. - result.Set(GetEffectivePath()); + result.Set(ilImage->GetPath()); if (!result.IsEmpty()) PathToUrl(result); @@ -1092,11 +1049,6 @@ void PEAssembly::EnumMemoryRegions(CLRDataEnumMemoryFlags flags) { m_PEImage->EnumMemoryRegions(flags); } - - if (m_creator.IsValid()) - { - m_creator->EnumMemoryRegions(flags); - } } #endif // #ifdef DACCESS_COMPILE diff --git a/src/coreclr/vm/peassembly.h b/src/coreclr/vm/peassembly.h index a051343f2e1fd9..b63709bb7aa548 100644 --- a/src/coreclr/vm/peassembly.h +++ b/src/coreclr/vm/peassembly.h @@ -124,10 +124,6 @@ class PEAssembly final LPCWSTR GetPathForErrorMessages(); - // This returns a non-empty path representing the source of the assembly; it may - // be the parent assembly for dynamic or memory assemblies - const SString& GetEffectivePath(); - // Codebase is the fusion codebase or path for the assembly. It is in URL format. // Note this may be obtained from the parent PEAssembly if we don't have a path or fusion // assembly. @@ -339,9 +335,7 @@ class PEAssembly final // Creation entry points // ------------------------------------------------------------ - // CoreCLR's PrivBinder PEAssembly creation entrypoint static PEAssembly* Open( - PEAssembly* pParent, PEImage* pPEImageIL, BINDER_SPACE::Assembly* pHostAssembly); @@ -350,9 +344,7 @@ class PEAssembly final static PEAssembly* Open(BINDER_SPACE::Assembly* pBindResult); - static PEAssembly* Create( - PEAssembly* pParentAssembly, - IMetaDataAssemblyEmit* pEmit); + static PEAssembly* Create(IMetaDataAssemblyEmit* pEmit); // ------------------------------------------------------------ // Utility functions @@ -382,7 +374,6 @@ class PEAssembly final PEAssembly( BINDER_SPACE::Assembly* pBindResultInfo, IMetaDataEmit* pEmit, - PEAssembly* creator, BOOL isSystem, PEImage* pPEImageIL = NULL, BINDER_SPACE::Assembly* pHostAssembly = NULL @@ -409,7 +400,6 @@ class PEAssembly final // IL image, NULL if dynamic PTR_PEImage m_PEImage; - PTR_PEAssembly m_creator; // This flag is not updated atomically with m_pMDImport. Its fine for debugger usage // but don't rely on it in the runtime. In runtime try QI'ing the m_pMDImport for // IID_IMDInternalImportENC diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs index 5594d4fdef7f22..b266f9e5c4d078 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/AssemblyName.cs @@ -165,11 +165,11 @@ public object Clone() private static Func? s_getAssemblyName; private static Func InitGetAssemblyName() { - Type? readerType = Type.GetType( + Type readerType = Type.GetType( "System.Reflection.Metadata.MetadataReader, System.Reflection.Metadata", - throwOnError: true); + throwOnError: true)!; - MethodInfo? getAssemblyNameMethod = readerType!.GetMethod( + MethodInfo? getAssemblyNameMethod = readerType.GetMethod( "GetAssemblyName", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null,