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));
}
/// <summary>
/// Emit a method specification.
/// </summary>
/// <param name="methodSpecHandle">Method specification handle</param>
private string EmitMethodSpecificationName(MethodSpecificationHandle methodSpecHandle)
{
MethodSpecification methodSpec = _metadataReader.GetMethodSpecification(methodSpecHandle);
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(Array.Empty <string>(), Array.Empty <string>());
return(EmitHandleName(methodSpec.Method, namespaceQualified: true) + methodSpec.DecodeSignature <string, DisassemblingGenericContext>(this, genericContext));
}
private Object ResolveMethodSpecification(MethodSpecificationHandle handle)
{
MethodSpecification methodSpecification = _metadataReader.GetMethodSpecification(handle);
object resolvedMethod = GetObject(methodSpecification.Method, NotFoundBehavior.ReturnResolutionFailure);
if (resolvedMethod is ResolutionFailure)
{
return(resolvedMethod);
}
MethodDesc methodDef = resolvedMethod as MethodDesc;
if (methodDef == null)
{
ThrowHelper.ThrowBadImageFormatException($"method expected for handle {handle.ToString()}");
}
BlobReader signatureReader = _metadataReader.GetBlobReader(methodSpecification.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure);
TypeDesc[] instantiation = parser.ParseMethodSpecSignature();
if (instantiation == null)
{
return(parser.ResolutionFailure);
}
return(Context.GetInstantiatedMethod(methodDef, new Instantiation(instantiation)));
}
public static bool IsPossibleReferenceTo(EntityHandle member, PEFile module, IMethod analyzedMethod)
{
if (member.IsNil)
{
return(false);
}
MetadataReader metadata = module.Metadata;
switch (member.Kind)
{
case HandleKind.MethodDefinition:
return(member == analyzedMethod.MetadataToken &&
module == analyzedMethod.ParentModule.PEFile);
case HandleKind.MemberReference:
var mr = metadata.GetMemberReference((MemberReferenceHandle)member);
if (mr.GetKind() != MemberReferenceKind.Method)
{
return(false);
}
return(metadata.StringComparer.Equals(mr.Name, analyzedMethod.Name));
case HandleKind.MethodSpecification:
var ms = metadata.GetMethodSpecification((MethodSpecificationHandle)member);
return(IsPossibleReferenceTo(ms.Method, module, analyzedMethod));
default:
return(false);
}
}
public MethodSpecEntry(PEFile module, MethodSpecificationHandle handle)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.methodSpec = metadata.GetMethodSpecification(handle);
}
private Object ResolveMethodSpecification(MethodSpecificationHandle handle)
{
MethodSpecification methodSpecification = _metadataReader.GetMethodSpecification(handle);
MethodDesc methodDef = GetMethod(methodSpecification.Method);
BlobReader signatureReader = _metadataReader.GetBlobReader(methodSpecification.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader);
TypeDesc[] instantiation = parser.ParseMethodSpecSignature();
return(Context.GetInstantiatedMethod(methodDef, new Instantiation(instantiation)));
}
protected override MethodImplRecord[] ComputeVirtualMethodImplsForType()
{
ArrayBuilder <MethodImplRecord> records = new ArrayBuilder <MethodImplRecord>();
MetadataReader metadataReader = _module.MetadataReader;
foreach (var methodImplHandle in _typeDefinition.GetMethodImplementations())
{
MethodImplementation methodImpl = metadataReader.GetMethodImplementation(methodImplHandle);
EntityHandle methodDeclCheckHandle = methodImpl.MethodDeclaration;
HandleKind methodDeclHandleKind = methodDeclCheckHandle.Kind;
// We want to check that the type is not an interface matches before actually getting the MethodDesc.
// For MethodSpecifications we need to dereference that handle to the underlying member reference to
// look at the owning type.
if (methodDeclHandleKind == HandleKind.MethodSpecification)
{
methodDeclCheckHandle = metadataReader.GetMethodSpecification((MethodSpecificationHandle)methodDeclCheckHandle).Method;
methodDeclHandleKind = methodDeclCheckHandle.Kind;
}
MetadataType owningType = null;
switch (methodDeclHandleKind)
{
case HandleKind.MethodDefinition:
owningType = ((MethodDesc)_module.GetObject(methodDeclCheckHandle)).OwningType as MetadataType;
break;
case HandleKind.MemberReference:
EntityHandle owningTypeHandle = metadataReader.GetMemberReference((MemberReferenceHandle)methodDeclCheckHandle).Parent;
owningType = _module.GetObject(owningTypeHandle) as MetadataType;
break;
default:
Debug.Fail("unexpected methodDeclHandleKind");
break;
}
if (!owningType.IsInterface)
{
MethodImplRecord newRecord = new MethodImplRecord(
(MethodDesc)_module.GetObject(methodImpl.MethodDeclaration),
(MethodDesc)_module.GetObject(methodImpl.MethodBody));
records.Add(newRecord);
}
}
return(records.ToArray());
}
IMethod ResolveMethodSpecification(MethodSpecificationHandle methodSpecHandle, GenericContext context, bool expandVarArgs)
{
var methodSpec = metadata.GetMethodSpecification(methodSpecHandle);
var methodTypeArgs = methodSpec.DecodeSignature(TypeProvider, context)
.SelectReadOnlyArray(IntroduceTupleTypes);
IMethod method;
if (methodSpec.Method.Kind == HandleKind.MethodDefinition)
{
// generic instance of a methoddef (=generic method in non-generic class in current assembly)
method = ResolveMethodDefinition((MethodDefinitionHandle)methodSpec.Method, expandVarArgs);
method = method.Specialize(new TypeParameterSubstitution(null, methodTypeArgs));
}
else
{
method = ResolveMethodReference((MemberReferenceHandle)methodSpec.Method, context, methodTypeArgs, expandVarArgs);
}
return(method);
}
private void WriteMethodSpec()
{
AddHeader(
"Method",
"Signature"
);
for (int i = 1, count = reader.GetTableRowCount(TableIndex.MethodSpec); i <= count; i++)
{
var entry = reader.GetMethodSpecification(MetadataTokens.MethodSpecificationHandle(i));
AddRow(
Token(entry.Method),
Literal(entry.Signature)
);
}
WriteRows("MethodSpec (0x2b):");
}
// Virtual function related functionality
public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(string declName)
{
MetadataReader metadataReader = _module.MetadataReader;
var stringComparer = metadataReader.StringComparer;
ArrayBuilder <MethodImplRecord> foundRecords = new ArrayBuilder <MethodImplRecord>();
foreach (var methodImplHandle in _typeDefinition.GetMethodImplementations())
{
MethodImplementation methodImpl = metadataReader.GetMethodImplementation(methodImplHandle);
EntityHandle methodDeclCheckHandle = methodImpl.MethodDeclaration;
HandleKind methodDeclHandleKind = methodDeclCheckHandle.Kind;
// We want to check that the method name matches before actually getting the MethodDesc. For MethodSpecifications
// we need to dereference that handle to the underlying member reference to look at name matching.
if (methodDeclHandleKind == HandleKind.MethodSpecification)
{
methodDeclCheckHandle = metadataReader.GetMethodSpecification((MethodSpecificationHandle)methodDeclCheckHandle).Method;
methodDeclHandleKind = methodDeclCheckHandle.Kind;
}
bool foundRecord = false;
switch (methodDeclHandleKind)
{
case HandleKind.MethodDefinition:
if (stringComparer.Equals(metadataReader.GetMethodDefinition((MethodDefinitionHandle)methodDeclCheckHandle).Name, declName))
{
foundRecord = true;
}
break;
case HandleKind.MemberReference:
if (stringComparer.Equals(metadataReader.GetMemberReference((MemberReferenceHandle)methodDeclCheckHandle).Name, declName))
{
foundRecord = true;
}
break;
default:
Debug.Fail("unexpected methodDeclHandleKind");
break;
}
if (foundRecord)
{
MethodImplRecord newRecord = new MethodImplRecord(
(MethodDesc)_module.GetObject(methodImpl.MethodDeclaration),
(MethodDesc)_module.GetObject(methodImpl.MethodBody));
foundRecords.Add(newRecord);
}
}
if (foundRecords.Count != 0)
{
return(foundRecords.ToArray());
}
return(null);
}
public static MethodSpecification GetMethodSpecification(this MethodSpecificationHandle handle, MetadataReader reader) => reader.GetMethodSpecification(handle);
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);
}
