mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-02 21:10:27 +02:00
Code Activity

Implement jit_putarg*

Browse source 
* include/lightning.h, lib/jit_aarch64.c,
	lib/jit_alpha.c, lib/jit_arm.c, lib/jit_hppa.c,
	lib/jit_ia64.c, lib/jit_mips.c,	lib/jit_ppc.c,
	lib/jit_s390.c, lib/jit_sparc.c, lib/jit_x86.c:
	Implement jit_putarg*. It works as a mix of jit_getarg*
	and jit_pusharg*, in the way that the first argument is
	a register or immediate, and the second is a pointer
	returned by jit_arg*. The use of the interface is to change
	values of arguments to the current jit function.

	* check/put.ok, check/put.tst: New test cases exercising
	the new jit_putarg* interface.

	* check/Makefile.am, check/lightning.c: Update for the
	new test case and interface.
This commit is contained in:
Paulo Andrade 2015-01-15 14:20:07 -02:00
parent 192f89c0ee
commit 27d9b68a3f
16 changed files with 1535 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

18
ChangeLog
View file

@ -1,3 +1,21 @@
2015-01-15 Paulo Andrade <pcpa@gnu.org>
* include/lightning.h, lib/jit_aarch64.c,
lib/jit_alpha.c, lib/jit_arm.c, lib/jit_hppa.c,
lib/jit_ia64.c, lib/jit_mips.c, lib/jit_ppc.c,
lib/jit_s390.c, lib/jit_sparc.c, lib/jit_x86.c:
Implement jit_putarg*. It works as a mix of jit_getarg*
and jit_pusharg*, in the way that the first argument is
a register or immediate, and the second is a pointer
returned by jit_arg*. The use of the interface is to change
values of arguments to the current jit function.
* check/put.ok, check/put.tst: New test cases exercising
the new jit_putarg* interface.
* check/Makefile.am, check/lightning.c: Update for the
new test case and interface.
2015-01-08 Paulo Andrade <pcpa@gnu.org> 2015-01-08 Paulo Andrade <pcpa@gnu.org>
* include/lightning/jit_s390.h, lib/jit_s390-cpu.c, * include/lightning/jit_s390.h, lib/jit_s390-cpu.c,

20
check/Makefile.am
View file

@ -84,6 +84,7 @@ EXTRA_DIST = \
call.tst call.ok \ call.tst call.ok \
float.tst float.ok \ float.tst float.ok \
jmpr.tst jmpr.ok \ jmpr.tst jmpr.ok \
put.tst put.ok \
qalu.inc \ qalu.inc \
qalu_mul.tst qalu_mul.ok \ qalu_mul.tst qalu_mul.ok \
qalu_div.tst qalu_div.ok \ qalu_div.tst qalu_div.ok \
@ -115,7 +116,7 @@ base_TESTS = \
fop_abs fop_sqrt \ fop_abs fop_sqrt \
varargs stack \ varargs stack \
clobber carry call \ clobber carry call \
float jmpr \ float jmpr put \
qalu_mul qalu_div \ qalu_mul qalu_div \
range ret tramp range ret tramp
@ -142,7 +143,7 @@ x87_TESTS = \
fop_abs.x87 fop_sqrt.x87 \ fop_abs.x87 fop_sqrt.x87 \
varargs.x87 stack.x87 \ varargs.x87 stack.x87 \
clobber.x87 carry.x87 call.x87 \ clobber.x87 carry.x87 call.x87 \
float.x87 jmpr.x87 float.x87 jmpr.x87 put.x87
$(x87_TESTS): check.x87.sh $(x87_TESTS): check.x87.sh
$(LN_S) $(srcdir)/check.x87.sh $@ $(LN_S) $(srcdir)/check.x87.sh $@
TESTS += $(x87_TESTS) TESTS += $(x87_TESTS)
@ -164,7 +165,7 @@ x87_nodata_TESTS = \
fop_abs.x87.nodata fop_sqrt.x87.nodata \ fop_abs.x87.nodata fop_sqrt.x87.nodata \
varargs.x87.nodata stack.x87.nodata \ varargs.x87.nodata stack.x87.nodata \
clobber.x87.nodata carry.x87.nodata call.x87.nodata \ clobber.x87.nodata carry.x87.nodata call.x87.nodata \
float.x87.nodata jmpr.x87.nodata float.x87.nodata jmpr.x87.nodata put.nodata
$(x87_nodata_TESTS): check.x87.nodata.sh $(x87_nodata_TESTS): check.x87.nodata.sh
$(LN_S) $(srcdir)/check.x87.nodata.sh $@ $(LN_S) $(srcdir)/check.x87.nodata.sh $@
TESTS += $(x87_nodata_TESTS) TESTS += $(x87_nodata_TESTS)
@ -188,7 +189,8 @@ arm_TESTS = \
fop_abs.arm fop_sqrt.arm \ fop_abs.arm fop_sqrt.arm \
varargs.arm stack.arm \ varargs.arm stack.arm \
clobber.arm carry.arm call.arm \ clobber.arm carry.arm call.arm \
float.arm jmpr.arm tramp.arm range.arm float.arm jmpr.arm tramp.arm range.arm \
put.arm
$(arm_TESTS): check.arm.sh $(arm_TESTS): check.arm.sh
$(LN_S) $(srcdir)/check.arm.sh $@ $(LN_S) $(srcdir)/check.arm.sh $@
TESTS += $(arm_TESTS) TESTS += $(arm_TESTS)
@ -212,7 +214,8 @@ swf_TESTS = \
fop_abs.swf fop_sqrt.swf \ fop_abs.swf fop_sqrt.swf \
varargs.swf stack.swf \ varargs.swf stack.swf \
clobber.swf carry.swf call.swf \ clobber.swf carry.swf call.swf \
float.swf jmpr.swf tramp.swf range.swf float.swf jmpr.swf tramp.swf range.swf \
put.swf
$(swf_TESTS): check.swf.sh $(swf_TESTS): check.swf.sh
$(LN_S) $(srcdir)/check.swf.sh $@ $(LN_S) $(srcdir)/check.swf.sh $@
TESTS += $(swf_TESTS) TESTS += $(swf_TESTS)
@ -234,7 +237,8 @@ arm_swf_TESTS = \
fop_abs.arm.swf fop_sqrt.arm.swf \ fop_abs.arm.swf fop_sqrt.arm.swf \
varargs.arm.swf stack.arm.swf \ varargs.arm.swf stack.arm.swf \
clobber.arm.swf carry.arm.swf call.arm.swf \ clobber.arm.swf carry.arm.swf call.arm.swf \
float.arm.swf jmpr.arm.swf tramp.arm.swf range.arm.swf float.arm.swf jmpr.arm.swf tramp.arm.swf range.arm.swf \
put.arm.swf
$(arm_swf_TESTS): check.arm.swf.sh $(arm_swf_TESTS): check.arm.swf.sh
$(LN_S) $(srcdir)/check.arm.swf.sh $@ $(LN_S) $(srcdir)/check.arm.swf.sh $@
TESTS += $(arm_swf_TESTS) TESTS += $(arm_swf_TESTS)
@ -258,7 +262,7 @@ arm4_swf_TESTS = \
varargs.arm4.swf stack.arm4.swf \ varargs.arm4.swf stack.arm4.swf \
clobber.arm4.swf carry.arm4.swf call.arm4.swf \ clobber.arm4.swf carry.arm4.swf call.arm4.swf \
float.arm4.swf jmpr.arm4.swf tramp.arm4.swf \ float.arm4.swf jmpr.arm4.swf tramp.arm4.swf \
range.arm4.swf range.arm4.swf put.arm4.swf
$(arm4_swf_TESTS): check.arm4.swf.sh $(arm4_swf_TESTS): check.arm4.swf.sh
$(LN_S) $(srcdir)/check.arm4.swf.sh $@ $(LN_S) $(srcdir)/check.arm4.swf.sh $@
TESTS += $(arm4_swf_TESTS) TESTS += $(arm4_swf_TESTS)
@ -284,7 +288,7 @@ nodata_TESTS = \
varargs.nodata stack.nodata \ varargs.nodata stack.nodata \
clobber.nodata carry.nodata call.nodata \ clobber.nodata carry.nodata call.nodata \
float.nodata jmpr.nodata tramp.nodata \ float.nodata jmpr.nodata tramp.nodata \
range.nodata range.nodata put.nodata
$(nodata_TESTS): check.nodata.sh $(nodata_TESTS): check.nodata.sh
$(LN_S) $(srcdir)/check.nodata.sh $@ $(LN_S) $(srcdir)/check.nodata.sh $@
TESTS += $(nodata_TESTS) TESTS += $(nodata_TESTS)

45
check/lightning.c
View file

@ -280,6 +280,7 @@ static void getarg_i(void);
static void getarg_ui(void); static void getarg_l(void); static void getarg_ui(void); static void getarg_l(void);
#endif #endif
static void getarg(void); static void getarg(void);
static void putargr(void); static void putargi(void);
static void addr(void); static void addi(void); static void addr(void); static void addi(void);
static void addxr(void); static void addxi(void); static void addxr(void); static void addxi(void);
static void addcr(void); static void addci(void); static void addcr(void); static void addci(void);
@ -394,8 +395,8 @@ static void retval_ui(void); static void retval_l(void);
#endif #endif
static void retval(void); static void retval(void);
static void epilog(void); static void epilog(void);
static void arg_f(void); static void arg_f(void); static void getarg_f(void);
static void getarg_f(void); static void putargr_f(void); static void putargi_f(void);
static void addr_f(void); static void addi_f(void); static void addr_f(void); static void addi_f(void);
static void subr_f(void); static void subi_f(void); static void subr_f(void); static void subi_f(void);
static void rsbr_f(void); static void rsbi_f(void); static void rsbr_f(void); static void rsbi_f(void);
@ -445,8 +446,8 @@ static void bunordr_f(void); static void bunordi_f(void);
static void pushargr_f(void); static void pushargi_f(void); static void pushargr_f(void); static void pushargi_f(void);
static void retr_f(void); static void reti_f(void); static void retr_f(void); static void reti_f(void);
static void retval_f(void); static void retval_f(void);
static void arg_d(void); static void arg_d(void); static void getarg_d(void);
static void getarg_d(void); static void putargr_d(void); static void putargi_d(void);
static void addr_d(void); static void addi_d(void); static void addr_d(void); static void addi_d(void);
static void subr_d(void); static void subi_d(void); static void subr_d(void); static void subi_d(void);
static void rsbr_d(void); static void rsbi_d(void); static void rsbr_d(void); static void rsbi_d(void);
@ -588,6 +589,7 @@ static instr_t instr_vector[] = {
entry(getarg_ui), entry(getarg_l), entry(getarg_ui), entry(getarg_l),
#endif #endif
entry(getarg), entry(getarg),
entry(putargr), entry(putargi),
entry(addr), entry(addi), entry(addr), entry(addi),
entry(addxr), entry(addxi), entry(addxr), entry(addxi),
entry(addcr), entry(addci), entry(addcr), entry(addci),
@ -702,8 +704,8 @@ static instr_t instr_vector[] = {
#endif #endif
entry(retval), entry(retval),
entry(epilog), entry(epilog),
entry(arg_f), entry(arg_f), entry(getarg_f),
entry(getarg_f), entry(putargr_f), entry(putargi_f),
entry(addr_f), entry(addi_f), entry(addr_f), entry(addi_f),
entry(subr_f), entry(subi_f), entry(subr_f), entry(subi_f),
entry(rsbr_f), entry(rsbi_f), entry(rsbr_f), entry(rsbi_f),
@ -753,8 +755,8 @@ static instr_t instr_vector[] = {
entry(pushargr_f), entry(pushargi_f), entry(pushargr_f), entry(pushargi_f),
entry(retr_f), entry(reti_f), entry(retr_f), entry(reti_f),
entry(retval_f), entry(retval_f),
entry(arg_d), entry(arg_d), entry(getarg_d),
entry(getarg_d), entry(putargr_d), entry(putargi_d),
entry(addr_d), entry(addi_d), entry(addr_d), entry(addi_d),
entry(subr_d), entry(subi_d), entry(subr_d), entry(subi_d),
entry(rsbr_d), entry(rsbi_d), entry(rsbr_d), entry(rsbi_d),
@ -964,6 +966,14 @@ name(void) \
jit_gpr_t r0 = get_ireg(); \ jit_gpr_t r0 = get_ireg(); \
jit_##name(r0); \ jit_##name(r0); \
} }
#define entry_ima(name) \
static void \
name(void) \
{ \
jit_word_t im = get_imm(); \
jit_pointer_t ac = get_arg(); \
jit_##name(im, ac); \
}
#define entry_ir_ir_ir(name) \ #define entry_ir_ir_ir(name) \
static void \ static void \
name(void) \ name(void) \
@ -1091,6 +1101,14 @@ name(void) \
jit_pointer_t ac = get_arg(); \ jit_pointer_t ac = get_arg(); \
jit_##name(r0, ac); \ jit_##name(r0, ac); \
} }
#define entry_fma(name) \
static void \
name(void) \
{ \
jit_float64_t im = get_float(skip_ws); \
jit_pointer_t ac = get_arg(); \
jit_##name(im, ac); \
}
#define entry_fr_fr_fr(name) \ #define entry_fr_fr_fr(name) \
static void \ static void \
name(void) \ name(void) \
@ -1361,6 +1379,7 @@ entry_ia(getarg_i)
entry_ia(getarg_ui) entry_ia(getarg_l) entry_ia(getarg_ui) entry_ia(getarg_l)
#endif #endif
entry_ia(getarg) entry_ia(getarg)
entry_ia(putargr) entry_ima(putargi)
entry_ir_ir_ir(addr) entry_ir_ir_im(addi) entry_ir_ir_ir(addr) entry_ir_ir_im(addi)
entry_ir_ir_ir(addxr) entry_ir_ir_im(addxi) entry_ir_ir_ir(addxr) entry_ir_ir_im(addxi)
entry_ir_ir_ir(addcr) entry_ir_ir_im(addci) entry_ir_ir_ir(addcr) entry_ir_ir_im(addci)
@ -1522,8 +1541,8 @@ entry_ir(retval_ui) entry_ir(retval_l)
#endif #endif
entry_ir(retval) entry_ir(retval)
entry(epilog) entry(epilog)
entry_ca(arg_f) entry_ca(arg_f) entry_fa(getarg_f)
entry_fa(getarg_f) entry_fa(putargr_f) entry_fma(putargi_f)
entry_fr_fr_fr(addr_f) entry_fr_fr_fm(addi_f) entry_fr_fr_fr(addr_f) entry_fr_fr_fm(addi_f)
entry_fr_fr_fr(subr_f) entry_fr_fr_fm(subi_f) entry_fr_fr_fr(subr_f) entry_fr_fr_fm(subi_f)
entry_fr_fr_fr(rsbr_f) entry_fr_fr_fm(rsbi_f) entry_fr_fr_fr(rsbr_f) entry_fr_fr_fm(rsbi_f)
@ -1573,8 +1592,8 @@ entry_lb_fr_fr(bunordr_f) entry_lb_fr_fm(bunordi_f)
entry_fr(pushargr_f) entry_fm(pushargi_f) entry_fr(pushargr_f) entry_fm(pushargi_f)
entry_fr(retr_f) entry_fm(reti_f) entry_fr(retr_f) entry_fm(reti_f)
entry_fr(retval_f) entry_fr(retval_f)
entry_ca(arg_d) entry_ca(arg_d) entry_fa(getarg_d)
entry_fa(getarg_d) entry_fa(putargr_d) entry_fma(putargi_d)
entry_fr_fr_fr(addr_d) entry_fr_fr_dm(addi_d) entry_fr_fr_fr(addr_d) entry_fr_fr_dm(addi_d)
entry_fr_fr_fr(subr_d) entry_fr_fr_dm(subi_d) entry_fr_fr_fr(subr_d) entry_fr_fr_dm(subi_d)
entry_fr_fr_fr(rsbr_d) entry_fr_fr_dm(rsbi_d) entry_fr_fr_fr(rsbr_d) entry_fr_fr_dm(rsbi_d)
@ -1647,6 +1666,7 @@ entry_fr(retval_d)
#undef entry_fr_fr_fm #undef entry_fr_fr_fm
#undef entry_fr_fr_dm #undef entry_fr_fr_dm
#undef entry_fr_fr_fr #undef entry_fr_fr_fr
#undef entry_fma
#undef entry_fa #undef entry_fa
#undef entry_pm #undef entry_pm
#undef entry_lb #undef entry_lb
@ -1659,6 +1679,7 @@ entry_fr(retval_d)
#undef entry_ir_ir #undef entry_ir_ir
#undef entry_ir_ir_im #undef entry_ir_ir_im
#undef entry_ir_ir_ir #undef entry_ir_ir_ir
#undef entry_ima
#undef entry_ir #undef entry_ir
#undef entry_im #undef entry_im
#undef entry_ia #undef entry_ia

1
check/put.ok Normal file
View file

@ -0,0 +1 @@
ok

428
check/put.tst Normal file
View file

@ -0,0 +1,428 @@
.data 8
ok:
.c "ok"
.code
jmpi main
name putr
putr:
prolog
frame 160
arg $ac
arg $auc
arg $as
arg $aus
arg $ai
#if __WORDSIZE == 64
arg $aui
arg $al
#endif
arg_f $af
arg_d $ad
arg $a
#if __WORDSIZE == 64
arg $_l
arg $_ui
#endif
arg $_i
arg $_us
arg $_s
arg $_uc
arg $_c
getarg_c %r0 $ac
negr %r0 %r0
putargr %r0 $ac
getarg_uc %r0 $auc
negr %r0 %r0
putargr %r0 $auc
getarg_s %r0 $as
negr %r0 %r0
putargr %r0 $as
getarg_us %r0 $aus
negr %r0 %r0
putargr %r0 $aus
getarg_i %r0 $ai
negr %r0 %r0
putargr %r0 $ai
#if __WORDSIZE == 64
getarg_ui %r0 $aui
negr %r0 %r0
putargr %r0 $aui
getarg_l %r0 $al
negr %r0 %r0
putargr %r0 $al
#endif
getarg_f %f0 $af
negr_f %f0 %f0
putargr_f %f0 $af
getarg_d %f0 $ad
negr_d %f0 %f0
putargr_d %f0 $ad
getarg %r0 $a
negr %r0 %r0
putargr %r0 $a
#if __WORDSIZE == 64
getarg_l %r0 $_l
negr %r0 %r0
putargr %r0 $_l
getarg_ui %r0 $_ui
negr %r0 %r0
putargr %r0 $_ui
#endif
getarg_i %r0 $_i
negr %r0 %r0
putargr %r0 $_i
getarg_us %r0 $_us
negr %r0 %r0
putargr %r0 $_us
getarg_s %r0 $_s
negr %r0 %r0
putargr %r0 $_s
getarg_uc %r0 $_uc
negr %r0 %r0
putargr %r0 $_uc
getarg_c %r0 $_c
negr %r0 %r0
putargr %r0 $_c
jmpi _putr
rputr:
putargi 17 $ac
putargi 16 $auc
putargi 15 $as
putargi 14 $aus
putargi 13 $ai
#if __WORDSIZE == 64
putargi 12 $aui
putargi 11 $al
#endif
putargi_f 10 $af
putargi_d 9 $ad
putargi 8 $a
#if __WORDSIZE == 64
putargi 7 $_l
putargi 6 $_ui
#endif
putargi 5 $_i
putargi 4 $_us
putargi 3 $_s
putargi 2 $_uc
putargi 1 $_c
jmpi _puti
rputi:
ret
epilog
name _putr
_putr:
prolog
tramp 160
arg $ac
arg $auc
arg $as
arg $aus
arg $ai
#if __WORDSIZE == 64
arg $aui
arg $al
#endif
arg_f $af
arg_d $ad
arg $a
#if __WORDSIZE == 64
arg $_l
arg $_ui
#endif
arg $_i
arg $_us
arg $_s
arg $_uc
arg $_c
getarg_c %r0 $ac
beqi rac %r0 -1
calli @abort
rac:
getarg_uc %r0 $auc
beqi rauc %r0 $(-2 & 0xff)
calli @abort
rauc:
getarg_s %r0 $as
beqi ras %r0 -3
calli @abort
ras:
getarg_us %r0 $aus
beqi raus %r0 $(-4 & 0xffff)
calli @abort
raus:
getarg_i %r0 $ai
beqi rai %r0 -5
calli @abort
rai:
#if __WORDSIZE == 64
getarg_ui %r0 $aui
beqi raui %r0 $(-6 & 0xffffffff)
calli @abort
raui:
getarg_l %r0 $al
beqi ral %r0 -7
calli @abort
ral:
#endif
getarg_f %f0 $af
beqi_f raf %f0 -8
calli @abort
raf:
getarg_d %f0 $ad
beqi_d rad %f0 -9
calli @abort
rad:
getarg %r0 $a
beqi ra %r0 -10
calli @abort
ra:
#if __WORDSIZE == 64
getarg %r0 $_l
beqi r_l %r0 -11
calli @abort
r_l:
getarg_ui %r0 $_ui
beqi r_ui %r0 $(-12 & 0xffffffff)
calli @abort
r_ui:
#endif
getarg_i %r0 $_i
beqi r_i %r0 -13
calli @abort
r_i:
getarg_us %r0 $_us
beqi r_us %r0 $(-14 & 0xffff)
calli @abort
r_us:
getarg_s %r0 $_s
beqi r_s %r0 -15
calli @abort
r_s:
getarg_uc %r0 $_uc
beqi r_uc %r0 $(-16 & 0xff)
calli @abort
r_uc:
getarg_c %r0 $_c
beqi r_c %r0 -17
calli @abort
r_c:
jmpi rputr
epilog
name _puti
_puti:
prolog
tramp 160
arg $ac
arg $auc
arg $as
arg $aus
arg $ai
#if __WORDSIZE == 64
arg $aui
arg $al
#endif
arg_f $af
arg_d $ad
arg $a
#if __WORDSIZE == 64
arg $_l
arg $_ui
#endif
arg $_i
arg $_us
arg $_s
arg $_uc
arg $_c
getarg_c %r0 $ac
beqi iac %r0 17
calli @abort
iac:
getarg_uc %r0 $auc
beqi iauc %r0 16
calli @abort
iauc:
getarg_s %r0 $as
beqi ias %r0 15
calli @abort
ias:
getarg_us %r0 $aus
beqi iaus %r0 14
calli @abort
iaus:
getarg_i %r0 $ai
beqi iai %r0 13
calli @abort
iai:
#if __WORDSIZE == 64
getarg_ui %r0 $aui
beqi iaui %r0 12
calli @abort
iaui:
getarg_l %r0 $al
beqi ial %r0 11
calli @abort
ial:
#endif
getarg_f %f0 $af
beqi_f iaf %f0 10
calli @abort
iaf:
getarg_d %f0 $ad
beqi_d iad %f0 9
calli @abort
iad:
getarg %r0 $a
beqi ia %r0 8
calli @abort
ia:
#if __WORDSIZE == 64
getarg %r0 $_l
beqi i_l %r0 7
calli @abort
i_l:
getarg_ui %r0 $_ui
beqi i_ui %r0 6
calli @abort
i_ui:
#endif
getarg_i %r0 $_i
beqi i_i %r0 5
calli @abort
i_i:
getarg_us %r0 $_us
beqi i_us %r0 4
calli @abort
i_us:
getarg_s %r0 $_s
beqi i_s %r0 3
calli @abort
i_s:
getarg_uc %r0 $_uc
beqi i_uc %r0 2
calli @abort
i_uc:
getarg_c %r0 $_c
beqi i_c %r0 1
calli @abort
i_c:
jmpi rputi
epilog
name putf
putf:
prolog
frame 56
arg $i1
arg_d $d1
arg_f $f1
arg_f $f2
arg_f $f3
arg $i2
arg_d $d2
getarg %r0 $i1
addi %r0 %r0 1
putargr %r0 $i1
getarg_d %f0 $d1
addi_d %f0 %f0 1
putargr_d %f0 $d1
getarg_f %f0 $f1
addi_f %f0 %f0 1
putargr_f %f0 $f1
getarg_f %f0 $f2
subi_f %f0 %f0 1
putargr_f %f0 $f2
putargi_f -5 $f3
putargi -6 $i2
putargi_d -7 $d2
jmpi _putf
rputf:
ret
epilog
name _putf
_putf:
prolog
tramp 56
arg $i1
arg_d $d1
arg_f $f1
arg_f $f2
arg_f $f3
arg $i2
arg_d $d2
getarg %r0 $i1
beqi fi1 %r0 2
calli @abort
fi1:
getarg_d %f0 $d1
beqi_d fd1 %f0 3
calli @abort
fd1:
getarg_f %f0 $f1
beqi_f ff1 %f0 4
calli @abort
ff1:
getarg_f %f0 $f2
beqi_f ff2 %f0 3
calli @abort
ff2:
getarg_f %f0 $f3
beqi_f ff3 %f0 -5
calli @abort
ff3:
getarg %r0 $i2
beqi fi2 %r0 -6
calli @abort
fi2:
getarg_d %f0 $d2
beqi_d fd2 %f0 -7
calli @abort
fd2:
jmpi rputf
epilog
name main
main:
prolog
prepare
pushargi 1
pushargi 2
pushargi 3
pushargi 4
pushargi 5
#if __WORDSIZE == 64
pushargi 6
pushargi 7
#endif
pushargi_f 8
pushargi_d 9
pushargi 10
#if __WORDSIZE == 64
pushargi 11
pushargi 12
#endif
pushargi 13
pushargi 14
pushargi 15
pushargi 16
pushargi 17
finishi putr
prepare
pushargi 1
pushargi_d 2
pushargi_f 3
pushargi_f 4
pushargi_f 5
pushargi 6
pushargi_d 7
finishi putf
prepare
pushargi ok
finishi @puts
ret
epilog

12
include/lightning.h
View file

@ -207,6 +207,8 @@ typedef enum {
# define jit_getarg_ui(u,v) _jit_getarg_ui(_jit,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) # define jit_getarg_l(u,v) _jit_getarg_l(_jit,u,v)
#endif #endif
# define jit_putargr(u,v) _jit_putargr(_jit,u,v)
# define jit_putargi(u,v) _jit_putargi(_jit,u,v)
jit_code_arg, jit_code_arg,
#define jit_addr(u,v,w) jit_new_node_www(jit_code_addr,u,v,w) #define jit_addr(u,v,w) jit_new_node_www(jit_code_addr,u,v,w)
@ -539,6 +541,8 @@ typedef enum {
#define jit_arg_f() _jit_arg_f(_jit) #define jit_arg_f() _jit_arg_f(_jit)
#define jit_getarg_f(u,v) _jit_getarg_f(_jit,u,v) #define jit_getarg_f(u,v) _jit_getarg_f(_jit,u,v)
#define jit_putargr_f(u,v) _jit_putargr_f(_jit,u,v)
#define jit_putargi_f(u,v) _jit_putargi_f(_jit,u,v)
jit_code_arg_f, jit_code_arg_f,
#define jit_addr_f(u,v,w) jit_new_node_www(jit_code_addr_f,u,v,w) #define jit_addr_f(u,v,w) jit_new_node_www(jit_code_addr_f,u,v,w)
@ -684,6 +688,8 @@ typedef enum {
#define jit_arg_d() _jit_arg_d(_jit) #define jit_arg_d() _jit_arg_d(_jit)
#define jit_getarg_d(u,v) _jit_getarg_d(_jit,u,v) #define jit_getarg_d(u,v) _jit_getarg_d(_jit,u,v)
#define jit_putargr_d(u,v) _jit_putargr_d(_jit,u,v)
#define jit_putargi_d(u,v) _jit_putargi_d(_jit,u,v)
jit_code_arg_d, jit_code_arg_d,
#define jit_addr_d(u,v,w) jit_new_node_www(jit_code_addr_d,u,v,w) #define jit_addr_d(u,v,w) jit_new_node_www(jit_code_addr_d,u,v,w)
@ -896,6 +902,8 @@ extern void _jit_getarg_i(jit_state_t*, jit_gpr_t, jit_node_t*);
extern void _jit_getarg_ui(jit_state_t*, jit_gpr_t, jit_node_t*); extern void _jit_getarg_ui(jit_state_t*, jit_gpr_t, jit_node_t*);
extern void _jit_getarg_l(jit_state_t*, jit_gpr_t, jit_node_t*); extern void _jit_getarg_l(jit_state_t*, jit_gpr_t, jit_node_t*);
#endif #endif
extern void _jit_putargr(jit_state_t*, jit_gpr_t, jit_node_t*);
extern void _jit_putargi(jit_state_t*, jit_word_t, jit_node_t*);
extern void _jit_prepare(jit_state_t*); extern void _jit_prepare(jit_state_t*);
extern void _jit_ellipsis(jit_state_t*); extern void _jit_ellipsis(jit_state_t*);
@ -945,6 +953,8 @@ extern void _jit_print(jit_state_t*);
extern jit_node_t *_jit_arg_f(jit_state_t*); extern jit_node_t *_jit_arg_f(jit_state_t*);
extern void _jit_getarg_f(jit_state_t*, jit_fpr_t, jit_node_t*); extern void _jit_getarg_f(jit_state_t*, jit_fpr_t, jit_node_t*);
extern void _jit_putargr_f(jit_state_t*, jit_fpr_t, jit_node_t*);
extern void _jit_putargi_f(jit_state_t*, jit_float32_t, jit_node_t*);
extern void _jit_pushargr_f(jit_state_t*, jit_fpr_t); extern void _jit_pushargr_f(jit_state_t*, jit_fpr_t);
extern void _jit_pushargi_f(jit_state_t*, jit_float32_t); extern void _jit_pushargi_f(jit_state_t*, jit_float32_t);
extern void _jit_retr_f(jit_state_t*, jit_fpr_t); extern void _jit_retr_f(jit_state_t*, jit_fpr_t);
@ -953,6 +963,8 @@ extern void _jit_retval_f(jit_state_t*, jit_fpr_t);
extern jit_node_t *_jit_arg_d(jit_state_t*); extern jit_node_t *_jit_arg_d(jit_state_t*);
extern void _jit_getarg_d(jit_state_t*, jit_fpr_t, jit_node_t*); extern void _jit_getarg_d(jit_state_t*, jit_fpr_t, jit_node_t*);
extern void _jit_putargr_d(jit_state_t*, jit_fpr_t, jit_node_t*);
extern void _jit_putargi_d(jit_state_t*, jit_float64_t, jit_node_t*);
extern void _jit_pushargr_d(jit_state_t*, jit_fpr_t); extern void _jit_pushargr_d(jit_state_t*, jit_fpr_t);
extern void _jit_pushargi_d(jit_state_t*, jit_float64_t); extern void _jit_pushargi_d(jit_state_t*, jit_float64_t);
extern void _jit_retr_d(jit_state_t*, jit_fpr_t); extern void _jit_retr_d(jit_state_t*, jit_fpr_t);

84
lib/jit_aarch64.c
View file

@ -306,6 +306,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_c(u, JIT_RA0 - v->u.w); jit_extr_c(u, JIT_RA0 - v->u.w);
else else
@ -315,6 +316,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_uc(u, JIT_RA0 - v->u.w); jit_extr_uc(u, JIT_RA0 - v->u.w);
else else
@ -324,6 +326,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_s(u, JIT_RA0 - v->u.w); jit_extr_s(u, JIT_RA0 - v->u.w);
else else
@ -333,6 +336,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_us(u, JIT_RA0 - v->u.w); jit_extr_us(u, JIT_RA0 - v->u.w);
else else
@ -342,6 +346,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_i(u, JIT_RA0 - v->u.w); jit_extr_i(u, JIT_RA0 - v->u.w);
else else
@ -351,6 +356,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_ui(u, JIT_RA0 - v->u.w); jit_extr_ui(u, JIT_RA0 - v->u.w);
else else
@ -360,30 +366,108 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr(u, JIT_RA0 - v->u.w); jit_movr(u, JIT_RA0 - v->u.w);
else else
jit_ldxi_l(u, JIT_FP, v->u.w); jit_ldxi_l(u, JIT_FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr_f(u, JIT_FA0 - v->u.w); jit_movr_f(u, JIT_FA0 - v->u.w);
else else
jit_ldxi_f(u, JIT_FP, v->u.w); jit_ldxi_f(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 8)
jit_movr_f(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 8)
jit_movi_f(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr_d(u, JIT_FA0 - v->u.w); jit_movr_d(u, JIT_FA0 - v->u.w);
else else
jit_ldxi_d(u, JIT_FP, v->u.w); jit_ldxi_d(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 8)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 8)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

93
lib/jit_alpha.c
View file

@ -304,6 +304,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_c(u, _A0 - v->u.w); jit_extr_c(u, _A0 - v->u.w);
else { else {
@ -318,6 +319,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_uc(u, _A0 - v->u.w); jit_extr_uc(u, _A0 - v->u.w);
else { else {
@ -332,6 +334,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_s(u, _A0 - v->u.w); jit_extr_s(u, _A0 - v->u.w);
else { else {
@ -346,6 +349,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_us(u, _A0 - v->u.w); jit_extr_us(u, _A0 - v->u.w);
else { else {
@ -360,6 +364,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_i(u, _A0 - v->u.w); jit_extr_i(u, _A0 - v->u.w);
else { else {
@ -374,6 +379,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_ui(u, _A0 - v->u.w); jit_extr_ui(u, _A0 - v->u.w);
else { else {
@ -388,15 +394,42 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_movr(u, _A0 - v->u.w); jit_movr(u, _A0 - v->u.w);
else else
jit_ldxi_l(u, _FP, v->u.w); jit_ldxi_l(u, _FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_movr(_A0 - v->u.w, u);
else
jit_stxi(v->u.w, _FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_movi(_A0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w < 6) if (v->u.w < 6)
jit_movr_f(u, _F16 - v->u.w); jit_movr_f(u, _F16 - v->u.w);
else { else {
@ -408,15 +441,75 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 6)
jit_movr_f(_F16 - v->u.w, u);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, _FP, u);
#else
jit_stxi_f(v->u.w + 8 - sizeof(jit_float32_t), _FP, u);
#endif
}
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 6)
jit_movi_f(_F16 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, _FP, regno);
#else
jit_stxi_f(v->u.w + 8 - sizeof(jit_float32_t), _FP, regno);
#endif
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w < 6) if (v->u.w < 6)
jit_movr_d(u, _F16 - v->u.w); jit_movr_d(u, _F16 - v->u.w);
else else
jit_ldxi_d(u, _FP, v->u.w); jit_ldxi_d(u, _FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 6)
jit_movr_d(_F16 - v->u.w, u);
else
jit_stxi_d(v->u.w, _FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 6)
jit_movi_d(_F16 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

144
lib/jit_arm.c
View file

@ -452,6 +452,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_swf_p()) if (jit_swf_p())
jit_ldxi_c(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w); jit_ldxi_c(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4) else if (v->u.w < 4)
@ -463,6 +464,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_swf_p()) if (jit_swf_p())
jit_ldxi_uc(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w); jit_ldxi_uc(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4) else if (v->u.w < 4)
@ -474,6 +476,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_swf_p()) if (jit_swf_p())
jit_ldxi_s(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w); jit_ldxi_s(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4) else if (v->u.w < 4)
@ -485,6 +488,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_swf_p()) if (jit_swf_p())
jit_ldxi_us(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w); jit_ldxi_us(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4) else if (v->u.w < 4)
@ -496,6 +500,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_swf_p()) if (jit_swf_p())
jit_ldxi_i(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w); jit_ldxi_i(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4) else if (v->u.w < 4)
@ -504,9 +509,43 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_i(u, JIT_FP, v->u.w); jit_ldxi_i(u, JIT_FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (jit_swf_p())
jit_stxi(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else if (v->u.w < 4)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (jit_swf_p()) {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else if (v->u.w < 4)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (jit_cpu.abi) { if (jit_cpu.abi) {
if (v->u.w < 16) if (v->u.w < 16)
jit_movr_f(u, JIT_FA0 - v->u.w); jit_movr_f(u, JIT_FA0 - v->u.w);
@ -523,9 +562,62 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_f(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
else if (jit_swf_p())
jit_stxi_f(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else {
if (v->u.w < 4)
jit_movr_f_w(JIT_RA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movi_f(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
else if (jit_swf_p()) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
if (v->u.w < 4)
jit_movr_f_w(JIT_RA0 - v->u.w, regno);
else
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (jit_cpu.abi) { if (jit_cpu.abi) {
if (v->u.w < 16) if (v->u.w < 16)
jit_movr_d(u, JIT_FA0 - v->u.w); jit_movr_d(u, JIT_FA0 - v->u.w);
@ -542,6 +634,58 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
else if (jit_swf_p())
jit_stxi_d(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else {
if (v->u.w < 4)
jit_movr_d_ww(JIT_RA0 - v->u.w, JIT_RA0 - (v->u.w + 1), u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
else if (jit_swf_p()) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
if (v->u.w < 4)
jit_movr_d_ww(JIT_RA0 - v->u.w, JIT_RA0 - (v->u.w + 1), regno);
else
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

82
lib/jit_hppa.c
View file

@ -316,6 +316,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_extr_c(u, _R26 - v->u.w); jit_extr_c(u, _R26 - v->u.w);
else else
@ -325,6 +326,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_extr_uc(u, _R26 - v->u.w); jit_extr_uc(u, _R26 - v->u.w);
else else
@ -334,6 +336,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_extr_s(u, _R26 - v->u.w); jit_extr_s(u, _R26 - v->u.w);
else else
@ -343,6 +346,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_extr_us(u, _R26 - v->u.w); jit_extr_us(u, _R26 - v->u.w);
else else
@ -352,30 +356,108 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_movr(u, _R26 - v->u.w); jit_movr(u, _R26 - v->u.w);
else else
jit_ldxi_i(u, JIT_FP, v->u.w); jit_ldxi_i(u, JIT_FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w >= 0)
jit_movr(_R26 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w >= 0)
jit_movi(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_movr_f(u, _F4 - v->u.w); jit_movr_f(u, _F4 - v->u.w);
else else
jit_ldxi_f(u, JIT_FP, v->u.w); jit_ldxi_f(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w >= 0)
jit_movr_f(_F4 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w >= 0)
jit_movi_f(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w >= 0) if (v->u.w >= 0)
jit_movr_d(u, _F4 - v->u.w); jit_movr_d(u, _F4 - v->u.w);
else else
jit_ldxi_d(u, JIT_FP, v->u.w); jit_ldxi_d(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w >= 0)
jit_movr_d(_F4 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w >= 0)
jit_movi_d(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

93
lib/jit_ia64.c
View file

@ -404,6 +404,7 @@ _jit_arg_d(jit_state_t *_jit)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) { if (v->u.w < 8) {
jit_extr_c(u, _R32 + v->u.w); jit_extr_c(u, _R32 + v->u.w);
} }
@ -420,6 +421,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_uc(u, _R32 + v->u.w); jit_extr_uc(u, _R32 + v->u.w);
else { else {
@ -435,6 +437,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_s(u, _R32 + v->u.w); jit_extr_s(u, _R32 + v->u.w);
else { else {
@ -450,6 +453,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_us(u, _R32 + v->u.w); jit_extr_us(u, _R32 + v->u.w);
else { else {
@ -465,6 +469,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_i(u, _R32 + v->u.w); jit_extr_i(u, _R32 + v->u.w);
else { else {
@ -480,6 +485,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_ui(u, _R32 + v->u.w); jit_extr_ui(u, _R32 + v->u.w);
else { else {
@ -495,15 +501,42 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr(u, _R32 + v->u.w); jit_movr(u, _R32 + v->u.w);
else else
jit_ldxi(u, JIT_FP, v->u.w); jit_ldxi(u, JIT_FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movr(_R32 + v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movi(_R32 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr_f(u, _F8 + v->u.w); jit_movr_f(u, _F8 + v->u.w);
else { else {
@ -516,15 +549,75 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 8)
jit_movr_f(_F8 + v->u.w, u);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, JIT_FP, u);
#else
jit_stxi_f(v->u.w + (__WORDSIZE >> 3) - sizeof(jit_float32_t), JIT_FP, u);
#endif
}
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 8)
jit_movi_f(_F8 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, JIT_FP, regno);
#else
jit_stxi_f(v->u.w, JIT_FP + (__WORDSIZE >> 3) - sizeof(jit_float32_t), regno);
#endif
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr_d(u, _F8 + v->u.w); jit_movr_d(u, _F8 + v->u.w);
else else
jit_ldxi_d(u, JIT_FP, v->u.w); jit_ldxi_d(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 8)
jit_movr_d(_F8 + v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 8)
jit_movi_d(_F8 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

120
lib/jit_mips.c
View file

@ -379,6 +379,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_extr_c(u, _A0 - v->u.w); jit_extr_c(u, _A0 - v->u.w);
else { else {
@ -393,6 +394,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_extr_uc(u, _A0 - v->u.w); jit_extr_uc(u, _A0 - v->u.w);
else { else {
@ -407,6 +409,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_extr_s(u, _A0 - v->u.w); jit_extr_s(u, _A0 - v->u.w);
else { else {
@ -421,6 +424,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_extr_us(u, _A0 - v->u.w); jit_extr_us(u, _A0 - v->u.w);
else { else {
@ -435,6 +439,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) { if (v->u.w < NUM_WORD_ARGS) {
#if __WORDSIZE == 64 #if __WORDSIZE == 64
jit_extr_i(u, _A0 - v->u.w); jit_extr_i(u, _A0 - v->u.w);
@ -455,6 +460,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_extr_ui(u, _A0 - v->u.w); jit_extr_ui(u, _A0 - v->u.w);
else { else {
@ -469,6 +475,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_movr(u, _A0 - v->u.w); jit_movr(u, _A0 - v->u.w);
else else
@ -476,9 +483,35 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
#endif #endif
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS)
jit_movr(_A0 - v->u.w, u);
else
jit_stxi(v->u.w, _FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS)
jit_movi(_A0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
#if NEW_ABI #if NEW_ABI
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_movr_f(u, _F12 - v->u.w); jit_movr_f(u, _F12 - v->u.w);
@ -492,9 +525,53 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, _FP, v->u.w); jit_ldxi_f(u, _FP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_f(_F12 - v->u.w, u);
#else
if (v->u.w < 4)
jit_movr_f_w(_A0 - v->u.w, u);
else if (v->u.w < 8)
jit_movr_f(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else
jit_stxi_f(v->u.w, _FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movi_f(_F12 - v->u.w, u);
#else
if (v->u.w < 4) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_movr_f_w(_A0 - ((v->u.w - 4) >> 1), regno);
jit_unget_reg(regno);
}
else if (v->u.w < 8)
jit_movi_f(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
#if NEW_ABI #if NEW_ABI
if (v->u.w < NUM_WORD_ARGS) if (v->u.w < NUM_WORD_ARGS)
jit_movr_d(u, _F12 - v->u.w); jit_movr_d(u, _F12 - v->u.w);
@ -508,6 +585,49 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_d(u, _FP, v->u.w); jit_ldxi_d(u, _FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_d(_F12 - v->u.w, u);
#else
if (v->u.w < 4)
jit_movr_d_ww(_A0 - v->u.w, _A0 - (v->u.w + 1), u);
else if (v->u.w < 8)
jit_movr_d(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else
jit_stxi_d(v->u.w, _FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movi_d(_F12 - v->u.w, u);
#else
if (v->u.w < 4) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_movr_d_ww(_A0 - v->u.w, _A0 - (v->u.w + 1), regno);
jit_unget_reg(regno);
}
else if (v->u.w < 8)
jit_movi_d(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

98
lib/jit_ppc.c
View file

@ -283,6 +283,13 @@ _jit_arg_f(jit_state_t *_jit)
offset = _jitc->function->self.size; offset = _jitc->function->self.size;
#else #else
offset = _jitc->function->self.size + 4; offset = _jitc->function->self.size + 4;
#endif
}
if (_jitc->function->self.argi < 8) {
#if __WORDSIZE == 32
_jitc->function->self.argi += 2;
#else
_jitc->function->self.argi++;
#endif #endif
} }
_jitc->function->self.size += sizeof(jit_word_t); _jitc->function->self.size += sizeof(jit_word_t);
@ -304,6 +311,13 @@ _jit_arg_d(jit_state_t *_jit)
offset = _jitc->function->self.argf++; offset = _jitc->function->self.argf++;
else else
offset = _jitc->function->self.size; offset = _jitc->function->self.size;
if (_jitc->function->self.argi < 8) {
#if __WORDSIZE == 32
_jitc->function->self.argi += 2;
#else
_jitc->function->self.argi++;
#endif
}
_jitc->function->self.size += sizeof(jit_float64_t); _jitc->function->self.size += sizeof(jit_float64_t);
return (jit_new_node_w(jit_code_arg_d, offset)); return (jit_new_node_w(jit_code_arg_d, offset));
} }
@ -317,6 +331,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_c(u, JIT_RA0 - v->u.w); jit_extr_c(u, JIT_RA0 - v->u.w);
else { else {
@ -332,6 +347,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_uc(u, JIT_RA0 - v->u.w); jit_extr_uc(u, JIT_RA0 - v->u.w);
else { else {
@ -347,6 +363,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_s(u, JIT_RA0 - v->u.w); jit_extr_s(u, JIT_RA0 - v->u.w);
else { else {
@ -362,6 +379,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_us(u, JIT_RA0 - v->u.w); jit_extr_us(u, JIT_RA0 - v->u.w);
else { else {
@ -377,6 +395,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) { if (v->u.w < 8) {
#if __WORDSIZE == 32 #if __WORDSIZE == 32
jit_movr(u, JIT_RA0 - v->u.w); jit_movr(u, JIT_RA0 - v->u.w);
@ -398,6 +417,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_extr_ui(u, JIT_RA0 - v->u.w); jit_extr_ui(u, JIT_RA0 - v->u.w);
else { else {
@ -413,6 +433,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 8) if (v->u.w < 8)
jit_movr(u, JIT_RA0 - v->u.w); jit_movr(u, JIT_RA0 - v->u.w);
else else
@ -420,24 +441,101 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
#endif #endif
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w < 13) if (v->u.w < 13)
jit_movr_d(u, JIT_FA0 - v->u.w); jit_movr_d(u, JIT_FA0 - v->u.w);
else else
jit_ldxi_f(u, JIT_FP, v->u.w); jit_ldxi_f(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 13)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 13)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w < 13) if (v->u.w < 13)
jit_movr_d(u, JIT_FA0 - v->u.w); jit_movr_d(u, JIT_FA0 - v->u.w);
else else
jit_ldxi_d(u, JIT_FP, v->u.w); jit_ldxi_d(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 13)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 13)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

92
lib/jit_s390.c
View file

@ -283,6 +283,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_extr_c(u, _R2 - v->u.w); jit_extr_c(u, _R2 - v->u.w);
else else
@ -293,6 +294,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_extr_uc(u, _R2 - v->u.w); jit_extr_uc(u, _R2 - v->u.w);
else else
@ -303,6 +305,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_extr_s(u, _R2 - v->u.w); jit_extr_s(u, _R2 - v->u.w);
else else
@ -313,6 +316,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_extr_us(u, _R2 - v->u.w); jit_extr_us(u, _R2 - v->u.w);
else else
@ -323,6 +327,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) { if (v->u.w < 5) {
#if __WORDSIZE == 32 #if __WORDSIZE == 32
jit_movr(u, _R2 - v->u.w); jit_movr(u, _R2 - v->u.w);
@ -339,6 +344,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_extr_ui(u, _R2 - v->u.w); jit_extr_ui(u, _R2 - v->u.w);
else else
@ -349,6 +355,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 5) if (v->u.w < 5)
jit_movr(u, _R2 - v->u.w); jit_movr(u, _R2 - v->u.w);
else else
@ -356,9 +363,35 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
#endif #endif
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 5)
jit_movr(_R2 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 5)
jit_movi(_R2 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
if (v->u.w < 4) if (v->u.w < 4)
jit_movr_f(u, _F0 - v->u.w); jit_movr_f(u, _F0 - v->u.w);
else else
@ -370,15 +403,74 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
); );
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 4)
jit_movr_f(_F0 - v->u.w, u);
else
jit_stxi_f(v->u.w
#if __WORDSIZE == 64
+ (__WORDSIZE >> 3) - sizeof(jit_float32_t)
#endif
, JIT_FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 4)
jit_movi_f(_F0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w
#if __WORDSIZE == 64
+ (__WORDSIZE >> 3) - sizeof(jit_float32_t)
#endif
, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
if (v->u.w < 4) if (v->u.w < 4)
jit_movr_d(u, _F0 - v->u.w); jit_movr_d(u, _F0 - v->u.w);
else else
jit_ldxi_d(u, JIT_FP, v->u.w); jit_ldxi_d(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 4)
jit_movr_d(_F0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 4)
jit_movi_d(_F0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

126
lib/jit_sparc.c
View file

@ -294,6 +294,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_c(u, _I0 + v->u.w); jit_extr_c(u, _I0 + v->u.w);
else { else {
@ -306,6 +307,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_uc(u, _I0 + v->u.w); jit_extr_uc(u, _I0 + v->u.w);
else { else {
@ -318,6 +320,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_s(u, _I0 + v->u.w); jit_extr_s(u, _I0 + v->u.w);
else { else {
@ -330,6 +333,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_extr_us(u, _I0 + v->u.w); jit_extr_us(u, _I0 + v->u.w);
else { else {
@ -342,15 +346,42 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (v->u.w < 6) if (v->u.w < 6)
jit_movr(u, _I0 + v->u.w); jit_movr(u, _I0 + v->u.w);
else else
jit_ldxi_i(u, JIT_FP, v->u.w); jit_ldxi_i(u, JIT_FP, v->u.w);
} }
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_movr(_I0 + v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_movi(_I0 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
assert(_jitc->function); assert(_jitc->function);
if (v->u.w < 6) { if (v->u.w < 6) {
jit_stxi(-4, JIT_FP, _I0 + v->u.w); jit_stxi(-4, JIT_FP, _I0 + v->u.w);
@ -360,9 +391,38 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, JIT_FP, v->u.w); jit_ldxi_f(u, JIT_FP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 6) {
jit_stxi_f(-4, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -4);
}
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
if (v->u.w < 6) {
jit_stxi_f(-4, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -4);
}
else
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
assert(_jitc->function); assert(_jitc->function);
if (v->u.w < 5) { if (v->u.w < 5) {
jit_stxi(-8, JIT_FP, _I0 + v->u.w); jit_stxi(-8, JIT_FP, _I0 + v->u.w);
@ -380,6 +440,72 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 5) {
jit_stxi_d(-8, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
}
if (v->u.w < 6) {
regno = jit_get_reg(jit_class_gpr);
jit_stxi_d(-8, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(regno, JIT_FP, -4);
jit_stxi(stack_framesize, JIT_FP, regno);
jit_unget_reg(regno);
}
else if ((v->u.w & 7) == 0)
jit_stxi_d(v->u.w, JIT_FP, u);
else {
jit_stxi_d(-8, JIT_FP, u);
regno = jit_get_reg(jit_class_gpr);
jit_ldxi(regno, JIT_FP, -8);
jit_stxi(v->u.w, JIT_FP, regno);
jit_ldxi(regno, JIT_FP, -4);
jit_stxi(v->u.w + 4, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno, gpr;
assert(v->code == jit_code_arg_d);
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
if (v->u.w < 5) {
jit_stxi_d(-8, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
}
else if (v->u.w < 6) {
gpr = jit_get_reg(jit_class_gpr);
jit_stxi_d(-8, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(gpr, JIT_FP, -4);
jit_stxi(stack_framesize, JIT_FP, gpr);
jit_unget_reg(gpr);
}
else if ((v->u.w & 7) == 0)
jit_stxi_d(v->u.w, JIT_FP, regno);
else {
jit_stxi_d(-8, JIT_FP, regno);
gpr = jit_get_reg(jit_class_gpr);
jit_ldxi(gpr, JIT_FP, -8);
jit_stxi(v->u.w, JIT_FP, gpr);
jit_ldxi(gpr, JIT_FP, -4);
jit_stxi(v->u.w + 4, JIT_FP, gpr);
jit_unget_reg(gpr);
}
jit_unget_reg(regno);
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {

99
lib/jit_x86.c
View file

@ -577,6 +577,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
#if __X64 #if __X64
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_extr_c(u, JIT_RA0 - v->u.w); jit_extr_c(u, JIT_RA0 - v->u.w);
@ -588,6 +589,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
#if __X64 #if __X64
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_extr_uc(u, JIT_RA0 - v->u.w); jit_extr_uc(u, JIT_RA0 - v->u.w);
@ -599,6 +601,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
#if __X64 #if __X64
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_extr_s(u, JIT_RA0 - v->u.w); jit_extr_s(u, JIT_RA0 - v->u.w);
@ -610,6 +613,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
#if __X64 #if __X64
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_extr_us(u, JIT_RA0 - v->u.w); jit_extr_us(u, JIT_RA0 - v->u.w);
@ -621,6 +625,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
#if __X64 #if __X64
if (jit_arg_reg_p(v->u.w)) { if (jit_arg_reg_p(v->u.w)) {
# if __X64_32 # if __X64_32
@ -638,6 +643,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_extr_ui(u, JIT_RA0 - v->u.w); jit_extr_ui(u, JIT_RA0 - v->u.w);
else else
@ -647,6 +653,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg);
if (jit_arg_reg_p(v->u.w)) if (jit_arg_reg_p(v->u.w))
jit_movr(u, JIT_RA0 - v->u.w); jit_movr(u, JIT_RA0 - v->u.w);
else else
@ -654,9 +661,40 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
} }
#endif #endif
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr(JIT_RA0 - v->u.w, u);
else
#endif
jit_stxi(v->u.w, _RBP, u);
}
void
_jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movi(JIT_RA0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_f);
#if __X64 #if __X64
if (jit_arg_f_reg_p(v->u.w)) if (jit_arg_f_reg_p(v->u.w))
jit_movr_f(u, _XMM0 - v->u.w); jit_movr_f(u, _XMM0 - v->u.w);
@ -665,9 +703,40 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, _RBP, v->u.w); jit_ldxi_f(u, _RBP, v->u.w);
} }
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr_f(_XMM0 - v->u.w, u);
else
#endif
jit_stxi_f(v->u.w, _RBP, u);
}
void
_jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movi_f(_XMM0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{ {
assert(v->code == jit_code_arg_d);
#if __X64 #if __X64
if (jit_arg_f_reg_p(v->u.w)) if (jit_arg_f_reg_p(v->u.w))
jit_movr_d(u, _XMM0 - v->u.w); jit_movr_d(u, _XMM0 - v->u.w);
@ -676,6 +745,36 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_d(u, _RBP, v->u.w); jit_ldxi_d(u, _RBP, v->u.w);
} }
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr_d(_XMM0 - v->u.w, u);
else
#endif
jit_stxi_d(v->u.w, _RBP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movi_d(_XMM0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u) _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{ {