private void LookupMetadataDefinitions(
TypeDefinition typeDefinition,
OrderPreservingMultiDictionary <string, MetadataDefinition> definitionMap)
{
// Only bother looking for extension methods in static types.
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.GetCustomAttributes().Count > 0)
{
var definition = new MetadataDefinition(
MetadataDefinitionKind.Member, _metadataReader.GetString(method.Name));
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);
}
}
}
public static ImmutableArray <MethodImplementationHandle> GetMethodImplementations(this MethodDefinitionHandle handle, MetadataReader reader)
{
var resultBuilder = ImmutableArray.CreateBuilder <MethodImplementationHandle>();
var typeDefinition = reader.GetTypeDefinition(reader.GetMethodDefinition(handle).GetDeclaringType());
foreach (var methodImplementationHandle in typeDefinition.GetMethodImplementations())
{
var methodImplementation = reader.GetMethodImplementation(methodImplementationHandle);
if (methodImplementation.MethodBody == handle)
{
resultBuilder.Add(methodImplementationHandle);
}
}
return(resultBuilder.ToImmutable());
}
public static string GetCustomAttributeFullName(this MetadataReader reader, CustomAttribute attribute)
{
if (attribute.Constructor.Kind == HandleKind.MemberReference)
{
var ctor = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor);
var type = reader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
return(reader.GetString(type.Namespace) + "." + reader.GetString(type.Name));
}
else if (attribute.Constructor.Kind == HandleKind.MethodDefinition)
{
var ctor = reader.GetMethodDefinition((MethodDefinitionHandle)attribute.Constructor);
var type = reader.GetTypeDefinition(ctor.GetDeclaringType());
return(reader.GetString(type.Namespace) + "." + reader.GetString(type.Name));
}
return(null);
}
public static bool IsCompilerGeneratedOrIsInCompilerGeneratedClass(this MethodDefinitionHandle handle, MetadataReader metadata)
{
MethodDefinition method = metadata.GetMethodDefinition(handle);
if (method.IsCompilerGenerated(metadata))
{
return(true);
}
TypeDefinitionHandle declaringTypeHandle = method.GetDeclaringType();
if (!declaringTypeHandle.IsNil && declaringTypeHandle.IsCompilerGenerated(metadata))
{
return(true);
}
return(false);
}
/// <summary>
/// Gets the type of the attribute.
/// </summary>
public static EntityHandle GetAttributeType(this SRM.CustomAttribute attribute, MetadataReader reader)
{
switch (attribute.Constructor.Kind)
{
case HandleKind.MethodDefinition:
var md = reader.GetMethodDefinition((MethodDefinitionHandle)attribute.Constructor);
return(md.GetDeclaringType());
case HandleKind.MemberReference:
var mr = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor);
return(mr.Parent);
default:
throw new BadImageFormatException("Unexpected token kind for attribute constructor: " + attribute.Constructor.Kind);
}
}
private ModuleToken GetTypeToken(ModuleToken token)
{
if (token.IsNull)
{
return(token);
}
MetadataReader mdReader = token.MetadataReader;
EntityHandle handle = (EntityHandle)MetadataTokens.Handle((int)token.Token);
ModuleToken typeToken;
switch (token.TokenType)
{
case CorTokenType.mdtTypeRef:
case CorTokenType.mdtTypeDef:
typeToken = token;
break;
case CorTokenType.mdtMemberRef:
{
MemberReferenceHandle memberRefHandle = (MemberReferenceHandle)handle;
MemberReference memberRef = mdReader.GetMemberReference(memberRefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(memberRef.Parent));
}
break;
case CorTokenType.mdtFieldDef:
{
FieldDefinitionHandle fieldDefHandle = (FieldDefinitionHandle)handle;
FieldDefinition fieldDef = mdReader.GetFieldDefinition(fieldDefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(fieldDef.GetDeclaringType()));
}
break;
case CorTokenType.mdtMethodDef:
{
MethodDefinitionHandle methodDefHandle = (MethodDefinitionHandle)handle;
MethodDefinition methodDef = mdReader.GetMethodDefinition(methodDefHandle);
typeToken = new ModuleToken(token.Module, (mdToken)MetadataTokens.GetToken(methodDef.GetDeclaringType()));
}
break;
default:
throw new NotImplementedException();
}
return(typeToken);
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public R2RMethod(MetadataReader mdReader, uint rid, int entryPointId, GenericElementTypes[] instanceArgs, uint[] tok)
{
Token = _mdtMethodDef | rid;
Rid = rid;
EntryPointRuntimeFunctionId = entryPointId;
_mdReader = mdReader;
RuntimeFunctions = new List <RuntimeFunction>();
// get the method signature from the MethodDefhandle
MethodDefinitionHandle methodDefHandle = MetadataTokens.MethodDefinitionHandle((int)rid);
_methodDef = mdReader.GetMethodDefinition(methodDefHandle);
Name = mdReader.GetString(_methodDef.Name);
BlobReader signatureReader = mdReader.GetBlobReader(_methodDef.Signature);
TypeDefinitionHandle declaringTypeHandle = _methodDef.GetDeclaringType();
DeclaringType = R2RReader.GetTypeDefFullName(mdReader, declaringTypeHandle);
SignatureHeader signatureHeader = signatureReader.ReadSignatureHeader();
IsGeneric = signatureHeader.IsGeneric;
GenericParameterHandleCollection genericParams = _methodDef.GetGenericParameters();
_genericParamInstanceMap = new Dictionary <string, string>();
int argCount = signatureReader.ReadCompressedInteger();
if (IsGeneric)
{
argCount = signatureReader.ReadCompressedInteger();
}
DisassemblingTypeProvider provider = new DisassemblingTypeProvider();
if (IsGeneric && instanceArgs != null && tok != null)
{
InitGenericInstances(genericParams, instanceArgs, tok);
}
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(new string[0], _genericParamInstanceMap.Values.ToArray());
Signature = _methodDef.DecodeSignature(provider, genericContext);
SignatureString = GetSignature();
}
public R2RMethod(byte[] image, MetadataReader mdReader, NativeArray methodEntryPoints, uint offset, uint rid)
{
// get the id of the entry point runtime function from the MethodEntryPoints NativeArray
Token = _mdtMethodDef | rid;
uint id = 0; // the RUNTIME_FUNCTIONS index
offset = methodEntryPoints.DecodeUnsigned(image, offset, ref id);
if ((id & 1) != 0)
{
if ((id & 2) != 0)
{
uint val = 0;
methodEntryPoints.DecodeUnsigned(image, offset, ref val);
offset -= val;
}
// TODO: Dump fixups
id >>= 2;
}
else
{
id >>= 1;
}
EntryPointRuntimeFunctionId = id;
NativeCode = new List <RuntimeFunction>();
// get the method signature from the MethodDefhandle
try
{
MethodDefinitionHandle methodDefHandle = MetadataTokens.MethodDefinitionHandle((int)rid);
var methodDef = mdReader.GetMethodDefinition(methodDefHandle);
BlobReader signatureReader = mdReader.GetBlobReader(methodDef.Signature);
SignatureHeader header = signatureReader.ReadSignatureHeader();
Name = mdReader.GetString(methodDef.Name);
int argCount = signatureReader.ReadCompressedInteger();
ReturnType = new SignatureType(ref signatureReader, ref mdReader);
ArgTypes = new SignatureType[argCount];
for (int i = 0; i < argCount; i++)
{
ArgTypes[i] = new SignatureType(ref signatureReader, ref mdReader);
}
}
catch (System.BadImageFormatException)
{
R2RDump.OutputWarning("The method with rowId " + rid + " doesn't have a corresponding MethodDefHandle");
}
}
private IEnumerable <VerificationResult> VerifyAssembly(PEReader peReader)
{
MetadataReader metadataReader = peReader.GetMetadataReader();
foreach (var methodHandle in metadataReader.MethodDefinitions)
{
var methodName = metadataReader.GetString(metadataReader.GetMethodDefinition(methodHandle).Name);
if (ShouldVerifyMethod(methodName))
{
var results = _verifier.Verify(peReader, methodHandle);
foreach (var result in results)
{
yield return(result);
}
}
}
}
public bool TryGetMethodInfo(int methodDefinitionToken, [NotNullWhen(true)] out string?methodName, out int declaringTypeToken)
{
var handle = (MethodDefinitionHandle)MetadataTokens.Handle(methodDefinitionToken);
if (handle.IsNil)
{
methodName = null;
declaringTypeToken = 0;
return(false);
}
var methodDefinition = _reader.GetMethodDefinition(handle);
methodName = _reader.GetString(methodDefinition.Name);
declaringTypeToken = MetadataTokens.GetToken(methodDefinition.GetDeclaringType());
return(true);
}
private ConstructorInfo GetConstructor()
{
if (_constructor != null)
{
return(_constructor);
}
if (Definition.Constructor.Kind == HandleKind.MethodDefinition)
{
MethodDefinition definition = _metadata.GetMethodDefinition(
(MethodDefinitionHandle)Definition.Constructor);
MetadataType type = MetadataDomain.GetMetadataType(
_metadata,
definition.GetDeclaringType());
return(type.GetMetadataConstructor(
MetadataTokens.GetToken(
_metadata,
Definition.Constructor)));
}
MemberReference methodRef = _metadata.GetMemberReference(
(MemberReferenceHandle)Definition.Constructor);
MetadataType parent = MetadataDomain.GetMetadataType(_metadata, methodRef.Parent);
var signature = methodRef.DecodeMethodSignature(
new MetadataSignatureProvider(),
new GenericContext()
{
DeclaringType = parent
});
ParameterModifier[] parameterModifier =
signature.ParameterTypes.Length == 0
? Empty <ParameterModifier> .Array
: new[] { new ParameterModifier(signature.RequiredParameterCount) };
return(_constructor = parent.GetMetadataConstructor(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null,
default(CallingConventions),
signature.ParameterTypes.ToArray(),
parameterModifier));
}
/// <summary>
/// Check if the attribute type name is what we expected.
/// </summary>
private static bool IsAttributeOfType(MetadataReader reader, CustomAttribute customAttribute, string expectedTypeName)
{
string attributeFullName = null;
switch (customAttribute.Constructor.Kind)
{
case HandleKind.MethodDefinition:
// Attribute is defined in the same module
MethodDefinition methodDef = reader.GetMethodDefinition((MethodDefinitionHandle)customAttribute.Constructor);
TypeDefinitionHandle declaringTypeDefHandle = methodDef.GetDeclaringType();
if (declaringTypeDefHandle.IsNil) /* Global method */ return {
(false);
}
TypeDefinition declaringTypeDef = reader.GetTypeDefinition(declaringTypeDefHandle);
attributeFullName = GetTypeFullName(reader, declaringTypeDef);
break;
case HandleKind.MemberReference:
MemberReference memberRef = reader.GetMemberReference((MemberReferenceHandle)customAttribute.Constructor);
switch (memberRef.Parent.Kind)
{
case HandleKind.TypeReference:
TypeReference typeRef = reader.GetTypeReference((TypeReferenceHandle)memberRef.Parent);
attributeFullName = GetTypeFullName(reader, typeRef);
break;
case HandleKind.TypeDefinition:
TypeDefinition typeDef = reader.GetTypeDefinition((TypeDefinitionHandle)memberRef.Parent);
attributeFullName = GetTypeFullName(reader, typeDef);
break;
default:
// constructor is global method, vararg method, or from a generic type.
return(false);
}
break;
default:
throw new BadImageFormatException("Invalid custom attribute.");
}
return(string.Equals(attributeFullName, expectedTypeName, StringComparison.Ordinal));
}
private static MethodDefinitionHandle GetTokenForMethod(MetadataReader metadataReader, string methodName)
{
Assert.NotNull(methodName);
Assert.NotEmpty(methodName);
foreach (var methodDef in metadataReader.MethodDefinitions)
{
string name = metadataReader.GetString(metadataReader.GetMethodDefinition(methodDef).Name);
if (methodName.Equals(name))
{
return methodDef;
}
}
AssertEx.Fail("Unable to find method:" + methodName);
return default(MethodDefinitionHandle);
}
public void WrongSignatureType()
{
using (FileStream stream = File.OpenRead(AssemblyPathHelper.GetAssemblyLocation(typeof(VarArgsToDecode).GetTypeInfo().Assembly)))
using (var peReader = new PEReader(stream))
{
MetadataReader reader = peReader.GetMetadataReader();
var provider = new DisassemblingTypeProvider();
var decoder = new SignatureDecoder <string, DisassemblingGenericContext>(provider, reader, genericContext: null);
BlobReader fieldSignature = reader.GetBlobReader(reader.GetFieldDefinition(MetadataTokens.FieldDefinitionHandle(1)).Signature);
BlobReader methodSignature = reader.GetBlobReader(reader.GetMethodDefinition(MetadataTokens.MethodDefinitionHandle(1)).Signature);
BlobReader propertySignature = reader.GetBlobReader(reader.GetPropertyDefinition(MetadataTokens.PropertyDefinitionHandle(1)).Signature);
Assert.Throws <BadImageFormatException>(() => decoder.DecodeMethodSignature(ref fieldSignature));
Assert.Throws <BadImageFormatException>(() => decoder.DecodeFieldSignature(ref methodSignature));
Assert.Throws <BadImageFormatException>(() => decoder.DecodeLocalSignature(ref propertySignature));
}
}
private static int GetMethodCount(MetadataReader reader, TypeDefinition type)
{
var count = 0;
foreach (var handle in type.GetMethods())
{
var methodDefinition = reader.GetMethodDefinition(handle);
if (methodDefinition.GetCustomAttributes().Count == 0 ||
!IsValidIdentifier(reader, methodDefinition.Name))
{
continue;
}
count++;
}
return(count);
}
public override PInvokeMetadata GetPInvokeMethodMetadata()
{
if (!IsPInvoke)
{
return(default(PInvokeMetadata));
}
MetadataReader metadataReader = MetadataReader;
MethodImport import = metadataReader.GetMethodDefinition(_handle).GetImport();
string name = metadataReader.GetString(import.Name);
// Spot check the enums match
Debug.Assert((int)MethodImportAttributes.CallingConventionStdCall == (int)PInvokeAttributes.CallingConventionStdCall);
Debug.Assert((int)MethodImportAttributes.CharSetAuto == (int)PInvokeAttributes.CharSetAuto);
Debug.Assert((int)MethodImportAttributes.CharSetUnicode == (int)PInvokeAttributes.CharSetUnicode);
return(new PInvokeMetadata(name, (PInvokeAttributes)import.Attributes));
}
public MethodInfo(AssemblyInfo assembly, MethodDefinitionHandle methodDefHandle, int token, SourceFile source, TypeInfo type, MetadataReader asmMetadataReader, MetadataReader pdbMetadataReader)
{
this.IsAsync = -1;
this.Assembly = assembly;
this.methodDef = asmMetadataReader.GetMethodDefinition(methodDefHandle);
this.DebugInformation = pdbMetadataReader.GetMethodDebugInformation(methodDefHandle.ToDebugInformationHandle());
this.source = source;
this.Token = token;
this.methodDefHandle = methodDefHandle;
this.Name = asmMetadataReader.GetString(methodDef.Name);
this.pdbMetadataReader = pdbMetadataReader;
this.IsEnCMethod = false;
if (!DebugInformation.SequencePointsBlob.IsNil)
{
var sps = DebugInformation.GetSequencePoints();
SequencePoint start = sps.First();
SequencePoint end = sps.First();
foreach (SequencePoint sp in sps)
{
if (sp.StartLine < start.StartLine)
{
start = sp;
}
else if (sp.StartLine == start.StartLine && sp.StartColumn < start.StartColumn)
{
start = sp;
}
if (sp.EndLine > end.EndLine)
{
end = sp;
}
else if (sp.EndLine == end.EndLine && sp.EndColumn > end.EndColumn)
{
end = sp;
}
}
StartLocation = new SourceLocation(this, start);
EndLocation = new SourceLocation(this, end);
}
localScopes = pdbMetadataReader.GetLocalScopes(methodDefHandle);
}
/// <summary>
/// Emit a method definition.
/// </summary>
/// <param name="methodSpecHandle">Method definition handle</param>
private string EmitMethodDefinitionName(MethodDefinitionHandle methodDefinitionHandle, string owningTypeOverride)
{
MethodDefinition methodDef = _metadataReader.GetMethodDefinition(methodDefinitionHandle);
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(Array.Empty <string>(), Array.Empty <string>());
MethodSignature <string> methodSig = methodDef.DecodeSignature <string, DisassemblingGenericContext>(this, genericContext);
StringBuilder builder = new StringBuilder();
builder.Append(methodSig.ReturnType);
builder.Append(" ");
if (owningTypeOverride == null)
{
owningTypeOverride = EmitHandleName(methodDef.GetDeclaringType(), namespaceQualified: false, owningTypeOverride: null);
}
builder.Append(owningTypeOverride);
builder.Append(".");
builder.Append(EmitString(methodDef.Name));
builder.Append(EmitMethodSignature(methodSig));
return(builder.ToString());
}
internal ImportedMethod ResolveMethod(MethodDefinitionHandle handle, ImportedType declaringType = null)
{
ImportedMethod method;
if (!_resolvedMethods.TryGetValue(handle, out method))
{
MethodDefinition methodDef = _reader.GetMethodDefinition(handle);
if (declaringType == null)
{
declaringType = ResolveType(methodDef.GetDeclaringType());
}
var name = methodDef.Name;
var strName = this.Reader.GetString(name);
method = new ImportedMethod(this, methodDef, declaringType);
_resolvedMethods.Add(handle, method);
}
return(method);
}
internal sealed override IEnumerable <MethodInfo> CoreGetDeclaredMethods(NameFilter optionalNameFilter, RuntimeTypeInfo reflectedType, RuntimeTypeInfo contextTypeInfo)
{
MetadataReader reader = Reader;
foreach (MethodDefinitionHandle methodHandle in DeclaredMethodAndConstructorHandles)
{
MethodDefinition method = reader.GetMethodDefinition(methodHandle);
if (EcmaMetadataHelpers.IsConstructor(ref method, reader))
{
continue;
}
if (optionalNameFilter == null || optionalNameFilter.Matches(method.Name, reader))
{
yield return(RuntimeNamedMethodInfo <EcmaFormatMethodCommon> .GetRuntimeNamedMethodInfo(new EcmaFormatMethodCommon(methodHandle, this, contextTypeInfo), reflectedType));
}
}
}
// tools for loading headers based on attributes in compiled C# code (early setup for shipping Q# libraries)
/// <summary>
/// There are two possible handle kinds in use for the constructor of a custom attribute,
/// one pointing to the MethodDef table and one to the MemberRef table, see p.216 in the ECMA standard linked above and
/// https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeSystem/CustomAttribute.cs#L42
/// This routine extracts the namespace and type name of the given attribute and returns the corresponding string handles.
/// Returns null if the constructor handle is not a MethodDefinition or a MemberDefinition.
/// </summary>
private static (StringHandle, StringHandle)? GetAttributeType(MetadataReader metadataReader, CustomAttribute attribute)
{
if (attribute.Constructor.Kind == HandleKind.MethodDefinition)
{
var ctor = metadataReader.GetMethodDefinition((MethodDefinitionHandle)attribute.Constructor);
var type = metadataReader.GetTypeDefinition(ctor.GetDeclaringType());
return(type.Namespace, type.Name);
}
else if (attribute.Constructor.Kind == HandleKind.MemberReference)
{
var ctor = metadataReader.GetMemberReference((MemberReferenceHandle)attribute.Constructor);
var type = metadataReader.GetTypeReference((TypeReferenceHandle)ctor.Parent);
return(type.Namespace, type.Name);
}
else
{
return(null);
}
}
// The only purpose of this method is to get type name of the method and declaring type token (opaque for SymWriter), everything else is ignored by the SymWriter.
// "mb" is the token passed to OpenMethod. The token is remembered until the corresponding CloseMethod, which passes it to GetMethodProps.
// It's opaque for SymWriter.
public unsafe int GetMethodProps(
int methodDefinition,
out int declaringTypeDefinition,
[Out] char *nameBuffer,
int nameBufferLength,
out int nameLength,
[Out] ushort *attributes,
[Out] byte *signature,
[Out] int *signatureLength,
[Out] int *relativeVirtualAddress,
[Out] ushort *implAttributes)
{
Debug.Assert(nameBuffer != null);
Debug.Assert(attributes == null);
Debug.Assert(signature == null);
Debug.Assert(signatureLength == null);
Debug.Assert(relativeVirtualAddress == null);
Debug.Assert(implAttributes == null);
MetadataRequired();
var handle = (MethodDefinitionHandle)MetadataTokens.Handle(methodDefinition);
var methodDef = _metadataReaderOpt.GetMethodDefinition(handle);
string methodName = _metadataReaderOpt.GetString(methodDef.Name);
// if the buffer is too small to fit the name, truncate the name
int nameLengthIncludingNull = Math.Min(methodName.Length + 1, nameBufferLength);
// return the length of the name not including NUL
nameLength = nameLengthIncludingNull - 1;
int methodNameByteCount = nameLengthIncludingNull * sizeof(char);
fixed(char *methodNamePtr = methodName)
{
Buffer.MemoryCopy(methodNamePtr, nameBuffer, methodNameByteCount, methodNameByteCount);
}
declaringTypeDefinition = MetadataTokens.GetToken(methodDef.GetDeclaringType());
return(0);
}
private void ComputeGenericParameters()
{
var genericParameterHandles = MetadataReader.GetMethodDefinition(_handle).GetGenericParameters();
int count = genericParameterHandles.Count;
if (count > 0)
{
TypeDesc[] genericParameters = new TypeDesc[count];
int i = 0;
foreach (var genericParameterHandle in genericParameterHandles)
{
genericParameters[i++] = new EcmaGenericParameter(Module, genericParameterHandle);
}
Interlocked.CompareExchange(ref _genericParameters, genericParameters, null);
}
else
{
_genericParameters = TypeDesc.EmptyTypes;
}
}
private void WalkProperty(MetadataReader mdReader, PropertyDefinitionHandle handle, MutableSymbol parent)
{
PropertyDefinition prop = mdReader.GetPropertyDefinition(handle);
MutableSymbol result = new MutableSymbol(mdReader.GetString(prop.Name), SymbolType.Property);
// Use the accessibility and location of the getter [or setter, if write only property]
// Not identical to Roslyn PEPropertyDeclaration but much simpler
MethodDefinitionHandle getterOrSetterHandle = prop.GetAccessors().Getter;
if (getterOrSetterHandle.IsNil)
{
getterOrSetterHandle = prop.GetAccessors().Setter;
}
// If we couldn't retrieve a getter or setter, exclude this property
if (getterOrSetterHandle.IsNil)
{
return;
}
MethodDefinition getterOrSetter = mdReader.GetMethodDefinition(getterOrSetterHandle);
AddModifiers(getterOrSetter.Attributes, result);
AddLocation(getterOrSetterHandle, result);
AddParameters(mdReader, getterOrSetter, result);
// If this is an Indexer, rename it and retype it
// Roslyn PEPropertySymbol.IsIndexer is also just based on the name.
if (result.Name == "Item")
{
result.Name = "this[]";
result.Type = SymbolType.Indexer;
}
if (IsExcluded(result))
{
return;
}
parent.AddChild(result);
}
//<SnippetPrintMethods>
static void PrintMethods(PEReader reader, MetadataReader mr, TypeDefinition tdef)
{
MethodDefinitionHandleCollection methods = tdef.GetMethods();
foreach (MethodDefinitionHandle mdefh in methods)
{
MethodDefinition mdef = mr.GetMethodDefinition(mdefh);
string mname = mr.GetString(mdef.Name);
Console.WriteLine($"Method: {mname}");
// Get the relative address of the method body in the executable
int rva = mdef.RelativeVirtualAddress;
if (rva == 0)
{
Console.WriteLine("Method body not found");
Console.WriteLine();
continue;
}
// Get method body information
MethodBodyBlock mb = reader.GetMethodBody(rva);
Console.WriteLine($" Maximum stack size: {mb.MaxStack}");
Console.WriteLine($" Local variables initialized: {mb.LocalVariablesInitialized}");
byte[] il = mb.GetILBytes();
Console.WriteLine($" Method body size: {il.Length}");
Console.WriteLine($" Exception regions: {mb.ExceptionRegions.Length}");
Console.WriteLine();
foreach (var region in mb.ExceptionRegions)
{
Console.WriteLine(region.Kind.ToString());
Console.WriteLine($" Try block offset: {region.TryOffset}");
Console.WriteLine($" Try block length: {region.TryLength}");
Console.WriteLine($" Handler offset: {region.HandlerOffset}");
Console.WriteLine($" Handler length: {region.HandlerLength}");
Console.WriteLine();
}
}
}
private static string DumpRec(this MetadataReader reader, EntityHandle handle)
{
switch (handle.Kind)
{
case HandleKind.AssemblyReference:
return(reader.GetString(reader.GetAssemblyReference((AssemblyReferenceHandle)handle).Name));
case HandleKind.TypeDefinition:
return(reader.GetString(reader.GetTypeDefinition((TypeDefinitionHandle)handle).Name));
case HandleKind.MethodDefinition:
{
var method = reader.GetMethodDefinition((MethodDefinitionHandle)handle);
var blob = reader.GetBlobReader(method.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {reader.GetString(method.Name)}({parameters})");
}
case HandleKind.MemberReference:
{
var member = reader.GetMemberReference((MemberReferenceHandle)handle);
var blob = reader.GetBlobReader(member.Signature);
var decoder = new SignatureDecoder <string, object>(ConstantSignatureVisualizer.Instance, reader, genericContext: null);
var signature = decoder.DecodeMethodSignature(ref blob);
var parameters = signature.ParameterTypes.Join(", ");
return($"{signature.ReturnType} {DumpRec(reader, member.Parent)}{reader.GetString(member.Name)}({parameters})");
}
case HandleKind.TypeReference:
{
var type = reader.GetTypeReference((TypeReferenceHandle)handle);
return($"{reader.GetString(type.Namespace)}.{reader.GetString(type.Name)}");
}
default:
return(null);
}
}
/// <summary>Gets the string argument value of an attribute with a single fixed string argument.</summary>
/// <param name="reader">The metadata reader.</param>
/// <param name="attr">The attribute.</param>
/// <param name="value">The value parsed from the attribute, if it could be retrieved; otherwise, the value is left unmodified.</param>
private static void GetStringAttributeArgumentValue(MetadataReader reader, CustomAttribute attr, ref string?value)
{
EntityHandle ctorHandle = attr.Constructor;
BlobHandle signature;
switch (ctorHandle.Kind)
{
case HandleKind.MemberReference:
signature = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Signature;
break;
case HandleKind.MethodDefinition:
signature = reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle).Signature;
break;
default:
// Unusual case, potentially invalid IL
return;
}
BlobReader signatureReader = reader.GetBlobReader(signature);
BlobReader valueReader = reader.GetBlobReader(attr.Value);
const ushort Prolog = 1; // two-byte "prolog" defined by ECMA-335 (II.23.3) to be at the beginning of attribute value blobs
if (valueReader.ReadUInt16() == Prolog)
{
SignatureHeader header = signatureReader.ReadSignatureHeader();
int parameterCount;
if (header.Kind == SignatureKind.Method && // attr ctor must be a method
!header.IsGeneric && // attr ctor must be non-generic
signatureReader.TryReadCompressedInteger(out parameterCount) && // read parameter count
parameterCount == 1 && // attr ctor must have 1 parameter
signatureReader.ReadSignatureTypeCode() == SignatureTypeCode.Void && // attr ctor return type must be void
signatureReader.ReadSignatureTypeCode() == SignatureTypeCode.String) // attr ctor first parameter must be string
{
value = valueReader.ReadSerializedString();
}
}
}
/// <summary>
/// Given a token for a constructor, return the token for the constructor's type and the blob containing the
/// constructor's signature.
/// </summary>
public static void GetAttributeTypeDefRefOrSpecHandle(
MetadataReader metadataReader,
EntityHandle attributeCtor,
out EntityHandle ctorType)
{
ctorType = default(EntityHandle);
if (attributeCtor.Kind == HandleKind.MemberReference)
{
MemberReference memberRef = metadataReader.GetMemberReference((MemberReferenceHandle)attributeCtor);
StringHandle ctorName = memberRef.Name;
if (!metadataReader.StringComparer.Equals(ctorName, ConstructorInfo.ConstructorName))
{
// Not a constructor.
throw new BadImageFormatException();
}
ctorType = memberRef.Parent;
}
else if (attributeCtor.Kind == HandleKind.MethodDefinition)
{
var methodDef = metadataReader.GetMethodDefinition((MethodDefinitionHandle)attributeCtor);
if (!metadataReader.StringComparer.Equals(methodDef.Name, ConstructorInfo.ConstructorName))
{
// Not a constructor.
throw new BadImageFormatException();
}
ctorType = methodDef.GetDeclaringType();
Debug.Assert(!ctorType.IsNil);
}
else
{
// invalid metadata
throw new BadImageFormatException();
}
}
public static bool GetAttributeTypeAndConstructor(this MetadataReader metadataReader, CustomAttributeHandle attributeHandle,
out EntityHandle attributeType, out EntityHandle attributeCtor)
{
attributeCtor = metadataReader.GetCustomAttribute(attributeHandle).Constructor;
if (attributeCtor.Kind == HandleKind.MemberReference)
{
attributeType = metadataReader.GetMemberReference((MemberReferenceHandle)attributeCtor).Parent;
return(true);
}
else if (attributeCtor.Kind == HandleKind.MethodDefinition)
{
attributeType = metadataReader.GetMethodDefinition((MethodDefinitionHandle)attributeCtor).GetDeclaringType();
return(true);
}
else
{
// invalid metadata
attributeType = default(EntityHandle);
return(false);
}
}
public static string GetCustomAttributeName(this MetadataReader reader, CustomAttributeRow row)
{
EntityHandle parent;
var token = row.ConstructorToken;
switch (token.Kind)
{
case HandleKind.MemberReference:
parent = reader.GetMemberReference((MemberReferenceHandle)token).Parent;
break;
case HandleKind.MethodDefinition:
parent = reader.GetMethodDefinition((MethodDefinitionHandle)token).GetDeclaringType();
break;
default:
throw ExceptionUtilities.UnexpectedValue(token.Kind);
}
var strHandle = reader.GetName(parent);
return(reader.GetString(strHandle));
}
internal static string SolveMethodName(MetadataReader metadataReader, int token, CilTypeProvider provider)
{
string genericParameters = string.Empty;
if (IsMethodSpecification(token))
{
var methodHandle = MetadataTokens.MethodSpecificationHandle(token);
var methodSpec = metadataReader.GetMethodSpecification(methodHandle);
token = MetadataTokens.GetToken(methodSpec.Method);
genericParameters = GetGenericParametersSignature(methodSpec, provider);
}
if (IsMemberReference(token))
{
return GetMemberRef(metadataReader, token, provider, genericParameters);
}
var handle = MetadataTokens.MethodDefinitionHandle(token);
var definition = metadataReader.GetMethodDefinition(handle);
var parent = definition.GetDeclaringType();
MethodSignature<CilType> signature = SignatureDecoder.DecodeMethodSignature(definition.Signature, provider);
var returnType = GetMethodReturnType(signature);
var parameters = provider.GetParameterList(signature);
var parentType = SignatureDecoder.DecodeType(parent, provider, null);
return string.Format("{0} {1}::{2}{3}{4}",returnType, parentType.ToString(false), GetString(metadataReader, definition.Name), genericParameters, parameters);
}
internal static string DecodeOverridenMethodName(MetadataReader metadataReader, int token, CilTypeProvider provider)
{
var handle = MetadataTokens.MethodDefinitionHandle(token);
var definition = metadataReader.GetMethodDefinition(handle);
var parent = definition.GetDeclaringType();
MethodSignature<CilType> signature = SignatureDecoder.DecodeMethodSignature(definition.Signature, provider);
var parentType = SignatureDecoder.DecodeType(parent, provider, null);
return string.Format("{0}::{1}", parentType.ToString(false), GetString(metadataReader, definition.Name));
}
