diff --git a/ChangeLog b/ChangeLog index 5985a8bbd..760d29ee4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,31 @@ +2012-12-03 Paulo Andrade + + * 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 * configure.ac, check/Makefile.am, check/check.sh, diff --git a/check/all.tst b/check/all.tst index 9a2ec4437..055da44b9 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 ddca50a1f..2df7b23a5 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 43d2bb90c..88d07fd5c 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 6a0ca56c5..f4fb5aeaf 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 5091d5bf2..003a28dc0 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 063ce6ab3..089ad388a 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 59eadd949..d75136a8c 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 8e231ba12..625419bae 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 1a8bb4ccc..9ab14e7fe 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 ec1cb58ef..ffeb2919d 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 3e746bf6e..4cfa5614d 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 4a2e26920..17af6a66f 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 9be3721f1..44e1706cd 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 939e0c97e..416e72ae7 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 75afeba0b..3595611c7 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