internal static CilType DecodeType(EntityHandle type, CilTypeProvider provider)
{
return(SignatureDecoder.DecodeType(type, provider, 0));
}
public static MethodSignature <CilType> DecodeMethodSignature(MethodDefinition methodDefinition, CilTypeProvider provider)
{
return(SignatureDecoder.DecodeMethodSignature(methodDefinition.Signature, provider));
}
private void LookupMetadataDefinitions(
TypeDefinition typeDefinition,
OrderPreservingMultiDictionary <string, MetadataDefinition> definitionMap)
{
// Only bother looking for extension methods in static types.
// Note this check means we would ignore extension methods declared in assemblies
// compiled from VB code, since a module in VB is compiled into class with
// "sealed" attribute but not "abstract".
// Although this can be addressed by checking custom attributes,
// we believe this is not a common scenario to warrant potential perf impact.
if ((typeDefinition.Attributes & TypeAttributes.Abstract) != 0 &&
(typeDefinition.Attributes & TypeAttributes.Sealed) != 0)
{
foreach (var child in typeDefinition.GetMethods())
{
var method = _metadataReader.GetMethodDefinition(child);
if ((method.Attributes & MethodAttributes.SpecialName) != 0 ||
(method.Attributes & MethodAttributes.RTSpecialName) != 0)
{
continue;
}
// SymbolTreeInfo is only searched for types and extension methods.
// So we don't want to pull in all methods here. As a simple approximation
// we just pull in methods that have attributes on them.
if ((method.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public &&
(method.Attributes & MethodAttributes.Static) != 0 &&
method.GetParameters().Count > 0 &&
method.GetCustomAttributes().Count > 0)
{
// Decode method signature to get the receiver type name (i.e. type name for the first parameter)
var blob = _metadataReader.GetBlobReader(method.Signature);
var decoder = new SignatureDecoder <ParameterTypeInfo, object>(ParameterTypeInfoProvider.Instance, _metadataReader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
// It'd be good if we don't need to go through all parameters and make unnecessary allocations.
// However, this is not possible with meatadata reader API right now (although it's possible by copying code from meatadata reader implementaion)
if (signature.ParameterTypes.Length > 0)
{
_containsExtensionsMethod = true;
var firstParameterTypeInfo = signature.ParameterTypes[0];
var definition = new MetadataDefinition(MetadataDefinitionKind.Member, _metadataReader.GetString(method.Name), firstParameterTypeInfo);
definitionMap.Add(definition.Name, definition);
}
}
}
}
foreach (var child in typeDefinition.GetNestedTypes())
{
var type = _metadataReader.GetTypeDefinition(child);
// We don't include internals from metadata assemblies. It's less likely that
// a project would have IVT to it and so it helps us save on memory. It also
// means we can avoid loading lots and lots of obfuscated code in the case the
// dll was obfuscated.
if (IsPublic(type.Attributes))
{
var definition = MetadataDefinition.Create(_metadataReader, type);
definitionMap.Add(definition.Name, definition);
_allTypeDefinitions.Add(definition);
}
}
}
/// <summary>
/// Initialize generic method instances with argument types and runtime function indices from InstanceMethodEntrypoints
/// </summary>
private void ParseInstanceMethodEntrypoints(bool[] isEntryPoint)
{
if (!ReadyToRunHeader.Sections.ContainsKey(ReadyToRunSection.SectionType.READYTORUN_SECTION_INSTANCE_METHOD_ENTRYPOINTS))
{
return;
}
ReadyToRunSection instMethodEntryPointSection = ReadyToRunHeader.Sections[ReadyToRunSection.SectionType.READYTORUN_SECTION_INSTANCE_METHOD_ENTRYPOINTS];
int instMethodEntryPointsOffset = GetOffset(instMethodEntryPointSection.RelativeVirtualAddress);
NativeParser parser = new NativeParser(Image, (uint)instMethodEntryPointsOffset);
NativeHashtable instMethodEntryPoints = new NativeHashtable(Image, parser, (uint)(instMethodEntryPointsOffset + instMethodEntryPointSection.Size));
NativeHashtable.AllEntriesEnumerator allEntriesEnum = instMethodEntryPoints.EnumerateAllEntries();
NativeParser curParser = allEntriesEnum.GetNext();
while (!curParser.IsNull())
{
SignatureDecoder decoder = new SignatureDecoder(_assemblyResolver, this, (int)curParser.Offset);
MetadataReader mdReader = MetadataReader;
string owningType = null;
uint methodFlags = decoder.ReadUInt();
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
{
mdReader = decoder.GetMetadataReaderFromModuleOverride();
owningType = decoder.ReadTypeSignatureNoEmit();
}
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_SlotInsteadOfToken) != 0)
{
throw new NotImplementedException();
}
EntityHandle methodHandle;
int rid = (int)decoder.ReadUInt();
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MemberRefToken) != 0)
{
methodHandle = MetadataTokens.MemberReferenceHandle(rid);
}
else
{
methodHandle = MetadataTokens.MethodDefinitionHandle(rid);
}
string[] methodTypeArgs = null;
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MethodInstantiation) != 0)
{
uint typeArgCount = decoder.ReadUInt();
methodTypeArgs = new string[typeArgCount];
for (int typeArgIndex = 0; typeArgIndex < typeArgCount; typeArgIndex++)
{
methodTypeArgs[typeArgIndex] = decoder.ReadTypeSignatureNoEmit();
}
}
string constrainedType = null;
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_Constrained) != 0)
{
constrainedType = decoder.ReadTypeSignatureNoEmit();
}
int runtimeFunctionId;
FixupCell[] fixups;
GetRuntimeFunctionIndexFromOffset((int)decoder.Offset, out runtimeFunctionId, out fixups);
ReadyToRunMethod method = new ReadyToRunMethod(
Methods.Count,
mdReader == null ? MetadataReader : mdReader,
methodHandle,
runtimeFunctionId,
owningType,
constrainedType,
methodTypeArgs,
fixups);
if (method.EntryPointRuntimeFunctionId >= 0 && method.EntryPointRuntimeFunctionId < isEntryPoint.Length)
{
isEntryPoint[method.EntryPointRuntimeFunctionId] = true;
}
Methods.Add(method);
InstanceMethods.Add(new InstanceMethod(curParser.LowHashcode, method));
curParser = allEntriesEnum.GetNext();
}
}
/// <summary>
/// Initialize generic method instances with argument types and runtime function indices from InstanceMethodEntrypoints
/// </summary>
private void ParseInstanceMethodEntrypoints(bool[] isEntryPoint)
{
if (!ReadyToRunHeader.Sections.TryGetValue(ReadyToRunSectionType.InstanceMethodEntryPoints, out ReadyToRunSection instMethodEntryPointSection))
{
return;
}
int instMethodEntryPointsOffset = GetOffset(instMethodEntryPointSection.RelativeVirtualAddress);
NativeParser parser = new NativeParser(Image, (uint)instMethodEntryPointsOffset);
NativeHashtable instMethodEntryPoints = new NativeHashtable(Image, parser, (uint)(instMethodEntryPointsOffset + instMethodEntryPointSection.Size));
NativeHashtable.AllEntriesEnumerator allEntriesEnum = instMethodEntryPoints.EnumerateAllEntries();
NativeParser curParser = allEntriesEnum.GetNext();
while (!curParser.IsNull())
{
SignatureDecoder decoder = new SignatureDecoder(_assemblyResolver, this, (int)curParser.Offset);
MetadataReader mdReader = _composite ? null : _assemblyCache[0];
string owningType = null;
uint methodFlags = decoder.ReadUInt();
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_OwnerType) != 0)
{
mdReader = decoder.GetMetadataReaderFromModuleOverride() ?? mdReader;
if (_composite)
{
// The only types that don't have module overrides on them in composite images are primitive types within the system module
mdReader = GetSystemModuleMetadataReader();
}
owningType = decoder.ReadTypeSignatureNoEmit();
}
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_SlotInsteadOfToken) != 0)
{
throw new NotImplementedException();
}
EntityHandle methodHandle;
int rid = (int)decoder.ReadUInt();
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MemberRefToken) != 0)
{
methodHandle = MetadataTokens.MemberReferenceHandle(rid);
}
else
{
methodHandle = MetadataTokens.MethodDefinitionHandle(rid);
}
string[] methodTypeArgs = null;
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_MethodInstantiation) != 0)
{
uint typeArgCount = decoder.ReadUInt();
methodTypeArgs = new string[typeArgCount];
for (int typeArgIndex = 0; typeArgIndex < typeArgCount; typeArgIndex++)
{
methodTypeArgs[typeArgIndex] = decoder.ReadTypeSignatureNoEmit();
}
}
string constrainedType = null;
if ((methodFlags & (uint)ReadyToRunMethodSigFlags.READYTORUN_METHOD_SIG_Constrained) != 0)
{
constrainedType = decoder.ReadTypeSignatureNoEmit();
}
int runtimeFunctionId;
int?fixupOffset;
GetRuntimeFunctionIndexFromOffset((int)decoder.Offset, out runtimeFunctionId, out fixupOffset);
ReadyToRunMethod method = new ReadyToRunMethod(
this,
_methods.Count,
mdReader,
methodHandle,
runtimeFunctionId,
owningType,
constrainedType,
methodTypeArgs,
fixupOffset);
if (method.EntryPointRuntimeFunctionId >= 0 && method.EntryPointRuntimeFunctionId < isEntryPoint.Length)
{
isEntryPoint[method.EntryPointRuntimeFunctionId] = true;
}
if (!Methods.TryGetValue(instMethodEntryPointSection, out List <ReadyToRunMethod> sectionMethods))
{
sectionMethods = new List <ReadyToRunMethod>();
Methods.Add(instMethodEntryPointSection, sectionMethods);
}
sectionMethods.Add(method);
_instanceMethods.Add(new InstanceMethod(curParser.LowHashcode, method));
curParser = allEntriesEnum.GetNext();
}
}
public MemberMetadataInfoTypeProvider(MetadataReader reader)
{
Reader = reader;
_methodDecoder = new SignatureDecoder <MemberMetadataInfo, object>(this, reader, null);
}
