/// <summary> /// Try to locate a (reference) assembly using the list of explicit reference assemblies /// and the list of reference paths passed to R2RDump. /// </summary> /// <param name="simpleName">Simple name of the assembly to look up</param> /// <param name="parentFile">Name of assembly from which we're performing the lookup</param> /// <returns></returns> public MetadataReader FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile) { string simpleName = metadataReader.GetString(metadataReader.GetAssemblyReference(assemblyReferenceHandle).Name); foreach (FileInfo refAsm in Reference ?? Enumerable.Empty <FileInfo>()) { if (Path.GetFileNameWithoutExtension(refAsm.FullName).Equals(simpleName, StringComparison.OrdinalIgnoreCase)) { return(Open(refAsm.FullName)); } } IEnumerable <string> allRefPaths = new string[] { Path.GetDirectoryName(parentFile) } .Concat((ReferencePath ?? Enumerable.Empty <DirectoryInfo>()).Select(path => path.FullName)); foreach (string refPath in allRefPaths) { foreach (string extension in ProbeExtensions) { string probeFile = Path.Combine(refPath, simpleName + extension); if (File.Exists(probeFile)) { return(Open(probeFile)); } } } return(null); }
public IAssemblyMetadata FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile) { LoadedAssembly loadedAssembly = this.loadedAssembly.LookupReferencedAssembly(new Decompiler.Metadata.AssemblyReference(metadataReader, assemblyReferenceHandle)); PEReader reader = loadedAssembly?.GetPEFileOrNull()?.Reader; return(reader == null ? null : new StandaloneAssemblyMetadata(reader)); }
public IModule ResolveModule(AssemblyReferenceHandle handle) { if (handle.IsNil) { return(null); } if (referencedAssemblies == null) { return(ResolveModuleUncached(handle)); } int row = MetadataTokens.GetRowNumber(handle); Debug.Assert(row != 0); if (row >= referencedAssemblies.Length) { HandleOutOfRange(handle); } var module = LazyInit.VolatileRead(ref referencedAssemblies[row]); if (module != null) { return(module); } module = ResolveModuleUncached(handle); return(LazyInit.GetOrSet(ref referencedAssemblies[row], module)); }
// https://github.com/Microsoft/msbuild/issues/4002 // https://github.com/dotnet/corefx/issues/34008 // // We do not use AssemblyReference.GetAssemblyName() here because its behavior // is different from other code paths with respect to neutral culture. We will // get unspecified culture instead of explicitly neutral culture. This in turn // leads string comparisons of assembly-name-modulo-version in RAR to false // negatives that break its conflict resolution and binding redirect generation. private static AssemblyName GetAssemblyName(MetadataReader metadataReader, AssemblyReferenceHandle handle) { var entry = metadataReader.GetAssemblyReference(handle); var assemblyName = new AssemblyName { Name = metadataReader.GetString(entry.Name), Version = entry.Version, CultureName = metadataReader.GetString(entry.Culture) }; var publicKeyOrToken = metadataReader.GetBlobBytes(entry.PublicKeyOrToken); if (publicKeyOrToken != null) { if (publicKeyOrToken.Length <= 8) { assemblyName.SetPublicKeyToken(publicKeyOrToken); } else { assemblyName.SetPublicKey(publicKeyOrToken); } } assemblyName.Flags = (AssemblyNameFlags)(int)entry.Flags; return(assemblyName); }
private Object ResolveAssemblyReference(AssemblyReferenceHandle handle) { AssemblyReference assemblyReference = _metadataReader.GetAssemblyReference(handle); AssemblyName an = new AssemblyName(); an.Name = _metadataReader.GetString(assemblyReference.Name); an.Version = assemblyReference.Version; var publicKeyOrToken = _metadataReader.GetBlobBytes(assemblyReference.PublicKeyOrToken); if ((assemblyReference.Flags & AssemblyFlags.PublicKey) != 0) { an.SetPublicKey(publicKeyOrToken); } else { an.SetPublicKeyToken(publicKeyOrToken); } an.CultureName = _metadataReader.GetString(assemblyReference.Culture); an.ContentType = GetContentTypeFromAssemblyFlags(assemblyReference.Flags); return(_moduleResolver.ResolveAssembly(an)); }
public IAssemblyMetadata FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile) { PEFile module = assemblyResolver.Resolve(new Decompiler.Metadata.AssemblyReference(metadataReader, assemblyReferenceHandle)); PEReader reader = module?.Reader; return(reader == null ? null : new StandaloneAssemblyMetadata(reader)); }
public AssemblyRefEntry(PEFile module, AssemblyReferenceHandle handle) { this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset; this.module = module; this.metadata = module.Metadata; this.handle = handle; this.assemblyRef = metadata.GetAssemblyReference(handle); }
public AssemblyReference(PEFile module, AssemblyReferenceHandle handle) { Module = module ?? throw new ArgumentNullException(nameof(module)); if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } Handle = handle; }
private static string GetAssemblyReferenceName( MetadataReader reader, AssemblyReferenceHandle handle ) { var reference = reader.GetAssemblyReference(handle); return(reader.GetString(reference.Name)); }
public CustomAttributeHandleCollection GetCustomAttributes() { if (IsVirtual) { return(GetVirtualCustomAttributes()); } return(new CustomAttributeHandleCollection(_reader, AssemblyReferenceHandle.FromRowId(RowId))); }
public void IsVirtual() { Assert.False(AssemblyReferenceHandle.FromRowId(1).IsVirtual); Assert.False(StringHandle.FromOffset(1).IsVirtual); Assert.False(BlobHandle.FromOffset(1).IsVirtual); Assert.True(AssemblyReferenceHandle.FromVirtualIndex(0).IsVirtual); Assert.True(StringHandle.FromVirtualIndex(0).IsVirtual); Assert.True(BlobHandle.FromVirtualIndex(0, 0).IsVirtual); }
public PortableExternAliasRecord( string alias, TModuleSymbol owningModule, PEModule owningPEModule, AssemblyReferenceHandle targetAssemblyHandle) : base(alias) { _owningModule = owningModule; _owningPEModule = owningPEModule; _targetAssemblyHandle = targetAssemblyHandle; }
public override IAssemblySymbolInternal GetReferencedAssembly(AssemblyReferenceHandle handle) { int index = _metadataDecoder.Module.GetAssemblyReferenceIndexOrThrow(handle); var assembly = _metadataDecoder.ModuleSymbol.GetReferencedAssemblySymbol(index); if (assembly == null) { throw new BadImageFormatException(); } return(assembly); }
private EntityHandle GetProjectedResolutionScope() { switch (Treatment) { case TypeRefTreatment.SystemAttribute: case TypeRefTreatment.SystemDelegate: return(AssemblyReferenceHandle.FromVirtualIndex(AssemblyReferenceHandle.VirtualIndex.System_Runtime)); } Debug.Assert(false, "Unknown TypeRef treatment"); return(default(AssemblyReferenceHandle)); }
public ScannedAssembly(AssemblyReferenceHandle handle, MetadataReader reader) { var reference = reader.GetAssemblyReference(handle); Name = reader.GetString(reference.Name); Culture = reader.GetString(reference.Culture); PublicKey = reader.GetBlobBytes(reference.PublicKeyOrToken).ToList(); Token = reader.GetToken(handle); Version = reference.Version; Flags = reference.Flags; ResolutionStatus = ResolutionStatus.UnResolved; }
private PortableImportRecord( ImportTargetKind targetKind, string alias, AssemblyReferenceHandle targetAssemblyHandle, Handle targetTypeHandle, string targetNamespaceName) { _targetKind = targetKind; _alias = alias; _targetAssemblyHandle = targetAssemblyHandle; _targetTypeHandle = targetTypeHandle; _targetNamespaceName = targetNamespaceName; }
public static RuntimeAssemblyName ToRuntimeAssemblyName(this AssemblyReferenceHandle assemblyReferenceHandle, MetadataReader reader) { AssemblyReference assemblyReference = reader.GetAssemblyReference(assemblyReferenceHandle); return(CreateRuntimeAssemblyNameFromMetadata( reader, assemblyReference.Name, assemblyReference.Version, assemblyReference.Culture, assemblyReference.PublicKeyOrToken, assemblyReference.Flags )); }
/// <summary> /// If this module forwards the given type to another assembly, return that assembly; /// otherwise, return null. /// </summary> /// <param name="fullName">Type to look up.</param> /// <returns>Assembly symbol or null.</returns> /// <remarks> /// The returned assembly may also forward the type. /// </remarks> internal AssemblySymbol GetAssemblyForForwardedType(ref MetadataTypeName fullName) { try { string matchedName; AssemblyReferenceHandle assemblyRef = Module.GetAssemblyForForwardedType(fullName.FullName, ignoreCase: false, matchedName: out matchedName); return(assemblyRef.IsNil ? null : this.ReferencedAssemblySymbols[Module.GetAssemblyReferenceIndexOrThrow(assemblyRef)]); } catch (BadImageFormatException) { return(null); } }
private TypeRefTypeSystemType ResolveTypeRef(PEInfo peInfo, TypeReferenceHandle handle) { if (peInfo.handleLookup.TryGetValue(handle, out TypeRefTypeSystemType type)) { return(type); } var typeReference = peInfo.reader.GetTypeReference(handle); if (typeReference.ResolutionScope.Kind == HandleKind.TypeReference) { var containingType = ResolveTypeRef(peInfo, (TypeReferenceHandle)typeReference.ResolutionScope); string typeName = peInfo.reader.GetString(typeReference.Name); if (!typeReference.Namespace.IsNil) { typeName = peInfo.reader.GetString(typeReference.Namespace) + "." + typeName; } type = containingType.GetOrAddNestedType(typeName); } else if (typeReference.ResolutionScope.Kind == HandleKind.AssemblyReference) { AssemblyReferenceHandle asmRefHandle = (AssemblyReferenceHandle)typeReference.ResolutionScope; TypeRefTypeSystemModule module; if (!peInfo.assemblyLookup.TryGetValue(asmRefHandle, out module)) { var assemblyReference = peInfo.reader.GetAssemblyReference(asmRefHandle); string assemblyName = peInfo.reader.GetString(assemblyReference.Name); if (!_typeRefModules.TryGetValue(assemblyName, out module)) { module = new TypeRefTypeSystemModule(this, new System.Reflection.AssemblyName(assemblyName)); _typeRefModules.Add(module.Assembly.GetName().Name, module); } peInfo.assemblyLookup.Add(asmRefHandle, module); } type = module.GetOrAddType(!typeReference.Namespace.IsNil ? peInfo.reader.GetString(typeReference.Namespace) : null, peInfo.reader.GetString(typeReference.Name)); } else { type = null; } if (type != null) { peInfo.handleLookup.Add(handle, type); } return(type); }
public AssemblyReference(PEFile module, AssemblyReferenceHandle handle) { if (module == null) { throw new ArgumentNullException(nameof(module)); } if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } Metadata = module.Metadata; Handle = handle; entry = Metadata.GetAssemblyReference(handle); }
public AssemblyReference(MetadataReader metadata, AssemblyReferenceHandle handle) { if (metadata == null) { throw new ArgumentNullException(nameof(metadata)); } if (handle.IsNil) { throw new ArgumentNullException(nameof(handle)); } Metadata = metadata; Handle = handle; entry = metadata.GetAssemblyReference(handle); }
private AssemblySymbol GetReferencedAssemblySymbol(AssemblyReferenceHandle assemblyRef) { int referencedAssemblyIndex; try { referencedAssemblyIndex = Module.GetAssemblyReferenceIndexOrThrow(assemblyRef); } catch (BadImageFormatException) { return(null); } return(this.GetReferencedAssemblySymbol(referencedAssemblyIndex)); }
public ProjectionInfo( string winRtNamespace, StringHandle.VirtualIndex clrNamespace, StringHandle.VirtualIndex clrName, AssemblyReferenceHandle.VirtualIndex clrAssembly, TypeDefTreatment treatment = TypeDefTreatment.RedirectedToClrType, bool isIDisposable = false) { this.WinRTNamespace = winRtNamespace; this.ClrNamespace = clrNamespace; this.ClrName = clrName; this.AssemblyRef = clrAssembly; this.Treatment = treatment; this.IsIDisposable = isIDisposable; }
private Handle GetProjectedResolutionScope() { switch (Treatment) { case TypeRefTreatment.SystemAttribute: case TypeRefTreatment.SystemDelegate: return(AssemblyReferenceHandle.FromVirtualIndex(AssemblyReferenceHandle.VirtualIndex.System_Runtime)); case TypeRefTreatment.UseProjectionInfo: return(MetadataReader.GetProjectedAssemblyRef((int)RowId)); } Debug.Assert(false, "Unknown TypeRef treatment"); return(default(AssemblyReferenceHandle)); }
/// <summary> /// Returns a RoAssemblyName corresponding to the assembly reference. /// </summary> public static RoAssemblyName ToRoAssemblyName(this AssemblyReferenceHandle h, MetadataReader reader) { AssemblyReference a = h.GetAssemblyReference(reader); string name = a.Name.GetString(reader); Version version = a.Version.AdjustForUnspecifiedVersionComponents(); string culture = a.Culture.GetStringOrNull(reader); byte[] pkOrPkt = a.PublicKeyOrToken.GetBlobBytes(reader); AssemblyFlags flags = a.Flags; if ((flags & AssemblyFlags.PublicKey) != 0) { pkOrPkt = pkOrPkt.ComputePublicKeyToken(); } return(new RoAssemblyName(name, version, culture, pkOrPkt)); }
public ManifestMetadataTableNode(NodeFactory nodeFactory) : base(nodeFactory.Target) { _assemblyRefToModuleIdMap = new Dictionary <string, int>(); _moduleIdToAssemblyNameMap = new Dictionary <int, AssemblyName>(); _manifestAssemblyMvids = new List <Guid>(); _signatureEmitters = new List <ISignatureEmitter>(); _nodeFactory = nodeFactory; _nextModuleId = 1; if (!_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode) { MetadataReader mdReader = _nodeFactory.CompilationModuleGroup.CompilationModuleSet.Single().MetadataReader; _assemblyRefCount = mdReader.GetTableRowCount(TableIndex.AssemblyRef) + 1; if (!_nodeFactory.CompilationModuleGroup.IsInputBubble) { for (int assemblyRefIndex = 1; assemblyRefIndex < _assemblyRefCount; assemblyRefIndex++) { AssemblyReferenceHandle assemblyRefHandle = MetadataTokens.AssemblyReferenceHandle(assemblyRefIndex); AssemblyReference assemblyRef = mdReader.GetAssemblyReference(assemblyRefHandle); string assemblyName = mdReader.GetString(assemblyRef.Name); _assemblyRefToModuleIdMap[assemblyName] = assemblyRefIndex; } } // AssemblyRefCount + 1 corresponds to ROWID 0 in the manifest metadata _nextModuleId += _assemblyRefCount; } if (_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode) { // Fill in entries for all input modules right away to make sure they have parallel indices int nextExpectedId = 1; foreach (EcmaModule inputModule in _nodeFactory.CompilationModuleGroup.CompilationModuleSet) { int acquiredId = ModuleToIndexInternal(inputModule); if (acquiredId != nextExpectedId) { throw new InternalCompilerErrorException($"Manifest metadata consistency error - acquired ID {acquiredId}, expected {nextExpectedId}"); } nextExpectedId++; } } }
internal ImportDefinition( ImportDefinitionKind kind, BlobHandle alias = default(BlobHandle), AssemblyReferenceHandle assembly = default(AssemblyReferenceHandle), Handle typeOrNamespace = default(Handle)) { Debug.Assert( typeOrNamespace.IsNil || typeOrNamespace.Kind == HandleKind.Blob || typeOrNamespace.Kind == HandleKind.TypeDefinition || typeOrNamespace.Kind == HandleKind.TypeReference || typeOrNamespace.Kind == HandleKind.TypeSpecification); _kind = kind; _alias = alias; _assembly = assembly; _typeOrNamespace = typeOrNamespace; }
internal ImportDefinition( ImportDefinitionKind kind, BlobHandle alias = default(BlobHandle), AssemblyReferenceHandle assembly = default(AssemblyReferenceHandle), Handle typeOrNamespace = default(Handle)) { Debug.Assert( typeOrNamespace.IsNil || typeOrNamespace.Kind == HandleKind.Blob || typeOrNamespace.Kind == HandleKind.TypeDefinition || typeOrNamespace.Kind == HandleKind.TypeReference || typeOrNamespace.Kind == HandleKind.TypeSpecification); Kind = kind; Alias = alias; TargetAssembly = assembly; _typeOrNamespace = typeOrNamespace; }
private Mapping <AssemblyReferenceHandle> MapAssemblyReferenceImpl(AssemblyReferenceHandle handle) { AssemblyReference assemblyReference = _sourceMetadata.GetAssemblyReference(handle); string name = _sourceMetadata.GetString(assemblyReference.Name); string culture = _sourceMetadata.GetString(assemblyReference.Culture); ImmutableArray <byte> publicKeyOrToken = _sourceMetadata.GetBlobContent(assemblyReference.PublicKeyOrToken); foreach (var targetHandle in _targetMetadata.AssemblyReferences) { AssemblyReference target = _targetMetadata.GetAssemblyReference(targetHandle); if (!_targetMetadata.StringComparer.Equals(target.Name, name)) { continue; } if (!_targetMetadata.StringComparer.Equals(target.Culture, culture)) { continue; } if (!publicKeyOrToken.IsDefaultOrEmpty) { if (target.Version != assemblyReference.Version) { continue; } ImmutableArray <byte> targetPublicKeyOrToken = _targetMetadata.GetBlobContent(target.PublicKeyOrToken); if (!targetPublicKeyOrToken.SequenceEqual(targetPublicKeyOrToken)) { continue; } } return(new Mapping <AssemblyReferenceHandle>(targetHandle)); } return(new Mapping <AssemblyReferenceHandle>()); }
public ManifestMetadataTableNode(EcmaModule inputModule, NodeFactory nodeFactory) : base(inputModule.Context.Target) { _assemblyRefToModuleIdMap = new Dictionary <string, int>(); _moduleIdToAssemblyNameMap = new Dictionary <int, AssemblyName>(); _signatureEmitters = new List <ISignatureEmitter>(); _nodeFactory = nodeFactory; _inputModuleName = inputModule.Assembly.GetName().Name; _assemblyRefCount = inputModule.MetadataReader.GetTableRowCount(TableIndex.AssemblyRef); for (int assemblyRefIndex = 1; assemblyRefIndex <= _assemblyRefCount; assemblyRefIndex++) { AssemblyReferenceHandle assemblyRefHandle = MetadataTokens.AssemblyReferenceHandle(assemblyRefIndex); AssemblyReference assemblyRef = inputModule.MetadataReader.GetAssemblyReference(assemblyRefHandle); string assemblyName = inputModule.MetadataReader.GetString(assemblyRef.Name); _assemblyRefToModuleIdMap[assemblyName] = assemblyRefIndex; } // AssemblyRefCount + 1 corresponds to ROWID 0 in the manifest metadata _nextModuleId = _assemblyRefCount + 2; }
private unsafe void EnsureManifestReferences() { if (_manifestReferences != null) { return; } _manifestReferences = new List <AssemblyReferenceHandle>(); if (ReadyToRunHeader.Sections.TryGetValue(ReadyToRunSectionType.ManifestMetadata, out ReadyToRunSection manifestMetadata)) { fixed(byte *image = Image) { _manifestReader = new MetadataReader(image + GetOffset(manifestMetadata.RelativeVirtualAddress), manifestMetadata.Size); int assemblyRefCount = _manifestReader.GetTableRowCount(TableIndex.AssemblyRef); for (int assemblyRefIndex = 1; assemblyRefIndex <= assemblyRefCount; assemblyRefIndex++) { AssemblyReferenceHandle asmRefHandle = MetadataTokens.AssemblyReferenceHandle(assemblyRefIndex); _manifestReferences.Add(asmRefHandle); } } } }
/// <summary> /// Open a given reference assembly (relative to this ECMA metadata file). /// </summary> /// <param name="refAsmIndex">Reference assembly index</param> /// <returns>MetadataReader instance representing the reference assembly</returns> internal MetadataReader OpenReferenceAssembly(int refAsmIndex) { MetadataReader result = (refAsmIndex < _assemblyCache.Count ? _assemblyCache[refAsmIndex] : null); if (result == null) { AssemblyReferenceHandle assemblyReferenceHandle = GetAssemblyAtIndex(refAsmIndex, out MetadataReader metadataReader); result = _assemblyResolver.FindAssembly(metadataReader, assemblyReferenceHandle, Filename); if (result == null) { string name = metadataReader.GetString(metadataReader.GetAssemblyReference(assemblyReferenceHandle).Name); throw new Exception($"Missing reference assembly: {name}"); } while (_assemblyCache.Count <= refAsmIndex) { _assemblyCache.Add(null); } _assemblyCache[refAsmIndex] = result; } return(result); }
public AssemblyReference GetAssemblyReference(AssemblyReferenceHandle handle) { return new AssemblyReference(this, handle.Value); }
private StringHandle.VirtualIndex GetVirtualNameIndex(AssemblyReferenceHandle.VirtualIndex index) { switch (index) { case AssemblyReferenceHandle.VirtualIndex.System_ObjectModel: return StringHandle.VirtualIndex.System_ObjectModel; case AssemblyReferenceHandle.VirtualIndex.System_Runtime: return StringHandle.VirtualIndex.System_Runtime; case AssemblyReferenceHandle.VirtualIndex.System_Runtime_InteropServices_WindowsRuntime: return StringHandle.VirtualIndex.System_Runtime_InteropServices_WindowsRuntime; case AssemblyReferenceHandle.VirtualIndex.System_Runtime_WindowsRuntime: return StringHandle.VirtualIndex.System_Runtime_WindowsRuntime; case AssemblyReferenceHandle.VirtualIndex.System_Runtime_WindowsRuntime_UI_Xaml: return StringHandle.VirtualIndex.System_Runtime_WindowsRuntime_UI_Xaml; case AssemblyReferenceHandle.VirtualIndex.System_Numerics_Vectors: return StringHandle.VirtualIndex.System_Numerics_Vectors; } Debug.Assert(false, "Unexpected virtual index value"); return 0; }
public AssemblyReference GetAssemblyReference(AssemblyReferenceHandle handle) { return new AssemblyReference(this, handle.Token & TokenTypeIds.VirtualBitAndRowIdMask); }
private Mapping<AssemblyReferenceHandle> MapAssemblyReferenceImpl(AssemblyReferenceHandle handle) { AssemblyReference assemblyReference = _sourceMetadata.GetAssemblyReference(handle); string name = _sourceMetadata.GetString(assemblyReference.Name); string culture = _sourceMetadata.GetString(assemblyReference.Culture); ImmutableArray<byte> publicKeyOrToken = _sourceMetadata.GetBlobContent(assemblyReference.PublicKeyOrToken); foreach (var targetHandle in _targetMetadata.AssemblyReferences) { AssemblyReference target = _targetMetadata.GetAssemblyReference(targetHandle); if (!_targetMetadata.StringComparer.Equals(target.Name, name)) continue; if (!_targetMetadata.StringComparer.Equals(target.Culture, culture)) continue; if (!publicKeyOrToken.IsDefaultOrEmpty) { if (target.Version != assemblyReference.Version) continue; ImmutableArray<byte> targetPublicKeyOrToken = _targetMetadata.GetBlobContent(target.PublicKeyOrToken); if (!targetPublicKeyOrToken.SequenceEqual(targetPublicKeyOrToken)) continue; } return new Mapping<AssemblyReferenceHandle>(targetHandle); } return new Mapping<AssemblyReferenceHandle>(); }
public Mapping<AssemblyReferenceHandle> MapAssemblyReference(AssemblyReferenceHandle handle) { return _assemblyReferences.GetOrAdd(handle, MapAssemblyReferenceImpl); }
private AssemblySymbol GetReferencedAssemblySymbol(AssemblyReferenceHandle assemblyRef) { int referencedAssemblyIndex; try { referencedAssemblyIndex = Module.GetAssemblyReferenceIndexOrThrow(assemblyRef); } catch (BadImageFormatException) { return null; } return this.GetReferencedAssemblySymbol(referencedAssemblyIndex); }