[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 135/437: Correct implementation problems on ix86.
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 135/437: Correct implementation problems on ix86. |
|
Date: |
Mon, 2 Jul 2018 05:14:03 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 712877a5a4c967e0db6a6ce4e92162c9a9056192
Author: pcpa <address@hidden>
Date: Mon Dec 3 09:40:08 2012 -0200
Correct implementation problems on ix86.
* check/all.tst, check/lightning.c: Only declare or use 64 bit
interfaces on 64 bit builds.
* check/fib.tst: Use simpler logic to not need preprocessor
conditionals for 32 or 64 bit.
* include/lightning.h: Only declare 64 bit macros on a 64 bit
build. Code using lightning must know about wordsize and the
jit generation limitations, also, this way it generates a
compile time failure, not a runtime assertion.
* include/lightning/jit_x86.h: Correct typo in macro name.
* lib/jit_arm.c, lib/jit_arm-cpu.c, lib/jit_mips.c,
lib/jit_mips-cpu.c, lib/jit_ppc.c, lib/jit_ppc-cpu.c,
lib/jit_x86.c, lib/jit_x86-cpu.c: Correct wrong code to get
current jit function pointer.
* lib/lightning.c: Move call to the simplify() optimization
to after register liveness is known. Previous code did work
by accident but now with proper test cases the problem was
noticed.
* lib/jit_disasm.c: Always cast bfd_vma to long long when
passing it as printf argument.
---
ChangeLog | 28 +++++++++
check/all.tst | 20 +++++++
check/fib.tst | 2 +-
check/lightning.c | 66 ++++++++++++++++----
include/lightning.h | 54 +++++++----------
include/lightning/jit_x86.h | 2 +-
lib/jit_arm-cpu.c | 7 +--
lib/jit_arm.c | 3 +-
lib/jit_disasm.c | 4 +-
lib/jit_mips-cpu.c | 142 ++++++++++++++++++++------------------------
lib/jit_mips.c | 3 +-
lib/jit_ppc-cpu.c | 18 ++----
lib/jit_ppc.c | 3 +-
lib/jit_x86-cpu.c | 48 +++++++--------
lib/jit_x86.c | 9 +--
lib/lightning.c | 2 +-
16 files changed, 229 insertions(+), 182 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 5985a8b..760d29e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,33 @@
2012-12-03 Paulo Andrade <address@hidden>
+ * check/all.tst, check/lightning.c: Only declare or use 64 bit
+ interfaces on 64 bit builds.
+
+ * check/fib.tst: Use simpler logic to not need preprocessor
+ conditionals for 32 or 64 bit.
+
+ * include/lightning.h: Only declare 64 bit macros on a 64 bit
+ build. Code using lightning must know about wordsize and the
+ jit generation limitations, also, this way it generates a
+ compile time failure, not a runtime assertion.
+
+ * include/lightning/jit_x86.h: Correct typo in macro name.
+
+ * lib/jit_arm.c, lib/jit_arm-cpu.c, lib/jit_mips.c,
+ lib/jit_mips-cpu.c, lib/jit_ppc.c, lib/jit_ppc-cpu.c,
+ lib/jit_x86.c, lib/jit_x86-cpu.c: Correct wrong code to get
+ current jit function pointer.
+
+ * lib/lightning.c: Move call to the simplify() optimization
+ to after register liveness is known. Previous code did work
+ by accident but now with proper test cases the problem was
+ noticed.
+
+ * lib/jit_disasm.c: Always cast bfd_vma to long long when
+ passing it as printf argument.
+
+2012-12-03 Paulo Andrade <address@hidden>
+
* configure.ac, check/Makefile.am, check/check.sh,
doc/Makefile.am, include/lightning/Makefile.am,
lib/Makefile.am: Correct make distcheck.
diff --git a/check/all.tst b/check/all.tst
index 9a2ec44..055da44 100644
--- a/check/all.tst
+++ b/check/all.tst
@@ -7,15 +7,19 @@
arg $s
arg $us
arg $i
+#if __WORDSIZE == 64
arg $ui
arg $l
+#endif
getarg_c %r0 $c
getarg_uc %r0 $uc
getarg_s %r0 $s
getarg_us %r0 $us
getarg_i %r0 $i
+#if __WORDSIZE == 64
getarg_ui %r0 $ui
getarg_l %r0 $l
+#endif
addr %r0 %r1 %r2
addi %r0 %r1 2
addxr %r0 %r1 %r2
@@ -78,8 +82,10 @@
extr_uc %r0 %r1
extr_s %r0 %r1
extr_us %r0 %r1
+#if __WORDSIZE == 64
extr_i %r0 %r1
extr_ui %r0 %r1
+#endif
htonr %r0 %r1
ntohr %r0 %r1
ldr_c %r0 %r1
@@ -92,10 +98,12 @@
ldi_us %r0 0x80000000
ldr_i %r0 %r1
ldi_i %r0 0x80000000
+#if __WORDSIZE == 64
ldr_ui %r0 %r1
ldi_ui %r0 0x80000000
ldr_l %r0 %r1
ldi_l %r0 0x80000000
+#endif
ldxr_c %r0 %r1 %r2
ldxi_c %r0 %r1 1
ldxr_uc %r0 %r1 %r2
@@ -106,26 +114,32 @@
ldxi_us %r0 %r1 2
ldxr_i %r0 %r1 %r2
ldxi_i %r0 %r1 4
+#if __WORDSIZE == 64
ldxr_ui %r0 %r1 %r2
ldxi_ui %r0 %r1 4
ldxr_l %r0 %r1 %r2
ldxi_l %r0 %r1 8
+#endif
str_c %r1 %r0
sti_c 0x80000000 %r1
str_s %r1 %r0
sti_s 0x80000000 %r1
str_i %r1 %r0
sti_i 0x80000000 %r1
+#if __WORDSIZE == 64
str_l %r1 %r0
sti_l 0x80000000 %r1
+#endif
stxr_c %r2 %r1 %r0
stxi_c 1 %r1 %r0
stxr_s %r2 %r1 %r0
stxi_s 2 %r1 %r0
stxr_i %r2 %r1 %r0
stxi_i 4 %r1 %r0
+#if __WORDSIZE == 64
stxr_l %r2 %r1 %r0
stxi_l 8 %r1 %r0
+#endif
cond:
bltr cond %r0 %r1
condi:
@@ -196,8 +210,10 @@ label:
retval_s %r1
retval_us %r1
retval_i %r1
+#if __WORDSIZE == 64
retval_ui %r1
retval_l %r1
+#endif
arg_f $f
getarg_f %f1 $f
addr_f %f0 %f1 %f2
@@ -240,7 +256,9 @@ label:
unordr_f %r0 %f0 %f1
unordi_f %r0 %f0 0.5
truncr_f_i %r0 %f0
+#if __WORDSIZE == 64
truncr_f_l %r0 %f0
+#endif
extr_f %f0 %r0
extr_d_f %f0 %f1
movr_f %f0 %f1
@@ -334,7 +352,9 @@ unordi:
unordr_d %r0 %f0 %f1
unordi_d %r0 %f0 0.5
truncr_d_i %r0 %f0
+#if __WORDSIZE == 64
truncr_d_l %r0 %f0
+#endif
extr_d %f0 %r0
extr_f_d %f0 %f1
movr_d %f0 %f1
diff --git a/check/fib.tst b/check/fib.tst
index ddca50a..2df7b23 100644
--- a/check/fib.tst
+++ b/check/fib.tst
@@ -8,7 +8,7 @@ format:
nfibs:
prolog
arg $in
- getarg_ui %r2 $in // R2 = n
+ getarg %r2 $in // R2 = n
movi %r1 1
blti_u ref %r2 2
subi %r2 %r2 1
diff --git a/check/lightning.c b/check/lightning.c
index 43d2bb9..88d07fd 100644
--- a/check/lightning.c
+++ b/check/lightning.c
@@ -247,8 +247,10 @@ static void allocai(void);
static void arg(void);
static void getarg_c(void); static void getarg_uc(void);
static void getarg_s(void); static void getarg_us(void);
-static void getarg_i(void); static void getarg_ui(void);
-static void getarg_l(void);
+static void getarg_i(void);
+#if __WORDSIZE == 64
+static void getarg_ui(void); static void getarg_l(void);
+#endif
static void getarg(void);
static void addr(void); static void addi(void);
static void addxr(void); static void addxi(void);
@@ -281,33 +283,43 @@ static void ner(void); static void nei(void);
static void movr(void); static void movi(void);
static void extr_c(void); static void extr_uc(void);
static void extr_s(void); static void extr_us(void);
+#if __WORDSIZE == 64
static void extr_i(void); static void extr_ui(void);
+#endif
static void htonr(void); static void ntohr(void);
static void ldr_c(void); static void ldi_c(void);
static void ldr_uc(void); static void ldi_uc(void);
static void ldr_s(void); static void ldi_s(void);
static void ldr_us(void); static void ldi_us(void);
static void ldr_i(void); static void ldi_i(void);
+#if __WORDSIZE == 64
static void ldr_ui(void); static void ldi_ui(void);
static void ldr_l(void); static void ldi_l(void);
+#endif
static void ldr(void); static void ldi(void);
static void ldxr_c(void); static void ldxi_c(void);
static void ldxr_uc(void); static void ldxi_uc(void);
static void ldxr_s(void); static void ldxi_s(void);
static void ldxr_us(void); static void ldxi_us(void);
static void ldxr_i(void); static void ldxi_i(void);
+#if __WORDSIZE == 64
static void ldxr_ui(void); static void ldxi_ui(void);
static void ldxr_l(void); static void ldxi_l(void);
+#endif
static void ldxr(void); static void ldxi(void);
static void str_c(void); static void sti_c(void);
static void str_s(void); static void sti_s(void);
static void str_i(void); static void sti_i(void);
+#if __WORDSIZE == 64
static void str_l(void); static void sti_l(void);
+#endif
static void str(void); static void sti(void);
static void stxr_c(void); static void stxi_c(void);
static void stxr_s(void); static void stxi_s(void);
static void stxr_i(void); static void stxi_i(void);
+#if __WORDSIZE == 64
static void stxr_l(void); static void stxi_l(void);
+#endif
static void stxr(void); static void stxi(void);
static void bltr(void); static void blti(void);
static void bltr_u(void); static void blti_u(void);
@@ -338,8 +350,10 @@ static void ret(void);
static void retr(void); static void reti(void);
static void retval_c(void); static void retval_uc(void);
static void retval_s(void); static void retval_us(void);
-static void retval_i(void); static void retval_ui(void);
-static void retval_l(void);
+static void retval_i(void);
+#if __WORDSIZE == 64
+static void retval_ui(void); static void retval_l(void);
+#endif
static void retval(void);
static void epilog(void);
static void arg_f(void);
@@ -516,8 +530,10 @@ static instr_t instr_vector[] = {
entry(arg),
entry(getarg_c), entry(getarg_uc),
entry(getarg_s), entry(getarg_us),
- entry(getarg_i), entry(getarg_ui),
- entry(getarg_l),
+ entry(getarg_i),
+#if __WORDSIZE == 64
+ entry(getarg_ui), entry(getarg_l),
+#endif
entry(getarg),
entry(addr), entry(addi),
entry(addxr), entry(addxi),
@@ -550,33 +566,43 @@ static instr_t instr_vector[] = {
entry(movr), entry(movi),
entry(extr_c), entry(extr_uc),
entry(extr_s), entry(extr_us),
+#if __WORDSIZE == 64
entry(extr_i), entry(extr_ui),
+#endif
entry(htonr), entry(ntohr),
entry(ldr_c), entry(ldi_c),
entry(ldr_uc), entry(ldi_uc),
entry(ldr_s), entry(ldi_s),
entry(ldr_us), entry(ldi_us),
entry(ldr_i), entry(ldi_i),
+#if __WORDSIZE == 64
entry(ldr_ui), entry(ldi_ui),
entry(ldr_l), entry(ldi_l),
+#endif
entry(ldr), entry(ldi),
entry(ldxr_c), entry(ldxi_c),
entry(ldxr_uc), entry(ldxi_uc),
entry(ldxr_s), entry(ldxi_s),
entry(ldxr_us), entry(ldxi_us),
entry(ldxr_i), entry(ldxi_i),
+#if __WORDSIZE == 64
entry(ldxr_ui), entry(ldxi_ui),
entry(ldxr_l), entry(ldxi_l),
+#endif
entry(ldxr), entry(ldxi),
entry(str_c), entry(sti_c),
entry(str_s), entry(sti_s),
entry(str_i), entry(sti_i),
+#if __WORDSIZE == 64
entry(str_l), entry(sti_l),
+#endif
entry(str), entry(sti),
entry(stxr_c), entry(stxi_c),
entry(stxr_s), entry(stxi_s),
entry(stxr_i), entry(stxi_i),
+#if __WORDSIZE == 64
entry(stxr_l), entry(stxi_l),
+#endif
entry(stxr), entry(stxi),
entry(bltr), entry(blti),
entry(bltr_u), entry(blti_u),
@@ -607,8 +633,10 @@ static instr_t instr_vector[] = {
entry(retr), entry(reti),
entry(retval_c), entry(retval_uc),
entry(retval_s), entry(retval_us),
- entry(retval_i), entry(retval_ui),
- entry(retval_l),
+ entry(retval_i),
+#if __WORDSIZE == 64
+ entry(retval_ui), entry(retval_l),
+#endif
entry(retval),
entry(epilog),
entry(arg_f),
@@ -1180,8 +1208,10 @@ allocai(void) {
entry_ca(arg)
entry_ia(getarg_c) entry_ia(getarg_uc)
entry_ia(getarg_s) entry_ia(getarg_us)
-entry_ia(getarg_i) entry_ia(getarg_ui)
-entry_ia(getarg_l)
+entry_ia(getarg_i)
+#if __WORDSIZE == 64
+entry_ia(getarg_ui) entry_ia(getarg_l)
+#endif
entry_ia(getarg)
entry_ir_ir_ir(addr) entry_ir_ir_im(addi)
entry_ir_ir_ir(addxr) entry_ir_ir_im(addxi)
@@ -1253,33 +1283,43 @@ movi(void)
}
entry_ir_ir(extr_c) entry_ir_ir(extr_uc)
entry_ir_ir(extr_s) entry_ir_ir(extr_us)
+#if __WORDSIZE == 64
entry_ir_ir(extr_i) entry_ir_ir(extr_ui)
+#endif
entry_ir_ir(htonr) entry_ir_ir(ntohr)
entry_ir_ir(ldr_c) entry_ir_pm(ldi_c)
entry_ir_ir(ldr_uc) entry_ir_pm(ldi_uc)
entry_ir_ir(ldr_s) entry_ir_pm(ldi_s)
entry_ir_ir(ldr_us) entry_ir_pm(ldi_us)
entry_ir_ir(ldr_i) entry_ir_pm(ldi_i)
+#if __WORDSIZE == 64
entry_ir_ir(ldr_ui) entry_ir_pm(ldi_ui)
entry_ir_ir(ldr_l) entry_ir_pm(ldi_l)
+#endif
entry_ir_ir(ldr) entry_ir_pm(ldi)
entry_ir_ir_ir(ldxr_c) entry_ir_ir_im(ldxi_c)
entry_ir_ir_ir(ldxr_uc) entry_ir_ir_im(ldxi_uc)
entry_ir_ir_ir(ldxr_s) entry_ir_ir_im(ldxi_s)
entry_ir_ir_ir(ldxr_us) entry_ir_ir_im(ldxi_us)
entry_ir_ir_ir(ldxr_i) entry_ir_ir_im(ldxi_i)
+#if __WORDSIZE == 64
entry_ir_ir_ir(ldxr_ui) entry_ir_ir_im(ldxi_ui)
entry_ir_ir_ir(ldxr_l) entry_ir_ir_im(ldxi_l)
+#endif
entry_ir_ir_ir(ldxr) entry_ir_ir_im(ldxi)
entry_ir_ir(str_c) entry_pm_ir(sti_c)
entry_ir_ir(str_s) entry_pm_ir(sti_s)
entry_ir_ir(str_i) entry_pm_ir(sti_i)
+#if __WORDSIZE == 64
entry_ir_ir(str_l) entry_pm_ir(sti_l)
+#endif
entry_ir_ir(str) entry_pm_ir(sti)
entry_ir_ir_ir(stxr_c) entry_im_ir_ir(stxi_c)
entry_ir_ir_ir(stxr_s) entry_im_ir_ir(stxi_s)
entry_ir_ir_ir(stxr_i) entry_im_ir_ir(stxi_i)
+#if __WORDSIZE == 64
entry_ir_ir_ir(stxr_l) entry_im_ir_ir(stxi_l)
+#endif
entry_ir_ir_ir(stxr) entry_im_ir_ir(stxi)
entry_lb_ir_ir(bltr) entry_lb_ir_im(blti)
entry_lb_ir_ir(bltr_u) entry_lb_ir_im(blti_u)
@@ -1310,8 +1350,10 @@ entry(ret)
entry_ir(retr) entry_im(reti)
entry_ir(retval_c) entry_ir(retval_uc)
entry_ir(retval_s) entry_ir(retval_us)
-entry_ir(retval_i) entry_ir(retval_ui)
-entry_ir(retval_l)
+entry_ir(retval_i)
+#if __WORDSIZE == 64
+entry_ir(retval_ui) entry_ir(retval_l)
+#endif
entry_ir(retval)
entry(epilog)
entry_ca(arg_f)
diff --git a/include/lightning.h b/include/lightning.h
index 6a0ca56..f4fb5ae 100644
--- a/include/lightning.h
+++ b/include/lightning.h
@@ -122,14 +122,12 @@ typedef enum {
#define jit_getarg_s(u,v) _jit_getarg_s(_jit,u,v)
#define jit_getarg_us(u,v) _jit_getarg_us(_jit,u,v)
#define jit_getarg_i(u,v) _jit_getarg_i(_jit,u,v)
- /* >> 64 bit */
-#define jit_getarg_ui(u,v) _jit_getarg_ui(_jit,u,v)
-#define jit_getarg_l(u,v) _jit_getarg_l(_jit,u,v)
- /* << 64 bit */
#if __WORDSIZE == 32
# define jit_getarg(u,v) jit_getarg_i(u,v)
#else
# define jit_getarg(u,v) jit_getarg_l(u,v)
+# define jit_getarg_ui(u,v) _jit_getarg_ui(_jit,u,v)
+# define jit_getarg_l(u,v) _jit_getarg_l(_jit,u,v)
#endif
#define jit_addr(u,v,w) jit_new_node_www(jit_code_addr,u,v,w)
@@ -231,11 +229,11 @@ typedef enum {
#define jit_extr_s(u,v) jit_new_node_ww(jit_code_extr_s,u,v)
#define jit_extr_us(u,v) jit_new_node_ww(jit_code_extr_us,u,v)
jit_code_extr_s, jit_code_extr_us,
- /* >> 64 bit */
-#define jit_extr_i(u,v) jit_new_node_ww(jit_code_extr_i,u,v)
-#define jit_extr_ui(u,v) jit_new_node_ww(jit_code_extr_ui,u,v)
+#if __WORDSIZE == 64
+# define jit_extr_i(u,v) jit_new_node_ww(jit_code_extr_i,u,v)
+# define jit_extr_ui(u,v) jit_new_node_ww(jit_code_extr_ui,u,v)
+#endif
jit_code_extr_i, jit_code_extr_ui,
- /* << 64 bit */
#define jit_htonr(u,v) jit_new_node_ww(jit_code_htonr,u,v)
#define jit_ntohr(u,v) jit_new_node_ww(jit_code_htonr,u,v)
jit_code_htonr,
@@ -261,15 +259,13 @@ typedef enum {
#else
# define jit_ldr(u,v) jit_ldr_l(u,v)
# define jit_ldi(u,v) jit_ldi_l(u,v)
-#endif
- /* >> 64 bit */
-#define jit_ldr_ui(u,v) jit_new_node_ww(jit_code_ldr_ui,u,v)
-#define jit_ldi_ui(u,v) jit_new_node_ww(jit_code_ldi_ui,u,v)
- jit_code_ldr_ui, jit_code_ldi_ui,
+# define jit_ldr_ui(u,v) jit_new_node_ww(jit_code_ldr_ui,u,v)
+# define jit_ldi_ui(u,v) jit_new_node_ww(jit_code_ldi_ui,u,v)
#define jit_ldr_l(u,v) jit_new_node_ww(jit_code_ldr_l,u,v)
#define jit_ldi_l(u,v) jit_new_node_ww(jit_code_ldi_l,u,v)
+#endif
+ jit_code_ldr_ui, jit_code_ldi_ui,
jit_code_ldr_l, jit_code_ldi_l,
- /* << 64 bit */
#define jit_ldxr_c(u,v,w) jit_new_node_www(jit_code_ldxr_c,u,v,w)
#define jit_ldxi_c(u,v,w) jit_new_node_www(jit_code_ldxi_c,u,v,w)
@@ -313,14 +309,12 @@ typedef enum {
# define jit_str(u,v) jit_str_i(u,v)
# define jit_sti(u,v) jit_sti_i(u,v)
#else
-#define jit_str(u,v) jit_str_l(u,v)
-#define jit_sti(u,v) jit_sti_l(u,v)
+# define jit_str(u,v) jit_str_l(u,v)
+# define jit_sti(u,v) jit_sti_l(u,v)
+# define jit_str_l(u,v) jit_new_node_ww(jit_code_str_l,u,v)
+# define jit_sti_l(u,v) jit_new_node_ww(jit_code_sti_l,u,v)
#endif
- /* >> 64 bit */
-#define jit_str_l(u,v) jit_new_node_ww(jit_code_str_l,u,v)
-#define jit_sti_l(u,v) jit_new_node_ww(jit_code_sti_l,u,v)
jit_code_str_l, jit_code_sti_l,
- /* << 64 bit */
#define jit_stxr_c(u,v,w) jit_new_node_www(jit_code_stxr_c,u,v,w)
#define jit_stxi_c(u,v,w) jit_new_node_www(jit_code_stxi_c,u,v,w)
@@ -335,14 +329,12 @@ typedef enum {
# define jit_stxr(u,v,w) jit_stxr_i(u,v,w)
# define jit_stxi(u,v,w) jit_stxi_i(u,v,w)
#else
+# define jit_stxr(u,v,w) jit_stxr_l(u,v,w)
+# define jit_stxi(u,v,w) jit_stxi_l(u,v,w)
# define jit_stxr_l(u,v,w) jit_new_node_www(jit_code_stxr_l,u,v,w)
# define jit_stxi_l(u,v,w) jit_new_node_www(jit_code_stxi_l,u,v,w)
#endif
- /* >> 64 bit */
-#define jit_stxr(u,v,w) jit_stxr_l(u,v,w)
-#define jit_stxi(u,v,w) jit_stxi_l(u,v,w)
jit_code_stxr_l, jit_code_stxi_l,
- /* << 64 bit */
#define jit_bltr(v,w) jit_new_node_pww(jit_code_bltr,NULL,v,w)
#define jit_blti(v,w) jit_new_node_pww(jit_code_blti,NULL,v,w)
@@ -427,14 +419,12 @@ typedef enum {
#define jit_retval_s(u) _jit_retval_s(_jit,u)
#define jit_retval_us(u) _jit_retval_us(_jit,u)
#define jit_retval_i(u) _jit_retval_i(_jit,u)
- /* >> 64 bit */
-#define jit_retval_ui(u) _jit_retval_ui(_jit,u)
-#define jit_retval_l(u) _jit_retval_l(_jit,u)
- /* << 64 bit */
#if __WORDSIZE == 32
# define jit_retval(u) jit_retval_i(u)
#else
# define jit_retval(u) jit_retval_l(u)
+# define jit_retval_ui(u) _jit_retval_ui(_jit,u)
+# define jit_retval_l(u) _jit_retval_l(_jit,u)
#endif
/* Usually should not need to call directly, but useful if need
* to get a label just before a jit_prolog() call */
@@ -510,11 +500,9 @@ typedef enum {
# define jit_truncr_f(u,v) jit_truncr_f_i(u,v)
#else
# define jit_truncr_f(u,v) jit_truncr_f_l(u,v)
+# define jit_truncr_f_l(u,v) jit_new_node_ww(jit_code_truncr_f_l,u,v)
#endif
- /* >> 64 bit */
-#define jit_truncr_f_l(u,v) jit_new_node_ww(jit_code_truncr_f_l,u,v)
jit_code_truncr_f_l,
- /* << 64 bit */
#define jit_extr_f(u,v) jit_new_node_ww(jit_code_extr_f,u,v)
#define jit_extr_d_f(u,v) jit_new_node_ww(jit_code_extr_d_f,u,v)
jit_code_extr_f, jit_code_extr_d_f,
@@ -655,11 +643,9 @@ typedef enum {
# define jit_truncr_d(u,v) jit_truncr_d_i(u,v)
#else
# define jit_truncr_d(u,v) jit_truncr_d_l(u,v)
+# define jit_truncr_d_l(u,v) jit_new_node_ww(jit_code_truncr_d_l,u,v)
#endif
- /* >> 64 bit */
-#define jit_truncr_d_l(u,v) jit_new_node_ww(jit_code_truncr_d_l,u,v)
jit_code_truncr_d_l,
- /* << 64 bit */
#define jit_extr_d(u,v) jit_new_node_ww(jit_code_extr_f,u,v)
#define jit_extr_f_d(u,v) jit_new_node_ww(jit_code_extr_f_d,u,v)
jit_code_extr_d, jit_code_extr_f_d,
diff --git a/include/lightning/jit_x86.h b/include/lightning/jit_x86.h
index 5091d5b..003a28d 100644
--- a/include/lightning/jit_x86.h
+++ b/include/lightning/jit_x86.h
@@ -37,7 +37,7 @@ typedef enum {
# define jit_r_num() 3
# define jit_v(i) (_RBX + (i))
# define jit_v_num() 3
-# define jit_arg_reg_p(i) 0
+# define jit_arg_f_reg_p(i) 0
# define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
# define jit_f_num() (jit_cpu.sse2 ? 8 : 6)
# define JIT_FRET _ST0
diff --git a/lib/jit_arm-cpu.c b/lib/jit_arm-cpu.c
index 063ce6a..089ad38 100644
--- a/lib/jit_arm-cpu.c
+++ b/lib/jit_arm-cpu.c
@@ -3562,11 +3562,6 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
static void
_prolog(jit_state_t *_jit, jit_node_t *node)
{
- jit_function_t *function;
- jit_pointer_t *functions;
-
- functions = _jit->functions->v.obj;
- function = functions[node->u.w];
if (jit_thumb_p()) {
/* switch to thumb mode (better approach would be to
* ORR 1 address being called, but no clear distinction
@@ -3592,7 +3587,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
PUSH(0x3ff|(1<<_FP_REGNO)|(1<<_LR_REGNO));
}
movr(_FP_REGNO, _SP_REGNO);
- subi(_SP_REGNO, _SP_REGNO, function->stack);
+ subi(_SP_REGNO, _SP_REGNO, _jit->function->stack);
}
static void
diff --git a/lib/jit_arm.c b/lib/jit_arm.c
index 59eadd9..d75136a 100644
--- a/lib/jit_arm.c
+++ b/lib/jit_arm.c
@@ -1340,7 +1340,7 @@ _jit_emit(jit_state_t *_jit)
calli(node->u.w);
break;
case jit_code_prolog:
- _jit->function = _jit->functions.ptr + node->u.w;
+ _jit->function = _jit->functions.ptr + node->w.w;
undo.node = node;
undo.word = _jit->pc.w;
undo.data = _jit->consts.data;
@@ -1353,6 +1353,7 @@ _jit_emit(jit_state_t *_jit)
prolog(node);
break;
case jit_code_epilog:
+ assert(_jit->function == _jit->functions.ptr + node->w.w);
if (_jit->again) {
for (temp = undo.node->next;
temp != node; temp = temp->next) {
diff --git a/lib/jit_disasm.c b/lib/jit_disasm.c
index 8e231ba..625419b 100644
--- a/lib/jit_disasm.c
+++ b/lib/jit_disasm.c
@@ -194,7 +194,7 @@ disasm_print_address(bfd_vma addr, struct disassemble_info
*info)
{
char buffer[address_buffer_length];
- sprintf(buffer, address_buffer_format, (jit_word_t)addr);
+ sprintf(buffer, address_buffer_format, (long long)addr);
(*info->fprintf_func)(info->stream, "0x%s", buffer);
if (disasm_num_symbols) {
@@ -287,7 +287,7 @@ disassemble(jit_pointer_t code, jit_int32_t length)
}
}
#endif
- bytes = sprintf(buffer, address_buffer_format, (jit_word_t)pc);
+ bytes = sprintf(buffer, address_buffer_format, (long long)pc);
(*disasm_info.fprintf_func)(disasm_stream, "%*c0x%s\t",
16 - bytes, ' ', buffer);
pc += (*disasm_print)(pc, &disasm_info);
diff --git a/lib/jit_mips-cpu.c b/lib/jit_mips-cpu.c
index 1a8bb4c..9ab14e7 100644
--- a/lib/jit_mips-cpu.c
+++ b/lib/jit_mips-cpu.c
@@ -2697,80 +2697,74 @@ _calli(jit_state_t *_jit, jit_word_t i0)
static void
_prolog(jit_state_t *_jit, jit_node_t *node)
{
- jit_function_t *function;
- jit_pointer_t *functions;
-
- functions = _jit->functions->v.obj;
- function = functions[node->u.w];
-
/* callee save registers */
subi(_SP_REGNO, _SP_REGNO, stack_framesize);
#if __WORDSIZE == 32
- if (jit_regset_tstbit(function->regset, _F30))
+ if (jit_regset_tstbit(_jit->function->regset, _F30))
stxi_d(96, _SP_REGNO, _F30_REGNO);
- if (jit_regset_tstbit(function->regset, _F28))
+ if (jit_regset_tstbit(_jit->function->regset, _F28))
stxi_d(88, _SP_REGNO, _F28_REGNO);
- if (jit_regset_tstbit(function->regset, _F26))
+ if (jit_regset_tstbit(_jit->function->regset, _F26))
stxi_d(80, _SP_REGNO, _F26_REGNO);
- if (jit_regset_tstbit(function->regset, _F24))
+ if (jit_regset_tstbit(_jit->function->regset, _F24))
stxi_d(72, _SP_REGNO, _F24_REGNO);
- if (jit_regset_tstbit(function->regset, _F22))
+ if (jit_regset_tstbit(_jit->function->regset, _F22))
stxi_d(64, _SP_REGNO, _F22_REGNO);
- if (jit_regset_tstbit(function->regset, _F20))
+ if (jit_regset_tstbit(_jit->function->regset, _F20))
stxi_d(56, _SP_REGNO, _F20_REGNO);
- if (jit_regset_tstbit(function->regset, _F18))
+ if (jit_regset_tstbit(_jit->function->regset, _F18))
stxi_d(48, _SP_REGNO, _F18_REGNO);
- if (jit_regset_tstbit(function->regset, _F16))
+ if (jit_regset_tstbit(_jit->function->regset, _F16))
stxi_d(40, _SP_REGNO, _F16_REGNO);
- if (jit_regset_tstbit(function->regset, _S7))
+ if (jit_regset_tstbit(_jit->function->regset, _S7))
stxi(36, _SP_REGNO, _S7_REGNO);
- if (jit_regset_tstbit(function->regset, _S6))
+ if (jit_regset_tstbit(_jit->function->regset, _S6))
stxi(32, _SP_REGNO, _S6_REGNO);
- if (jit_regset_tstbit(function->regset, _S5))
+ if (jit_regset_tstbit(_jit->function->regset, _S5))
stxi(28, _SP_REGNO, _S5_REGNO);
- if (jit_regset_tstbit(function->regset, _S4))
+ if (jit_regset_tstbit(_jit->function->regset, _S4))
stxi(24, _SP_REGNO, _S4_REGNO);
- if (jit_regset_tstbit(function->regset, _S3))
+ if (jit_regset_tstbit(_jit->function->regset, _S3))
stxi(20, _SP_REGNO, _S3_REGNO);
- if (jit_regset_tstbit(function->regset, _S2))
+ if (jit_regset_tstbit(_jit->function->regset, _S2))
stxi(16, _SP_REGNO, _S2_REGNO);
- if (jit_regset_tstbit(function->regset, _S1))
+ if (jit_regset_tstbit(_jit->function->regset, _S1))
stxi(12, _SP_REGNO, _S1_REGNO);
- if (jit_regset_tstbit(function->regset, _S0))
+ if (jit_regset_tstbit(_jit->function->regset, _S0))
stxi( 8, _SP_REGNO, _S0_REGNO);
stxi( 4, _SP_REGNO, _RA_REGNO);
#else
- if (jit_regset_tstbit(function->regset, _F30))
+ if (jit_regset_tstbit(_jit->function->regset, _F30))
stxi_d(136, _SP_REGNO, _F30_REGNO);
- if (jit_regset_tstbit(function->regset, _F28))
+ if (jit_regset_tstbit(_jit->function->regset, _F28))
stxi_d(128, _SP_REGNO, _F28_REGNO);
- if (jit_regset_tstbit(function->regset, _F26))
+ if (jit_regset_tstbit(_jit->function->regset, _F26))
stxi_d(120, _SP_REGNO, _F26_REGNO);
- if (jit_regset_tstbit(function->regset, _F24))
+ if (jit_regset_tstbit(_jit->function->regset, _F24))
stxi_d(112, _SP_REGNO, _F24_REGNO);
- if (jit_regset_tstbit(function->regset, _F22))
+ if (jit_regset_tstbit(_jit->function->regset, _F22))
stxi_d(104, _SP_REGNO, _F22_REGNO);
- if (jit_regset_tstbit(function->regset, _F20))
+ if (jit_regset_tstbit(_jit->function->regset, _F20))
stxi_d(96, _SP_REGNO, _F20_REGNO);
- if (jit_regset_tstbit(function->regset, _F18))
+ if (jit_regset_tstbit(_jit->function->regset, _F18))
stxi_d(88, _SP_REGNO, _F18_REGNO);
- if (jit_regset_tstbit(function->regset, _F16))
+ if (jit_regset_tstbit(_jit->function->regset, _F16))
stxi_d(80, _SP_REGNO, _F16_REGNO);
- if (jit_regset_tstbit(function->regset, _S7))
+ if (jit_regset_tstbit(_jit->function->regset, _S7))
stxi(72, _SP_REGNO, _S7_REGNO);
- if (jit_regset_tstbit(function->regset, _S6))
+ if (jit_regset_tstbit(_jit->function->regset, _S6))
stxi(64, _SP_REGNO, _S6_REGNO);
- if (jit_regset_tstbit(function->regset, _S5))
+ if (jit_regset_tstbit(_jit->function->regset, _S5))
stxi(56, _SP_REGNO, _S5_REGNO);
- if (jit_regset_tstbit(function->regset, _S4))
+ if (jit_regset_tstbit(_jit->function->regset, _S4))
stxi(48, _SP_REGNO, _S4_REGNO);
- if (jit_regset_tstbit(function->regset, _S3))
+ if (jit_regset_tstbit(_jit->function->regset, _S3))
stxi(40, _SP_REGNO, _S3_REGNO);
- if (jit_regset_tstbit(function->regset, _S2))
+ if (jit_regset_tstbit(_jit->function->regset, _S2))
stxi(32, _SP_REGNO, _S2_REGNO);
- if (jit_regset_tstbit(function->regset, _S1))
+ if (jit_regset_tstbit(_jit->function->regset, _S1))
stxi(24, _SP_REGNO, _S1_REGNO);
- if (jit_regset_tstbit(function->regset, _S0))
+ if (jit_regset_tstbit(_jit->function->regset, _S0))
stxi(16, _SP_REGNO, _S0_REGNO);
stxi( 8, _SP_REGNO, _RA_REGNO);
#endif
@@ -2778,86 +2772,80 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
movr(_BP_REGNO, _SP_REGNO);
/* alloca */
- subi(_SP_REGNO, _SP_REGNO, function->stack);
+ subi(_SP_REGNO, _SP_REGNO, _jit->function->stack);
}
static void
_epilog(jit_state_t *_jit, jit_node_t *node)
{
- jit_function_t *function;
- jit_pointer_t *functions;
-
- functions = _jit->functions->v.obj;
- function = functions[node->w.w];
-
/* callee save registers */
movr(_SP_REGNO, _BP_REGNO);
#if __WORDSIZE == 32
- if (jit_regset_tstbit(function->regset, _F30))
+ if (jit_regset_tstbit(_jit->function->regset, _F30))
ldxi_d(_F30_REGNO, _SP_REGNO, 96);
- if (jit_regset_tstbit(function->regset, _F28))
+ if (jit_regset_tstbit(_jit->function->regset, _F28))
ldxi_d(_F28_REGNO, _SP_REGNO, 88);
- if (jit_regset_tstbit(function->regset, _F26))
+ if (jit_regset_tstbit(_jit->function->regset, _F26))
ldxi_d(_F26_REGNO, _SP_REGNO, 80);
- if (jit_regset_tstbit(function->regset, _F24))
+ if (jit_regset_tstbit(_jit->function->regset, _F24))
ldxi_d(_F24_REGNO, _SP_REGNO, 72);
- if (jit_regset_tstbit(function->regset, _F22))
+ if (jit_regset_tstbit(_jit->function->regset, _F22))
ldxi_d(_F22_REGNO, _SP_REGNO, 64);
- if (jit_regset_tstbit(function->regset, _F20))
+ if (jit_regset_tstbit(_jit->function->regset, _F20))
ldxi_d(_F20_REGNO, _SP_REGNO, 56);
- if (jit_regset_tstbit(function->regset, _F18))
+ if (jit_regset_tstbit(_jit->function->regset, _F18))
ldxi_d(_F18_REGNO, _SP_REGNO, 48);
- if (jit_regset_tstbit(function->regset, _F16))
+ if (jit_regset_tstbit(_jit->function->regset, _F16))
ldxi_d(_F16_REGNO, _SP_REGNO, 40);
- if (jit_regset_tstbit(function->regset, _S7))
+ if (jit_regset_tstbit(_jit->function->regset, _S7))
ldxi(_S7_REGNO, _SP_REGNO, 36);
- if (jit_regset_tstbit(function->regset, _S6))
+ if (jit_regset_tstbit(_jit->function->regset, _S6))
ldxi(_S6_REGNO, _SP_REGNO, 32);
- if (jit_regset_tstbit(function->regset, _S5))
+ if (jit_regset_tstbit(_jit->function->regset, _S5))
ldxi(_S5_REGNO, _SP_REGNO, 28);
- if (jit_regset_tstbit(function->regset, _S4))
+ if (jit_regset_tstbit(_jit->function->regset, _S4))
ldxi(_S4_REGNO, _SP_REGNO, 24);
- if (jit_regset_tstbit(function->regset, _S3))
+ if (jit_regset_tstbit(_jit->function->regset, _S3))
ldxi(_S3_REGNO, _SP_REGNO, 20);
- if (jit_regset_tstbit(function->regset, _S2))
+ if (jit_regset_tstbit(_jit->function->regset, _S2))
ldxi(_S2_REGNO, _SP_REGNO, 16);
- if (jit_regset_tstbit(function->regset, _S1))
+ if (jit_regset_tstbit(_jit->function->regset, _S1))
ldxi(_S1_REGNO, _SP_REGNO, 12);
- if (jit_regset_tstbit(function->regset, _S0))
+ if (jit_regset_tstbit(_jit->function->regset, _S0))
ldxi(_S0_REGNO, _SP_REGNO, 8);
ldxi(_RA_REGNO, _SP_REGNO, 4);
#else
- if (jit_regset_tstbit(function->regset, _F30))
+ if (jit_regset_tstbit(_jit->function->regset, _F30))
ldxi_d(_F30_REGNO, _SP_REGNO, 136);
- if (jit_regset_tstbit(function->regset, _F28))
+ if (jit_regset_tstbit(_jit->function->regset, _F28))
ldxi_d(_F28_REGNO, _SP_REGNO, 128);
- if (jit_regset_tstbit(function->regset, _F26))
+ if (jit_regset_tstbit(_jit->function->regset, _F26))
ldxi_d(_F26_REGNO, _SP_REGNO, 120);
- if (jit_regset_tstbit(function->regset, _F24))
+ if (jit_regset_tstbit(_jit->function->regset, _F24))
ldxi_d(_F24_REGNO, _SP_REGNO, 112);
- if (jit_regset_tstbit(function->regset, _F22))
+ if (jit_regset_tstbit(_jit->function->regset, _F22))
ldxi_d(_F22_REGNO, _SP_REGNO, 104);
- if (jit_regset_tstbit(function->regset, _F20))
+ if (jit_regset_tstbit(_jit->function->regset, _F20))
ldxi_d(_F20_REGNO, _SP_REGNO, 96);
- if (jit_regset_tstbit(function->regset, _F18))
+ if (jit_regset_tstbit(_jit->function->regset, _F18))
ldxi_d(_F18_REGNO, _SP_REGNO, 88);
- if (jit_regset_tstbit(function->regset, _F16))
+ if (jit_regset_tstbit(_jit->function->regset, _F16))
ldxi_d(_F16_REGNO, _SP_REGNO, 80);
- if (jit_regset_tstbit(function->regset, _S7))
+ if (jit_regset_tstbit(_jit->function->regset, _S7))
ldxi(_S7_REGNO, _SP_REGNO, 72);
- if (jit_regset_tstbit(function->regset, _S6))
+ if (jit_regset_tstbit(_jit->function->regset, _S6))
ldxi(_S6_REGNO, _SP_REGNO, 64);
- if (jit_regset_tstbit(function->regset, _S5))
+ if (jit_regset_tstbit(_jit->function->regset, _S5))
ldxi(_S5_REGNO, _SP_REGNO, 56);
- if (jit_regset_tstbit(function->regset, _S4))
+ if (jit_regset_tstbit(_jit->function->regset, _S4))
ldxi(_S4_REGNO, _SP_REGNO, 48);
- if (jit_regset_tstbit(function->regset, _S3))
+ if (jit_regset_tstbit(_jit->function->regset, _S3))
ldxi(_S3_REGNO, _SP_REGNO, 40);
- if (jit_regset_tstbit(function->regset, _S2))
+ if (jit_regset_tstbit(_jit->function->regset, _S2))
ldxi(_S2_REGNO, _SP_REGNO, 32);
- if (jit_regset_tstbit(function->regset, _S1))
+ if (jit_regset_tstbit(_jit->function->regset, _S1))
ldxi(_S1_REGNO, _SP_REGNO, 24);
- if (jit_regset_tstbit(function->regset, _S0))
+ if (jit_regset_tstbit(_jit->function->regset, _S0))
ldxi(_S0_REGNO, _SP_REGNO, 16);
ldxi(_RA_REGNO, _SP_REGNO, 8);
#endif
diff --git a/lib/jit_mips.c b/lib/jit_mips.c
index ec1cb58..ffeb291 100644
--- a/lib/jit_mips.c
+++ b/lib/jit_mips.c
@@ -1092,7 +1092,7 @@ _jit_emit(jit_state_t *_jit)
calli(node->u.w);
break;
case jit_code_prolog:
- _jit->function = _jit->functions.ptr[node->u.w];
+ _jit->function = _jit->functions.ptr + node->w.w;
undo.node = node;
undo.word = _jit->pc.w;
undo.patch_offset = _jit->patches.offset;
@@ -1101,6 +1101,7 @@ _jit_emit(jit_state_t *_jit)
prolog(node);
break;
case jit_code_epilog:
+ assert(_jit->function == _jit->functions.ptr + node->w.w);
if (_jit->again) {
for (temp = undo.node->next;
temp != node; temp = temp->next) {
diff --git a/lib/jit_ppc-cpu.c b/lib/jit_ppc-cpu.c
index 3e746bf..4cfa561 100644
--- a/lib/jit_ppc-cpu.c
+++ b/lib/jit_ppc-cpu.c
@@ -2210,11 +2210,7 @@ static void
_prolog(jit_state_t *_jit, jit_node_t *node)
{
unsigned long regno;
- jit_function_t *function;
- jit_pointer_t *functions;
- functions = _jit->functions->v.obj;
- function = functions[node->u.w];
subi(_SP_REGNO, _SP_REGNO, stack_framesize);
/* return address */
MFLR(_R0_REGNO);
@@ -2223,34 +2219,30 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
/* save any clobbered callee save fpr register */
/* FIXME actually, no "clean" interface to use these registers */
for (regno = _F31; regno >= _F14; regno--) {
- if (jit_regset_tstbit(function->regset, regno))
+ if (jit_regset_tstbit(_jit->function->regset, regno))
stxi_d(stack_framesize - rn(regno) * 8, _SP_REGNO, regno);
}
/* save any clobbered callee save gpr register */
- regno = jit_regset_scan1(function->regset, _R14);
+ regno = jit_regset_scan1(_jit->function->regset, _R14);
if (regno == ULONG_MAX || regno > _R31)
regno = _R31; /* aka _FP_REGNO */
STMW(regno, _SP_REGNO, rn(regno) * 4 + 8);
movr(_FP_REGNO, _SP_REGNO);
/* alloca and/or space for excess parameters */
- subi(_SP_REGNO, _SP_REGNO, function->stack);
+ subi(_SP_REGNO, _SP_REGNO, _jit->function->stack);
}
static void
_epilog(jit_state_t *_jit, jit_node_t *node)
{
unsigned long regno;
- jit_function_t *function;
- jit_pointer_t *functions;
- functions = _jit->functions->v.obj;
- function = functions[node->w.w];
movr(_SP_REGNO, _FP_REGNO);
for (regno = _F31; regno >= _F14; regno--) {
- if (jit_regset_tstbit(function->regset, regno))
+ if (jit_regset_tstbit(_jit->function->regset, regno))
ldxi_d(regno, _SP_REGNO, stack_framesize - rn(regno) * 8);
}
- regno = jit_regset_scan1(function->regset, _R14);
+ regno = jit_regset_scan1(_jit->function->regset, _R14);
if (regno == ULONG_MAX || regno > _R31)
regno = _R31; /* aka _FP_REGNO */
LMW(rn(regno), _SP_REGNO, regno * 4 + 8);
diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c
index 4a2e269..17af6a6 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_ppc.c
@@ -1011,7 +1011,7 @@ _jit_emit(jit_state_t *_jit)
calli(node->u.w);
break;
case jit_code_prolog:
- _jit->function = _jit->functions.ptr + node->u.w;
+ _jit->function = _jit->functions.ptr + node->w.w;
undo.node = node;
undo.word = _jit->pc.w;
undo.patch_offset = _jit->patches.offset;
@@ -1020,6 +1020,7 @@ _jit_emit(jit_state_t *_jit)
prolog(node);
break;
case jit_code_epilog:
+ assert(_jit->function == _jit->functions.ptr + node->w.w);
if (_jit->again) {
for (temp = undo.node->next;
temp != node; temp = temp->next) {
diff --git a/lib/jit_x86-cpu.c b/lib/jit_x86-cpu.c
index 9be3721..44e1706 100644
--- a/lib/jit_x86-cpu.c
+++ b/lib/jit_x86-cpu.c
@@ -26,9 +26,9 @@
# define ldxi(u, v, w) ldxi_i(u, v, w)
# define sti(u, v) sti_i(u, v)
# define stxi(u, v, w) stxi_i(u, v, w)
-# define can_sign_extend_int_p(im) true
-# define can_zero_extend_int_p(im) true
-# define fits_uint32_p(im) true
+# define can_sign_extend_int_p(im) 1
+# define can_zero_extend_int_p(im) 1
+# define fits_uint32_p(im) 1
# define reg8_p(rn) \
((rn) >= _RAX_REGNO && (rn) <= _RBX_REGNO)
# else
@@ -3033,64 +3033,56 @@ _jmpi(jit_state_t *_jit, jit_word_t i0)
static void
_prolog(jit_state_t *_jit, jit_node_t *node)
{
- jit_function_t *function;
-
- function = _jit->functions.ptr + node->u.w;
-
/* callee save registers */
subi(_RSP_REGNO, _RSP_REGNO, stack_framesize - sizeof(jit_word_t));
#if __WORDSIZE == 32
- if (jit_regset_tstbit(function->regset, _RDI))
+ if (jit_regset_tstbit(_jit->function->regset, _RDI))
stxi(12, _RSP_REGNO, _RDI_REGNO);
- if (jit_regset_tstbit(function->regset, _RSI))
+ if (jit_regset_tstbit(_jit->function->regset, _RSI))
stxi( 8, _RSP_REGNO, _RSI_REGNO);
- if (jit_regset_tstbit(function->regset, _RBX))
+ if (jit_regset_tstbit(_jit->function->regset, _RBX))
stxi( 4, _RSP_REGNO, _RBX_REGNO);
#else
- if (jit_regset_tstbit(function->regset, _RBX))
+ if (jit_regset_tstbit(_jit->function->regset, _RBX))
stxi(40, _RSP_REGNO, _RBX_REGNO);
- if (jit_regset_tstbit(function->regset, _R12))
+ if (jit_regset_tstbit(_jit->function->regset, _R12))
stxi(32, _RSP_REGNO, _R12_REGNO);
- if (jit_regset_tstbit(function->regset, _R13))
+ if (jit_regset_tstbit(_jit->function->regset, _R13))
stxi(24, _RSP_REGNO, _R13_REGNO);
- if (jit_regset_tstbit(function->regset, _R14))
+ if (jit_regset_tstbit(_jit->function->regset, _R14))
stxi(16, _RSP_REGNO, _R14_REGNO);
- if (jit_regset_tstbit(function->regset, _R15))
+ if (jit_regset_tstbit(_jit->function->regset, _R15))
stxi( 8, _RSP_REGNO, _R15_REGNO);
#endif
stxi(0, _RSP_REGNO, _RBP_REGNO);
movr(_RBP_REGNO, _RSP_REGNO);
/* alloca */
- subi(_RSP_REGNO, _RSP_REGNO, function->stack);
+ subi(_RSP_REGNO, _RSP_REGNO, _jit->function->stack);
}
static void
_epilog(jit_state_t *_jit, jit_node_t *node)
{
- jit_function_t *function;
-
- function = _jit->functions.ptr + node->w.w;
-
/* callee save registers */
movr(_RSP_REGNO, _RBP_REGNO);
#if __WORDSIZE == 32
- if (jit_regset_tstbit(function->regset, _RDI))
+ if (jit_regset_tstbit(_jit->function->regset, _RDI))
ldxi(_RDI_REGNO, _RSP_REGNO, 12);
- if (jit_regset_tstbit(function->regset, _RSI))
+ if (jit_regset_tstbit(_jit->function->regset, _RSI))
ldxi(_RSI_REGNO, _RSP_REGNO, 8);
- if (jit_regset_tstbit(function->regset, _RBX))
+ if (jit_regset_tstbit(_jit->function->regset, _RBX))
ldxi(_RBX_REGNO, _RSP_REGNO, 4);
#else
- if (jit_regset_tstbit(function->regset, _RBX))
+ if (jit_regset_tstbit(_jit->function->regset, _RBX))
ldxi(_RBX_REGNO, _RSP_REGNO, 40);
- if (jit_regset_tstbit(function->regset, _R12))
+ if (jit_regset_tstbit(_jit->function->regset, _R12))
ldxi(_R12_REGNO, _RSP_REGNO, 32);
- if (jit_regset_tstbit(function->regset, _R13))
+ if (jit_regset_tstbit(_jit->function->regset, _R13))
ldxi(_R13_REGNO, _RSP_REGNO, 24);
- if (jit_regset_tstbit(function->regset, _R14))
+ if (jit_regset_tstbit(_jit->function->regset, _R14))
ldxi(_R14_REGNO, _RSP_REGNO, 16);
- if (jit_regset_tstbit(function->regset, _R15))
+ if (jit_regset_tstbit(_jit->function->regset, _R15))
ldxi(_R15_REGNO, _RSP_REGNO, 8);
#endif
ldxi(_RBP_REGNO, _RSP_REGNO, 0);
diff --git a/lib/jit_x86.c b/lib/jit_x86.c
index 939e0c9..416e72a 100644
--- a/lib/jit_x86.c
+++ b/lib/jit_x86.c
@@ -418,7 +418,7 @@ _jit_arg(jit_state_t *_jit)
return (_jit->function->self.argi++);
#endif
offset = _jit->function->self.size;
- _jit->function->self.size += stack_alignment;
+ _jit->function->self.size += sizeof(jit_word_t);
return (offset);
}
@@ -443,7 +443,7 @@ _jit_arg_f(jit_state_t *_jit)
return (_jit->function->self.argf++);
#endif
offset = _jit->function->self.size;
- _jit->function->self.size += stack_alignment;
+ _jit->function->self.size += sizeof(jit_float32_t);
return (offset);
}
@@ -467,7 +467,7 @@ _jit_arg_d(jit_state_t *_jit)
assert(_jit->function);
offset = _jit->function->self.size;
- _jit->function->self.size += 8;
+ _jit->function->self.size += sizeof(jit_float64_t);
return (offset);
#endif
}
@@ -1527,7 +1527,7 @@ _jit_emit(jit_state_t *_jit)
calli(node->u.w);
break;
case jit_code_prolog:
- _jit->function = _jit->functions.ptr + node->u.w;
+ _jit->function = _jit->functions.ptr + node->w.w;
undo.node = node;
undo.word = _jit->pc.w;
undo.patch_offset = _jit->patches.offset;
@@ -1536,6 +1536,7 @@ _jit_emit(jit_state_t *_jit)
prolog(node);
break;
case jit_code_epilog:
+ assert(_jit->function == _jit->functions.ptr + node->w.w);
if (_jit->again) {
for (temp = undo.node->next;
temp != node; temp = temp->next) {
diff --git a/lib/lightning.c b/lib/lightning.c
index 75afeba..3595611 100644
--- a/lib/lightning.c
+++ b/lib/lightning.c
@@ -978,7 +978,6 @@ _jit_optimize(jit_state_t *_jit)
thread_jumps();
sequential_labels();
- simplify();
/* create initial mapping of live register values
* at the start of a basic block */
@@ -1003,6 +1002,7 @@ _jit_optimize(jit_state_t *_jit)
}
patch_registers();
+ simplify();
/* figure out labels that are only reached with a jump
* and is required to do a simple redundant_store removal
- [Guile-commits] 76/437: fix several load/store patterns for x86-64., (continued)
- [Guile-commits] 76/437: fix several load/store patterns for x86-64., Andy Wingo, 2018/07/02
- [Guile-commits] 81/437: fix stack alignment for Apple 32-bit ABI, Andy Wingo, 2018/07/02
- [Guile-commits] 98/437: always set and replace lightning_frag, Andy Wingo, 2018/07/02
- [Guile-commits] 166/437: Correct extra regressions found by the call.tst test case., Andy Wingo, 2018/07/02
- [Guile-commits] 165/437: Add simple test case to test argument and return values., Andy Wingo, 2018/07/02
- [Guile-commits] 158/437: Add new test case to check stack integrity on complex stack frames., Andy Wingo, 2018/07/02
- [Guile-commits] 150/437: Add jit_ellipis and remove jit_prepare argument., Andy Wingo, 2018/07/02
- [Guile-commits] 108/437: fix x86_64 jit_bner_{f,d}, Andy Wingo, 2018/07/02
- [Guile-commits] 122/437: Correct ALU add and sub operations with 64 bit immediate operands., Andy Wingo, 2018/07/02
- [Guile-commits] 119/437: Correct branches and several ALU operations with 64 immediates, Andy Wingo, 2018/07/02
- [Guile-commits] 135/437: Correct implementation problems on ix86.,
Andy Wingo <=
- [Guile-commits] 169/437: Correct wrong and confusing reverse float comparison logic, Andy Wingo, 2018/07/02
- [Guile-commits] 139/437: Implement sqrt codes in mips., Andy Wingo, 2018/07/02
- [Guile-commits] 134/437: Correct make distcheck., Andy Wingo, 2018/07/02
- [Guile-commits] 156/437: Simplify listing of test cases with alternate jit generation options, Andy Wingo, 2018/07/02
- [Guile-commits] 157/437: Add two extra test cases for float operations., Andy Wingo, 2018/07/02
- [Guile-commits] 161/437: Add new register clobber detection test case., Andy Wingo, 2018/07/02
- [Guile-commits] 164/437: Add new carry test case., Andy Wingo, 2018/07/02
- [Guile-commits] 138/437: Correct mips backend implementation to pass initial tests., Andy Wingo, 2018/07/02
- [Guile-commits] 163/437: Add missing jit_htonr to ppc backend., Andy Wingo, 2018/07/02
- [Guile-commits] 177/437: Correct reference to dangling pointer and better note bounds checking, Andy Wingo, 2018/07/02