diff --git a/ChangeLog b/ChangeLog
index 780a74f43..3c131090e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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>
 
 	* include/lightning/jit_s390.h, lib/jit_s390-cpu.c,
diff --git a/check/Makefile.am b/check/Makefile.am
index 653742be6..c29571184 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 81b2671dc..f1d2c79c8 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 000000000..9766475a4
--- /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 000000000..a7e39e1c7
--- /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 0e8f3659c..d4e86bc6b 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 17b2fbe0f..bdb77e65b 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,30 +366,108 @@ _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
 	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
 _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
 	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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_alpha.c b/lib/jit_alpha.c
index d266a7066..83b76511f 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,15 +394,42 @@ _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
 	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
 _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 {
@@ -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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_arm.c b/lib/jit_arm.c
index a77ee93db..4c42ff920 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)
@@ -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);
 }
 
+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);
@@ -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
 _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);
@@ -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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_hppa.c b/lib/jit_hppa.c
index 54d3bddb8..9bc9ddb8a 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,30 +356,108 @@ _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
 	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
 _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
 	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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_ia64.c b/lib/jit_ia64.c
index 6949355f3..d898598cb 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,15 +501,42 @@ _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
 	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
 _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 {
@@ -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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_mips.c b/lib/jit_mips.c
index 19170df6b..e95316aa7 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
@@ -476,9 +483,35 @@ _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);
@@ -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);
 }
 
+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);
@@ -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);
 }
 
+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)
 {
diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c
index d3df78c98..bb7733637 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_ppc.c
@@ -283,6 +283,13 @@ _jit_arg_f(jit_state_t *_jit)
 	offset = _jitc->function->self.size;
 #else
 	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);
@@ -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
@@ -420,24 +441,101 @@ _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
 	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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_s390.c b/lib/jit_s390.c
index d3d3f0641..b60af9bd8 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
@@ -356,9 +363,35 @@ _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
@@ -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
 _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
 	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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_sparc.c b/lib/jit_sparc.c
index 47da7cc99..1f3581bc7 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,15 +346,42 @@ _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
 	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
 _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);
@@ -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);
 }
 
+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);
@@ -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
 _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 {
diff --git a/lib/jit_x86.c b/lib/jit_x86.c
index d06d560ed..4f75edeca 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
@@ -654,9 +661,40 @@ _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);
@@ -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);
 }
 
+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);
@@ -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);
 }
 
+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)
 {