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