From 7bdd22bd99a212bb7380852966443d83bad936ee Mon Sep 17 00:00:00 2001 From: pcpa Date: Wed, 10 Apr 2013 15:07:01 -0300 Subject: [PATCH] Make it simpler to add support for more than 64 registers. * include/lightning/jit_private.h, lib/jit_arm.c, lib/jit_mips-cpu.c, lib/jit_mips.c, lib/jit_ppc-cpu.c, lib/jit_ppc.c, lib/jit_print.c, lib/jit_sparc-cpu.c, lib/jit_sparc.c, lib/jit_x86-cpu.c, lib/jit_x86.c, lib/lightning.c: Change all jit_regset macros to take a pointer argument, to avoid structure copies when adding a port to an architecture with more than 64 registers. --- ChangeLog | 11 ++ include/lightning/jit_private.h | 51 +++--- lib/jit_arm.c | 26 +-- lib/jit_mips-cpu.c | 128 +++++++-------- lib/jit_mips.c | 6 +- lib/jit_ppc-cpu.c | 16 +- lib/jit_ppc.c | 6 +- lib/jit_print.c | 2 +- lib/jit_sparc-cpu.c | 32 ++-- lib/jit_sparc.c | 6 +- lib/jit_x86-cpu.c | 44 ++--- lib/jit_x86.c | 10 +- lib/lightning.c | 281 ++++++++++++++++---------------- 13 files changed, 310 insertions(+), 309 deletions(-) diff --git a/ChangeLog b/ChangeLog index fe265f9b4..f4b40b985 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2013-04-10 Paulo Andrade + + * include/lightning/jit_private.h, lib/jit_arm.c, + lib/jit_mips-cpu.c, lib/jit_mips.c, lib/jit_ppc-cpu.c, + lib/jit_ppc.c, lib/jit_print.c, lib/jit_sparc-cpu.c, + lib/jit_sparc.c, lib/jit_x86-cpu.c, lib/jit_x86.c, + lib/lightning.c: Change all jit_regset macros to take + a pointer argument, to avoid structure copies when + adding a port to an architecture with more than 64 + registers. + 2013-04-08 Paulo Andrade * lib/jit_arm.c, lib/jit_ppc.c: Do not rely on __clear_cache diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h index 133937b03..ae8a9e7cb 100644 --- a/include/lightning/jit_private.h +++ b/include/lightning/jit_private.h @@ -78,9 +78,9 @@ #define jit_size(vector) (sizeof(vector) / sizeof((vector)[0])) #define jit_reg_free_p(regno) \ - (!jit_regset_tstbit(_jitc->reglive, regno) && \ - !jit_regset_tstbit(_jitc->regarg, regno) && \ - !jit_regset_tstbit(_jitc->regsav, regno)) + (!jit_regset_tstbit(&_jitc->reglive, regno) && \ + !jit_regset_tstbit(&_jitc->regarg, regno) && \ + !jit_regset_tstbit(&_jitc->regsav, regno)) /* * Private jit_class bitmasks @@ -121,38 +121,27 @@ #define jit_cc_a2_flt 0x00200000 /* arg2 is immediate float */ #define jit_cc_a2_dbl 0x00400000 /* arg2 is immediate double */ -#define jit_regset_com(u, v) ((u) = ~(v)) -#define jit_regset_and(u, v, w) ((u) = (v) & (w)) -#define jit_regset_ior(u, v, w) ((u) = (v) | (w)) -#define jit_regset_xor(u, v, w) ((u) = (v) ^ (w)) -#define jit_regset_set(u, v) ((u) = (v)) -#define jit_regset_cmp_ui(u, v) ((u) != (v)) -#define jit_regset_set_ui(u, v) ((u) = (v)) -#define jit_regset_set_p(set) (set) -#if DEBUG -# define jit_regset_clrbit(set, bit) \ - (assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \ - (set) &= ~(1LL << (bit))) -# define jit_regset_setbit(set, bit) \ - (assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \ - (set) |= 1LL << (bit)) -# define jit_regset_tstbit(set, bit) \ - (assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \ - (set) & (1LL << (bit))) -#else -# define jit_regset_clrbit(set, bit) ((set) &= ~(1LL << (bit))) -# define jit_regset_setbit(set, bit) ((set) |= 1LL << (bit)) -# define jit_regset_tstbit(set, bit) ((set) & (1LL << (bit))) -#endif -#define jit_regset_new(set) ((set) = 0) -#define jit_regset_del(set) ((set) = 0) +#define jit_regset_com(u, v) (*(u) = ~*(v)) +#define jit_regset_and(u, v, w) (*(u) = *(v) & *(w)) +#define jit_regset_ior(u, v, w) (*(u) = *(v) | *(w)) +#define jit_regset_xor(u, v, w) (*(u) = *(v) ^ *(w)) +#define jit_regset_set(u, v) (*(u) = *(v)) +#define jit_regset_set_mask(u, v) (*(u) = (1LL << (v)) - 1) +#define jit_regset_cmp_ui(u, v) (*(u) != (v)) +#define jit_regset_set_ui(u, v) (*(u) = (v)) +#define jit_regset_set_p(set) (*set) +#define jit_regset_clrbit(set, bit) (*(set) &= ~(1LL << (bit))) +#define jit_regset_setbit(set, bit) (*(set) |= 1LL << (bit)) +#define jit_regset_tstbit(set, bit) (*(set) & (1LL << (bit))) +#define jit_regset_new(set) (*(set) = 0) +#define jit_regset_del(set) (*(set) = 0) extern unsigned long -jit_regset_scan1(jit_regset_t, jit_int32_t); +jit_regset_scan1(jit_regset_t*, jit_int32_t); #define jit_reglive_setup() \ do { \ - jit_regset_set_ui(_jitc->reglive, 0); \ - jit_regset_set_ui(_jitc->regmask, 0); \ + jit_regset_set_ui(&_jitc->reglive, 0); \ + jit_regset_set_ui(&_jitc->regmask, 0); \ } while (0) /* diff --git a/lib/jit_arm.c b/lib/jit_arm.c index 07223e558..020142371 100644 --- a/lib/jit_arm.c +++ b/lib/jit_arm.c @@ -211,8 +211,8 @@ _jit_prolog(jit_state_t *_jit) if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jitc->regarg, 0) == 0); - jit_regset_set_ui(_jitc->regsav, 0); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); offset = _jitc->functions.offset; if (offset >= _jitc->functions.length) { jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, @@ -245,7 +245,7 @@ _jit_prolog(jit_state_t *_jit) */ _jitc->function->epilog->w.w = offset; - jit_regset_new(_jitc->function->regset); + jit_regset_new(&_jitc->function->regset); } jit_int32_t @@ -1613,28 +1613,28 @@ _jit_get_reg_pair(jit_state_t *_jit) * return JIT_NOREG if fail, as the cost of spills is greater * than splitting a double load/store in two operations. */ if (jit_reg_free_p(_R0) && jit_reg_free_p(_R1)) { - jit_regset_setbit(_jitc->regarg, _R0); - jit_regset_setbit(_jitc->regarg, _R1); + jit_regset_setbit(&_jitc->regarg, _R0); + jit_regset_setbit(&_jitc->regarg, _R1); return (_R0); } if (jit_reg_free_p(_R2) && jit_reg_free_p(_R3)) { - jit_regset_setbit(_jitc->regarg, _R2); - jit_regset_setbit(_jitc->regarg, _R3); + jit_regset_setbit(&_jitc->regarg, _R2); + jit_regset_setbit(&_jitc->regarg, _R3); return (_R2); } if (jit_reg_free_p(_R4) && jit_reg_free_p(_R5)) { - jit_regset_setbit(_jitc->regarg, _R4); - jit_regset_setbit(_jitc->regarg, _R5); + jit_regset_setbit(&_jitc->regarg, _R4); + jit_regset_setbit(&_jitc->regarg, _R5); return (_R4); } if (jit_reg_free_p(_R6) && jit_reg_free_p(_R7)) { - jit_regset_setbit(_jitc->regarg, _R6); - jit_regset_setbit(_jitc->regarg, _R7); + jit_regset_setbit(&_jitc->regarg, _R6); + jit_regset_setbit(&_jitc->regarg, _R7); return (_R6); } if (jit_reg_free_p(_R8) && jit_reg_free_p(_R9)) { - jit_regset_setbit(_jitc->regarg, _R8); - jit_regset_setbit(_jitc->regarg, _R9); + jit_regset_setbit(&_jitc->regarg, _R8); + jit_regset_setbit(&_jitc->regarg, _R9); return (_R8); } return (JIT_NOREG); diff --git a/lib/jit_mips-cpu.c b/lib/jit_mips-cpu.c index 18ee0d8ea..25c1a7f8e 100644 --- a/lib/jit_mips-cpu.c +++ b/lib/jit_mips-cpu.c @@ -2781,71 +2781,71 @@ _prolog(jit_state_t *_jit, jit_node_t *node) /* callee save registers */ subi(_SP_REGNO, _SP_REGNO, stack_framesize); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jitc->function->regset, _F30)) + if (jit_regset_tstbit(&_jitc->function->regset, _F30)) stxi_d(96, _SP_REGNO, _F30_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F28)) + if (jit_regset_tstbit(&_jitc->function->regset, _F28)) stxi_d(88, _SP_REGNO, _F28_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F26)) + if (jit_regset_tstbit(&_jitc->function->regset, _F26)) stxi_d(80, _SP_REGNO, _F26_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F24)) + if (jit_regset_tstbit(&_jitc->function->regset, _F24)) stxi_d(72, _SP_REGNO, _F24_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F22)) + if (jit_regset_tstbit(&_jitc->function->regset, _F22)) stxi_d(64, _SP_REGNO, _F22_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F20)) + if (jit_regset_tstbit(&_jitc->function->regset, _F20)) stxi_d(56, _SP_REGNO, _F20_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F18)) + if (jit_regset_tstbit(&_jitc->function->regset, _F18)) stxi_d(48, _SP_REGNO, _F18_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F16)) + if (jit_regset_tstbit(&_jitc->function->regset, _F16)) stxi_d(40, _SP_REGNO, _F16_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S7)) + if (jit_regset_tstbit(&_jitc->function->regset, _S7)) stxi(36, _SP_REGNO, _S7_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S6)) + if (jit_regset_tstbit(&_jitc->function->regset, _S6)) stxi(32, _SP_REGNO, _S6_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S5)) + if (jit_regset_tstbit(&_jitc->function->regset, _S5)) stxi(28, _SP_REGNO, _S5_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S4)) + if (jit_regset_tstbit(&_jitc->function->regset, _S4)) stxi(24, _SP_REGNO, _S4_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S3)) + if (jit_regset_tstbit(&_jitc->function->regset, _S3)) stxi(20, _SP_REGNO, _S3_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S2)) + if (jit_regset_tstbit(&_jitc->function->regset, _S2)) stxi(16, _SP_REGNO, _S2_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S1)) + if (jit_regset_tstbit(&_jitc->function->regset, _S1)) stxi(12, _SP_REGNO, _S1_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S0)) + if (jit_regset_tstbit(&_jitc->function->regset, _S0)) stxi( 8, _SP_REGNO, _S0_REGNO); stxi( 4, _SP_REGNO, _RA_REGNO); #else - if (jit_regset_tstbit(_jitc->function->regset, _F30)) + if (jit_regset_tstbit(&_jitc->function->regset, _F30)) stxi_d(136, _SP_REGNO, _F30_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F28)) + if (jit_regset_tstbit(&_jitc->function->regset, _F28)) stxi_d(128, _SP_REGNO, _F28_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F26)) + if (jit_regset_tstbit(&_jitc->function->regset, _F26)) stxi_d(120, _SP_REGNO, _F26_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F24)) + if (jit_regset_tstbit(&_jitc->function->regset, _F24)) stxi_d(112, _SP_REGNO, _F24_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F22)) + if (jit_regset_tstbit(&_jitc->function->regset, _F22)) stxi_d(104, _SP_REGNO, _F22_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F20)) + if (jit_regset_tstbit(&_jitc->function->regset, _F20)) stxi_d(96, _SP_REGNO, _F20_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F18)) + if (jit_regset_tstbit(&_jitc->function->regset, _F18)) stxi_d(88, _SP_REGNO, _F18_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _F16)) + if (jit_regset_tstbit(&_jitc->function->regset, _F16)) stxi_d(80, _SP_REGNO, _F16_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S7)) + if (jit_regset_tstbit(&_jitc->function->regset, _S7)) stxi(72, _SP_REGNO, _S7_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S6)) + if (jit_regset_tstbit(&_jitc->function->regset, _S6)) stxi(64, _SP_REGNO, _S6_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S5)) + if (jit_regset_tstbit(&_jitc->function->regset, _S5)) stxi(56, _SP_REGNO, _S5_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S4)) + if (jit_regset_tstbit(&_jitc->function->regset, _S4)) stxi(48, _SP_REGNO, _S4_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S3)) + if (jit_regset_tstbit(&_jitc->function->regset, _S3)) stxi(40, _SP_REGNO, _S3_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S2)) + if (jit_regset_tstbit(&_jitc->function->regset, _S2)) stxi(32, _SP_REGNO, _S2_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S1)) + if (jit_regset_tstbit(&_jitc->function->regset, _S1)) stxi(24, _SP_REGNO, _S1_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _S0)) + if (jit_regset_tstbit(&_jitc->function->regset, _S0)) stxi(16, _SP_REGNO, _S0_REGNO); stxi( 8, _SP_REGNO, _RA_REGNO); #endif @@ -2862,71 +2862,71 @@ _epilog(jit_state_t *_jit, jit_node_t *node) /* callee save registers */ movr(_SP_REGNO, _BP_REGNO); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jitc->function->regset, _F30)) + if (jit_regset_tstbit(&_jitc->function->regset, _F30)) ldxi_d(_F30_REGNO, _SP_REGNO, 96); - if (jit_regset_tstbit(_jitc->function->regset, _F28)) + if (jit_regset_tstbit(&_jitc->function->regset, _F28)) ldxi_d(_F28_REGNO, _SP_REGNO, 88); - if (jit_regset_tstbit(_jitc->function->regset, _F26)) + if (jit_regset_tstbit(&_jitc->function->regset, _F26)) ldxi_d(_F26_REGNO, _SP_REGNO, 80); - if (jit_regset_tstbit(_jitc->function->regset, _F24)) + if (jit_regset_tstbit(&_jitc->function->regset, _F24)) ldxi_d(_F24_REGNO, _SP_REGNO, 72); - if (jit_regset_tstbit(_jitc->function->regset, _F22)) + if (jit_regset_tstbit(&_jitc->function->regset, _F22)) ldxi_d(_F22_REGNO, _SP_REGNO, 64); - if (jit_regset_tstbit(_jitc->function->regset, _F20)) + if (jit_regset_tstbit(&_jitc->function->regset, _F20)) ldxi_d(_F20_REGNO, _SP_REGNO, 56); - if (jit_regset_tstbit(_jitc->function->regset, _F18)) + if (jit_regset_tstbit(&_jitc->function->regset, _F18)) ldxi_d(_F18_REGNO, _SP_REGNO, 48); - if (jit_regset_tstbit(_jitc->function->regset, _F16)) + if (jit_regset_tstbit(&_jitc->function->regset, _F16)) ldxi_d(_F16_REGNO, _SP_REGNO, 40); - if (jit_regset_tstbit(_jitc->function->regset, _S7)) + if (jit_regset_tstbit(&_jitc->function->regset, _S7)) ldxi(_S7_REGNO, _SP_REGNO, 36); - if (jit_regset_tstbit(_jitc->function->regset, _S6)) + if (jit_regset_tstbit(&_jitc->function->regset, _S6)) ldxi(_S6_REGNO, _SP_REGNO, 32); - if (jit_regset_tstbit(_jitc->function->regset, _S5)) + if (jit_regset_tstbit(&_jitc->function->regset, _S5)) ldxi(_S5_REGNO, _SP_REGNO, 28); - if (jit_regset_tstbit(_jitc->function->regset, _S4)) + if (jit_regset_tstbit(&_jitc->function->regset, _S4)) ldxi(_S4_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jitc->function->regset, _S3)) + if (jit_regset_tstbit(&_jitc->function->regset, _S3)) ldxi(_S3_REGNO, _SP_REGNO, 20); - if (jit_regset_tstbit(_jitc->function->regset, _S2)) + if (jit_regset_tstbit(&_jitc->function->regset, _S2)) ldxi(_S2_REGNO, _SP_REGNO, 16); - if (jit_regset_tstbit(_jitc->function->regset, _S1)) + if (jit_regset_tstbit(&_jitc->function->regset, _S1)) ldxi(_S1_REGNO, _SP_REGNO, 12); - if (jit_regset_tstbit(_jitc->function->regset, _S0)) + if (jit_regset_tstbit(&_jitc->function->regset, _S0)) ldxi(_S0_REGNO, _SP_REGNO, 8); ldxi(_RA_REGNO, _SP_REGNO, 4); #else - if (jit_regset_tstbit(_jitc->function->regset, _F30)) + if (jit_regset_tstbit(&_jitc->function->regset, _F30)) ldxi_d(_F30_REGNO, _SP_REGNO, 136); - if (jit_regset_tstbit(_jitc->function->regset, _F28)) + if (jit_regset_tstbit(&_jitc->function->regset, _F28)) ldxi_d(_F28_REGNO, _SP_REGNO, 128); - if (jit_regset_tstbit(_jitc->function->regset, _F26)) + if (jit_regset_tstbit(&_jitc->function->regset, _F26)) ldxi_d(_F26_REGNO, _SP_REGNO, 120); - if (jit_regset_tstbit(_jitc->function->regset, _F24)) + if (jit_regset_tstbit(&_jitc->function->regset, _F24)) ldxi_d(_F24_REGNO, _SP_REGNO, 112); - if (jit_regset_tstbit(_jitc->function->regset, _F22)) + if (jit_regset_tstbit(&_jitc->function->regset, _F22)) ldxi_d(_F22_REGNO, _SP_REGNO, 104); - if (jit_regset_tstbit(_jitc->function->regset, _F20)) + if (jit_regset_tstbit(&_jitc->function->regset, _F20)) ldxi_d(_F20_REGNO, _SP_REGNO, 96); - if (jit_regset_tstbit(_jitc->function->regset, _F18)) + if (jit_regset_tstbit(&_jitc->function->regset, _F18)) ldxi_d(_F18_REGNO, _SP_REGNO, 88); - if (jit_regset_tstbit(_jitc->function->regset, _F16)) + if (jit_regset_tstbit(&_jitc->function->regset, _F16)) ldxi_d(_F16_REGNO, _SP_REGNO, 80); - if (jit_regset_tstbit(_jitc->function->regset, _S7)) + if (jit_regset_tstbit(&_jitc->function->regset, _S7)) ldxi(_S7_REGNO, _SP_REGNO, 72); - if (jit_regset_tstbit(_jitc->function->regset, _S6)) + if (jit_regset_tstbit(&_jitc->function->regset, _S6)) ldxi(_S6_REGNO, _SP_REGNO, 64); - if (jit_regset_tstbit(_jitc->function->regset, _S5)) + if (jit_regset_tstbit(&_jitc->function->regset, _S5)) ldxi(_S5_REGNO, _SP_REGNO, 56); - if (jit_regset_tstbit(_jitc->function->regset, _S4)) + if (jit_regset_tstbit(&_jitc->function->regset, _S4)) ldxi(_S4_REGNO, _SP_REGNO, 48); - if (jit_regset_tstbit(_jitc->function->regset, _S3)) + if (jit_regset_tstbit(&_jitc->function->regset, _S3)) ldxi(_S3_REGNO, _SP_REGNO, 40); - if (jit_regset_tstbit(_jitc->function->regset, _S2)) + if (jit_regset_tstbit(&_jitc->function->regset, _S2)) ldxi(_S2_REGNO, _SP_REGNO, 32); - if (jit_regset_tstbit(_jitc->function->regset, _S1)) + if (jit_regset_tstbit(&_jitc->function->regset, _S1)) ldxi(_S1_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jitc->function->regset, _S0)) + if (jit_regset_tstbit(&_jitc->function->regset, _S0)) ldxi(_S0_REGNO, _SP_REGNO, 16); ldxi(_RA_REGNO, _SP_REGNO, 8); #endif diff --git a/lib/jit_mips.c b/lib/jit_mips.c index 29e087111..952c1ba74 100644 --- a/lib/jit_mips.c +++ b/lib/jit_mips.c @@ -120,8 +120,8 @@ _jit_prolog(jit_state_t *_jit) if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jitc->regarg, 0) == 0); - jit_regset_set_ui(_jitc->regsav, 0); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); offset = _jitc->functions.offset; if (offset >= _jitc->functions.length) { jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, @@ -147,7 +147,7 @@ _jit_prolog(jit_state_t *_jit) */ _jitc->function->epilog->w.w = offset; - jit_regset_new(_jitc->function->regset); + jit_regset_new(&_jitc->function->regset); } jit_int32_t diff --git a/lib/jit_ppc-cpu.c b/lib/jit_ppc-cpu.c index c18222705..25b3328d2 100644 --- a/lib/jit_ppc-cpu.c +++ b/lib/jit_ppc-cpu.c @@ -3076,12 +3076,12 @@ _prolog(jit_state_t *_jit, jit_node_t *node) # if __WORDSIZE == 32 /* save any clobbered callee save gpr register */ - regno = jit_regset_scan1(_jitc->function->regset, _R14); + regno = jit_regset_scan1(&_jitc->function->regset, _R14); if (regno == ULONG_MAX || regno > _R31) regno = _R31; /* aka _FP_REGNO */ STMW(rn(regno), _SP_REGNO, -fpr_save_area - (32 * 4) + rn(regno) * 4); for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(_jitc->function->regset, _F14 + offset)) + if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) stxi_d(-fpr_save_area + offset * 8, _SP_REGNO, rn(_F14 + offset)); } @@ -3093,11 +3093,11 @@ _prolog(jit_state_t *_jit, jit_node_t *node) stxi(16, _SP_REGNO, _R0_REGNO); offset = -144; for (regno = 0; regno < jit_size(save); regno++, offset += 8) { - if (jit_regset_tstbit(_jitc->function->regset, save[regno])) + if (jit_regset_tstbit(&_jitc->function->regset, save[regno])) stxi(offset, _SP_REGNO, rn(save[regno])); } for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(_jitc->function->regset, _F14 + offset)) + if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) stxi_d(-(152 + offset * 8), _SP_REGNO, rn(_F14 + offset)); } @@ -3119,12 +3119,12 @@ _epilog(jit_state_t *_jit, jit_node_t *node) MTLR(_R0_REGNO); - regno = jit_regset_scan1(_jitc->function->regset, _R14); + regno = jit_regset_scan1(&_jitc->function->regset, _R14); if (regno == ULONG_MAX || regno > _R31) regno = _R31; /* aka _FP_REGNO */ LMW(rn(regno), _SP_REGNO, -fpr_save_area - (32 * 4) + rn(regno) * 4); for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(_jitc->function->regset, _F14 + offset)) + if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) ldxi_d(rn(_F14 + offset), _SP_REGNO, -fpr_save_area + offset * 8); } @@ -3133,11 +3133,11 @@ _epilog(jit_state_t *_jit, jit_node_t *node) ldxi(_R0_REGNO, _SP_REGNO, 16); offset = -144; for (regno = 0; regno < jit_size(save); regno++, offset += 8) { - if (jit_regset_tstbit(_jitc->function->regset, save[regno])) + if (jit_regset_tstbit(&_jitc->function->regset, save[regno])) ldxi(rn(save[regno]), _SP_REGNO, offset); } for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(_jitc->function->regset, _F14 + offset)) + if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) ldxi_d(rn(_F14 + offset), _SP_REGNO, -(152 + offset * 8)); } diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c index 1f1c6b4ba..5dc22d7f2 100644 --- a/lib/jit_ppc.c +++ b/lib/jit_ppc.c @@ -131,8 +131,8 @@ _jit_prolog(jit_state_t *_jit) if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jitc->regarg, 0) == 0); - jit_regset_set_ui(_jitc->regsav, 0); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); offset = _jitc->functions.offset; if (offset >= _jitc->functions.length) { jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, @@ -160,7 +160,7 @@ _jit_prolog(jit_state_t *_jit) */ _jitc->function->epilog->w.w = offset; - jit_regset_new(_jitc->function->regset); + jit_regset_new(&_jitc->function->regset); } jit_int32_t diff --git a/lib/jit_print.c b/lib/jit_print.c index 07b22094d..f692e3c1f 100644 --- a/lib/jit_print.c +++ b/lib/jit_print.c @@ -239,7 +239,7 @@ _jit_print(jit_state_t *_jit) print_chr(':'); block = _jitc->blocks.ptr + node->v.w; for (offset = 0; offset < _jitc->reglen; offset++) { - if (jit_regset_tstbit(block->reglive, offset)) { + if (jit_regset_tstbit(&block->reglive, offset)) { print_chr(' '); print_reg(offset); } diff --git a/lib/jit_sparc-cpu.c b/lib/jit_sparc-cpu.c index 8bb20d318..3ddbfd9b6 100644 --- a/lib/jit_sparc-cpu.c +++ b/lib/jit_sparc-cpu.c @@ -1626,21 +1626,21 @@ _prolog(jit_state_t *_jit, jit_node_t *node) /* (most) other backends do not save incoming arguments, so, * only save locals here */ - if (jit_regset_tstbit(_jitc->function->regset, _L0)) + if (jit_regset_tstbit(&_jitc->function->regset, _L0)) stxi(0, _SP_REGNO, _L0_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L1)) + if (jit_regset_tstbit(&_jitc->function->regset, _L1)) stxi(4, _SP_REGNO, _L1_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L2)) + if (jit_regset_tstbit(&_jitc->function->regset, _L2)) stxi(8, _SP_REGNO, _L2_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L3)) + if (jit_regset_tstbit(&_jitc->function->regset, _L3)) stxi(12, _SP_REGNO, _L3_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L4)) + if (jit_regset_tstbit(&_jitc->function->regset, _L4)) stxi(16, _SP_REGNO, _L4_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L5)) + if (jit_regset_tstbit(&_jitc->function->regset, _L5)) stxi(20, _SP_REGNO, _L5_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L6)) + if (jit_regset_tstbit(&_jitc->function->regset, _L6)) stxi(24, _SP_REGNO, _L6_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _L7)) + if (jit_regset_tstbit(&_jitc->function->regset, _L7)) stxi(28, _SP_REGNO, _L7_REGNO); } @@ -1649,21 +1649,21 @@ _epilog(jit_state_t *_jit, jit_node_t *node) { /* (most) other backends do not save incoming arguments, so, * only save locals here */ - if (jit_regset_tstbit(_jitc->function->regset, _L0)) + if (jit_regset_tstbit(&_jitc->function->regset, _L0)) ldxi(_L0_REGNO, _SP_REGNO, 0); - if (jit_regset_tstbit(_jitc->function->regset, _L1)) + if (jit_regset_tstbit(&_jitc->function->regset, _L1)) ldxi(_L1_REGNO, _SP_REGNO, 4); - if (jit_regset_tstbit(_jitc->function->regset, _L2)) + if (jit_regset_tstbit(&_jitc->function->regset, _L2)) ldxi(_L2_REGNO, _SP_REGNO, 8); - if (jit_regset_tstbit(_jitc->function->regset, _L3)) + if (jit_regset_tstbit(&_jitc->function->regset, _L3)) ldxi(_L3_REGNO, _SP_REGNO, 12); - if (jit_regset_tstbit(_jitc->function->regset, _L4)) + if (jit_regset_tstbit(&_jitc->function->regset, _L4)) ldxi(_L4_REGNO, _SP_REGNO, 16); - if (jit_regset_tstbit(_jitc->function->regset, _L5)) + if (jit_regset_tstbit(&_jitc->function->regset, _L5)) ldxi(_L5_REGNO, _SP_REGNO, 20); - if (jit_regset_tstbit(_jitc->function->regset, _L6)) + if (jit_regset_tstbit(&_jitc->function->regset, _L6)) ldxi(_L6_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jitc->function->regset, _L7)) + if (jit_regset_tstbit(&_jitc->function->regset, _L7)) ldxi(_L7_REGNO, _SP_REGNO, 28); RESTOREI(0, 0, 0); RETL(); diff --git a/lib/jit_sparc.c b/lib/jit_sparc.c index a9eab396b..5142c8c41 100644 --- a/lib/jit_sparc.c +++ b/lib/jit_sparc.c @@ -105,8 +105,8 @@ _jit_prolog(jit_state_t *_jit) if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jitc->regarg, 0) == 0); - jit_regset_set_ui(_jitc->regsav, 0); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); offset = _jitc->functions.offset; if (offset >= _jitc->functions.length) { jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, @@ -134,7 +134,7 @@ _jit_prolog(jit_state_t *_jit) */ _jitc->function->epilog->w.w = offset; - jit_regset_new(_jitc->function->regset); + jit_regset_new(&_jitc->function->regset); } jit_int32_t diff --git a/lib/jit_x86-cpu.c b/lib/jit_x86-cpu.c index 2565e195f..0a0b9db4f 100644 --- a/lib/jit_x86-cpu.c +++ b/lib/jit_x86-cpu.c @@ -867,8 +867,8 @@ _save(jit_state_t *_jit, jit_int32_t r0) _jitc->function->regoff[r0] = jit_allocai(sizeof(jit_word_t)); _jitc->again = 1; } - assert(!jit_regset_tstbit(_jitc->regsav, r0)); - jit_regset_setbit(_jitc->regsav, r0); + assert(!jit_regset_tstbit(&_jitc->regsav, r0)); + jit_regset_setbit(&_jitc->regsav, r0); stxi(_jitc->function->regoff[r0], _RBP_REGNO, r0); } @@ -876,8 +876,8 @@ static void _load(jit_state_t *_jit, jit_int32_t r0) { assert(_jitc->function->regoff[r0]); - assert(jit_regset_tstbit(_jitc->regsav, r0)); - jit_regset_clrbit(_jitc->regsav, r0); + assert(jit_regset_tstbit(&_jitc->regsav, r0)); + jit_regset_clrbit(&_jitc->regsav, r0); ldxi(r0, _RBP_REGNO, _jitc->function->regoff[r0]); } @@ -1199,8 +1199,8 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) if (set & (1 << rn)) \ (void)jit_get_reg(rv|jit_class_gpr|jit_class_named); \ if (sav & (1 << rn)) { \ - if ( jit_regset_tstbit(_jitc->regsav, rv) || \ - !jit_regset_tstbit(_jitc->reglive, rv)) \ + if ( jit_regset_tstbit(&_jitc->regsav, rv) || \ + !jit_regset_tstbit(&_jitc->reglive, rv)) \ sav &= ~(1 << rn); \ else \ save(rv); \ @@ -3313,22 +3313,22 @@ _prolog(jit_state_t *_jit, jit_node_t *node) /* callee save registers */ subi(_RSP_REGNO, _RSP_REGNO, stack_framesize - sizeof(jit_word_t)); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jitc->function->regset, _RDI)) + if (jit_regset_tstbit(&_jitc->function->regset, _RDI)) stxi(12, _RSP_REGNO, _RDI_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _RSI)) + if (jit_regset_tstbit(&_jitc->function->regset, _RSI)) stxi( 8, _RSP_REGNO, _RSI_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _RBX)) + if (jit_regset_tstbit(&_jitc->function->regset, _RBX)) stxi( 4, _RSP_REGNO, _RBX_REGNO); #else - if (jit_regset_tstbit(_jitc->function->regset, _RBX)) + if (jit_regset_tstbit(&_jitc->function->regset, _RBX)) stxi(40, _RSP_REGNO, _RBX_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _R12)) + if (jit_regset_tstbit(&_jitc->function->regset, _R12)) stxi(32, _RSP_REGNO, _R12_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _R13)) + if (jit_regset_tstbit(&_jitc->function->regset, _R13)) stxi(24, _RSP_REGNO, _R13_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _R14)) + if (jit_regset_tstbit(&_jitc->function->regset, _R14)) stxi(16, _RSP_REGNO, _R14_REGNO); - if (jit_regset_tstbit(_jitc->function->regset, _R15)) + if (jit_regset_tstbit(&_jitc->function->regset, _R15)) stxi( 8, _RSP_REGNO, _R15_REGNO); #endif stxi(0, _RSP_REGNO, _RBP_REGNO); @@ -3344,22 +3344,22 @@ _epilog(jit_state_t *_jit, jit_node_t *node) /* callee save registers */ movr(_RSP_REGNO, _RBP_REGNO); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jitc->function->regset, _RDI)) + if (jit_regset_tstbit(&_jitc->function->regset, _RDI)) ldxi(_RDI_REGNO, _RSP_REGNO, 12); - if (jit_regset_tstbit(_jitc->function->regset, _RSI)) + if (jit_regset_tstbit(&_jitc->function->regset, _RSI)) ldxi(_RSI_REGNO, _RSP_REGNO, 8); - if (jit_regset_tstbit(_jitc->function->regset, _RBX)) + if (jit_regset_tstbit(&_jitc->function->regset, _RBX)) ldxi(_RBX_REGNO, _RSP_REGNO, 4); #else - if (jit_regset_tstbit(_jitc->function->regset, _RBX)) + if (jit_regset_tstbit(&_jitc->function->regset, _RBX)) ldxi(_RBX_REGNO, _RSP_REGNO, 40); - if (jit_regset_tstbit(_jitc->function->regset, _R12)) + if (jit_regset_tstbit(&_jitc->function->regset, _R12)) ldxi(_R12_REGNO, _RSP_REGNO, 32); - if (jit_regset_tstbit(_jitc->function->regset, _R13)) + if (jit_regset_tstbit(&_jitc->function->regset, _R13)) ldxi(_R13_REGNO, _RSP_REGNO, 24); - if (jit_regset_tstbit(_jitc->function->regset, _R14)) + if (jit_regset_tstbit(&_jitc->function->regset, _R14)) ldxi(_R14_REGNO, _RSP_REGNO, 16); - if (jit_regset_tstbit(_jitc->function->regset, _R15)) + if (jit_regset_tstbit(&_jitc->function->regset, _R15)) ldxi(_R15_REGNO, _RSP_REGNO, 8); #endif ldxi(_RBP_REGNO, _RSP_REGNO, 0); diff --git a/lib/jit_x86.c b/lib/jit_x86.c index 345dad7e7..3908f581f 100644 --- a/lib/jit_x86.c +++ b/lib/jit_x86.c @@ -294,8 +294,8 @@ _jit_prolog(jit_state_t *_jit) if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jitc->regarg, 0) == 0); - jit_regset_set_ui(_jitc->regsav, 0); + assert(jit_regset_cmp_ui(&_jitc->regarg, 0) == 0); + jit_regset_set_ui(&_jitc->regsav, 0); offset = _jitc->functions.offset; if (offset >= _jitc->functions.length) { jit_realloc((jit_pointer_t *)&_jitc->functions.ptr, @@ -323,7 +323,7 @@ _jit_prolog(jit_state_t *_jit) */ _jitc->function->epilog->w.w = offset; - jit_regset_new(_jitc->function->regset); + jit_regset_new(&_jitc->function->regset); } jit_int32_t @@ -784,13 +784,13 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) * registers, and not save/restore it, what would be wrong if using the * the return value, otherwise, just a needless noop */ /* >> prevent %rax from being allocated as the function pointer */ - jit_regset_setbit(_jitc->regarg, _RAX); + jit_regset_setbit(&_jitc->regarg, _RAX); reg = jit_get_reg(jit_class_gpr); node = jit_movi(reg, (jit_word_t)i0); jit_finishr(reg); jit_unget_reg(reg); /* << prevent %rax from being allocated as the function pointer */ - jit_regset_clrbit(_jitc->regarg, _RAX); + jit_regset_clrbit(&_jitc->regarg, _RAX); #else node = jit_calli(i0); node->v.w = _jitc->function->call.argi; diff --git a/lib/lightning.c b/lib/lightning.c index 58b1a558e..79327dee7 100644 --- a/lib/lightning.c +++ b/lib/lightning.c @@ -182,19 +182,19 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) spec = regspec & ~(jit_class_chk|jit_class_nospill); if (spec & jit_class_named) { regno = jit_regno(spec); - if (jit_regset_tstbit(_jitc->regsav, regno)) + if (jit_regset_tstbit(&_jitc->regsav, regno)) /* fail if register is spilled */ goto fail; - if (jit_regset_tstbit(_jitc->regarg, regno)) + if (jit_regset_tstbit(&_jitc->regarg, regno)) /* fail if register is an argument to current instruction */ goto fail; - if (jit_regset_tstbit(_jitc->reglive, regno)) { + if (jit_regset_tstbit(&_jitc->reglive, regno)) { if (regspec & jit_class_nospill) /* fail if register is live and should not spill/reload */ goto fail; goto spill; } - jit_regset_setbit(_jitc->regarg, regno); + jit_regset_setbit(&_jitc->regarg, regno); return (regno); } else @@ -204,8 +204,8 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) /* search for a free register matching spec */ for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jitc->regarg, regno) && - !jit_regset_tstbit(_jitc->reglive, regno)) + !jit_regset_tstbit(&_jitc->regarg, regno) && + !jit_regset_tstbit(&_jitc->reglive, regno)) goto regarg; } @@ -213,8 +213,8 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) * for the current instruction */ for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jitc->regsav, regno) && - !jit_regset_tstbit(_jitc->regarg, regno) && + !jit_regset_tstbit(&_jitc->regsav, regno) && + !jit_regset_tstbit(&_jitc->regarg, regno) && !(regspec & jit_class_nospill)) { spill: assert(_jitc->function); @@ -234,15 +234,15 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) } emit_stxi_d(_jitc->function->regoff[regno], JIT_FP, regno); } - jit_regset_setbit(_jitc->regsav, regno); + jit_regset_setbit(&_jitc->regsav, regno); regarg: - jit_regset_setbit(_jitc->regarg, regno); + jit_regset_setbit(&_jitc->regarg, regno); if (jit_class(_rvs[regno].spec) & jit_class_sav) { /* if will modify callee save registers without a * function prolog, better patch this assertion */ assert(_jitc->function); - if (!jit_regset_tstbit(_jitc->function->regset, regno)) { - jit_regset_setbit(_jitc->function->regset, regno); + if (!jit_regset_tstbit(&_jitc->function->regset, regno)) { + jit_regset_setbit(&_jitc->function->regset, regno); _jitc->again = 1; } } @@ -255,10 +255,10 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) assert(!(regspec & jit_class_nospill)); for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jitc->regsav, regno) && - !jit_regset_tstbit(_jitc->regarg, regno)) { - jit_regset_setbit(_jitc->regarg, regno); - jit_regset_setbit(_jitc->regsav, regno); + !jit_regset_tstbit(&_jitc->regsav, regno) && + !jit_regset_tstbit(&_jitc->regarg, regno)) { + jit_regset_setbit(&_jitc->regarg, regno); + jit_regset_setbit(&_jitc->regsav, regno); jit_save(regno); return (jit_regno_patch|regno); } @@ -275,7 +275,7 @@ void _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno) { regno = jit_regno(regno); - if (jit_regset_tstbit(_jitc->regsav, regno)) { + if (jit_regset_tstbit(&_jitc->regsav, regno)) { if (_jitc->emit) { if (jit_class(_rvs[regno].spec) & jit_class_gpr) emit_ldxi(regno, JIT_FP, _jitc->function->regoff[regno]); @@ -284,18 +284,18 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno) } else jit_load(regno); - jit_regset_clrbit(_jitc->regsav, regno); + jit_regset_clrbit(&_jitc->regsav, regno); } - assert(jit_regset_tstbit(_jitc->regarg, regno)); - jit_regset_clrbit(_jitc->regarg, regno); + assert(jit_regset_tstbit(&_jitc->regarg, regno)); + jit_regset_clrbit(&_jitc->regarg, regno); } unsigned long -jit_regset_scan1(jit_regset_t set, jit_int32_t offset) +jit_regset_scan1(jit_regset_t *set, jit_int32_t offset) { assert(offset >= 0 && offset <= 63); for (; offset < 64; offset++) { - if (set & (1LL << offset)) + if (*set & (1LL << offset)) return (offset); } return (ULONG_MAX); @@ -508,8 +508,8 @@ _del_label(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) /* del_label() should only be called when optimizing. * This will leave an empty block index */ - jit_regset_del(block->reglive); - jit_regset_del(block->regmask); + jit_regset_del(&block->reglive); + jit_regset_del(&block->regmask); block->label = NULL; /* redundant, should be already true */ @@ -579,10 +579,10 @@ jit_new_state(void) jit_alloc((jit_pointer_t *)&_jit, sizeof(jit_state_t)); jit_alloc((jit_pointer_t *)&_jitc, sizeof(jit_compiler_t)); - jit_regset_new(_jitc->regarg); - jit_regset_new(_jitc->regsav); - jit_regset_new(_jitc->reglive); - jit_regset_new(_jitc->regmask); + jit_regset_new(&_jitc->regarg); + jit_regset_new(&_jitc->regsav); + jit_regset_new(&_jitc->reglive); + jit_regset_new(&_jitc->regmask); bmp_init(); jit_init(); @@ -891,8 +891,8 @@ _jit_link(jit_state_t *_jit, jit_node_t *node) block = _jitc->blocks.ptr + _jitc->blocks.offset; block->label = node; node->v.w = _jitc->blocks.offset; - jit_regset_new(block->reglive); - jit_regset_new(block->regmask); + jit_regset_new(&block->reglive); + jit_regset_new(&block->regmask); ++_jitc->blocks.offset; } @@ -1216,7 +1216,7 @@ _jit_optimize(jit_state_t *_jit) if (!block->label) continue; if (block->label->code != jit_code_epilog) { - jit_regset_set(_jitc->regmask, block->regmask); + jit_regset_set(&_jitc->regmask, &block->regmask); jit_update(block->label->next, &block->reglive, &_jitc->regmask); } } @@ -1283,11 +1283,11 @@ _jit_optimize(jit_state_t *_jit) if (_jitc->function) { if ((mask & (jit_cc_a0_reg|jit_cc_a0_chg)) == (jit_cc_a0_reg|jit_cc_a0_chg)) - jit_regset_setbit(_jitc->function->regset, + jit_regset_setbit(&_jitc->function->regset, jit_regno(node->u.w)); if ((mask & (jit_cc_a1_reg|jit_cc_a1_chg)) == (jit_cc_a1_reg|jit_cc_a1_chg)) - jit_regset_setbit(_jitc->function->regset, + jit_regset_setbit(&_jitc->function->regset, jit_regno(node->v.w)); } break; @@ -1331,34 +1331,34 @@ _jit_reglive(jit_state_t *_jit, jit_node_t *node) switch (node->code) { case jit_code_label: case jit_code_prolog: case jit_code_epilog: block = _jitc->blocks.ptr + node->v.w; - jit_regset_set(_jitc->reglive, block->reglive); + jit_regset_set(&_jitc->reglive, &block->reglive); break; case jit_code_callr: value = jit_regno(node->u.w); if (!(node->u.w & jit_regno_patch)) { - jit_regset_setbit(_jitc->reglive, value); + jit_regset_setbit(&_jitc->reglive, value); } case jit_code_calli: for (value = 0; value < _jitc->reglen; value++) { spec = jit_class(_rvs[value].spec); if ((spec & jit_class_arg) && jit_regarg_p(node, value)) - jit_regset_setbit(_jitc->reglive, value); + jit_regset_setbit(&_jitc->reglive, value); else if (!(spec & jit_class_sav)) - jit_regset_clrbit(_jitc->reglive, value); + jit_regset_clrbit(&_jitc->reglive, value); } #if defined(JIT_RET) /* Explicitly set return registers as live, because retval * should be free to not create a note, and/or user not * call jit_retval (but not a good idea to expect JIT_R0 * to match JIT_RET) */ - jit_regset_setbit(_jitc->reglive, JIT_RET); + jit_regset_setbit(&_jitc->reglive, JIT_RET); # if __arm__ /* FIXME need a better logic (and r2-r3 may contain results) */ - jit_regset_setbit(_jitc->reglive, _R1); + jit_regset_setbit(&_jitc->reglive, _R1); # endif #endif #if defined(JIT_FRET) - jit_regset_setbit(_jitc->reglive, JIT_FRET); + jit_regset_setbit(&_jitc->reglive, JIT_FRET); #endif break; default: @@ -1367,49 +1367,50 @@ _jit_reglive(jit_state_t *_jit, jit_node_t *node) if (value & jit_cc_a0_rlh) { if (!(node->u.q.l & jit_regno_patch)) { if (value & jit_cc_a0_chg) { - jit_regset_clrbit(_jitc->reglive, node->u.q.l); - jit_regset_setbit(_jitc->regmask, node->u.q.l); + jit_regset_clrbit(&_jitc->reglive, node->u.q.l); + jit_regset_setbit(&_jitc->regmask, node->u.q.l); } else - jit_regset_setbit(_jitc->reglive, node->u.q.l); + jit_regset_setbit(&_jitc->reglive, node->u.q.l); } if (!(node->u.q.h & jit_regno_patch)) { if (value & jit_cc_a0_chg) { - jit_regset_clrbit(_jitc->reglive, node->u.q.h); - jit_regset_setbit(_jitc->regmask, node->u.q.h); + jit_regset_clrbit(&_jitc->reglive, node->u.q.h); + jit_regset_setbit(&_jitc->regmask, node->u.q.h); } else - jit_regset_setbit(_jitc->reglive, node->u.q.h); + jit_regset_setbit(&_jitc->reglive, node->u.q.h); } } else { if (!(node->u.w & jit_regno_patch)) { if (value & jit_cc_a0_chg) { - jit_regset_clrbit(_jitc->reglive, node->u.w); - jit_regset_setbit(_jitc->regmask, node->u.w); + jit_regset_clrbit(&_jitc->reglive, node->u.w); + jit_regset_setbit(&_jitc->regmask, node->u.w); } else - jit_regset_setbit(_jitc->reglive, node->u.w); + jit_regset_setbit(&_jitc->reglive, node->u.w); } } } if ((value & jit_cc_a1_reg) && !(node->v.w & jit_regno_patch)) { if (value & jit_cc_a1_chg) { - jit_regset_clrbit(_jitc->reglive, node->v.w); - jit_regset_setbit(_jitc->regmask, node->v.w); + jit_regset_clrbit(&_jitc->reglive, node->v.w); + jit_regset_setbit(&_jitc->regmask, node->v.w); } else - jit_regset_setbit(_jitc->reglive, node->v.w); + jit_regset_setbit(&_jitc->reglive, node->v.w); } if ((value & jit_cc_a2_reg) && !(node->w.w & jit_regno_patch)) - jit_regset_setbit(_jitc->reglive, node->w.w); - if (jit_regset_set_p(_jitc->regmask)) { + jit_regset_setbit(&_jitc->reglive, node->w.w); + if (jit_regset_set_p(&_jitc->regmask)) { bmp_zero(); jit_update(node->next, &_jitc->reglive, &_jitc->regmask); - if (jit_regset_set_p(_jitc->regmask)) { + if (jit_regset_set_p(&_jitc->regmask)) { /* any unresolved live state is considered as live */ - jit_regset_ior(_jitc->reglive, _jitc->reglive, _jitc->regmask); - jit_regset_set_ui(_jitc->regmask, 0); + jit_regset_ior(&_jitc->reglive, + &_jitc->reglive, &_jitc->regmask); + jit_regset_set_ui(&_jitc->regmask, 0); } } break; @@ -1421,16 +1422,16 @@ _jit_regarg_set(jit_state_t *_jit, jit_node_t *node, jit_int32_t value) { if (value & jit_cc_a0_reg) { if (value & jit_cc_a0_rlh) { - jit_regset_setbit(_jitc->regarg, jit_regno(node->u.q.l)); - jit_regset_setbit(_jitc->regarg, jit_regno(node->u.q.h)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->u.q.l)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->u.q.h)); } else - jit_regset_setbit(_jitc->regarg, jit_regno(node->u.w)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->u.w)); } if (value & jit_cc_a1_reg) - jit_regset_setbit(_jitc->regarg, jit_regno(node->v.w)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->v.w)); if (value & jit_cc_a2_reg) - jit_regset_setbit(_jitc->regarg, jit_regno(node->w.w)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->w.w)); } void @@ -1438,16 +1439,16 @@ _jit_regarg_clr(jit_state_t *_jit, jit_node_t *node, jit_int32_t value) { if (value & jit_cc_a0_reg) { if (value & jit_cc_a0_rlh) { - jit_regset_clrbit(_jitc->regarg, jit_regno(node->u.q.l)); - jit_regset_clrbit(_jitc->regarg, jit_regno(node->u.q.h)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->u.q.l)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->u.q.h)); } else - jit_regset_clrbit(_jitc->regarg, jit_regno(node->u.w)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->u.w)); } if (value & jit_cc_a1_reg) - jit_regset_clrbit(_jitc->regarg, jit_regno(node->v.w)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->v.w)); if (value & jit_cc_a2_reg) - jit_regset_clrbit(_jitc->regarg, jit_regno(node->w.w)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->w.w)); } jit_pointer_t @@ -1536,7 +1537,7 @@ _jit_setup(jit_state_t *_jit, jit_block_t *block) unsigned long value; jump = 0; - jit_regset_set_ui(regmask, (1LL << _jitc->reglen) - 1); + jit_regset_set_mask(®mask, _jitc->reglen); for (node = block->label->next; node; node = node->next) { switch (node->code) { case jit_code_label: case jit_code_prolog: @@ -1548,44 +1549,44 @@ _jit_setup(jit_state_t *_jit, jit_block_t *block) live = !(value & jit_cc_a0_chg); if (value & jit_cc_a0_rlh) { if (!(node->u.q.l & jit_regno_patch) && - jit_regset_tstbit(regmask, node->u.q.l)) { + jit_regset_tstbit(®mask, node->u.q.l)) { if (live || !jump) - jit_regset_clrbit(regmask, node->u.q.l); + jit_regset_clrbit(®mask, node->u.q.l); if (live) - jit_regset_setbit(reglive, node->u.q.l); + jit_regset_setbit(®live, node->u.q.l); } if (!(node->u.q.h & jit_regno_patch) && - jit_regset_tstbit(regmask, node->u.q.h)) { + jit_regset_tstbit(®mask, node->u.q.h)) { if (live || !jump) - jit_regset_clrbit(regmask, node->u.q.h); + jit_regset_clrbit(®mask, node->u.q.h); if (live) - jit_regset_setbit(reglive, node->u.q.h); + jit_regset_setbit(®live, node->u.q.h); } } else { if (!(node->u.w & jit_regno_patch) && - jit_regset_tstbit(regmask, node->u.w)) { + jit_regset_tstbit(®mask, node->u.w)) { if (live || !jump) - jit_regset_clrbit(regmask, node->u.w); + jit_regset_clrbit(®mask, node->u.w); if (live) - jit_regset_setbit(reglive, node->u.w); + jit_regset_setbit(®live, node->u.w); } } } if ((value & jit_cc_a1_reg) && !(node->v.w & jit_regno_patch) && - jit_regset_tstbit(regmask, node->v.w)) { + jit_regset_tstbit(®mask, node->v.w)) { live = !(value & jit_cc_a1_chg); if (live || !jump) - jit_regset_clrbit(regmask, node->v.w); + jit_regset_clrbit(®mask, node->v.w); if (live) - jit_regset_setbit(reglive, node->v.w); + jit_regset_setbit(®live, node->v.w); } if ((value & jit_cc_a2_reg) && !(node->w.w & jit_regno_patch) && - jit_regset_tstbit(regmask, node->w.w)) { - jit_regset_clrbit(regmask, node->w.w); - jit_regset_setbit(reglive, node->w.w); + jit_regset_tstbit(®mask, node->w.w)) { + jit_regset_clrbit(®mask, node->w.w); + jit_regset_setbit(®live, node->w.w); } if (value & jit_cc_a0_jmp) jump = 1; @@ -1615,7 +1616,7 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, for (; node; node = node->next) { restart: - if (jit_regset_set_p(*mask) == 0) + if (jit_regset_set_p(mask) == 0) break; switch (node->code) { case jit_code_label: @@ -1623,96 +1624,96 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, if (bmp_tst(node->v.w)) return; bmp_set(node->v.w); - jit_regset_and(ztmp, *mask, block->reglive); - if (jit_regset_set_p(ztmp)) { - jit_regset_ior(*live, *live, ztmp); - jit_regset_com(ztmp, ztmp); - jit_regset_and(*mask, *mask, ztmp); + jit_regset_and(&ztmp, mask, &block->reglive); + if (jit_regset_set_p(&ztmp)) { + jit_regset_ior(live, live, &ztmp); + jit_regset_com(&ztmp, &ztmp); + jit_regset_and(mask, mask, &ztmp); } break; case jit_code_prolog: case jit_code_epilog: - jit_regset_set_ui(*mask, 0); + jit_regset_set_ui(mask, 0); return; case jit_code_callr: value = jit_regno(node->u.w); if (!(node->u.w & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, value)) { - jit_regset_clrbit(*mask, value); - jit_regset_setbit(*live, value); + if (jit_regset_tstbit(mask, value)) { + jit_regset_clrbit(mask, value); + jit_regset_setbit(live, value); } } case jit_code_calli: #if defined(JIT_RET) - if (jit_regset_tstbit(*mask, JIT_RET)) { - jit_regset_setbit(_jitc->reglive, JIT_RET); - jit_regset_clrbit(*mask, JIT_RET); + if (jit_regset_tstbit(mask, JIT_RET)) { + jit_regset_setbit(&_jitc->reglive, JIT_RET); + jit_regset_clrbit(mask, JIT_RET); } # if __arm__ - if (jit_regset_tstbit(*mask, _R1)) { - jit_regset_setbit(_jitc->reglive, _R1); - jit_regset_clrbit(*mask, _R1); + if (jit_regset_tstbit(mask, _R1)) { + jit_regset_setbit(&_jitc->reglive, _R1); + jit_regset_clrbit(mask, _R1); } # endif #endif #if defined(JIT_FRET) - if (jit_regset_tstbit(*mask, JIT_FRET)) { - jit_regset_setbit(_jitc->reglive, JIT_FRET); - jit_regset_clrbit(*mask, JIT_FRET); + if (jit_regset_tstbit(mask, JIT_FRET)) { + jit_regset_setbit(&_jitc->reglive, JIT_FRET); + jit_regset_clrbit(mask, JIT_FRET); } #endif for (value = 0; value < _jitc->reglen; ++value) { - value = jit_regset_scan1(*mask, value); + value = jit_regset_scan1(mask, value); if (value >= _jitc->reglen) break; spec = jit_class(_rvs[value].spec); if (!(spec & jit_class_sav)) - jit_regset_clrbit(*mask, value); + jit_regset_clrbit(mask, value); if ((spec & jit_class_arg) && jit_regarg_p(node, value)) - jit_regset_setbit(*live, value); + jit_regset_setbit(live, value); } break; default: value = jit_classify(node->code); if (value & jit_cc_a2_reg) { if (!(node->w.w & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, node->w.w)) { - jit_regset_clrbit(*mask, node->w.w); - jit_regset_setbit(*live, node->w.w); + if (jit_regset_tstbit(mask, node->w.w)) { + jit_regset_clrbit(mask, node->w.w); + jit_regset_setbit(live, node->w.w); } } } if (value & jit_cc_a1_reg) { if (!(node->v.w & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, node->v.w)) { - jit_regset_clrbit(*mask, node->v.w); + if (jit_regset_tstbit(mask, node->v.w)) { + jit_regset_clrbit(mask, node->v.w); if (!(value & jit_cc_a1_chg)) - jit_regset_setbit(*live, node->v.w); + jit_regset_setbit(live, node->v.w); } } } if (value & jit_cc_a0_reg) { if (value & jit_cc_a0_rlh) { if (!(node->u.q.l & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, node->u.q.l)) { - jit_regset_clrbit(*mask, node->u.q.l); + if (jit_regset_tstbit(mask, node->u.q.l)) { + jit_regset_clrbit(mask, node->u.q.l); if (!(value & jit_cc_a0_chg)) - jit_regset_setbit(*live, node->u.q.l); + jit_regset_setbit(live, node->u.q.l); } } if (!(node->u.q.h & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, node->u.q.h)) { - jit_regset_clrbit(*mask, node->u.q.h); + if (jit_regset_tstbit(mask, node->u.q.h)) { + jit_regset_clrbit(mask, node->u.q.h); if (!(value & jit_cc_a0_chg)) - jit_regset_setbit(*live, node->u.q.h); + jit_regset_setbit(live, node->u.q.h); } } } else { if (!(node->u.w & jit_regno_patch)) { - if (jit_regset_tstbit(*mask, node->u.w)) { - jit_regset_clrbit(*mask, node->u.w); + if (jit_regset_tstbit(mask, node->u.w)) { + jit_regset_clrbit(mask, node->u.w); if (!(value & jit_cc_a0_chg)) - jit_regset_setbit(*live, node->u.w); + jit_regset_setbit(live, node->u.w); } } } @@ -1728,29 +1729,29 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, if (bmp_tst(label->v.w)) continue; bmp_set(label->v.w); - jit_regset_and(ztmp, *mask, block->reglive); - if (jit_regset_set_p(ztmp)) { - jit_regset_ior(*live, *live, ztmp); - jit_regset_com(ztmp, ztmp); - jit_regset_and(*mask, *mask, ztmp); + jit_regset_and(&ztmp, mask, &block->reglive); + if (jit_regset_set_p(&ztmp)) { + jit_regset_ior(live, live, &ztmp); + jit_regset_com(&ztmp, &ztmp); + jit_regset_and(mask, mask, &ztmp); } - if (jit_regset_set_p(*mask) == 0) + if (jit_regset_set_p(mask) == 0) return; /* restore mask if branch is conditional */ - zmask = *mask; + jit_regset_set(&zmask, mask); jit_update(block->label->next, live, &zmask); - jit_regset_xor(ztmp, zmask, *mask); + jit_regset_xor(&ztmp, &zmask, mask); /* remove known live registers from mask */ - if (jit_regset_set_p(ztmp)) { - jit_regset_and(ztmp, ztmp, *live); - jit_regset_com(ztmp, ztmp); - jit_regset_and(*mask, *mask, ztmp); + if (jit_regset_set_p(&ztmp)) { + jit_regset_and(&ztmp, &ztmp, live); + jit_regset_com(&ztmp, &ztmp); + jit_regset_and(mask, mask, &ztmp); } continue; } /* assume value is live due to jump to unknown location */ - jit_regset_ior(*live, *live, *mask); - jit_regset_set_ui(*mask, 0); + jit_regset_ior(live, live, mask); + jit_regset_set_ui(mask, 0); return; } break; @@ -2519,11 +2520,11 @@ _register_change_p(jit_state_t *_jit, jit_node_t *node, jit_node_t *link, static jit_bool_t _spill_reglive_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno) { - if (!jit_regset_tstbit(_jitc->reglive, regno)) { + if (!jit_regset_tstbit(&_jitc->reglive, regno)) { bmp_zero(); - jit_regset_setbit(_jitc->regmask, regno); + jit_regset_setbit(&_jitc->regmask, regno); jit_update(node->next, &_jitc->reglive, &_jitc->regmask); - if (!jit_regset_tstbit(_jitc->reglive, regno) && + if (!jit_regset_tstbit(&_jitc->reglive, regno) && register_change_p(node->next, node->link, regno) != jit_reg_change) return (0); } @@ -2568,7 +2569,7 @@ _patch_registers(jit_state_t *_jit) if (value != regno && ((jit_class(_rvs[value].spec) & spec) & ~jit_class_arg) == spec && - !jit_regset_tstbit(_jitc->regarg, value) && + !jit_regset_tstbit(&_jitc->regarg, value) && !spill_reglive_p(node, value)) break; } @@ -2580,7 +2581,7 @@ _patch_registers(jit_state_t *_jit) /* mark as live just in case there are nested * register patches, so that next patch will * not want to use the same register */ - jit_regset_setbit(_jitc->reglive, value); + jit_regset_setbit(&_jitc->reglive, value); /* register is not live, just remove spill/reload */ node->link->v.w = jit_regload_isdead; del_node(prev, node); @@ -2615,7 +2616,7 @@ _patch_registers(jit_state_t *_jit) regno = jit_regno(node->u.w); if (node->v.w) { if (node->v.w == jit_regload_isdead) - jit_regset_clrbit(_jitc->reglive, regno); + jit_regset_clrbit(&_jitc->reglive, regno); del_node(prev, node); continue; }