mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-21 03:00:19 +02:00
Code Activity

Correct implementation problems on ix86.

Browse source 
* 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.
This commit is contained in:
pcpa 2012-12-03 09:40:08 -02:00
parent e6f1df7124
commit 712877a5a4
16 changed files with 229 additions and 182 deletions
Download patch file Download diff file Expand all files Collapse all files

28
ChangeLog
View file

@ -1,3 +1,31 @@
2012-12-03 Paulo Andrade <pcpa@gnu.org>
* 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 <pcpa@gnu.org>
* configure.ac, check/Makefile.am, check/check.sh,

20
check/all.tst
View file

@ -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

2
check/fib.tst
View file

@ -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

66
check/lightning.c
View file

@ -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)

40
include/lightning.h
View file

@ -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 */
#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_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)
@ -315,12 +311,10 @@ typedef enum {
#else
# define jit_str(u,v) jit_str_l(u,v)
# define jit_sti(u,v) jit_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)
#endif
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)
#endif
/* >> 64 bit */
# define jit_truncr_f_l(u,v) jit_new_node_ww(jit_code_truncr_f_l,u,v)
#endif
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)
#endif
/* >> 64 bit */
# define jit_truncr_d_l(u,v) jit_new_node_ww(jit_code_truncr_d_l,u,v)
#endif
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,

2
include/lightning/jit_x86.h
View file

@ -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

7
lib/jit_arm-cpu.c
View file

@ -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

3
lib/jit_arm.c
View file

@ -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) {

4
lib/jit_disasm.c
View file

@ -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);

142
lib/jit_mips-cpu.c
View file

@ -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

3
lib/jit_mips.c
View file

@ -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) {

18
lib/jit_ppc-cpu.c
View file

@ -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);

3
lib/jit_ppc.c
View file

@ -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) {

48
lib/jit_x86-cpu.c
View file

@ -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);

9
lib/jit_x86.c
View file

@ -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) {

2
lib/lightning.c
View file

@ -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