mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-18 10:10:23 +02:00
Code Activity

Implement jit_putarg*

Browse source 
* include/lightning.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:
	Implement jit_putarg*. It works as a mix of jit_getarg*
	and jit_pusharg*, in the way that the first argument is
	a register or immediate, and the second is a pointer
	returned by jit_arg*. The use of the interface is to change
	values of arguments to the current jit function.

	* check/put.ok, check/put.tst: New test cases exercising
	the new jit_putarg* interface.

	* check/Makefile.am, check/lightning.c: Update for the
	new test case and interface.
This commit is contained in:
Paulo Andrade 2015-01-15 14:20:07 -02:00
parent 192f89c0ee
commit 27d9b68a3f
16 changed files with 1535 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

84
lib/jit_aarch64.c
View file

@ -306,6 +306,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_extr_c(u, JIT_RA0 - v->u.w);
else
@ -315,6 +316,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_uc(u, JIT_RA0 - v->u.w);
else
@ -324,6 +326,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_s(u, JIT_RA0 - v->u.w);
else
@ -333,6 +336,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_us(u, JIT_RA0 - v->u.w);
else
@ -342,6 +346,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_i(u, JIT_RA0 - v->u.w);
else
@ -351,6 +356,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_ui(u, JIT_RA0 - v->u.w);
else
@ -360,30 +366,108 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_movr(u, JIT_RA0 - v->u.w);
else
jit_ldxi_l(u, JIT_FP, v->u.w);
}
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 < 8)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 8)
jit_movr_f(u, JIT_FA0 - v->u.w);
else
jit_ldxi_f(u, JIT_FP, v->u.w);
}
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 < 8)
jit_movr_f(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi_f(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 8)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
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 < 8)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

93
lib/jit_alpha.c
View file

@ -304,6 +304,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_extr_c(u, _A0 - v->u.w);
else {
@ -318,6 +319,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_uc(u, _A0 - v->u.w);
else {
@ -332,6 +334,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_s(u, _A0 - v->u.w);
else {
@ -346,6 +349,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_us(u, _A0 - v->u.w);
else {
@ -360,6 +364,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_i(u, _A0 - v->u.w);
else {
@ -374,6 +379,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_ui(u, _A0 - v->u.w);
else {
@ -388,15 +394,42 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_movr(u, _A0 - v->u.w);
else
jit_ldxi_l(u, _FP, v->u.w);
}
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)
jit_movr(_A0 - v->u.w, u);
else
jit_stxi(v->u.w, _FP, u);
}
void
_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)
jit_movi(_A0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
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)
jit_movr_f(u, _F16 - v->u.w);
else {
@ -408,15 +441,75 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
}
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)
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
}
}
void
_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)
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_unget_reg(regno);
}
}
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)
jit_movr_d(u, _F16 - v->u.w);
else
jit_ldxi_d(u, _FP, v->u.w);
}
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)
jit_movr_d(_F16 - v->u.w, u);
else
jit_stxi_d(v->u.w, _FP, u);
}
void
_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)
jit_movi_d(_F16 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

144
lib/jit_arm.c
View file

@ -452,6 +452,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
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)
@ -463,6 +464,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
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)
@ -474,6 +476,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
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)
@ -485,6 +488,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
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)
@ -496,6 +500,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
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)
@ -504,9 +509,43 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_i(u, JIT_FP, v->u.w);
}
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (jit_swf_p())
jit_stxi(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else if (v->u.w < 4)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 (jit_swf_p()) {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else if (v->u.w < 4)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_f(u, JIT_FA0 - v->u.w);
@ -523,9 +562,62 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
}
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_f(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
else if (jit_swf_p())
jit_stxi_f(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else {
if (v->u.w < 4)
jit_movr_f_w(JIT_RA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
}
void
_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 (jit_cpu.abi) {
if (v->u.w < 16)
jit_movi_f(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
else if (jit_swf_p()) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
if (v->u.w < 4)
jit_movr_f_w(JIT_RA0 - v->u.w, regno);
else
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_d(u, JIT_FA0 - v->u.w);
@ -542,6 +634,58 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
}
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
if (jit_cpu.abi) {
if (v->u.w < 16)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
else if (jit_swf_p())
jit_stxi_d(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, u);
else {
if (v->u.w < 4)
jit_movr_d_ww(JIT_RA0 - v->u.w, JIT_RA0 - (v->u.w + 1), u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
}
void
_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 (jit_cpu.abi) {
if (v->u.w < 16)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
else if (jit_swf_p()) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w < 4 ? v->u.w << 2 : v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
if (v->u.w < 4)
jit_movr_d_ww(JIT_RA0 - v->u.w, JIT_RA0 - (v->u.w + 1), regno);
else
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

82
lib/jit_hppa.c
View file

@ -316,6 +316,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w >= 0)
jit_extr_c(u, _R26 - v->u.w);
else
@ -325,6 +326,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 >= 0)
jit_extr_uc(u, _R26 - v->u.w);
else
@ -334,6 +336,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 >= 0)
jit_extr_s(u, _R26 - v->u.w);
else
@ -343,6 +346,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 >= 0)
jit_extr_us(u, _R26 - v->u.w);
else
@ -352,30 +356,108 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 >= 0)
jit_movr(u, _R26 - v->u.w);
else
jit_ldxi_i(u, JIT_FP, v->u.w);
}
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 >= 0)
jit_movr(_R26 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 >= 0)
jit_movi(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 >= 0)
jit_movr_f(u, _F4 - v->u.w);
else
jit_ldxi_f(u, JIT_FP, v->u.w);
}
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 >= 0)
jit_movr_f(_F4 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_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 >= 0)
jit_movi_f(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 >= 0)
jit_movr_d(u, _F4 - v->u.w);
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
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 >= 0)
jit_movr_d(_F4 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w >= 0)
jit_movi_d(_R26 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

93
lib/jit_ia64.c
View file

@ -404,6 +404,7 @@ _jit_arg_d(jit_state_t *_jit)
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 < 8) {
jit_extr_c(u, _R32 + v->u.w);
}
@ -420,6 +421,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_uc(u, _R32 + v->u.w);
else {
@ -435,6 +437,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_s(u, _R32 + v->u.w);
else {
@ -450,6 +453,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_us(u, _R32 + v->u.w);
else {
@ -465,6 +469,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_i(u, _R32 + v->u.w);
else {
@ -480,6 +485,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_ui(u, _R32 + v->u.w);
else {
@ -495,15 +501,42 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_movr(u, _R32 + v->u.w);
else
jit_ldxi(u, JIT_FP, v->u.w);
}
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 < 8)
jit_movr(_R32 + v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi(_R32 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 8)
jit_movr_f(u, _F8 + v->u.w);
else {
@ -516,15 +549,75 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
}
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 < 8)
jit_movr_f(_F8 + v->u.w, u);
else {
#if __BYTE_ORDER == __LITTLE_ENDIAN
jit_stxi_f(v->u.w, JIT_FP, u);
#else
jit_stxi_f(v->u.w + (__WORDSIZE >> 3) - sizeof(jit_float32_t), JIT_FP, u);
#endif
}
}
void
_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 < 8)
jit_movi_f(_F8 + 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, JIT_FP, regno);
#else
jit_stxi_f(v->u.w, JIT_FP + (__WORDSIZE >> 3) - sizeof(jit_float32_t), regno);
#endif
jit_unget_reg(regno);
}
}
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 < 8)
jit_movr_d(u, _F8 + v->u.w);
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
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 < 8)
jit_movr_d(_F8 + v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi_d(_F8 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

120
lib/jit_mips.c
View file

@ -379,6 +379,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < NUM_WORD_ARGS)
jit_extr_c(u, _A0 - v->u.w);
else {
@ -393,6 +394,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS)
jit_extr_uc(u, _A0 - v->u.w);
else {
@ -407,6 +409,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS)
jit_extr_s(u, _A0 - v->u.w);
else {
@ -421,6 +424,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS)
jit_extr_us(u, _A0 - v->u.w);
else {
@ -435,6 +439,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS) {
#if __WORDSIZE == 64
jit_extr_i(u, _A0 - v->u.w);
@ -455,6 +460,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS)
jit_extr_ui(u, _A0 - v->u.w);
else {
@ -469,6 +475,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < NUM_WORD_ARGS)
jit_movr(u, _A0 - v->u.w);
else
@ -476,9 +483,35 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
#endif
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 < NUM_WORD_ARGS)
jit_movr(_A0 - v->u.w, u);
else
jit_stxi(v->u.w, _FP, u);
}
void
_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 < NUM_WORD_ARGS)
jit_movi(_A0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_f(u, _F12 - v->u.w);
@ -492,9 +525,53 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, _FP, v->u.w);
}
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_f(_F12 - v->u.w, u);
#else
if (v->u.w < 4)
jit_movr_f_w(_A0 - v->u.w, u);
else if (v->u.w < 8)
jit_movr_f(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else
jit_stxi_f(v->u.w, _FP, u);
}
void
_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 NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movi_f(_F12 - v->u.w, u);
#else
if (v->u.w < 4) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_movr_f_w(_A0 - ((v->u.w - 4) >> 1), regno);
jit_unget_reg(regno);
}
else if (v->u.w < 8)
jit_movi_f(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_d(u, _F12 - v->u.w);
@ -508,6 +585,49 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_d(u, _FP, v->u.w);
}
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movr_d(_F12 - v->u.w, u);
#else
if (v->u.w < 4)
jit_movr_d_ww(_A0 - v->u.w, _A0 - (v->u.w + 1), u);
else if (v->u.w < 8)
jit_movr_d(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else
jit_stxi_d(v->u.w, _FP, u);
}
void
_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 NEW_ABI
if (v->u.w < NUM_WORD_ARGS)
jit_movi_d(_F12 - v->u.w, u);
#else
if (v->u.w < 4) {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_movr_d_ww(_A0 - v->u.w, _A0 - (v->u.w + 1), regno);
jit_unget_reg(regno);
}
else if (v->u.w < 8)
jit_movi_d(_F12 - ((v->u.w - 4) >> 1), u);
#endif
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

98
lib/jit_ppc.c
View file

@ -283,6 +283,13 @@ _jit_arg_f(jit_state_t *_jit)
offset = _jitc->function->self.size;
#else
offset = _jitc->function->self.size + 4;
#endif
}
if (_jitc->function->self.argi < 8) {
#if __WORDSIZE == 32
_jitc->function->self.argi += 2;
#else
_jitc->function->self.argi++;
#endif
}
_jitc->function->self.size += sizeof(jit_word_t);
@ -304,6 +311,13 @@ _jit_arg_d(jit_state_t *_jit)
offset = _jitc->function->self.argf++;
else
offset = _jitc->function->self.size;
if (_jitc->function->self.argi < 8) {
#if __WORDSIZE == 32
_jitc->function->self.argi += 2;
#else
_jitc->function->self.argi++;
#endif
}
_jitc->function->self.size += sizeof(jit_float64_t);
return (jit_new_node_w(jit_code_arg_d, offset));
}
@ -317,6 +331,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 8)
jit_extr_c(u, JIT_RA0 - v->u.w);
else {
@ -332,6 +347,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_uc(u, JIT_RA0 - v->u.w);
else {
@ -347,6 +363,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_s(u, JIT_RA0 - v->u.w);
else {
@ -362,6 +379,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_us(u, JIT_RA0 - v->u.w);
else {
@ -377,6 +395,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8) {
#if __WORDSIZE == 32
jit_movr(u, JIT_RA0 - v->u.w);
@ -398,6 +417,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_extr_ui(u, JIT_RA0 - v->u.w);
else {
@ -413,6 +433,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 8)
jit_movr(u, JIT_RA0 - v->u.w);
else
@ -420,24 +441,101 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
#endif
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 < 8)
jit_movr(JIT_RA0 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 < 8)
jit_movi(JIT_RA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 13)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
jit_ldxi_f(u, JIT_FP, v->u.w);
}
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 < 13)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_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 < 13)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 13)
jit_movr_d(u, JIT_FA0 - v->u.w);
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
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 < 13)
jit_movr_d(JIT_FA0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_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 < 13)
jit_movi_d(JIT_FA0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

92
lib/jit_s390.c
View file

@ -283,6 +283,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 5)
jit_extr_c(u, _R2 - v->u.w);
else
@ -293,6 +294,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5)
jit_extr_uc(u, _R2 - v->u.w);
else
@ -303,6 +305,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5)
jit_extr_s(u, _R2 - v->u.w);
else
@ -313,6 +316,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5)
jit_extr_us(u, _R2 - v->u.w);
else
@ -323,6 +327,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5) {
#if __WORDSIZE == 32
jit_movr(u, _R2 - v->u.w);
@ -339,6 +344,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5)
jit_extr_ui(u, _R2 - v->u.w);
else
@ -349,6 +355,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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 < 5)
jit_movr(u, _R2 - v->u.w);
else
@ -356,9 +363,35 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
#endif
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 < 5)
jit_movr(_R2 - v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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 < 5)
jit_movi(_R2 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 4)
jit_movr_f(u, _F0 - v->u.w);
else
@ -370,15 +403,74 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
);
}
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 < 4)
jit_movr_f(_F0 - v->u.w, u);
else
jit_stxi_f(v->u.w
#if __WORDSIZE == 64
+ (__WORDSIZE >> 3) - sizeof(jit_float32_t)
#endif
, JIT_FP, u);
}
void
_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 < 4)
jit_movi_f(_F0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w
#if __WORDSIZE == 64
+ (__WORDSIZE >> 3) - sizeof(jit_float32_t)
#endif
, JIT_FP, regno);
jit_unget_reg(regno);
}
}
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 < 4)
jit_movr_d(u, _F0 - v->u.w);
else
jit_ldxi_d(u, JIT_FP, v->u.w);
}
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 < 4)
jit_movr_d(_F0 - v->u.w, u);
else
jit_stxi_d(v->u.w, JIT_FP, u);
}
void
_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 < 4)
jit_movi_d(_F0 - v->u.w, u);
else {
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

126
lib/jit_sparc.c
View file

@ -294,6 +294,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
if (v->u.w < 6)
jit_extr_c(u, _I0 + v->u.w);
else {
@ -306,6 +307,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_uc(u, _I0 + v->u.w);
else {
@ -318,6 +320,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_s(u, _I0 + v->u.w);
else {
@ -330,6 +333,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_extr_us(u, _I0 + v->u.w);
else {
@ -342,15 +346,42 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
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)
jit_movr(u, _I0 + v->u.w);
else
jit_ldxi_i(u, JIT_FP, v->u.w);
}
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)
jit_movr(_I0 + v->u.w, u);
else
jit_stxi(v->u.w, JIT_FP, u);
}
void
_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)
jit_movi(_I0 + v->u.w, u);
else {
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
assert(_jitc->function);
if (v->u.w < 6) {
jit_stxi(-4, JIT_FP, _I0 + v->u.w);
@ -360,9 +391,38 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, JIT_FP, v->u.w);
}
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) {
jit_stxi_f(-4, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -4);
}
else
jit_stxi_f(v->u.w, JIT_FP, u);
}
void
_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);
regno = jit_get_reg(jit_class_fpr);
jit_movi_f(regno, u);
if (v->u.w < 6) {
jit_stxi_f(-4, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -4);
}
else
jit_stxi_f(v->u.w, JIT_FP, regno);
jit_unget_reg(regno);
}
void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
assert(_jitc->function);
if (v->u.w < 5) {
jit_stxi(-8, JIT_FP, _I0 + v->u.w);
@ -380,6 +440,72 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
}
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
jit_int32_t regno;
assert(v->code == jit_code_arg_d);
if (v->u.w < 5) {
jit_stxi_d(-8, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
}
if (v->u.w < 6) {
regno = jit_get_reg(jit_class_gpr);
jit_stxi_d(-8, JIT_FP, u);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(regno, JIT_FP, -4);
jit_stxi(stack_framesize, JIT_FP, regno);
jit_unget_reg(regno);
}
else if ((v->u.w & 7) == 0)
jit_stxi_d(v->u.w, JIT_FP, u);
else {
jit_stxi_d(-8, JIT_FP, u);
regno = jit_get_reg(jit_class_gpr);
jit_ldxi(regno, JIT_FP, -8);
jit_stxi(v->u.w, JIT_FP, regno);
jit_ldxi(regno, JIT_FP, -4);
jit_stxi(v->u.w + 4, JIT_FP, regno);
jit_unget_reg(regno);
}
}
void
_jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
{
jit_int32_t regno, gpr;
assert(v->code == jit_code_arg_d);
regno = jit_get_reg(jit_class_fpr);
jit_movi_d(regno, u);
if (v->u.w < 5) {
jit_stxi_d(-8, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(_I0 + v->u.w + 1, JIT_FP, -4);
}
else if (v->u.w < 6) {
gpr = jit_get_reg(jit_class_gpr);
jit_stxi_d(-8, JIT_FP, regno);
jit_ldxi(_I0 + v->u.w, JIT_FP, -8);
jit_ldxi(gpr, JIT_FP, -4);
jit_stxi(stack_framesize, JIT_FP, gpr);
jit_unget_reg(gpr);
}
else if ((v->u.w & 7) == 0)
jit_stxi_d(v->u.w, JIT_FP, regno);
else {
jit_stxi_d(-8, JIT_FP, regno);
gpr = jit_get_reg(jit_class_gpr);
jit_ldxi(gpr, JIT_FP, -8);
jit_stxi(v->u.w, JIT_FP, gpr);
jit_ldxi(gpr, JIT_FP, -4);
jit_stxi(v->u.w + 4, JIT_FP, gpr);
jit_unget_reg(gpr);
}
jit_unget_reg(regno);
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{

99
lib/jit_x86.c
View file

@ -577,6 +577,7 @@ _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_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_extr_c(u, JIT_RA0 - v->u.w);
@ -588,6 +589,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_extr_uc(u, JIT_RA0 - v->u.w);
@ -599,6 +601,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_extr_s(u, JIT_RA0 - v->u.w);
@ -610,6 +613,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_extr_us(u, JIT_RA0 - v->u.w);
@ -621,6 +625,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w)) {
# if __X64_32
@ -638,6 +643,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (jit_arg_reg_p(v->u.w))
jit_extr_ui(u, JIT_RA0 - v->u.w);
else
@ -647,6 +653,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
void
_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
if (jit_arg_reg_p(v->u.w))
jit_movr(u, JIT_RA0 - v->u.w);
else
@ -654,9 +661,40 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
}
#endif
void
_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr(JIT_RA0 - v->u.w, u);
else
#endif
jit_stxi(v->u.w, _RBP, u);
}
void
_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 __X64
if (jit_arg_reg_p(v->u.w))
jit_movi(JIT_RA0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi(regno, u);
jit_stxi(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if __X64
if (jit_arg_f_reg_p(v->u.w))
jit_movr_f(u, _XMM0 - v->u.w);
@ -665,9 +703,40 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_f(u, _RBP, v->u.w);
}
void
_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_f);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr_f(_XMM0 - v->u.w, u);
else
#endif
jit_stxi_f(v->u.w, _RBP, u);
}
void
_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 __X64
if (jit_arg_reg_p(v->u.w))
jit_movi_f(_XMM0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi_f(regno, u);
jit_stxi_f(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void
_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if __X64
if (jit_arg_f_reg_p(v->u.w))
jit_movr_d(u, _XMM0 - v->u.w);
@ -676,6 +745,36 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
jit_ldxi_d(u, _RBP, v->u.w);
}
void
_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
{
assert(v->code == jit_code_arg_d);
#if __X64
if (jit_arg_reg_p(v->u.w))
jit_movr_d(_XMM0 - v->u.w, u);
else
#endif
jit_stxi_d(v->u.w, _RBP, u);
}
void
_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 __X64
if (jit_arg_reg_p(v->u.w))
jit_movi_d(_XMM0 - v->u.w, u);
else
#endif
{
regno = jit_get_reg(jit_class_gpr);
jit_movi_d(regno, u);
jit_stxi_d(v->u.w, _RBP, regno);
jit_unget_reg(regno);
}
}
void
_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
{