[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 167/437: Change type of return of jit_arg* and argument
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 167/437: Change type of return of jit_arg* and argument to jit_getarg* |
|
Date: |
Mon, 2 Jul 2018 05:14:10 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 2e6c680d706a7b9020136feeaa0f9c86bf48c18f
Author: pcpa <address@hidden>
Date: Fri Dec 28 10:35:14 2012 -0200
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 a4e89ad..2ec26e1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2012-12-28 Paulo Andrade <address@hidden>
+
+ * 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 <address@hidden>
* 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;
- [Guile-commits] 169/437: Correct wrong and confusing reverse float comparison logic, (continued)
- [Guile-commits] 169/437: Correct wrong and confusing reverse float comparison logic, Andy Wingo, 2018/07/02
- [Guile-commits] 139/437: Implement sqrt codes in mips., Andy Wingo, 2018/07/02
- [Guile-commits] 134/437: Correct make distcheck., Andy Wingo, 2018/07/02
- [Guile-commits] 156/437: Simplify listing of test cases with alternate jit generation options, Andy Wingo, 2018/07/02
- [Guile-commits] 157/437: Add two extra test cases for float operations., Andy Wingo, 2018/07/02
- [Guile-commits] 161/437: Add new register clobber detection test case., Andy Wingo, 2018/07/02
- [Guile-commits] 164/437: Add new carry test case., Andy Wingo, 2018/07/02
- [Guile-commits] 138/437: Correct mips backend implementation to pass initial tests., Andy Wingo, 2018/07/02
- [Guile-commits] 163/437: Add missing jit_htonr to ppc backend., Andy Wingo, 2018/07/02
- [Guile-commits] 177/437: Correct reference to dangling pointer and better note bounds checking, Andy Wingo, 2018/07/02
- [Guile-commits] 167/437: Change type of return of jit_arg* and argument to jit_getarg*,
Andy Wingo <=
- [Guile-commits] 168/437: Add new extensive float comparison and conversion test case, Andy Wingo, 2018/07/02
- [Guile-commits] 192/437: Correct SPARC optimized assembly example in documentation, Andy Wingo, 2018/07/02
- [Guile-commits] 93/437: subtract 1 from the final byte being flushed in PPC jit_flush_code, Andy Wingo, 2018/07/02
- [Guile-commits] 176/437: Add the new jit_name call to mark function boundaries, Andy Wingo, 2018/07/02
- [Guile-commits] 146/437: Add several arithmetic and branch tests cases., Andy Wingo, 2018/07/02
- [Guile-commits] 191/437: Add updated sparc example from lightning 1.2c documentation., Andy Wingo, 2018/07/02
- [Guile-commits] 151/437: Add new varargs test and correct related test case failures in all ports., Andy Wingo, 2018/07/02
- [Guile-commits] 198/437: Remove non optional gmp dependency., Andy Wingo, 2018/07/02
- [Guile-commits] 202/437: Ensure the end argument of __clear_cache is page aligned., Andy Wingo, 2018/07/02
- [Guile-commits] 197/437: Adapt PowerPC port to work in Darwin 32 bit and Linux 64 bit., Andy Wingo, 2018/07/02