[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] libjit ChangeLog jit/jit-interp.h jit/jit-inter...
|
From: |
Aleksey Demakov |
|
Subject: |
[dotgnu-pnet-commits] libjit ChangeLog jit/jit-interp.h jit/jit-inter... |
|
Date: |
Wed, 30 Aug 2006 13:31:58 +0000 |
CVSROOT: /sources/dotgnu-pnet
Module name: libjit
Changes by: Aleksey Demakov <avd> 06/08/30 13:31:58
Modified files:
. : ChangeLog
jit : jit-interp.h jit-interp.c jit-rules-interp.h
jit-rules-interp.c jit-opcode.c jit-function.c
Log message:
replace interpreter stack with 3 dedicated pseudo-registers
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/libjit/ChangeLog?cvsroot=dotgnu-pnet&r1=1.262&r2=1.263
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-interp.h?cvsroot=dotgnu-pnet&r1=1.7&r2=1.8
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-interp.c?cvsroot=dotgnu-pnet&r1=1.14&r2=1.15
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-rules-interp.h?cvsroot=dotgnu-pnet&r1=1.4&r2=1.5
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-rules-interp.c?cvsroot=dotgnu-pnet&r1=1.26&r2=1.27
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-opcode.c?cvsroot=dotgnu-pnet&r1=1.18&r2=1.19
http://cvs.savannah.gnu.org/viewcvs/libjit/jit/jit-function.c?cvsroot=dotgnu-pnet&r1=1.21&r2=1.22
Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/ChangeLog,v
retrieving revision 1.262
retrieving revision 1.263
diff -u -b -r1.262 -r1.263
--- ChangeLog 29 Aug 2006 13:29:35 -0000 1.262
+++ ChangeLog 30 Aug 2006 13:31:58 -0000 1.263
@@ -1,5 +1,22 @@
+2006-08-30 Aleksey Demakov <address@hidden>
+
+ * 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 <address@hidden>
+ * 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.
Index: jit/jit-interp.h
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-interp.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -b -r1.7 -r1.8
--- jit/jit-interp.h 13 Aug 2004 04:06:33 -0000 1.7
+++ jit/jit-interp.h 30 Aug 2006 13:31:58 -0000 1.8
@@ -90,86 +90,139 @@
/*
* 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)
-
-/*
- * Pointer check opcodes (interpreter only).
- */
-#define JIT_OP_CHECK_NULL_N
(JIT_OP_NUM_OPCODES + 0x0026)
+#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)
+
+/*
+ * Load constant values.
+ */
+#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)
+
+/*
+ * Load return value.
+ */
+#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)
/*
* Stack management.
*/
-#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_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)
/*
* Nested function call handling.
*/
-#define JIT_OP_IMPORT_LOCAL
(JIT_OP_NUM_OPCODES + 0x0030)
-#define JIT_OP_IMPORT_ARG
(JIT_OP_NUM_OPCODES + 0x0031)
-
-/*
- * Push constant values onto the stack.
- */
-#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.
Index: jit/jit-interp.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-interp.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -b -r1.14 -r1.15
--- jit/jit-interp.c 11 Jan 2006 00:24:42 -0000 1.14
+++ jit/jit-interp.c 30 Aug 2006 13:31:58 -0000 1.15
@@ -66,6 +66,10 @@
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); \
@@ -80,6 +84,49 @@
#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.
*/
#define VM_STK_INT0 (stacktop[0].int_value)
@@ -130,9 +177,9 @@
* 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 @@
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 @@
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 @@
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 @@
{
/* 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 @@
{
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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;
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 @@
VMCASE(JIT_OP_CHECK_NULL):
{
/* Check the top of stack to see if it is null */
- if(!VM_STK_PTR0)
+ if(!VM_R1_PTR)
{
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))
- {
- VM_BUILTIN(JIT_RESULT_NULL_REFERENCE);
- }
- VM_MODIFY_PC_AND_STACK(1, 0);
+ VM_MODIFY_PC(1);
}
VMBREAK;
@@ -3360,14 +3303,15 @@
{
/* 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,
+ _jit_run_function((jit_function_interp_t)entry,
+ stacktop,
return_area);
_jit_backtrace_pop();
}
@@ -3392,10 +3336,10 @@
/* 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,
+ (void *)VM_R1_PTR,
stacktop,
(unsigned
int)temparg,
VM_STK_PTRP);
@@ -3406,19 +3350,20 @@
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,
+ _jit_run_function((jit_function_interp_t)entry,
+ stacktop,
return_area);
_jit_backtrace_pop();
}
@@ -3427,7 +3372,7 @@
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);
@@ -3473,7 +3418,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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,
+#if JIT_APPLY_MAX_STRUCT_IN_REG != 0
+ jit_memcpy(return_area->struct_value,
+ VM_R1_PTR,
(unsigned int)VM_NINT_ARG);
- #endif
+#endif
if(jbuf)
{
_jit_unwind_pop_setjmp();
@@ -3547,6 +3493,7 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 */
+ if(jbuf)
+ {
_jit_unwind_pop_setjmp();
+ }
jit_exception_throw(exception_object);
}
}
@@ -3644,24 +3631,27 @@
VMCASE(JIT_OP_RETHROW):
{
/* Rethrow an exception to the caller */
+ if(jbuf)
+ {
_jit_unwind_pop_setjmp();
- jit_exception_throw(VM_STK_PTR0);
+ }
+ 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
* 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_LDARGA):
+ VMCASE(JIT_OP_LDA_1_SBYTE):
{
- /* Load the address of an argument onto the stack */
- VM_STK_PTRP = VM_ARG(void);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* 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_STARG_BYTE):
+ VMCASE(JIT_OP_LDA_1_UBYTE):
{
- /* 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 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_STARG_SHORT):
+ VMCASE(JIT_OP_LDA_1_SHORT):
{
- /* 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 signed 16-bit integer argument into the
register 1 */
+ VM_R1_INT = *VM_ARG(jit_short);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_INT):
+ VMCASE(JIT_OP_LDA_1_USHORT):
{
- /* Store a 32-bit integer into a stack argument */
- *VM_ARG(jit_int) = VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STARG_LONG):
+ VMCASE(JIT_OP_LDA_1_INT):
{
- /* 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 32-bit integer argument into the register 1 */
+ VM_R1_INT = *VM_ARG(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_FLOAT32):
+ VMCASE(JIT_OP_LDA_1_LONG):
{
- /* 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 64-bit integer argument into the register 1 */
+ VM_R1_LONG = *VM_ARG(jit_long);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STARG_FLOAT64):
+ VMCASE(JIT_OP_LDA_1_FLOAT32):
{
- /* Store a 64-bit float into a stack argument */
- *VM_ARG(jit_float64) = VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STARG_NFLOAT):
+ VMCASE(JIT_OP_LDA_1_FLOAT64):
{
- /* Store a native float into a stack argument */
- *VM_ARG(jit_nfloat) = VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STARG_STRUCT):
+ VMCASE(JIT_OP_LDA_1_NFLOAT):
{
- /* Store a structure value into a stack argument */
+ /* 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(VM_ARG(void), stacktop, temparg);
- stacktop += JIT_NUM_ITEMS_IN_STRUCT(temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ 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_LDA_2_INT):
+ {
+ /* 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_LDA_2_LONG):
+ {
+ /* 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_LDA_2_FLOAT32):
+ {
+ /* 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_LDA_2_FLOAT64):
+ {
+ /* 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_LDA_2_NFLOAT):
+ {
+ /* Load a native float argument into the register 2 */
+ VM_R2_NFLOAT = *VM_ARG(jit_nfloat);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDA_2_STRUCT):
+ {
+ /* 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_LDAA_2):
+ {
+ /* Load the address of an argument into the register 2
*/
+ VM_R2_PTR = VM_ARG(void);
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_STA_0_BYTE):
+ {
+ /* 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_STA_0_SHORT):
+ {
+ /* 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), &r0, temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
@@ -4220,308 +4382,574 @@
* 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_LDLOCA):
+ VMCASE(JIT_OP_LDL_1_SBYTE):
{
- /* Load the address of an local onto the stack */
- VM_STK_PTRP = VM_LOC(void);
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* 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_STLOC_BYTE):
+ VMCASE(JIT_OP_LDL_1_UBYTE):
{
- /* 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 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_STLOC_SHORT):
+ VMCASE(JIT_OP_LDL_1_SHORT):
{
- /* 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 signed 16-bit integer local into the register
1 */
+ VM_R1_INT = *VM_LOC(jit_short);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_STLOC_INT):
+ VMCASE(JIT_OP_LDL_1_USHORT):
{
- /* Store a 32-bit integer into a stack local */
- *VM_LOC(jit_int) = VM_STK_INT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STLOC_LONG):
+ VMCASE(JIT_OP_LDL_1_INT):
{
- /* Store a 64-bit integer into a stack local */
- *VM_LOC(jit_long) = VM_STK_LONG0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STLOC_FLOAT32):
+ VMCASE(JIT_OP_LDL_1_LONG):
{
- /* Store a 32-bit float into a stack local */
- *VM_LOC(jit_float32) = VM_STK_FLOAT320;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STLOC_FLOAT64):
+ VMCASE(JIT_OP_LDL_1_FLOAT32):
{
- /* Store a 64-bit float into a stack local */
- *VM_LOC(jit_float64) = VM_STK_FLOAT640;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STLOC_NFLOAT):
+ VMCASE(JIT_OP_LDL_1_FLOAT64):
{
- /* Store a native float into a stack local */
- *VM_LOC(jit_nfloat) = VM_STK_NFLOAT0;
- VM_MODIFY_PC_AND_STACK(2, 1);
+ /* 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_STLOC_STRUCT):
+ VMCASE(JIT_OP_LDL_1_NFLOAT):
{
- /* Store a structure value into a stack local */
+ /* 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(VM_LOC(void), stacktop, temparg);
- stacktop += JIT_NUM_ITEMS_IN_STRUCT(temparg);
- VM_MODIFY_PC_AND_STACK(3, 0);
+ jit_memcpy(&r1, VM_LOC(void), temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
-
/******************************************************************
- * Stack management
-
******************************************************************/
+ 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_POP_STACK):
+ VMCASE(JIT_OP_LDL_2_SBYTE):
{
- /* Pop a specific number of items from the stack */
- temparg = VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, temparg);
+ /* 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_POP):
+ VMCASE(JIT_OP_LDL_2_UBYTE):
{
- /* Pop a single item from the stack */
- VM_MODIFY_PC_AND_STACK(1, 1);
+ /* 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_POP_2):
+ VMCASE(JIT_OP_LDL_2_SHORT):
{
- /* Pop two items from the stack */
- VM_MODIFY_PC_AND_STACK(1, 2);
+ /* 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_POP_3):
+ VMCASE(JIT_OP_LDL_2_USHORT):
{
- /* Pop three items from the stack */
- VM_MODIFY_PC_AND_STACK(1, 3);
+ /* 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_PUSH_RETURN_INT):
+ VMCASE(JIT_OP_LDL_2_INT):
{
- /* 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 32-bit integer local into the register 2 */
+ VM_R2_INT = *VM_LOC(jit_int);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_LONG):
+ VMCASE(JIT_OP_LDL_2_LONG):
{
- /* 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 a 64-bit integer local into the register 2 */
+ VM_R2_LONG = *VM_LOC(jit_long);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_FLOAT32):
+ VMCASE(JIT_OP_LDL_2_FLOAT32):
{
- /* 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 32-bit float local into the register 2 */
+ VM_R2_FLOAT32 = *VM_LOC(jit_float32);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_FLOAT64):
+ VMCASE(JIT_OP_LDL_2_FLOAT64):
{
- /* 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 64-bit float local into the register 2 */
+ VM_R2_FLOAT64 = *VM_LOC(jit_float64);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_NFLOAT):
+ VMCASE(JIT_OP_LDL_2_NFLOAT):
{
- /* 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 native float local into the register 2 */
+ VM_R2_NFLOAT = *VM_LOC(jit_nfloat);
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_RETURN_SMALL_STRUCT):
+ VMCASE(JIT_OP_LDL_2_STRUCT):
{
- /* 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 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_PUSH_RETURN_AREA_PTR):
+ VMCASE(JIT_OP_LDLA_2):
{
- /* Push the address of "return_area" for an external
call */
- VM_STK_PTRP = return_area;
- VM_MODIFY_PC_AND_STACK(1, -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_STL_0_BYTE):
+ {
+ /* 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_STL_0_SHORT):
+ {
+ /* 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_STL_0_INT):
+ {
+ /* 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_STL_0_LONG):
+ {
+ /* 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_STL_0_FLOAT32):
+ {
+ /* 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), &r0, temparg);
+ VM_MODIFY_PC(3);
}
VMBREAK;
/******************************************************************
- * Stack management
+ * Load constant values.
******************************************************************/
#define JIT_WORDS_PER_TYPE(type) \
((sizeof(type) + sizeof(void *) - 1) / sizeof(void *))
- VMCASE(JIT_OP_PUSH_CONST_INT):
+ VMCASE(JIT_OP_LDC_0_INT):
+ {
+ /* Load an integer constant into the register 0 */
+ VM_R0_INT = (jit_int)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
+ }
+ VMBREAK;
+
+ VMCASE(JIT_OP_LDC_0_LONG):
+ {
+ /* 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_LDC_0_FLOAT32):
+ {
+ /* 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_LDC_0_FLOAT64):
{
- /* Push an integer constant onto the stack */
- VM_STK_INTP = (jit_int)VM_NINT_ARG;
- VM_MODIFY_PC_AND_STACK(2, -1);
+ /* 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_CONST_LONG):
+ VMCASE(JIT_OP_LDC_0_NFLOAT):
{
- /* 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 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_CONST_FLOAT32):
+ VMCASE(JIT_OP_LDC_1_INT):
{
- /* 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 an integer constant into the register 1 */
+ VM_R1_INT = (jit_int)VM_NINT_ARG;
+ VM_MODIFY_PC(2);
}
VMBREAK;
- VMCASE(JIT_OP_PUSH_CONST_FLOAT64):
+ VMCASE(JIT_OP_LDC_1_LONG):
{
- /* 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 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_CONST_NFLOAT):
+ VMCASE(JIT_OP_LDC_1_FLOAT32):
{
- /* 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);
+ /* 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_LDC_1_FLOAT64):
+ {
+ /* 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_LDC_1_NFLOAT):
+ {
+ /* 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_LDC_2_INT):
+ {
+ /* 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;
+
+
/******************************************************************
+ * Load return value.
+
******************************************************************/
+
+ 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_LDR_0_FLOAT32):
+ {
+ /* 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_LDR_0_FLOAT64):
+ {
+ /* 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_LDR_0_NFLOAT):
+ {
+ /* 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_LDR_0_SMALL_STRUCT):
+ {
+ /* 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;
+
+
/******************************************************************
+ * Stack management.
+
******************************************************************/
+
+ VMCASE(JIT_OP_POP_STACK):
+ {
+ /* 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 @@
/* 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 @@
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):
Index: jit/jit-rules-interp.h
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-rules-interp.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -b -r1.4 -r1.5
--- jit/jit-rules-interp.h 24 Jun 2004 04:11:46 -0000 1.4
+++ jit/jit-rules-interp.h 30 Aug 2006 13:31:58 -0000 1.5
@@ -31,25 +31,10 @@
* 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
+ {"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
/*
Index: jit/jit-rules-interp.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-rules-interp.c,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -b -r1.26 -r1.27
--- jit/jit-rules-interp.c 29 Aug 2006 11:57:13 -0000 1.26
+++ jit/jit-rules-interp.c 30 Aug 2006 13:31:58 -0000 1.27
@@ -532,7 +532,8 @@
@*/
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_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_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_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 @@
/* 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 @@
}
}
-/*
- * 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)
+ {
+ /* 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_LDC_0_INT +
index);
+ jit_cache_native(&(gen->posn),
(jit_nint)(value->address));
+ break;
+
+ case JIT_TYPE_LONG:
+ case JIT_TYPE_ULONG:
{
- if((insn->flags & JIT_INSN_DEST_NEXT_USE) != 0)
+ 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:
{
- /* Record that the destination is in "reg" */
- _jit_regs_set_value(gen, reg, insn->dest, 0);
+ 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
{
- /* 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);
+ /* 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
{
- /* This is a note, with the result left on the stack */
- _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
+ {
+ 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,55 +1039,6 @@
switch(insn->opcode)
{
- case JIT_OP_BR:
- case JIT_OP_CALL_FINALLY:
- {
- /* 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;
-
- 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 */
- 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;
- }
- /* Not reached */
-
case JIT_OP_BR_IEQ:
case JIT_OP_BR_INE:
case JIT_OP_BR_ILT:
@@ -1143,22 +1095,42 @@
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);
- if(!_jit_regs_is_top_two(gen, insn->value1,
insn->value2) ||
- _jit_regs_num_used(gen, 0) != 2)
+ pc = (void **)(gen->posn.ptr);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
+ block = jit_block_from_label(func, label);
+ if(!block)
{
- _jit_regs_spill_all(gen);
+ break;
}
- 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;
+ 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;
}
- /* Not reached */
+ break;
case JIT_OP_JUMP_TABLE:
{
@@ -1166,16 +1138,11 @@
jit_nint num_labels;
jit_nint index;
+ load_value(gen, insn->dest, 0);
+
labels = (jit_label_t *) insn->value1->address;
num_labels = insn->value2->address;
- _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);
-
jit_cache_opcode(&(gen->posn), insn->opcode);
jit_cache_native(&(gen->posn), num_labels);
for(index = 0; index < num_labels; index++)
@@ -1198,31 +1165,23 @@
block->fixup_absolute_list = pc;
}
}
- }
break;
+ }
case JIT_OP_ADDRESS_OF_LABEL:
- {
/* 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);
if(!block)
{
break;
}
+ pc = (void **)(gen->posn.ptr);
+ jit_cache_opcode(&(gen->posn), insn->opcode);
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), ((void
**)(block->address)) - pc);
}
else
{
@@ -1230,57 +1189,53 @@
jit_cache_native(&(gen->posn),
block->fixup_list);
block->fixup_list = (void *)pc;
}
- }
+ store_value(gen, insn->dest, 0);
break;
+#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_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_CALL_INDIRECT:
case JIT_OP_CALL_INDIRECT_TAIL:
- {
- /* Call a function, whose pointer is supplied on the
stack */
+ /* 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))));
- adjust_working(gen, -1);
- }
break;
case JIT_OP_CALL_VTABLE_PTR:
case JIT_OP_CALL_VTABLE_PTR_TAIL:
- {
- /* Call a function, whose vtable pointer is supplied on
the stack */
+ /* Call a function, whose vtable pointer is supplied in the
register */
+ load_value(gen, insn->value1, 1);
jit_cache_opcode(&(gen->posn), insn->opcode);
- adjust_working(gen, -1);
- }
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))));
- }
break;
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);
- }
break;
case JIT_OP_RETURN_INT:
@@ -1288,55 +1243,36 @@
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);
+ load_value(gen, insn->value1, 1);
jit_cache_opcode(&(gen->posn), insn->opcode);
- _jit_regs_free_reg(gen, reg, 1);
- }
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);
+ 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));
- _jit_regs_free_reg(gen, reg, 1);
- }
+ jit_cache_native(&(gen->posn),
jit_value_get_nint_constant(insn->value2));
break;
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_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_IMPORT:
- {
+ /* TODO!!! */
/* Import a local variable from an outer nested scope */
if(_jit_regs_num_used(gen, 0) >= JIT_NUM_REGS)
{
@@ -1347,81 +1283,58 @@
{
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));
+ 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));
+ 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_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);
+ load_value(gen, insn->value1, 1);
jit_cache_opcode(&(gen->posn), insn->opcode);
- _jit_regs_free_reg(gen, reg, 1);
- }
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);
- }
+ store_value(gen, insn->dest, 0);
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_OP_ENTER_FINALLY:
- {
/* Record that the finally return address is on the
stack */
++(gen->extra_working_space);
- }
break;
case JIT_OP_LEAVE_FINALLY:
- {
/* Leave a finally clause */
jit_cache_opcode(&(gen->posn), insn->opcode);
- }
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_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)
@@ -1431,11 +1344,9 @@
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_RETURN_REG:
- {
/* Push a function return value back onto the stack */
switch(jit_type_normalize(insn->value1->type)->kind)
{
@@ -1445,42 +1356,31 @@
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);
- }
+ 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_PUSH_RETURN_LONG);
- adjust_working(gen, 1);
- }
+ 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_PUSH_RETURN_FLOAT32);
- adjust_working(gen, 1);
- }
+ 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_PUSH_RETURN_FLOAT64);
- adjust_working(gen, 1);
- }
+ 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_PUSH_RETURN_NFLOAT);
- adjust_working(gen, 1);
- }
+ jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_NFLOAT);
+ store_value(gen, insn->value1, 0);
break;
}
- }
break;
case JIT_OP_COPY_LOAD_SBYTE:
@@ -1495,38 +1395,25 @@
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
*/
- 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);
- }
+ load_value(gen, insn->value1, 0);
+ store_value(gen, insn->dest, 0);
break;
case JIT_OP_ADDRESS_OF:
- {
/* 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_opcode(&(gen->posn), JIT_OP_LDLA_0);
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);
+ 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_PUSH_INT:
@@ -1534,54 +1421,29 @@
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);
- }
+ 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 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);
-
+ /* 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) - 1);
- }
+ 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_regs_spill_all(gen);
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)
@@ -1601,11 +1463,12 @@
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 @@
jit_cache_native
(&(gen->posn),
jit_type_get_size(insn->value1->type));
adjust_working(gen, -2);
+#endif
}
break;
@@ -1642,32 +1506,24 @@
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 @@
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 @@
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)
- {
- /* 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);
- }
- else if(insn->value2)
- {
- /* 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)
+ if(insn->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE)
!= 0)
{
- /* Record that the destination
is in "reg" */
- _jit_regs_set_value(gen, reg,
insn->dest, 0);
+ load_value(gen, insn->dest, 0);
}
- else
+ if(insn->value1)
{
- /* 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_value(gen, insn->value1, 1);
}
- else
+ if(insn->value2)
{
- /* This is a note, with the result left
on the stack */
- _jit_regs_free_reg(gen, reg, 1);
- }
+ load_value(gen, insn->value2, 2);
}
- else
- {
- /* 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->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE)
== 0)
{
- 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);
- }
+ store_value(gen, insn->dest, 0);
}
}
break;
Index: jit/jit-opcode.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-opcode.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -b -r1.18 -r1.19
--- jit/jit-opcode.c 28 Aug 2006 19:52:48 -0000 1.18
+++ jit/jit-opcode.c 30 Aug 2006 13:31:58 -0000 1.19
@@ -549,53 +549,121 @@
/*
* 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},
-
- /*
- * Pointer check opcodes (interpreter only).
- */
- {"check_null_n", JIT_OPCODE_NINT_ARG},
+ {"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},
+
+ /*
+ * Load constant values.
+ */
+ {"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},
+
+ /*
+ * Load return value.
+ */
+ {"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},
/*
* Stack management.
@@ -603,12 +671,6 @@
{"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},
/*
* Nested function call handling.
@@ -617,15 +679,6 @@
{"import_arg",
JIT_OPCODE_NINT_ARG_TWO},
/*
- * Push constant values onto the stack.
- */
- {"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},
-
- /*
* Marker opcode for the end of a function.
*/
{"end_marker", 0},
Index: jit/jit-function.c
===================================================================
RCS file: /sources/dotgnu-pnet/libjit/jit/jit-function.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -b -r1.21 -r1.22
--- jit/jit-function.c 22 Aug 2006 20:55:31 -0000 1.21
+++ jit/jit-function.c 30 Aug 2006 13:31:58 -0000 1.22
@@ -519,6 +519,7 @@
}
break;
+#ifndef JIT_BACKEND_INTERP
case JIT_OP_INCOMING_REG:
{
/* Assign a register to an incoming value */
@@ -527,6 +528,7 @@
insn->value1);
}
break;
+#endif
case JIT_OP_INCOMING_FRAME_POSN:
{
@@ -547,6 +549,7 @@
}
break;
+#ifndef JIT_BACKEND_INTERP
case JIT_OP_OUTGOING_REG:
{
/* Copy a value into an outgoing register */
@@ -555,6 +558,7 @@
insn->value1);
}
break;
+#endif
case JIT_OP_OUTGOING_FRAME_POSN:
{
@@ -569,6 +573,7 @@
}
break;
+#ifndef JIT_BACKEND_INTERP
case JIT_OP_RETURN_REG:
{
/* Assign a register to a return value */
@@ -578,6 +583,7 @@
_jit_gen_insn(gen, func, block, insn);
}
break;
+#endif
case JIT_OP_MARK_OFFSET:
{
@@ -681,7 +687,9 @@
_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 @@
#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;
@@ -744,13 +754,17 @@
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 @@
/* Convert the cookie into a handler address */
if(handler)
{
+#if 0
if(cookie)
{
*handler = ((jit_cache_eh_t)cookie)->handler;
@@ -1080,6 +1095,9 @@
{
*handler = 0;
}
+#else
+ *handler = cookie;
+#endif
}
return func;
}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] libjit ChangeLog jit/jit-interp.h jit/jit-inter...,
Aleksey Demakov <=