public override bool Apply(OpCode code, int operandsize, Span <byte> operands) { if (operandsize == 4) { int val = BinaryPrimitives.ReadInt32LittleEndian(operands); if (code.Equals(OpCodes.Call) || code.Equals(OpCodes.Callvirt) || code.Equals(OpCodes.Newobj)) { var b = Info.Module.ResolveMethod(val); IL.Emit(code, b as MethodInfo); } else { IL.Emit(code, val); } } else if (operandsize == 2) { short val = BinaryPrimitives.ReadInt16LittleEndian(operands); IL.Emit(code, val); } else if (operandsize == 1) { byte val = operands[0]; IL.Emit(code, val); } else if (operandsize == 0) { IL.Emit(code); } else { return(false); } return(true); }
private Instruction GetDefaultInsertSlot(MethodDefinition m) { int count = m.Body.Instructions.Count; if (count == 1) { return(m.Body.Instructions[0]); } else { int rNum = ObfuscatorHelper.ObfuscateRandom.Next(0, 100); if (rNum > 50) { OpCode op = m.Body.Instructions[count - 2].OpCode; if (op.Equals(OpCodes.Endfinally) || op.Equals(OpCodes.Endfilter)) { return(m.Body.Instructions[count - 2]); } else { return(m.Body.Instructions[count - 1]); } } else { return(m.Body.Instructions[0]); } } }
internal void Emit(OpCode opcode, MethodInfo meth) { if (opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj)) { EmitCall(opcode, meth, null); return; } LogIL(opcode, meth); il.Emit(opcode, meth); }
internal void Emit(OpCode opcode, MethodInfo meth) { if (opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj)) { EmitCall(opcode, meth, null); return; } instructions.Add(CurrentPos(), new CodeInstruction(opcode, meth)); LogIL(opcode, meth); il.Emit(opcode, meth); }
public static ProgramPrecompile Compile(byte[] ops) { ProgramPrecompile result = new ProgramPrecompile(); for (int i = 0; i < ops.Length; ++i) { if (!Enum.IsDefined(typeof(OpCode), ops[i])) { continue; } OpCode op = (OpCode)ops[i]; if (op.Equals(OpCode.JUMPDEST)) { Logger.Debug("JUMPDEST:" + i); result.jumpdest.Add(i); } if (op >= OpCode.PUSH1 && op <= OpCode.PUSH32) { i += (int)op - (int)OpCode.PUSH1 + 1; } } return(result); }
private void Convert(ILProcessor il, TypeReference source, TypeReference target, bool isAddress) { Debug.Assert(!target.IsByReference); if (target == source) { return; } if (source.IsByReference) { Debug.Assert(!isAddress); TypeReference argType = source.GetElementType(); Ldind(il, argType); Convert(il, argType, target, isAddress); return; } if (target.IsValueType) { if (source.IsValueType) { OpCode opCode = s_convOpCodes[GetTypeCode(target)]; Debug.Assert(!opCode.Equals(OpCodes.Nop)); il.Emit(opCode); } else { Debug.Assert(IsAssignableFrom(source, target)); il.Emit(OpCodes.Unbox, ModuleDefinition.ImportReference(target)); if (!isAddress) { Ldind(il, target); } } } else if (IsAssignableFrom(target, source)) { if (source.IsValueType) { if (isAddress) { Ldind(il, source); } il.Emit(OpCodes.Box, ModuleDefinition.ImportReference(source)); } } else { Debug.Assert(IsAssignableFrom(source, target) || target.Resolve().IsInterface || source.Resolve().IsInterface); if (target.IsGenericParameter) { il.Emit(OpCodes.Unbox_Any, ModuleDefinition.ImportReference(target)); } else { il.Emit(OpCodes.Castclass, ModuleDefinition.ImportReference(target)); } } }
public void VerifyOpCode(OpCode opCode, string name, OpCodeType opCodeType, OperandType operandType, int size, int value, StackBehaviour stackBehaviourPop, StackBehaviour stackBehaviourPush) { Assert.Equal(name, opCode.Name); Assert.Equal(opCodeType, opCode.OpCodeType); Assert.Equal(operandType, opCode.OperandType); Assert.Equal(size, opCode.Size); Assert.Equal((short)value, opCode.Value); Assert.Equal(stackBehaviourPop, opCode.StackBehaviourPop); Assert.Equal(stackBehaviourPush, opCode.StackBehaviourPush); Assert.Equal(name, opCode.ToString()); Assert.Equal(opCode.GetHashCode(), opCode.GetHashCode()); Assert.True(opCode.Equals(opCode)); Assert.False(opCode.Equals("OpCode")); Assert.False(opCode.Equals(null)); }
static void Convert(ILGenerator il, Type source, Type target, bool isAddress) { Debug.Assert(!target.IsByRef); if (target == source) { return; } if (source.IsByRef) { Debug.Assert(!isAddress); Type argType = source.GetElementType(); Ldind(il, argType); Convert(il, argType, target, false); //??? always false return; } if (target.GetTypeInfo().IsValueType) { if (source.GetTypeInfo().IsValueType) { OpCode opCode = ConvOpCodes[(int)TypeHelper.FakeGetTypeCode(target)]; Debug.Assert(!opCode.Equals(OpCodes.Nop)); il.Emit(opCode); } else { Debug.Assert(source.IsAssignableFrom(target)); il.Emit(OpCodes.Unbox, target); if (!isAddress) { Ldind(il, target); } } } else if (target.IsAssignableFrom(source)) { if (source.GetTypeInfo().IsValueType) { if (isAddress) { Ldind(il, source); } il.Emit(OpCodes.Box, source); } } else { Debug.Assert(source.IsAssignableFrom(target) || target.GetTypeInfo().IsInterface || source.GetTypeInfo().IsInterface); if (target.IsGenericParameter) { il.Emit(OpCodes.Unbox_Any, target); } else { il.Emit(OpCodes.Castclass, target); } } }
internal override bool EqualsData(DnsOption other) { DnsOptionLongLivedQuery castedOther = (DnsOptionLongLivedQuery)other; return(Version.Equals(castedOther.Version) && OpCode.Equals(castedOther.OpCode) && ErrorCode.Equals(castedOther.ErrorCode) && Id.Equals(castedOther.Id) && LeaseLife.Equals(castedOther.LeaseLife)); }
/// <summary> /// Emit the appropriate stind instruction(s) to store the /// specified type from the top of the stack to the address /// bwlow it. /// </summary> /// <param name="il">generator to emit code to</param> /// <param name="referencedType">type of the value on the top of /// the stack</param> public static void EmitTypedStind(ILGenerator il, Type referencedType) { OpCode opCode = GetStindOpCodeForType(referencedType); if (opCode.Equals(OpCodes.Stobj)) { il.Emit(opCode, referencedType); } else { il.Emit(opCode); } }
private void runLuaClosure() { for (; ;) { int i = Fetch(); OpCode opCode = Instruction.GetOpCode(i); opCode.Action(i, this); if (opCode.Equals(OpCodeEnum.OP_RETURN)) { break; } } }
public static void Stind(ILGenerator il, Type type) { OpCode opCode = s_stindOpCodes[GetTypeCode(type)]; if (!opCode.Equals(OpCodes.Nop)) { il.Emit(opCode); } else { il.Emit(OpCodes.Stobj, type); } }
private static void Ldind(ILGenerator il, Type type) { OpCode opCode = s_ldindOpCodes[GetTypeCode(type)]; if (!opCode.Equals(OpCodes.Nop)) { il.Emit(opCode); } else { il.Emit(OpCodes.Ldobj, type); } }
static void Stind(ILGenerator il, Type type) { OpCode opCode = StindOpCodes[(int)TypeHelper.FakeGetTypeCode(type)]; if (!opCode.Equals(OpCodes.Nop)) { il.Emit(opCode); } else { il.Emit(OpCodes.Stobj, type); } }
private void Stind(ILProcessor il, TypeReference type) { OpCode opCode = s_stindOpCodes[GetTypeCode(type)]; if (!opCode.Equals(OpCodes.Nop)) { il.Emit(opCode); } else { il.Emit(OpCodes.Stobj, type); } }
public override bool Apply(OpCode code, int operandsize, Span <byte> operands) { if (operandsize == 4 && (code.Equals(OpCodes.Call) || code.Equals(OpCodes.Callvirt) || code.Equals(OpCodes.Newobj))) { int val = BinaryPrimitives.ReadInt32LittleEndian(operands); var currentmethod = Info.Module.ResolveMethod(val); int currentmethodtoken = currentmethod.GetMetadataToken(); if (SwapDict.ContainsKey(currentmethodtoken)) { IL.Emit(code, SwapDict[currentmethodtoken]); } else { return(false); } } else { return(false); } return(true); }
public static byte[] GetCode(byte[] ops) { for (int i = 0; i < ops.Length; ++i) { if (!Enum.IsDefined(typeof(OpCode), ops[i])) { continue; } OpCode op = (OpCode)ops[i]; if (op.Equals(OpCode.RETURN)) { Logger.Debug("Op code : return"); } if (op.Equals(OpCode.RETURN) && i + 1 < ops.Length && Enum.IsDefined(typeof(OpCode), ops[i + 1]) && ((OpCode)ops[i + 1]).Equals(OpCode.STOP)) { byte[] result = null; i++; result = new byte[ops.Length - i - 1]; Array.Copy(ops, i + 1, result, 0, ops.Length - i - 1); return(result); } if (op >= OpCode.PUSH1 && op <= OpCode.PUSH32) { i += (int)op - (int)OpCode.PUSH1 + 1; } } return(new DataWord(0).Data); }
private bool VerifyEqualsOpCodeT(OpCode op1, OpCode op2, string errNum) { bool retVal = true; try { if (!op1.Equals(op2)) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Result is not the value as expected,opcode1 is: " + op1 + ",opcode2 is: " + op2); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Unexpected exception: " + e); retVal = false; } return(retVal); }
/// <summary> /// True iff the two objects are equal Layers. /// </summary> public bool Equals(DnsLayer other) { return(other != null && Id.Equals(other.Id) && IsQuery.Equals(other.IsQuery) && OpCode.Equals(other.OpCode) && IsAuthoritativeAnswer.Equals(other.IsAuthoritativeAnswer) && IsTruncated.Equals(other.IsTruncated) && IsRecursionDesired.Equals(other.IsRecursionDesired) && IsRecursionAvailable.Equals(other.IsRecursionAvailable) && FutureUse.Equals(other.FutureUse) && IsAuthenticData.Equals(other.IsAuthenticData) && IsCheckingDisabled.Equals(other.IsCheckingDisabled) && ResponseCode.Equals(other.ResponseCode) && (Queries.IsNullOrEmpty() && other.Queries.IsNullOrEmpty() || Queries.SequenceEqual(other.Queries)) && (Answers.IsNullOrEmpty() && other.Answers.IsNullOrEmpty() || Answers.SequenceEqual(other.Answers)) && (Authorities.IsNullOrEmpty() && other.Authorities.IsNullOrEmpty() || Authorities.SequenceEqual(other.Authorities)) && (Additionals.IsNullOrEmpty() && other.Additionals.IsNullOrEmpty() || Additionals.SequenceEqual(other.Additionals))); }
private bool VerifyEqualsObjectF(OpCode op, object ob, string errNum) { bool retVal = true; try { object obj = ob; if (op.Equals(obj)) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Result is not the value as expected,opcode is: " + op + ", object is: " + obj); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Unexpected exception: " + e); retVal = false; } return(retVal); }
internal void Ldobj(Type type) { OpCode ldindOpCode = this.GetLdindOpCode(Type.GetTypeCode(type)); if (!ldindOpCode.Equals(OpCodes.Nop)) { if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction(ldindOpCode.ToString()); } this.ilGen.Emit(ldindOpCode); } else { if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Ldobj " + type); } this.ilGen.Emit(OpCodes.Ldobj, type); } }
internal void Ldelem(Type arrayElementType) { if (arrayElementType.IsEnum) { this.Ldelem(Enum.GetUnderlyingType(arrayElementType)); } else { OpCode ldelemOpCode = this.GetLdelemOpCode(Type.GetTypeCode(arrayElementType)); if (ldelemOpCode.Equals(OpCodes.Nop)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxCodeGenArrayTypeIsNotSupported", new object[] { arrayElementType.FullName }))); } if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction(ldelemOpCode.ToString()); } this.ilGen.Emit(ldelemOpCode); this.EmitStackTop(arrayElementType); } }
internal void Stelem(Type arrayElementType) { if (arrayElementType.IsEnum) { Stelem(Enum.GetUnderlyingType(arrayElementType)); } else { OpCode opCode = GetStelemOpCode(Type.GetTypeCode(arrayElementType)); if (opCode.Equals(OpCodes.Nop)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenArrayTypeIsNotSupported, arrayElementType.FullName))); } if (codeGenTrace != CodeGenTrace.None) { EmitSourceInstruction(opCode.ToString()); } EmitStackTop(arrayElementType); ilGen.Emit(opCode); } }
internal void Ldobj(Type type) { OpCode opCode = GetLdindOpCode(Type.GetTypeCode(type)); if (!opCode.Equals(OpCodes.Nop)) { if (codeGenTrace != CodeGenTrace.None) { EmitSourceInstruction(opCode.ToString()); } ilGen.Emit(opCode); } else { if (codeGenTrace != CodeGenTrace.None) { EmitSourceInstruction("Ldobj " + type); } ilGen.Emit(OpCodes.Ldobj, type); } }
public override bool match(CodeInstruction instruction) { // Exact match. if (query == instruction) { return(true); } // Check Opcode if (!query.opcode.Equals(instruction.opcode) && !alt.Equals(instruction.opcode)) { return(false); } // Check Operand if (instruction.operand == null) { return(query.operand == null); } if (query.operand == null) { return(false); } if (instruction.operand.Equals(query.operand)) { return(true); } // In case the operand is an integer, but their boxing types don't match. try { if (Convert.ToInt64(instruction.operand) != Convert.ToInt64(query.operand)) { return(false); } return(true); } catch { return(false); } }
public static bool isCode(CodeInstruction code, OpCode opcode) { if (opcode.Equals(OpCodes.Ldarg) || opcode.Equals(OpCodes.Ldarg_S)) { return(code.opcode.Equals(OpCodes.Ldarg_0) || code.opcode.Equals(OpCodes.Ldarg_1) || code.opcode.Equals(OpCodes.Ldarg_2) || code.opcode.Equals(OpCodes.Ldarg_3) || code.opcode.Equals(OpCodes.Ldarg) || code.opcode.Equals(OpCodes.Ldarg_S)); } if (opcode.Equals(OpCodes.Ldloc) || opcode.Equals(OpCodes.Ldloc_S)) { return(code.opcode.Equals(OpCodes.Ldloc_0) || code.opcode.Equals(OpCodes.Ldloc_1) || code.opcode.Equals(OpCodes.Ldloc_2) || code.opcode.Equals(OpCodes.Ldloc_3) || code.opcode.Equals(OpCodes.Ldloc) || code.opcode.Equals(OpCodes.Ldloc_S)); } if (opcode.Equals(OpCodes.Stloc) || opcode.Equals(OpCodes.Stloc_S)) { return(code.opcode.Equals(OpCodes.Stloc_0) || code.opcode.Equals(OpCodes.Stloc_1) || code.opcode.Equals(OpCodes.Stloc_2) || code.opcode.Equals(OpCodes.Stloc_3) || code.opcode.Equals(OpCodes.Stloc) || code.opcode.Equals(OpCodes.Stloc_S)); } return(code.opcode.Equals(opcode)); }
private bool VerifyEqualsOpCodeT(OpCode op1, OpCode op2, string errNum) { bool retVal = true; try { if (!op1.Equals(op2)) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Result is not the value as expected,opcode1 is: " + op1 + ",opcode2 is: " + op2); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Unexpected exception: " + e); retVal = false; } return retVal; }
private static void Convert(ILGenerator il, Type source, Type target, bool isAddress) { Debug.Assert(!target.IsByRef); if (target == source) { return; } TypeInfo sourceTypeInfo = source.GetTypeInfo(); TypeInfo targetTypeInfo = target.GetTypeInfo(); if (source.IsByRef) { Debug.Assert(!isAddress); Type argType = source.GetElementType(); Ldind(il, argType); Convert(il, argType, target, isAddress); return; } if (targetTypeInfo.IsValueType) { if (sourceTypeInfo.IsValueType) { OpCode opCode = s_convOpCodes[GetTypeCode(target)]; Debug.Assert(!opCode.Equals(OpCodes.Nop)); il.Emit(opCode); } else { Debug.Assert(sourceTypeInfo.IsAssignableFrom(targetTypeInfo)); il.Emit(OpCodes.Unbox, target); if (!isAddress) { Ldind(il, target); } } } else if (targetTypeInfo.IsAssignableFrom(sourceTypeInfo)) { if (sourceTypeInfo.IsValueType) { if (isAddress) { Ldind(il, source); } il.Emit(OpCodes.Box, source); } } else { Debug.Assert(sourceTypeInfo.IsAssignableFrom(targetTypeInfo) || targetTypeInfo.IsInterface || sourceTypeInfo.IsInterface); if (target.IsGenericParameter) { // T GetProperty<T>() where T : class; Debug.Assert(targetTypeInfo.GenericParameterAttributes == GenericParameterAttributes.ReferenceTypeConstraint); il.Emit(OpCodes.Unbox_Any, target); } else { il.Emit(OpCodes.Castclass, target); } } }
internal void Emit(OpCode opcode, LocalBuilder local) { _ilg.Emit(opcode, local); int tempVal = local.LocalIndex; if (opcode.Equals(OpCodes.Ldloc)) { switch (tempVal) { case 0: opcode = OpCodes.Ldloc_0; break; case 1: opcode = OpCodes.Ldloc_1; break; case 2: opcode = OpCodes.Ldloc_2; break; case 3: opcode = OpCodes.Ldloc_3; break; default: if (tempVal <= 255) { opcode = OpCodes.Ldloc_S; } break; } } else if (opcode.Equals(OpCodes.Stloc)) { switch (tempVal) { case 0: opcode = OpCodes.Stloc_0; break; case 1: opcode = OpCodes.Stloc_1; break; case 2: opcode = OpCodes.Stloc_2; break; case 3: opcode = OpCodes.Stloc_3; break; default: if (tempVal <= 255) { opcode = OpCodes.Stloc_S; } break; } } else if (opcode.Equals(OpCodes.Ldloca)) { if (tempVal <= 255) { opcode = OpCodes.Ldloca_S; } } AdvanceOffset(opcode); if (opcode.OperandType == OperandType.InlineNone) { return; } else if (!OpCodes.TakesSingleByteArgument(opcode)) { _offset += 2; } else { _offset++; } AssertOffsetMatches(); }
private bool VerifyEqualsObjectF(OpCode op, object ob, string errNum) { bool retVal = true; try { object obj = ob; if (op.Equals(obj)) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Result is not the value as expected,opcode is: " + op + ", object is: " + obj); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError(errNum.ToString(), "Unexpected exception: " + e); retVal = false; } return retVal; }
private static void EmitExplicitNumericCast(FleeILGenerator ilg, Type sourceType, Type destType, IServiceProvider services) { TypeCode desttc = Type.GetTypeCode(destType); TypeCode sourcetc = Type.GetTypeCode(sourceType); bool unsigned = IsUnsignedType(sourceType); ExpressionOptions options = (ExpressionOptions)services.GetService(typeof(ExpressionOptions)); bool @checked = options.Checked; OpCode op = OpCodes.Nop; switch (desttc) { case TypeCode.SByte: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_I1_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_I1; } else { op = OpCodes.Conv_I1; } break; case TypeCode.Byte: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_U1_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_U1; } else { op = OpCodes.Conv_U1; } break; case TypeCode.Int16: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_I2_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_I2; } else { op = OpCodes.Conv_I2; } break; case TypeCode.UInt16: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_U2_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_U2; } else { op = OpCodes.Conv_U2; } break; case TypeCode.Int32: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_I4_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_I4; } else if (sourcetc != TypeCode.UInt32) { // Don't need to emit a convert for this case since, to the CLR, it is the same data type op = OpCodes.Conv_I4; } break; case TypeCode.UInt32: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_U4_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_U4; } else if (sourcetc != TypeCode.Int32) { op = OpCodes.Conv_U4; } break; case TypeCode.Int64: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_I8_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_I8; } else if (sourcetc != TypeCode.UInt64) { op = OpCodes.Conv_I8; } break; case TypeCode.UInt64: if (unsigned == true & @checked == true) { op = OpCodes.Conv_Ovf_U8_Un; } else if (@checked == true) { op = OpCodes.Conv_Ovf_U8; } else if (sourcetc != TypeCode.Int64) { op = OpCodes.Conv_U8; } break; case TypeCode.Single: op = OpCodes.Conv_R4; break; default: Debug.Assert(false, "Unknown cast dest type"); break; } if (op.Equals(OpCodes.Nop) == false) { ilg.Emit(op); } }
public List <Instruction> Convert(ILProcessor il, List <Instruction> opCodes, TypeReference source, TypeReference target, bool isAddress) { Debug.Assert(!target.IsByReference); if (target == source) { return(opCodes); } if (source.IsByReference) { Debug.Assert(!isAddress); TypeReference argType = source.GetElementType(); OpCode opCode = s_ldindOpCodes[GetTypeCode(argType)]; if (!opCode.Equals(OpCodes.Nop)) { opCodes.Add(il.Create(opCode)); } else { opCodes.Add(il.Create(OpCodes.Ldobj, argType)); } Convert(il, opCodes, argType, target, isAddress); return(opCodes); } if (target.IsValueType) { if (source.IsValueType) { OpCode opCode = s_convOpCodes[GetTypeCode(target)]; Debug.Assert(!opCode.Equals(OpCodes.Nop)); opCodes.Add(il.Create(opCode)); } else { Debug.Assert(IsAssignableFrom(source, target)); opCodes.Add(il.Create(OpCodes.Unbox_Any, ModuleDefinition.ImportReference(target))); if (!isAddress) { OpCode opCode = s_ldindOpCodes[GetTypeCode(target)]; if (!opCode.Equals(OpCodes.Nop)) { opCodes.Add(il.Create(opCode)); } else { opCodes.Add(il.Create(OpCodes.Ldobj, target)); } } } } else if (IsAssignableFrom(target, source)) { if (source.IsValueType) { if (isAddress) { OpCode opCode = s_ldindOpCodes[GetTypeCode(source)]; if (!opCode.Equals(OpCodes.Nop)) { il.Emit(opCode); } else { il.Emit(OpCodes.Ldobj, source); } } opCodes.Add(il.Create(OpCodes.Box, ModuleDefinition.ImportReference(source))); } } else { if (target.IsGenericParameter) { opCodes.Add(il.Create(OpCodes.Unbox_Any, ModuleDefinition.ImportReference(target))); } else { opCodes.Add(il.Create(OpCodes.Castclass, ModuleDefinition.ImportReference(target))); } } return(opCodes); }