private void ProcessIlEmitMethodCall(Instruction emitCallInstruction, out Instruction?nextInstruction)
{
var emittedInstruction = CreateInstructionToEmit();
_il.Replace(emitCallInstruction, emittedInstruction);
if (emittedInstruction.OpCode.OpCodeType == OpCodeType.Prefix)
{
_il.RemoveNopsAfter(emittedInstruction);
}
var sequencePoint = _sequencePoints.MapSequencePoint(emitCallInstruction, emittedInstruction);
if (emittedInstruction.Previous?.OpCode.OpCodeType == OpCodeType.Prefix)
{
_sequencePoints.MergeWithPreviousSequencePoint(sequencePoint);
}
nextInstruction = emittedInstruction.Next;
RemoveNopInDebugBuild(ref nextInstruction);
nextInstruction = emittedInstruction.NextSkipNops();
switch (emittedInstruction.OpCode.Code)
{
case Code.Ret:
case Code.Endfinally:
case Code.Endfilter:
{
if (nextInstruction?.OpCode == emittedInstruction.OpCode)
{
_il.Remove(emittedInstruction);
_log.Debug($"Removed duplicate {emittedInstruction.OpCode}");
}
break;
}
case Code.Leave:
case Code.Leave_S:
case Code.Throw:
case Code.Rethrow:
{
if (nextInstruction?.OpCode == OpCodes.Leave || nextInstruction?.OpCode == OpCodes.Leave_S)
{
_il.RemoveNopsAfter(emittedInstruction);
_il.Remove(emittedInstruction);
_il.Replace(nextInstruction, emittedInstruction);
_log.Debug($"Replaced {nextInstruction.OpCode} with emitted {emittedInstruction.OpCode}");
nextInstruction = emittedInstruction.NextSkipNops();
}
break;
}
}
Instruction CreateInstructionToEmit()
{
var method = (MethodReference)emitCallInstruction.Operand;
var opCode = OpCodeMap.FromCecilFieldName(method.Name);
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(emitCallInstruction);
switch (opCode.OperandType)
{
case OperandType.InlineNone:
{
if (args.Length != 0)
{
throw new InstructionWeavingException(emitCallInstruction, "Unexpected operand argument");
}
return(_il.Create(opCode));
}
case OperandType.InlineI:
case OperandType.ShortInlineI:
case OperandType.InlineI8:
case OperandType.InlineR:
case OperandType.ShortInlineR:
return(_il.CreateConst(opCode, _consumer.ConsumeArgConst(args.Single())));
case OperandType.InlineString:
return(_il.CreateConst(opCode, _consumer.ConsumeArgString(args.Single())));
case OperandType.InlineType:
{
if (method.IsGenericInstance)
{
return(_il.Create(opCode, ((GenericInstanceMethod)method).GenericArguments[0]));
}
return(_il.Create(opCode, _consumer.ConsumeArgTypeRef(args.Single())));
}
case OperandType.InlineMethod:
return(_il.Create(opCode, _consumer.ConsumeArgMethodRef(args.Single())));
case OperandType.InlineField:
return(_il.Create(opCode, _consumer.ConsumeArgFieldRef(args.Single())));
case OperandType.InlineTok:
{
if (method.IsGenericInstance)
{
return(_il.Create(opCode, ((GenericInstanceMethod)method).GenericArguments[0]));
}
return(method.Parameters[0].ParameterType.FullName switch
{
KnownNames.Full.TypeRefType => _il.Create(opCode, _consumer.ConsumeArgTypeRef(args.Single())),
KnownNames.Full.MethodRefType => _il.Create(opCode, _consumer.ConsumeArgMethodRef(args.Single())),
KnownNames.Full.FieldRefType => _il.Create(opCode, _consumer.ConsumeArgFieldRef(args.Single())),
_ => throw new InstructionWeavingException(emitCallInstruction, $"Unexpected argument type: {method.Parameters[0].ParameterType.FullName}")
});
}
private TypeRefBuilder ConsumeArgTypeRefBuilder(Instruction instruction)
{
if (instruction.OpCode.FlowControl != FlowControl.Call || instruction.Operand is not MethodReference method)
{
throw UnexpectedInstruction(instruction, "a method call");
}
switch (method.GetElementMethod().FullName)
{
case "System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)":
{
var ldToken = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction).Single();
if (ldToken.OpCode != OpCodes.Ldtoken)
{
throw UnexpectedInstruction(ldToken, OpCodes.Ldtoken);
}
var builder = new TypeRefBuilder(Module, (TypeReference)ldToken.Operand);
_il.Remove(ldToken);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::op_Implicit(System.Type)":
case "InlineIL.TypeRef InlineIL.TypeRef::Type(System.Type)":
case "System.Void InlineIL.TypeRef::.ctor(System.Type)":
{
var builder = ConsumeArgTypeRefBuilder(_il.GetArgumentPushInstructionsInSameBasicBlock(instruction).Single());
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::Type()":
{
var builder = new TypeRefBuilder(Module, ((GenericInstanceMethod)method).GenericArguments[0]);
_il.Remove(instruction);
return(builder);
}
case "System.Void InlineIL.TypeRef::.ctor(System.String,System.String)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var assemblyName = ConsumeArgString(args[0]);
var typeName = ConsumeArgString(args[1]);
var builder = new TypeRefBuilder(Module, assemblyName, typeName);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.GenericParameters::get_Item(System.Int32)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var genericParameterType = ConsumeArgGenericParameterType(args[0]);
var genericParameterIndex = ConsumeArgInt32(args[1]);
var builder = new TypeRefBuilder(Module, genericParameterType, genericParameterIndex);
_il.Remove(instruction);
return(builder);
}
case "System.Type System.Type::MakeGenericMethodParameter(System.Int32)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var genericParameterIndex = ConsumeArgInt32(args[0]);
var builder = new TypeRefBuilder(Module, GenericParameterType.Method, genericParameterIndex);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::MakePointerType()":
case "System.Type System.Type::MakePointerType()":
{
var builder = ConsumeArgTypeRefBuilder(_il.GetArgumentPushInstructionsInSameBasicBlock(instruction).Single());
builder.MakePointerType();
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::MakeByRefType()":
case "System.Type System.Type::MakeByRefType()":
{
var builder = ConsumeArgTypeRefBuilder(_il.GetArgumentPushInstructionsInSameBasicBlock(instruction).Single());
builder.MakeByRefType();
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::MakeArrayType()":
case "System.Type System.Type::MakeArrayType()":
{
var builder = ConsumeArgTypeRefBuilder(_il.GetArgumentPushInstructionsInSameBasicBlock(instruction).Single());
builder.MakeArrayType(1);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::MakeArrayType(System.Int32)":
case "System.Type System.Type::MakeArrayType(System.Int32)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var builder = ConsumeArgTypeRefBuilder(args[0]);
var rank = ConsumeArgInt32(args[1]);
builder.MakeArrayType(rank);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::MakeGenericType(InlineIL.TypeRef[])":
case "System.Type System.Type::MakeGenericType(System.Type[])":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var builder = ConsumeArgTypeRefBuilder(args[0]);
var genericArgs = ConsumeArgArray(args[1], ConsumeArgTypeRefBuilder);
builder.MakeGenericType(genericArgs);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::WithOptionalModifier(InlineIL.TypeRef)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var builder = ConsumeArgTypeRefBuilder(args[0]);
var modifierType = ConsumeArgTypeRef(args[1]);
builder.AddOptionalModifier(modifierType);
_il.Remove(instruction);
return(builder);
}
case "InlineIL.TypeRef InlineIL.TypeRef::WithRequiredModifier(InlineIL.TypeRef)":
{
var args = _il.GetArgumentPushInstructionsInSameBasicBlock(instruction);
var builder = ConsumeArgTypeRefBuilder(args[0]);
var modifierType = ConsumeArgTypeRef(args[1]);
builder.AddRequiredModifier(modifierType);
_il.Remove(instruction);
return(builder);
}
default:
throw UnexpectedInstruction(instruction, "a type reference");
}
}