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; 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 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; uint bp = ctx.Registers[DarksVMConstants.REG_BP].U4; var type = (Type) ctx.Instance.Data.LookupReference(ctx.Stack[sp].U4); ctx.Stack[sp] = new DarksVMSlot { U4 = (uint) SizeOfHelper.SizeOf(type) }; 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 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) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var bp = ctx.Registers[DarksVMConstants.REG_BP].U4; var size = ctx.Stack[sp].U4; ctx.Stack[sp] = new DarksVMSlot { U8 = (ulong)ctx.Stack.Localloc(bp, size) }; state = ExecutionState.Next; }
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) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var operand = ctx.Stack[sp]; if ((operand.U4 & 0x80000000) != 0) { operand.U8 = 0xffffffff00000000 | operand.U4; } 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) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var type = ctx.Stack[sp--].U4; ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; if (type == 1) { state = ExecutionState.Rethrow; } else { state = ExecutionState.Throw; } }
public void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var valueSlot = ctx.Stack[sp--]; var maxSlot = ctx.Stack[sp--]; var 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) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var adrSlot = ctx.Stack[sp]; var 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; }
public void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; ctx.Stack.SetTopPosition(++sp); var regId = ctx.ReadByte(); var slot = ctx.Registers[regId]; ctx.Stack[sp] = new DarksVMSlot { U8 = slot.U8 }; ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; 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; }
private static bool NeedTypedInvoke(DarksVMContext ctx, uint sp, MethodBase method, bool isNewObj) { if (!isNewObj && !method.IsStatic) { if (method.DeclaringType.IsValueType) { return(true); } } foreach (ParameterInfo param in method.GetParameters()) { if (param.ParameterType.IsByRef) { return(true); } } return(method is MethodInfo && ((MethodInfo)method).ReturnType.IsByRef ? true : false); }
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) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var adrSlot = ctx.Stack[sp--]; var 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 void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; ctx.Stack.SetTopPosition(++sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; ulong imm = ctx.ReadByte(); imm |= (ulong)ctx.ReadByte() << 8; imm |= (ulong)ctx.ReadByte() << 16; imm |= (ulong)ctx.ReadByte() << 24; ulong sx = (imm & 0x80000000) != 0 ? 0xffffffffUL << 32 : 0; ctx.Stack[sp] = new DarksVMSlot { U8 = sx | imm }; 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 unsafe void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var tblSlot = ctx.Stack[sp]; var valSlot = ctx.Stack[sp - 1]; sp -= 2; ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; var index = valSlot.U4; var len = *(ushort *)(tblSlot.U8 - 2); if (index < len) { ctx.Registers[DarksVMConstants.REG_IP].U8 += (ulong)(int)((uint *)tblSlot.U8)[index]; } 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(); var result = op1Slot.U8 * op2Slot.U8; slot.U8 = 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 (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[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; ulong result = op1Slot.U8 - op2Slot.U8; 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(result, op2Slot.U8, op1Slot.U8, result, ref fl, mask); ctx.Registers[DarksVMConstants.REG_FL].U1 = fl; state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var fieldSlot = ctx.Stack[sp--]; var valSlot = ctx.Stack[sp--]; var objSlot = ctx.Stack[sp--]; var field = (FieldInfo)ctx.Instance.Data.LookupReference(fieldSlot.U4); if (!field.IsStatic && objSlot.O == null) { throw new NullReferenceException(); } object value; if (Type.GetTypeCode(field.FieldType) == TypeCode.String && valSlot.O == null) { value = ctx.Instance.Data.LookupString(valSlot.U4); } else { value = 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) { // coreclr/src/vm/jithelpers.cpp JIT_Dbl2ULngOvf & JIT_Dbl2LngOvf uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp]; const double two63 = 2147483648.0 * 4294967296.0; const double two64 = 4294967296.0 * 4294967296.0; double value = valueSlot.R8; valueSlot.U8 = (ulong)(long)value; byte fl = (byte)(ctx.Registers[DarksVMConstants.REG_FL].U1 & ~DarksVMConstants.FL_OVERFLOW); if ((fl & DarksVMConstants.FL_UNSIGNED) != 0) { if (!(value > -1.0 && value < two64)) { fl |= DarksVMConstants.FL_OVERFLOW; } if (!(value < two63)) { valueSlot.U8 = (ulong)((long)value - two63) + 0x8000000000000000UL; } } else { if (!(value > -two63 - 0x402 && value < two63)) { fl |= DarksVMConstants.FL_OVERFLOW; } } ctx.Registers[DarksVMConstants.REG_FL].U1 = (byte)(fl & ~DarksVMConstants.FL_UNSIGNED); ctx.Stack[sp] = valueSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; DarksVMSlot valueSlot = ctx.Stack[sp]; byte fl = ctx.Registers[DarksVMConstants.REG_FL].U1; if ((fl & DarksVMConstants.FL_UNSIGNED) != 0) { valueSlot.R8 = valueSlot.U8; } else { valueSlot.R8 = (long)valueSlot.U8; } ctx.Registers[DarksVMConstants.REG_FL].U1 = (byte)(fl & ~DarksVMConstants.FL_UNSIGNED); ctx.Stack[sp] = valueSlot; state = ExecutionState.Next; }
public void Load(DarksVMContext ctx, out ExecutionState state) { uint sp = ctx.Registers[DarksVMConstants.REG_SP].U4; ctx.Stack.SetTopPosition(++sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; ulong imm = ctx.ReadByte(); imm |= (ulong)ctx.ReadByte() << 8; imm |= (ulong)ctx.ReadByte() << 16; imm |= (ulong)ctx.ReadByte() << 24; imm |= (ulong)ctx.ReadByte() << 32; imm |= (ulong)ctx.ReadByte() << 40; imm |= (ulong)ctx.ReadByte() << 48; imm |= (ulong)ctx.ReadByte() << 56; ctx.Stack[sp] = new DarksVMSlot { U8 = imm }; 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, PointerType.BYTE); } else { byte value = valSlot.U1; byte *ptr = (byte *)adrSlot.U8; * ptr = value; } state = ExecutionState.Next; }
public unsafe void Load(DarksVMContext ctx, out ExecutionState state) { var sp = ctx.Registers[DarksVMConstants.REG_SP].U4; var adrSlot = ctx.Stack[sp--]; var 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.QWORD); } else { var value = valSlot.U8; var ptr = (ulong *)adrSlot.U8; * ptr = value; } 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, PointerType.QWORD); } else { ulong *ptr = (ulong *)adrSlot.U8; valSlot = new DarksVMSlot { U8 = *ptr }; } ctx.Stack[sp] = valSlot; state = ExecutionState.Next; }