From 2e6c680d706a7b9020136feeaa0f9c86bf48c18f Mon Sep 17 00:00:00 2001 From: pcpa Date: Fri, 28 Dec 2012 10:35:14 -0200 Subject: [PATCH] Change type of return of jit_arg* and argument to jit_getarg* * 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. --- ChangeLog | 14 ++++ check/lightning.c | 24 +++---- include/lightning.h | 31 +++++---- lib/jit_arm.c | 151 +++++++++++++++++++++----------------------- lib/jit_mips.c | 97 ++++++++++++++-------------- lib/jit_ppc.c | 107 +++++++++++++++++-------------- lib/jit_print.c | 9 ++- lib/jit_x86.c | 124 ++++++++++++++++++++---------------- lib/lightning.c | 3 + 9 files changed, 304 insertions(+), 256 deletions(-) diff --git a/ChangeLog b/ChangeLog index a4e89ad41..2ec26e19d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,17 @@ +2012-12-28 Paulo Andrade + + * 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 * 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;