lightning.git - Portable just-in-time compiler library

diff --git a/ChangeLog b/ChangeLog
index a4e89ad..2ec26e1 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 665fcd1..4c05ba7 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 35fcfa7..e992c6d 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 1b3bd8c..ed933a2 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 80ac40d..5f85f19 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 736b4d8..db0529c 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 e05e353..f5d3316 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 dad35c4..7104edb 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 1778a32..4ee202e 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;