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; }