mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-27 13:30:31 +02:00
Code Activity

Remove inconsistent, public jit_arg_reg_p macro

Browse source 
* include/lightning/jit_aarch64.h,
	include/lightning/jit_alpha.h,
	include/lightning/jit_arm.h,
	include/lightning/jit_hppa.h,
	include/lightning/jit_mips.h,
	 include/lightning/jit_ppc.h,
	include/lightning/jit_s390.h,
	include/lightning/jit_sparc.h,
	include/lightning/jit_x86.h,
	lib/jit_aarch64.c, lib/jit_alpha.c,
	lib/jit_arm.c, lib/jit_hppa.c,
	lib/jit_ia64.c, lib/jit_mips.c,
	lib/jit_ppc.c, lib/jit_s390.c,
	lib/jit_sparc.c, lib/jit_x86.c: Remove jit_arg_reg_p and
	jit_arg_f_reg_p from a public header, and define it only
	on port specific files where an integer offset is used
	to qualify an argument identifier. Exported code expects
	an opaque pointer (but of jit_node_t* type) to "qualify"
	an argument identifier.
	This patch, and the code review/simplification done during
	it also corrected some bugs:
	o Inconsistent jit_arg_d value of double argument after 3
	  integer arguments in arm for jit_functions; tested, C
	  functions were being properly called.
	o Inconsistent use of getarg_{f,d} and putarg*_{f,d} on
	  s390 (32-bit) that happened to not have a proper test
	  case, as it would only happen for jit functions, and
	  tested, called C functions had proper arguments.
	o Corrected a "last minute" correction that did not go
	  to the committed version, and would not compile on hppa,
	  due to bad _jit_putargi_d prototype definition.
This commit is contained in:
pcpa 2015-01-17 17:31:09 -02:00
parent 3695a2e99c
commit 73e520767f
20 changed files with 404 additions and 709 deletions
Download patch file Download diff file Expand all files Collapse all files

171
lib/jit_alpha.c
View file

@ -19,6 +19,19 @@
#define rc(value) jit_class_##value
#define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec))
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6)
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define C_DISP 0
# define S_DISP 0
# define I_DISP 0
# define F_DISP 0
#else
# define C_DISP 8 - sizeof(jit_int8_t)
# define S_DISP 8 - sizeof(jit_int16_t)
# define I_DISP 8 - sizeof(jit_int32_t)
# define F_DISP 8 - sizeof(jit_float32_t)
#endif
/*
* Prototypes
@ -246,7 +259,7 @@ _jit_arg(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jitc->function != NULL);
if (_jitc->function->self.argi < 6)
if (jit_arg_reg_p(_jitc->function->self.argi))
offset = _jitc->function->self.argi++;
else {
offset = _jitc->function->self.size;
@ -255,18 +268,12 @@ _jit_arg(jit_state_t *_jit)
return (jit_new_node_w(jit_code_arg, offset));
}
jit_bool_t
_jit_arg_reg_p(jit_state_t *_jit, jit_int32_t offset)
{
return (offset >= 0 && offset < 6);
}
jit_node_t *
_jit_arg_f(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jitc->function != NULL);
if (_jitc->function->self.argi < 6)
if (jit_arg_f_reg_p(_jitc->function->self.argi))
offset = _jitc->function->self.argi++;
else {
offset = _jitc->function->self.size;
@ -275,18 +282,12 @@ _jit_arg_f(jit_state_t *_jit)
return (jit_new_node_w(jit_code_arg_f, offset));
}
jit_bool_t
_jit_arg_f_reg_p(jit_state_t *_jit, jit_int32_t offset)
{
return (offset >= 0 && offset < 6);
}
jit_node_t *
_jit_arg_d(jit_state_t *_jit)
{
jit_int32_t offset;
assert(_jitc->function != NULL);
if (_jitc->function->self.argi < 6)
if (jit_arg_f_reg_p(_jitc->function->self.argi))
offset = _jitc->function->self.argi++;
else {
offset = _jitc->function->self.size;
@ -295,107 +296,71 @@ _jit_arg_d(jit_state_t *_jit)
return (jit_new_node_w(jit_code_arg_d, offset));
}
jit_bool_t
_jit_arg_d_reg_p(jit_state_t *_jit, jit_int32_t offset)
{
return (jit_arg_f_reg_p(offset));
}
void
_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_c(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_c(u, _FP, v->u.w);
#else
jit_ldxi_c(u, JIT_FP, v->u.w + 8 - sizeof(jit_int8_t));
#endif
}
else
jit_ldxi_c(u, _FP, v->u.w + C_DISP);
}
void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_uc(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_uc(u, _FP, v->u.w);
#else
jit_ldxi_uc(u, JIT_FP, v->u.w + 8 - sizeof(jit_uint8_t));
#endif
}
else
jit_ldxi_uc(u, _FP, v->u.w + C_DISP);
}
void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_s(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_s(u, _FP, v->u.w);
#else
jit_ldxi_s(u, JIT_FP, v->u.w + 8 - sizeof(jit_int16_t));
#endif
}
else
jit_ldxi_s(u, _FP, v->u.w + S_DISP);
}
void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_us(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_us(u, _FP, v->u.w);
#else
jit_ldxi_us(u, JIT_FP, v->u.w + 8 - sizeof(jit_uint16_t));
#endif
}
else
jit_ldxi_us(u, _FP, v->u.w + S_DISP);
}
void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_i(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_i(u, _FP, v->u.w);
#else
jit_ldxi_i(u, JIT_FP, v->u.w + 8 - sizeof(jit_int32_t));
#endif
}
else
jit_ldxi_i(u, _FP, v->u.w + I_DISP);
}
void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_extr_ui(u, _A0 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_ui(u, _FP, v->u.w);
#else
jit_ldxi_ui(u, JIT_FP, v->u.w + 8 - sizeof(jit_uint32_t));
#endif
}
else
jit_ldxi_ui(u, _FP, v->u.w + I_DISP);
}
void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_movr(u, _A0 - v->u.w);
else
jit_ldxi_l(u, _FP, v->u.w);
@ -405,7 +370,7 @@ void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_movr(_A0 - v->u.w, u);
else
jit_stxi(v->u.w, _FP, u);
@ -416,7 +381,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg);
if (v->u.w < 6)
if (jit_arg_reg_p(v->u.w))
jit_movi(_A0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
@ -430,30 +395,20 @@ void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movr_f(u, _F16 - v->u.w);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_ldxi_f(u, _FP, v->u.w);
#else
jit_ldxi_f(u, JIT_FP, v->u.w + 8 - sizeof(jit_float32_t));
#endif
}
else
jit_ldxi_f(u, _FP, v->u.w + F_DISP);
}
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movr_f(_F16 - v->u.w, u);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, _FP, u);
#else
jit_stxi_f(v->u.w + 8 - sizeof(jit_float32_t), _FP, u);
#endif
}
else
jit_stxi_f(v->u.w, _FP, u + F_DISP);
}
void
@ -461,16 +416,12 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_f);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movi_f(_F16 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, _FP, regno);
#else
jit_stxi_f(v->u.w + 8 - sizeof(jit_float32_t), _FP, regno);
#endif
jit_stxi_f(v->u.w, _FP, regno + F_DISP);
jit_unget_reg(regno);
}
}
@ -479,7 +430,7 @@ void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movr_d(u, _F16 - v->u.w);
else
jit_ldxi_d(u, _FP, v->u.w);
@ -489,7 +440,7 @@ void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movr_d(_F16 - v->u.w, u);
else
jit_stxi_d(v->u.w, _FP, u);
@ -500,7 +451,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 6)
if (jit_arg_f_reg_p(v->u.w))
jit_movi_d(_F16 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
@ -514,7 +465,7 @@ void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_reg_p(_jitc->function->call.argi)) {
jit_movr(_A0 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}
@ -529,7 +480,7 @@ _jit_pushargi(jit_state_t *_jit, jit_int64_t u)
{
jit_int32_t regno;
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_reg_p(_jitc->function->call.argi)) {
jit_movi(_A0 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}
@ -546,17 +497,12 @@ void
_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
jit_movr_f(_F16 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(_jitc->function->call.size, JIT_SP, u);
#else
jit_stxi_f(_jitc->function->call.size + 8 - sizeof(jit_float32_t),
JIT_SP, u);
#endif
jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, u);
_jitc->function->call.size += 8;
}
}
@ -566,19 +512,14 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
{
jit_int32_t regno;
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
jit_movi_f(_F16 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(_jitc->function->call.size, JIT_SP, regno);
#else
jit_stxi_f(_jitc->function->call.size + 8 - sizeof(jit_float32_t),
JIT_SP, regno);
#endif
jit_stxi_f(_jitc->function->call.size + F_DISP, JIT_SP, regno);
_jitc->function->call.size += 8;
jit_unget_reg(regno);
}
@ -588,7 +529,7 @@ void
_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
{
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
jit_movr_d(_F16 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}
@ -603,7 +544,7 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
{
jit_int32_t regno;
assert(_jitc->function != NULL);
if (_jitc->function->call.argi < 6) {
if (jit_arg_f_reg_p(_jitc->function->call.argi)) {
jit_movi_d(_F16 - _jitc->function->call.argi, u);
++_jitc->function->call.argi;
}