[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 349/437: Implement jit_putarg*
From: |
Andy Wingo |
Subject: |
[Guile-commits] 349/437: Implement jit_putarg* |
Date: |
Mon, 2 Jul 2018 05:14:52 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 27d9b68a3fad0fbb1956a11f35ce51852480135c
Author: Paulo Andrade <address@hidden>
Date: Thu Jan 15 14:20:07 2015 -0200
Implement jit_putarg*
* 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.
---
ChangeLog | 18 +++
check/Makefile.am | 20 ++-
check/lightning.c | 45 ++++--
check/put.ok | 1 +
check/put.tst | 428 ++++++++++++++++++++++++++++++++++++++++++++++++++++
include/lightning.h | 12 ++
lib/jit_aarch64.c | 84 +++++++++++
lib/jit_alpha.c | 93 ++++++++++++
lib/jit_arm.c | 144 ++++++++++++++++++
lib/jit_hppa.c | 82 ++++++++++
lib/jit_ia64.c | 93 ++++++++++++
lib/jit_mips.c | 120 +++++++++++++++
lib/jit_ppc.c | 98 ++++++++++++
lib/jit_s390.c | 92 +++++++++++
lib/jit_sparc.c | 126 ++++++++++++++++
lib/jit_x86.c | 99 ++++++++++++
16 files changed, 1535 insertions(+), 20 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 780a74f..3c13109 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,21 @@
+2015-01-15 Paulo Andrade <address@hidden>
+
+ * 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 <address@hidden>
* include/lightning/jit_s390.h, lib/jit_s390-cpu.c,
diff --git a/check/Makefile.am b/check/Makefile.am
index 653742b..c295711 100644
--- a/check/Makefile.am
+++ b/check/Makefile.am
@@ -84,6 +84,7 @@ EXTRA_DIST = \
call.tst call.ok \
float.tst float.ok \
jmpr.tst jmpr.ok \
+ put.tst put.ok \
qalu.inc \
qalu_mul.tst qalu_mul.ok \
qalu_div.tst qalu_div.ok \
@@ -115,7 +116,7 @@ base_TESTS = \
fop_abs fop_sqrt \
varargs stack \
clobber carry call \
- float jmpr \
+ float jmpr put \
qalu_mul qalu_div \
range ret tramp
@@ -142,7 +143,7 @@ x87_TESTS = \
fop_abs.x87 fop_sqrt.x87 \
varargs.x87 stack.x87 \
clobber.x87 carry.x87 call.x87 \
- float.x87 jmpr.x87
+ float.x87 jmpr.x87 put.x87
$(x87_TESTS): check.x87.sh
$(LN_S) $(srcdir)/check.x87.sh $@
TESTS += $(x87_TESTS)
@@ -164,7 +165,7 @@ x87_nodata_TESTS =
\
fop_abs.x87.nodata fop_sqrt.x87.nodata \
varargs.x87.nodata stack.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
$(LN_S) $(srcdir)/check.x87.nodata.sh $@
TESTS += $(x87_nodata_TESTS)
@@ -188,7 +189,8 @@ arm_TESTS = \
fop_abs.arm fop_sqrt.arm \
varargs.arm stack.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
$(LN_S) $(srcdir)/check.arm.sh $@
TESTS += $(arm_TESTS)
@@ -212,7 +214,8 @@ swf_TESTS = \
fop_abs.swf fop_sqrt.swf \
varargs.swf stack.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
$(LN_S) $(srcdir)/check.swf.sh $@
TESTS += $(swf_TESTS)
@@ -234,7 +237,8 @@ arm_swf_TESTS =
\
fop_abs.arm.swf fop_sqrt.arm.swf \
varargs.arm.swf stack.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
$(LN_S) $(srcdir)/check.arm.swf.sh $@
TESTS += $(arm_swf_TESTS)
@@ -258,7 +262,7 @@ arm4_swf_TESTS =
\
varargs.arm4.swf stack.arm4.swf \
clobber.arm4.swf carry.arm4.swf call.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
$(LN_S) $(srcdir)/check.arm4.swf.sh $@
TESTS += $(arm4_swf_TESTS)
@@ -284,7 +288,7 @@ nodata_TESTS =
\
varargs.nodata stack.nodata \
clobber.nodata carry.nodata call.nodata \
float.nodata jmpr.nodata tramp.nodata \
- range.nodata
+ range.nodata put.nodata
$(nodata_TESTS): check.nodata.sh
$(LN_S) $(srcdir)/check.nodata.sh $@
TESTS += $(nodata_TESTS)
diff --git a/check/lightning.c b/check/lightning.c
index 81b2671..f1d2c79 100644
--- a/check/lightning.c
+++ b/check/lightning.c
@@ -280,6 +280,7 @@ static void getarg_i(void);
static void getarg_ui(void); static void getarg_l(void);
#endif
static void getarg(void);
+static void putargr(void); static void putargi(void);
static void addr(void); static void addi(void);
static void addxr(void); static void addxi(void);
static void addcr(void); static void addci(void);
@@ -394,8 +395,8 @@ static void retval_ui(void); static void
retval_l(void);
#endif
static void retval(void);
static void epilog(void);
-static void arg_f(void);
-static void getarg_f(void);
+static void arg_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 subr_f(void); static void subi_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 retr_f(void); static void reti_f(void);
static void retval_f(void);
-static void arg_d(void);
-static void getarg_d(void);
+static void arg_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 subr_d(void); static void subi_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),
#endif
entry(getarg),
+ entry(putargr), entry(putargi),
entry(addr), entry(addi),
entry(addxr), entry(addxi),
entry(addcr), entry(addci),
@@ -702,8 +704,8 @@ static instr_t instr_vector[] = {
#endif
entry(retval),
entry(epilog),
- entry(arg_f),
- entry(getarg_f),
+ entry(arg_f), entry(getarg_f),
+ entry(putargr_f), entry(putargi_f),
entry(addr_f), entry(addi_f),
entry(subr_f), entry(subi_f),
entry(rsbr_f), entry(rsbi_f),
@@ -753,8 +755,8 @@ static instr_t instr_vector[] = {
entry(pushargr_f), entry(pushargi_f),
entry(retr_f), entry(reti_f),
entry(retval_f),
- entry(arg_d),
- entry(getarg_d),
+ entry(arg_d), entry(getarg_d),
+ entry(putargr_d), entry(putargi_d),
entry(addr_d), entry(addi_d),
entry(subr_d), entry(subi_d),
entry(rsbr_d), entry(rsbi_d),
@@ -964,6 +966,14 @@ name(void)
\
jit_gpr_t r0 = get_ireg(); \
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) \
static void \
name(void) \
@@ -1091,6 +1101,14 @@ name(void)
\
jit_pointer_t ac = get_arg(); \
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) \
static void \
name(void) \
@@ -1361,6 +1379,7 @@ entry_ia(getarg_i)
entry_ia(getarg_ui) entry_ia(getarg_l)
#endif
entry_ia(getarg)
+entry_ia(putargr) entry_ima(putargi)
entry_ir_ir_ir(addr) entry_ir_ir_im(addi)
entry_ir_ir_ir(addxr) entry_ir_ir_im(addxi)
entry_ir_ir_ir(addcr) entry_ir_ir_im(addci)
@@ -1522,8 +1541,8 @@ entry_ir(retval_ui) entry_ir(retval_l)
#endif
entry_ir(retval)
entry(epilog)
-entry_ca(arg_f)
-entry_fa(getarg_f)
+entry_ca(arg_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(subr_f) entry_fr_fr_fm(subi_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(retr_f) entry_fm(reti_f)
entry_fr(retval_f)
-entry_ca(arg_d)
-entry_fa(getarg_d)
+entry_ca(arg_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(subr_d) entry_fr_fr_dm(subi_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_dm
#undef entry_fr_fr_fr
+#undef entry_fma
#undef entry_fa
#undef entry_pm
#undef entry_lb
@@ -1659,6 +1679,7 @@ entry_fr(retval_d)
#undef entry_ir_ir
#undef entry_ir_ir_im
#undef entry_ir_ir_ir
+#undef entry_ima
#undef entry_ir
#undef entry_im
#undef entry_ia
diff --git a/check/put.ok b/check/put.ok
new file mode 100644
index 0000000..9766475
--- /dev/null
+++ b/check/put.ok
@@ -0,0 +1 @@
+ok
diff --git a/check/put.tst b/check/put.tst
new file mode 100644
index 0000000..a7e39e1
--- /dev/null
+++ b/check/put.tst
@@ -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
diff --git a/include/lightning.h b/include/lightning.h
index 0e8f365..d4e86bc 100644
--- a/include/lightning.h
+++ b/include/lightning.h
@@ -207,6 +207,8 @@ typedef enum {
# 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_putargr(u,v) _jit_putargr(_jit,u,v)
+# define jit_putargi(u,v) _jit_putargi(_jit,u,v)
jit_code_arg,
#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_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,
#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_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,
#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_l(jit_state_t*, jit_gpr_t, jit_node_t*);
#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_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 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_pushargi_f(jit_state_t*, jit_float32_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 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_pushargi_d(jit_state_t*, jit_float64_t);
extern void _jit_retr_d(jit_state_t*, jit_fpr_t);
diff --git a/lib/jit_aarch64.c b/lib/jit_aarch64.c
index 17b2fbe..bdb77e6 100644
--- a/lib/jit_aarch64.c
+++ b/lib/jit_aarch64.c
@@ -306,6 +306,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, JIT_RA0 - v->u.w);
else
@@ -315,6 +316,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, JIT_RA0 - v->u.w);
else
@@ -324,6 +326,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, JIT_RA0 - v->u.w);
else
@@ -333,6 +336,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, JIT_RA0 - v->u.w);
else
@@ -342,6 +346,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_i(u, JIT_RA0 - v->u.w);
else
@@ -351,6 +356,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_ui(u, JIT_RA0 - v->u.w);
else
@@ -360,6 +366,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, JIT_RA0 - v->u.w);
else
@@ -367,8 +374,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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)
jit_movr_f(u, JIT_FA0 - v->u.w);
else
@@ -376,8 +409,34 @@ _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(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
_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)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
@@ -385,6 +444,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_alpha.c b/lib/jit_alpha.c
index d266a70..83b7651 100644
--- a/lib/jit_alpha.c
+++ b/lib/jit_alpha.c
@@ -304,6 +304,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, _A0 - v->u.w);
else {
@@ -318,6 +319,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, _A0 - v->u.w);
else {
@@ -332,6 +334,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _A0 - v->u.w);
else {
@@ -346,6 +349,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _A0 - v->u.w);
else {
@@ -360,6 +364,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_i(u, _A0 - v->u.w);
else {
@@ -374,6 +379,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_ui(u, _A0 - v->u.w);
else {
@@ -388,6 +394,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _A0 - v->u.w);
else
@@ -395,8 +402,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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)
jit_movr_f(u, _F16 - v->u.w);
else {
@@ -409,8 +442,43 @@ _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
_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)
jit_movr_d(u, _F16 - v->u.w);
else
@@ -418,6 +486,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function != NULL);
diff --git a/lib/jit_arm.c b/lib/jit_arm.c
index a77ee93..4c42ff9 100644
--- a/lib/jit_arm.c
+++ b/lib/jit_arm.c
@@ -452,6 +452,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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())
jit_ldxi_c(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
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
_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())
jit_ldxi_uc(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
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
_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())
jit_ldxi_s(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
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
_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())
jit_ldxi_us(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
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
_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())
jit_ldxi_i(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
else if (v->u.w < 4)
@@ -505,8 +510,42 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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 (v->u.w < 16)
jit_movr_f(u, JIT_FA0 - v->u.w);
@@ -524,8 +563,61 @@ _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
_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 (v->u.w < 16)
jit_movr_d(u, JIT_FA0 - v->u.w);
@@ -543,6 +635,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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_hppa.c b/lib/jit_hppa.c
index 54d3bdd..9bc9ddb 100644
--- a/lib/jit_hppa.c
+++ b/lib/jit_hppa.c
@@ -316,6 +316,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, _R26 - v->u.w);
else
@@ -325,6 +326,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, _R26 - v->u.w);
else
@@ -334,6 +336,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _R26 - v->u.w);
else
@@ -343,6 +346,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _R26 - v->u.w);
else
@@ -352,6 +356,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _R26 - v->u.w);
else
@@ -359,8 +364,34 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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)
jit_movr_f(u, _F4 - v->u.w);
else
@@ -368,8 +399,34 @@ _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 >= 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
_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)
jit_movr_d(u, _F4 - v->u.w);
else
@@ -377,6 +434,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_ia64.c b/lib/jit_ia64.c
index 6949355..d898598 100644
--- a/lib/jit_ia64.c
+++ b/lib/jit_ia64.c
@@ -404,6 +404,7 @@ _jit_arg_d(jit_state_t *_jit)
void
_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) {
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
_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)
jit_extr_uc(u, _R32 + v->u.w);
else {
@@ -435,6 +437,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _R32 + v->u.w);
else {
@@ -450,6 +453,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _R32 + v->u.w);
else {
@@ -465,6 +469,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_i(u, _R32 + v->u.w);
else {
@@ -480,6 +485,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_ui(u, _R32 + v->u.w);
else {
@@ -495,6 +501,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _R32 + v->u.w);
else
@@ -502,8 +509,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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)
jit_movr_f(u, _F8 + v->u.w);
else {
@@ -517,8 +550,43 @@ _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
_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)
jit_movr_d(u, _F8 + v->u.w);
else
@@ -526,6 +594,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_mips.c b/lib/jit_mips.c
index 19170df..e95316a 100644
--- a/lib/jit_mips.c
+++ b/lib/jit_mips.c
@@ -379,6 +379,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, _A0 - v->u.w);
else {
@@ -393,6 +394,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, _A0 - v->u.w);
else {
@@ -407,6 +409,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _A0 - v->u.w);
else {
@@ -421,6 +424,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _A0 - v->u.w);
else {
@@ -435,6 +439,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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 __WORDSIZE == 64
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
_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)
jit_extr_ui(u, _A0 - v->u.w);
else {
@@ -469,6 +475,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _A0 - v->u.w);
else
@@ -477,8 +484,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
#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
_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 (v->u.w < NUM_WORD_ARGS)
jit_movr_f(u, _F12 - v->u.w);
@@ -493,8 +526,52 @@ _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 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
_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 (v->u.w < NUM_WORD_ARGS)
jit_movr_d(u, _F12 - v->u.w);
@@ -509,6 +586,49 @@ _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 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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
#if NEW_ABI
diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c
index d3df78c..bb77336 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_ppc.c
@@ -285,6 +285,13 @@ _jit_arg_f(jit_state_t *_jit)
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
+ }
_jitc->function->self.size += sizeof(jit_word_t);
return (jit_new_node_w(jit_code_arg_f, offset));
}
@@ -304,6 +311,13 @@ _jit_arg_d(jit_state_t *_jit)
offset = _jitc->function->self.argf++;
else
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);
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
_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)
jit_extr_c(u, JIT_RA0 - v->u.w);
else {
@@ -332,6 +347,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, JIT_RA0 - v->u.w);
else {
@@ -347,6 +363,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, JIT_RA0 - v->u.w);
else {
@@ -362,6 +379,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, JIT_RA0 - v->u.w);
else {
@@ -377,6 +395,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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 __WORDSIZE == 32
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
_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)
jit_extr_ui(u, JIT_RA0 - v->u.w);
else {
@@ -413,6 +433,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, JIT_RA0 - v->u.w);
else
@@ -421,8 +442,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
#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
_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)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
@@ -430,8 +477,34 @@ _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 < 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
_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)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
@@ -439,6 +512,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_s390.c b/lib/jit_s390.c
index d3d3f06..b60af9b 100644
--- a/lib/jit_s390.c
+++ b/lib/jit_s390.c
@@ -283,6 +283,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, _R2 - v->u.w);
else
@@ -293,6 +294,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, _R2 - v->u.w);
else
@@ -303,6 +305,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _R2 - v->u.w);
else
@@ -313,6 +316,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _R2 - v->u.w);
else
@@ -323,6 +327,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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 __WORDSIZE == 32
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
_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)
jit_extr_ui(u, _R2 - v->u.w);
else
@@ -349,6 +355,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _R2 - v->u.w);
else
@@ -357,8 +364,34 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
#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
_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)
jit_movr_f(u, _F0 - v->u.w);
else
@@ -371,8 +404,42 @@ _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
_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)
jit_movr_d(u, _F0 - v->u.w);
else
@@ -380,6 +447,31 @@ _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 (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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
diff --git a/lib/jit_sparc.c b/lib/jit_sparc.c
index 47da7cc..1f3581b 100644
--- a/lib/jit_sparc.c
+++ b/lib/jit_sparc.c
@@ -294,6 +294,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_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)
jit_extr_c(u, _I0 + v->u.w);
else {
@@ -306,6 +307,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_uc(u, _I0 + v->u.w);
else {
@@ -318,6 +320,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_s(u, _I0 + v->u.w);
else {
@@ -330,6 +333,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_extr_us(u, _I0 + v->u.w);
else {
@@ -342,6 +346,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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)
jit_movr(u, _I0 + v->u.w);
else
@@ -349,8 +354,34 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
}
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
_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);
if (v->u.w < 6) {
jit_stxi(-4, JIT_FP, _I0 + v->u.w);
@@ -361,8 +392,37 @@ _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_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
_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);
if (v->u.w < 5) {
jit_stxi(-8, JIT_FP, _I0 + v->u.w);
@@ -381,6 +441,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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
if (_jitc->function->call.argi < 6) {
diff --git a/lib/jit_x86.c b/lib/jit_x86.c
index d06d560..4f75ede 100644
--- a/lib/jit_x86.c
+++ b/lib/jit_x86.c
@@ -577,6 +577,7 @@ _jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
void
_jit_getarg_c(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_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
_jit_getarg_uc(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_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
_jit_getarg_s(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_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
_jit_getarg_us(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_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
_jit_getarg_i(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)) {
# if __X64_32
@@ -638,6 +643,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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))
jit_extr_ui(u, JIT_RA0 - v->u.w);
else
@@ -647,6 +653,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
void
_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))
jit_movr(u, JIT_RA0 - v->u.w);
else
@@ -655,8 +662,39 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t
*v)
#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
_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 (jit_arg_f_reg_p(v->u.w))
jit_movr_f(u, _XMM0 - v->u.w);
@@ -666,8 +704,39 @@ _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 __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
_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 (jit_arg_f_reg_p(v->u.w))
jit_movr_d(u, _XMM0 - v->u.w);
@@ -677,6 +746,36 @@ _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 __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
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function);
- [Guile-commits] 126/437: Cleanup on preparation for lightning rework., (continued)
- [Guile-commits] 126/437: Cleanup on preparation for lightning rework., Andy Wingo, 2018/07/02
- [Guile-commits] 364/437: GNU lightning 2.1.0 release, Andy Wingo, 2018/07/02
- [Guile-commits] 242/437: Add missing jit_clear_state to documentation sample., Andy Wingo, 2018/07/02
- [Guile-commits] 417/437: HPPA: Correct wrong regarg_p check, Andy Wingo, 2018/07/02
- [Guile-commits] 333/437: Implement jit_flush, Andy Wingo, 2018/07/02
- [Guile-commits] 316/437: Implement the jit_rsb* interface., Andy Wingo, 2018/07/02
- [Guile-commits] 358/437: Add new --enable-devel-disassembler configure option, Andy Wingo, 2018/07/02
- [Guile-commits] 262/437: Rerun tests on supported backends after bogus self test correction, Andy Wingo, 2018/07/02
- [Guile-commits] 399/437: mips: Pass tests for variadic jit functions on new abi, Andy Wingo, 2018/07/02
- [Guile-commits] 408/437: GNU lightning 2.1.1 release, Andy Wingo, 2018/07/02
- [Guile-commits] 349/437: Implement jit_putarg*,
Andy Wingo <=
- [Guile-commits] 120/437: Change _ASM_SAFETY register width check to accept valid alternate values., Andy Wingo, 2018/07/02
- [Guile-commits] 393/437: Intermediate, fully functional, rework for variadic functions, Andy Wingo, 2018/07/02
- [Guile-commits] 361/437: Correct the reason the simplify_stxi bug was not noticed before, Andy Wingo, 2018/07/02
- [Guile-commits] 356/437: ARM: Do not limit to 24 bit displacement jump to unknown address, Andy Wingo, 2018/07/02
- [Guile-commits] 422/437: Remove lightning unit tests, Andy Wingo, 2018/07/02
- [Guile-commits] 226/437: New aarch64 port built on the Foundation v8 emulator., Andy Wingo, 2018/07/02
- [Guile-commits] 128/437: Big merge with new lightning semantics aiming for lightning 2.0., Andy Wingo, 2018/07/02
- [Guile-commits] 132/437: Add extra files implementing different jit backends., Andy Wingo, 2018/07/02
- [Guile-commits] 433/437: Remove unused configure-time checks for x87, thumb, and sof float, Andy Wingo, 2018/07/02
- [Guile-commits] 283/437: Correct crash on arm in the doc/printf example., Andy Wingo, 2018/07/02