internal unsafe override void Emulate(EmuContext ctx)
{
var slot = ctx.Stack.Pop();
VMSlot value = new VMSlot();
if (slot.O is IReference)
{
value = ((IReference)slot.O).GetValue(ctx, IntPtr.Size == 8 ? PointerType.QWORD : PointerType.DWORD);
}
else
{
if (IntPtr.Size == 8)
{
ulong *ptr = (ulong *)slot.U8;
value = new VMSlot {
U8 = *ptr
};
}
else
{
uint *ptr = (uint *)slot.U8;
value = new VMSlot {
U4 = *ptr
};
}
}
ctx.Stack.Push(value);
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot slot = ctx.Stack.Pop();
VMSlot slot2 = ctx.Stack.Pop();
Type type = (Type)ctx.Header.References[slot.U4];
bool flag = slot2.O is IReference;
if (flag)
{
IReference reference = (IReference)slot2.O;
VMSlot val = new VMSlot();
bool isValueType = type.IsValueType;
if (isValueType)
{
object vt = null;
bool flag2 = Nullable.GetUnderlyingType(type) == null;
if (flag2)
{
vt = FormatterServices.GetUninitializedObject(type);
}
slot.O = Box(vt, type);
}
else
{
slot.O = null;
}
}
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var op1Slot = ctx.Stack[sp - 1];
var op2Slot = ctx.Stack[sp];
sp -= 1;
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
var slot = new VMSlot();
if (op1Slot.O is IReference)
{
slot.O = ((IReference)op1Slot.O).Add(op2Slot.U8);
}
else if (op2Slot.O is IReference)
{
slot.O = ((IReference)op2Slot.O).Add(op1Slot.U8);
}
else
{
slot.U8 = op2Slot.U8 + op1Slot.U8;
}
ctx.Stack[sp] = slot;
byte mask = (byte)(Constants.FL_ZERO | Constants.FL_SIGN | Constants.FL_OVERFLOW | Constants.FL_CARRY);
var fl = ctx.Registers[Constants.REG_FL].U1;
Utils.UpdateFL(op1Slot.U8, op2Slot.U8, slot.U8, slot.U8, ref fl, mask);
ctx.Registers[Constants.REG_FL].U1 = fl;
state = ExecutionState.Next;
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var typeSlot = ctx.Stack[sp--];
var valSlot = ctx.Stack[sp];
bool unboxPtr = (typeSlot.U4 & 0x80000000) != 0;
var valType = (Type)ctx.Instance.Data.LookupReference(typeSlot.U4 & ~0x80000000);
if (unboxPtr)
{
unsafe {
TypedReference typedRef;
TypedReferenceHelpers.UnboxTypedRef(valSlot.O, &typedRef);
var reference = new TypedRef(typedRef);
valSlot = VMSlot.FromObject(valSlot.O, valType);
ctx.Stack[sp] = valSlot;
}
}
else
{
if (valType == typeof(object) && valSlot.O != null)
{
valType = valSlot.O.GetType();
}
valSlot = VMSlot.FromObject(valSlot.O, valType);
ctx.Stack[sp] = valSlot;
}
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
state = ExecutionState.Next;
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var op1Slot = ctx.Stack[sp - 1];
var op2Slot = ctx.Stack[sp];
sp -= 1;
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
var fl = ctx.Registers[Constants.REG_FL].U1;
var slot = new VMSlot();
if ((fl & Constants.FL_UNSIGNED) != 0)
{
slot.U4 = op1Slot.U4 >> (int)op2Slot.U4;
}
else
{
slot.U4 = (uint)((int)op1Slot.U4 >> (int)op2Slot.U4);
}
ctx.Stack[sp] = slot;
byte mask = (byte)(Constants.FL_ZERO | Constants.FL_SIGN | Constants.FL_UNSIGNED);
Utils.UpdateFL(op1Slot.U4, op2Slot.U4, slot.U4, slot.U4, ref fl, mask);
ctx.Registers[Constants.REG_FL].U1 = fl;
state = ExecutionState.Next;
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var op1Slot = ctx.Stack[sp - 1];
var op2Slot = ctx.Stack[sp];
sp -= 1;
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
var slot = new VMSlot();
slot.R4 = op2Slot.R4 % op1Slot.R4;
ctx.Stack[sp] = slot;
byte mask = (byte)(Constants.FL_ZERO | Constants.FL_SIGN | Constants.FL_OVERFLOW | Constants.FL_CARRY);
var fl = (byte)(ctx.Registers[Constants.REG_FL].U1 & ~mask);
if (slot.R4 == 0)
{
fl |= Constants.FL_ZERO;
}
else if (slot.R4 < 0)
{
fl |= Constants.FL_SIGN;
}
ctx.Registers[Constants.REG_FL].U1 = fl;
state = ExecutionState.Next;
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot value = ctx.Stack.Pop();
MemberInfo memberInfo = (MemberInfo)ctx.Header.References[value.U4];
bool flag = memberInfo is Type;
if (flag)
{
value.O = ValueTypeBox.Box(((Type)memberInfo).TypeHandle, typeof(RuntimeTypeHandle));
}
else
{
bool flag2 = memberInfo is MethodBase;
if (flag2)
{
value.O = ValueTypeBox.Box(((MethodBase)memberInfo).MethodHandle, typeof(RuntimeMethodHandle));
}
else
{
bool flag3 = memberInfo is FieldInfo;
if (flag3)
{
value.O = ValueTypeBox.Box(((FieldInfo)memberInfo).FieldHandle, typeof(RuntimeFieldHandle));
}
}
}
ctx.Stack.Push(value);
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot slot = ctx.Stack.Pop();
byte u2 = ctx.Registers[(int)ctx.Constants.REG_FL].U1;
bool flag = (u2 & ctx.Constants.FL_UNSIGNED) > 0;
if (flag)
{
float r = slot.R4;
bool flag2 = float.IsNaN(r) || float.IsInfinity(r);
if (flag2)
{
//throw arithmeticexception
}
}
else
{
double r2 = slot.R8;
bool flag3 = double.IsNaN(r2) || double.IsInfinity(r2);
if (flag3)
{
//throw arithmeticexception
}
}
}
public unsafe void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var adrSlot = ctx.Stack[sp];
VMSlot valSlot;
if (adrSlot.O is IReference)
{
valSlot = ((IReference)adrSlot.O).GetValue(ctx, Platform.x64 ? PointerType.QWORD : PointerType.DWORD);
}
else
{
if (Platform.x64)
{
var ptr = (ulong *)adrSlot.U8;
valSlot = new VMSlot {
U8 = *ptr
};
}
else
{
var ptr = (uint *)adrSlot.U8;
valSlot = new VMSlot {
U4 = *ptr
};
}
}
ctx.Stack[sp] = valSlot;
state = ExecutionState.Next;
}
object Run(ulong codeAddr, uint key, VMFuncSig sig, object[] arguments)
{
if (currentCtx != null)
{
ctxStack.Push(currentCtx);
}
currentCtx = new VMContext(this);
try {
Debug.Assert(sig.ParamTypes.Length == arguments.Length);
currentCtx.Stack.SetTopPosition((uint)arguments.Length + 1);
for (uint i = 0; i < arguments.Length; i++)
{
currentCtx.Stack[i + 1] = VMSlot.FromObject(arguments[i], sig.ParamTypes[i]);
}
currentCtx.Stack[(uint)arguments.Length + 1] = new VMSlot {
U8 = 1
};
currentCtx.Registers[Constants.REG_K1] = new VMSlot {
U4 = key
};
currentCtx.Registers[Constants.REG_BP] = new VMSlot {
U4 = 0
};
currentCtx.Registers[Constants.REG_SP] = new VMSlot {
U4 = (uint)arguments.Length + 1
};
currentCtx.Registers[Constants.REG_IP] = new VMSlot {
U8 = codeAddr
};
VMDispatcher.Run(currentCtx);
Debug.Assert(currentCtx.EHStack.Count == 0);
object retVal = null;
if (sig.RetType != typeof(void))
{
var retSlot = currentCtx.Registers[Constants.REG_R0];
if (Type.GetTypeCode(sig.RetType) == TypeCode.String && retSlot.O == null)
{
retVal = Data.LookupString(retSlot.U4);
}
else
{
retVal = retSlot.ToObject(sig.RetType);
}
}
return(retVal);
}
finally {
currentCtx.Stack.FreeAllLocalloc();
if (ctxStack.Count > 0)
{
currentCtx = ctxStack.Pop();
}
}
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
byte b = ctx.ReadByte();
VMSlot value = ctx.Registers[(int)b];
ctx.Stack.Push(value);
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot slot = ctx.Stack.Pop();
slot.R4 = (float)slot.U8;
ctx.Stack.Push(slot);
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot value = ctx.Stack.Pop();
VMSlot slot = ctx.Stack.Pop();
VMSlot slot2 = ctx.Stack.Pop();
value.U8 = ((value.U8 > slot.U8 || value.U8 < slot2.U8) ? 1UL : 0UL);
ctx.Stack.Push(value);
}
internal override void Emulate(EmuContext ctx)
{
VMSlot first = ctx.Stack.Pop();
VMSlot second = ctx.Stack.Pop();
ctx.Stack.Push(new VMSlot()
{
U4 = first.U4 / second.U4
});
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
byte b = ctx.ReadByte();
VMSlot vmslot = ctx.Registers[(int)b];
ctx.Stack.Push(new VMSlot()
{
U8 = vmslot.U8
});
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot slot = ctx.Stack.Pop();
VMSlot slot2 = ctx.Stack.Pop();
VMSlot slotnew = new VMSlot();
ulong num2 = (ulong)(slot.U4 * slot2.U4);
slotnew.U4 = (uint)num2;
ctx.Stack.Push(slotnew);
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot first = ctx.Stack.Pop();
VMSlot second = ctx.Stack.Pop();
ctx.Stack.Push(new VMSlot()
{
R8 = second.R8 + first.R8
});
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot slot = ctx.Stack.Pop();
VMSlot slot2 = ctx.Stack.Pop();
ctx.Stack.Push(new VMSlot()
{
U4 = ~(slot.U4 | slot2.U4)
});
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot value = ctx.Stack.Pop();
bool flag = (value.U1 & 128) > 0;
if (flag)
{
value.U4 = ((uint)value.U1 | 4294967040u);
}
ctx.Stack.Push(value);
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
VMSlot value = ctx.Stack.Pop();
bool flag = (value.U4 & 2147483648u) > 0u;
if (flag)
{
value.U8 = (18446744069414584320UL | (ulong)value.U4);
}
ctx.Stack.Push(value);
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot slot = ctx.Stack.Pop();
VMSlot slot2 = ctx.Stack.Pop();
if (slot2.O != null)
{
MethodInfo methodInfo = (MethodInfo)ctx.Header.References[slot.U4];
Type type = slot2.O.GetType();
List <Type> list = new List <Type>();
do
{
list.Add(type);
type = type.BaseType;
}while (type != null && type != methodInfo.DeclaringType);
list.Reverse();
MethodInfo methodInfo2 = methodInfo;
foreach (Type type2 in list)
{
foreach (MethodInfo methodInfo3 in type2.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
bool flag2 = methodInfo3.GetBaseDefinition() == methodInfo2;
if (flag2)
{
methodInfo2 = methodInfo3;
break;
}
}
}
ctx.Stack.Push(new VMSlot()
{
U8 = (ulong)((long)methodInfo2.MethodHandle.GetFunctionPointer())
});
}
if (slot2.U8 > 0UL)
{
uint u = ctx.Stack.Pop().U4;
ulong u2 = slot.U8;
// VMFuncSig TODO: VMFuncSig,VMTrampoline
}
else
{
MethodBase methodBase = (MethodBase)ctx.Header.References[slot.U4];
ctx.Stack.Push(new VMSlot()
{
U8 = (ulong)((long)methodBase.MethodHandle.GetFunctionPointer())
});
}
}
internal override void Emulate(EmuContext ctx)
{
//throw new System.NotImplementedException();
ulong num2 = (ulong)ctx.ReadByte();
num2 |= (ulong)ctx.ReadByte() << 8;
num2 |= (ulong)ctx.ReadByte() << 16;
num2 |= (ulong)ctx.ReadByte() << 24;
int lol = int.MinValue;
ulong num3 = ((num2 & (ulong)lol) != 0UL) ? 18446744069414584320UL : 0UL;
VMSlot newslot = new VMSlot();
newslot.U8 = (num3 | num2);
ctx.Stack.Push(newslot);
}
internal override void Emulate(EmuContext ctx)
{
var slot = ctx.Stack.Pop();
VMSlot value = new VMSlot();
if (slot.O is IReference)
{
value = ((IReference)slot.O).GetValue(ctx, PointerType.OBJECT);
}
else
{
//throw exception?
}
ctx.Stack.Push(value);
}
internal override void EmulateVCall(EmuContext ctx)
{
VMSlot slot = ctx.Stack.Pop();
VMSlot value = ctx.Stack.Pop();
Type type = (Type)ctx.Header.References[slot.U4];
if (Type.GetTypeCode(type) == TypeCode.String && value.O == null)
{
value.O = ctx.Header.Strings[value.U4];
}
else
{
value.O = value.ToObject(type);
}
ctx.Stack.Push(value);
}
private static object PopObject(EmuContext ctx, Type type)
{
VMSlot vmslot = ctx.Stack.Pop();
bool flag = Type.GetTypeCode(type) == TypeCode.String && vmslot.O == null;
object result;
if (flag)
{
result = ctx.Header.References[vmslot.U4];
}
else
{
result = vmslot.ToObject(type);
}
return(result);
}
internal unsafe override void Emulate(EmuContext ctx)
{
var slot = ctx.Stack.Pop();
VMSlot value = new VMSlot();
if (slot.O is IReference)
{
value = ((IReference)slot.O).GetValue(ctx, PointerType.BYTE);
}
else
{
byte *ptr = (byte *)slot.U8;
value = new VMSlot {
U1 = *ptr
};
}
ctx.Stack.Push(value);
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var op1Slot = ctx.Stack[sp - 1];
var op2Slot = ctx.Stack[sp];
sp -= 1;
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
var fl = ctx.Registers[Constants.REG_FL].U1;
var slot = new VMSlot();
ulong result = op1Slot.U4 * op2Slot.U4;
slot.U4 = (uint)result;
ctx.Stack[sp] = slot;
byte mask1 = (byte)(Constants.FL_ZERO | Constants.FL_SIGN | Constants.FL_UNSIGNED);
byte mask2 = (byte)(Constants.FL_CARRY | Constants.FL_OVERFLOW);
byte ovF = 0;
if ((fl & Constants.FL_UNSIGNED) != 0)
{
if ((result & (0xffffffff << 32)) != 0)
{
ovF = mask2;
}
}
else
{
result = (ulong)((int)op1Slot.U4 * (int)op2Slot.U4);
if ((result >> 63) != (slot.U4 >> 31))
{
ovF = mask2;
}
}
fl = (byte)((fl & ~mask2) | ovF);
Utils.UpdateFL(op1Slot.U4, op2Slot.U4, slot.U4, slot.U4, ref fl, mask1);
ctx.Registers[Constants.REG_FL].U1 = fl;
state = ExecutionState.Next;
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var op1Slot = ctx.Stack[sp - 1];
var op2Slot = ctx.Stack[sp];
sp -= 1;
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
var fl = ctx.Registers[Constants.REG_FL].U1;
var slot = new VMSlot();
var result = op1Slot.U8 * op2Slot.U8;
slot.U8 = result;
ctx.Stack[sp] = slot;
var mask1 = (byte)(Constants.FL_ZERO | Constants.FL_SIGN | Constants.FL_UNSIGNED);
var mask2 = (byte)(Constants.FL_CARRY | Constants.FL_OVERFLOW);
byte ovF = 0;
if ((fl & Constants.FL_UNSIGNED) != 0)
{
if (Carry(op1Slot.U8, op2Slot.U8) != 0)
{
ovF = mask2;
}
}
else
{
if (result >> 63 != (op1Slot.U8 ^ op2Slot.U8) >> 63)
{
ovF = mask2;
}
}
fl = (byte)((fl & ~mask2) | ovF);
Utils.UpdateFL(op1Slot.U4, op2Slot.U8, slot.U8, slot.U8, ref fl, mask1);
ctx.Registers[Constants.REG_FL].U1 = fl;
state = ExecutionState.Next;
}
public void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var fieldSlot = ctx.Stack[sp--];
var objSlot = ctx.Stack[sp];
bool addr = (fieldSlot.U4 & 0x80000000) != 0;
var field = (FieldInfo)ctx.Instance.Data.LookupReference(fieldSlot.U4 & 0x7fffffff);
if (!field.IsStatic && objSlot.O == null)
{
throw new NullReferenceException();
}
if (addr)
{
ctx.Stack[sp] = new VMSlot {
O = new FieldRef(objSlot.O, field)
}
}
;
else
{
object instance;
if (field.DeclaringType.IsValueType && objSlot.O is IReference)
{
instance = ((IReference)objSlot.O).GetValue(ctx, PointerType.OBJECT).ToObject(field.DeclaringType);
}
else
{
instance = objSlot.ToObject(field.DeclaringType);
}
ctx.Stack[sp] = VMSlot.FromObject(field.GetValue(instance), field.FieldType);
}
ctx.Stack.SetTopPosition(sp);
ctx.Registers[Constants.REG_SP].U4 = sp;
state = ExecutionState.Next;
}
public unsafe void Run(VMContext ctx, out ExecutionState state)
{
var sp = ctx.Registers[Constants.REG_SP].U4;
var adrSlot = ctx.Stack[sp];
VMSlot valSlot;
if (adrSlot.O is IReference)
{
valSlot = ((IReference)adrSlot.O).GetValue(ctx, PointerType.WORD);
}
else
{
var ptr = (ushort *)adrSlot.U8;
valSlot = new VMSlot {
U2 = *ptr
};
}
ctx.Stack[sp] = valSlot;
state = ExecutionState.Next;
}
