public CallingConventionSignature ImportCallingConventionSignature(CallingConventionSignature signature)
{
var memberSig = signature as MemberSignature;
if (memberSig != null)
{
return(ImportMemberSignature(memberSig));
}
var propertySig = signature as PropertySignature;
if (propertySig != null)
{
return(ImportPropertySignature(propertySig));
}
var genericInstanceSig = signature as GenericInstanceMethodSignature;
if (genericInstanceSig != null)
{
return(ImportGenericInstanceMethodSignature(genericInstanceSig));
}
var localVarSig = signature as LocalVariableSignature;
if (localVarSig != null)
{
return(ImportLocalVariableSignature(localVarSig));
}
throw new NotSupportedException("Invalid or unsupported calling convention signature.");
}
/// <summary>
/// Determines whether two member signatures are considered equal according to their signatures.
/// </summary>
/// <param name="signature1">The first signature to compare.</param>
/// <param name="signature2">The second signature to compare.</param>
/// <returns><c>True</c> if the signatures are considered equal, <c>False</c> otherwise.</returns>
public bool MatchMemberSignatures(CallingConventionSignature signature1, CallingConventionSignature signature2)
{
if (signature1 == null && signature2 == null)
{
return(true);
}
if (signature1 == null || signature2 == null)
{
return(false);
}
var fieldSignature = signature1 as FieldSignature;
if (fieldSignature != null)
{
return(MatchFieldSignatures(fieldSignature, signature2 as FieldSignature));
}
var methodSignature = signature1 as MethodSignature;
if (methodSignature != null)
{
return(MatchMethodSignatures(methodSignature, signature2 as MethodSignature));
}
var propertySignature = signature1 as PropertySignature;
if (propertySignature != null)
{
return(MatchPropertySignatures(propertySignature, signature2 as PropertySignature));
}
return(false);
}
/// <summary>
/// Determines whether two member signatures are considered equal according to their signatures.
/// </summary>
/// <param name="signature1">The first signature to compare.</param>
/// <param name="signature2">The second signature to compare.</param>
/// <returns><c>True</c> if the signatures are considered equal, <c>False</c> otherwise.</returns>
public bool Equals(CallingConventionSignature signature1, CallingConventionSignature signature2)
{
if (signature1 == null && signature2 == null)
{
return(true);
}
if (signature1 == null || signature2 == null)
{
return(false);
}
switch (signature1)
{
case FieldSignature fieldSignature:
return(Equals(fieldSignature, signature2 as FieldSignature));
case MethodSignature methodSignature:
return(Equals(methodSignature, signature2 as MethodSignature));
case PropertySignature propertySignature:
return(Equals(propertySignature, signature2 as PropertySignature));
case GenericInstanceMethodSignature genericInstanceSignature:
return(Equals(genericInstanceSignature, signature2 as GenericInstanceMethodSignature));
}
return(false);
}
public StandAloneSignature(CallingConventionSignature signature, MetadataImage image)
: base(new MetadataToken(MetadataTokenType.StandAloneSig))
{
Image = image;
_signature = new LazyValue <CallingConventionSignature>(signature);
CustomAttributes = new CustomAttributeCollection(this);
}
/// <inheritdoc />
protected override CallingConventionSignature GetSignature()
{
var reader = _parentModule.DotNetDirectory.Metadata
.GetStream <BlobStream>()
.GetBlobReaderByIndex(_row.Signature);
return(CallingConventionSignature.FromReader(_parentModule, reader, true));
}
public static void ReadLocalVariables(this CilMethodBody methodBody, MethodDefinition method, byte[] localSig)
{
var locals = CallingConventionSignature.FromReader(method.Module, new ByteArrayReader(localSig)) as LocalVariablesSignature;
for (var i = 0; i < locals?.VariableTypes.Count; i++)
{
methodBody.LocalVariables.Add(new CilLocalVariable(locals.VariableTypes[i]));
}
}
internal StandAloneSignature(MetadataImage image, MetadataRow <uint> row)
: base(row.MetadataToken)
{
Image = image;
_signature = new LazyValue <CallingConventionSignature>(() =>
image.Header.GetStream <BlobStream>().TryCreateBlobReader(row.Column1, out var reader)
? CallingConventionSignature.FromReader(image, reader, true)
: null);
CustomAttributes = new CustomAttributeCollection(this);
}
internal StandAloneSignature(MetadataHeader header, MetadataToken token, MetadataRow <uint> row)
: base(header, token, row)
{
_signature = new LazyValue <CallingConventionSignature>(() =>
{
IBinaryStreamReader reader;
return(header.GetStream <BlobStream>().TryCreateBlobReader(row.Column1, out reader)
? CallingConventionSignature.FromReader(header, reader)
: null);
});
}
internal StandAloneSignature(MetadataImage image, MetadataRow <uint> row)
: base(row.MetadataToken)
{
_image = image;
_signature = new LazyValue <CallingConventionSignature>(() =>
{
IBinaryStreamReader reader;
return(image.Header.GetStream <BlobStream>().TryCreateBlobReader(row.Column1, out reader)
? CallingConventionSignature.FromReader(image, reader)
: null);
});
}
internal MemberReference(MetadataHeader header, MetadataToken token, MetadataRow <uint, uint, uint> row)
: base(header, token, row)
{
var tableStream = header.GetStream <TableStream>();
_parent = new LazyValue <IMemberRefParent>(() =>
{
var parentToken = tableStream.GetIndexEncoder(CodedIndex.MemberRefParent).DecodeIndex(row.Column1);
return(parentToken.Rid != 0 ? (IMemberRefParent)tableStream.ResolveMember(parentToken) : null);
});
_name = new LazyValue <string>(() => header.GetStream <StringStream>().GetStringByOffset(row.Column2));
_signature = new LazyValue <MemberSignature>(() =>
CallingConventionSignature.FromReader(header, header.GetStream <BlobStream>().CreateBlobReader(row.Column3)) as MemberSignature);
}
public static void ReadLocalVariables(CilMethodBody methodBody, MethodDefinition method, byte[] localSig)
{
if (!(method.Module is SerializedModuleDefinition module))
{
throw new ArgumentException("Method body should reference a serialized module.");
}
var localsSignature = (LocalVariablesSignature)CallingConventionSignature.FromReader(
new BlobReadContext(module.ReaderContext),
new ByteArrayReader(localSig));
for (int i = 0; i < localsSignature?.VariableTypes.Count; i++)
{
methodBody.LocalVariables.Add(new CilLocalVariable(localsSignature.VariableTypes[i]));
}
}
public int GetHashCode(CallingConventionSignature obj)
{
switch (obj)
{
case MethodSignature methodSignature:
return(GetHashCode(methodSignature));
case FieldSignature fieldSignature:
return(GetHashCode(fieldSignature));
case PropertySignature propertySignature:
return(GetHashCode(propertySignature));
default:
return(obj.GetHashCode());
}
}
public MemberReference(MetadataImage image, MetadataRow <uint, uint, uint> row)
: base(row.MetadataToken)
{
_image = image;
var tableStream = image.Header.GetStream <TableStream>();
_parent = new LazyValue <IMemberRefParent>(() =>
{
var parentToken = tableStream.GetIndexEncoder(CodedIndex.MemberRefParent).DecodeIndex(row.Column1);
return(parentToken.Rid != 0 ? (IMemberRefParent)image.ResolveMember(parentToken) : null);
});
_name = new LazyValue <string>(() => image.Header.GetStream <StringStream>().GetStringByOffset(row.Column2));
_signature = new LazyValue <MemberSignature>(() =>
CallingConventionSignature.FromReader(image, image.Header.GetStream <BlobStream>().CreateBlobReader(row.Column3)) as MemberSignature);
CustomAttributes = new CustomAttributeCollection(this);
}
/// <inheritdoc />
public CallingConventionSignature ImportCallingConventionSignature(CallingConventionSignature signature)
{
switch (signature)
{
case MemberSignature memberSig:
return(ImportMemberSignature(memberSig));
case PropertySignature propertySig:
return(ImportPropertySignature(propertySig));
case GenericInstanceMethodSignature genericInstanceSig:
return(ImportGenericInstanceMethodSignature(genericInstanceSig));
case LocalVariableSignature localVarSig:
return(ImportLocalVariableSignature(localVarSig));
default:
throw new NotSupportedException("Invalid or unsupported calling convention signature.");
}
}
/// <summary>
/// Determines whether two member signatures are considered equal according to their signatures.
/// </summary>
/// <param name="signature1">The first signature to compare.</param>
/// <param name="signature2">The second signature to compare.</param>
/// <returns><c>True</c> if the signatures are considered equal, <c>False</c> otherwise.</returns>
public bool Equals(CallingConventionSignature signature1, CallingConventionSignature signature2)
{
if (signature1 == null && signature2 == null)
{
return(true);
}
if (signature1 == null || signature2 == null)
{
return(false);
}
var fieldSignature = signature1 as FieldSignature;
if (fieldSignature != null)
{
return(Equals(fieldSignature, signature2 as FieldSignature));
}
var methodSignature = signature1 as MethodSignature;
if (methodSignature != null)
{
return(Equals(methodSignature, signature2 as MethodSignature));
}
var propertySignature = signature1 as PropertySignature;
if (propertySignature != null)
{
return(Equals(propertySignature, signature2 as PropertySignature));
}
var genericInstanceSignature = signature1 as GenericInstanceMethodSignature;
if (genericInstanceSignature != null)
{
return(Equals(genericInstanceSignature, signature2 as GenericInstanceMethodSignature));
}
return(false);
}
/// <inheritdoc />
public override object ResolveMember(MetadataToken token)
{
switch (token.Table)
{
case TableIndex.TypeDef:
var type = _tokens[(int)token.Rid];
if (type is RuntimeTypeHandle runtimeTypeHandle)
{
return(_importer.ImportType(Type.GetTypeFromHandle(runtimeTypeHandle)));
}
break;
case TableIndex.Field:
var field = _tokens[(int)token.Rid];
if (field is null)
{
return(null);
}
if (field is RuntimeFieldHandle runtimeFieldHandle)
{
return(_importer.ImportField(FieldInfo.GetFieldFromHandle(runtimeFieldHandle)));
}
if (field.GetType().FullName == "System.Reflection.Emit.GenericFieldInfo")
{
bool result = FieldReader.TryReadField <RuntimeFieldHandle>(field, "m_field", out var mField);
var ctx = FieldReader.ReadField <RuntimeTypeHandle>(field, "m_context");
return(_importer.ImportField(FieldInfo.GetFieldFromHandle(result
? mField
: FieldReader.ReadField <RuntimeFieldHandle>(field, "m_fieldHandle"), ctx)));
}
break;
case TableIndex.Method:
case TableIndex.MemberRef:
var obj = _tokens[(int)token.Rid];
if (obj is RuntimeMethodHandle methodHandle)
{
return(_importer.ImportMethod(MethodBase.GetMethodFromHandle(methodHandle)));
}
if (obj.GetType().FullName == "System.Reflection.Emit.GenericMethodInfo")
{
var context = FieldReader.ReadField <RuntimeTypeHandle>(obj, "m_context");
bool hasHandle = FieldReader.TryReadField <RuntimeMethodHandle>(obj, "m_method", out var mMethod);
var mHandle = FieldReader.ReadField <RuntimeMethodHandle>(obj, "m_methodHandle");
var method = MethodBase.GetMethodFromHandle(
hasHandle ? mMethod : mHandle,
context);
return(_importer.ImportMethod(method));
}
if (obj.GetType().FullName == "System.Reflection.Emit.VarArgMethod")
{
return(_importer.ImportMethod(FieldReader.ReadField <MethodInfo>(obj, "m_method")));
}
break;
case TableIndex.StandAloneSig:
var reader = ByteArrayDataSource.CreateReader((byte[])_tokens[(int)token.Rid]);
return(CallingConventionSignature.FromReader(new BlobReadContext(_readerContext), ref reader));
}
return(token);
}
public StandAloneSignature(CallingConventionSignature signature, MetadataImage image)
: base(new MetadataToken(MetadataTokenType.StandAloneSig))
{
_image = image;
_signature = new LazyValue <CallingConventionSignature>(signature);
}
public StandAloneSignature(CallingConventionSignature signature)
: this(signature, null)
{
}
private static object ReadToken(ModuleReaderContext readerContext, MetadataToken token, IList <object> tokens, ReferenceImporter importer)
{
switch (token.Table)
{
case TableIndex.TypeDef:
var type = tokens[(int)token.Rid];
if (type is RuntimeTypeHandle runtimeTypeHandle)
{
return(importer.ImportType(Type.GetTypeFromHandle(runtimeTypeHandle)));
}
break;
case TableIndex.Field:
var field = tokens[(int)token.Rid];
if (field is null)
{
return(null);
}
if (field is RuntimeFieldHandle runtimeFieldHandle)
{
return(importer.ImportField(FieldInfo.GetFieldFromHandle(runtimeFieldHandle)));
}
if (field.GetType().FullName == "System.Reflection.Emit.GenericFieldInfo")
{
var result = FieldReader.TryReadField <RuntimeFieldHandle>(field, "m_field", out var mField);
var ctx = FieldReader.ReadField <RuntimeTypeHandle>(field, "m_context");
return(importer.ImportField(FieldInfo.GetFieldFromHandle(result
? mField
: FieldReader.ReadField <RuntimeFieldHandle>(field, "m_fieldHandle"), ctx)));
}
break;
case TableIndex.Method:
case TableIndex.MemberRef:
var obj = tokens[(int)token.Rid];
if (obj is RuntimeMethodHandle methodHandle)
{
return(importer.ImportMethod(MethodBase.GetMethodFromHandle(methodHandle)));
}
if (obj.GetType().FullName == "System.Reflection.Emit.GenericMethodInfo")
{
var context =
FieldReader.ReadField <RuntimeTypeHandle>(obj, "m_context");
var res = FieldReader.TryReadField <RuntimeMethodHandle>(obj, "m_method", out var m_method);
var m_handle = FieldReader.ReadField <RuntimeMethodHandle>(obj, "m_methodHandle");
var method = MethodBase.GetMethodFromHandle(
res
? m_method
: m_handle, context);
return(importer.ImportMethod(method));
}
if (obj.GetType().FullName == "System.Reflection.Emit.VarArgMethod")
{
return(importer.ImportMethod(FieldReader.ReadField <MethodInfo>(obj, "m_method")));
}
break;
case TableIndex.StandAloneSig:
return(CallingConventionSignature.FromReader(
new BlobReadContext(readerContext),
new ByteArrayReader((byte[])tokens[(int)token.Rid])));
case (TableIndex)112:
return(tokens[(int)token.Rid] as string);
}
return(null);
}
/// <summary>
/// Wraps a blob signature into a new stand-alone signature.
/// </summary>
/// <param name="signature">The signature to assign a metadata token.</param>
public StandAloneSignature(CallingConventionSignature signature)
: this(new MetadataToken(TableIndex.StandAloneSig, 0))
{
Signature = signature;
}
public StandAloneSignature(CallingConventionSignature signature)
: base(null, new MetadataToken(MetadataTokenType.StandAloneSig), new MetadataRow <uint>())
{
_signature = new LazyValue <CallingConventionSignature>(signature);
}
