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