private void ResolveStandAloneSigToken(StandAloneSignature entity)
{
var row = CreateStandAloneSigRow(entity, _metadata);
var rid = _metadata.StandAloneSigTable.Add(row);
_token = new MetadataToken(MetadataTokenType.Signature, rid);
}
public void NewStandaloneSignature()
{
var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld);
// Import arbitrary method signature.
var importer = new ReferenceImporter(module);
var signature = new StandAloneSignature(
importer.ImportMethodSignature(MethodSignature.CreateStatic(module.CorLibTypeFactory.Void)));
// Ensure reference is added to the module by referencing it in main.
var instructions = module.ManagedEntrypointMethod.CilMethodBody.Instructions;
instructions.Insert(0, CilOpCodes.Ldnull);
instructions.Insert(0, CilOpCodes.Calli, signature);
// Rebuild.
var builder = new ManagedPEImageBuilder();
var result = builder.CreateImage(module);
// Assert valid token.
var newToken = result.TokenMapping[signature];
Assert.NotEqual(0u, newToken.Rid);
// Assert token resolves to the same method reference.
var newModule = ModuleDefinition.FromImage(result.ConstructedImage);
var newSignature = (StandAloneSignature)newModule.LookupMember(newToken);
Assert.Equal(signature.Signature, newSignature.Signature, new SignatureComparer());
}
public MetadataToken GetStandaloneSignatureToken(StandAloneSignature signature)
{
if (signature == null)
{
return(MetadataToken.Zero);
}
MetadataToken token;
if (_members.TryGetValue(signature, out token))
{
return(token);
}
var table = (StandAloneSignatureTable)_tableStream.GetTable(MetadataTokenType.StandAloneSig);
var signatureRow = new MetadataRow <uint>
{
Column1 = _parentBuffer.BlobStreamBuffer.GetBlobOffset(signature.Signature)
};
table.Add(signatureRow);
_members.Add(signature, token = signatureRow.MetadataToken);
AddCustomAttributes(signature);
return(token);
}
public static MsilInstruction Create(MsilOpCode code, StandAloneSignature operand)
{
if (code.OperandType != MsilOperandType.InlineSig)
{
throw new ArgumentException("Opcode does not accept a signature operand.", "code");
}
return(new MsilInstruction(0, code, operand));
}
public void VariablesTest()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem;
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var methodTable = tableStream.GetTable <MethodDefinition>();
var signatureTable = tableStream.GetTable <StandAloneSignature>();
var variable = new VariableSignature(typeSystem.String);
var variable2 = new VariableSignature(typeSystem.Int32);
// create localvarsig.
var localVarSig = new LocalVariableSignature();
localVarSig.Variables.Add(variable);
localVarSig.Variables.Add(variable2);
var signature = new StandAloneSignature(localVarSig);
signatureTable.Add(signature);
// write code.
var body = methodTable[0].MethodBody;
body.Signature = signature;
body.Instructions.Clear();
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldloc, variable));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldloc, variable2));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ret));
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly, true);
methodTable = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>().GetTable <MethodDefinition>();
var newBody = methodTable[0].MethodBody;
Assert.IsNotNull(newBody.Signature);
Assert.IsInstanceOfType(newBody.Signature.Signature, typeof(LocalVariableSignature));
var newLocalVarSig = (LocalVariableSignature)newBody.Signature.Signature;
Assert.AreEqual(localVarSig.Variables.Count, newLocalVarSig.Variables.Count);
for (int i = 0; i < localVarSig.Variables.Count; i++)
{
Utilities.ValidateType(localVarSig.Variables[i].VariableType, newLocalVarSig.Variables[i].VariableType);
}
Assert.IsInstanceOfType(newBody.Instructions[0].Operand, typeof(VariableSignature));
Utilities.ValidateType(variable.VariableType,
((VariableSignature)newBody.Instructions[0].Operand).VariableType);
Assert.IsInstanceOfType(newBody.Instructions[2].Operand, typeof(VariableSignature));
Utilities.ValidateType(variable2.VariableType,
((VariableSignature)newBody.Instructions[2].Operand).VariableType);
}
/// <summary>
/// Verifies and inserts a instruction into the collection that references a standalone signature.
/// </summary>
/// <param name="index">The zero-based index at which the instruction should be inserted at.</param>
/// <param name="code">The opcode.</param>
/// <param name="signature">The referenced signature.</param>
/// <returns>The created instruction.</returns>
/// <exception cref="InvalidCilInstructionException">
/// Occurs when the provided operation is not an opcode referencing a standalone signature.
/// </exception>
public CilInstruction Insert(int index, CilOpCode code, StandAloneSignature signature)
{
if (code.OperandType != CilOperandType.InlineSig)
{
throw new InvalidCilInstructionException(code);
}
return(InsertAndReturn(index, code, signature));
}
/// <inheritdoc />
public MetadataToken GetStandAloneSignatureToken(StandAloneSignature signature)
{
var table = Metadata.TablesStream.GetTable <StandAloneSignatureRow>(TableIndex.StandAloneSig);
var row = new StandAloneSignatureRow(
Metadata.BlobStream.GetBlobIndex(this, signature.Signature));
var token = table.Add(row);
AddCustomAttributes(token, signature);
return(token);
}
internal void WriteStandAloneSig(StandAloneSignature signature)
{
if (signature.UpdateRowOnRebuild)
{
object[] parts = new object[]
{
GetHeapOffset(netHeader.BlobHeap, Convert.ToUInt32(signature.MetaDataRow.Parts[0])), // TODO: Serialize signatures.
};
signature.MetaDataRow = new MetaDataRow(parts);
}
writer.Write(signature.MetaDataRow.GenerateBytes());
}
private FatMethodHeader ComputeFatHeader(MethodDefinition methodDef)
{
return(new FatMethodHeader()
{
Size = 0x30,
MaxStack = (ushort)methodDef.Body.MaxStack,
CodeSize = (uint)methodDef.Body.CodeSize,
Attributes = GetFatHeaderAttributes(methodDef),
LocalVarSigTok = _metadata.ResolveToken(
StandAloneSignature
.GetVariablesSignature(methodDef.Body.Variables, _metadata))
});
}
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);
}
}
private static int DetermineVarPushCount(CilInstruction instruction)
{
var signature = instruction.Operand switch
{
IMethodDescriptor method => method.Signature,
StandAloneSignature standAloneSig => standAloneSig.Signature as MethodSignature,
_ => null
};
if (signature == null)
{
return(0);
}
if (!signature.ReturnType.IsTypeOf("System", "Void") || instruction.OpCode.Code == CilCode.Newobj)
{
return(1);
}
return(0);
}
private CilRawMethodBody BuildFatMethodBody(MethodBodySerializationContext context, CilMethodBody body, byte[] code)
{
// Serialize local variables.
MetadataToken token;
if (body.LocalVariables.Count == 0)
{
token = MetadataToken.Zero;
}
else
{
var localVarSig = new LocalVariablesSignature(body.LocalVariables.Select(v => v.VariableType));
var standAloneSig = new StandAloneSignature(localVarSig);
token = context.TokenProvider.GetStandAloneSignatureToken(standAloneSig);
}
var fatBody = new CilRawFatMethodBody(CilMethodBodyAttributes.Fat, (ushort)body.MaxStack, token, code);
fatBody.InitLocals = body.InitializeLocals;
// Build up EH table section.
if (body.ExceptionHandlers.Count > 0)
{
fatBody.HasSections = true;
bool needsFatFormat = body.ExceptionHandlers.Any(e => e.IsFat);
var attributes = CilExtraSectionAttributes.EHTable;
if (needsFatFormat)
{
attributes |= CilExtraSectionAttributes.FatFormat;
}
var rawSectionData = SerializeExceptionHandlers(context, body.ExceptionHandlers, needsFatFormat);
var section = new CilExtraSection(attributes, rawSectionData);
fatBody.ExtraSections.Add(section);
}
return(fatBody);
}
private static int DetermineVarPopCount(CilInstruction instruction, bool isVoid)
{
var opCode = instruction.OpCode;
var signature = instruction.Operand switch
{
IMethodDescriptor method => method.Signature,
StandAloneSignature standAloneSig => standAloneSig.Signature as MethodSignature,
_ => null
};
if (signature == null)
{
if (opCode.Code == CilCode.Ret)
{
return(isVoid ? 0 : 1);
}
}
else
{
int count = signature.GetTotalParameterCount();
switch (opCode.Code)
{
case CilCode.Newobj:
// NewObj produces instead of consumes the this parameter.
count--;
break;
case CilCode.Calli:
// Calli consumes an extra parameter (the address to call).
count++;
break;
}
return(count);
}
return(0);
}
public static MsilInstruction Create(MsilOpCode code, StandAloneSignature operand)
{
if (code.OperandType != MsilOperandType.InlineSig)
throw new ArgumentException("Opcode does not accept a signature operand.", "code");
return new MsilInstruction(0, code, operand);
}
public uint WriteSignature(IMethodInfo methodInfo)
{
var signature = StandAloneSignature.GetMethodSignature(methodInfo, this);
return(WriteBlob(signature));
}
private StandAloneSigRow CreateStandAloneSigRow(StandAloneSignature entity, MetadataBuilder metadata)
{
return(new StandAloneSigRow(metadata.WriteBlob(entity)));
}
public void VisitStandAloneSignature(StandAloneSignature entity) => ResolveStandAloneSigToken(entity);
public CilInstruction Add(CilOpCode code, StandAloneSignature signature) => Insert(Count, code, signature);
public uint WriteSignature(IMemberReference memberRef)
{
var signature = StandAloneSignature.GetMemberReferenceSignature(memberRef, this);
return(WriteBlob(signature));
}
public void VariablesTest()
{
// set up temp assembly.
var assembly = Utilities.CreateTempNetAssembly();
var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem;
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>();
var methodTable = tableStream.GetTable<MethodDefinition>();
var signatureTable = tableStream.GetTable<StandAloneSignature>();
var variable = new VariableSignature(typeSystem.String);
var variable2 = new VariableSignature(typeSystem.Int32);
// create localvarsig.
var localVarSig = new LocalVariableSignature();
localVarSig.Variables.Add(variable);
localVarSig.Variables.Add(variable2);
var signature = new StandAloneSignature(localVarSig);
signatureTable.Add(signature);
// write code.
var body = methodTable[0].MethodBody;
body.Signature = signature;
body.Instructions.Clear();
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldloc, variable));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldloc, variable2));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop));
body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ret));
// build and validate.
assembly = Utilities.RebuildNetAssembly(assembly, true);
methodTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<MethodDefinition>();
var newBody = methodTable[0].MethodBody;
Assert.IsNotNull(newBody.Signature);
Assert.IsInstanceOfType(newBody.Signature.Signature, typeof(LocalVariableSignature));
var newLocalVarSig = (LocalVariableSignature)newBody.Signature.Signature;
Assert.AreEqual(localVarSig.Variables.Count, newLocalVarSig.Variables.Count);
for (int i = 0; i < localVarSig.Variables.Count; i++)
Utilities.ValidateType(localVarSig.Variables[i].VariableType, newLocalVarSig.Variables[i].VariableType);
Assert.IsInstanceOfType(newBody.Instructions[0].Operand, typeof(VariableSignature));
Utilities.ValidateType(variable.VariableType,
((VariableSignature)newBody.Instructions[0].Operand).VariableType);
Assert.IsInstanceOfType(newBody.Instructions[2].Operand, typeof(VariableSignature));
Utilities.ValidateType(variable2.VariableType,
((VariableSignature)newBody.Instructions[2].Operand).VariableType);
}
private void UpdateStandAloneSig(Workspace workspace, StandAloneSignature signature)
{
// TODO: serialize blob.
}
public uint WriteSignature(CustomAttribute attribute)
{
var signature = StandAloneSignature.GetAttributeSignature(attribute, this);
return(WriteBlob(signature));
}
public uint WriteSignature(FieldDefinition fieldDef)
{
var signature = StandAloneSignature.GetFieldSignature(fieldDef, this);
return(WriteBlob(signature));
}
public uint WriteSignature(ITypeInfo type)
{
var signature = StandAloneSignature.GetTypeSignature(type, this);
return(WriteBlob(signature));
}
