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