diff --git a/ChangeLog b/ChangeLog
index a4e89ad41..2ec26e19d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2012-12-28 Paulo Andrade <pcpa@gnu.org>
+
+	* check/lightning.c, include/lightning.h, lib/jit_arm.c,
+	lib/jit_mips.c, lib/jit_ppc.c, lib/jit_print.c,	lib/jit_x86.c,
+	lib/lightning.c: Change return value of jit_arg{,_f,_d} to
+	a jit_node_t* object, that should be used as argument to
+	jit_getarg_{c,uc,s,us,i,ui,l,f,d}. This just requires changing
+	from jit_int32_t to jit_pointer_t (or jit_node_t*) the "handle"
+	for the getarg calls, with the benefit that it makes it easy
+	to implement patching of the stack address of non register
+	arguments, this way allowing to implement variable size stack
+	frames if applicable; useful if there are too many registers and
+	jit functions uses only a few callee save registers.
+
 2012-12-27 Paulo Andrade <pcpa@gnu.org>
 
 	* lib/jit_arm.c, lib/jit_mips-cpu.c, lib/jit_mips.c: Correct
diff --git a/check/lightning.c b/check/lightning.c
index 665fcd1c8..4c05ba7c8 100644
--- a/check/lightning.c
+++ b/check/lightning.c
@@ -239,8 +239,8 @@ static symbol_t *get_symbol(void);
 static void jmp_forward(void *value, label_t *label);
 static void mov_forward(void *value, label_t *label);
 static void call_forward(void *value, label_t *label);
-static void make_arg(long value);
-static long get_arg(void);
+static void make_arg(void *value);
+static jit_pointer_t get_arg(void);
 static long get_imm(void);
 static void prolog(void);	static void ellipsis(void);
 static void allocai(void);
@@ -812,23 +812,23 @@ call_forward(void *value, label_t *label)
 }
 
 static void
-make_arg(long value)
+make_arg(void *value)
 {
     symbol_t	*symbol = get_symbol();
 
-    symbol->type = type_l;
-    symbol->value.i = value;
+    symbol->type = type_p;
+    symbol->value.p = value;
 }
 
-static long
+static jit_pointer_t
 get_arg(void)
 {
     symbol_t	*symbol = get_symbol();
 
-    if (symbol->type != type_l)
+    if (symbol->type != type_p)
 	error("bad argument %s type", symbol->name);
 
-    return symbol->value.i;
+    return symbol->value.p;
 }
 
 static long
@@ -885,8 +885,8 @@ name(void)								\
 static void								\
 name(void)								\
 {									\
-    jit_gpr_t	r0 = get_ireg();					\
-    jit_int32_t	ac = get_arg();						\
+    jit_gpr_t		r0 = get_ireg();				\
+    jit_pointer_t	ac = get_arg();					\
     jit_##name(r0, ac);							\
 }
 #define entry_im(name)							\
@@ -1010,8 +1010,8 @@ name(void)								\
 static void								\
 name(void)								\
 {									\
-    jit_fpr_t	r0 = get_freg();					\
-    jit_int32_t	ac = get_arg();						\
+    jit_fpr_t		r0 = get_freg();				\
+    jit_pointer_t	ac = get_arg();					\
     jit_##name(r0, ac);							\
 }
 #define entry_fr_fr_fr(name)						\
diff --git a/include/lightning.h b/include/lightning.h
index 35fcfa758..e992c6d62 100644
--- a/include/lightning.h
+++ b/include/lightning.h
@@ -127,6 +127,7 @@ 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
+    jit_code_arg,
 
 #define jit_addr(u,v,w)		jit_new_node_www(jit_code_addr,u,v,w)
 #define jit_addi(u,v,w)		jit_new_node_www(jit_code_addi,u,v,w)
@@ -431,7 +432,7 @@ typedef enum {
 
 #define jit_arg_f()		_jit_arg_f(_jit)
 #define jit_getarg_f(u,v)	_jit_getarg_f(_jit,u,v)
-    jit_code_getarg_f,
+    jit_code_arg_f,		jit_code_getarg_f,
 
 #define jit_addr_f(u,v,w)	jit_new_node_www(jit_code_addr_f,u,v,w)
 #define jit_addi_f(u,v,w)	jit_new_node_wwf(jit_code_addi_f,u,v,w)
@@ -575,7 +576,7 @@ typedef enum {
 
 #define jit_arg_d()		_jit_arg_d(_jit)
 #define jit_getarg_d(u,v)	_jit_getarg_d(_jit,u,v)
-    jit_code_getarg_d,
+    jit_code_arg_d,		jit_code_getarg_d,
 
 #define jit_addr_d(u,v,w)	jit_new_node_www(jit_code_addr_d,u,v,w)
 #define jit_addi_d(u,v,w)	jit_new_node_wwd(jit_code_addi_d,u,v,w)
@@ -739,15 +740,15 @@ extern void _jit_prolog(jit_state_t*);
 extern jit_int32_t _jit_allocai(jit_state_t*, jit_int32_t);
 extern void _jit_ellipsis(jit_state_t*);
 
-extern jit_int32_t _jit_arg(jit_state_t*);
-extern void _jit_getarg_c(jit_state_t*, jit_gpr_t, jit_int32_t);
-extern void _jit_getarg_uc(jit_state_t*, jit_gpr_t, jit_int32_t);
-extern void _jit_getarg_s(jit_state_t*, jit_gpr_t, jit_int32_t);
-extern void _jit_getarg_us(jit_state_t*, jit_gpr_t, jit_int32_t);
-extern void _jit_getarg_i(jit_state_t*, jit_gpr_t, jit_int32_t);
+extern jit_node_t *_jit_arg(jit_state_t*);
+extern void _jit_getarg_c(jit_state_t*, jit_gpr_t, jit_node_t*);
+extern void _jit_getarg_uc(jit_state_t*, jit_gpr_t, jit_node_t*);
+extern void _jit_getarg_s(jit_state_t*, jit_gpr_t, jit_node_t*);
+extern void _jit_getarg_us(jit_state_t*, jit_gpr_t, jit_node_t*);
+extern void _jit_getarg_i(jit_state_t*, jit_gpr_t, jit_node_t*);
 #if __WORDSIZE == 64
-extern void _jit_getarg_ui(jit_state_t*, jit_gpr_t, jit_int32_t);
-extern void _jit_getarg_l(jit_state_t*, jit_gpr_t, jit_int32_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_prepare(jit_state_t*);
@@ -782,18 +783,16 @@ extern jit_pointer_t _jit_emit(jit_state_t*);
 #define jit_print()		_jit_print(_jit)
 extern void _jit_print(jit_state_t*);
 
-extern jit_int32_t _jit_arg_f(jit_state_t*);
-extern void _jit_getarg_f(jit_state_t*, jit_fpr_t, jit_int32_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_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);
 extern void _jit_reti_f(jit_state_t*, jit_float32_t);
 extern void _jit_retval_f(jit_state_t*, jit_fpr_t);
 
-extern jit_int32_t _jit_arg_d(jit_state_t*);
-extern void _jit_getarg_d(jit_state_t*, jit_fpr_t, jit_int32_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_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_arm.c b/lib/jit_arm.c
index 1b3bd8c23..ed933a2f3 100644
--- a/lib/jit_arm.c
+++ b/lib/jit_arm.c
@@ -327,7 +327,7 @@ _jit_epilog(jit_state_t *_jit)
     _jit->function = NULL;
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -339,7 +339,7 @@ _jit_arg(jit_state_t *_jit)
 	offset = _jit->function->self.size;
 	_jit->function->self.size += sizeof(jit_word_t);
     }
-    return (offset);
+    return (jit_new_node_w(jit_code_arg, offset));
 }
 
 jit_bool_t
@@ -348,10 +348,12 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (offset >= 0 && offset < 4);
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_int32_t		offset;
+
+    assert(_jit->function);
     if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) {
 	if (_jit->function->self.argf < 16)
 	    offset = _jit->function->self.argf++;
@@ -360,9 +362,15 @@ _jit_arg_f(jit_state_t *_jit)
 	    _jit->function->self.size += sizeof(jit_word_t);
 	}
     }
-    else
-	offset = _jit_arg(_jit);
-    return (offset);
+    else {
+	if (_jit->function->self.argi < 4)
+	    offset = _jit->function->self.argi++;
+	else {
+	    offset = _jit->function->self.size;
+	    _jit->function->self.size += sizeof(jit_float32_t);
+	}
+    }
+    return (jit_new_node_w(jit_code_arg_f, offset));
 }
 
 jit_bool_t
@@ -371,17 +379,19 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (jit_arg_reg_p(offset));
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_int32_t		offset;
+
+    assert(_jit->function);
     if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) {
 	if (_jit->function->self.argf < 15) {
 	    if (_jit->function->self.argf & 1)
 		++_jit->function->self.argf;
 	    offset = _jit->function->self.argf;
 	    _jit->function->self.argf += 2;
-	    return (offset);
+	    goto done;
 	}
     }
     else {
@@ -390,14 +400,15 @@ _jit_arg_d(jit_state_t *_jit)
 		++_jit->function->self.argi;
 	    offset = _jit->function->self.argi;
 	    _jit->function->self.argi += 2;
-	    return (offset);
+	    goto done;
 	}
     }
     if (_jit->function->self.size & 7)
 	_jit->function->self.size += 4;
     offset = _jit->function->self.size;
     _jit->function->self.size += sizeof(jit_float64_t);
-    return (offset);
+done:
+    return (jit_new_node_w(jit_code_arg_d, offset));
 }
 
 jit_bool_t
@@ -407,116 +418,95 @@ _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_int32_t v)
+_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_c(u, JIT_FP, v);
-    }
-    else if (v < 4)
-	jit_extr_c(u, JIT_RA0 - v);
+    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)
+	jit_extr_c(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_c(u, JIT_FP, v);
+	jit_ldxi_c(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_uc(u, JIT_FP, v);
-    }
-    else if (v < 4)
-	jit_extr_uc(u, JIT_RA0 - v);
+    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)
+	jit_extr_uc(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_uc(u, JIT_FP, v);
+	jit_ldxi_uc(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_s(u, JIT_FP, v);
-    }
-    else if (v < 4)
-	jit_extr_s(u, JIT_RA0 - v);
+    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)
+	jit_extr_s(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_s(u, JIT_FP, v);
+	jit_ldxi_s(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_us(u, JIT_FP, v);
-    }
-    else if (v < 4)
-	jit_extr_us(u, JIT_RA0 - v);
+    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)
+	jit_extr_us(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_us(u, JIT_FP, v);
+	jit_ldxi_us(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_i(u, JIT_FP, v);
-    }
-    else if (v < 4)
-	jit_movr(u, JIT_RA0 - v);
+    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)
+	jit_movr(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_i(u, JIT_FP, v);
+	jit_ldxi_i(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
     if (jit_cpu.abi) {
-	if (v < 16)
-	    jit_movr_f(u, JIT_FA0 - v);
+	if (v->u.w < 16)
+	    jit_movr_f(u, JIT_FA0 - v->u.w);
 	else
-	    jit_ldxi_f(u, JIT_FP, v);
-    }
-    else if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_f(u, JIT_FP, v);
+	    jit_ldxi_f(u, JIT_FP, v->u.w);
     }
+    else if (jit_swf_p())
+	jit_ldxi_f(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
     else {
-	if (v < 4)
-	    jit_movr_f(u, JIT_RA0 - v);
+	if (v->u.w < 4)
+	    jit_movr_f(u, JIT_RA0 - v->u.w);
 	else
-	    jit_ldxi_f(u, JIT_FP, v);
+	    jit_ldxi_f(u, JIT_FP, v->u.w);
     }
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
     if (jit_cpu.abi) {
-	if (v < 16)
-	    jit_movr_d(u, JIT_FA0 - v);
+	if (v->u.w < 16)
+	    jit_movr_d(u, JIT_FA0 - v->u.w);
 	else
-	    jit_ldxi_d(u, JIT_FP, v);
-    }
-    else if (jit_swf_p()) {
-	if (v < 4)
-	    v <<= 2;
-	jit_ldxi_d(u, JIT_FP, v);
+	    jit_ldxi_d(u, JIT_FP, v->u.w);
     }
+    else if (jit_swf_p())
+	jit_ldxi_d(u, JIT_FP, v->u.w < 4 ? v->u.w << 2 : v->u.w);
     else {
-	if (v < 4)
-	    jit_movr_d(u, JIT_RA0 - v);
+	if (v->u.w < 4)
+	    jit_movr_d(u, JIT_RA0 - v->u.w);
 	else
-	    jit_ldxi_d(u, JIT_FP, v);
+	    jit_ldxi_d(u, JIT_FP, v->u.w);
     }
 }
 
@@ -1420,6 +1410,9 @@ _jit_emit(jit_state_t *_jit)
 		_jit->function = NULL;
 		flush_consts();
 		break;
+	    case jit_code_arg:
+	    case jit_code_arg_f:		case jit_code_arg_d:
+		break;
 	    default:
 		abort();
 	}
diff --git a/lib/jit_mips.c b/lib/jit_mips.c
index 80ac40d1a..5f85f190f 100644
--- a/lib/jit_mips.c
+++ b/lib/jit_mips.c
@@ -229,7 +229,7 @@ _jit_epilog(jit_state_t *_jit)
     _jit->function = NULL;
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -244,7 +244,7 @@ _jit_arg(jit_state_t *_jit)
     else
 	offset = _jit->function->self.size;
     _jit->function->self.size += sizeof(jit_word_t);
-    return (offset);
+    return (jit_new_node_w(jit_code_arg, offset));
 }
 
 jit_bool_t
@@ -253,7 +253,7 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (offset >= 0 && offset < 4);
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -278,7 +278,7 @@ _jit_arg_f(jit_state_t *_jit)
     else
 	offset = _jit->function->self.size;
     _jit->function->self.size += sizeof(jit_float32_t);
-    return (offset);
+    return (jit_new_node_w(jit_code_arg_f, offset));
 }
 
 jit_bool_t
@@ -288,7 +288,7 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (offset >= 0 && offset < 8);
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -313,7 +313,7 @@ _jit_arg_d(jit_state_t *_jit)
     else
 	offset = _jit->function->self.size;
     _jit->function->self.size += sizeof(jit_float64_t);
-    return (offset);
+    return (jit_new_node_w(jit_code_arg_d, offset));
 }
 
 jit_bool_t
@@ -323,95 +323,95 @@ _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_int32_t v)
+_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_extr_c(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_extr_c(u, _A0 - v->u.w);
     else
-	jit_ldxi_c(u, _FP, v);
+	jit_ldxi_c(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_extr_uc(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_extr_uc(u, _A0 - v->u.w);
     else
-	jit_ldxi_uc(u, _FP, v);
+	jit_ldxi_uc(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_extr_s(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_extr_s(u, _A0 - v->u.w);
     else
-	jit_ldxi_s(u, _FP, v);
+	jit_ldxi_s(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_extr_us(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_extr_us(u, _A0 - v->u.w);
     else
-	jit_ldxi_us(u, _FP, v);
+	jit_ldxi_us(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4) {
+    if (v->u.w < 4) {
 #if __WORDSIZE == 64
-	jit_extr_i(u, _A0 - v);
+	jit_extr_i(u, _A0 - v->u.w);
 #else
-	jit_movr(u, _A0 - v);
+	jit_movr(u, _A0 - v->u.w);
 #endif
     }
     else
-	jit_ldxi_i(u, _FP, v);
+	jit_ldxi_i(u, _FP, v->u.w);
 }
 
 #if __WORDSIZE == 64
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_extr_ui(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_extr_ui(u, _A0 - v->u.w);
     else
-	jit_ldxi_ui(u, _FP, v);
+	jit_ldxi_ui(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_movr(u, _A0 - v);
+    if (v->u.w < 4)
+	jit_movr(u, _A0 - v->u.w);
     else
-	jit_ldxi_l(u, _FP, v);
+	jit_ldxi_l(u, _FP, v->u.w);
 }
 #endif
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_new_node_ww(jit_code_getarg_f, u, _A0 - v);
-    else if (v < 8)
-	jit_movr_f(u, _F12 - ((v - 4) >> 1));
+    if (v->u.w < 4)
+	jit_new_node_ww(jit_code_getarg_f, u, _A0 - v->u.w);
+    else if (v->u.w < 8)
+	jit_movr_f(u, _F12 - ((v->u.w - 4) >> 1));
     else
-	jit_ldxi_f(u, _FP, v);
+	jit_ldxi_f(u, _FP, v->u.w);
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 4)
-	jit_new_node_ww(jit_code_getarg_d, u, _A0 - v);
-    else if (v < 8)
-	jit_movr_d(u, _F12 - ((v - 4) >> 1));
+    if (v->u.w < 4)
+	jit_new_node_ww(jit_code_getarg_d, u, _A0 - v->u.w);
+    else if (v->u.w < 8)
+	jit_movr_d(u, _F12 - ((v->u.w - 4) >> 1));
     else
-	jit_ldxi_d(u, _FP, v);
+	jit_ldxi_d(u, _FP, v->u.w);
 }
 
 void
@@ -1232,6 +1232,9 @@ _jit_emit(jit_state_t *_jit)
 		assert(node->flag & jit_flag_data);
 		pushargi_d(rn(node->u.w), (jit_float64_t *)node->v.n->u.w);
 		break;
+	    case jit_code_arg:
+	    case jit_code_arg_f:		case jit_code_arg_d:
+		break;
 	    default:
 		abort();
 	}
diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c
index 736b4d852..db0529c11 100644
--- a/lib/jit_ppc.c
+++ b/lib/jit_ppc.c
@@ -235,16 +235,18 @@ _jit_epilog(jit_state_t *_jit)
     _jit->function = NULL;
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_int32_t		offset;
     assert(_jit->function);
     if (_jit->function->self.argi < 8)
-	return (_jit->function->self.argi++);
-    offset = _jit->function->self.size;
-    _jit->function->self.size += sizeof(jit_word_t);
-    return (offset);
+	offset = _jit->function->self.argi++;
+    else {
+	offset = _jit->function->self.size;
+	_jit->function->self.size += sizeof(jit_word_t);
+    }
+    return (jit_new_node_w(jit_code_arg, offset));
 }
 
 jit_bool_t
@@ -253,10 +255,18 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (offset >= 0 && offset < 8);
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
-    return (jit_arg_d());
+    jit_int32_t		offset;
+    assert(_jit->function);
+    if (_jit->function->self.argf < 8)
+	offset = _jit->function->self.argf++;
+    else {
+	offset = _jit->function->self.size;
+	_jit->function->self.size += sizeof(jit_float64_t);
+    }
+    return (jit_new_node_w(jit_code_arg_f, offset));
 }
 
 jit_bool_t
@@ -265,16 +275,18 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
     return (jit_arg_d_reg_p(offset));
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_int32_t		offset;
     assert(_jit->function);
     if (_jit->function->self.argf < 8)
-	return (_jit->function->self.argf++);
-    offset = _jit->function->self.size;
-    _jit->function->self.size += sizeof(jit_float64_t);
-    return (offset);
+	offset = _jit->function->self.argf++;
+    else {
+	offset = _jit->function->self.size;
+	_jit->function->self.size += sizeof(jit_float64_t);
+    }
+    return (jit_new_node_w(jit_code_arg_d, offset));
 }
 
 jit_bool_t
@@ -284,83 +296,83 @@ _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_int32_t v)
+_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_extr_c(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_extr_c(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_c(u, JIT_FP, v);
+	jit_ldxi_c(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_extr_uc(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_extr_uc(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_uc(u, JIT_FP, v);
+	jit_ldxi_uc(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_extr_s(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_extr_s(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_s(u, JIT_FP, v);
+	jit_ldxi_s(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_extr_us(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_extr_us(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_us(u, JIT_FP, v);
+	jit_ldxi_us(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_movr(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_movr(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_i(u, JIT_FP, v);
+	jit_ldxi_i(u, JIT_FP, v->u.w);
 }
 
 #if __WORDSIZE == 64
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_extr_ui(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_extr_ui(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_ui(u, JIT_FP, v);
+	jit_ldxi_ui(u, JIT_FP, v->u.w);
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_movr(u, JIT_RA0 - v);
+    if (v->u.w < 8)
+	jit_movr(u, JIT_RA0 - v->u.w);
     else
-	jit_ldxi_l(u, JIT_FP, v);
+	jit_ldxi_l(u, JIT_FP, v->u.w);
 }
 #endif
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
     jit_getarg_d(u, v);
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 8)
-	jit_movr_d(u, JIT_FA0 - v);
+    if (v->u.w < 8)
+	jit_movr_d(u, JIT_FA0 - v->u.w);
     else
-	jit_ldxi_d(u, JIT_FP, v);
+	jit_ldxi_d(u, JIT_FP, v->u.w);
 }
 
 void
@@ -1046,7 +1058,7 @@ _jit_emit(jit_state_t *_jit)
 		    temp = node->u.n;
 		    assert(temp->code == jit_code_label ||
 			   temp->code == jit_code_epilog);
-		    word = calli(temp->u.w);
+		    word = calli_p(temp->u.w);
 		    if (!(temp->flag & jit_flag_patch))
 			patch(word, node);
 		}
@@ -1082,6 +1094,9 @@ _jit_emit(jit_state_t *_jit)
 		epilog(node);
 		_jit->function = NULL;
 		break;
+	    case jit_code_arg:
+	    case jit_code_arg_f:		case jit_code_arg_d:
+		break;
 	    default:
 		abort();
 	}
diff --git a/lib/jit_print.c b/lib/jit_print.c
index e05e3535a..f5d3316bb 100644
--- a/lib/jit_print.c
+++ b/lib/jit_print.c
@@ -40,6 +40,7 @@ static char *code_name[] = {
     "#note",
     "label",
     "prolog",
+    "arg",
     "addr",		"addi",
     "addcr",		"addci",
     "addxr",		"addxi",
@@ -118,7 +119,7 @@ static char *code_name[] = {
     "jmpr",		"jmpi",
     "callr",		"calli",
     "epilog",
-    "getarg_f",
+    "arg_f",		"getarg_f",
     "addr_f",		"addi_f",
     "subr_f",		"subi_f",
     "mulr_f",		"muli_f",
@@ -162,7 +163,7 @@ static char *code_name[] = {
     "bunordr_f",	"bunordi_f",
     "pushargr_f",	"pushargi_f",
     "retval_f",
-    "getarg_d",
+    "arg_d",		"getarg_d",
     "addr_d",		"addi_d",
     "subr_d",		"subi_d",
     "mulr_d",		"muli_d",
@@ -258,6 +259,8 @@ _jit_print(jit_state_t *_jit)
 	switch (node->code) {
 	r:
 	    print_chr(' ');		print_reg(node->u.w);	continue;
+	w:
+	    print_chr(' ');		print_hex(node->u.w);	continue;
 	n:
 	    print_chr(' ');
 	    if (!(node->flag & jit_flag_node))
@@ -391,6 +394,8 @@ _jit_print(jit_state_t *_jit)
 		    case jit_cc_a0_reg|jit_cc_a0_chg:
 		    case jit_cc_a0_reg|jit_cc_a0_jmp:
 			goto r;
+		    case jit_cc_a0_int:
+			goto w;
 		    case jit_cc_a0_jmp:
 			goto n;
 		    case jit_cc_a0_reg|jit_cc_a1_reg:
diff --git a/lib/jit_x86.c b/lib/jit_x86.c
index dad35c432..7104edbfa 100644
--- a/lib/jit_x86.c
+++ b/lib/jit_x86.c
@@ -407,7 +407,7 @@ _jit_epilog(jit_state_t *_jit)
     _jit->function = NULL;
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -415,11 +415,14 @@ _jit_arg(jit_state_t *_jit)
     assert(_jit->function);
 #if __WORDSIZE == 64
     if (_jit->function->self.argi < 6)
-	return (_jit->function->self.argi++);
+	offset = _jit->function->self.argi++;
+    else
 #endif
-    offset = _jit->function->self.size;
-    _jit->function->self.size += sizeof(jit_word_t);
-    return (offset);
+    {
+	offset = _jit->function->self.size;
+	_jit->function->self.size += sizeof(jit_word_t);
+    }
+    return (jit_new_node_w(jit_code_arg, offset));
 }
 
 jit_bool_t
@@ -432,7 +435,7 @@ _jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
 #endif
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_int32_t		offset;
@@ -440,15 +443,18 @@ _jit_arg_f(jit_state_t *_jit)
     assert(_jit->function);
 #if __WORDSIZE == 64
     if (_jit->function->self.argf < 8)
-	return (_jit->function->self.argf++);
+	offset = _jit->function->self.argf++;
+    else
 #endif
-    offset = _jit->function->self.size;
+    {
+	offset = _jit->function->self.size;
 #if __WORDSIZE == 32
-    _jit->function->self.size += sizeof(jit_float32_t);
+	_jit->function->self.size += sizeof(jit_float32_t);
 #else
-    _jit->function->self.size += sizeof(jit_float64_t);
+	_jit->function->self.size += sizeof(jit_float64_t);
 #endif
-    return (offset);
+    }
+    return (jit_new_node_w(jit_code_arg_f, offset));
 }
 
 jit_bool_t
@@ -461,19 +467,26 @@ _jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
 #endif
 }
 
-jit_int32_t
+jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
-#if __WORDSIZE == 64
-    return (jit_arg_f());
-#else
     jit_int32_t		offset;
 
     assert(_jit->function);
-    offset = _jit->function->self.size;
-    _jit->function->self.size += sizeof(jit_float64_t);
-    return (offset);
+#if __WORDSIZE == 64
+    if (_jit->function->self.argf < 8)
+	offset = _jit->function->self.argf++;
+    else
 #endif
+    {
+	offset = _jit->function->self.size;
+#if __WORDSIZE == 32
+	_jit->function->self.size += sizeof(jit_float32_t);
+#else
+	_jit->function->self.size += sizeof(jit_float64_t);
+#endif
+    }
+    return (jit_new_node_w(jit_code_arg_d, offset));
 }
 
 jit_bool_t
@@ -483,100 +496,100 @@ _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_int32_t v)
+_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 6)
-	jit_extr_c(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_c(u, _RDI - v->u.w);
     else
 #endif
-	jit_ldxi_c(u, _RBP, v);
+	jit_ldxi_c(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 6)
-	jit_extr_uc(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_uc(u, _RDI - v->u.w);
     else
 #endif
-	jit_ldxi_uc(u, _RBP, v);
+	jit_ldxi_uc(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 6)
-	jit_extr_s(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_s(u, _RDI - v->u.w);
     else
 #endif
-	jit_ldxi_s(u, _RBP, v);
+	jit_ldxi_s(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 6)
-	jit_extr_us(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_us(u, _RDI - v->u.w);
     else
 #endif
-	jit_ldxi_us(u, _RBP, v);
+	jit_ldxi_us(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 6)
-	jit_extr_i(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_i(u, _RDI - v->u.w);
     else
 #endif
-	jit_ldxi_i(u, _RBP, v);
+	jit_ldxi_i(u, _RBP, v->u.w);
 }
 
 #if __WORDSIZE == 64
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 6)
-	jit_extr_ui(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_extr_ui(u, _RDI - v->u.w);
     else
-	jit_ldxi_ui(u, _RBP, v);
+	jit_ldxi_ui(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
-    if (v < 6)
-	jit_movr(u, _RDI - v);
+    if (v->u.w < 6)
+	jit_movr(u, _RDI - v->u.w);
     else
-	jit_ldxi_l(u, _RBP, v);
+	jit_ldxi_l(u, _RBP, v->u.w);
 }
 #endif
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 8)
-	jit_movr_f(u, _XMM0 - v);
+    if (v->u.w < 8)
+	jit_movr_f(u, _XMM0 - v->u.w);
     else
 #endif
-	jit_ldxi_f(u, _RBP, v);
+	jit_ldxi_f(u, _RBP, v->u.w);
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
 {
 #if __WORDSIZE == 64
-    if (v < 8)
-	jit_movr_d(u, _XMM0 - v);
+    if (v->u.w < 8)
+	jit_movr_d(u, _XMM0 - v->u.w);
     else
 #endif
-	jit_ldxi_d(u, _RBP, v);
+	jit_ldxi_d(u, _RBP, v->u.w);
 }
 
 void
@@ -1582,6 +1595,9 @@ _jit_emit(jit_state_t *_jit)
 		    fstpr(rn(node->u.w) + 1);
 		break;
 #endif
+	    case jit_code_arg:
+	    case jit_code_arg_f:		case jit_code_arg_d:
+		break;
 	    default:
 		abort();
 	}
diff --git a/lib/lightning.c b/lib/lightning.c
index 1778a32e1..4ee202e94 100644
--- a/lib/lightning.c
+++ b/lib/lightning.c
@@ -777,6 +777,9 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
 	case jit_code_epilog:
 	    mask = 0;
 	    break;
+	case jit_code_arg:	case jit_code_arg_f:	case jit_code_arg_d:
+	    mask = jit_cc_a0_int;
+	    break;
 	case jit_code_calli:	case jit_code_jmpi:
 	    mask = jit_cc_a0_jmp;
 	    break;