public void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var op1Slot = ctx.Stack[sp - 1]; var op2Slot = ctx.Stack[sp]; sp -= 1; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; var slot = new DarksVMSlot(); slot.R8 = op2Slot.R8 * op1Slot.R8; ctx.Stack[sp] = slot; var mask = (byte)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN | DarksVMConstants.FL_UNSIGNED); var fl = (byte)(ctx.Registers[DarksVMConstants.REG_FL].U1 & ~mask); if (slot.R8 == 0) { fl |= DarksVMConstants.FL_ZERO; } else if (slot.R8 < 0) { fl |= DarksVMConstants.FL_SIGN; } ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot fieldSlot = ctx.Stack[sp--]; DarksVMSlot valSlot = ctx.Stack[sp--]; DarksVMSlot objSlot = ctx.Stack[sp--]; var field = (FieldInfo)ctx.Instance.Data.LookupReference(fieldSlot.U4); if (!field.IsStatic && objSlot.O == null) { throw new NullReferenceException(); } object value = Type.GetTypeCode(field.FieldType) == TypeCode.String && valSlot.O == null ? ctx.Instance.Data.LookupString(valSlot.U4) : valSlot.ToObject(field.FieldType); if (field.DeclaringType.IsValueType && objSlot.O is IReference) { TypedReference typedRef; ((IReference)objSlot.O).ToTypedReference(ctx, &typedRef, field.DeclaringType); TypedReferenceHelpers.CastTypedRef(&typedRef, field.DeclaringType); field.SetValueDirect(typedRef, value); } else { field.SetValue(objSlot.ToObject(field.DeclaringType), value); } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot methodSlot = ctx.Stack[sp--]; DarksVMSlot objectSlot = ctx.Stack[sp]; if (objectSlot.O != null) { var method = (MethodInfo)ctx.Instance.Data.LookupReference(methodSlot.U4); Type type = objectSlot.O.GetType(); var baseTypes = new List <Type>(); do { baseTypes.Add(type); type = type.BaseType; } while(type != null && type != method.DeclaringType); baseTypes.Reverse(); MethodInfo found = method; const BindingFlags fl = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; foreach (Type baseType in baseTypes) { foreach (MethodInfo m in baseType.GetMethods(fl)) { if (m.GetBaseDefinition() == found) { found = m; break; } } } ctx.Stack[sp] = new DarksVMSlot { U8 = (ulong)found.MethodHandle.GetFunctionPointer() }; } if (objectSlot.U8 != 0) { // intra linking uint entryKey = ctx.Stack[--sp].U4; ulong codeAdr = methodSlot.U8; Data.DarksVMFuncSig sig = ctx.Instance.Data.LookupExport(objectSlot.U4).Signature; IntPtr ptr = DarksVMTrampoline.CreateTrampoline(ctx.Instance.Data.Module, codeAdr, entryKey, sig, objectSlot.U4); ctx.Stack[sp] = new DarksVMSlot { U8 = (ulong)ptr }; } else { var method = (MethodBase)ctx.Instance.Data.LookupReference(methodSlot.U4); ctx.Stack[sp] = new DarksVMSlot { U8 = (ulong)method.MethodHandle.GetFunctionPointer() }; } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot op1Slot = ctx.Stack[sp - 1]; DarksVMSlot op2Slot = ctx.Stack[sp]; sp -= 1; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; var slot = new DarksVMSlot(); 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)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN | DarksVMConstants.FL_OVERFLOW | DarksVMConstants.FL_CARRY); byte fl = ctx.Registers[DarksVMConstants.REG_FL].U1; Utils.UpdateFL(op1Slot.U8, op2Slot.U8, slot.U8, slot.U8, ref fl, mask); ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot op1Slot = ctx.Stack[sp - 1]; DarksVMSlot op2Slot = ctx.Stack[sp]; sp -= 2; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; double result = op1Slot.R8 - op2Slot.R8; byte mask = (byte)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN | DarksVMConstants.FL_OVERFLOW | DarksVMConstants.FL_CARRY); byte fl = (byte)(ctx.Registers[DarksVMConstants.REG_FL].U1 & ~mask); if (result == 0) { fl |= DarksVMConstants.FL_ZERO; } else if (result < 0) { fl |= DarksVMConstants.FL_SIGN; } ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var typeSlot = ctx.Stack[sp--]; var valSlot = ctx.Stack[sp]; var 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 = DarksVMSlot.FromObject(valSlot.O, valType); ctx.Stack[sp] = valSlot; } } else { if (valType == typeof(object) && valSlot.O != null) { valType = valSlot.O.GetType(); } valSlot = DarksVMSlot.FromObject(valSlot.O, valType); ctx.Stack[sp] = valSlot; } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot typeSlot = ctx.Stack[sp]; MemberInfo reference = ctx.Instance.Data.LookupReference(typeSlot.U4); switch (reference) { case Type _: typeSlot.O = ValueTypeBox.Box(((Type)reference).TypeHandle, typeof(RuntimeTypeHandle)); break; case MethodBase _: typeSlot.O = ValueTypeBox.Box(((MethodBase)reference).MethodHandle, typeof(RuntimeMethodHandle)); break; case FieldInfo _: typeSlot.O = ValueTypeBox.Box(((FieldInfo)reference).FieldHandle, typeof(RuntimeFieldHandle)); break; } ctx.Stack[sp] = typeSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot op1Slot = ctx.Stack[sp - 1]; DarksVMSlot op2Slot = ctx.Stack[sp]; sp -= 1; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; var slot = new DarksVMSlot(); slot.R4 = op1Slot.R4 / op2Slot.R4; ctx.Stack[sp] = slot; byte mask = (byte)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN); byte fl = (byte)(ctx.Registers[DarksVMConstants.REG_FL].U1 & ~mask); if (slot.R4 == 0) { fl |= DarksVMConstants.FL_ZERO; } else if (slot.R4 < 0) { fl |= DarksVMConstants.FL_SIGN; } ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot op1Slot = ctx.Stack[sp - 1]; DarksVMSlot op2Slot = ctx.Stack[sp]; sp -= 1; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; byte fl = ctx.Registers[DarksVMConstants.REG_FL].U1; var slot = new DarksVMSlot(); if ((fl & DarksVMConstants.FL_UNSIGNED) != 0) { slot.U8 = op1Slot.U8 / op2Slot.U8; } else { slot.U8 = (uint)((int)op1Slot.U8 / (int)op2Slot.U8); } ctx.Stack[sp] = slot; byte mask = (byte)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN | DarksVMConstants.FL_UNSIGNED); Utils.UpdateFL(op1Slot.U8, op2Slot.U8, slot.U8, slot.U8, ref fl, mask); ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp--]; switch (ctx.Registers[DarksVMConstants.REG_FL].U1 & DarksVMConstants.FL_UNSIGNED) { case 0: { double v = valueSlot.R8; if (double.IsNaN(v) || double.IsInfinity(v)) { throw new ArithmeticException(); } break; } default: { float v = valueSlot.R4; if (float.IsNaN(v) || float.IsInfinity(v)) { throw new ArithmeticException(); } break; } } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot typeSlot = ctx.Stack[sp--]; DarksVMSlot valSlot = ctx.Stack[sp]; var valType = (Type)ctx.Instance.Data.LookupReference(typeSlot.U4); switch (Type.GetTypeCode(valType)) { case TypeCode.String when valSlot.O == null: valSlot.O = ctx.Instance.Data.LookupString(valSlot.U4); break; default: Debug.Assert(valType.IsValueType); valSlot.O = valSlot.ToObject(valType); break; } ctx.Stack[sp] = valSlot; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot fieldSlot = ctx.Stack[sp--]; DarksVMSlot objSlot = ctx.Stack[sp]; var field = (FieldInfo)ctx.Instance.Data.LookupReference(fieldSlot.U4 & 0x7fffffff); if (!field.IsStatic && objSlot.O == null) { throw new NullReferenceException(); } if (!((fieldSlot.U4 & 0x80000000) != 0)) { object instance = field.DeclaringType.IsValueType && objSlot.O is IReference ? ((IReference)objSlot.O).GetValue(ctx, PointerType.OBJECT).ToObject(field.DeclaringType) : objSlot.ToObject(field.DeclaringType); ctx.Stack[sp] = DarksVMSlot.FromObject(field.GetValue(instance), field.FieldType); } else { ctx.Stack[sp] = new DarksVMSlot { O = new FieldRef(objSlot.O, field) }; } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot adrSlot = ctx.Stack[sp--]; DarksVMSlot valSlot = ctx.Stack[sp--]; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; if (adrSlot.O is IReference) { ((IReference)adrSlot.O).SetValue(ctx, valSlot, Platform.x64 ? PointerType.QWORD : PointerType.DWORD); } else { if (Platform.x64) { ulong *ptr = (ulong *)adrSlot.U8; * ptr = valSlot.U8; } else { uint *ptr = (uint *)adrSlot.U8; * ptr = valSlot.U4; } } state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot adrSlot = ctx.Stack[sp]; DarksVMSlot valSlot; if (adrSlot.O is IReference) { valSlot = ((IReference)adrSlot.O).GetValue(ctx, Platform.x64 ? PointerType.QWORD : PointerType.DWORD); } else { if (Platform.x64) { ulong *ptr = (ulong *)adrSlot.U8; valSlot = new DarksVMSlot { U8 = *ptr }; } else { uint *ptr = (uint *)adrSlot.U8; valSlot = new DarksVMSlot { U4 = *ptr }; } } ctx.Stack[sp] = valSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; ctx.Stack.SetTopPosition(++sp); byte regId = ctx.ReadByte(); DarksVMSlot slot = ctx.Registers[regId]; if (regId == DarksVMConstants.REG_SP || regId == DarksVMConstants.REG_BP) { ctx.Stack[sp] = new DarksVMSlot { O = new StackRef(slot.U4) } } ; else { ctx.Stack[sp] = new DarksVMSlot { U4 = slot.U4 } }; ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; } }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot slot = ctx.Stack[sp]; ctx.Stack[sp] = ctx.Registers[DarksVMConstants.REG_IP]; ctx.Registers[DarksVMConstants.REG_IP].U8 = slot.U8; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp]; valueSlot.R4 = (float)valueSlot.R8; ctx.Stack[sp] = valueSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot slot = ctx.Stack[sp]; ctx.Stack.SetTopPosition(--sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; VCalls.IVCall vCall = VCallMap.Lookup(slot.U1); vCall.Load(ctx, out state); }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot typeSlot = ctx.Stack[sp--]; DarksVMSlot addrSlot = ctx.Stack[sp--]; var type = (Type)ctx.Instance.Data.LookupReference(typeSlot.U4); if (!(addrSlot.O is IReference reference)) { throw new NotSupportedException(); }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot operand = ctx.Stack[sp]; if ((operand.U1 & 0x80) != 0) { operand.U4 = operand.U1 | 0xffffff00; } ctx.Stack[sp] = operand; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot fSlot = ctx.Stack[sp--]; if (fSlot.U4 != 0) { throw new OverflowException(); } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; ctx.Stack.SetTopPosition(++sp); byte regId = ctx.ReadByte(); DarksVMSlot slot = ctx.Registers[regId]; ctx.Stack[sp] = slot; ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp--]; DarksVMSlot maxSlot = ctx.Stack[sp--]; DarksVMSlot minSlot = ctx.Stack[sp]; valueSlot.U8 = (long)valueSlot.U8 > (long)maxSlot.U8 || (long)valueSlot.U8 < (long)minSlot.U8 ? 1u : 0; ctx.Stack[sp] = valueSlot; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot adrSlot = ctx.Stack[sp]; DarksVMSlot valSlot = ctx.Stack[sp - 1]; sp -= 2; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; if (valSlot.U8 != 0) { ctx.Registers[DarksVMConstants.REG_IP].U8 = adrSlot.U8; } state = ExecutionState.Next; }
private static IReference PopRef(DarksVMContext ctx, Type type, ref uint sp) { DarksVMSlot arg = ctx.Stack[sp]; if (type.IsByRef) { sp--; type = type.GetElementType(); return(arg.O is Pointer ? new PointerRef(Pointer.Unbox(arg.O)) : arg.O is IReference ? (IReference)arg.O : new PointerRef((void *)arg.U8)); } if (Type.GetTypeCode(type) == TypeCode.String && arg.O == null) { arg.O = ctx.Instance.Data.LookupString(arg.U4); ctx.Stack[sp] = arg; } return(new StackRef(sp--)); }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp]; byte fl = (byte)(ctx.Registers[DarksVMConstants.REG_FL].U1 & ~DarksVMConstants.FL_OVERFLOW); if (!Platform.x64 && valueSlot.U8 >> 32 != 0) { fl |= DarksVMConstants.FL_OVERFLOW; } ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; ctx.Stack[sp] = valueSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var op1Slot = ctx.Stack[sp - 1]; var op2Slot = ctx.Stack[sp]; sp -= 1; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; var fl = ctx.Registers[DarksVMConstants.REG_FL].U1; var slot = new DarksVMSlot(); ulong result = op1Slot.U4 * op2Slot.U4; slot.U4 = (uint)result; ctx.Stack[sp] = slot; var mask1 = (byte)(DarksVMConstants.FL_ZERO | DarksVMConstants.FL_SIGN | DarksVMConstants.FL_UNSIGNED); var mask2 = (byte)(DarksVMConstants.FL_CARRY | DarksVMConstants.FL_OVERFLOW); byte ovF = 0; if ((fl & DarksVMConstants.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[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot adrSlot = ctx.Stack[sp]; DarksVMSlot valSlot; if (adrSlot.O is IReference) { valSlot = ((IReference)adrSlot.O).GetValue(ctx, PointerType.OBJECT); } else { throw new ExecutionEngineException(); } ctx.Stack[sp] = valSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot adrSlot = ctx.Stack[sp--]; DarksVMSlot valSlot = ctx.Stack[sp--]; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; if (adrSlot.O is IReference) { ((IReference)adrSlot.O).SetValue(ctx, valSlot, PointerType.OBJECT); } else { throw new ExecutionEngineException(); } state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot tblSlot = ctx.Stack[sp]; DarksVMSlot valSlot = ctx.Stack[sp - 1]; sp -= 2; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; uint index = valSlot.U4; ushort len = *(ushort *)(tblSlot.U8 - 2); if (index < len) { ctx.Registers[DarksVMConstants.REG_IP].U8 += (ulong)(int)((uint *)tblSlot.U8)[index]; } state = ExecutionState.Next; }