From: Aleksey Demakov Date: Wed, 30 Aug 2006 13:31:58 +0000 (+0000) Subject: replace interpreter stack with 3 dedicated pseudo-registers X-Git-Tag: before.move.to.git~200 X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=b247520091c25b600f2adf9269c76ba532aeede3;p=francis%2Flibjit.git replace interpreter stack with 3 dedicated pseudo-registers --- diff --git a/ChangeLog b/ChangeLog index 69dcfb8..b8060c2 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,22 @@ +2006-08-30 Aleksey Demakov + + * jit/jit-interp.h, jit/jit-interp.c, jit/jit-opcode.c, + jit/jit-rules-interp.h, jit/jit-rules-interp.c: major change in the + internal interpreter instruction set. Now the stack is used only for + function arguments. There are three pseudo-registers used instead of + the stack for operands. One is used for the destination value, two + others are used for the source values. The destination register is + spilled after each instruction. This scheme obviates the need for + register allocation for the interpreter backend. + + * jit/jit-function.c (jit_function_compile, compile_block): do not + make register allocator calls if JIT_BACKEND_INTERP is defined. + 2006-08-29 Aleksey Demakov + * jit/jit-function.c (jit_function_from_pc): fix problem with wrong + exception handler address for interpreter. + * jit/jit-insn.c (jit_insn_return, jit_insn_return_ptr): do not pop the setjmp context for the interpreter backend because it takes care of this by itself. diff --git a/jit/jit-function.c b/jit/jit-function.c index 3dccad4..fd2896a 100644 --- a/jit/jit-function.c +++ b/jit/jit-function.c @@ -519,6 +519,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, } break; +#ifndef JIT_BACKEND_INTERP case JIT_OP_INCOMING_REG: { /* Assign a register to an incoming value */ @@ -527,6 +528,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, insn->value1); } break; +#endif case JIT_OP_INCOMING_FRAME_POSN: { @@ -547,6 +549,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, } break; +#ifndef JIT_BACKEND_INTERP case JIT_OP_OUTGOING_REG: { /* Copy a value into an outgoing register */ @@ -555,6 +558,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, insn->value1); } break; +#endif case JIT_OP_OUTGOING_FRAME_POSN: { @@ -569,6 +573,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, } break; +#ifndef JIT_BACKEND_INTERP case JIT_OP_RETURN_REG: { /* Assign a register to a return value */ @@ -578,6 +583,7 @@ static void compile_block(jit_gencode_t gen, jit_function_t func, _jit_gen_insn(gen, func, block, insn); } break; +#endif case JIT_OP_MARK_OFFSET: { @@ -681,7 +687,9 @@ int jit_function_compile(jit_function_t func) _jit_function_compute_liveness(func); /* Allocate global registers to variables within the function */ +#ifndef JIT_BACKEND_INTERP _jit_regs_alloc_global(&gen, func); +#endif /* We may need to perform output twice, if the first attempt fails due to a lack of space in the current method cache page */ @@ -725,7 +733,9 @@ int jit_function_compile(jit_function_t func) #endif /* Clear the register assignments for the first block */ +#ifndef JIT_BACKEND_INTERP _jit_regs_init_for_block(&gen); +#endif /* Generate code for the blocks in the function */ block = 0; @@ -742,15 +752,19 @@ int jit_function_compile(jit_function_t func) /* Generate the block's code */ compile_block(&gen, func, block); - + /* Spill all live register values back to their frame positions */ +#ifndef JIT_BACKEND_INTERP _jit_regs_spill_all(&gen); +#endif /* Notify the back end that the block is finished */ _jit_gen_end_block(&gen, block); /* Clear the local register assignments, ready for the next block */ +#ifndef JIT_BACKEND_INTERP _jit_regs_init_for_block(&gen); +#endif } /* Output the function epilog. All return paths will jump to here */ @@ -1072,6 +1086,7 @@ jit_function_t jit_function_from_pc /* Convert the cookie into a handler address */ if(handler) { +#if 0 if(cookie) { *handler = ((jit_cache_eh_t)cookie)->handler; @@ -1080,6 +1095,9 @@ jit_function_t jit_function_from_pc { *handler = 0; } +#else + *handler = cookie; +#endif } return func; } diff --git a/jit/jit-interp.c b/jit/jit-interp.c index 26becaa..a8dd9be 100644 --- a/jit/jit-interp.c +++ b/jit/jit-interp.c @@ -66,6 +66,10 @@ straight vanilla ANSI C. 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); \ @@ -79,6 +83,49 @@ straight vanilla ANSI C. #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. */ @@ -130,9 +177,9 @@ straight vanilla ANSI C. * 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. @@ -253,6 +300,7 @@ void _jit_run_function(jit_function_interp_t func, jit_item *args, jit_item *frame_base; jit_item *frame; jit_item *stacktop; + jit_item r0, r1, r2; void **pc; jit_int builtin_exception; jit_nint temparg; @@ -308,7 +356,7 @@ restart_tail: 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; @@ -319,32 +367,32 @@ restart_tail: 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; @@ -352,7 +400,7 @@ restart_tail: { /* 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; @@ -360,239 +408,239 @@ restart_tail: { /* 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; @@ -603,122 +651,112 @@ restart_tail: 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; @@ -733,288 +771,272 @@ restart_tail: 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; @@ -1025,32 +1047,32 @@ restart_tail: 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; @@ -1065,71 +1087,71 @@ restart_tail: 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; @@ -1148,14 +1170,13 @@ restart_tail: 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; @@ -1163,14 +1184,13 @@ restart_tail: 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; @@ -1178,14 +1198,13 @@ restart_tail: 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; @@ -1193,14 +1212,13 @@ restart_tail: 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; @@ -1208,14 +1226,13 @@ restart_tail: 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; @@ -1223,14 +1240,13 @@ restart_tail: 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; @@ -1238,14 +1254,13 @@ restart_tail: 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; @@ -1253,14 +1268,13 @@ restart_tail: 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; @@ -1268,14 +1282,13 @@ restart_tail: 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; @@ -1283,14 +1296,13 @@ restart_tail: 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; @@ -1298,14 +1310,13 @@ restart_tail: 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; @@ -1313,14 +1324,13 @@ restart_tail: 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; @@ -1328,14 +1338,13 @@ restart_tail: 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; @@ -1343,14 +1352,13 @@ restart_tail: 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; @@ -1358,14 +1366,13 @@ restart_tail: 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; @@ -1373,14 +1380,13 @@ restart_tail: 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; @@ -1388,14 +1394,13 @@ restart_tail: 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; @@ -1403,14 +1408,13 @@ restart_tail: 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; @@ -1418,14 +1422,13 @@ restart_tail: 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; @@ -1433,14 +1436,13 @@ restart_tail: 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; @@ -1448,14 +1450,13 @@ restart_tail: 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; @@ -1463,14 +1464,13 @@ restart_tail: 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; @@ -1478,14 +1478,13 @@ restart_tail: 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; @@ -1493,14 +1492,13 @@ restart_tail: 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; @@ -1508,14 +1506,13 @@ restart_tail: 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; @@ -1523,14 +1520,13 @@ restart_tail: 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; @@ -1538,14 +1534,13 @@ restart_tail: 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; @@ -1553,14 +1548,13 @@ restart_tail: 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; @@ -1568,14 +1562,13 @@ restart_tail: 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; @@ -1583,14 +1576,13 @@ restart_tail: 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; @@ -1598,14 +1590,13 @@ restart_tail: 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; @@ -1613,14 +1604,13 @@ restart_tail: 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; @@ -1628,14 +1618,13 @@ restart_tail: 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; @@ -1643,14 +1632,13 @@ restart_tail: 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; @@ -1658,14 +1646,13 @@ restart_tail: 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; @@ -1673,14 +1660,13 @@ restart_tail: 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; @@ -1688,14 +1674,13 @@ restart_tail: 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; @@ -1703,14 +1688,13 @@ restart_tail: 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; @@ -1718,14 +1702,13 @@ restart_tail: 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; @@ -1733,14 +1716,13 @@ restart_tail: 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; @@ -1748,14 +1730,13 @@ restart_tail: 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; @@ -1763,14 +1744,13 @@ restart_tail: 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; @@ -1778,14 +1758,13 @@ restart_tail: 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; @@ -1793,14 +1772,13 @@ restart_tail: 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; @@ -1808,14 +1786,13 @@ restart_tail: 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; @@ -1823,14 +1800,13 @@ restart_tail: 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; @@ -1838,14 +1814,13 @@ restart_tail: 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; @@ -1853,14 +1828,13 @@ restart_tail: 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; @@ -1868,14 +1842,13 @@ restart_tail: 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; @@ -1883,14 +1856,13 @@ restart_tail: 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; @@ -1898,14 +1870,13 @@ restart_tail: 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; @@ -1913,14 +1884,13 @@ restart_tail: 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; @@ -1928,14 +1898,13 @@ restart_tail: 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; @@ -1943,14 +1912,13 @@ restart_tail: 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; @@ -1958,14 +1926,13 @@ restart_tail: 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; @@ -1973,14 +1940,13 @@ restart_tail: 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; @@ -1988,14 +1954,13 @@ restart_tail: 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; @@ -2003,14 +1968,13 @@ restart_tail: 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; @@ -2018,14 +1982,13 @@ restart_tail: 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; @@ -2033,28 +1996,26 @@ restart_tail: 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; @@ -2066,15 +2027,15 @@ restart_tail: 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; @@ -2082,7 +2043,7 @@ restart_tail: 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; @@ -2090,7 +2051,7 @@ restart_tail: 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; @@ -2098,568 +2059,568 @@ restart_tail: 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; @@ -2670,462 +2631,456 @@ restart_tail: 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; @@ -3136,192 +3091,192 @@ restart_tail: 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; @@ -3332,23 +3287,11 @@ restart_tail: 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; @@ -3360,15 +3303,16 @@ restart_tail: { /* 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; @@ -3392,13 +3336,13 @@ restart_tail: /* 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; @@ -3406,20 +3350,21 @@ restart_tail: 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; @@ -3427,7 +3372,7 @@ restart_tail: 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); @@ -3451,10 +3396,10 @@ restart_tail: 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; @@ -3473,7 +3418,7 @@ restart_tail: 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(); @@ -3485,7 +3430,7 @@ restart_tail: 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(); @@ -3497,7 +3442,7 @@ restart_tail: 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(); @@ -3509,7 +3454,7 @@ restart_tail: 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(); @@ -3521,7 +3466,7 @@ restart_tail: 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(); @@ -3533,10 +3478,11 @@ restart_tail: 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(); @@ -3547,6 +3493,7 @@ restart_tail: 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; @@ -3556,6 +3503,7 @@ restart_tail: 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; @@ -3573,6 +3521,7 @@ restart_tail: 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; @@ -3590,6 +3539,7 @@ restart_tail: 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; @@ -3603,14 +3553,48 @@ restart_tail: } 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; @@ -3621,21 +3605,24 @@ restart_tail: 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); } } @@ -3644,24 +3631,27 @@ restart_tail: 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; @@ -3675,6 +3665,7 @@ restart_tail: 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]; @@ -3684,6 +3675,7 @@ restart_tail: 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); @@ -3704,8 +3696,8 @@ restart_tail: 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; @@ -3716,158 +3708,152 @@ restart_tail: 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; @@ -3878,128 +3864,128 @@ restart_tail: 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; @@ -4010,24 +3996,24 @@ restart_tail: 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; @@ -4038,8 +4024,8 @@ restart_tail: 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. @@ -4060,159 +4046,335 @@ restart_tail: * 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; @@ -4220,308 +4382,574 @@ restart_tail: * 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; @@ -4534,7 +4962,7 @@ restart_tail: /* 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); @@ -4566,11 +4994,6 @@ restart_tail: 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): diff --git a/jit/jit-interp.h b/jit/jit-interp.h index f5c07f2..7885067 100644 --- a/jit/jit-interp.h +++ b/jit/jit-interp.h @@ -90,86 +90,139 @@ struct jit_function_interp /* * Argument variable access opcodes. */ -#define JIT_OP_LDARG_SBYTE (JIT_OP_NUM_OPCODES + 0x0000) -#define JIT_OP_LDARG_UBYTE (JIT_OP_NUM_OPCODES + 0x0001) -#define JIT_OP_LDARG_SHORT (JIT_OP_NUM_OPCODES + 0x0002) -#define JIT_OP_LDARG_USHORT (JIT_OP_NUM_OPCODES + 0x0003) -#define JIT_OP_LDARG_INT (JIT_OP_NUM_OPCODES + 0x0004) -#define JIT_OP_LDARG_LONG (JIT_OP_NUM_OPCODES + 0x0005) -#define JIT_OP_LDARG_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0006) -#define JIT_OP_LDARG_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0007) -#define JIT_OP_LDARG_NFLOAT (JIT_OP_NUM_OPCODES + 0x0008) -#define JIT_OP_LDARG_STRUCT (JIT_OP_NUM_OPCODES + 0x0009) -#define JIT_OP_LDARGA (JIT_OP_NUM_OPCODES + 0x000A) -#define JIT_OP_STARG_BYTE (JIT_OP_NUM_OPCODES + 0x000B) -#define JIT_OP_STARG_SHORT (JIT_OP_NUM_OPCODES + 0x000C) -#define JIT_OP_STARG_INT (JIT_OP_NUM_OPCODES + 0x000D) -#define JIT_OP_STARG_LONG (JIT_OP_NUM_OPCODES + 0x000E) -#define JIT_OP_STARG_FLOAT32 (JIT_OP_NUM_OPCODES + 0x000F) -#define JIT_OP_STARG_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0010) -#define JIT_OP_STARG_NFLOAT (JIT_OP_NUM_OPCODES + 0x0011) -#define JIT_OP_STARG_STRUCT (JIT_OP_NUM_OPCODES + 0x0012) +#define JIT_OP_LDA_0_SBYTE (JIT_OP_NUM_OPCODES + 0x0000) +#define JIT_OP_LDA_0_UBYTE (JIT_OP_NUM_OPCODES + 0x0001) +#define JIT_OP_LDA_0_SHORT (JIT_OP_NUM_OPCODES + 0x0002) +#define JIT_OP_LDA_0_USHORT (JIT_OP_NUM_OPCODES + 0x0003) +#define JIT_OP_LDA_0_INT (JIT_OP_NUM_OPCODES + 0x0004) +#define JIT_OP_LDA_0_LONG (JIT_OP_NUM_OPCODES + 0x0005) +#define JIT_OP_LDA_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0006) +#define JIT_OP_LDA_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0007) +#define JIT_OP_LDA_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0008) +#define JIT_OP_LDA_0_STRUCT (JIT_OP_NUM_OPCODES + 0x0009) +#define JIT_OP_LDAA_0 (JIT_OP_NUM_OPCODES + 0x000a) +#define JIT_OP_LDA_1_SBYTE (JIT_OP_NUM_OPCODES + 0x000b) +#define JIT_OP_LDA_1_UBYTE (JIT_OP_NUM_OPCODES + 0x000c) +#define JIT_OP_LDA_1_SHORT (JIT_OP_NUM_OPCODES + 0x000d) +#define JIT_OP_LDA_1_USHORT (JIT_OP_NUM_OPCODES + 0x000e) +#define JIT_OP_LDA_1_INT (JIT_OP_NUM_OPCODES + 0x000f) +#define JIT_OP_LDA_1_LONG (JIT_OP_NUM_OPCODES + 0x0010) +#define JIT_OP_LDA_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0011) +#define JIT_OP_LDA_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0012) +#define JIT_OP_LDA_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x0013) +#define JIT_OP_LDA_1_STRUCT (JIT_OP_NUM_OPCODES + 0x0014) +#define JIT_OP_LDAA_1 (JIT_OP_NUM_OPCODES + 0x0015) +#define JIT_OP_LDA_2_SBYTE (JIT_OP_NUM_OPCODES + 0x0016) +#define JIT_OP_LDA_2_UBYTE (JIT_OP_NUM_OPCODES + 0x0017) +#define JIT_OP_LDA_2_SHORT (JIT_OP_NUM_OPCODES + 0x0018) +#define JIT_OP_LDA_2_USHORT (JIT_OP_NUM_OPCODES + 0x0019) +#define JIT_OP_LDA_2_INT (JIT_OP_NUM_OPCODES + 0x001a) +#define JIT_OP_LDA_2_LONG (JIT_OP_NUM_OPCODES + 0x001b) +#define JIT_OP_LDA_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x001c) +#define JIT_OP_LDA_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x001d) +#define JIT_OP_LDA_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x001e) +#define JIT_OP_LDA_2_STRUCT (JIT_OP_NUM_OPCODES + 0x001f) +#define JIT_OP_LDAA_2 (JIT_OP_NUM_OPCODES + 0x0020) +#define JIT_OP_STA_0_BYTE (JIT_OP_NUM_OPCODES + 0x0021) +#define JIT_OP_STA_0_SHORT (JIT_OP_NUM_OPCODES + 0x0022) +#define JIT_OP_STA_0_INT (JIT_OP_NUM_OPCODES + 0x0023) +#define JIT_OP_STA_0_LONG (JIT_OP_NUM_OPCODES + 0x0024) +#define JIT_OP_STA_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0025) +#define JIT_OP_STA_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0026) +#define JIT_OP_STA_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0027) +#define JIT_OP_STA_0_STRUCT (JIT_OP_NUM_OPCODES + 0x0028) /* * Local variable frame access opcodes. */ -#define JIT_OP_LDLOC_SBYTE (JIT_OP_NUM_OPCODES + 0x0013) -#define JIT_OP_LDLOC_UBYTE (JIT_OP_NUM_OPCODES + 0x0014) -#define JIT_OP_LDLOC_SHORT (JIT_OP_NUM_OPCODES + 0x0015) -#define JIT_OP_LDLOC_USHORT (JIT_OP_NUM_OPCODES + 0x0016) -#define JIT_OP_LDLOC_INT (JIT_OP_NUM_OPCODES + 0x0017) -#define JIT_OP_LDLOC_LONG (JIT_OP_NUM_OPCODES + 0x0018) -#define JIT_OP_LDLOC_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0019) -#define JIT_OP_LDLOC_FLOAT64 (JIT_OP_NUM_OPCODES + 0x001A) -#define JIT_OP_LDLOC_NFLOAT (JIT_OP_NUM_OPCODES + 0x001B) -#define JIT_OP_LDLOC_STRUCT (JIT_OP_NUM_OPCODES + 0x001C) -#define JIT_OP_LDLOCA (JIT_OP_NUM_OPCODES + 0x001D) -#define JIT_OP_STLOC_BYTE (JIT_OP_NUM_OPCODES + 0x001E) -#define JIT_OP_STLOC_SHORT (JIT_OP_NUM_OPCODES + 0x001F) -#define JIT_OP_STLOC_INT (JIT_OP_NUM_OPCODES + 0x0020) -#define JIT_OP_STLOC_LONG (JIT_OP_NUM_OPCODES + 0x0021) -#define JIT_OP_STLOC_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0022) -#define JIT_OP_STLOC_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0023) -#define JIT_OP_STLOC_NFLOAT (JIT_OP_NUM_OPCODES + 0x0024) -#define JIT_OP_STLOC_STRUCT (JIT_OP_NUM_OPCODES + 0x0025) +#define JIT_OP_LDL_0_SBYTE (JIT_OP_NUM_OPCODES + 0x0029) +#define JIT_OP_LDL_0_UBYTE (JIT_OP_NUM_OPCODES + 0x002a) +#define JIT_OP_LDL_0_SHORT (JIT_OP_NUM_OPCODES + 0x002b) +#define JIT_OP_LDL_0_USHORT (JIT_OP_NUM_OPCODES + 0x002c) +#define JIT_OP_LDL_0_INT (JIT_OP_NUM_OPCODES + 0x002d) +#define JIT_OP_LDL_0_LONG (JIT_OP_NUM_OPCODES + 0x002e) +#define JIT_OP_LDL_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x002f) +#define JIT_OP_LDL_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0030) +#define JIT_OP_LDL_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0031) +#define JIT_OP_LDL_0_STRUCT (JIT_OP_NUM_OPCODES + 0x0032) +#define JIT_OP_LDLA_0 (JIT_OP_NUM_OPCODES + 0x0033) +#define JIT_OP_LDL_1_SBYTE (JIT_OP_NUM_OPCODES + 0x0034) +#define JIT_OP_LDL_1_UBYTE (JIT_OP_NUM_OPCODES + 0x0035) +#define JIT_OP_LDL_1_SHORT (JIT_OP_NUM_OPCODES + 0x0036) +#define JIT_OP_LDL_1_USHORT (JIT_OP_NUM_OPCODES + 0x0037) +#define JIT_OP_LDL_1_INT (JIT_OP_NUM_OPCODES + 0x0038) +#define JIT_OP_LDL_1_LONG (JIT_OP_NUM_OPCODES + 0x0039) +#define JIT_OP_LDL_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x003a) +#define JIT_OP_LDL_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x003b) +#define JIT_OP_LDL_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x003c) +#define JIT_OP_LDL_1_STRUCT (JIT_OP_NUM_OPCODES + 0x003d) +#define JIT_OP_LDLA_1 (JIT_OP_NUM_OPCODES + 0x003e) +#define JIT_OP_LDL_2_SBYTE (JIT_OP_NUM_OPCODES + 0x003f) +#define JIT_OP_LDL_2_UBYTE (JIT_OP_NUM_OPCODES + 0x0040) +#define JIT_OP_LDL_2_SHORT (JIT_OP_NUM_OPCODES + 0x0041) +#define JIT_OP_LDL_2_USHORT (JIT_OP_NUM_OPCODES + 0x0042) +#define JIT_OP_LDL_2_INT (JIT_OP_NUM_OPCODES + 0x0043) +#define JIT_OP_LDL_2_LONG (JIT_OP_NUM_OPCODES + 0x0044) +#define JIT_OP_LDL_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0045) +#define JIT_OP_LDL_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0046) +#define JIT_OP_LDL_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x0047) +#define JIT_OP_LDL_2_STRUCT (JIT_OP_NUM_OPCODES + 0x0048) +#define JIT_OP_LDLA_2 (JIT_OP_NUM_OPCODES + 0x0049) +#define JIT_OP_STL_0_BYTE (JIT_OP_NUM_OPCODES + 0x004a) +#define JIT_OP_STL_0_SHORT (JIT_OP_NUM_OPCODES + 0x004b) +#define JIT_OP_STL_0_INT (JIT_OP_NUM_OPCODES + 0x004c) +#define JIT_OP_STL_0_LONG (JIT_OP_NUM_OPCODES + 0x004d) +#define JIT_OP_STL_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x004e) +#define JIT_OP_STL_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x004f) +#define JIT_OP_STL_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0050) +#define JIT_OP_STL_0_STRUCT (JIT_OP_NUM_OPCODES + 0x0051) /* - * Pointer check opcodes (interpreter only). + * Load constant values. */ -#define JIT_OP_CHECK_NULL_N (JIT_OP_NUM_OPCODES + 0x0026) +#define JIT_OP_LDC_0_INT (JIT_OP_NUM_OPCODES + 0x0052) +#define JIT_OP_LDC_1_INT (JIT_OP_NUM_OPCODES + 0x0053) +#define JIT_OP_LDC_2_INT (JIT_OP_NUM_OPCODES + 0x0054) +#define JIT_OP_LDC_0_LONG (JIT_OP_NUM_OPCODES + 0x0055) +#define JIT_OP_LDC_1_LONG (JIT_OP_NUM_OPCODES + 0x0056) +#define JIT_OP_LDC_2_LONG (JIT_OP_NUM_OPCODES + 0x0057) +#define JIT_OP_LDC_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0058) +#define JIT_OP_LDC_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0059) +#define JIT_OP_LDC_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x005a) +#define JIT_OP_LDC_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x005b) +#define JIT_OP_LDC_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x005c) +#define JIT_OP_LDC_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x005d) +#define JIT_OP_LDC_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x005e) +#define JIT_OP_LDC_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x005f) +#define JIT_OP_LDC_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x0060) /* - * Stack management. + * Load return value. */ -#define JIT_OP_POP (JIT_OP_NUM_OPCODES + 0x0027) -#define JIT_OP_POP_2 (JIT_OP_NUM_OPCODES + 0x0028) -#define JIT_OP_POP_3 (JIT_OP_NUM_OPCODES + 0x0029) -#define JIT_OP_PUSH_RETURN_INT (JIT_OP_NUM_OPCODES + 0x002A) -#define JIT_OP_PUSH_RETURN_LONG (JIT_OP_NUM_OPCODES + 0x002B) -#define JIT_OP_PUSH_RETURN_FLOAT32 (JIT_OP_NUM_OPCODES + 0x002C) -#define JIT_OP_PUSH_RETURN_FLOAT64 (JIT_OP_NUM_OPCODES + 0x002D) -#define JIT_OP_PUSH_RETURN_NFLOAT (JIT_OP_NUM_OPCODES + 0x002E) -#define JIT_OP_PUSH_RETURN_SMALL_STRUCT (JIT_OP_NUM_OPCODES + 0x002F) +#define JIT_OP_LDR_0_INT (JIT_OP_NUM_OPCODES + 0x0061) +#define JIT_OP_LDR_0_LONG (JIT_OP_NUM_OPCODES + 0x0062) +#define JIT_OP_LDR_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0063) +#define JIT_OP_LDR_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0064) +#define JIT_OP_LDR_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0065) +#define JIT_OP_LDR_0_SMALL_STRUCT (JIT_OP_NUM_OPCODES + 0x0066) /* - * Nested function call handling. + * Stack management. */ -#define JIT_OP_IMPORT_LOCAL (JIT_OP_NUM_OPCODES + 0x0030) -#define JIT_OP_IMPORT_ARG (JIT_OP_NUM_OPCODES + 0x0031) +#define JIT_OP_POP (JIT_OP_NUM_OPCODES + 0x0067) +#define JIT_OP_POP_2 (JIT_OP_NUM_OPCODES + 0x0068) +#define JIT_OP_POP_3 (JIT_OP_NUM_OPCODES + 0x0069) /* - * Push constant values onto the stack. + * Nested function call handling. */ -#define JIT_OP_PUSH_CONST_INT (JIT_OP_NUM_OPCODES + 0x0032) -#define JIT_OP_PUSH_CONST_LONG (JIT_OP_NUM_OPCODES + 0x0033) -#define JIT_OP_PUSH_CONST_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0034) -#define JIT_OP_PUSH_CONST_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0035) -#define JIT_OP_PUSH_CONST_NFLOAT (JIT_OP_NUM_OPCODES + 0x0036) +#define JIT_OP_IMPORT_LOCAL (JIT_OP_NUM_OPCODES + 0x006a) +#define JIT_OP_IMPORT_ARG (JIT_OP_NUM_OPCODES + 0x006b) /* * Marker opcode for the end of the interpreter-specific opcodes. */ -#define JIT_OP_END_MARKER (JIT_OP_NUM_OPCODES + 0x0037) +#define JIT_OP_END_MARKER (JIT_OP_NUM_OPCODES + 0x006c) /* * Number of interpreter-specific opcodes. diff --git a/jit/jit-opcode.c b/jit/jit-opcode.c index a80c5cc..34d1c3d 100644 --- a/jit/jit-opcode.c +++ b/jit/jit-opcode.c @@ -549,86 +549,139 @@ jit_opcode_info_t const _jit_interp_opcodes[JIT_OP_NUM_INTERP_OPCODES] = { /* * Argument variable access opcodes. */ - {"ldarg_sbyte", JIT_OPCODE_NINT_ARG}, - {"ldarg_ubyte", JIT_OPCODE_NINT_ARG}, - {"ldarg_short", JIT_OPCODE_NINT_ARG}, - {"ldarg_ushort", JIT_OPCODE_NINT_ARG}, - {"ldarg_int", JIT_OPCODE_NINT_ARG}, - {"ldarg_long", JIT_OPCODE_NINT_ARG}, - {"ldarg_float32", JIT_OPCODE_NINT_ARG}, - {"ldarg_float64", JIT_OPCODE_NINT_ARG}, - {"ldarg_nfloat", JIT_OPCODE_NINT_ARG}, - {"ldarg_struct", JIT_OPCODE_NINT_ARG_TWO}, - {"ldarga", JIT_OPCODE_NINT_ARG}, - {"starg_byte", JIT_OPCODE_NINT_ARG}, - {"starg_short", JIT_OPCODE_NINT_ARG}, - {"starg_int", JIT_OPCODE_NINT_ARG}, - {"starg_long", JIT_OPCODE_NINT_ARG}, - {"starg_float32", JIT_OPCODE_NINT_ARG}, - {"starg_float64", JIT_OPCODE_NINT_ARG}, - {"starg_nfloat", JIT_OPCODE_NINT_ARG}, - {"starg_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"lda_0_sbyte", JIT_OPCODE_NINT_ARG}, + {"lda_0_ubyte", JIT_OPCODE_NINT_ARG}, + {"lda_0_short", JIT_OPCODE_NINT_ARG}, + {"lda_0_ushort", JIT_OPCODE_NINT_ARG}, + {"lda_0_int", JIT_OPCODE_NINT_ARG}, + {"lda_0_long", JIT_OPCODE_NINT_ARG}, + {"lda_0_float32", JIT_OPCODE_NINT_ARG}, + {"lda_0_float64", JIT_OPCODE_NINT_ARG}, + {"lda_0_nfloat", JIT_OPCODE_NINT_ARG}, + {"lda_0_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldaa_0", JIT_OPCODE_NINT_ARG}, + {"lda_1_sbyte", JIT_OPCODE_NINT_ARG}, + {"lda_1_ubyte", JIT_OPCODE_NINT_ARG}, + {"lda_1_short", JIT_OPCODE_NINT_ARG}, + {"lda_1_ushort", JIT_OPCODE_NINT_ARG}, + {"lda_1_int", JIT_OPCODE_NINT_ARG}, + {"lda_1_long", JIT_OPCODE_NINT_ARG}, + {"lda_1_float32", JIT_OPCODE_NINT_ARG}, + {"lda_1_float64", JIT_OPCODE_NINT_ARG}, + {"lda_1_nfloat", JIT_OPCODE_NINT_ARG}, + {"lda_1_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldaa_1", JIT_OPCODE_NINT_ARG}, + {"lda_2_sbyte", JIT_OPCODE_NINT_ARG}, + {"lda_2_ubyte", JIT_OPCODE_NINT_ARG}, + {"lda_2_short", JIT_OPCODE_NINT_ARG}, + {"lda_2_ushort", JIT_OPCODE_NINT_ARG}, + {"lda_2_int", JIT_OPCODE_NINT_ARG}, + {"lda_2_long", JIT_OPCODE_NINT_ARG}, + {"lda_2_float32", JIT_OPCODE_NINT_ARG}, + {"lda_2_float64", JIT_OPCODE_NINT_ARG}, + {"lda_2_nfloat", JIT_OPCODE_NINT_ARG}, + {"lda_2_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldaa_2", JIT_OPCODE_NINT_ARG}, + {"sta_0_byte", JIT_OPCODE_NINT_ARG}, + {"sta_0_short", JIT_OPCODE_NINT_ARG}, + {"sta_0_int", JIT_OPCODE_NINT_ARG}, + {"sta_0_long", JIT_OPCODE_NINT_ARG}, + {"sta_0_float32", JIT_OPCODE_NINT_ARG}, + {"sta_0_float64", JIT_OPCODE_NINT_ARG}, + {"sta_0_nfloat", JIT_OPCODE_NINT_ARG}, + {"sta_0_struct", JIT_OPCODE_NINT_ARG_TWO}, /* * Local variable frame access opcodes. */ - {"ldloc_sbyte", JIT_OPCODE_NINT_ARG}, - {"ldloc_ubyte", JIT_OPCODE_NINT_ARG}, - {"ldloc_short", JIT_OPCODE_NINT_ARG}, - {"ldloc_ushort", JIT_OPCODE_NINT_ARG}, - {"ldloc_int", JIT_OPCODE_NINT_ARG}, - {"ldloc_long", JIT_OPCODE_NINT_ARG}, - {"ldloc_float32", JIT_OPCODE_NINT_ARG}, - {"ldloc_float64", JIT_OPCODE_NINT_ARG}, - {"ldloc_nfloat", JIT_OPCODE_NINT_ARG}, - {"ldloc_struct", JIT_OPCODE_NINT_ARG_TWO}, - {"ldloca", JIT_OPCODE_NINT_ARG}, - {"stloc_byte", JIT_OPCODE_NINT_ARG}, - {"stloc_short", JIT_OPCODE_NINT_ARG}, - {"stloc_int", JIT_OPCODE_NINT_ARG}, - {"stloc_long", JIT_OPCODE_NINT_ARG}, - {"stloc_float32", JIT_OPCODE_NINT_ARG}, - {"stloc_float64", JIT_OPCODE_NINT_ARG}, - {"stloc_nfloat", JIT_OPCODE_NINT_ARG}, - {"stloc_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldl_0_sbyte", JIT_OPCODE_NINT_ARG}, + {"ldl_0_ubyte", JIT_OPCODE_NINT_ARG}, + {"ldl_0_short", JIT_OPCODE_NINT_ARG}, + {"ldl_0_ushort", JIT_OPCODE_NINT_ARG}, + {"ldl_0_int", JIT_OPCODE_NINT_ARG}, + {"ldl_0_long", JIT_OPCODE_NINT_ARG}, + {"ldl_0_float32", JIT_OPCODE_NINT_ARG}, + {"ldl_0_float64", JIT_OPCODE_NINT_ARG}, + {"ldl_0_nfloat", JIT_OPCODE_NINT_ARG}, + {"ldl_0_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldla_0", JIT_OPCODE_NINT_ARG}, + {"ldl_1_sbyte", JIT_OPCODE_NINT_ARG}, + {"ldl_1_ubyte", JIT_OPCODE_NINT_ARG}, + {"ldl_1_short", JIT_OPCODE_NINT_ARG}, + {"ldl_1_ushort", JIT_OPCODE_NINT_ARG}, + {"ldl_1_int", JIT_OPCODE_NINT_ARG}, + {"ldl_1_long", JIT_OPCODE_NINT_ARG}, + {"ldl_1_float32", JIT_OPCODE_NINT_ARG}, + {"ldl_1_float64", JIT_OPCODE_NINT_ARG}, + {"ldl_1_nfloat", JIT_OPCODE_NINT_ARG}, + {"ldl_1_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldla_1", JIT_OPCODE_NINT_ARG}, + {"ldl_2_sbyte", JIT_OPCODE_NINT_ARG}, + {"ldl_2_ubyte", JIT_OPCODE_NINT_ARG}, + {"ldl_2_short", JIT_OPCODE_NINT_ARG}, + {"ldl_2_ushort", JIT_OPCODE_NINT_ARG}, + {"ldl_2_int", JIT_OPCODE_NINT_ARG}, + {"ldl_2_long", JIT_OPCODE_NINT_ARG}, + {"ldl_2_float32", JIT_OPCODE_NINT_ARG}, + {"ldl_2_float64", JIT_OPCODE_NINT_ARG}, + {"ldl_2_nfloat", JIT_OPCODE_NINT_ARG}, + {"ldl_2_struct", JIT_OPCODE_NINT_ARG_TWO}, + {"ldla_2", JIT_OPCODE_NINT_ARG}, + {"stl_0_byte", JIT_OPCODE_NINT_ARG}, + {"stl_0_short", JIT_OPCODE_NINT_ARG}, + {"stl_0_int", JIT_OPCODE_NINT_ARG}, + {"stl_0_long", JIT_OPCODE_NINT_ARG}, + {"stl_0_float32", JIT_OPCODE_NINT_ARG}, + {"stl_0_float64", JIT_OPCODE_NINT_ARG}, + {"stl_0_nfloat", JIT_OPCODE_NINT_ARG}, + {"stl_0_struct", JIT_OPCODE_NINT_ARG_TWO}, /* - * Pointer check opcodes (interpreter only). + * Load constant values. */ - {"check_null_n", JIT_OPCODE_NINT_ARG}, + {"ldc_0_int", JIT_OPCODE_NINT_ARG}, + {"ldc_1_int", JIT_OPCODE_NINT_ARG}, + {"ldc_2_int", JIT_OPCODE_NINT_ARG}, + {"ldc_0_long", JIT_OPCODE_CONST_LONG}, + {"ldc_1_long", JIT_OPCODE_CONST_LONG}, + {"ldc_2_long", JIT_OPCODE_CONST_LONG}, + {"ldc_0_float32", JIT_OPCODE_CONST_FLOAT32}, + {"ldc_1_float32", JIT_OPCODE_CONST_FLOAT32}, + {"ldc_2_float32", JIT_OPCODE_CONST_FLOAT32}, + {"ldc_0_float64", JIT_OPCODE_CONST_FLOAT64}, + {"ldc_1_float64", JIT_OPCODE_CONST_FLOAT64}, + {"ldc_2_float64", JIT_OPCODE_CONST_FLOAT64}, + {"ldc_0_nfloat", JIT_OPCODE_CONST_NFLOAT}, + {"ldc_1_nfloat", JIT_OPCODE_CONST_NFLOAT}, + {"ldc_2_nfloat", JIT_OPCODE_CONST_NFLOAT}, /* - * Stack management. + * Load return value. */ - {"pop", 0}, - {"pop_2", 0}, - {"pop_3", 0}, - {"push_return_int", 0}, - {"push_return_long", 0}, - {"push_return_float32", 0}, - {"push_return_float64", 0}, - {"push_return_nfloat", 0}, - {"push_return_small_struct", JIT_OPCODE_NINT_ARG}, + {"ldr_0_int", 0}, + {"ldr_0_long", 0}, + {"ldr_0_float32", 0}, + {"ldr_0_float64", 0}, + {"ldr_0_nfloat", 0}, + {"ldr_0_small_struct", JIT_OPCODE_NINT_ARG}, /* - * Nested function call handling. + * Stack management. */ - {"import_local", JIT_OPCODE_NINT_ARG_TWO}, - {"import_arg", JIT_OPCODE_NINT_ARG_TWO}, + {"pop", 0}, + {"pop_2", 0}, + {"pop_3", 0}, /* - * Push constant values onto the stack. + * Nested function call handling. */ - {"push_const_int", JIT_OPCODE_NINT_ARG}, - {"push_const_long", JIT_OPCODE_CONST_LONG}, - {"push_const_float32", JIT_OPCODE_CONST_FLOAT32}, - {"push_const_float64", JIT_OPCODE_CONST_FLOAT64}, - {"push_const_nfloat", JIT_OPCODE_CONST_NFLOAT}, + {"import_local", JIT_OPCODE_NINT_ARG_TWO}, + {"import_arg", JIT_OPCODE_NINT_ARG_TWO}, /* * Marker opcode for the end of a function. */ - {"end_marker", 0}, + {"end_marker", 0}, }; #endif /* JIT_BACKEND_INTERP */ diff --git a/jit/jit-rules-interp.c b/jit/jit-rules-interp.c index 28bd821..aedc8c3 100644 --- a/jit/jit-rules-interp.c +++ b/jit/jit-rules-interp.c @@ -532,7 +532,8 @@ int _jit_create_call_setup_insns @*/ 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; } /*@ @@ -754,28 +755,7 @@ void *_jit_gen_redirector(jit_gencode_t gen, jit_function_t func) 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 */ } /*@ @@ -795,13 +775,7 @@ void _jit_gen_spill_reg(jit_gencode_t gen, int reg, 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 */ } /*@ @@ -814,95 +788,7 @@ void _jit_gen_free_reg(jit_gencode_t gen, int reg, 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 */ } /*@ @@ -919,7 +805,6 @@ void _jit_gen_spill_global(jit_gencode_t gen, int reg, jit_value_t value) /* 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. @@ -992,30 +877,146 @@ void _jit_gen_fix_value(jit_value_t value) } } -/* - * 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); } } @@ -1038,574 +1039,436 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t func, 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) @@ -1628,6 +1491,7 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t func, jit_cache_native (&(gen->posn), jit_type_get_size(insn->value1->type)); adjust_working(gen, -2); +#endif } break; @@ -1642,32 +1506,24 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t func, 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; @@ -1680,55 +1536,43 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t func, 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; @@ -1743,82 +1587,22 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t func, 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; diff --git a/jit/jit-rules-interp.h b/jit/jit-rules-interp.h index f46c71f..0605196 100644 --- a/jit/jit-rules-interp.h +++ b/jit/jit-rules-interp.h @@ -30,26 +30,11 @@ extern "C" { /* * Information about all of the registers, in allocation order. */ -#define JIT_REG_INFO \ - {"r0", 0, -1, JIT_REG_ALL | JIT_REG_CALL_USED | \ - JIT_REG_START_STACK | JIT_REG_IN_STACK}, \ - {"r1", 1, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r2", 2, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r3", 3, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r4", 4, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r5", 5, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r6", 6, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r7", 7, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r8", 8, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r9", 9, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r10", 10, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r11", 11, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r12", 12, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r13", 13, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r14", 14, -1, JIT_REG_ALL | JIT_REG_CALL_USED | JIT_REG_IN_STACK}, \ - {"r15", 15, -1, JIT_REG_ALL | JIT_REG_CALL_USED | \ - JIT_REG_END_STACK | JIT_REG_IN_STACK}, -#define JIT_NUM_REGS 16 +#define JIT_REG_INFO \ + {"r0", 0, -1, JIT_REG_ALL | JIT_REG_CALL_USED}, \ + {"r1", 1, -1, JIT_REG_ALL | JIT_REG_CALL_USED}, \ + {"r2", 2, -1, JIT_REG_ALL | JIT_REG_CALL_USED}, +#define JIT_NUM_REGS 3 #define JIT_NUM_GLOBAL_REGS 0 /*