public static int ModuleNameHashCode(ModuleDesc module)
{
IAssemblyDesc assembly = module.Assembly;
Debug.Assert(assembly == module);
return(NameHashCode(assembly.GetName().Name));
}
public AssemblyReferenceHandle GetAssemblyRef(IAssemblyDesc assemblyDesc)
{
if (_assemblyRefs.TryGetValue(assemblyDesc, out var handle))
{
return(handle);
}
AssemblyName name = assemblyDesc.GetName();
StringHandle assemblyName = _metadataBuilder.GetOrAddString(name.Name);
StringHandle cultureName = (name.CultureName != null) ? _metadataBuilder.GetOrAddString(name.CultureName) : default(StringHandle);
BlobHandle publicTokenBlob = name.GetPublicKeyToken() != null?_metadataBuilder.GetOrAddBlob(name.GetPublicKeyToken()) : default(BlobHandle);
AssemblyFlags flags = default(AssemblyFlags);
if (name.Flags.HasFlag(AssemblyNameFlags.Retargetable))
{
flags |= AssemblyFlags.Retargetable;
}
if (name.ContentType == AssemblyContentType.WindowsRuntime)
{
flags |= AssemblyFlags.WindowsRuntime;
}
var referenceHandle = _metadataBuilder.AddAssemblyReference(assemblyName, name.Version, cultureName, publicTokenBlob, flags, default(BlobHandle));
_assemblyRefs.Add(assemblyDesc, referenceHandle);
return(referenceHandle);
}
internal virtual ModuleDesc ResolveModule(IAssemblyDesc referencingModule, string fileName, bool throwIfNotFound = true)
{
if (throwIfNotFound)
{
throw new NotSupportedException();
}
return(null);
}
// Takes a documentation signature (not including the documentation member type prefix) and resolves it to a type
// in the assembly.
public static TypeDesc GetTypeByDocumentationSignature(IAssemblyDesc assembly, string signature)
{
int index = 0;
var results = new List <TypeSystemEntity>();
DocumentationSignatureParser.ParseSignaturePart(signature, ref index, (ModuleDesc)assembly, DocumentationSignatureParser.MemberType.Type, results);
Debug.Assert(results.Count <= 1);
return(results.Count == 0 ? null : (TypeDesc)results[0]);
}
private void AppendAssemblyName(StringBuilder sb, IAssemblyDesc assembly)
{
if (assembly == null)
{
return;
}
sb.Append(',');
AppendEscapedIdentifier(sb, assembly.GetName().Name);
}
public AssemblyGetExecutingAssemblyMethodThunk(TypeDesc owningType, IAssemblyDesc executingAssembly)
{
OwningType = owningType;
ExecutingAssembly = executingAssembly;
TypeSystemContext context = owningType.Context;
Signature = new MethodSignature(MethodSignatureFlags.Static, 0,
context.SystemModule.GetKnownType("System.Reflection", "Assembly"), TypeDesc.EmptyTypes);
}
public AssemblyReferenceHandle GetAssemblyRef(IAssemblyDesc assemblyDesc)
{
if (_assemblyRefs.TryGetValue(assemblyDesc, out var handle))
{
return(handle);
}
AssemblyName name = assemblyDesc.GetName();
var referenceHandle = GetAssemblyRef(name);
_assemblyRefs.Add(assemblyDesc, referenceHandle);
return(referenceHandle);
}
internal override ModuleDesc ResolveModule(IAssemblyDesc referencingModule, string fileName, bool throwIfNotFound = true)
{
// The referencing module is not getting verified currently.
// However, netmodules are resolved in the context of assembly, not in the global context.
EcmaModule module = CacheResolvedAssemblyOrNetmodule(_resolver.ResolveModule(referencingModule.GetName(), fileName), fileName, referencingModule, throwIfNotFound);
if (module.MetadataReader.IsAssembly)
{
throw new VerifierException($"The module '{fileName}' is not expected to be an assembly");
}
return(module);
}
internal override ModuleDesc ResolveModule(IAssemblyDesc referencingModule, string fileName, bool throwIfNotFound = true)
{
// Referenced modules are stored without their extension (see CommandLineHelpers.cs), so we have to drop
// the extension here as well to find a match.
string simpleName = Path.GetFileNameWithoutExtension(fileName);
// The referencing module is not getting verified currently.
// However, netmodules are resolved in the context of assembly, not in the global context.
EcmaModule module = ResolveAssemblyOrNetmodule(simpleName, fileName, referencingModule as IAssemblyDesc, throwIfNotFound);
if (module.MetadataReader.IsAssembly)
{
throw new VerifierException($"The module '{fileName}' is not expected to be an assembly");
}
return(module);
}
protected override void AppendNameForNamespaceType(StringBuilder sb, DefType type)
{
string ns = GetTypeNamespace(type);
if (ns.Length > 0)
{
AppendEscapedIdentifier(sb, ns);
sb.Append('.');
}
AppendEscapedIdentifier(sb, GetTypeName(type));
if (type is MetadataType)
{
IAssemblyDesc homeAssembly = ((MetadataType)type).Module as IAssemblyDesc;
AppendAssemblyName(sb, homeAssembly);
}
}
public static string Module(ModuleDesc module)
{
if (module == null)
{
return("?");
}
IAssemblyDesc assembly = module as IAssemblyDesc;
if (assembly != null)
{
return(assembly.GetName().FullName);
}
else
{
Debug.Assert(false, "Multi-module assemblies");
return(module.ToString());
}
}
private AssemblyReferenceHandle MakeAssemblyReferenceHandle(IAssemblyDesc assemblyRef)
{
AssemblyReferenceHandle handle;
if (!_assemblyRefHandles.TryGetValue(assemblyRef, out handle))
{
AssemblyName assemblyName = assemblyRef.GetName();
handle = _metadataBuilder.AddAssemblyReference(
_metadataBuilder.GetOrAddString(assemblyName.Name),
assemblyName.Version,
default(StringHandle),
_metadataBuilder.GetOrAddBlob(ImmutableArray.Create <byte>(assemblyName.GetPublicKeyToken())),
default(AssemblyFlags),
default(BlobHandle));
_assemblyRefHandles[assemblyRef] = handle;
}
return(handle);
}
internal EcmaModule GetModule(PEReader peReader, IAssemblyDesc containingAssembly = null)
{
if (peReader == null)
{
return(null);
}
if (_modulesCache.TryGetValue(peReader, out EcmaModule existingModule))
{
if (containingAssembly != null && existingModule.Assembly != containingAssembly)
{
throw new VerifierException($"Containing assembly for module '{existingModule}' must be '{containingAssembly}'");
}
return(existingModule);
}
EcmaModule module = EcmaModule.Create(this, peReader, containingAssembly);
_modulesCache.Add(peReader, module);
return(module);
}
public ModuleDesc(TypeSystemContext context, IAssemblyDesc assembly)
{
Context = context;
Assembly = assembly;
}
private EcmaModule CacheResolvedAssemblyOrNetmodule(PEReader peReader, string verificationName, IAssemblyDesc containingAssembly, bool throwIfNotFound)
{
if (peReader == null)
{
if (throwIfNotFound)
{
throw new VerifierException("Assembly or module not found: " + verificationName);
}
return(null);
}
var module = GetModule(peReader, containingAssembly);
VerifyModuleName(verificationName, module);
return(module);
}
internal EcmaModule(TypeSystemContext context, PEReader peReader, MetadataReader metadataReader, IAssemblyDesc containingAssembly, PdbSymbolReader pdbReader)
: this(context, peReader, metadataReader, containingAssembly)
{
PdbReader = pdbReader;
}
public override MethodIL EmitIL()
{
ILEmitter emitter = new ILEmitter();
ILCodeStream codeStream = emitter.NewCodeStream();
// Allow the class library to run explicitly ordered class constructors first thing in start-up.
if (_libraryInitializers != null)
{
foreach (MethodDesc method in _libraryInitializers)
{
codeStream.Emit(ILOpcode.call, emitter.NewToken(method));
}
}
MetadataType startup = Context.GetHelperType("StartupCodeHelpers");
// Initialize command line args if the class library supports this
string initArgsName = (Context.Target.OperatingSystem == TargetOS.Windows)
? "InitializeCommandLineArgsW"
: "InitializeCommandLineArgs";
MethodDesc initArgs = startup.GetMethod(initArgsName, null);
if (initArgs != null)
{
codeStream.Emit(ILOpcode.ldarg_0); // argc
codeStream.Emit(ILOpcode.ldarg_1); // argv
codeStream.Emit(ILOpcode.call, emitter.NewToken(initArgs));
}
// Initialize the entrypoint assembly if the class library supports this
MethodDesc initEntryAssembly = startup.GetMethod("InitializeEntryAssembly", null);
if (initEntryAssembly != null)
{
IAssemblyDesc entrypointAssembly = ((MetadataType)_mainMethod.WrappedMethod.OwningType).Module as IAssemblyDesc;
Debug.Assert(entrypointAssembly != null, "Multi-module assembly?");
codeStream.Emit(ILOpcode.ldstr, emitter.NewToken(entrypointAssembly.GetName().FullName));
codeStream.Emit(ILOpcode.call, emitter.NewToken(initEntryAssembly));
}
// Call program Main
if (_mainMethod.Signature.Length > 0)
{
// TODO: better exception
if (initArgs == null)
{
throw new Exception("Main() has parameters, but the class library doesn't support them");
}
codeStream.Emit(ILOpcode.call, emitter.NewToken(startup.GetKnownMethod("GetMainMethodArguments", null)));
}
codeStream.Emit(ILOpcode.call, emitter.NewToken(_mainMethod));
MethodDesc setLatchedExitCode = startup.GetMethod("SetLatchedExitCode", null);
MethodDesc shutdown = startup.GetMethod("Shutdown", null);
// The class library either supports "advanced shutdown", or doesn't. No half-implementations allowed.
Debug.Assert((setLatchedExitCode != null) == (shutdown != null));
if (setLatchedExitCode != null)
{
// If the main method has a return value, save it
if (!_mainMethod.Signature.ReturnType.IsVoid)
{
codeStream.Emit(ILOpcode.call, emitter.NewToken(setLatchedExitCode));
}
// Ask the class library to shut down and return exit code.
codeStream.Emit(ILOpcode.call, emitter.NewToken(shutdown));
}
else
{
// This is a class library that doesn't have SetLatchedExitCode/Shutdown.
// If the main method returns void, we simply use 0 exit code.
if (_mainMethod.Signature.ReturnType.IsVoid)
{
codeStream.EmitLdc(0);
}
}
codeStream.Emit(ILOpcode.ret);
return(emitter.Link(this));
}
public static EcmaModule Create(TypeSystemContext context, PEReader peReader, IAssemblyDesc containingAssembly, IModuleResolver customModuleResolver = null)
{
MetadataReader metadataReader = CreateMetadataReader(context, peReader);
if (containingAssembly == null)
{
return(new EcmaAssembly(context, peReader, metadataReader, customModuleResolver));
}
else
{
return(new EcmaModule(context, peReader, metadataReader, containingAssembly, customModuleResolver));
}
}
public MethodDesc GetHelper(IAssemblyDesc executingAssembly)
{
return(_cache.GetOrCreateValue(executingAssembly));
}
private EcmaModule ResolveAssemblyOrNetmodule(string simpleName, string verificationName, IAssemblyDesc containingAssembly, bool throwIfNotFound)
{
PEReader peReader = _resolver.Resolve(simpleName);
if (peReader == null && throwIfNotFound)
{
throw new VerifierException("Assembly or module not found: " + simpleName);
}
var module = GetModule(peReader, containingAssembly);
VerifyModuleName(verificationName, module);
return(module);
}
public static EcmaModule Create(TypeSystemContext context, PEReader peReader, IAssemblyDesc containingAssembly, PdbSymbolReader pdbReader)
{
MetadataReader metadataReader = CreateMetadataReader(context, peReader);
if (containingAssembly == null)
{
return(new EcmaAssembly(context, peReader, metadataReader, pdbReader));
}
else
{
return(new EcmaModule(context, peReader, metadataReader, containingAssembly, pdbReader));
}
}
ModuleDesc IModuleResolver.ResolveModule(IAssemblyDesc referencingModule, string fileName, bool throwIfNotFound)
{
return(_wrappedResolver.ResolveModule(referencingModule, fileName, throwIfNotFound));
}
internal EcmaModule(TypeSystemContext context, PEReader peReader, MetadataReader metadataReader, IAssemblyDesc containingAssembly, IModuleResolver customModuleResolver)
: base(context, containingAssembly)
{
_peReader = peReader;
_metadataReader = metadataReader;
_resolvedTokens = new EcmaObjectLookupHashtable(this);
_moduleResolver = customModuleResolver != null ? customModuleResolver : context;
}
