void PatchMethods()
{
MethodTable methodTable = (MethodTable)stripped_tables [MethodTable.RId];
if (methodTable == null)
{
return;
}
RVA method_rva = RVA.Zero;
for (int i = 0; i < methodTable.Rows.Count; i++)
{
MethodRow methodRow = methodTable[i];
methodRow.ImplFlags |= MethodImplAttributes.NoInlining;
MetadataToken methodToken = MetadataToken.FromMetadataRow(TokenType.Method, i);
MethodDefinition method = (MethodDefinition)assembly.MainModule.LookupByToken(methodToken);
if (method.HasBody)
{
method_rva = method_rva != RVA.Zero
? method_rva
: reflection_writer.CodeWriter.WriteMethodBody(method);
methodRow.RVA = method_rva;
}
else
{
methodRow.RVA = RVA.Zero;
}
}
}
void ReadMethods()
{
if (!m_tHeap.HasTable(MethodTable.RId))
{
m_meths = new MethodDefinition [0];
return;
}
MethodTable mTable = m_tableReader.GetMethodTable();
m_meths = new MethodDefinition [mTable.Rows.Count];
for (int i = 0; i < mTable.Rows.Count; i++)
{
MethodRow mRow = mTable [i];
MethodDefinition meth = new MethodDefinition(
m_root.Streams.StringsHeap [mRow.Name],
mRow.Flags);
meth.RVA = mRow.RVA;
meth.ImplAttributes = mRow.ImplFlags;
meth.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Method, i);
m_meths [i] = meth;
}
}
public MethodIL GetMethodBody(int num)
{
MethodIL il = null;
if (img == null)
{
return(il);
}
MDStream tabs = Streams["#~"] as MDStream;
TablesHeap tabsHeap = tabs.Heap as TablesHeap;
if (tabsHeap.HasMethod)
{
MDTable methods = tabsHeap[TableId.Method];
if (methods == null)
{
return(il);
}
MethodRow row = methods[num] as MethodRow;
if (row == null)
{
return(il);
}
BinaryReader reader = img.reader;
reader.BaseStream.Position = img.RVAToVA(row.RVA);
il = new MethodIL();
il.Read(reader);
}
return(il);
}
private MethodDefinitionResolver(uint rid, MethodRow row, MetadataSystem metadata, TypeDefinition declaringType)
{
_token = new MetadataToken(MetadataTokenType.Method, rid);
_row = row;
_metadata = metadata;
_declaringType = declaringType;
_signature = new Lazy <MethodSignatureReader>(() => new MethodSignatureReader(_row, _metadata));
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new MethodRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += MethodRow.LogicalSize;
}
}
private void ReadSignature(MethodRow row, MetadataSystem metadata)
{
var blob = metadata.ResolveBlob(row.Signature);
var sig = new StandAloneSignature(blob);
CallingConventions = (CallingConventions)sig.ReadByte();
ParamCount = sig.ReadCompressedUInt32();
ReturnType = sig.ReadType(metadata);
ParamTypes = new ITypeInfo[ParamCount];
for (int index = 0; index < ParamCount; index++)
{
ParamTypes[index] = sig.ReadType(metadata);
}
}
public Collection <ParameterDefinition> GetParameters(MethodRow methodRow, MethodSignatureReader signature, MethodDefinition methodDef)
{
var start = methodRow.ParamList;
var count = signature.ParamCount;
var parameters = new ParameterDefinition[count];
for (uint offset = 0; offset < count; offset++)
{
var paramRid = start + offset;
var paramRow = _reader.ParameterTable[paramRid];
var paramType = signature.ParamTypes[paramRow.Sequence - 1];
parameters[offset] = ParameterDefinitionResolver.Resolve(paramRid, paramRow, this, methodDef, paramType);
}
return(new Collection <ParameterDefinition>(parameters));
}
private MethodRow CreateMethodRow(MethodDefinition entity, MetadataBuilder metadata)
{
var row = new MethodRow(
metadata.WriteMethod(entity),
entity.ImplAttributes,
entity.Attributes,
metadata.WriteString(entity.Name),
metadata.WriteSignature(entity),
(ushort)(metadata.ParamTable.Length + 1)
);
foreach (var param in entity.Parameters)
{
metadata.ResolveToken(param);
}
return(row);
}
void PatchMethods()
{
MethodTable methodTable = (MethodTable)stripped_tables [MethodTable.RId];
if (methodTable == null)
{
return;
}
for (int i = 0; i < methodTable.Rows.Count; i++)
{
MethodRow methodRow = methodTable[i];
MetadataToken methodToken = MetadataToken.FromMetadataRow(TokenType.Method, i);
MethodDefinition method = (MethodDefinition)assembly.MainModule.LookupByToken(methodToken);
methodRow.RVA = reflection_writer.CodeWriter.WriteMethodBody(method);
}
}
public virtual void VisitMethodRow(MethodRow row)
{
}
void CompleteMethods()
{
TypeDefTable tdefTable = m_tableReader.GetTypeDefTable();
if (!m_tHeap.HasTable(MethodTable.RId))
{
m_meths = new MethodDefinition [0];
return;
}
MethodTable methTable = m_tableReader.GetMethodTable();
ParamTable paramTable = m_tableReader.GetParamTable();
if (!m_tHeap.HasTable(ParamTable.RId))
{
m_parameters = new ParameterDefinition [0];
}
else
{
m_parameters = new ParameterDefinition [paramTable.Rows.Count];
}
for (int i = 0; i < m_typeDefs.Length; i++)
{
TypeDefinition dec = m_typeDefs [i];
int index = i, next;
if (index == tdefTable.Rows.Count - 1)
{
next = methTable.Rows.Count + 1;
}
else
{
next = (int)(tdefTable [index + 1]).MethodList;
}
for (int j = (int)tdefTable [index].MethodList; j < next; j++)
{
MethodRow methRow = methTable [j - 1];
MethodDefinition mdef = m_meths [j - 1];
if (mdef.IsConstructor)
{
dec.Constructors.Add(mdef);
}
else
{
dec.Methods.Add(mdef);
}
GenericContext context = new GenericContext(mdef);
MethodDefSig msig = m_sigReader.GetMethodDefSig(methRow.Signature);
mdef.HasThis = msig.HasThis;
mdef.ExplicitThis = msig.ExplicitThis;
mdef.CallingConvention = msig.MethCallConv;
int prms;
if (j == methTable.Rows.Count)
{
prms = m_parameters.Length + 1;
}
else
{
prms = (int)(methTable [j]).ParamList;
}
ParameterDefinition retparam = null;
//TODO: optimize this
ParamRow pRow = null;
int start = (int)methRow.ParamList - 1;
if (paramTable != null && start < prms - 1)
{
pRow = paramTable [start];
}
if (pRow != null && pRow.Sequence == 0) // ret type
{
retparam = new ParameterDefinition(
m_root.Streams.StringsHeap [pRow.Name],
0,
pRow.Flags,
null);
retparam.Method = mdef;
m_parameters [start] = retparam;
start++;
}
for (int k = 0; k < msig.ParamCount; k++)
{
int pointer = start + k;
if (paramTable != null && pointer < prms - 1)
{
pRow = paramTable [pointer];
}
Param psig = msig.Parameters [k];
ParameterDefinition pdef;
if (pRow != null)
{
pdef = BuildParameterDefinition(
m_root.Streams.StringsHeap [pRow.Name],
pRow.Sequence, pRow.Flags, psig, context);
pdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Param, pointer);
m_parameters [pointer] = pdef;
}
else
{
pdef = BuildParameterDefinition(
string.Concat("A_", mdef.IsStatic ? k : k + 1),
k + 1, (ParamAttributes)0, psig, context);
}
pdef.Method = mdef;
mdef.Parameters.Add(pdef);
}
mdef.ReturnType = GetMethodReturnType(msig, context);
MethodReturnType mrt = mdef.ReturnType as MethodReturnType;
mrt.Method = mdef;
if (retparam != null)
{
mrt.Parameter = retparam;
mrt.Parameter.ParameterType = mrt.ReturnType;
}
}
}
uint eprid = CodeReader.GetRid((int)m_reader.Image.CLIHeader.EntryPointToken);
if (eprid > 0 && eprid <= m_meths.Length)
{
m_module.Assembly.EntryPoint = GetMethodDefAt(eprid);
}
}
public static MethodDefinition Resolve(uint rid, MethodRow row, MetadataSystem metadata, TypeDefinition declaringType)
{
var resolver = new MethodDefinitionResolver(rid, row, metadata, declaringType);
return(new MethodDefinition(resolver));
}
public virtual void VisitMethodRow(MethodRow row)
{
}
public MethodSignatureReader(MethodRow row, MetadataSystem metadata)
{
ReadSignature(row, metadata);
}
