pc += (jit_nint)(int)(pcmod); \
stacktop += (jit_nint)(int)(stkmod); \
} while (0)
+#define VM_MODIFY_PC(pcmod) \
+ do { \
+ pc += (jit_nint)(int)(pcmod); \
+ } while (0)
#define VM_MODIFY_STACK(stkmod) \
do { \
stacktop += (jit_nint)(int)(stkmod); \
#define VM_NINT_ARG3 (((jit_nint *)(pc))[3])
#define VM_BR_TARGET (pc + VM_NINT_ARG)
+/*
+ * Fetch registers of various types.
+ */
+#define VM_R0_INT (r0.int_value)
+#define VM_R0_UINT (r0.uint_value)
+#define VM_R0_LONG (r0.long_value)
+#define VM_R0_ULONG (r0.ulong_value)
+#define VM_R0_FLOAT32 (r0.float32_value)
+#define VM_R0_FLOAT64 (r0.float64_value)
+#define VM_R0_NFLOAT (r0.nfloat_value)
+#define VM_R0_PTR (r0.ptr_value)
+#define VM_R1_INT (r1.int_value)
+#define VM_R1_UINT (r1.uint_value)
+#define VM_R1_LONG (r1.long_value)
+#define VM_R1_ULONG (r1.ulong_value)
+#define VM_R1_FLOAT32 (r1.float32_value)
+#define VM_R1_FLOAT64 (r1.float64_value)
+#define VM_R1_NFLOAT (r1.nfloat_value)
+#define VM_R1_PTR (r1.ptr_value)
+#define VM_R2_INT (r2.int_value)
+#define VM_R2_UINT (r2.uint_value)
+#define VM_R2_LONG (r2.long_value)
+#define VM_R2_ULONG (r2.ulong_value)
+#define VM_R2_FLOAT32 (r2.float32_value)
+#define VM_R2_FLOAT64 (r2.float64_value)
+#define VM_R2_NFLOAT (r2.nfloat_value)
+#define VM_R2_PTR (r2.ptr_value)
+#ifdef JIT_NATIVE_INT32
+#define VM_R0_NINT VM_RO_INT
+#define VM_R0_NUINT VM_RO_UINT
+#define VM_R1_NINT VM_R1_INT
+#define VM_R1_NUINT VM_R1_UINT
+#define VM_R2_NINT VM_R2_INT
+#define VM_R2_NUINT VM_R2_UINT
+#else
+#define VM_R0_NINT VM_RO_LONG
+#define VM_R0_NUINT VM_RO_ULONG
+#define VM_R1_NINT VM_R1_LONG
+#define VM_R1_NUINT VM_R1_ULONG
+#define VM_R2_NINT VM_R2_LONG
+#define VM_R2_NUINT VM_R2_LONG
+#endif
+
/*
* Fetch stack items from various positions.
*/
* Apply an array adjustment to a pointer.
*/
#define VM_LOAD_ELEM(type) \
- (*(((type *)VM_STK_PTR1) + VM_STK_NINT0))
+ (*(((type *)VM_R1_PTR) + VM_R2_NINT))
#define VM_STORE_ELEM(type,value) \
- (*(((type *)VM_STK_PTR2) + VM_STK_NINT1) = (type)(value))
+ (*(((type *)VM_R0_PTR) + VM_R1_NINT) = (type)(value))
/*
* Get the address of an argument or local variable at a particular offset.
jit_item *frame_base;
jit_item *frame;
jit_item *stacktop;
+ jit_item r0, r1, r2;
void **pc;
jit_int builtin_exception;
jit_nint temparg;
VMCASE(JIT_OP_NOP):
{
/* Nothing to do except move on to the next instruction */
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_TRUNC_SBYTE):
{
/* Truncate an integer to a signed 8-bit value */
- VM_STK_INT0 = (jit_int)(jit_sbyte)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = (jit_int)(jit_sbyte)VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_TRUNC_UBYTE):
{
/* Truncate an integer to an unsigned 8-bit value */
- VM_STK_INT0 = (jit_int)(jit_ubyte)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = (jit_int)(jit_ubyte)VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_TRUNC_SHORT):
{
/* Truncate an integer to a signed 16-bit value */
- VM_STK_INT0 = (jit_int)(jit_short)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = (jit_int)(jit_short)VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_TRUNC_USHORT):
{
/* Truncate an integer to an unsigned 16-bit value */
- VM_STK_INT0 = (jit_int)(jit_ushort)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = (jit_int)(jit_ushort)VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
{
/* Truncate an integer to a signed 32-bit value */
/* In the interpreter, this is a NOP */
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_MODIFY_PC(1);
}
VMBREAK;
{
/* Truncate an integer to an unsigned 32-bit value */
/* In the interpreter, this is a NOP */
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_SBYTE):
{
/* Truncate an integer to a signed 8-bit value, and check */
- VM_BUILTIN(jit_int_to_sbyte_ovf(&VM_STK_INT0, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_int_to_sbyte_ovf(&VM_R0_INT, VM_R1_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_UBYTE):
{
/* Truncate an integer to an unsigned 8-bit value, and check */
- VM_BUILTIN(jit_int_to_ubyte_ovf(&VM_STK_INT0, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_int_to_ubyte_ovf(&VM_R0_INT, VM_R1_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_SHORT):
{
/* Truncate an integer to a signed 16-bit value, and check */
- VM_BUILTIN(jit_int_to_short_ovf(&VM_STK_INT0, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_int_to_short_ovf(&VM_R0_INT, VM_R1_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_USHORT):
{
/* Truncate an integer to an unsigned 16-bit value, and check */
- VM_BUILTIN(jit_int_to_ushort_ovf(&VM_STK_INT0, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_int_to_ushort_ovf(&VM_R0_INT, VM_R1_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_INT):
{
/* Truncate an integer to a signed 32-bit value, and check */
- VM_BUILTIN(jit_uint_to_int_ovf(&VM_STK_INT0, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_uint_to_int_ovf(&VM_R0_INT, VM_R1_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_UINT):
{
/* Truncate an integer to an unsigned 32-bit value, and check */
- VM_BUILTIN(jit_int_to_uint_ovf(&VM_STK_UINT0, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_int_to_uint_ovf(&VM_R0_UINT, VM_R1_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOW_WORD):
{
/* Fetch the low word of a 64-bit value */
- VM_STK_UINT0 = (jit_uint)VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_UINT = (jit_uint)VM_R1_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_EXPAND_INT):
{
/* Expand a signed 32-bit value to a 64-bit value */
- VM_STK_LONG0 = (jit_long)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_LONG = (jit_long)VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_EXPAND_UINT):
{
/* Expand an unsigned 32-bit value to a 64-bit value */
- VM_STK_ULONG0 = (jit_ulong)VM_STK_UINT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_ULONG = (jit_ulong)VM_R1_UINT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_LOW_WORD):
{
/* Fetch the low word of a 64-bit value, and check */
- VM_BUILTIN(jit_long_to_uint_ovf(&VM_STK_UINT0, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_long_to_uint_ovf(&VM_R0_UINT, VM_R1_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_SIGNED_LOW_WORD):
{
/* Fetch the signed low word of a 64-bit value, and check */
- VM_BUILTIN(jit_long_to_int_ovf(&VM_STK_INT0, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_long_to_int_ovf(&VM_R0_INT, VM_R1_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_LONG):
{
/* Convert unsigned 64-bit into signed, and check */
- VM_BUILTIN(jit_ulong_to_long_ovf(&VM_STK_LONG0, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_ulong_to_long_ovf(&VM_R0_LONG, VM_R1_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_ULONG):
{
/* Convert signed 64-bit into unsigned, and check */
- VM_BUILTIN(jit_long_to_ulong_ovf(&VM_STK_ULONG0, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_long_to_ulong_ovf(&VM_R0_ULONG, VM_R1_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_INT):
{
/* Convert native float into 32-bit signed integer */
- VM_STK_INT0 = jit_nfloat_to_int(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_nfloat_to_int(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_UINT):
{
/* Convert native float into 32-bit unsigned integer */
- VM_STK_UINT0 = jit_nfloat_to_uint(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_UINT = jit_nfloat_to_uint(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_LONG):
{
/* Convert native float into 64-bit signed integer */
- VM_STK_LONG0 = jit_nfloat_to_long(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_LONG = jit_nfloat_to_long(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_ULONG):
{
/* Convert native float into 64-bit unsigned integer */
- VM_STK_ULONG0 = jit_nfloat_to_ulong(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_ULONG = jit_nfloat_to_ulong(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_NFLOAT_TO_INT):
{
/* Convert native float into 32-bit signed integer, and check */
- VM_BUILTIN(jit_nfloat_to_int_ovf(&VM_STK_INT0, VM_STK_NFLOAT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_nfloat_to_int_ovf(&VM_R0_INT, VM_R1_NFLOAT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_NFLOAT_TO_UINT):
{
/* Convert native float into 32-bit unsigned integer, and check */
- VM_BUILTIN(jit_nfloat_to_uint_ovf(&VM_STK_UINT0, VM_STK_NFLOAT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_nfloat_to_uint_ovf(&VM_R0_UINT, VM_R1_NFLOAT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_NFLOAT_TO_LONG):
{
/* Convert native float into 64-bit signed integer, and check */
- VM_BUILTIN(jit_nfloat_to_long_ovf(&VM_STK_LONG0, VM_STK_NFLOAT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_nfloat_to_long_ovf(&VM_R0_LONG, VM_R1_NFLOAT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_NFLOAT_TO_ULONG):
{
/* Convert native float into 64-bit unsigned integer, and check */
- VM_BUILTIN(jit_nfloat_to_ulong_ovf(&VM_STK_ULONG0, VM_STK_NFLOAT0));
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_BUILTIN(jit_nfloat_to_ulong_ovf(&VM_R0_ULONG, VM_R1_NFLOAT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_INT_TO_NFLOAT):
{
/* Convert 32-bit signed integer into native float */
- VM_STK_NFLOAT0 = jit_int_to_nfloat(VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_int_to_nfloat(VM_R1_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_UINT_TO_NFLOAT):
{
/* Convert 32-bit unsigned integer into native float */
- VM_STK_NFLOAT0 = jit_uint_to_nfloat(VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_uint_to_nfloat(VM_R1_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LONG_TO_NFLOAT):
{
/* Convert 64-bit signed integer into native float */
- VM_STK_NFLOAT0 = jit_long_to_nfloat(VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_long_to_nfloat(VM_R1_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ULONG_TO_NFLOAT):
{
/* Convert 64-bit unsigned integer into native float */
- VM_STK_NFLOAT0 = jit_ulong_to_nfloat(VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_ulong_to_nfloat(VM_R1_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_FLOAT32):
{
/* Convert native float into 32-bit float */
- VM_STK_FLOAT320 = jit_nfloat_to_float32(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_nfloat_to_float32(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOAT_TO_FLOAT64):
{
/* Convert native float into 64-bit float */
- VM_STK_FLOAT640 = jit_nfloat_to_float64(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_nfloat_to_float64(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLOAT32_TO_NFLOAT):
{
/* Convert 32-bit float into native float */
- VM_STK_NFLOAT0 = jit_float32_to_nfloat(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_float32_to_nfloat(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLOAT64_TO_NFLOAT):
{
/* Convert 64-bit float into native float */
- VM_STK_NFLOAT0 = jit_float64_to_nfloat(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_float64_to_nfloat(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IADD):
{
/* Add signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 + VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT + VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IADD_OVF):
{
/* Add signed 32-bit integers, and check */
- VM_BUILTIN(jit_int_add_ovf
- (&VM_STK_INT1, VM_STK_INT1, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_int_add_ovf(&VM_R0_INT, VM_R1_INT, VM_R2_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IADD_OVF_UN):
{
/* Add unsigned 32-bit integers, and check */
- VM_BUILTIN(jit_uint_add_ovf
- (&VM_STK_UINT1, VM_STK_UINT1, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_uint_add_ovf(&VM_R0_UINT, VM_R1_UINT, VM_R2_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISUB):
{
/* Subtract signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 - VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT - VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISUB_OVF):
{
/* Subtract signed 32-bit integers, and check */
- VM_BUILTIN(jit_int_sub_ovf
- (&VM_STK_INT1, VM_STK_INT1, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_int_sub_ovf(&VM_R0_INT, VM_R1_INT, VM_R2_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISUB_OVF_UN):
{
/* Subtract unsigned 32-bit integers, and check */
- VM_BUILTIN(jit_uint_sub_ovf
- (&VM_STK_UINT1, VM_STK_UINT1, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_uint_sub_ovf(&VM_R0_UINT, VM_R1_UINT, VM_R2_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMUL):
{
/* Multiply signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 * VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT * VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMUL_OVF):
{
/* Multiply signed 32-bit integers, and check */
- VM_BUILTIN(jit_int_mul_ovf
- (&VM_STK_INT1, VM_STK_INT1, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_int_mul_ovf(&VM_R0_INT, VM_R1_INT, VM_R2_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMUL_OVF_UN):
{
/* Multiply unsigned 32-bit integers, and check */
- VM_BUILTIN(jit_uint_mul_ovf
- (&VM_STK_UINT1, VM_STK_UINT1, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_uint_mul_ovf(&VM_R0_UINT, VM_R1_UINT, VM_R2_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IDIV):
{
/* Divide signed 32-bit integers */
- VM_BUILTIN(jit_int_div
- (&VM_STK_INT1, VM_STK_INT1, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_int_div(&VM_R0_INT, VM_R1_INT, VM_R2_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IDIV_UN):
{
/* Divide unsigned 32-bit integers */
- VM_BUILTIN(jit_uint_div
- (&VM_STK_UINT1, VM_STK_UINT1, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_uint_div(&VM_R0_UINT, VM_R1_UINT, VM_R2_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IREM):
{
/* Remainder signed 32-bit integers */
- VM_BUILTIN(jit_int_rem
- (&VM_STK_INT1, VM_STK_INT1, VM_STK_INT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_int_rem(&VM_R0_INT, VM_R1_INT, VM_R2_INT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IREM_UN):
{
/* Remainder unsigned 32-bit integers */
- VM_BUILTIN(jit_uint_rem
- (&VM_STK_UINT1, VM_STK_UINT1, VM_STK_UINT0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_uint_rem(&VM_R0_UINT, VM_R1_UINT, VM_R2_UINT));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_INEG):
{
/* Negate signed 32-bit integer */
- VM_STK_INT0 = -VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = -VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LADD_OVF):
{
/* Add signed 64-bit integers, and check */
- VM_BUILTIN(jit_long_add_ovf
- (&VM_STK_LONG1, VM_STK_LONG1, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_long_add_ovf(&VM_R0_LONG, VM_R1_LONG, VM_R2_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LADD_OVF_UN):
{
/* Add unsigned 64-bit integers, and check */
- VM_BUILTIN(jit_ulong_add_ovf
- (&VM_STK_ULONG1, VM_STK_ULONG1, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_ulong_add_ovf(&VM_R0_ULONG, VM_R1_ULONG, VM_R2_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSUB):
{
/* Subtract signed 64-bit integers */
- VM_STK_LONG1 = VM_STK_LONG1 - VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_R1_LONG - VM_R2_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSUB_OVF):
{
/* Subtract signed 64-bit integers, and check */
- VM_BUILTIN(jit_long_sub_ovf
- (&VM_STK_LONG1, VM_STK_LONG1, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_long_sub_ovf(&VM_R0_LONG, VM_R1_LONG, VM_R2_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSUB_OVF_UN):
{
/* Subtract unsigned 64-bit integers, and check */
- VM_BUILTIN(jit_ulong_sub_ovf
- (&VM_STK_ULONG1, VM_STK_ULONG1, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_ulong_sub_ovf(&VM_R0_ULONG, VM_R1_ULONG, VM_R2_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMUL):
{
/* Multiply signed 64-bit integers */
- VM_STK_LONG1 = VM_STK_LONG1 * VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_R1_LONG * VM_R2_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMUL_OVF):
{
/* Multiply signed 64-bit integers, and check */
- VM_BUILTIN(jit_long_mul_ovf
- (&VM_STK_LONG1, VM_STK_LONG1, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_long_mul_ovf(&VM_R0_LONG, VM_R1_LONG, VM_R2_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMUL_OVF_UN):
{
/* Multiply unsigned 64-bit integers, and check */
- VM_BUILTIN(jit_ulong_mul_ovf
- (&VM_STK_ULONG1, VM_STK_ULONG1, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_ulong_mul_ovf(&VM_R0_ULONG, VM_R1_ULONG, VM_R2_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LDIV):
{
/* Divide signed 64-bit integers */
- VM_BUILTIN(jit_long_div
- (&VM_STK_LONG1, VM_STK_LONG1, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_long_div (&VM_R0_LONG, VM_R1_LONG, VM_R2_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LDIV_UN):
{
/* Divide unsigned 64-bit integers */
- VM_BUILTIN(jit_ulong_div
- (&VM_STK_ULONG1, VM_STK_ULONG1, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_ulong_div(&VM_R0_ULONG, VM_R1_ULONG, VM_R2_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LREM):
{
/* Remainder signed 64-bit integers */
- VM_BUILTIN(jit_long_rem
- (&VM_STK_LONG1, VM_STK_LONG1, VM_STK_LONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_long_rem(&VM_R0_LONG, VM_R1_LONG, VM_R2_LONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LREM_UN):
{
/* Remainder unsigned 64-bit integers */
- VM_BUILTIN(jit_ulong_rem
- (&VM_STK_ULONG1, VM_STK_ULONG1, VM_STK_ULONG0));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_BUILTIN(jit_ulong_rem(&VM_R0_ULONG, VM_R1_ULONG, VM_R2_ULONG));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LNEG):
{
/* Negate signed 64-bit integer */
- VM_STK_LONG0 = -VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_LONG = -VM_R1_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FADD):
{
/* Add 32-bit floats */
- VM_STK_FLOAT321 = VM_STK_FLOAT321 + VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = VM_R1_FLOAT32 + VM_R2_FLOAT32;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FSUB):
{
/* Subtract 32-bit floats */
- VM_STK_FLOAT321 = VM_STK_FLOAT321 - VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = VM_R1_FLOAT32 - VM_R2_FLOAT32;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FMUL):
{
/* Multiply 32-bit floats */
- VM_STK_FLOAT321 = VM_STK_FLOAT321 * VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = VM_R1_FLOAT32 * VM_R2_FLOAT32;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FDIV):
{
/* Divide 32-bit floats */
- VM_STK_FLOAT321 = VM_STK_FLOAT321 / VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = VM_R1_FLOAT32 / VM_R2_FLOAT32;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FREM):
{
/* Remainder 32-bit floats */
- VM_STK_FLOAT321 = jit_float32_rem
- (VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_rem(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FREM_IEEE):
{
/* Remainder 32-bit floats, with IEEE rules */
- VM_STK_FLOAT321 = jit_float32_ieee_rem
- (VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_ieee_rem(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FNEG):
{
/* Negate 32-bit float */
- VM_STK_FLOAT320 = -VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = -VM_R1_FLOAT32;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DADD):
{
/* Add 64-bit floats */
- VM_STK_FLOAT641 = VM_STK_FLOAT641 + VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = VM_R1_FLOAT64 + VM_R2_FLOAT64;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DSUB):
{
/* Subtract 64-bit floats */
- VM_STK_FLOAT641 = VM_STK_FLOAT641 - VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = VM_R1_FLOAT64 - VM_R2_FLOAT64;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DMUL):
{
/* Multiply 64-bit floats */
- VM_STK_FLOAT641 = VM_STK_FLOAT641 * VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = VM_R1_FLOAT64 * VM_R2_FLOAT64;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DDIV):
{
/* Divide 64-bit floats */
- VM_STK_FLOAT641 = VM_STK_FLOAT641 / VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = VM_R1_FLOAT64 / VM_R2_FLOAT64;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DREM):
{
/* Remainder 64-bit floats */
- VM_STK_FLOAT641 = jit_float64_rem
- (VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_rem(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DREM_IEEE):
{
/* Remainder 64-bit floats, with IEEE rules */
- VM_STK_FLOAT641 = jit_float64_ieee_rem
- (VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_ieee_rem(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DNEG):
{
/* Negate 64-bit float */
- VM_STK_FLOAT640 = -VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = -VM_R1_FLOAT64;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFADD):
{
/* Add native floats */
- VM_STK_NFLOAT1 = VM_STK_NFLOAT1 + VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = VM_R1_NFLOAT + VM_R2_NFLOAT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFSUB):
{
/* Subtract native floats */
- VM_STK_NFLOAT1 = VM_STK_NFLOAT1 - VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = VM_R1_NFLOAT - VM_R2_NFLOAT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFMUL):
{
/* Multiply native floats */
- VM_STK_NFLOAT1 = VM_STK_NFLOAT1 * VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = VM_R1_NFLOAT * VM_R2_NFLOAT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFDIV):
{
/* Divide native floats */
- VM_STK_NFLOAT1 = VM_STK_NFLOAT1 / VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = VM_R1_NFLOAT / VM_R2_NFLOAT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFREM):
{
/* Remainder native floats */
- VM_STK_NFLOAT1 = jit_nfloat_rem
- (VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_rem(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFREM_IEEE):
{
/* Remainder native floats, with IEEE rules */
- VM_STK_NFLOAT1 = jit_nfloat_ieee_rem
- (VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_ieee_rem(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFNEG):
{
/* Negate native float */
- VM_STK_NFLOAT0 = -VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = -VM_R1_NFLOAT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IAND):
{
/* Bitwise and signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 & VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT & VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IOR):
{
/* Bitwise or signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 | VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT | VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IXOR):
{
/* Bitwise xor signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 ^ VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT ^ VM_R2_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_INOT):
{
/* Bitwise not signed 32-bit integers */
- VM_STK_INT0 = ~VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = ~VM_R1_INT;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISHR):
{
/* Shift right signed 32-bit integers */
- VM_STK_INT1 = VM_STK_INT1 >> (VM_STK_UINT0 & 0x1F);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_R1_INT >> (VM_R2_UINT & 0x1F);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISHR_UN):
{
/* Shift right unsigned 32-bit integers */
- VM_STK_UINT1 = VM_STK_UINT1 >> (VM_STK_UINT0 & 0x1F);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_UINT = VM_R1_UINT >> (VM_R2_UINT & 0x1F);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LAND):
{
/* Bitwise and signed 64-bit integers */
- VM_STK_LONG1 = VM_STK_LONG1 & VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_R1_LONG & VM_R2_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOR):
{
/* Bitwise or signed 64-bit integers */
- VM_STK_LONG1 = VM_STK_LONG1 | VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_R1_LONG | VM_R2_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LXOR):
{
/* Bitwise xor signed 64-bit integers */
- VM_STK_LONG1 = VM_STK_LONG1 ^ VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_R1_LONG ^ VM_R2_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LNOT):
{
/* Bitwise not signed 64-bit integers */
- VM_STK_LONG0 = ~VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_LONG = ~VM_R1_LONG;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSHL):
{
/* Shift left signed 64-bit integers */
- VM_STK_LONG1 = (VM_STK_LONG1 << (VM_STK_UINT0 & 0x3F));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = (VM_R1_LONG << (VM_R2_UINT & 0x3F));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSHR):
{
/* Shift right signed 64-bit integers */
- VM_STK_LONG1 = (VM_STK_LONG1 >> (VM_STK_UINT0 & 0x3F));
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = (VM_R1_LONG >> (VM_R2_UINT & 0x3F));
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSHR_UN):
{
/* Shift right signed 64-bit integers */
- VM_STK_ULONG1 = (VM_STK_ULONG1 >> (VM_STK_UINT0 & 0x3F));
+ VM_R0_ULONG = (VM_R1_ULONG >> (VM_R2_UINT & 0x3F));
VM_MODIFY_PC_AND_STACK(1, 1);
}
VMBREAK;
VMCASE(JIT_OP_BR_IFALSE):
{
/* Branch if signed 32-bit integer is false */
- if(VM_STK_INT0 == 0)
+ if(VM_R1_INT == 0)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(1);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 1);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_ITRUE):
{
/* Branch if signed 32-bit integer is true */
- if(VM_STK_INT0 != 0)
+ if(VM_R1_INT != 0)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(1);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 1);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_IEQ):
{
/* Branch if signed 32-bit integers are equal */
- if(VM_STK_INT1 == VM_STK_INT0)
+ if(VM_R1_INT == VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_INE):
{
/* Branch if signed 32-bit integers are not equal */
- if(VM_STK_INT1 != VM_STK_INT0)
+ if(VM_R1_INT != VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_ILT):
{
/* Branch if signed 32-bit integers are less than */
- if(VM_STK_INT1 < VM_STK_INT0)
+ if(VM_R1_INT < VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_ILT_UN):
{
/* Branch if unsigned 32-bit integers are less than */
- if(VM_STK_UINT1 < VM_STK_UINT0)
+ if(VM_R1_UINT < VM_R2_UINT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_ILE):
{
/* Branch if signed 32-bit integers are less than or equal */
- if(VM_STK_INT1 <= VM_STK_INT0)
+ if(VM_R1_INT <= VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_ILE_UN):
{
/* Branch if unsigned 32-bit integers are less than or equal */
- if(VM_STK_UINT1 <= VM_STK_UINT0)
+ if(VM_R1_UINT <= VM_R2_UINT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_IGT):
{
/* Branch if signed 32-bit integers are greater than */
- if(VM_STK_INT1 > VM_STK_INT0)
+ if(VM_R1_INT > VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_IGT_UN):
{
/* Branch if unsigned 32-bit integers are greater than */
- if(VM_STK_UINT1 > VM_STK_UINT0)
+ if(VM_R1_UINT > VM_R2_UINT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_IGE):
{
/* Branch if signed 32-bit integers are greater than or equal */
- if(VM_STK_INT1 >= VM_STK_INT0)
+ if(VM_R1_INT >= VM_R2_INT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_IGE_UN):
{
/* Branch if unsigned 32-bit integers are greater than or equal */
- if(VM_STK_UINT1 >= VM_STK_UINT0)
+ if(VM_R1_UINT >= VM_R2_UINT)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LFALSE):
{
/* Branch if signed 64-bit integer is false */
- if(VM_STK_LONG0 == 0)
+ if(VM_R1_LONG == 0)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(1);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 1);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LTRUE):
{
/* Branch if signed 64-bit integer is true */
- if(VM_STK_LONG0 != 0)
+ if(VM_R1_LONG != 0)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(1);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 1);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LEQ):
{
/* Branch if signed 64-bit integers are equal */
- if(VM_STK_LONG1 == VM_STK_LONG0)
+ if(VM_R1_LONG == VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LNE):
{
/* Branch if signed 64-bit integers are not equal */
- if(VM_STK_LONG1 != VM_STK_LONG0)
+ if(VM_R1_LONG != VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LLT):
{
/* Branch if signed 64-bit integers are less than */
- if(VM_STK_LONG1 < VM_STK_LONG0)
+ if(VM_R1_LONG < VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LLT_UN):
{
/* Branch if unsigned 64-bit integers are less than */
- if(VM_STK_ULONG1 < VM_STK_ULONG0)
+ if(VM_R1_ULONG < VM_R2_ULONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LLE):
{
/* Branch if signed 64-bit integers are less than or equal */
- if(VM_STK_LONG1 <= VM_STK_LONG0)
+ if(VM_R1_LONG <= VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LLE_UN):
{
/* Branch if unsigned 64-bit integers are less than or equal */
- if(VM_STK_ULONG1 <= VM_STK_ULONG0)
+ if(VM_R1_ULONG <= VM_R2_ULONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LGT):
{
/* Branch if signed 64-bit integers are greater than */
- if(VM_STK_LONG1 > VM_STK_LONG0)
+ if(VM_R1_LONG > VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LGT_UN):
{
/* Branch if unsigned 64-bit integers are greater than */
- if(VM_STK_ULONG1 > VM_STK_ULONG0)
+ if(VM_R1_ULONG > VM_R2_ULONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LGE):
{
/* Branch if signed 64-bit integers are greater than or equal */
- if(VM_STK_LONG1 >= VM_STK_LONG0)
+ if(VM_R1_LONG >= VM_R2_LONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_LGE_UN):
{
/* Branch if unsigned 64-bit integers are greater than or equal */
- if(VM_STK_ULONG1 >= VM_STK_ULONG0)
+ if(VM_R1_ULONG >= VM_R2_ULONG)
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FEQ):
{
/* Branch if 32-bit floats are equal */
- if(jit_float32_eq(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FNE):
{
/* Branch if 32-bit floats are not equal */
- if(jit_float32_ne(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FLT):
{
/* Branch if 32-bit floats are less than */
- if(jit_float32_lt(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_lt(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FLE):
{
/* Branch if 32-bit floats are less than or equal */
- if(jit_float32_le(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_le(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FGT):
{
/* Branch if 32-bit floats are greater than */
- if(jit_float32_gt(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_gt(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FGE):
{
/* Branch if 32-bit floats are greater than or equal */
- if(jit_float32_ge(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(jit_float32_ge(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FEQ_INV):
{
/* Branch if 32-bit floats are equal; invert nan test */
- if(!jit_float32_ne(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FNE_INV):
{
/* Branch if 32-bit floats are not equal; invert nan test */
- if(!jit_float32_eq(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FLT_INV):
{
/* Branch if 32-bit floats are less than; invert nan test */
- if(!jit_float32_ge(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_ge(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FLE_INV):
{
/* Branch if 32-bit floats are less or equal; invert nan test */
- if(!jit_float32_gt(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_gt(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FGT_INV):
{
/* Branch if 32-bit floats are greater than; invert nan test */
- if(!jit_float32_le(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_le(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_FGE_INV):
{
/* Branch if 32-bit floats are greater or equal; invert nan test */
- if(!jit_float32_lt(VM_STK_FLOAT321, VM_STK_FLOAT320))
+ if(!jit_float32_lt(VM_R1_FLOAT32, VM_R2_FLOAT32))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DEQ):
{
/* Branch if 64-bit floats are equal */
- if(jit_float64_eq(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DNE):
{
/* Branch if 64-bit floats are not equal */
- if(jit_float64_ne(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DLT):
{
/* Branch if 64-bit floats are less than */
- if(jit_float64_lt(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_lt(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DLE):
{
/* Branch if 64-bit floats are less than or equal */
- if(jit_float64_le(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_le(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DGT):
{
/* Branch if 64-bit floats are greater than */
- if(jit_float64_gt(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_gt(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DGE):
{
/* Branch if 64-bit floats are greater than or equal */
- if(jit_float64_ge(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(jit_float64_ge(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DEQ_INV):
{
/* Branch if 64-bit floats are equal; invert nan test */
- if(!jit_float64_ne(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DNE_INV):
{
/* Branch if 64-bit floats are not equal; invert nan test */
- if(!jit_float64_eq(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DLT_INV):
{
/* Branch if 64-bit floats are less than; invert nan test */
- if(!jit_float64_ge(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_ge(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DLE_INV):
{
/* Branch if 64-bit floats are less or equal; invert nan test */
- if(!jit_float64_gt(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_gt(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DGT_INV):
{
/* Branch if 64-bit floats are greater than; invert nan test */
- if(!jit_float64_le(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_le(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_DGE_INV):
{
/* Branch if 64-bit floats are greater or equal; invert nan test */
- if(!jit_float64_lt(VM_STK_FLOAT641, VM_STK_FLOAT640))
+ if(!jit_float64_lt(VM_R1_FLOAT64, VM_R2_FLOAT64))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFEQ):
{
/* Branch if native floats are equal */
- if(jit_nfloat_eq(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFNE):
{
/* Branch if native floats are not equal */
- if(jit_nfloat_ne(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFLT):
{
/* Branch if native floats are less than */
- if(jit_nfloat_lt(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_lt(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFLE):
{
/* Branch if native floats are less than or equal */
- if(jit_nfloat_le(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_le(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFGT):
{
/* Branch if native floats are greater than */
- if(jit_nfloat_gt(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_gt(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFGE):
{
/* Branch if native floats are greater than or equal */
- if(jit_nfloat_ge(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(jit_nfloat_ge(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFEQ_INV):
{
/* Branch if native floats are equal; invert nan test */
- if(!jit_nfloat_ne(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFNE_INV):
{
/* Branch if native floats are not equal; invert nan test */
- if(!jit_nfloat_eq(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFLT_INV):
{
/* Branch if native floats are less than; invert nan test */
- if(!jit_nfloat_ge(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_ge(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFLE_INV):
{
/* Branch if native floats are less or equal; invert nan test */
- if(!jit_nfloat_gt(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_gt(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFGT_INV):
{
/* Branch if native floats are greater than; invert nan test */
- if(!jit_nfloat_le(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_le(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_BR_NFGE_INV):
{
/* Branch if native floats are greater or equal; invert nan test */
- if(!jit_nfloat_lt(VM_STK_NFLOAT1, VM_STK_NFLOAT0))
+ if(!jit_nfloat_lt(VM_R1_NFLOAT, VM_R2_NFLOAT))
{
pc = VM_BR_TARGET;
- VM_MODIFY_STACK(2);
}
else
{
- VM_MODIFY_PC_AND_STACK(2, 2);
+ VM_MODIFY_PC(2);
}
}
VMBREAK;
VMCASE(JIT_OP_JUMP_TABLE):
{
- if(VM_STK_INT0 < VM_NINT_ARG && VM_STK_INT0 >= 0)
+ if(VM_R0_INT < VM_NINT_ARG && VM_R0_INT >= 0)
{
- pc = pc[2 + VM_STK_INT0];
- VM_MODIFY_STACK(1);
+ pc = pc[2 + VM_R0_INT];
}
else
{
- VM_MODIFY_PC_AND_STACK(2 + VM_NINT_ARG, 1);
+ VM_MODIFY_PC(2 + VM_NINT_ARG);
}
}
VMBREAK;
VMCASE(JIT_OP_ICMP):
{
/* Compare signed 32-bit integers */
- VM_STK_INT1 = jit_int_cmp(VM_STK_INT1, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_int_cmp(VM_R1_INT, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ICMP_UN):
{
/* Compare unsigned 32-bit integers */
- VM_STK_UINT1 = jit_uint_cmp(VM_STK_UINT1, VM_STK_UINT0);
+ VM_R0_UINT = jit_uint_cmp(VM_R1_UINT, VM_R2_UINT);
VM_MODIFY_PC_AND_STACK(1, 1);
}
VMBREAK;
VMCASE(JIT_OP_LCMP):
{
/* Compare signed 64-bit integers */
- VM_STK_INT1 = jit_long_cmp(VM_STK_LONG1, VM_STK_LONG0);
+ VM_R0_INT = jit_long_cmp(VM_R1_LONG, VM_R2_LONG);
VM_MODIFY_PC_AND_STACK(1, 1);
}
VMBREAK;
VMCASE(JIT_OP_LCMP_UN):
{
/* Compare unsigned 64-bit integers */
- VM_STK_INT1 = jit_long_cmp(VM_STK_ULONG1, VM_STK_ULONG0);
+ VM_R0_INT = jit_long_cmp(VM_R1_ULONG, VM_R2_ULONG);
VM_MODIFY_PC_AND_STACK(1, 1);
}
VMBREAK;
VMCASE(JIT_OP_FCMPL):
{
/* Compare 32-bit floats, with less nan */
- VM_STK_INT1 = jit_float32_cmpl(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_cmpl(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FCMPG):
{
/* Compare 32-bit floats, with greater nan */
- VM_STK_INT1 = jit_float32_cmpg(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_cmpg(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DCMPL):
{
/* Compare 64-bit floats, with less nan */
- VM_STK_INT1 = jit_float64_cmpl(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_cmpl(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DCMPG):
{
/* Compare 64-bit floats, with greater nan */
- VM_STK_INT1 = jit_float64_cmpg(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_cmpg(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFCMPL):
{
/* Compare native floats, with less nan */
- VM_STK_INT1 = jit_float64_cmpl(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_cmpl(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFCMPG):
{
/* Compare native floats, with greater nan */
- VM_STK_INT1 = jit_float64_cmpg(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_cmpg(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IEQ):
{
/* Compare signed 32-bit integers for equal */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 == VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT == VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_INE):
{
/* Compare signed 32-bit integers for not equal */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 != VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT != VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ILT):
{
/* Compare signed 32-bit integers for less than */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 < VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT < VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ILT_UN):
{
/* Compare unsigned 32-bit integers for less than */
- VM_STK_INT1 = (jit_int)(VM_STK_UINT1 < VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_UINT < VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ILE):
{
/* Compare signed 32-bit integers for less than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 <= VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT <= VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ILE_UN):
{
/* Compare unsigned 32-bit integers for less than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_UINT1 <= VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_UINT <= VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IGT):
{
/* Compare signed 32-bit integers for greater than */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 > VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT > VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IGT_UN):
{
/* Compare unsigned 32-bit integers for greater than */
- VM_STK_INT1 = (jit_int)(VM_STK_UINT1 > VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_UINT > VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IGE):
{
/* Compare signed 32-bit integers for greater than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_INT1 >= VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_INT >= VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IGE_UN):
{
/* Compare unsigned 32-bit integers for greater than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_UINT1 >= VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_UINT >= VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LEQ):
{
/* Compare signed 64-bit integers for equal */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 == VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG == VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LNE):
{
/* Compare signed 64-bit integers for not equal */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 != VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG != VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LLT):
{
/* Compare signed 64-bit integers for less than */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 < VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG < VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LLT_UN):
{
/* Compare unsigned 64-bit integers for less than */
- VM_STK_INT1 = (jit_int)(VM_STK_ULONG1 < VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_ULONG < VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LLE):
{
/* Compare signed 64-bit integers for less than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 <= VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG <= VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LLE_UN):
{
/* Compare unsigned 64-bit integers for less than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_ULONG1 <= VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_ULONG <= VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LGT):
{
/* Compare signed 64-bit integers for greater than */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 > VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG > VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LGT_UN):
{
/* Compare unsigned 64-bit integers for greater than */
- VM_STK_INT1 = (jit_int)(VM_STK_ULONG1 > VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_ULONG > VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LGE):
{
/* Compare signed 64-bit integers for greater than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_LONG1 >= VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_LONG >= VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LGE_UN):
{
/* Compare unsigned 64-bit integers for greater than or equal */
- VM_STK_INT1 = (jit_int)(VM_STK_ULONG1 >= VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = (jit_int)(VM_R1_ULONG >= VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FEQ):
{
/* Compare 32-bit floats for equal */
- VM_STK_INT1 = jit_float32_eq(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FNE):
{
/* Compare 32-bit floats for not equal */
- VM_STK_INT1 = jit_float32_ne(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLT):
{
/* Compare 32-bit floats for less than */
- VM_STK_INT1 = jit_float32_lt(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_lt(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLE):
{
/* Compare 32-bit floats for less than or equal */
- VM_STK_INT1 = jit_float32_le(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_le(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FGT):
{
/* Compare 32-bit floats for greater than */
- VM_STK_INT1 = jit_float32_gt(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_gt(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FGE):
{
/* Compare 32-bit floats for greater than or equal */
- VM_STK_INT1 = jit_float32_ge(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float32_ge(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FEQ_INV):
{
/* Compare 32-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float32_ne(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FNE_INV):
{
/* Compare 32-bit floats for not equal; invert nan test */
- VM_STK_INT1 = !jit_float32_eq(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLT_INV):
{
/* Compare 32-bit floats for less than; invert nan test */
- VM_STK_INT1 = !jit_float32_ge(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_ge(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLE_INV):
{
/* Compare 32-bit floats for less than or equal; invert nan test */
- VM_STK_INT1 = !jit_float32_gt(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_gt(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FGT_INV):
{
/* Compare 32-bit floats for greater than; invert nan test */
- VM_STK_INT1 = !jit_float32_le(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_le(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FGE_INV):
{
/* Compare 32-bit floats for greater or equal; invert nan test */
- VM_STK_INT1 = !jit_float32_lt(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float32_lt(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DEQ):
{
/* Compare 64-bit floats for equal */
- VM_STK_INT1 = jit_float64_eq(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DNE):
{
/* Compare 64-bit floats for not equal */
- VM_STK_INT1 = jit_float64_ne(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLT):
{
/* Compare 64-bit floats for less than */
- VM_STK_INT1 = jit_float64_lt(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_lt(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLE):
{
/* Compare 64-bit floats for less than or equal */
- VM_STK_INT1 = jit_float64_le(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_le(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DGT):
{
/* Compare 64-bit floats for greater than */
- VM_STK_INT1 = jit_float64_gt(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_gt(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DGE):
{
/* Compare 64-bit floats for greater than or equal */
- VM_STK_INT1 = jit_float64_ge(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_float64_ge(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DEQ_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_ne(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DNE_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_eq(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLT_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_ge(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_ge(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLE_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_gt(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_gt(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DGT_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_le(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_le(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DGE_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
- VM_STK_INT1 = !jit_float64_lt(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_float64_lt(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFEQ):
{
/* Compare native floats for equal */
- VM_STK_INT1 = jit_nfloat_eq(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFNE):
{
/* Compare native floats for not equal */
- VM_STK_INT1 = jit_nfloat_ne(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLT):
{
/* Compare native floats for less than */
- VM_STK_INT1 = jit_nfloat_lt(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_lt(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLE):
{
/* Compare native floats for less than or equal */
- VM_STK_INT1 = jit_nfloat_le(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_le(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFGT):
{
/* Compare native floats for greater than */
- VM_STK_INT1 = jit_nfloat_gt(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_gt(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFGE):
{
/* Compare native floats for greater than or equal */
- VM_STK_INT1 = jit_nfloat_ge(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_nfloat_ge(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFEQ_INV):
{
/* Compare native floats for equal; invert nan test */
- VM_STK_INT1 = !jit_nfloat_ne(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFNE_INV):
{
/* Compare native floats for not equal; invert nan test */
- VM_STK_INT1 = !jit_nfloat_eq(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLT_INV):
{
/* Compare native floats for less than; invert nan test */
- VM_STK_INT1 = !jit_nfloat_ge(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_ge(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLE_INV):
{
/* Compare native floats for less than or equal; invert nan test */
- VM_STK_INT1 = !jit_nfloat_gt(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_gt(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFGT_INV):
{
/* Compare native floats for greater than; invert nan test */
- VM_STK_INT1 = !jit_nfloat_le(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_le(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFGE_INV):
{
/* Compare native floats for greater or equal; invert nan test */
- VM_STK_INT1 = !jit_nfloat_lt(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = !jit_nfloat_lt(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_FNAN):
{
/* Check a 32-bit float for "not a number" */
- VM_STK_INT0 = jit_float32_is_nan(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float32_is_nan(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_FINF):
{
/* Check a 32-bit float for "infinity" */
- VM_STK_INT0 = jit_float32_is_inf(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float32_is_inf(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_FFINITE):
{
/* Check a 32-bit float for "finite" */
- VM_STK_INT0 = jit_float32_is_finite(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float32_is_finite(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_DNAN):
{
/* Check a 64-bit float for "not a number" */
- VM_STK_INT0 = jit_float64_is_nan(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float64_is_nan(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_DINF):
{
/* Check a 64-bit float for "infinity" */
- VM_STK_INT0 = jit_float64_is_inf(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float64_is_inf(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_DFINITE):
{
/* Check a 64-bit float for "finite" */
- VM_STK_INT0 = jit_float64_is_finite(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float64_is_finite(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_NFNAN):
{
/* Check a native float for "not a number" */
- VM_STK_INT0 = jit_nfloat_is_nan(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_nfloat_is_nan(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_NFINF):
{
/* Check a native float for "infinity" */
- VM_STK_INT0 = jit_nfloat_is_inf(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_nfloat_is_inf(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IS_NFFINITE):
{
/* Check a native float for "finite" */
- VM_STK_INT0 = jit_nfloat_is_finite(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_nfloat_is_finite(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FACOS):
{
/* Compute 32-bit float "acos" */
- VM_STK_FLOAT320 = jit_float32_acos(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_acos(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FASIN):
{
/* Compute 32-bit float "asin" */
- VM_STK_FLOAT320 = jit_float32_asin(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_asin(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FATAN):
{
/* Compute 32-bit float "atan" */
- VM_STK_FLOAT320 = jit_float32_atan(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_atan(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FATAN2):
{
/* Compute 32-bit float "atan2" */
- VM_STK_FLOAT321 = jit_float32_atan2
- (VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_atan2(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FCEIL):
{
/* Compute 32-bit float "ceil" */
- VM_STK_FLOAT320 = jit_float32_ceil(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_ceil(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FCOS):
{
/* Compute 32-bit float "cos" */
- VM_STK_FLOAT320 = jit_float32_cos(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_cos(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FCOSH):
{
/* Compute 32-bit float "cosh" */
- VM_STK_FLOAT320 = jit_float32_cosh(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_cosh(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FEXP):
{
/* Compute 32-bit float "exp" */
- VM_STK_FLOAT320 = jit_float32_exp(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_exp(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FFLOOR):
{
/* Compute 32-bit float "floor" */
- VM_STK_FLOAT320 = jit_float32_floor(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_floor(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLOG):
{
/* Compute 32-bit float "log" */
- VM_STK_FLOAT320 = jit_float32_log(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_log(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FLOG10):
{
/* Compute 32-bit float "log10" */
- VM_STK_FLOAT320 = jit_float32_log10(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_log10(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FPOW):
{
/* Compute 32-bit float "pow" */
- VM_STK_FLOAT321 = jit_float32_pow
- (VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_pow(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FRINT):
{
/* Compute 32-bit float "rint" */
- VM_STK_FLOAT320 = jit_float32_rint(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_rint(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FROUND):
{
/* Compute 32-bit float "round" */
- VM_STK_FLOAT320 = jit_float32_round(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_round(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FSIN):
{
/* Compute 32-bit float "sin" */
- VM_STK_FLOAT320 = jit_float32_sin(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_sin(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FSINH):
{
/* Compute 32-bit float "sinh" */
- VM_STK_FLOAT320 = jit_float32_sinh(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_sinh(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FSQRT):
{
/* Compute 32-bit float "sqrt" */
- VM_STK_FLOAT320 = jit_float32_sqrt(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_sqrt(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FTAN):
{
/* Compute 32-bit float "tan" */
- VM_STK_FLOAT320 = jit_float32_tan(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_tan(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FTANH):
{
/* Compute 32-bit float "tanh" */
- VM_STK_FLOAT320 = jit_float32_tanh(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_tanh(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DACOS):
{
/* Compute 64-bit float "acos" */
- VM_STK_FLOAT640 = jit_float64_acos(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_acos(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DASIN):
{
/* Compute 64-bit float "asin" */
- VM_STK_FLOAT640 = jit_float64_asin(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_asin(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DATAN):
{
/* Compute 64-bit float "atan" */
- VM_STK_FLOAT640 = jit_float64_atan(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_atan(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DATAN2):
{
/* Compute 64-bit float "atan2" */
- VM_STK_FLOAT641 = jit_float64_atan2
- (VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_atan2(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DCEIL):
{
/* Compute 64-bit float "ceil" */
- VM_STK_FLOAT640 = jit_float64_ceil(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_ceil(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DCOS):
{
/* Compute 64-bit float "cos" */
- VM_STK_FLOAT640 = jit_float64_cos(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_cos(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DCOSH):
{
/* Compute 64-bit float "cosh" */
- VM_STK_FLOAT640 = jit_float64_cosh(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_cosh(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DEXP):
{
/* Compute 64-bit float "exp" */
- VM_STK_FLOAT640 = jit_float64_exp(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_exp(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DFLOOR):
{
/* Compute 64-bit float "floor" */
- VM_STK_FLOAT640 = jit_float64_floor(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_floor(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLOG):
{
/* Compute 64-bit float "log" */
- VM_STK_FLOAT640 = jit_float64_log(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_log(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DLOG10):
{
/* Compute 64-bit float "log10" */
- VM_STK_FLOAT640 = jit_float64_log10(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_log10(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DPOW):
{
/* Compute 64-bit float "pow" */
- VM_STK_FLOAT641 = jit_float64_pow
- (VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_pow(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DRINT):
{
/* Compute 64-bit float "rint" */
- VM_STK_FLOAT640 = jit_float64_rint(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_rint(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DROUND):
{
/* Compute 64-bit float "round" */
- VM_STK_FLOAT640 = jit_float64_round(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_round(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DSIN):
{
/* Compute 64-bit float "sin" */
- VM_STK_FLOAT640 = jit_float64_sin(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_sin(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DSINH):
{
/* Compute 64-bit float "sinh" */
- VM_STK_FLOAT640 = jit_float64_sinh(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_sinh(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DSQRT):
{
/* Compute 64-bit float "sqrt" */
- VM_STK_FLOAT640 = jit_float64_sqrt(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_sqrt(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DTAN):
{
/* Compute 64-bit float "tan" */
- VM_STK_FLOAT640 = jit_float64_tan(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_tan(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DTANH):
{
/* Compute 64-bit float "tanh" */
- VM_STK_FLOAT640 = jit_float64_tanh(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_tanh(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFACOS):
{
/* Compute native float "acos" */
- VM_STK_NFLOAT0 = jit_nfloat_acos(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_acos(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFASIN):
{
/* Compute native float "asin" */
- VM_STK_NFLOAT0 = jit_nfloat_asin(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_asin(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFATAN):
{
/* Compute native float "atan" */
- VM_STK_NFLOAT0 = jit_nfloat_atan(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_atan(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFATAN2):
{
/* Compute native float "atan2" */
- VM_STK_NFLOAT1 = jit_nfloat_atan2
- (VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_atan2(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFCEIL):
{
/* Compute native float "ceil" */
- VM_STK_NFLOAT0 = jit_nfloat_ceil(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_ceil(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFCOS):
{
/* Compute native float "cos" */
- VM_STK_NFLOAT0 = jit_nfloat_cos(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_cos(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFCOSH):
{
/* Compute native float "cosh" */
- VM_STK_NFLOAT0 = jit_nfloat_cosh(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_cosh(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFEXP):
{
/* Compute native float "exp" */
- VM_STK_NFLOAT0 = jit_nfloat_exp(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_exp(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFFLOOR):
{
/* Compute native float "floor" */
- VM_STK_NFLOAT0 = jit_nfloat_floor(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_floor(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOG):
{
/* Compute native float "log" */
- VM_STK_NFLOAT0 = jit_nfloat_log(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_log(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFLOG10):
{
/* Compute native float "log10" */
- VM_STK_NFLOAT0 = jit_nfloat_log10(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_log10(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFPOW):
{
/* Compute native float "pow" */
- VM_STK_NFLOAT1 = jit_nfloat_pow
- (VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_pow(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFRINT):
{
/* Compute native float "rint" */
- VM_STK_NFLOAT0 = jit_nfloat_rint(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_rint(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFROUND):
{
/* Compute native float "round" */
- VM_STK_NFLOAT0 = jit_nfloat_round(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_round(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFSIN):
{
/* Compute native float "sin" */
- VM_STK_NFLOAT0 = jit_nfloat_sin(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_sin(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFSINH):
{
/* Compute native float "sinh" */
- VM_STK_NFLOAT0 = jit_nfloat_sinh(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_sinh(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFSQRT):
{
/* Compute native float "sqrt" */
- VM_STK_NFLOAT0 = jit_nfloat_sqrt(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_sqrt(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFTAN):
{
/* Compute native float "tan" */
- VM_STK_NFLOAT0 = jit_nfloat_tan(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_tan(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFTANH):
{
/* Compute native float "tanh" */
- VM_STK_NFLOAT0 = jit_nfloat_tanh(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_tanh(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IABS):
{
/* Compute the absolute value of a signed 32-bit integer value */
- VM_STK_INT0 = jit_int_abs(VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_int_abs(VM_R1_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LABS):
{
/* Compute the absolute value of a signed 64-bit integer value */
- VM_STK_LONG0 = jit_long_abs(VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_LONG = jit_long_abs(VM_R1_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FABS):
{
/* Compute the absolute value of a 32-bit float value */
- VM_STK_FLOAT320 = jit_float32_abs(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT32 = jit_float32_abs(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DABS):
{
/* Compute the absolute value of a 64-bit float value */
- VM_STK_FLOAT640 = jit_float64_abs(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_FLOAT64 = jit_float64_abs(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFABS):
{
/* Compute the absolute value of a native float value */
- VM_STK_NFLOAT0 = jit_nfloat_abs(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_NFLOAT = jit_nfloat_abs(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMIN):
{
/* Compute the minimum of two signed 32-bit integer values */
- VM_STK_INT1 = jit_int_min(VM_STK_INT1, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_int_min(VM_R1_INT, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMIN_UN):
{
/* Compute the minimum of two unsigned 32-bit integer values */
- VM_STK_UINT1 = jit_uint_min(VM_STK_UINT1, VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_UINT = jit_uint_min(VM_R1_UINT, VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMIN):
{
/* Compute the minimum of two signed 64-bit integer values */
- VM_STK_LONG1 = jit_long_min(VM_STK_LONG1, VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = jit_long_min(VM_R1_LONG, VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMIN_UN):
{
/* Compute the minimum of two unsigned 64-bit integer values */
- VM_STK_ULONG1 = jit_ulong_min(VM_STK_ULONG1, VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_ULONG = jit_ulong_min(VM_R1_ULONG, VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FMIN):
{
/* Compute the minimum of two 32-bit float values */
- VM_STK_FLOAT321 = jit_float32_min(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_min(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DMIN):
{
/* Compute the minimum of two 64-bit float values */
- VM_STK_FLOAT641 = jit_float64_min(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_min(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFMIN):
{
/* Compute the minimum of two native float values */
- VM_STK_NFLOAT1 = jit_nfloat_min(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_min(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMAX):
{
/* Compute the maximum of two signed 32-bit integer values */
- VM_STK_INT1 = jit_int_max(VM_STK_INT1, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = jit_int_max(VM_R1_INT, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_IMAX_UN):
{
/* Compute the maximum of two unsigned 32-bit integer values */
- VM_STK_UINT1 = jit_uint_max(VM_STK_UINT1, VM_STK_UINT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_UINT = jit_uint_max(VM_R1_UINT, VM_R2_UINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMAX):
{
/* Compute the maximum of two signed 64-bit integer values */
- VM_STK_LONG1 = jit_long_max(VM_STK_LONG1, VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = jit_long_max(VM_R1_LONG, VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LMAX_UN):
{
/* Compute the maximum of two unsigned 64-bit integer values */
- VM_STK_ULONG1 = jit_ulong_max(VM_STK_ULONG1, VM_STK_ULONG0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_ULONG = jit_ulong_max(VM_R1_ULONG, VM_R2_ULONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_FMAX):
{
/* Compute the maximum of two 32-bit float values */
- VM_STK_FLOAT321 = jit_float32_max(VM_STK_FLOAT321, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = jit_float32_max(VM_R1_FLOAT32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DMAX):
{
/* Compute the maximum of two 64-bit float values */
- VM_STK_FLOAT641 = jit_float64_max(VM_STK_FLOAT641, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = jit_float64_max(VM_R1_FLOAT64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFMAX):
{
/* Compute the maximum of two native float values */
- VM_STK_NFLOAT1 = jit_nfloat_max(VM_STK_NFLOAT1, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = jit_nfloat_max(VM_R1_NFLOAT, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ISIGN):
{
/* Compute the sign of a signed 32-bit integer value */
- VM_STK_INT0 = jit_int_sign(VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_int_sign(VM_R1_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LSIGN):
{
/* Compute the sign of a signed 64-bit integer value */
- VM_STK_INT0 = jit_long_sign(VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_long_sign(VM_R1_LONG);
+ VM_MODIFY_PC(1);
}
- VMBREAK;
+ VMBREAK;
VMCASE(JIT_OP_FSIGN):
{
/* Compute the sign of a 32-bit float value */
- VM_STK_INT0 = jit_float32_sign(VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float32_sign(VM_R1_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_DSIGN):
{
/* Compute the sign of a 64-bit float value */
- VM_STK_INT0 = jit_float64_sign(VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_float64_sign(VM_R1_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_NFSIGN):
{
/* Compute the sign of a native float value */
- VM_STK_INT0 = jit_nfloat_sign(VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_INT = jit_nfloat_sign(VM_R1_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_CHECK_NULL):
{
/* Check the top of stack to see if it is null */
- if(!VM_STK_PTR0)
- {
- VM_BUILTIN(JIT_RESULT_NULL_REFERENCE);
- }
- VM_MODIFY_PC_AND_STACK(1, 0);
- }
- VMBREAK;
-
- VMCASE(JIT_OP_CHECK_NULL_N):
- {
- /* Check a pointer for null "n" items down the stack.
- This opcode is specific to the interpreter */
- if(!(stacktop[VM_NINT_ARG].ptr_value))
+ if(!VM_R1_PTR)
{
VM_BUILTIN(JIT_RESULT_NULL_REFERENCE);
}
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_MODIFY_PC(1);
}
VMBREAK;
{
/* Call a function that is under the control of the JIT */
call_func = (jit_function_t)VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_MODIFY_PC(2);
entry = call_func->entry_point;
_jit_backtrace_push(&call_trace, pc);
if(!entry)
{
entry = _jit_function_compile_on_demand(call_func);
}
- _jit_run_function((jit_function_interp_t)entry, stacktop,
- return_area);
+ _jit_run_function((jit_function_interp_t)entry,
+ stacktop,
+ return_area);
_jit_backtrace_pop();
}
VMBREAK;
/* Call a native function via an indirect pointer */
tempptr = (void *)VM_NINT_ARG;
temparg = VM_NINT_ARG2;
- VM_MODIFY_PC_AND_STACK(3, 2);
+ VM_MODIFY_PC_AND_STACK(3, 1);
_jit_backtrace_push(&call_trace, pc);
apply_from_interpreter((jit_type_t)tempptr,
- (void *)VM_STK_PTRP2,
- stacktop,
- (unsigned int)temparg,
- VM_STK_PTRP);
+ (void *)VM_R1_PTR,
+ stacktop,
+ (unsigned int)temparg,
+ VM_STK_PTRP);
_jit_backtrace_pop();
}
VMBREAK;
VMCASE(JIT_OP_CALL_VTABLE_PTR):
{
/* Call a JIT-managed function via an indirect vtable pointer */
- call_func = (jit_function_t)(VM_STK_PTR0);
+ call_func = (jit_function_t)(VM_R1_PTR);
if(!call_func)
{
VM_BUILTIN(JIT_RESULT_NULL_FUNCTION);
}
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_MODIFY_PC(1);
entry = call_func->entry_point;
_jit_backtrace_push(&call_trace, pc);
if(!entry)
{
entry = _jit_function_compile_on_demand(call_func);
}
- _jit_run_function((jit_function_interp_t)entry, stacktop,
- return_area);
+ _jit_run_function((jit_function_interp_t)entry,
+ stacktop,
+ return_area);
_jit_backtrace_pop();
}
VMBREAK;
VMCASE(JIT_OP_CALL_VTABLE_PTR_TAIL):
{
/* Tail call a JIT-managed function via indirect vtable pointer */
- call_func = (jit_function_t)(VM_STK_PTR0);
+ call_func = (jit_function_t)(VM_R1_PTR);
if(!call_func)
{
VM_BUILTIN(JIT_RESULT_NULL_FUNCTION);
VM_MODIFY_PC_AND_STACK(4, 1);
_jit_backtrace_push(&call_trace, pc);
apply_from_interpreter((jit_type_t)tempptr,
- (void *)tempptr2,
- stacktop,
- (unsigned int)temparg,
- VM_STK_PTRP);
+ (void *)tempptr2,
+ stacktop,
+ (unsigned int)temparg,
+ VM_STK_PTRP);
_jit_backtrace_pop();
}
VMBREAK;
VMCASE(JIT_OP_RETURN_INT):
{
/* Return from the current function, with an integer result */
- return_area->int_value = VM_STK_INT0;
+ return_area->int_value = VM_R1_INT;
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_RETURN_LONG):
{
/* Return from the current function, with a long result */
- return_area->long_value = VM_STK_LONG0;
+ return_area->long_value = VM_R1_LONG;
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_RETURN_FLOAT32):
{
/* Return from the current function, with a 32-bit float result */
- return_area->float32_value = VM_STK_FLOAT320;
+ return_area->float32_value = VM_R1_FLOAT32;
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_RETURN_FLOAT64):
{
/* Return from the current function, with a 64-bit float result */
- return_area->float64_value = VM_STK_FLOAT640;
+ return_area->float64_value = VM_R1_FLOAT64;
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_RETURN_NFLOAT):
{
/* Return from the current function, with a native float result */
- return_area->nfloat_value = VM_STK_NFLOAT0;
+ return_area->nfloat_value = VM_R1_NFLOAT;
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_RETURN_SMALL_STRUCT):
{
/* Return from the current function, with a small structure */
- #if JIT_APPLY_MAX_STRUCT_IN_REG != 0
- jit_memcpy(return_area->struct_value, VM_STK_PTR0,
- (unsigned int)VM_NINT_ARG);
- #endif
+#if JIT_APPLY_MAX_STRUCT_IN_REG != 0
+ jit_memcpy(return_area->struct_value,
+ VM_R1_PTR,
+ (unsigned int)VM_NINT_ARG);
+#endif
if(jbuf)
{
_jit_unwind_pop_setjmp();
VMCASE(JIT_OP_SETUP_FOR_NESTED):
{
+ /* TODO!!! */
/* Set up to call a nested function who is our child */
stacktop[-1].ptr_value = args;
stacktop[-2].ptr_value = frame;
VMCASE(JIT_OP_SETUP_FOR_SIBLING):
{
+ /* TODO!!! */
/* Set up to call a nested function who is our sibling, a sibling
of one of our ancestors, or one of our ancestors directly */
temparg = VM_NINT_ARG;
VMCASE(JIT_OP_IMPORT_LOCAL):
{
+ /* TODO!!! */
/* Import the address of a local variable from an outer scope */
temparg = VM_NINT_ARG2;
tempptr = args[0].ptr_value;
VMCASE(JIT_OP_IMPORT_ARG):
{
+ /* TODO!!! */
/* Import the address of an argument from an outer scope */
temparg = VM_NINT_ARG2;
tempptr = args[1].ptr_value;
}
VMBREAK;
+ VMCASE(JIT_OP_PUSH_INT):
+ {
+ VM_STK_INTP = VM_R1_INT;
+ VM_MODIFY_PC_AND_STACK(1, -1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_PUSH_LONG):
+ {
+ VM_STK_LONGP = VM_R1_LONG;
+ VM_MODIFY_PC_AND_STACK(1, -1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_PUSH_FLOAT32):
+ {
+ VM_STK_FLOAT32P = VM_R1_FLOAT32;
+ VM_MODIFY_PC_AND_STACK(1, -1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_PUSH_FLOAT64):
+ {
+ VM_STK_FLOAT64P = VM_R1_FLOAT64;
+ VM_MODIFY_PC_AND_STACK(1, -1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_PUSH_NFLOAT):
+ {
+ VM_STK_NFLOATP = VM_R1_NFLOAT;
+ VM_MODIFY_PC_AND_STACK(1, -1);
+ }
+ VMBREAK;
+
VMCASE(JIT_OP_PUSH_STRUCT):
{
/* Push a structure value onto the stack, given a pointer to it */
- tempptr = VM_STK_PTR0;
temparg = VM_NINT_ARG;
stacktop -= (JIT_NUM_ITEMS_IN_STRUCT(temparg) - 1);
- jit_memcpy(stacktop, tempptr, (unsigned int)temparg);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ jit_memcpy(stacktop, VM_R1_PTR, (unsigned int)temparg);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_THROW):
{
/* Throw an exception, which may be handled in this function */
- exception_object = VM_STK_PTR0;
+ exception_object = VM_R1_PTR;
handle_exception:
exception_pc = pc;
- if(jit_function_from_pc(func->func->context, pc, &handler)
- == func->func && handler != 0)
+ tempptr = jit_function_from_pc(func->func->context, pc, &handler);
+ if(tempptr == func->func && handler != 0)
{
/* We have an appropriate "catch" handler in this function */
pc = (void **)handler;
- stacktop = frame - 1;
- stacktop->ptr_value = exception_object;
+ stacktop = frame;
+ VM_R0_PTR = exception_object;
}
else
{
/* Throw the exception up to the next level */
- _jit_unwind_pop_setjmp();
+ if(jbuf)
+ {
+ _jit_unwind_pop_setjmp();
+ }
jit_exception_throw(exception_object);
}
}
VMCASE(JIT_OP_RETHROW):
{
/* Rethrow an exception to the caller */
- _jit_unwind_pop_setjmp();
- jit_exception_throw(VM_STK_PTR0);
+ if(jbuf)
+ {
+ _jit_unwind_pop_setjmp();
+ }
+ jit_exception_throw(VM_R1_PTR);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_PC):
{
/* Load the current program counter onto the stack */
- VM_STK_PTRP = (void *)pc;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ VM_R0_PTR = (void *)pc;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_EXCEPTION_PC):
{
/* Load the address where the exception occurred onto the stack */
- VM_STK_PTRP = (void *)exception_pc;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ VM_R0_PTR = (void *)exception_pc;
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LEAVE_FILTER):
{
+ /* TODO!!! */
/* Return from a "filter" handler: pc and value on stack */
pc = (void **)(stacktop[1].ptr_value);
stacktop[1] = stacktop[0];
VMCASE(JIT_OP_CALL_FILTER):
{
+ /* TODO!!! */
/* Call a "filter" handler with pc and value on stack */
stacktop[-1] = stacktop[0];
stacktop[0].ptr_value = (void *)(pc + 2);
VMCASE(JIT_OP_ADDRESS_OF_LABEL):
{
/* Load the address of a label onto the stack */
- VM_STK_PTRP = VM_BR_TARGET;
- VM_MODIFY_PC_AND_STACK(2, -1);
+ VM_R0_PTR = VM_BR_TARGET;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_SBYTE):
{
/* Load a signed 8-bit integer from a relative pointer */
- VM_STK_INT0 = *VM_REL(jit_sbyte, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_INT = *VM_REL(jit_sbyte, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_UBYTE):
{
/* Load an unsigned 8-bit integer from a relative pointer */
- VM_STK_INT0 = *VM_REL(jit_ubyte, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_INT = *VM_REL(jit_ubyte, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_SHORT):
{
/* Load a signed 16-bit integer from a relative pointer */
- VM_STK_INT0 = *VM_REL(jit_short, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_INT = *VM_REL(jit_short, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_USHORT):
{
/* Load an unsigned 16-bit integer from a relative pointer */
- VM_STK_INT0 = *VM_REL(jit_ushort, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_INT = *VM_REL(jit_ushort, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_INT):
{
/* Load a 32-bit integer from a relative pointer */
- VM_STK_INT0 = *VM_REL(jit_int, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_INT = *VM_REL(jit_int, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_LONG):
{
/* Load a 64-bit integer from a relative pointer */
- VM_STK_LONG0 = *VM_REL(jit_long, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_LONG = *VM_REL(jit_long, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_FLOAT32):
{
/* Load a 32-bit float from a relative pointer */
- VM_STK_FLOAT320 = *VM_REL(jit_float32, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_FLOAT32 = *VM_REL(jit_float32, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_FLOAT64):
{
/* Load a 64-bit float from a relative pointer */
- VM_STK_FLOAT640 = *VM_REL(jit_float64, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_FLOAT64 = *VM_REL(jit_float64, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_NFLOAT):
{
/* Load a native float from a relative pointer */
- VM_STK_NFLOAT0 = *VM_REL(jit_nfloat, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_NFLOAT = *VM_REL(jit_nfloat, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_RELATIVE_STRUCT):
{
/* Load a structure from a relative pointer */
- tempptr = VM_REL(void, VM_STK_PTR0);
- temparg = VM_NINT_ARG2;
- stacktop -= (JIT_NUM_ITEMS_IN_STRUCT(temparg) - 1);
- jit_memcpy(stacktop, tempptr, temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(&r0, VM_REL(void, VM_R1_PTR), VM_NINT_ARG2);
+ VM_MODIFY_PC(3);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_BYTE):
{
/* Store an 8-bit integer value to a relative pointer */
- *VM_REL(jit_sbyte, VM_STK_PTR1) = (jit_sbyte)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_sbyte, VM_R0_PTR) = (jit_sbyte)VM_R1_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_SHORT):
{
/* Store a 16-bit integer value to a relative pointer */
- *VM_REL(jit_short, VM_STK_PTR1) = (jit_short)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_short, VM_R0_PTR) = (jit_short)VM_R1_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_INT):
{
/* Store a 32-bit integer value to a relative pointer */
- *VM_REL(jit_int, VM_STK_PTR1) = VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_int, VM_R0_PTR) = VM_R1_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_LONG):
{
/* Store a 64-bit integer value to a relative pointer */
- *VM_REL(jit_long, VM_STK_PTR1) = VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_long, VM_R0_PTR) = VM_R1_LONG;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_FLOAT32):
{
/* Store a 32-bit float value to a relative pointer */
- *VM_REL(jit_float32, VM_STK_PTR1) = VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_float32, VM_R0_PTR) = VM_R1_FLOAT32;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_FLOAT64):
{
/* Store a 64-bit float value to a relative pointer */
- *VM_REL(jit_float64, VM_STK_PTR1) = VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_float64, VM_R0_PTR) = VM_R1_FLOAT64;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_NFLOAT):
{
/* Store a native float value to a relative pointer */
- *VM_REL(jit_nfloat, VM_STK_PTR1) = VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(2, 2);
+ *VM_REL(jit_nfloat, VM_R0_PTR) = VM_R1_NFLOAT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_STORE_RELATIVE_STRUCT):
{
/* Store a structure value to a relative pointer */
- temparg = VM_NINT_ARG2;
- tempptr = stacktop;
- stacktop += JIT_NUM_ITEMS_IN_STRUCT(temparg);
- jit_memcpy(VM_REL(void, VM_STK_PTR0), tempptr, temparg);
- VM_MODIFY_PC_AND_STACK(3, 1);
+ jit_memcpy(VM_REL(void, VM_R0_PTR), &r1, VM_NINT_ARG2);
+ VM_MODIFY_PC(3);
}
VMBREAK;
VMCASE(JIT_OP_ADD_RELATIVE):
{
/* Add a relative offset to a pointer */
- VM_STK_PTR0 = VM_REL(void, VM_STK_PTR0);
- VM_MODIFY_PC_AND_STACK(2, 0);
+ VM_R0_PTR = VM_REL(void, VM_R1_PTR);
+ VM_MODIFY_PC(2);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_SBYTE):
{
/* Load a signed 8-bit integer value from an array */
- VM_STK_INT1 = VM_LOAD_ELEM(jit_sbyte);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_LOAD_ELEM(jit_sbyte);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_UBYTE):
{
/* Load an unsigned 8-bit integer value from an array */
- VM_STK_INT1 = VM_LOAD_ELEM(jit_ubyte);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_LOAD_ELEM(jit_ubyte);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_SHORT):
{
/* Load a signed 16-bit integer value from an array */
- VM_STK_INT1 = VM_LOAD_ELEM(jit_short);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_LOAD_ELEM(jit_short);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_USHORT):
{
/* Load an unsigned 16-bit integer value from an array */
- VM_STK_INT1 = VM_LOAD_ELEM(jit_ushort);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_LOAD_ELEM(jit_ushort);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_INT):
{
/* Load a signed 32-bit integer value from an array */
- VM_STK_INT1 = VM_LOAD_ELEM(jit_int);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_INT = VM_LOAD_ELEM(jit_int);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_LONG):
{
/* Load a signed 64-bit integer value from an array */
- VM_STK_LONG1 = VM_LOAD_ELEM(jit_long);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_LONG = VM_LOAD_ELEM(jit_long);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_FLOAT32):
{
/* Load a 32-bit float value from an array */
- VM_STK_FLOAT321 = VM_LOAD_ELEM(jit_float32);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT32 = VM_LOAD_ELEM(jit_float32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_FLOAT64):
{
/* Load a 64-bit float value from an array */
- VM_STK_FLOAT641 = VM_LOAD_ELEM(jit_float64);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_FLOAT64 = VM_LOAD_ELEM(jit_float64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_LOAD_ELEMENT_NFLOAT):
{
/* Load a native float value from an array */
- VM_STK_NFLOAT1 = VM_LOAD_ELEM(jit_nfloat);
- VM_MODIFY_PC_AND_STACK(1, 1);
+ VM_R0_NFLOAT = VM_LOAD_ELEM(jit_nfloat);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_BYTE):
{
/* Store a 8-bit integer value to an array */
- VM_STORE_ELEM(jit_sbyte, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_sbyte, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_SHORT):
{
/* Store a 16-bit integer value to an array */
- VM_STORE_ELEM(jit_short, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_short, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_INT):
{
/* Store a 32-bit integer value to an array */
- VM_STORE_ELEM(jit_int, VM_STK_INT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_int, VM_R2_INT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_LONG):
{
/* Store a 64-bit integer value to an array */
- VM_STORE_ELEM(jit_long, VM_STK_LONG0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_long, VM_R2_LONG);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_FLOAT32):
{
/* Store a 32-bit float value to an array */
- VM_STORE_ELEM(jit_float32, VM_STK_FLOAT320);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_float32, VM_R2_FLOAT32);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_FLOAT64):
{
/* Store a 64-bit float value to an array */
- VM_STORE_ELEM(jit_float64, VM_STK_FLOAT640);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_float64, VM_R2_FLOAT64);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_STORE_ELEMENT_NFLOAT):
{
/* Store a native float value to an array */
- VM_STORE_ELEM(jit_nfloat, VM_STK_NFLOAT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ VM_STORE_ELEM(jit_nfloat, VM_R2_NFLOAT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_MEMCPY):
{
/* Copy a block of memory */
- jit_memcpy(VM_STK_PTR2, VM_STK_PTR1, VM_STK_NUINT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ jit_memcpy(VM_R0_PTR, VM_R1_PTR, VM_R2_NUINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_MEMMOVE):
{
/* Move a block of memory */
- jit_memmove(VM_STK_PTR2, VM_STK_PTR1, VM_STK_NUINT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ jit_memmove(VM_R0_PTR, VM_R1_PTR, VM_R2_NUINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_MEMSET):
{
/* Set a block of memory to a value */
- jit_memset(VM_STK_PTR2, (int)VM_STK_INT1, VM_STK_NUINT0);
- VM_MODIFY_PC_AND_STACK(1, 3);
+ jit_memset(VM_R0_PTR, (int)VM_R1_INT, VM_R2_NUINT);
+ VM_MODIFY_PC(1);
}
VMBREAK;
VMCASE(JIT_OP_ALLOCA):
{
/* Allocate memory from the stack */
- VM_STK_PTR0 = (void *)alloca(VM_STK_NUINT0);
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_R0_PTR = (void *)alloca(VM_R1_NUINT);
+ VM_MODIFY_PC(1);
/* We need to reset the "setjmp" point for this function
because the saved stack pointer is no longer the same.
* Argument variable access opcodes.
******************************************************************/
- VMCASE(JIT_OP_LDARG_SBYTE):
+ VMCASE(JIT_OP_LDA_0_SBYTE):
{
- /* Load a signed 8-bit integer argument onto the stack */
- VM_STK_INTP = *VM_ARG(jit_sbyte);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a signed 8-bit integer argument into the register 0 */
+ VM_R0_INT = *VM_ARG(jit_sbyte);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_UBYTE):
+ VMCASE(JIT_OP_LDA_0_UBYTE):
{
- /* Load an unsigned 8-bit integer argument onto the stack */
- VM_STK_INTP = *VM_ARG(jit_ubyte);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load an unsigned 8-bit integer argument into the register 0 */
+ VM_R0_INT = *VM_ARG(jit_ubyte);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_SHORT):
+ VMCASE(JIT_OP_LDA_0_SHORT):
{
- /* Load a signed 16-bit integer argument onto the stack */
- VM_STK_INTP = *VM_ARG(jit_short);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a signed 16-bit integer argument into the register 0 */
+ VM_R0_INT = *VM_ARG(jit_short);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_USHORT):
+ VMCASE(JIT_OP_LDA_0_USHORT):
{
- /* Load an unsigned 16-bit integer argument onto the stack */
- VM_STK_INTP = *VM_ARG(jit_ushort);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load am unsigned 16-bit argument local into the register 0 */
+ VM_R0_INT = *VM_ARG(jit_ushort);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_INT):
+ VMCASE(JIT_OP_LDA_0_INT):
{
- /* Load a 32-bit integer argument onto the stack */
- VM_STK_INTP = *VM_ARG(jit_int);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit integer argument into the register 0 */
+ VM_R0_INT = *VM_ARG(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_LONG):
+ VMCASE(JIT_OP_LDA_0_LONG):
{
- /* Load a 64-bit integer argument onto the stack */
- VM_STK_LONGP = *VM_ARG(jit_long);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 64-bit integer argument into the register 0 */
+ VM_R0_LONG = *VM_ARG(jit_long);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_FLOAT32):
+ VMCASE(JIT_OP_LDA_0_FLOAT32):
{
- /* Load a 32-bit float argument onto the stack */
- VM_STK_FLOAT32P = *VM_ARG(jit_float32);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit float argument into the register 0 */
+ VM_R0_FLOAT32 = *VM_ARG(jit_float32);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_FLOAT64):
+ VMCASE(JIT_OP_LDA_0_FLOAT64):
{
- /* Load a 64-bit float argument onto the stack */
- VM_STK_FLOAT64P = *VM_ARG(jit_float64);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 64-bit float argument into the register 0 */
+ VM_R0_FLOAT64 = *VM_ARG(jit_float64);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_NFLOAT):
+ VMCASE(JIT_OP_LDA_0_NFLOAT):
{
- /* Load a native float argument onto the stack */
- VM_STK_NFLOATP = *VM_ARG(jit_nfloat);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a native float argument into the register 0 */
+ VM_R0_NFLOAT = *VM_ARG(jit_nfloat);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARG_STRUCT):
+ VMCASE(JIT_OP_LDA_0_STRUCT):
{
- /* Load a structure argument onto the stack */
+ /* Load a structure argument into the register 0 */
temparg = VM_NINT_ARG2;
- stacktop -= JIT_NUM_ITEMS_IN_STRUCT(temparg);
- jit_memcpy(stacktop, VM_ARG(void), temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(&r0, VM_ARG(void), temparg);
+ VM_MODIFY_PC(3);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDAA_0):
+ {
+ /* Load the address of an argument into the register 0 */
+ VM_R0_PTR = VM_ARG(void);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_SBYTE):
+ {
+ /* Load a signed 8-bit integer argument into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_sbyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_UBYTE):
+ {
+ /* Load an unsigned 8-bit integer argument into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_ubyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_SHORT):
+ {
+ /* Load a signed 16-bit integer argument into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_short);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_USHORT):
+ {
+ /* Load am unsigned 16-bit argument local into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_ushort);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_INT):
+ {
+ /* Load a 32-bit integer argument into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_int);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_LONG):
+ {
+ /* Load a 64-bit integer argument into the register 1 */
+ VM_R1_LONG = *VM_ARG(jit_long);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_FLOAT32):
+ {
+ /* Load a 32-bit float argument into the register 1 */
+ VM_R1_FLOAT32 = *VM_ARG(jit_float32);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_FLOAT64):
+ {
+ /* Load a 64-bit float argument into the register 1 */
+ VM_R1_FLOAT64 = *VM_ARG(jit_float64);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_NFLOAT):
+ {
+ /* Load a native float argument into the register 1 */
+ VM_R1_NFLOAT = *VM_ARG(jit_nfloat);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_1_STRUCT):
+ {
+ /* Load a structure argument into the register 1 */
+ temparg = VM_NINT_ARG2;
+ jit_memcpy(&r1, VM_ARG(void), temparg);
+ VM_MODIFY_PC(3);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDAA_1):
+ {
+ /* Load the address of an argument into the register 1 */
+ VM_R1_PTR = VM_ARG(void);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_2_SBYTE):
+ {
+ /* Load a signed 8-bit integer argument into the register 2 */
+ VM_R2_INT = *VM_ARG(jit_sbyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_2_UBYTE):
+ {
+ /* Load an unsigned 8-bit integer argument into the register 2 */
+ VM_R2_INT = *VM_ARG(jit_ubyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_2_SHORT):
+ {
+ /* Load a signed 16-bit integer argument into the register 2 */
+ VM_R2_INT = *VM_ARG(jit_short);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_2_USHORT):
+ {
+ /* Load am unsigned 16-bit argument local into the register 2 */
+ VM_R2_INT = *VM_ARG(jit_ushort);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDARGA):
+ VMCASE(JIT_OP_LDA_2_INT):
{
- /* Load the address of an argument onto the stack */
- VM_STK_PTRP = VM_ARG(void);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit integer argument into the register 2 */
+ VM_R2_INT = *VM_ARG(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_BYTE):
+ VMCASE(JIT_OP_LDA_2_LONG):
{
- /* Store an 8-bit integer into a stack argument */
- *VM_ARG(jit_sbyte) = (jit_sbyte)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a 64-bit integer argument into the register 2 */
+ VM_R2_LONG = *VM_ARG(jit_long);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_SHORT):
+ VMCASE(JIT_OP_LDA_2_FLOAT32):
{
- /* Store a 16-bit integer into a stack argument */
- *VM_ARG(jit_short) = (jit_short)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a 32-bit float argument into the register 2 */
+ VM_R2_FLOAT32 = *VM_ARG(jit_float32);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_INT):
+ VMCASE(JIT_OP_LDA_2_FLOAT64):
{
- /* Store a 32-bit integer into a stack argument */
- *VM_ARG(jit_int) = VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a 64-bit float argument into the register 2 */
+ VM_R2_FLOAT64 = *VM_ARG(jit_float64);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_LONG):
+ VMCASE(JIT_OP_LDA_2_NFLOAT):
{
- /* Store a 64-bit integer into a stack argument */
- *VM_ARG(jit_long) = VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a native float argument into the register 2 */
+ VM_R2_NFLOAT = *VM_ARG(jit_nfloat);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_FLOAT32):
+ VMCASE(JIT_OP_LDA_2_STRUCT):
{
- /* Store a 32-bit float into a stack argument */
- *VM_ARG(jit_float32) = VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a structure argument into the register 2 */
+ temparg = VM_NINT_ARG2;
+ jit_memcpy(&r2, VM_ARG(void), temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_FLOAT64):
+ VMCASE(JIT_OP_LDAA_2):
{
- /* Store a 64-bit float into a stack argument */
- *VM_ARG(jit_float64) = VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load the address of an argument into the register 2 */
+ VM_R2_PTR = VM_ARG(void);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_NFLOAT):
+ VMCASE(JIT_OP_STA_0_BYTE):
{
- /* Store a native float into a stack argument */
- *VM_ARG(jit_nfloat) = VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Store an 8-bit integer into an argument */
+ *VM_ARG(jit_sbyte) = (jit_sbyte)VM_R0_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_STRUCT):
+ VMCASE(JIT_OP_STA_0_SHORT):
{
- /* Store a structure value into a stack argument */
+ /* Store an 16-bit integer into an argument */
+ *VM_ARG(jit_short) = (jit_short)VM_R0_INT;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_INT):
+ {
+ /* Store an 32-bit integer into an argument */
+ *VM_ARG(jit_int) = (jit_int)VM_R0_INT;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_LONG):
+ {
+ /* Store an 64-bit integer into an argument */
+ *VM_ARG(jit_long) = (jit_long)VM_R0_LONG;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_FLOAT32):
+ {
+ /* Store a 32-bit float into an argument */
+ *VM_ARG(jit_float32) = VM_R0_FLOAT32;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_FLOAT64):
+ {
+ /* Store a 64-bit float into an argument */
+ *VM_ARG(jit_float64) = VM_R0_FLOAT64;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_NFLOAT):
+ {
+ /* Store a native float into an argument */
+ *VM_ARG(jit_nfloat) = VM_R0_NFLOAT;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_STRUCT):
+ {
+ /* Store a structure value into an argument */
temparg = VM_NINT_ARG2;
- jit_memcpy(VM_ARG(void), stacktop, temparg);
- stacktop += JIT_NUM_ITEMS_IN_STRUCT(temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(VM_ARG(void), &r0, temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
* Local variable frame access opcodes.
******************************************************************/
- VMCASE(JIT_OP_LDLOC_SBYTE):
+ VMCASE(JIT_OP_LDL_0_SBYTE):
{
- /* Load a signed 8-bit integer local onto the stack */
- VM_STK_INTP = *VM_LOC(jit_sbyte);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a signed 8-bit integer local into the register 0 */
+ VM_R0_INT = *VM_LOC(jit_sbyte);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_UBYTE):
+ VMCASE(JIT_OP_LDL_0_UBYTE):
{
- /* Load an unsigned 8-bit integer local onto the stack */
- VM_STK_INTP = *VM_LOC(jit_ubyte);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load an unsigned 8-bit integer local into the register 0 */
+ VM_R0_INT = *VM_LOC(jit_ubyte);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_SHORT):
+ VMCASE(JIT_OP_LDL_0_SHORT):
{
- /* Load a signed 16-bit integer local onto the stack */
- VM_STK_INTP = *VM_LOC(jit_short);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a signed 16-bit integer local into the register 0 */
+ VM_R0_INT = *VM_LOC(jit_short);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_USHORT):
+ VMCASE(JIT_OP_LDL_0_USHORT):
{
- /* Load an unsigned 16-bit integer local onto the stack */
- VM_STK_INTP = *VM_LOC(jit_ushort);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load am unsigned 16-bit integer local into the register 0 */
+ VM_R0_INT = *VM_LOC(jit_ushort);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_INT):
+ VMCASE(JIT_OP_LDL_0_INT):
{
- /* Load a 32-bit integer local onto the stack */
- VM_STK_INTP = *VM_LOC(jit_int);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit integer local into the register 0 */
+ VM_R0_INT = *VM_LOC(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_LONG):
+ VMCASE(JIT_OP_LDL_0_LONG):
{
- /* Load a 64-bit integer local onto the stack */
- VM_STK_LONGP = *VM_LOC(jit_long);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 64-bit integer local into the register 0 */
+ VM_R0_LONG = *VM_LOC(jit_long);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_FLOAT32):
+ VMCASE(JIT_OP_LDL_0_FLOAT32):
{
- /* Load a 32-bit float local onto the stack */
- VM_STK_FLOAT32P = *VM_LOC(jit_float32);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit float local into the register 0 */
+ VM_R0_FLOAT32 = *VM_LOC(jit_float32);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_FLOAT64):
+ VMCASE(JIT_OP_LDL_0_FLOAT64):
{
- /* Load a 64-bit float local onto the stack */
- VM_STK_FLOAT64P = *VM_LOC(jit_float64);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 64-bit float local into the register 0 */
+ VM_R0_FLOAT64 = *VM_LOC(jit_float64);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_NFLOAT):
+ VMCASE(JIT_OP_LDL_0_NFLOAT):
{
- /* Load a native float local onto the stack */
- VM_STK_NFLOATP = *VM_LOC(jit_nfloat);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a native float local into the register 0 */
+ VM_R0_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOC_STRUCT):
+ VMCASE(JIT_OP_LDL_0_STRUCT):
{
- /* Load a structure local onto the stack */
+ /* Load a structure local onto the register 0 */
temparg = VM_NINT_ARG2;
- stacktop -= JIT_NUM_ITEMS_IN_STRUCT(temparg);
- jit_memcpy(stacktop, VM_LOC(void), temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(&r0, VM_LOC(void), temparg);
+ VM_MODIFY_PC(3);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDLA_0):
+ {
+ /* Load the address of an local into the register 0 */
+ VM_R0_PTR = VM_LOC(void);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_SBYTE):
+ {
+ /* Load a signed 8-bit integer local into the register 1 */
+ VM_R1_INT = *VM_LOC(jit_sbyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_UBYTE):
+ {
+ /* Load an unsigned 8-bit integer local into the register 1 */
+ VM_R1_INT = *VM_LOC(jit_ubyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_SHORT):
+ {
+ /* Load a signed 16-bit integer local into the register 1 */
+ VM_R1_INT = *VM_LOC(jit_short);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_USHORT):
+ {
+ /* Load am unsigned 16-bit integer local into the register 1 */
+ VM_R1_INT = *VM_LOC(jit_ushort);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_INT):
+ {
+ /* Load a 32-bit integer local into the register 1 */
+ VM_R1_INT = *VM_LOC(jit_int);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_LONG):
+ {
+ /* Load a 64-bit integer local into the register 1 */
+ VM_R1_LONG = *VM_LOC(jit_long);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_FLOAT32):
+ {
+ /* Load a 32-bit float local into the register 1 */
+ VM_R1_FLOAT32 = *VM_LOC(jit_float32);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_FLOAT64):
+ {
+ /* Load a 64-bit float local into the register 1 */
+ VM_R1_FLOAT64 = *VM_LOC(jit_float64);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_NFLOAT):
+ {
+ /* Load a native float local into the register 1 */
+ VM_R1_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_1_STRUCT):
+ {
+ /* Load a structure local onto the register 1 */
+ temparg = VM_NINT_ARG2;
+ jit_memcpy(&r1, VM_LOC(void), temparg);
+ VM_MODIFY_PC(3);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDLA_1):
+ {
+ /* Load a native float local into the register 1 */
+ VM_R1_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_SBYTE):
+ {
+ /* Load a signed 8-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_sbyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_UBYTE):
+ {
+ /* Load an unsigned 8-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_ubyte);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_SHORT):
+ {
+ /* Load a signed 16-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_short);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_LDLOCA):
+ VMCASE(JIT_OP_LDL_2_USHORT):
{
- /* Load the address of an local onto the stack */
- VM_STK_PTRP = VM_LOC(void);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load am unsigned 16-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_ushort);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_BYTE):
+ VMCASE(JIT_OP_LDL_2_INT):
{
- /* Store an 8-bit integer into a stack local */
- *VM_LOC(jit_sbyte) = (jit_sbyte)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a 32-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_SHORT):
+ VMCASE(JIT_OP_LDL_2_LONG):
{
- /* Store a 16-bit integer into a stack local */
- *VM_LOC(jit_short) = (jit_short)VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a 64-bit integer local into the register 2 */
+ VM_R2_LONG = *VM_LOC(jit_long);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_FLOAT32):
+ {
+ /* Load a 32-bit float local into the register 2 */
+ VM_R2_FLOAT32 = *VM_LOC(jit_float32);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_FLOAT64):
+ {
+ /* Load a 64-bit float local into the register 2 */
+ VM_R2_FLOAT64 = *VM_LOC(jit_float64);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_NFLOAT):
+ {
+ /* Load a native float local into the register 2 */
+ VM_R2_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDL_2_STRUCT):
+ {
+ /* Load a structure local onto the register 2 */
+ temparg = VM_NINT_ARG2;
+ jit_memcpy(&r2, VM_LOC(void), temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_INT):
+ VMCASE(JIT_OP_LDLA_2):
{
- /* Store a 32-bit integer into a stack local */
- *VM_LOC(jit_int) = VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Load a native float local into the register 2 */
+ VM_R2_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_LONG):
+ VMCASE(JIT_OP_STL_0_BYTE):
{
- /* Store a 64-bit integer into a stack local */
- *VM_LOC(jit_long) = VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Store an 8-bit integer into a local */
+ *VM_LOC(jit_sbyte) = (jit_sbyte)VM_R0_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_FLOAT32):
+ VMCASE(JIT_OP_STL_0_SHORT):
{
- /* Store a 32-bit float into a stack local */
- *VM_LOC(jit_float32) = VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Store an 16-bit integer into a local */
+ *VM_LOC(jit_short) = (jit_short)VM_R0_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_FLOAT64):
+ VMCASE(JIT_OP_STL_0_INT):
{
- /* Store a 64-bit float into a stack local */
- *VM_LOC(jit_float64) = VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Store an 32-bit integer into a local */
+ *VM_LOC(jit_int) = (jit_int)VM_R0_INT;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_NFLOAT):
+ VMCASE(JIT_OP_STL_0_LONG):
{
- /* Store a native float into a stack local */
- *VM_LOC(jit_nfloat) = VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* Store an 64-bit integer into a local */
+ *VM_LOC(jit_long) = (jit_long)VM_R0_LONG;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_STRUCT):
+ VMCASE(JIT_OP_STL_0_FLOAT32):
{
- /* Store a structure value into a stack local */
+ /* Store a 32-bit float into a local */
+ *VM_LOC(jit_float32) = VM_R0_FLOAT32;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STL_0_FLOAT64):
+ {
+ /* Store a 64-bit float into a local */
+ *VM_LOC(jit_float64) = VM_R0_FLOAT64;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STL_0_NFLOAT):
+ {
+ /* Store a native float into a local */
+ *VM_LOC(jit_nfloat) = VM_R0_NFLOAT;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STL_0_STRUCT):
+ {
+ /* Store a structure value into a local */
temparg = VM_NINT_ARG2;
- jit_memcpy(VM_LOC(void), stacktop, temparg);
- stacktop += JIT_NUM_ITEMS_IN_STRUCT(temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(VM_LOC(void), &r0, temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
/******************************************************************
- * Stack management
+ * Load constant values.
******************************************************************/
- VMCASE(JIT_OP_POP_STACK):
+ #define JIT_WORDS_PER_TYPE(type) \
+ ((sizeof(type) + sizeof(void *) - 1) / sizeof(void *))
+
+ VMCASE(JIT_OP_LDC_0_INT):
{
- /* Pop a specific number of items from the stack */
- temparg = VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, temparg);
+ /* Load an integer constant into the register 0 */
+ VM_R0_INT = (jit_int)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_POP):
+ VMCASE(JIT_OP_LDC_0_LONG):
{
- /* Pop a single item from the stack */
- VM_MODIFY_PC_AND_STACK(1, 1);
+ /* Load a long constant into the register 0 */
+#ifdef JIT_NATIVE_INT64
+ VM_R0_LONG = (jit_long)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
+#else
+ jit_memcpy(&r0.long_value, pc + 1, sizeof(jit_long));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_long));
+#endif
}
VMBREAK;
- VMCASE(JIT_OP_POP_2):
+ VMCASE(JIT_OP_LDC_0_FLOAT32):
{
- /* Pop two items from the stack */
- VM_MODIFY_PC_AND_STACK(1, 2);
+ /* Load a 32-bit float constant into the register 0 */
+ jit_memcpy(&r0.float32_value, pc + 1, sizeof(jit_float32));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float32));
}
VMBREAK;
- VMCASE(JIT_OP_POP_3):
+ VMCASE(JIT_OP_LDC_0_FLOAT64):
{
- /* Pop three items from the stack */
- VM_MODIFY_PC_AND_STACK(1, 3);
+ /* Load a 64-bit float constant into the register 0 */
+ jit_memcpy(&r0.float64_value, pc + 1, sizeof(jit_float64));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float64));
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_INT):
+ VMCASE(JIT_OP_LDC_0_NFLOAT):
{
- /* Push an integer return value back onto the stack */
- VM_STK_INTP = return_area->int_value;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load a native float constant into the registre 0 */
+ jit_memcpy(&r0.nfloat_value, pc + 1, sizeof(jit_nfloat));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_nfloat));
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_LONG):
+ VMCASE(JIT_OP_LDC_1_INT):
{
- /* Push a long integer return value back onto the stack */
- VM_STK_LONGP = return_area->long_value;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load an integer constant into the register 1 */
+ VM_R1_INT = (jit_int)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_FLOAT32):
+ VMCASE(JIT_OP_LDC_1_LONG):
{
- /* Push a 32-bit float return value back onto the stack */
- VM_STK_FLOAT32P = return_area->float32_value;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load a long constant into the register 1 */
+#ifdef JIT_NATIVE_INT64
+ VM_R1_LONG = (jit_long)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
+#else
+ jit_memcpy(&r1.long_value, pc + 1, sizeof(jit_long));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_long));
+#endif
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_FLOAT64):
+ VMCASE(JIT_OP_LDC_1_FLOAT32):
{
- /* Push a 64-bit float return value back onto the stack */
- VM_STK_FLOAT64P = return_area->float64_value;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load a 32-bit float constant into the register 1 */
+ jit_memcpy(&r1.float32_value, pc + 1, sizeof(jit_float32));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float32));
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_NFLOAT):
+ VMCASE(JIT_OP_LDC_1_FLOAT64):
{
- /* Push a native float return value back onto the stack */
- VM_STK_NFLOATP = return_area->nfloat_value;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load a 64-bit float constant into the register 1 */
+ jit_memcpy(&r1.float64_value, pc + 1, sizeof(jit_float64));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float64));
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_SMALL_STRUCT):
+ VMCASE(JIT_OP_LDC_1_NFLOAT):
{
- /* Push a small structure return value back onto the stack */
- temparg = VM_NINT_ARG;
- stacktop -= JIT_NUM_ITEMS_IN_STRUCT(temparg);
- #if JIT_APPLY_MAX_STRUCT_IN_REG != 0
- jit_memcpy(stacktop, return_area->struct_value, temparg);
- #endif
- VM_MODIFY_PC_AND_STACK(2, 0);
+ /* Load a native float constant into the registre 1 */
+ jit_memcpy(&r1.nfloat_value, pc + 1, sizeof(jit_nfloat));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_nfloat));
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_AREA_PTR):
+ VMCASE(JIT_OP_LDC_2_INT):
{
- /* Push the address of "return_area" for an external call */
- VM_STK_PTRP = return_area;
- VM_MODIFY_PC_AND_STACK(1, -1);
+ /* Load an integer constant into the register 2 */
+ VM_R2_INT = (jit_int)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDC_2_LONG):
+ {
+ /* Load a long constant into the register 2 */
+#ifdef JIT_NATIVE_INT64
+ VM_R2_LONG = (jit_long)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
+#else
+ jit_memcpy(&r2.long_value, pc + 1, sizeof(jit_long));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_long));
+#endif
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDC_2_FLOAT32):
+ {
+ /* Load a 32-bit float constant into the register 2 */
+ jit_memcpy(&r2.float32_value, pc + 1, sizeof(jit_float32));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float32));
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDC_2_FLOAT64):
+ {
+ /* Load a 64-bit float constant into the register 2 */
+ jit_memcpy(&r2.float64_value, pc + 1, sizeof(jit_float64));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_float64));
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDC_2_NFLOAT):
+ {
+ /* Load a native float constant into the registre 2 */
+ jit_memcpy(&r2.nfloat_value, pc + 1, sizeof(jit_nfloat));
+ VM_MODIFY_PC(1 + JIT_WORDS_PER_TYPE(jit_nfloat));
}
VMBREAK;
/******************************************************************
- * Stack management
+ * Load return value.
******************************************************************/
- #define JIT_WORDS_PER_TYPE(type) \
- ((sizeof(type) + sizeof(void *) - 1) / sizeof(void *))
+ VMCASE(JIT_OP_LDR_0_INT):
+ {
+ /* Load an integer return value into the register 0 */
+ VM_R0_INT = return_area->int_value;
+ VM_MODIFY_PC(1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDR_0_LONG):
+ {
+ /* Load a long integer return value into the register 0 */
+ VM_R0_LONG = return_area->long_value;
+ VM_MODIFY_PC(1);
+ }
+ VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_INT):
+ VMCASE(JIT_OP_LDR_0_FLOAT32):
{
- /* Push an integer constant onto the stack */
- VM_STK_INTP = (jit_int)VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* Load a 32-bit float return value into the register 0 */
+ VM_R0_FLOAT32 = return_area->float32_value;
+ VM_MODIFY_PC(1);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_LONG):
+ VMCASE(JIT_OP_LDR_0_FLOAT64):
{
- /* Push a long constant onto the stack */
- #ifdef JIT_NATIVE_INT64
- VM_STK_LONGP = (jit_long)VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, -1);
- #else
- jit_memcpy(stacktop - 1, pc + 1, sizeof(jit_long));
- VM_MODIFY_PC_AND_STACK
- (1 + JIT_WORDS_PER_TYPE(jit_long), -1);
- #endif
+ /* Load a 64-bit float return value into the register 0 */
+ VM_R0_FLOAT64 = return_area->float64_value;
+ VM_MODIFY_PC(1);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_FLOAT32):
+ VMCASE(JIT_OP_LDR_0_NFLOAT):
{
- /* Push a 32-bit float constant onto the stack */
- jit_memcpy(stacktop - 1, pc + 1, sizeof(jit_float32));
- VM_MODIFY_PC_AND_STACK
- (1 + JIT_WORDS_PER_TYPE(jit_float32), -1);
+ /* Load a native float return value into the register 0 */
+ VM_R0_NFLOAT = return_area->nfloat_value;
+ VM_MODIFY_PC(1);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_FLOAT64):
+ VMCASE(JIT_OP_LDR_0_SMALL_STRUCT):
{
- /* Push a 64-bit float constant onto the stack */
- jit_memcpy(stacktop - 1, pc + 1, sizeof(jit_float64));
- VM_MODIFY_PC_AND_STACK
- (1 + JIT_WORDS_PER_TYPE(jit_float64), -1);
+ /* Load a small structure return value into the register 0 */
+ temparg = VM_NINT_ARG;
+ stacktop -= JIT_NUM_ITEMS_IN_STRUCT(temparg);
+#if JIT_APPLY_MAX_STRUCT_IN_REG != 0
+ jit_memcpy(&r0, return_area->struct_value, temparg);
+#endif
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_NFLOAT):
+ /******************************************************************
+ * Stack management.
+ ******************************************************************/
+
+ VMCASE(JIT_OP_POP_STACK):
{
- /* Push a native float constant onto the stack */
- jit_memcpy(stacktop - 1, pc + 1, sizeof(jit_nfloat));
- VM_MODIFY_PC_AND_STACK
- (1 + JIT_WORDS_PER_TYPE(jit_nfloat), -1);
+ /* Pop a specific number of items from the stack */
+ temparg = VM_NINT_ARG;
+ VM_MODIFY_PC_AND_STACK(2, temparg);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_POP):
+ {
+ /* Pop a single item from the stack */
+ VM_MODIFY_PC_AND_STACK(1, 1);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_POP_2):
+ {
+ /* Pop two items from the stack */
+ VM_MODIFY_PC_AND_STACK(1, 2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_POP_3):
+ {
+ /* Pop three items from the stack */
+ VM_MODIFY_PC_AND_STACK(1, 3);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_PUSH_RETURN_AREA_PTR):
+ {
+ /* Push the address of "return_area" for an external call */
+ VM_STK_PTRP = return_area;
+ VM_MODIFY_PC_AND_STACK(1, -1);
}
VMBREAK;
/* Process a marked breakpoint within the current function */
tempptr = (void *)VM_NINT_ARG;
tempptr2 = (void *)VM_NINT_ARG2;
- VM_MODIFY_PC_AND_STACK(3, 0);
+ VM_MODIFY_PC(3);
_jit_backtrace_push(&call_trace, pc);
_jit_debugger_hook
(func->func, (jit_nint)tempptr, (jit_nint)tempptr2);
VMCASE(JIT_OP_OUTGOING_REG):
VMCASE(JIT_OP_OUTGOING_FRAME_POSN):
VMCASE(JIT_OP_RETURN_REG):
- VMCASE(JIT_OP_PUSH_INT):
- VMCASE(JIT_OP_PUSH_LONG):
- VMCASE(JIT_OP_PUSH_FLOAT32):
- VMCASE(JIT_OP_PUSH_FLOAT64):
- VMCASE(JIT_OP_PUSH_NFLOAT):
VMCASE(JIT_OP_FLUSH_SMALL_STRUCT):
VMCASE(JIT_OP_SET_PARAM_INT):
VMCASE(JIT_OP_SET_PARAM_LONG):
@*/
int _jit_setup_indirect_pointer(jit_function_t func, jit_value_t value)
{
- return jit_insn_push(func, value);
+ //return jit_insn_outgoing_reg(func, value, 1);
+ return 1;
}
/*@
void _jit_gen_spill_reg(jit_gencode_t gen, int reg,
int other_reg, jit_value_t value)
{
- int opcode;
- jit_nint offset;
-
- /* Fix the value in place within the local variable frame */
- _jit_gen_fix_value(value);
-
- /* Output an appropriate instruction to spill the value */
- offset = value->frame_offset;
- if(offset >= 0)
- {
- opcode = _jit_store_opcode(JIT_OP_STLOC_BYTE, 0, value->type);
- }
- else
- {
- opcode = _jit_store_opcode(JIT_OP_STARG_BYTE, 0, value->type);
- offset = -(offset + 1);
- }
- jit_cache_opcode(&(gen->posn), opcode);
- jit_cache_native(&(gen->posn), offset);
-
- /* Adjust the working area to account for the popped value */
- adjust_working(gen, -1);
+ /* Registers are not used in the interpreted back end */
}
/*@
void _jit_gen_free_reg(jit_gencode_t gen, int reg,
int other_reg, int value_used)
{
- /* If the value wasn't used, then pop it from the stack.
- Registers are always freed from the top down */
- if(!value_used)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_POP);
- adjust_working(gen, -1);
- }
+ /* Registers are not used in the interpreted back end */
}
/*@
void _jit_gen_load_value
(jit_gencode_t gen, int reg, int other_reg, jit_value_t value)
{
- int opcode;
- if(value->is_constant)
- {
- /* Determine the type of constant to be loaded */
- switch(jit_type_normalize(value->type)->kind)
- {
- case JIT_TYPE_SBYTE:
- case JIT_TYPE_UBYTE:
- case JIT_TYPE_SHORT:
- case JIT_TYPE_USHORT:
- case JIT_TYPE_INT:
- case JIT_TYPE_UINT:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_CONST_INT);
- jit_cache_native(&(gen->posn), (jit_nint)(value->address));
- }
- break;
-
- case JIT_TYPE_LONG:
- case JIT_TYPE_ULONG:
- {
- jit_long long_value;
- long_value = jit_value_get_long_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_CONST_LONG);
- #ifdef JIT_NATIVE_INT64
- jit_cache_native(&(gen->posn), long_value);
- #else
- jit_cache_add_n(&(gen->posn), &long_value, sizeof(long_value));
- #endif
- }
- break;
-
- case JIT_TYPE_FLOAT32:
- {
- jit_float32 float32_value;
- float32_value = jit_value_get_float32_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_CONST_FLOAT32);
- jit_cache_add_n
- (&(gen->posn), &float32_value, sizeof(float32_value));
- }
- break;
-
- case JIT_TYPE_FLOAT64:
- {
- jit_float64 float64_value;
- float64_value = jit_value_get_float64_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_CONST_FLOAT64);
- jit_cache_add_n
- (&(gen->posn), &float64_value, sizeof(float64_value));
- }
- break;
-
- case JIT_TYPE_NFLOAT:
- {
- jit_nfloat nfloat_value;
- nfloat_value = jit_value_get_nfloat_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_CONST_NFLOAT);
- jit_cache_add_n
- (&(gen->posn), &nfloat_value, sizeof(nfloat_value));
- }
- break;
- }
- }
- else
- {
- /* Fix the position of the value in the stack frame */
- _jit_gen_fix_value(value);
-
- /* Generate a local or argument access opcode, as appropriate */
- if(value->frame_offset >= 0)
- {
- /* Load a local variable value onto the stack */
- opcode = _jit_load_opcode
- (JIT_OP_LDLOC_SBYTE, value->type, value, 0);
- jit_cache_opcode(&(gen->posn), opcode);
- jit_cache_native(&(gen->posn), value->frame_offset);
- }
- else
- {
- /* Load an argument value onto the stack */
- opcode = _jit_load_opcode
- (JIT_OP_LDARG_SBYTE, value->type, value, 0);
- jit_cache_opcode(&(gen->posn), opcode);
- jit_cache_native(&(gen->posn), -(value->frame_offset + 1));
- }
- }
-
- /* We have one more value on the stack */
- adjust_working(gen, 1);
+ /* Registers are not used in the interpreted back end */
}
/*@
/* Global registers are not used in the interpreted back end */
}
-
/*@
* @deftypefun void _jit_gen_load_global (jit_gencode_t gen, jit_value_t value)
* Load the contents of @code{value} into its corresponding global register.
}
}
-/*
- * Record that a destination is now in a particular register.
- */
-static void record_dest(jit_gencode_t gen, jit_insn_t insn, int reg)
+static void
+load_value(jit_gencode_t gen, jit_value_t value, int index)
{
- if(insn->dest)
+ int opcode;
+ jit_nint offset;
+
+ if(value->is_constant)
{
- if((insn->flags & JIT_INSN_DEST_NEXT_USE) != 0)
+ /* Determine the type of constant to be loaded */
+ switch(jit_type_normalize(value->type)->kind)
{
- /* Record that the destination is in "reg" */
- _jit_regs_set_value(gen, reg, insn->dest, 0);
+ case JIT_TYPE_SBYTE:
+ case JIT_TYPE_UBYTE:
+ case JIT_TYPE_SHORT:
+ case JIT_TYPE_USHORT:
+ case JIT_TYPE_INT:
+ case JIT_TYPE_UINT:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_INT + index);
+ jit_cache_native(&(gen->posn), (jit_nint)(value->address));
+ break;
+
+ case JIT_TYPE_LONG:
+ case JIT_TYPE_ULONG:
+ {
+ jit_long long_value;
+ long_value = jit_value_get_long_constant(value);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_LONG + index);
+#ifdef JIT_NATIVE_INT64
+ jit_cache_native(&(gen->posn), long_value);
+#else
+ jit_cache_add_n(&(gen->posn), &long_value, sizeof(long_value));
+#endif
+ break;
+ }
+
+ case JIT_TYPE_FLOAT32:
+ {
+ jit_float32 float32_value;
+ float32_value = jit_value_get_float32_constant(value);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_FLOAT32 + index);
+ jit_cache_add_n(&(gen->posn), &float32_value, sizeof(float32_value));
+ break;
+ }
+
+ case JIT_TYPE_FLOAT64:
+ {
+ jit_float64 float64_value;
+ float64_value = jit_value_get_float64_constant(value);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_FLOAT64 + index);
+ jit_cache_add_n (&(gen->posn), &float64_value, sizeof(float64_value));
+ break;
+ }
+
+ case JIT_TYPE_NFLOAT:
+ {
+ jit_nfloat nfloat_value;
+ nfloat_value = jit_value_get_nfloat_constant(value);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_NFLOAT + index);
+ jit_cache_add_n (&(gen->posn), &nfloat_value, sizeof(nfloat_value));
+ break;
+ }
+ }
+ }
+ else
+ {
+ /* Fix the position of the value in the stack frame */
+ _jit_gen_fix_value(value);
+
+ /* Generate a local or argument access opcode, as appropriate */
+ if(value->frame_offset >= 0)
+ {
+ /* Load a local variable value onto the stack */
+ switch(index)
+ {
+ case 0:
+ opcode = JIT_OP_LDL_0_SBYTE;
+ break;
+ case 1:
+ opcode = JIT_OP_LDL_1_SBYTE;
+ break;
+ case 2:
+ opcode = JIT_OP_LDL_2_SBYTE;
+ break;
+ default:
+ return;
+ }
+ opcode = _jit_load_opcode(opcode, value->type, value, 0);
+ offset = value->frame_offset;
}
else
{
- /* No next use, so store to the destination */
- _jit_gen_spill_reg(gen, reg, -1, insn->dest);
- insn->dest->in_frame = 1;
- _jit_regs_free_reg(gen, reg, 1);
+ /* Load an argument value onto the stack */
+ switch(index)
+ {
+ case 0:
+ opcode = JIT_OP_LDA_0_SBYTE;
+ break;
+ case 1:
+ opcode = JIT_OP_LDA_1_SBYTE;
+ break;
+ case 2:
+ opcode = JIT_OP_LDA_2_SBYTE;
+ break;
+ default:
+ return;
+ }
+ opcode = _jit_load_opcode(opcode, value->type, value, 0);
+ offset = -(value->frame_offset + 1);
}
+
+ jit_cache_opcode(&(gen->posn), opcode);
+ jit_cache_native(&(gen->posn), offset);
+ }
+}
+
+static void
+store_value(jit_gencode_t gen, jit_value_t value, int size)
+{
+ int opcode;
+ jit_nint offset;
+
+ /* Fix the value in place within the local variable frame */
+ _jit_gen_fix_value(value);
+
+ /* Output an appropriate instruction to store the value */
+ offset = value->frame_offset;
+ if(offset >= 0)
+ {
+ opcode = _jit_store_opcode(JIT_OP_STL_0_BYTE, 0, value->type);
}
else
{
- /* This is a note, with the result left on the stack */
- _jit_regs_free_reg(gen, reg, 1);
+ opcode = _jit_store_opcode(JIT_OP_STA_0_BYTE, 0, value->type);
+ offset = -(offset + 1);
+ }
+ jit_cache_opcode(&(gen->posn), opcode);
+ jit_cache_native(&(gen->posn), offset);
+ if(size)
+ {
+ jit_cache_native(&(gen->posn), size);
}
}
switch(insn->opcode)
{
- case JIT_OP_BR:
- case JIT_OP_CALL_FINALLY:
+ case JIT_OP_BR_IEQ:
+ case JIT_OP_BR_INE:
+ case JIT_OP_BR_ILT:
+ case JIT_OP_BR_ILT_UN:
+ case JIT_OP_BR_ILE:
+ case JIT_OP_BR_ILE_UN:
+ case JIT_OP_BR_IGT:
+ case JIT_OP_BR_IGT_UN:
+ case JIT_OP_BR_IGE:
+ case JIT_OP_BR_IGE_UN:
+ case JIT_OP_BR_LEQ:
+ case JIT_OP_BR_LNE:
+ case JIT_OP_BR_LLT:
+ case JIT_OP_BR_LLT_UN:
+ case JIT_OP_BR_LLE:
+ case JIT_OP_BR_LLE_UN:
+ case JIT_OP_BR_LGT:
+ case JIT_OP_BR_LGT_UN:
+ case JIT_OP_BR_LGE:
+ case JIT_OP_BR_LGE_UN:
+ case JIT_OP_BR_FEQ:
+ case JIT_OP_BR_FNE:
+ case JIT_OP_BR_FLT:
+ case JIT_OP_BR_FLE:
+ case JIT_OP_BR_FGT:
+ case JIT_OP_BR_FGE:
+ case JIT_OP_BR_FEQ_INV:
+ case JIT_OP_BR_FNE_INV:
+ case JIT_OP_BR_FLT_INV:
+ case JIT_OP_BR_FLE_INV:
+ case JIT_OP_BR_FGT_INV:
+ case JIT_OP_BR_FGE_INV:
+ case JIT_OP_BR_DEQ:
+ case JIT_OP_BR_DNE:
+ case JIT_OP_BR_DLT:
+ case JIT_OP_BR_DLE:
+ case JIT_OP_BR_DGT:
+ case JIT_OP_BR_DGE:
+ case JIT_OP_BR_DEQ_INV:
+ case JIT_OP_BR_DNE_INV:
+ case JIT_OP_BR_DLT_INV:
+ case JIT_OP_BR_DLE_INV:
+ case JIT_OP_BR_DGT_INV:
+ case JIT_OP_BR_DGE_INV:
+ case JIT_OP_BR_NFEQ:
+ case JIT_OP_BR_NFNE:
+ case JIT_OP_BR_NFLT:
+ case JIT_OP_BR_NFLE:
+ case JIT_OP_BR_NFGT:
+ case JIT_OP_BR_NFGE:
+ case JIT_OP_BR_NFEQ_INV:
+ case JIT_OP_BR_NFNE_INV:
+ case JIT_OP_BR_NFLT_INV:
+ case JIT_OP_BR_NFLE_INV:
+ case JIT_OP_BR_NFGT_INV:
+ case JIT_OP_BR_NFGE_INV:
+ /* Binary branch */
+ load_value(gen, insn->value2, 2);
+ /* Fall through */
+
+ case JIT_OP_BR_IFALSE:
+ case JIT_OP_BR_ITRUE:
+ case JIT_OP_BR_LFALSE:
+ case JIT_OP_BR_LTRUE:
+ case JIT_OP_CALL_FILTER:
+ /* Unary branch */
+ load_value(gen, insn->value1, 1);
+ /* Fall through */
+
+ case JIT_OP_BR:
+ case JIT_OP_CALL_FINALLY:
+ /* Unconditional branch */
+ label = (jit_label_t)(insn->dest);
+ pc = (void **)(gen->posn.ptr);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ block = jit_block_from_label(func, label);
+ if(!block)
{
- /* Unconditional branch */
- _jit_regs_spill_all(gen);
- label = (jit_label_t)(insn->dest);
- branch:
- pc = (void **)(gen->posn.ptr);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- block = jit_block_from_label(func, label);
- if(!block)
- {
- break;
- }
- if(block->address)
- {
- /* We already know the address of the block */
- jit_cache_native
- (&(gen->posn), ((void **)(block->address)) - pc);
- }
- else
- {
- /* Record this position on the block's fixup list */
- jit_cache_native(&(gen->posn), block->fixup_list);
- block->fixup_list = (void *)pc;
- }
+ break;
}
- break;
-
- case JIT_OP_BR_IFALSE:
- case JIT_OP_BR_ITRUE:
- case JIT_OP_BR_LFALSE:
- case JIT_OP_BR_LTRUE:
- case JIT_OP_CALL_FILTER:
+ if(block->address)
{
- /* Unary branch */
- label = (jit_label_t)(insn->dest);
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top
- (gen, insn->value1, (insn->flags & JIT_INSN_VALUE1_LIVE), 0);
- _jit_regs_free_reg(gen, reg, 1);
- goto branch;
+ /* We already know the address of the block */
+ jit_cache_native(&(gen->posn), ((void **)(block->address)) - pc);
}
- /* Not reached */
-
- case JIT_OP_BR_IEQ:
- case JIT_OP_BR_INE:
- case JIT_OP_BR_ILT:
- case JIT_OP_BR_ILT_UN:
- case JIT_OP_BR_ILE:
- case JIT_OP_BR_ILE_UN:
- case JIT_OP_BR_IGT:
- case JIT_OP_BR_IGT_UN:
- case JIT_OP_BR_IGE:
- case JIT_OP_BR_IGE_UN:
- case JIT_OP_BR_LEQ:
- case JIT_OP_BR_LNE:
- case JIT_OP_BR_LLT:
- case JIT_OP_BR_LLT_UN:
- case JIT_OP_BR_LLE:
- case JIT_OP_BR_LLE_UN:
- case JIT_OP_BR_LGT:
- case JIT_OP_BR_LGT_UN:
- case JIT_OP_BR_LGE:
- case JIT_OP_BR_LGE_UN:
- case JIT_OP_BR_FEQ:
- case JIT_OP_BR_FNE:
- case JIT_OP_BR_FLT:
- case JIT_OP_BR_FLE:
- case JIT_OP_BR_FGT:
- case JIT_OP_BR_FGE:
- case JIT_OP_BR_FEQ_INV:
- case JIT_OP_BR_FNE_INV:
- case JIT_OP_BR_FLT_INV:
- case JIT_OP_BR_FLE_INV:
- case JIT_OP_BR_FGT_INV:
- case JIT_OP_BR_FGE_INV:
- case JIT_OP_BR_DEQ:
- case JIT_OP_BR_DNE:
- case JIT_OP_BR_DLT:
- case JIT_OP_BR_DLE:
- case JIT_OP_BR_DGT:
- case JIT_OP_BR_DGE:
- case JIT_OP_BR_DEQ_INV:
- case JIT_OP_BR_DNE_INV:
- case JIT_OP_BR_DLT_INV:
- case JIT_OP_BR_DLE_INV:
- case JIT_OP_BR_DGT_INV:
- case JIT_OP_BR_DGE_INV:
- case JIT_OP_BR_NFEQ:
- case JIT_OP_BR_NFNE:
- case JIT_OP_BR_NFLT:
- case JIT_OP_BR_NFLE:
- case JIT_OP_BR_NFGT:
- case JIT_OP_BR_NFGE:
- case JIT_OP_BR_NFEQ_INV:
- case JIT_OP_BR_NFNE_INV:
- case JIT_OP_BR_NFLT_INV:
- case JIT_OP_BR_NFLE_INV:
- case JIT_OP_BR_NFGT_INV:
- case JIT_OP_BR_NFGE_INV:
+ else
{
- /* Binary branch */
- label = (jit_label_t)(insn->dest);
- if(!_jit_regs_is_top_two(gen, insn->value1, insn->value2) ||
- _jit_regs_num_used(gen, 0) != 2)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top_two
- (gen, insn->value1, insn->value2,
- (insn->flags & JIT_INSN_VALUE1_LIVE),
- (insn->flags & JIT_INSN_VALUE2_LIVE), 0);
- _jit_regs_free_reg(gen, reg, 1);
- goto branch;
+ /* Record this position on the block's fixup list */
+ jit_cache_native(&(gen->posn), block->fixup_list);
+ block->fixup_list = (void *)pc;
}
- /* Not reached */
+ break;
- case JIT_OP_JUMP_TABLE:
- {
- jit_label_t *labels;
- jit_nint num_labels;
- jit_nint index;
+ case JIT_OP_JUMP_TABLE:
+ {
+ jit_label_t *labels;
+ jit_nint num_labels;
+ jit_nint index;
- labels = (jit_label_t *) insn->value1->address;
- num_labels = insn->value2->address;
+ load_value(gen, insn->dest, 0);
- _jit_regs_spill_all(gen);
- _jit_regs_load_to_top(gen,
- insn->dest,
- (insn->flags & (JIT_INSN_DEST_NEXT_USE |
- JIT_INSN_DEST_LIVE)),
- 0);
+ labels = (jit_label_t *) insn->value1->address;
+ num_labels = insn->value2->address;
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn), num_labels);
- for(index = 0; index < num_labels; index++)
- {
- block = jit_block_from_label(func, labels[index]);
- if(!block)
- {
- return;
- }
- if(block->address)
- {
- /* We already know the address of the block */
- jit_cache_native(&(gen->posn), block->address);
- }
- else
- {
- /* Record this position on the block's fixup list */
- pc = (void **)(gen->posn.ptr);
- jit_cache_native(&(gen->posn), block->fixup_absolute_list);
- block->fixup_absolute_list = pc;
- }
- }
- }
- break;
-
- case JIT_OP_ADDRESS_OF_LABEL:
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), num_labels);
+ for(index = 0; index < num_labels; index++)
{
- /* Get the address of a particular label */
- if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_new_top(gen, insn->dest, 0);
- adjust_working(gen, 1);
- label = (jit_label_t)(insn->value1);
- pc = (void **)(gen->posn.ptr);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- block = jit_block_from_label(func, label);
+ block = jit_block_from_label(func, labels[index]);
if(!block)
{
- break;
+ return;
}
if(block->address)
{
/* We already know the address of the block */
- jit_cache_native
- (&(gen->posn), ((void **)(block->address)) - pc);
+ jit_cache_native(&(gen->posn), block->address);
}
else
{
/* Record this position on the block's fixup list */
- jit_cache_native(&(gen->posn), block->fixup_list);
- block->fixup_list = (void *)pc;
+ pc = (void **)(gen->posn.ptr);
+ jit_cache_native(&(gen->posn), block->fixup_absolute_list);
+ block->fixup_absolute_list = pc;
}
}
break;
+ }
- case JIT_OP_CALL:
- case JIT_OP_CALL_TAIL:
+ case JIT_OP_ADDRESS_OF_LABEL:
+ /* Get the address of a particular label */
+ label = (jit_label_t)(insn->value1);
+ block = jit_block_from_label(func, label);
+ if(!block)
{
- /* Call a function, whose pointer is supplied explicitly */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn), (jit_nint)(insn->dest));
+ break;
}
- break;
-
- case JIT_OP_CALL_INDIRECT:
- case JIT_OP_CALL_INDIRECT_TAIL:
+ pc = (void **)(gen->posn.ptr);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ if(block->address)
{
- /* Call a function, whose pointer is supplied on the stack */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn), (jit_nint)(insn->value2));
- jit_cache_native(&(gen->posn), (jit_nint)
- (jit_type_num_params((jit_type_t)(insn->value2))));
- adjust_working(gen, -1);
+ /* We already know the address of the block */
+ jit_cache_native(&(gen->posn), ((void **)(block->address)) - pc);
}
- break;
-
- case JIT_OP_CALL_VTABLE_PTR:
- case JIT_OP_CALL_VTABLE_PTR_TAIL:
+ else
{
- /* Call a function, whose vtable pointer is supplied on the stack */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, -1);
+ /* Record this position on the block's fixup list */
+ jit_cache_native(&(gen->posn), block->fixup_list);
+ block->fixup_list = (void *)pc;
}
+ store_value(gen, insn->dest, 0);
break;
- case JIT_OP_CALL_EXTERNAL:
- case JIT_OP_CALL_EXTERNAL_TAIL:
- {
- /* Call a native function, whose pointer is supplied explicitly */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn), (jit_nint)(insn->value2));
- jit_cache_native(&(gen->posn), (jit_nint)(insn->dest));
- jit_cache_native(&(gen->posn), (jit_nint)
- (jit_type_num_params((jit_type_t)(insn->value2))));
- }
+#if 0
+ case JIT_OP_OUTGOING_REG:
+ /* Load a value to a register */
+ load_value(gen, insn->value1, insn->value2->address);
break;
+#endif
- case JIT_OP_RETURN:
- {
- /* Return from the current function with no result */
- _jit_regs_spill_all(gen);
- jit_cache_opcode(&(gen->posn), JIT_OP_RETURN);
- }
+ case JIT_OP_CALL:
+ case JIT_OP_CALL_TAIL:
+ /* Call a function, whose pointer is supplied explicitly */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), (jit_nint)(insn->dest));
break;
- case JIT_OP_RETURN_INT:
- case JIT_OP_RETURN_LONG:
- case JIT_OP_RETURN_FLOAT32:
- case JIT_OP_RETURN_FLOAT64:
- case JIT_OP_RETURN_NFLOAT:
- {
- /* Return from the current function with a specific result */
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top(gen, insn->value1, 0, 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- _jit_regs_free_reg(gen, reg, 1);
- }
+ case JIT_OP_CALL_INDIRECT:
+ case JIT_OP_CALL_INDIRECT_TAIL:
+ /* Call a function, whose pointer is supplied in the register */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), (jit_nint)(insn->value2));
+ jit_cache_native(&(gen->posn), (jit_nint)
+ (jit_type_num_params((jit_type_t)(insn->value2))));
break;
- case JIT_OP_RETURN_SMALL_STRUCT:
- {
- /* Return from current function with a small structure result */
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top(gen, insn->value1, 0, 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn),
- jit_value_get_nint_constant(insn->value2));
- _jit_regs_free_reg(gen, reg, 1);
- }
+ case JIT_OP_CALL_VTABLE_PTR:
+ case JIT_OP_CALL_VTABLE_PTR_TAIL:
+ /* Call a function, whose vtable pointer is supplied in the register */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
break;
- case JIT_OP_SETUP_FOR_NESTED:
- {
- /* Set up to call a nested child */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, 2);
- }
+ case JIT_OP_CALL_EXTERNAL:
+ case JIT_OP_CALL_EXTERNAL_TAIL:
+ /* Call a native function, whose pointer is supplied explicitly */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), (jit_nint)(insn->value2));
+ jit_cache_native(&(gen->posn), (jit_nint)(insn->dest));
+ jit_cache_native(&(gen->posn), (jit_nint)
+ (jit_type_num_params((jit_type_t)(insn->value2))));
break;
- case JIT_OP_SETUP_FOR_SIBLING:
- {
- /* Set up to call a nested sibling */
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn),
- jit_value_get_nint_constant(insn->value1));
- adjust_working(gen, 2);
- }
+ case JIT_OP_RETURN:
+ /* Return from the current function with no result */
+ jit_cache_opcode(&(gen->posn), JIT_OP_RETURN);
break;
- case JIT_OP_IMPORT:
- {
- /* Import a local variable from an outer nested scope */
- if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
- {
- _jit_regs_spill_all(gen);
- }
- _jit_gen_fix_value(insn->value1);
- if(insn->value1->frame_offset >= 0)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_LOCAL);
- jit_cache_native(&(gen->posn), insn->value1->frame_offset);
- jit_cache_native(&(gen->posn),
- jit_value_get_nint_constant(insn->value2));
- }
- else
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_ARG);
- jit_cache_native
- (&(gen->posn), -(insn->value1->frame_offset + 1));
- jit_cache_native(&(gen->posn),
- jit_value_get_nint_constant(insn->value2));
- }
- reg = _jit_regs_new_top(gen, insn->dest, 0);
- adjust_working(gen, 1);
- }
+ case JIT_OP_RETURN_INT:
+ case JIT_OP_RETURN_LONG:
+ case JIT_OP_RETURN_FLOAT32:
+ case JIT_OP_RETURN_FLOAT64:
+ case JIT_OP_RETURN_NFLOAT:
+ /* Return from the current function with a specific result */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
break;
- case JIT_OP_THROW:
- {
- /* Throw an exception */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- _jit_regs_free_reg(gen, reg, 1);
- }
+ case JIT_OP_RETURN_SMALL_STRUCT:
+ /* Return from current function with a small structure result */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), jit_value_get_nint_constant(insn->value2));
break;
- case JIT_OP_LOAD_PC:
- case JIT_OP_LOAD_EXCEPTION_PC:
- {
- /* Load the current program counter onto the stack */
- if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
- {
- _jit_regs_spill_all(gen);
- }
- jit_cache_opcode(&(gen->posn), insn->opcode);
- reg = _jit_regs_new_top(gen, insn->dest, 0);
- adjust_working(gen, 1);
- }
+ case JIT_OP_SETUP_FOR_NESTED:
+ /* TODO!!! */
+ /* Set up to call a nested child */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ adjust_working(gen, 2);
break;
- case JIT_OP_CALL_FILTER_RETURN:
- {
- /* The top of stack currently contains "dest" */
- _jit_regs_set_value(gen, 0, insn->dest, 0);
- adjust_working(gen, 1);
- }
+ case JIT_OP_SETUP_FOR_SIBLING:
+ /* TODO!!! */
+ /* Set up to call a nested sibling */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn),
+ jit_value_get_nint_constant(insn->value1));
+ adjust_working(gen, 2);
break;
- case JIT_OP_ENTER_FINALLY:
+ case JIT_OP_IMPORT:
+ /* TODO!!! */
+ /* Import a local variable from an outer nested scope */
+ if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
{
- /* Record that the finally return address is on the stack */
- ++(gen->extra_working_space);
+ _jit_regs_spill_all(gen);
}
- break;
-
- case JIT_OP_LEAVE_FINALLY:
+ _jit_gen_fix_value(insn->value1);
+ if(insn->value1->frame_offset >= 0)
{
- /* Leave a finally clause */
- jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_LOCAL);
+ jit_cache_native(&(gen->posn), insn->value1->frame_offset);
+ jit_cache_native(&(gen->posn), jit_value_get_nint_constant(insn->value2));
}
- break;
-
- case JIT_OP_ENTER_FILTER:
+ else
{
- /* The top of stack contains "dest" and a return address */
- ++(gen->extra_working_space);
- _jit_regs_set_value(gen, 0, insn->dest, 0);
- adjust_working(gen, 1);
+ jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_ARG);
+ jit_cache_native(&(gen->posn), -(insn->value1->frame_offset + 1));
+ jit_cache_native(&(gen->posn), jit_value_get_nint_constant(insn->value2));
}
+ reg = _jit_regs_new_top(gen, insn->dest, 0);
+ adjust_working(gen, 1);
break;
- case JIT_OP_LEAVE_FILTER:
- {
- /* Leave a filter clause, returning a particular value */
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top(gen, insn->value1, 0, 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- _jit_regs_free_reg(gen, reg, 1);
- }
+ case JIT_OP_THROW:
+ /* Throw an exception */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
break;
- case JIT_OP_RETURN_REG:
- {
- /* Push a function return value back onto the stack */
- switch(jit_type_normalize(insn->value1->type)->kind)
- {
- case JIT_TYPE_SBYTE:
- case JIT_TYPE_UBYTE:
- case JIT_TYPE_SHORT:
- case JIT_TYPE_USHORT:
- case JIT_TYPE_INT:
- case JIT_TYPE_UINT:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_RETURN_INT);
- adjust_working(gen, 1);
- }
- break;
+ case JIT_OP_LOAD_PC:
+ case JIT_OP_LOAD_EXCEPTION_PC:
+ /* Load the current program counter onto the stack */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ store_value(gen, insn->dest, 0);
+ break;
- case JIT_TYPE_LONG:
- case JIT_TYPE_ULONG:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_RETURN_LONG);
- adjust_working(gen, 1);
- }
- break;
+ case JIT_OP_CALL_FILTER_RETURN:
+ /* TODO!!! */
+ /* The top of stack currently contains "dest" */
+ _jit_regs_set_value(gen, 0, insn->dest, 0);
+ adjust_working(gen, 1);
+ break;
- case JIT_TYPE_FLOAT32:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_RETURN_FLOAT32);
- adjust_working(gen, 1);
- }
- break;
+ case JIT_OP_ENTER_FINALLY:
+ /* Record that the finally return address is on the stack */
+ ++(gen->extra_working_space);
+ break;
- case JIT_TYPE_FLOAT64:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_RETURN_FLOAT64);
- adjust_working(gen, 1);
- }
- break;
+ case JIT_OP_LEAVE_FINALLY:
+ /* Leave a finally clause */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ break;
- case JIT_TYPE_NFLOAT:
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_PUSH_RETURN_NFLOAT);
- adjust_working(gen, 1);
- }
- break;
- }
- }
+ case JIT_OP_ENTER_FILTER:
+ /* TODO!!! */
+ /* The top of stack contains "dest" and a return address */
+ ++(gen->extra_working_space);
+ _jit_regs_set_value(gen, 0, insn->dest, 0);
+ adjust_working(gen, 1);
break;
- case JIT_OP_COPY_LOAD_SBYTE:
- case JIT_OP_COPY_LOAD_UBYTE:
- case JIT_OP_COPY_LOAD_SHORT:
- case JIT_OP_COPY_LOAD_USHORT:
- case JIT_OP_COPY_INT:
- case JIT_OP_COPY_LONG:
- case JIT_OP_COPY_FLOAT32:
- case JIT_OP_COPY_FLOAT64:
- case JIT_OP_COPY_NFLOAT:
- case JIT_OP_COPY_STRUCT:
- case JIT_OP_COPY_STORE_BYTE:
- case JIT_OP_COPY_STORE_SHORT:
+ case JIT_OP_LEAVE_FILTER:
+ /* TODO!!! */
+ /* Leave a filter clause, returning a particular value */
+ if(!_jit_regs_is_top(gen, insn->value1) ||
+ _jit_regs_num_used(gen, 0) != 1)
{
- /* Copy a value from one temporary variable to another */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
- record_dest(gen, insn, reg);
+ _jit_regs_spill_all(gen);
}
+ reg = _jit_regs_load_to_top(gen, insn->value1, 0, 0);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ _jit_regs_free_reg(gen, reg, 1);
break;
- case JIT_OP_ADDRESS_OF:
+ case JIT_OP_RETURN_REG:
+ /* Push a function return value back onto the stack */
+ switch(jit_type_normalize(insn->value1->type)->kind)
{
- /* Get the address of a local variable */
- if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
- {
- _jit_regs_spill_all(gen);
- }
- _jit_gen_fix_value(insn->value1);
- if(insn->value1->frame_offset >= 0)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_LDLOCA);
- jit_cache_native(&(gen->posn), insn->value1->frame_offset);
- }
- else
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_LDARGA);
- jit_cache_native
- (&(gen->posn), -(insn->value1->frame_offset + 1));
- }
- reg = _jit_regs_new_top(gen, insn->dest, 0);
- adjust_working(gen, 1);
+ case JIT_TYPE_SBYTE:
+ case JIT_TYPE_UBYTE:
+ case JIT_TYPE_SHORT:
+ case JIT_TYPE_USHORT:
+ case JIT_TYPE_INT:
+ case JIT_TYPE_UINT:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_INT);
+ store_value(gen, insn->value1, 0);
+ break;
+
+ case JIT_TYPE_LONG:
+ case JIT_TYPE_ULONG:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_LONG);
+ store_value(gen, insn->value1, 0);
+ break;
+
+ case JIT_TYPE_FLOAT32:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_FLOAT32);
+ store_value(gen, insn->value1, 0);
+ break;
+
+ case JIT_TYPE_FLOAT64:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_FLOAT64);
+ store_value(gen, insn->value1, 0);
+ break;
+
+ case JIT_TYPE_NFLOAT:
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_NFLOAT);
+ store_value(gen, insn->value1, 0);
+ break;
}
break;
- case JIT_OP_PUSH_INT:
- case JIT_OP_PUSH_LONG:
- case JIT_OP_PUSH_FLOAT32:
- case JIT_OP_PUSH_FLOAT64:
- case JIT_OP_PUSH_NFLOAT:
- {
- /* Push an item onto the stack, ready for a function call */
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
- _jit_regs_free_reg(gen, reg, 1);
- }
+ case JIT_OP_COPY_LOAD_SBYTE:
+ case JIT_OP_COPY_LOAD_UBYTE:
+ case JIT_OP_COPY_LOAD_SHORT:
+ case JIT_OP_COPY_LOAD_USHORT:
+ case JIT_OP_COPY_INT:
+ case JIT_OP_COPY_LONG:
+ case JIT_OP_COPY_FLOAT32:
+ case JIT_OP_COPY_FLOAT64:
+ case JIT_OP_COPY_NFLOAT:
+ case JIT_OP_COPY_STRUCT:
+ case JIT_OP_COPY_STORE_BYTE:
+ case JIT_OP_COPY_STORE_SHORT:
+ /* Copy a value from one temporary variable to another */
+ load_value(gen, insn->value1, 0);
+ store_value(gen, insn->dest, 0);
break;
- case JIT_OP_PUSH_STRUCT:
+ case JIT_OP_ADDRESS_OF:
+ /* Get the address of a local variable */
+ _jit_gen_fix_value(insn->value1);
+ if(insn->value1->frame_offset >= 0)
{
- /* Load the pointer value to the top of the stack */
- if(!_jit_regs_is_top(gen, insn->value1) ||
- _jit_regs_num_used(gen, 0) != 1)
- {
- _jit_regs_spill_all(gen);
- }
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
- _jit_regs_free_reg(gen, reg, 1);
-
- /* Push the structure at the designated pointer */
- size = jit_value_get_nint_constant(insn->value2);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- jit_cache_native(&(gen->posn), size);
- adjust_working(gen, JIT_NUM_ITEMS_IN_STRUCT(size) - 1);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDLA_0);
+ jit_cache_native(&(gen->posn), insn->value1->frame_offset);
}
- break;
-
- case JIT_OP_PUSH_RETURN_AREA_PTR:
+ else
{
- /* Push the address of the interpreter's return area */
- _jit_regs_spill_all(gen);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, 1);
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDAA_0);
+ jit_cache_native(&(gen->posn), -(insn->value1->frame_offset + 1));
}
+ store_value(gen, insn->dest, 0);
break;
- case JIT_OP_POP_STACK:
+ case JIT_OP_PUSH_INT:
+ case JIT_OP_PUSH_LONG:
+ case JIT_OP_PUSH_FLOAT32:
+ case JIT_OP_PUSH_FLOAT64:
+ case JIT_OP_PUSH_NFLOAT:
+ /* Push an item onto the stack, ready for a function call */
+ load_value(gen, insn->value1, 1);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ adjust_working(gen, 1);
+ break;
+
+ case JIT_OP_PUSH_STRUCT:
+ /* Load the pointer value */
+ load_value(gen, insn->value1, 1);
+ /* Push the structure at the designated pointer */
+ size = jit_value_get_nint_constant(insn->value2);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ jit_cache_native(&(gen->posn), size);
+ adjust_working(gen, JIT_NUM_ITEMS_IN_STRUCT(size));
+ break;
+
+ case JIT_OP_PUSH_RETURN_AREA_PTR:
+ /* Push the address of the interpreter's return area */
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ adjust_working(gen, 1);
+ break;
+
+ case JIT_OP_POP_STACK:
+ /* Pop parameter values from the stack after a function returns */
+ size = jit_value_get_nint_constant(insn->value1);
+ if(size == 1)
{
- /* Pop parameter values from the stack after a function returns */
- size = jit_value_get_nint_constant(insn->value1);
- if(size == 1)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_POP);
- }
- else if(size == 2)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_POP_2);
- }
- else if(size == 3)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_POP_3);
- }
- else if(size != 0)
- {
- jit_cache_opcode(&(gen->posn), JIT_OP_POP_STACK);
- jit_cache_native(&(gen->posn), size);
- }
+ jit_cache_opcode(&(gen->posn), JIT_OP_POP);
+ }
+ else if(size == 2)
+ {
+ jit_cache_opcode(&(gen->posn), JIT_OP_POP_2);
+ }
+ else if(size == 3)
+ {
+ jit_cache_opcode(&(gen->posn), JIT_OP_POP_3);
+ }
+ else if(size != 0)
+ {
+ jit_cache_opcode(&(gen->posn), JIT_OP_POP_STACK);
+ jit_cache_native(&(gen->posn), size);
}
break;
case JIT_OP_FLUSH_SMALL_STRUCT:
{
+ /* TODO!!! */
+#if 0
/* Flush a small structure return value back into the frame */
_jit_gen_fix_value(insn->value1);
if(insn->value1->frame_offset >= 0)
jit_cache_native
(&(gen->posn), jit_type_get_size(insn->value1->type));
adjust_working(gen, -2);
+#endif
}
break;
case JIT_OP_LOAD_RELATIVE_NFLOAT:
{
/* Load a value from a relative pointer */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
+ load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), offset);
- record_dest(gen, insn, reg);
+ store_value(gen, insn->dest, 0);
}
break;
case JIT_OP_LOAD_RELATIVE_STRUCT:
{
/* Load a structured value from a relative pointer */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
+ load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->dest));
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), offset);
jit_cache_native(&(gen->posn), size);
- size = JIT_NUM_ITEMS_IN_STRUCT(size);
- record_dest(gen, insn, reg);
- adjust_working(gen, size - 1);
+ store_value(gen, insn->dest, size);
}
break;
case JIT_OP_STORE_RELATIVE_NFLOAT:
{
/* Store a value to a relative pointer */
- reg = _jit_regs_load_to_top_two
- (gen, insn->dest, insn->value1,
- (insn->flags & (JIT_INSN_DEST_NEXT_USE |
- JIT_INSN_DEST_LIVE)),
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
+ load_value(gen, insn->dest, 0);
+ load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), offset);
- _jit_regs_free_reg(gen, reg, 1);
- adjust_working(gen, -2);
}
break;
case JIT_OP_STORE_RELATIVE_STRUCT:
{
/* Store a structured value to a relative pointer */
- reg = _jit_regs_load_to_top_two
- (gen, insn->dest, insn->value1,
- (insn->flags & (JIT_INSN_DEST_NEXT_USE |
- JIT_INSN_DEST_LIVE)),
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
+ load_value(gen, insn->dest, 0);
+ load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
- size = (jit_nint)jit_type_get_size
- (jit_value_get_type(insn->value1));
+ size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->value1));
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), offset);
jit_cache_native(&(gen->posn), size);
- _jit_regs_free_reg(gen, reg, 1);
- size = JIT_NUM_ITEMS_IN_STRUCT(size);
- adjust_working(gen, -(size + 1));
}
break;
case JIT_OP_ADD_RELATIVE:
{
/* Add a relative offset to a pointer */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
offset = jit_value_get_nint_constant(insn->value2);
if(offset != 0)
{
+ load_value(gen, insn->value1, 1);
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), offset);
+ store_value(gen, insn->dest, 0);
+ }
+ else
+ {
+ load_value(gen, insn->value1, 0);
+ store_value(gen, insn->dest, 0);
}
- record_dest(gen, insn, reg);
}
break;
default:
{
- /* Whatever opcodes are left are ordinary operators,
- and the interpreter's opcode is identical to the JIT's */
- if(insn->value2 && (insn->flags & JIT_INSN_DEST_IS_VALUE) != 0)
+ if(insn->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE) != 0)
{
- /* Generate code for a ternary operator with no real dest */
- _jit_regs_load_to_top_three
- (gen, insn->dest, insn->value1, insn->value2,
- (insn->flags & (JIT_INSN_DEST_NEXT_USE |
- JIT_INSN_DEST_LIVE)),
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)),
- (insn->flags & (JIT_INSN_VALUE2_NEXT_USE |
- JIT_INSN_VALUE2_LIVE)), 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, -3);
+ load_value(gen, insn->dest, 0);
}
- else if(insn->value2)
+ if(insn->value1)
{
- /* Generate code for a binary operator */
- reg = _jit_regs_load_to_top_two
- (gen, insn->value1, insn->value2,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)),
- (insn->flags & (JIT_INSN_VALUE2_NEXT_USE |
- JIT_INSN_VALUE2_LIVE)), 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, -1);
- if(insn->dest)
- {
- if((insn->flags & JIT_INSN_DEST_NEXT_USE) != 0)
- {
- /* Record that the destination is in "reg" */
- _jit_regs_set_value(gen, reg, insn->dest, 0);
- }
- else
- {
- /* No next use, so store to the destination */
- _jit_gen_spill_reg(gen, reg, -1, insn->dest);
- insn->dest->in_frame = 1;
- _jit_regs_free_reg(gen, reg, 1);
- }
- }
- else
- {
- /* This is a note, with the result left on the stack */
- _jit_regs_free_reg(gen, reg, 1);
- }
+ load_value(gen, insn->value1, 1);
}
- else
+ if(insn->value2)
{
- /* Generate code for a unary operator */
- reg = _jit_regs_load_to_top
- (gen, insn->value1,
- (insn->flags & (JIT_INSN_VALUE1_NEXT_USE |
- JIT_INSN_VALUE1_LIVE)), 0);
- jit_cache_opcode(&(gen->posn), insn->opcode);
- if(insn->dest)
- {
- if((insn->flags & JIT_INSN_DEST_NEXT_USE) != 0)
- {
- /* Record that the destination is in "reg" */
- _jit_regs_set_value(gen, reg, insn->dest, 0);
- }
- else
- {
- /* No next use, so store to the destination */
- _jit_gen_spill_reg(gen, reg, -1, insn->dest);
- insn->dest->in_frame = 1;
- _jit_regs_free_reg(gen, reg, 1);
- }
- }
- else
- {
- /* This is a note, with the result left on the stack */
- _jit_regs_free_reg(gen, reg, 1);
- }
+ load_value(gen, insn->value2, 2);
+ }
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ if(insn->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE) == 0)
+ {
+ store_value(gen, insn->dest, 0);
}
}
break;
projects / francis / libjit.git / commitdiff