public (SignatureHeader, FunctionPointerType) DecodeMethodSignature(StandaloneSignatureHandle handle, GenericContext genericContext)
{
var standaloneSignature = metadata.GetStandaloneSignature(handle);
if (standaloneSignature.GetKind() != StandaloneSignatureKind.Method)
{
throw new BadImageFormatException("Expected Method signature");
}
var sig = standaloneSignature.DecodeMethodSignature(TypeProvider, genericContext);
var fpt = FunctionPointerType.FromSignature(sig, this);
return(sig.Header, (FunctionPointerType)IntroduceTupleTypes(fpt));
}
/// <summary>
/// Get the types of the local variables given the metadata token for the local variable
/// signature. This method is used for debugging support.
/// </summary>
/// <param name="mdToken">Local variable signature metadata token</param>
/// <returns>Immutable array of local variable types. The types are ordered by the local slot number</returns>
public ImmutableArray <IrisType> DecodeLocalVariableTypes(int mdToken)
{
StandaloneSignatureHandle localVarSigHandle = (StandaloneSignatureHandle)MetadataTokens.EntityHandle(mdToken);
StandaloneSignature sig = _reader.GetStandaloneSignature(localVarSigHandle);
return(sig.DecodeLocalSignature(IrisTypeProvider, genericContext: null));
}
public void PinnedAndUnpinnedLocals()
{
using (FileStream stream = File.OpenRead(AssemblyPathHelper.GetAssemblyLocation(typeof(PinnedAndUnpinnedLocalsToDecode).GetTypeInfo().Assembly)))
using (var peReader = new PEReader(stream))
{
MetadataReader reader = peReader.GetMetadataReader();
var provider = new DisassemblingTypeProvider();
TypeDefinitionHandle typeDefHandle = TestMetadataResolver.FindTestType(reader, typeof(PinnedAndUnpinnedLocalsToDecode));
TypeDefinition typeDef = reader.GetTypeDefinition(typeDefHandle);
MethodDefinition methodDef = reader.GetMethodDefinition(typeDef.GetMethods().First());
Assert.Equal("DoSomething", reader.GetString(methodDef.Name));
MethodBodyBlock body = peReader.GetMethodBody(methodDef.RelativeVirtualAddress);
StandaloneSignature localSignature = reader.GetStandaloneSignature(body.LocalSignature);
ImmutableArray <string> localTypes = localSignature.DecodeLocalSignature(provider, genericContext: null);
// Compiler can generate temporaries or re-order so just check the ones we expect are there.
// (They could get optimized away too. If that happens in practice, change this test to use hard-coded signatures.)
Assert.Contains("uint8[] pinned", localTypes);
Assert.Contains("uint8[]", localTypes);
}
}
public unsafe int GetSigFromToken(
int tkSignature, // Signature token.
out byte *ppvSig, // return pointer to signature blob
out int pcbSig
) // return size of signature
{
if (_metadataReaderOpt == null)
{
throw new NotSupportedException("Metadata not available");
}
var sig = _metadataReaderOpt.GetStandaloneSignature(
(StandaloneSignatureHandle)MetadataTokens.Handle(tkSignature)
);
var signature = _metadataReaderOpt.GetBlobBytes(sig.Signature);
GCHandle pinnedBuffer = GCHandle.Alloc(signature, GCHandleType.Pinned);
ppvSig = (byte *)pinnedBuffer.AddrOfPinnedObject();
pcbSig = signature.Length;
#pragma warning disable RS0042 // Do not copy value
_pinnedBuffers.Add(pinnedBuffer);
#pragma warning restore RS0042 // Do not copy value
return(0);
}
public StandAloneSigEntry(PEFile module, StandaloneSignatureHandle handle)
{
this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
this.module = module;
this.metadata = module.Metadata;
this.handle = handle;
this.standaloneSig = metadata.GetStandaloneSignature(handle);
}
private Object ResolveStandaloneSignature(StandaloneSignatureHandle handle)
{
StandaloneSignature signature = _metadataReader.GetStandaloneSignature(handle);
BlobReader signatureReader = _metadataReader.GetBlobReader(signature.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader);
MethodSignature methodSig = parser.ParseMethodSignature();
return(methodSig);
}
void DisassembleLocalsBlock(MethodDefinitionHandle method, MethodBodyBlock body)
{
if (body.LocalSignature.IsNil)
{
return;
}
output.Write(".locals");
WriteMetadataToken(body.LocalSignature, spaceBefore: true);
if (body.LocalVariablesInitialized)
{
output.Write(" init");
}
var blob = metadata.GetStandaloneSignature(body.LocalSignature);
var signature = ImmutableArray <Action <ILNameSyntax> > .Empty;
try
{
if (blob.GetKind() == StandaloneSignatureKind.LocalVariables)
{
signature = blob.DecodeLocalSignature(signatureDecoder, genericContext);
}
else
{
output.Write(" /* wrong signature kind */");
}
}
catch (BadImageFormatException ex)
{
output.Write($" /* {ex.Message} */");
}
output.Write(' ');
output.WriteLine("(");
output.Indent();
int index = 0;
foreach (var v in signature)
{
output.WriteLocalReference("[" + index + "]", "loc_" + index, isDefinition: true);
output.Write(' ');
v(ILNameSyntax.TypeName);
if (DebugInfo != null && DebugInfo.TryGetName(method, index, out var name))
{
output.Write(" " + DisassemblerHelpers.Escape(name));
}
if (index + 1 < signature.Length)
{
output.Write(',');
}
output.WriteLine();
index++;
}
output.Unindent();
output.WriteLine(")");
}
public unsafe int GetSigFromToken(int tkSignature, out byte *ppvSig, out int pcbSig)
{
var signatureHandle = (StandaloneSignatureHandle)MetadataTokens.Handle(tkSignature);
var bytes = MetadataReader.GetBlobBytes(MetadataReader.GetStandaloneSignature(signatureHandle).Signature);
var pinned = GCHandle.Alloc(bytes, GCHandleType.Pinned);
ppvSig = (byte *)pinned.AddrOfPinnedObject();
pcbSig = bytes.Length;
return(HResult.S_OK);
}
public MethodSignature <IType> DecodeMethodSignature(StandaloneSignatureHandle handle, GenericContext genericContext)
{
var standaloneSignature = metadata.GetStandaloneSignature(handle);
if (standaloneSignature.GetKind() != StandaloneSignatureKind.Method)
{
throw new BadImageFormatException("Expected Method signature");
}
var sig = standaloneSignature.DecodeMethodSignature(TypeProvider, genericContext);
return(new MethodSignature <IType>(
sig.Header,
IntroduceTupleTypes(sig.ReturnType),
sig.RequiredParameterCount,
sig.GenericParameterCount,
ImmutableArray.CreateRange(
sig.ParameterTypes, IntroduceTupleTypes
)
));
}
private static string GetSignature(MetadataReader metadataReader, int intOperand, CilTypeProvider provider)
{
if (IsStandaloneSignature(intOperand))
{
var handle = MetadataTokens.StandaloneSignatureHandle(intOperand);
var standaloneSignature = metadataReader.GetStandaloneSignature(handle);
var signature = SignatureDecoder.DecodeMethodSignature(standaloneSignature.Signature, provider);
return(string.Format("{0}{1}", GetMethodReturnType(signature), provider.GetParameterList(signature)));
}
throw new ArgumentException("Get signature invalid token");
}
private Object ResolveStandaloneSignature(StandaloneSignatureHandle handle)
{
StandaloneSignature signature = _metadataReader.GetStandaloneSignature(handle);
BlobReader signatureReader = _metadataReader.GetBlobReader(signature.Signature);
EcmaSignatureParser parser = new EcmaSignatureParser(this, signatureReader, NotFoundBehavior.ReturnResolutionFailure);
MethodSignature methodSig = parser.ParseMethodSignature();
if (methodSig == null)
{
return(parser.ResolutionFailure);
}
return(methodSig);
}
private static List <Type> ResolveLocalsFromSignature(MetadataReader aReader, MethodBase aMethodBase, Type[] aGenericTypeParameters, Type[] aGenericMethodParameters)
{
var xLocalVariables = new List <Type>();
var xMethodBody = GetMethodBodyBlock(aMethodBase.Module, aMethodBase.MetadataToken);
if (xMethodBody != null && !xMethodBody.LocalSignature.IsNil)
{
var xSig = aReader.GetStandaloneSignature(xMethodBody.LocalSignature);
var xLocals = xSig.DecodeLocalSignature(new LocalTypeProvider(aMethodBase.Module), new LocalTypeGenericContext(aGenericTypeParameters.ToImmutableArray(), aGenericMethodParameters.ToImmutableArray()));
foreach (var xLocal in xLocals)
{
xLocalVariables.Add(xLocal);
}
}
return(xLocalVariables);
}
// See: https://github.com/dotnet/corert/blob/635cf21aca11265ded9d78d216424bd609c052f5/src/Common/src/TypeSystem/Ecma/EcmaSignatureParser.cs#L242
public static int GetLocalsCount(this MetadataReader reader, MethodBodyBlock method)
{
if (method.LocalSignature.IsNil)
{
return(0);
}
var entryPointSignature = reader.GetStandaloneSignature(method.LocalSignature);
var signatureBlobReader = reader.GetBlobReader(entryPointSignature.Signature);
if (signatureBlobReader.ReadSignatureHeader().Kind != SignatureKind.LocalVariables)
{
throw new BadImageFormatException();
}
return(signatureBlobReader.ReadCompressedInteger());
}
int IMetadataImport.GetSigFromToken(
int standaloneSignature,
[Out] byte **signature,
[Out] int *signatureLength)
{
MetadataRequired();
var sigHandle = (StandaloneSignatureHandle)MetadataTokens.Handle(standaloneSignature);
// happens when a constant doesn't have a signature:
if (sigHandle.IsNil)
{
if (signature != null)
{
*signature = null;
}
if (signatureLength != null)
{
*signatureLength = 0;
}
// The caller expect the signature to have at least one byte on success,
// so we need to fail here. Otherwise AV happens.
return(HResult.E_INVALIDARG);
}
var sig = _metadataReaderOpt.GetStandaloneSignature(sigHandle);
var bytes = _metadataReaderOpt.GetBlobBytes(sig.Signature);
var pinnedBuffer = GCHandle.Alloc(bytes, GCHandleType.Pinned);
if (signature != null)
{
*signature = (byte *)pinnedBuffer.AddrOfPinnedObject();
}
if (signatureLength != null)
{
*signatureLength = bytes.Length;
}
_pinnedBuffers.Add(pinnedBuffer);
return(HResult.S_OK);
}
public unsafe int GetSigFromToken(
int tkSignature, // Signature token.
out byte *ppvSig, // return pointer to signature blob
out int pcbSig) // return size of signature
{
MetadataRequired();
var sig = _metadataReaderOpt.GetStandaloneSignature((StandaloneSignatureHandle)MetadataTokens.Handle(tkSignature));
var signature = _metadataReaderOpt.GetBlobBytes(sig.Signature);
GCHandle pinnedBuffer = GCHandle.Alloc(signature, GCHandleType.Pinned);
ppvSig = (byte *)pinnedBuffer.AddrOfPinnedObject();
pcbSig = signature.Length;
_pinnedBuffers.Add(pinnedBuffer);
return(0);
}
public unsafe bool TryGetStandaloneSignature(int standaloneSignatureToken, out byte *signature, out int length)
{
var sigHandle = (StandaloneSignatureHandle)MetadataTokens.Handle(standaloneSignatureToken);
if (sigHandle.IsNil)
{
signature = null;
length = 0;
return(false);
}
var sig = _reader.GetStandaloneSignature(sigHandle);
var blobReader = _reader.GetBlobReader(sig.Signature);
signature = blobReader.StartPointer;
length = blobReader.Length;
return(true);
}
private static string GetSignature(MetadataReader metadataReader, int intOperand, CilTypeProvider provider)
{
if (IsStandaloneSignature(intOperand))
{
var handle = MetadataTokens.StandaloneSignatureHandle(intOperand);
var standaloneSignature = metadataReader.GetStandaloneSignature(handle);
var signature = SignatureDecoder.DecodeMethodSignature(standaloneSignature.Signature, provider);
return string.Format("{0}{1}", GetMethodReturnType(signature), provider.GetParameterList(signature));
}
throw new ArgumentException("Get signature invalid token");
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public ReadyToRunMethod(
ReadyToRunReader readyToRunReader,
PEReader peReader,
MetadataReader metadataReader,
EntityHandle methodHandle,
int entryPointId,
string owningType,
string constrainedType,
string[] instanceArgs,
int?fixupOffset)
{
_readyToRunReader = readyToRunReader;
_fixupOffset = fixupOffset;
MethodHandle = methodHandle;
EntryPointRuntimeFunctionId = entryPointId;
MetadataReader = metadataReader;
EntityHandle owningTypeHandle;
GenericParameterHandleCollection genericParams = default(GenericParameterHandleCollection);
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(typeParameters: Array.Empty <string>(), methodParameters: instanceArgs);
DisassemblingTypeProvider typeProvider = new DisassemblingTypeProvider();
// get the method signature from the method handle
switch (MethodHandle.Kind)
{
case HandleKind.MethodDefinition:
{
MethodDefinition methodDef = MetadataReader.GetMethodDefinition((MethodDefinitionHandle)MethodHandle);
if (methodDef.RelativeVirtualAddress != 0)
{
MethodBodyBlock mbb = peReader.GetMethodBody(methodDef.RelativeVirtualAddress);
if (!mbb.LocalSignature.IsNil)
{
StandaloneSignature ss = MetadataReader.GetStandaloneSignature(mbb.LocalSignature);
LocalSignature = ss.DecodeLocalSignature(typeProvider, genericContext);
}
}
Name = MetadataReader.GetString(methodDef.Name);
Signature = methodDef.DecodeSignature <string, DisassemblingGenericContext>(typeProvider, genericContext);
owningTypeHandle = methodDef.GetDeclaringType();
genericParams = methodDef.GetGenericParameters();
}
break;
case HandleKind.MemberReference:
{
MemberReference memberRef = MetadataReader.GetMemberReference((MemberReferenceHandle)MethodHandle);
Name = MetadataReader.GetString(memberRef.Name);
Signature = memberRef.DecodeMethodSignature <string, DisassemblingGenericContext>(typeProvider, genericContext);
owningTypeHandle = memberRef.Parent;
}
break;
default:
throw new NotImplementedException();
}
if (owningType != null)
{
DeclaringType = owningType;
}
else
{
DeclaringType = MetadataNameFormatter.FormatHandle(MetadataReader, owningTypeHandle);
}
StringBuilder sb = new StringBuilder();
sb.Append(Signature.ReturnType);
sb.Append(" ");
sb.Append(DeclaringType);
sb.Append(".");
sb.Append(Name);
if (Signature.GenericParameterCount != 0)
{
sb.Append("<");
for (int i = 0; i < Signature.GenericParameterCount; i++)
{
if (i > 0)
{
sb.Append(", ");
}
if (instanceArgs != null && instanceArgs.Length > i)
{
sb.Append(instanceArgs[i]);
}
else
{
sb.Append("!");
sb.Append(i);
}
}
sb.Append(">");
}
sb.Append("(");
for (int i = 0; i < Signature.ParameterTypes.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
sb.AppendFormat($"{Signature.ParameterTypes[i]}");
}
sb.Append(")");
SignatureString = sb.ToString();
}
public static StandaloneSignature GetStandaloneSignature(this StandaloneSignatureHandle handle, MetadataReader reader) => reader.GetStandaloneSignature(handle);
