public unsafe int GetSignature(
int bufferLength,
out int count,
[In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0), Out] byte[] signature)
{
var localSignatureHandle = _symMethod.GetLocalSignatureHandle();
var metadataImport = _symMethod.SymReader.GetMetadataImport();
var local = _symMethod.MetadataReader.GetLocalVariable(_handle);
byte *signaturePtr;
int signatureLength;
int hr = metadataImport.GetSigFromToken(MetadataTokens.GetToken(localSignatureHandle), out signaturePtr, out signatureLength);
if (hr != HResult.S_OK)
{
count = 0;
return(hr);
}
var signatureReader = new BlobReader(signaturePtr, signatureLength);
SignatureHeader header = signatureReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.LocalVariables)
{
count = 0;
return(HResult.E_FAIL);
}
int slotCount = signatureReader.ReadCompressedInteger();
int slotIndex = local.Index;
if (slotIndex >= slotCount)
{
count = 0;
return(HResult.E_FAIL);
}
var typeProvider = DummyTypeProvider.Instance;
var decoder = new SignatureDecoder <object, object>(typeProvider, metadataReader: null, genericContext: null);
for (int i = 0; i < slotIndex - 1; i++)
{
decoder.DecodeType(ref signatureReader, allowTypeSpecifications: false);
}
int localSlotStart = signatureReader.Offset;
decoder.DecodeType(ref signatureReader, allowTypeSpecifications: false);
int localSlotLength = signatureReader.Offset - localSlotStart;
if (localSlotLength <= bufferLength)
{
Marshal.Copy((IntPtr)(signaturePtr + localSlotStart), signature, 0, localSlotLength);
}
count = localSlotLength;
return(HResult.S_OK);
}
private static MethodSymbol FindMethodBySignature(
TypeSymbol targetTypeSymbol,
string targetMemberName,
SignatureHeader targetMemberSignatureHeader,
int targetMemberTypeParamCount,
ParamInfo <TypeSymbol>[] targetParamInfo
)
{
foreach (Symbol member in targetTypeSymbol.GetMembers(targetMemberName))
{
var method = member as MethodSymbol;
if (
(object)method != null &&
((byte)method.CallingConvention == targetMemberSignatureHeader.RawValue) &&
(targetMemberTypeParamCount == method.Arity) &&
MethodSymbolMatchesParamInfo(method, targetParamInfo)
)
{
// Behavior in the face of multiple matching signatures is
// implementation defined - we'll just pick the first one.
return(method);
}
}
return(null);
}
public PropertySignature ParsePropertySignature()
{
SignatureHeader header = _reader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Property)
{
throw new BadImageFormatException();
}
bool isStatic = !header.IsInstance;
int count = _reader.ReadCompressedInteger();
TypeDesc returnType = ParseType();
TypeDesc[] parameters;
if (count > 0)
{
// Get all of the parameters.
parameters = new TypeDesc[count];
for (int i = 0; i < count; i++)
{
parameters[i] = ParseType();
}
}
else
{
parameters = TypeDesc.EmptyTypes;
}
return(new PropertySignature(isStatic, parameters, returnType));
}
public MethodSignature ParseMethodSignature()
{
MethodSignatureFlags flags = 0;
SignatureHeader header = _reader.ReadSignatureHeader();
if (!header.IsInstance)
{
flags |= MethodSignatureFlags.Static;
}
int arity = header.IsGeneric ? _reader.ReadCompressedInteger() : 0;
int count = _reader.ReadCompressedInteger();
TypeDesc returnType = ParseType();
TypeDesc[] parameters;
if (count > 0)
{
// Get all of the parameters.
parameters = new TypeDesc[count];
for (int i = 0; i < count; i++)
{
parameters[i] = ParseType();
}
}
else
{
parameters = TypeDesc.EmptyTypes;
}
return(new MethodSignature(flags, arity, returnType, parameters));
}
private static void CheckHeader(SignatureHeader header, SignatureKind expectedKind)
{
if (header.Kind != expectedKind)
{
throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue));
}
}
/// <summary>
/// Decodes a local variable signature blob and advances the reader past the signature.
/// </summary>
/// <param name="blobReader">The blob reader positioned at a local variable signature.</param>
/// <returns>The local variable types.</returns>
/// <exception cref="System.BadImageFormatException">The local variable signature is invalid.</exception>
public ImmutableArray <TType> DecodeLocalSignature(ref BlobReader blobReader)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
CheckHeader(header, SignatureKind.LocalVariables);
return(DecodeTypeSequence(ref blobReader));
}
/// <summary>
/// Decodes a method specification signature blob and advances the reader past the signature.
/// </summary>
/// <param name="blobReader">A BlobReader positioned at a valid method specification signature.</param>
/// <returns>The types used to instantiate a generic method via the method specification.</returns>
public ImmutableArray <TType> DecodeMethodSpecificationSignature(ref BlobReader blobReader)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
CheckHeader(header, SignatureKind.MethodSpecification);
return(DecodeTypeSequence(ref blobReader));
}
//^ [NotDelayed]
internal LocalVariableSignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MethodBody owningMethodBody,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, owningMethodBody.MethodDefinition)
{
_owningMethodBody = owningMethodBody;
//^ this.LocalVariables = ILReader.EmptyLocalVariables;
//^ this.SignatureMemoryReader = signatureMemoryReader;
//^ base;
byte firstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsLocalVarSignature(firstByte))
{
// MDError
}
int locVarCount = this.SignatureMemoryReader.ReadCompressedUInt32();
LocalVariableDefinition[] locVarArr = new LocalVariableDefinition[locVarCount];
for (int i = 0; i < locVarCount; ++i)
{
locVarArr[i] = this.GetLocalVariable((uint)i);
}
//^ NonNullType.AssertInitialized(locVarArr);
this.LocalVariables = new EnumerableArrayWrapper <LocalVariableDefinition, ILocalDefinition>(locVarArr, Dummy.LocalVariable);
}
public CallingConventions ComputeCallingConvention()
{
BlobReader signatureBlob = MethodDefinition.Signature.GetBlobReader(Reader);
SignatureHeader sigHeader = signatureBlob.ReadSignatureHeader();
CallingConventions result;
if (sigHeader.CallingConvention == SignatureCallingConvention.VarArgs)
{
result = CallingConventions.VarArgs;
}
else
{
result = CallingConventions.Standard;
}
if (sigHeader.IsInstance)
{
result |= CallingConventions.HasThis;
}
if (sigHeader.HasExplicitThis)
{
result |= CallingConventions.ExplicitThis;
}
return(result);
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public R2RMethod(byte[] image, MetadataReader mdReader, uint rid, int entryPointId, GenericElementTypes[] instanceArgs, uint[] tok)
{
Token = _mdtMethodDef | 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();
TypeDefinition declaringTypeDef;
while (!declaringTypeHandle.IsNil)
{
declaringTypeDef = mdReader.GetTypeDefinition(declaringTypeHandle);
DeclaringType = mdReader.GetString(declaringTypeDef.Name) + "." + DeclaringType;
declaringTypeHandle = declaringTypeDef.GetDeclaringType();
}
NamespaceDefinitionHandle namespaceHandle = declaringTypeDef.NamespaceDefinition;
while (!namespaceHandle.IsNil)
{
NamespaceDefinition namespaceDef = mdReader.GetNamespaceDefinition(namespaceHandle);
DeclaringType = mdReader.GetString(namespaceDef.Name) + "." + DeclaringType;
namespaceHandle = namespaceDef.Parent;
}
SignatureHeader signatureHeader = signatureReader.ReadSignatureHeader();
IsGeneric = signatureHeader.IsGeneric;
GenericParameterHandleCollection genericParams = _methodDef.GetGenericParameters();
_genericParamInstanceMap = new Dictionary <string, GenericInstance>();
int argCount = signatureReader.ReadCompressedInteger();
if (IsGeneric)
{
argCount = signatureReader.ReadCompressedInteger();
}
ReturnType = new SignatureType(ref signatureReader, mdReader, genericParams);
ArgTypes = new SignatureType[argCount];
for (int i = 0; i < argCount; i++)
{
ArgTypes[i] = new SignatureType(ref signatureReader, mdReader, genericParams);
}
if (IsGeneric && instanceArgs != null && tok != null)
{
InitGenericInstances(genericParams, instanceArgs, tok);
}
}
public ChaincodeStub(string channelId, string txId, Handler handler, List <ByteString> args, SignedProposal signedProposal)
{
ChannelId = channelId;
TxId = txId;
this.handler = handler;
this.args = args.ToList();
SignedProposal = signedProposal;
if (SignedProposal == null || SignedProposal.ProposalBytes.IsEmpty)
{
creator = null;
TxTimestamp = null;
transientMap = new Dictionary <string, ByteString>();
Binding = null;
}
else
{
Proposal proposal = Proposal.Parser.ParseFrom(signedProposal.ProposalBytes);
Header header = Header.Parser.ParseFrom(proposal.Header);
ChannelHeader channelHeader = ChannelHeader.Parser.ParseFrom(header.ChannelHeader);
ValidateProposalType(channelHeader);
SignatureHeader signatureHeader = SignatureHeader.Parser.ParseFrom(header.SignatureHeader);
ChaincodeProposalPayload chaincodeProposalPayload = ChaincodeProposalPayload.Parser.ParseFrom(proposal.Payload);
TxTimestamp = channelHeader.Timestamp.ToDateTimeOffset();
creator = signatureHeader.Creator;
transientMap = chaincodeProposalPayload.TransientMap.ToDictionary(a => a.Key, a => a.Value);
Binding = ComputeBinding(channelHeader, signatureHeader);
}
}
/// <summary>
/// Decodes a field signature blob and advances the reader past the signature.
/// </summary>
/// <param name="blobReader">The blob reader positioned at a field signature.</param>
/// <returns>The decoded field type.</returns>
public TType DecodeFieldSignature(ref BlobReader blobReader)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
CheckHeader(header, SignatureKind.Field);
return(DecodeType(ref blobReader));
}
private void CheckHeader(SignatureHeader header, SignatureKind expectedKind)
{
if (header.Kind != expectedKind)
{
throw new BadImageFormatException(StarkPlatform.Reflection.Resources.SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue));
}
}
public MethodSignature(SignatureHeader header, TType returnType, int requiredParameterCount, int genericParameterCount, ImmutableArray <TType> parameterTypes)
{
_header = header;
_returnType = returnType;
_genericParameterCount = genericParameterCount;
_requiredParameterCount = requiredParameterCount;
_parameterTypes = parameterTypes;
}
private void InspectFields(FieldDefinitionHandleCollection fields)
{
foreach (var fieldHandle in fields)
{
var inspectorField = new InspectorField();
var fieldDef = metaReader.GetFieldDefinition(fieldHandle);
var customAttr = fieldDef.GetCustomAttributes();
foreach (var caHandle in customAttr)
{
// Look for InspectorAttribute
if (DecodeCustomAttribute(caHandle, inspectorField))
{
BlobReader sigReader = metaReader.GetBlobReader(fieldDef.Signature);
SignatureHeader header = sigReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Field)
{
continue;
}
var typeCode = sigReader.ReadSignatureTypeCode();
string typeName = typeCode.ToString();
if (typeCode == SignatureTypeCode.SZArray)
{
inspectorField.IsArray = true;
SignatureTypeCode code = sigReader.ReadSignatureTypeCode();
if (code == SignatureTypeCode.TypeHandle)
{
bool isEnum;
DecodeTypeHandleTypeName(sigReader, out typeName, out isEnum);
}
else
{
typeName = code.ToString();
}
}
else if (typeCode == SignatureTypeCode.TypeHandle)
{
bool isEnum;
DecodeTypeHandleTypeName(sigReader, out typeName, out isEnum);
inspectorField.IsEnum = isEnum;
}
inspectorField.TypeName = typeName;
inspectorField.Name = metaReader.GetString(fieldDef.Name);
_inspectorComponent.Fields[inspectorField.Name] = inspectorField;
break;
}
}
}
}
private MethodSignature ParseMethodSignatureImpl(bool skipEmbeddedSignatureData)
{
SignatureHeader header = _reader.ReadSignatureHeader();
MethodSignatureFlags flags = 0;
SignatureCallingConvention signatureCallConv = header.CallingConvention;
if (signatureCallConv != SignatureCallingConvention.Default)
{
// Verify that it is safe to convert CallingConvention to MethodSignatureFlags via a simple cast
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)SignatureCallingConvention.CDecl);
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)SignatureCallingConvention.StdCall);
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)SignatureCallingConvention.ThisCall);
Debug.Assert((int)MethodSignatureFlags.CallingConventionVarargs == (int)SignatureCallingConvention.VarArgs);
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConvention == (int)SignatureCallingConvention.Unmanaged);
flags = (MethodSignatureFlags)signatureCallConv;
}
if (!header.IsInstance)
{
flags |= MethodSignatureFlags.Static;
}
int arity = header.IsGeneric ? _reader.ReadCompressedInteger() : 0;
int count = _reader.ReadCompressedInteger();
TypeDesc returnType = ParseType();
TypeDesc[] parameters;
if (count > 0)
{
// Get all of the parameters.
parameters = new TypeDesc[count];
for (int i = 0; i < count; i++)
{
parameters[i] = ParseType();
}
}
else
{
parameters = TypeDesc.EmptyTypes;
}
EmbeddedSignatureData[] embeddedSignatureDataArray = (_embeddedSignatureDataList == null || _embeddedSignatureDataList.Count == 0 || skipEmbeddedSignatureData) ? null : _embeddedSignatureDataList.ToArray();
if (_resolutionFailure == null)
{
return(new MethodSignature(flags, arity, returnType, parameters, embeddedSignatureDataArray));
}
else
{
return(null);
}
}
private static void CheckMethodOrPropertyHeader(SignatureHeader header)
{
SignatureKind kind = header.Kind;
if (kind != SignatureKind.Method && kind != SignatureKind.Property)
{
throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader2, SignatureKind.Property, SignatureKind.Method, header.Kind, header.RawValue));
}
}
private void CheckMethodOrPropertyHeader(SignatureHeader header)
{
SignatureKind kind = header.Kind;
if (kind != SignatureKind.Method && kind != SignatureKind.Property)
{
throw new BadImageFormatException(StarkPlatform.Reflection.Resources.SR.Format(SR.UnexpectedSignatureHeader2, SignatureKind.Property, SignatureKind.Method, header.Kind, header.RawValue));
}
}
public void VerifyConstructor3()
{
var header = new SignatureHeader(SignatureKind.Method, SignatureCallingConvention.Unmanaged, SignatureAttributes.Instance);
Assert.Equal(0x29, header.RawValue);
Assert.Equal(SignatureKind.Method, header.Kind);
Assert.Equal(SignatureCallingConvention.Unmanaged, header.CallingConvention);
Assert.Equal(SignatureAttributes.Instance, header.Attributes);
}
private void CheckHeader(SignatureHeader header, SignatureKind expectedKind)
{
if (header.Kind != expectedKind)
{
#if SRM
throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue));
#else
throw new BadImageFormatException();
#endif
}
}
/// <summary>
/// Decodes a local variable signature blob and advances the reader past the signature.
/// </summary>
/// <param name="blobReader">The blob reader.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The local variable types.</returns>
/// <exception cref="System.BadImageFormatException">The local variable signature is invalid.</exception>
public static ImmutableArray <TType> DecodeLocalSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.LocalVariables)
{
throw new BadImageFormatException();
}
return(DecodeTypes(ref blobReader, provider));
}
/// <summary>
/// Decodes a field signature.
/// </summary>
/// <returns>The decoded field type.</returns>
public static TType DecodeFieldSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Field)
{
throw new BadImageFormatException();
}
return(DecodeType(ref blobReader, provider));
}
public MethodSignature ParseMethodSignature()
{
SignatureHeader header = _reader.ReadSignatureHeader();
MethodSignatureFlags flags = 0;
SignatureCallingConvention signatureCallConv = header.CallingConvention;
if (signatureCallConv != SignatureCallingConvention.Default)
{
// Verify that it is safe to convert CallingConvention to MethodSignatureFlags via a simple cast
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)SignatureCallingConvention.CDecl);
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)SignatureCallingConvention.StdCall);
Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)SignatureCallingConvention.ThisCall);
// Vararg methods are not supported in .NET Core
if (signatureCallConv == SignatureCallingConvention.VarArgs)
{
throw new TypeSystemException.BadImageFormatException();
}
flags = (MethodSignatureFlags)signatureCallConv;
}
if (!header.IsInstance)
{
flags |= MethodSignatureFlags.Static;
}
int arity = header.IsGeneric ? _reader.ReadCompressedInteger() : 0;
int count = _reader.ReadCompressedInteger();
TypeDesc returnType = ParseType();
TypeDesc[] parameters;
if (count > 0)
{
// Get all of the parameters.
parameters = new TypeDesc[count];
for (int i = 0; i < count; i++)
{
parameters[i] = ParseType();
}
}
else
{
parameters = TypeDesc.EmptyTypes;
}
return(new MethodSignature(flags, arity, returnType, parameters));
}
/// <summary>
/// Close current archive and stream. Archive is committed after this
/// </summary>
public void Close()
{
this.signatureHeader = new SignatureHeader();
if (this.stream != null)
{
this.stream.Close();
this.stream.Dispose();
this.stream = null;
}
this.fileAccess = null;
this.Header = null;
this.IsValid = false;
}
/// <summary>
/// Close current archive and stream. Archive is committed after this
/// </summary>
public void Close()
{
signatureHeader = new SignatureHeader();
if (stream != null)
{
stream.Close();
stream.Dispose();
stream = null;
}
fileAccess = null;
Header = null;
IsValid = false;
}
public void VerifyConstructor2()
{
var header = new SignatureHeader(SignatureKind.Method, SignatureCallingConvention.StdCall, SignatureAttributes.ExplicitThis | SignatureAttributes.Generic);
Assert.Equal(0x52, header.RawValue);
Assert.Equal(SignatureKind.Method, header.Kind);
Assert.Equal(SignatureCallingConvention.StdCall, header.CallingConvention);
Assert.Equal(SignatureAttributes.ExplicitThis | SignatureAttributes.Generic, header.Attributes);
// no validation, since the header can be created with arbitrary raw value anyways
Assert.Equal(0xff, new SignatureHeader((SignatureKind)0xff, 0, 0).RawValue);
Assert.Equal(0xff, new SignatureHeader(0, (SignatureCallingConvention)0xff, 0).RawValue);
Assert.Equal(0xff, new SignatureHeader(0, 0, (SignatureAttributes)0xff).RawValue);
}
public CustomAttributeValue <TType> DecodeValue(EntityHandle constructor, BlobHandle value)
{
BlobHandle signature;
switch (constructor.Kind)
{
case HandleKind.MethodDefinition:
MethodDefinition definition = _reader.GetMethodDefinition((MethodDefinitionHandle)constructor);
signature = definition.Signature;
break;
case HandleKind.MemberReference:
MemberReference reference = _reader.GetMemberReference((MemberReferenceHandle)constructor);
signature = reference.Signature;
break;
default:
throw new BadImageFormatException();
}
BlobReader signatureReader = _reader.GetBlobReader(signature);
BlobReader valueReader = _reader.GetBlobReader(value);
ushort prolog = valueReader.ReadUInt16();
if (prolog != 1)
{
throw new BadImageFormatException();
}
SignatureHeader header = signatureReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method || header.IsGeneric)
{
throw new BadImageFormatException();
}
int parameterCount = signatureReader.ReadCompressedInteger();
SignatureTypeCode returnType = signatureReader.ReadSignatureTypeCode();
if (returnType != SignatureTypeCode.Void)
{
throw new BadImageFormatException();
}
ImmutableArray <CustomAttributeTypedArgument <TType> > fixedArguments = DecodeFixedArguments(ref signatureReader, ref valueReader, parameterCount);
ImmutableArray <CustomAttributeNamedArgument <TType> > namedArguments = DecodeNamedArguments(ref valueReader);
return(new CustomAttributeValue <TType>(fixedArguments, namedArguments));
}
public ZipReturn ZipFileCreate(string newFilename, bool compressOutput, int dictionarySize = 1 << 24, int numFastBytes = 64)
{
if (ZipOpen != ZipOpenType.Closed)
{
return(ZipReturn.ZipFileAlreadyOpen);
}
DirUtil.CreateDirForFile(newFilename);
_zipFileInfo = new FileInfo(newFilename);
int errorCode = FileStream.OpenFileWrite(newFilename, out _zipFs);
if (errorCode != 0)
{
ZipFileClose();
return(ZipReturn.ZipErrorOpeningFile);
}
ZipOpen = ZipOpenType.OpenWrite;
_signatureHeader = new SignatureHeader();
_header = new Header();
using (BinaryWriter bw = new BinaryWriter(_zipFs, Encoding.UTF8, true))
{
_signatureHeader.Write(bw);
}
_baseOffset = _zipFs.Position;
_compressed = compressOutput;
_unpackedStreamSize = 0;
if (_compressed)
{
LzmaEncoderProperties ep = new LzmaEncoderProperties(true, dictionarySize, numFastBytes);
LzmaStream lzs = new LzmaStream(ep, false, _zipFs);
_codeMSbytes = lzs.Properties;
_lzmaStream = lzs;
/*
* ZstandardStream zss = new ZstandardStream(_zipFs, 22, true);
* _codeMSbytes = new byte[] { 1, 4, 18, 0, 0 };
* _lzmaStream = zss;
*/
_packStreamStart = (ulong)_zipFs.Position;
}
return(ZipReturn.ZipGood);
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public R2RMethod(int index, MetadataReader mdReader, uint rid, int entryPointId, CorElementType[] instanceArgs, uint[] tok, FixupCell[] fixups)
{
Index = index;
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 = MetadataNameFormatter.FormatHandle(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();
}
Fixups = fixups;
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();
}
/// <summary>
/// Decodes a method signature blob.
/// </summary>
/// <param name="blobReader">BlobReader positioned at a method signature.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded method signature.</returns>
/// <exception cref="System.BadImageFormatException">The method signature is invalid.</exception>
private static MethodSignature <TType> DecodeMethodSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method && header.Kind != SignatureKind.Property)
{
throw new BadImageFormatException();
}
int genericParameterCount = 0;
if (header.IsGeneric)
{
genericParameterCount = blobReader.ReadCompressedInteger();
}
int parameterCount = blobReader.ReadCompressedInteger();
TType returnType = DecodeType(ref blobReader, provider);
if (parameterCount == 0)
{
return(new MethodSignature <TType>(header, returnType, 0, genericParameterCount, ImmutableArray <TType> .Empty));
}
var parameterTypes = new TType[parameterCount];
SignatureTypeCode typeCode;
int parameterIndex;
for (parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
{
var reader = blobReader;
typeCode = reader.ReadSignatureTypeCode();
if (typeCode == SignatureTypeCode.Sentinel)
{
break;
}
parameterTypes[parameterIndex] = DecodeType(ref blobReader, provider);
}
int requiredParameterCount = parameterIndex;
for (; parameterIndex < parameterCount; parameterIndex++)
{
parameterTypes[parameterIndex] = DecodeType(ref blobReader, provider);
}
return(new MethodSignature <TType>(header, returnType, requiredParameterCount, genericParameterCount, ImmutableArray.Create(parameterTypes)));
}
public void VerifyConstructor2()
{
var header = new SignatureHeader(SignatureKind.Method, SignatureCallingConvention.StdCall, SignatureAttributes.ExplicitThis | SignatureAttributes.Generic);
Assert.Equal(0x52, header.RawValue);
Assert.Equal(SignatureKind.Method, header.Kind);
Assert.Equal(SignatureCallingConvention.StdCall, header.CallingConvention);
Assert.Equal(SignatureAttributes.ExplicitThis | SignatureAttributes.Generic, header.Attributes);
// no validation, since the header can be created with arbitrary raw value anyways
Assert.Equal(0xff, new SignatureHeader((SignatureKind)0xff, 0, 0).RawValue);
Assert.Equal(0xff, new SignatureHeader(0, (SignatureCallingConvention)0xff, 0).RawValue);
Assert.Equal(0xff, new SignatureHeader(0, 0, (SignatureAttributes)0xff).RawValue);
}
public void VerifyConstructor()
{
var header = new SignatureHeader(2);
var returnType = 5;
var requiredParameterCount = 10;
var genericParameterCount = 3;
var parameterTypes = ImmutableArray.Create(2, 4, 6, 8);
var methodSignature = new MethodSignature<int>(header, returnType, requiredParameterCount, genericParameterCount, parameterTypes);
// Verify each field was correctly set
Assert.Equal(methodSignature.Header, header);
Assert.Equal(methodSignature.ReturnType, returnType);
Assert.Equal(methodSignature.RequiredParameterCount, requiredParameterCount);
Assert.Equal(methodSignature.GenericParameterCount, genericParameterCount);
Assert.Equal(methodSignature.ParameterTypes, parameterTypes);
}
public SignatureData(SignatureHeader header, ImmutableArray<ParameterSymbol> parameters, PEParameterSymbol returnParam)
{
this.Header = header;
this.Parameters = parameters;
this.ReturnParam = returnParam;
}
private static MethodSymbol FindMethodBySignature(TypeSymbol targetTypeSymbol, string targetMemberName, SignatureHeader targetMemberSignatureHeader, int targetMemberTypeParamCount, ParamInfo<TypeSymbol>[] targetParamInfo)
{
foreach (Symbol member in targetTypeSymbol.GetMembers(targetMemberName))
{
var method = member as MethodSymbol;
if ((object)method != null &&
((byte)method.CallingConvention == targetMemberSignatureHeader.RawValue) &&
(targetMemberTypeParamCount == method.Arity) &&
MethodSymbolMatchesParamInfo(method, targetParamInfo))
{
// Behavior in the face of multiple matching signatures is
// implementation defined - we'll just pick the first one.
return method;
}
}
return null;
}
