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);
}
