>From 0306d4d14ec37b76c67daecd58cacaf9d20795ca Mon Sep 17 00:00:00 2001 From: Paulo Cesar Pereira de Andrade Date: Tue, 24 Aug 2010 20:49:35 -0300 Subject: [PATCH 6/6] Implement support for multiple integer and float arguments. This changes the usage of some of the jit_local_state fields, and add two extra ones. Since jit_arg_x now returns either a register offset or an stack offset, it does not add _XMM0 to nextarg_putfp to distinguish from stack offsets. The nextarg_puti field is used to known when run out of integer register arguments, and should push arguments on the stack. The new framesize field is used to keep track of jit_arg_x offset on the stack, when jit_arg_x runs out of registers. The argssize field is used in a slightly different way now, and is used to keep track of number of stack slots used to pass arguments, and nextarg_puti is used in its previous semantics, to also match nextarg_putfp logic. --- lightning/i386/core-64.h | 93 +++++++++++++++++++++++++++++++-------------- lightning/i386/fp-64.h | 47 +++++++++++++++-------- 2 files changed, 95 insertions(+), 45 deletions(-) diff --git a/lightning/i386/core-64.h b/lightning/i386/core-64.h index ea2f42b..27c0696 100644 --- a/lightning/i386/core-64.h +++ b/lightning/i386/core-64.h @@ -54,6 +54,8 @@ struct jit_local_state { int nextarg_getfp; int nextarg_putfp; int nextarg_geti; + int nextarg_puti; + int framesize; int argssize; int fprssize; int alloca_offset; @@ -131,44 +133,77 @@ struct jit_local_state { #define jit_popr_i(rs) POPQr(rs) /* A return address is 8 bytes, plus 5 registers = 40 byte, total = 48 bytes. */ -#define jit_prolog(n) (_jitl.nextarg_getfp = _jitl.nextarg_geti = 0, _jitl.alloca_offset = 0, \ +#define jit_prolog(n) (_jitl.framesize = 48, _jitl.nextarg_getfp = _jitl.nextarg_geti = 0, _jitl.alloca_offset = 0, \ PUSHQr(_EBX), PUSHQr(_R12), PUSHQr(_R13), PUSHQr(_R14), PUSHQr(_EBP), MOVQrr(_ESP, _EBP)) #define jit_calli(sub) (MOVQir((long) (sub), JIT_REXTMP), CALLsr(JIT_REXTMP)) #define jit_callr(reg) CALLsr((reg)) -/* Stack isn't used for arguments: */ -#if !defined(_ASM_SAFETY) -#define jit_prepare_i(ni) (_jitl.argssize = (ni)) -#else -#define jit_prepare_i(ni) ((ni) <= JIT_RA_NUM ? _jitl.argssize = (ni) : JITFAIL("too many integer arguments")) -#endif - -#define jit_pusharg_i(rs) (--_jitl.argssize, MOVQrr(rs, jit_arg_reg_order[_jitl.argssize])) - -#define jit_finish(sub) (MOVBir(_jitl.fprssize < JIT_FA_NUM \ - ? _jitl.fprssize \ - : JIT_FA_NUM, _AL), \ - jit_calli(sub)) +#define jit_prepare_i(ni) (_jitl.nextarg_puti = (ni), \ + _jitl.argssize = _jitl.nextarg_puti > JIT_RA_NUM \ + ? _jitl.nextarg_puti - JIT_RA_NUM : 0) +#define jit_pusharg_i(rs) (--_jitl.nextarg_puti >= JIT_RA_NUM \ + ? PUSHQr(rs) : MOVQrr(rs, jit_arg_reg_order[_jitl.nextarg_puti])) + +#define jit_finish(sub) (_jitl.fprssize \ + ? (MOVBir(_jitl.fprssize, _AL), _jitl.fprssize = 0) \ + : MOVBir(0, _AL), \ + jit_calli(sub), \ + (_jitl.argssize \ + ? (ADDQir(sizeof(long) * _jitl.argssize, JIT_SP), \ + _jitl.argssize = 0) : 0)) #define jit_reg_is_arg(reg) ((reg) == _ECX || (reg) == _EDX) -#define jit_finishr(reg) (MOVBir(_jitl.fprssize < JIT_FA_NUM \ - ? _jitl.fprssize \ - : JIT_FA_NUM, _AL), \ +#define jit_finishr(reg) (_jitl.fprssize \ + ? (MOVBir(_jitl.fprssize, _AL), _jitl.fprssize = 0) \ + : MOVBir(0, _AL), \ (jit_reg_is_arg((reg)) \ - ? (MOVQrr(reg, JIT_REXTMP), \ - jit_callr(JIT_REXTMP)) \ - : jit_callr(reg))) + ? (MOVQrr(reg, JIT_REXTMP), \ + jit_callr(JIT_REXTMP)) \ + : jit_callr(reg)), \ + (_jitl.argssize \ + ? (ADDQir(sizeof(long) * _jitl.argssize, JIT_SP), \ + _jitl.argssize = 0) : 0)) #define jit_retval_l(rd) ((void)jit_movr_l ((rd), _EAX)) -#define jit_arg_c() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_uc() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_s() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_us() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_i() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_ui() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_l() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_ul() (jit_arg_reg_order[_jitl.nextarg_geti++]) -#define jit_arg_p() (jit_arg_reg_order[_jitl.nextarg_geti++]) +#define jit_arg_i() (_jitl.nextarg_geti < JIT_RA_NUM \ + ? _jitl.nextarg_geti++ \ + : ((_jitl.framesize += sizeof(long)) - sizeof(long))) +#define jit_arg_c() jit_arg_i() +#define jit_arg_uc() jit_arg_i() +#define jit_arg_s() jit_arg_i() +#define jit_arg_us() jit_arg_i() +#define jit_arg_ui() jit_arg_i() +#define jit_arg_l() jit_arg_i() +#define jit_arg_ul() jit_arg_i() +#define jit_arg_p() jit_arg_i() + +#define jit_getarg_c(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_extr_c_l((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_c((reg), JIT_FP, (ofs))) +#define jit_getarg_uc(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_extr_uc_ul((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_uc((reg), JIT_FP, (ofs))) +#define jit_getarg_s(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_extr_s_l((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_s((reg), JIT_FP, (ofs))) +#define jit_getarg_us(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_extr_us_ul((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_us((reg), JIT_FP, (ofs))) +#define jit_getarg_i(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_movr_l((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_i((reg), JIT_FP, (ofs))) +#define jit_getarg_ui(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_movr_ul((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_ui((reg), JIT_FP, (ofs))) +#define jit_getarg_l(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_movr_l((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_l((reg), JIT_FP, (ofs))) +#define jit_getarg_ul(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_movr_ul((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_ul((reg), JIT_FP, ofs)) +#define jit_getarg_p(reg, ofs) ((ofs) < JIT_RA_NUM \ + ? jit_movr_p((reg), jit_arg_reg_order[(ofs)]) \ + : jit_ldxi_p((reg), JIT_FP, (ofs))) static int jit_arg_reg_order[] = { _EDI, _ESI, _EDX, _ECX, _R8D, _R9D }; diff --git a/lightning/i386/fp-64.h b/lightning/i386/fp-64.h index cbe15d2..d7890d3 100644 --- a/lightning/i386/fp-64.h +++ b/lightning/i386/fp-64.h @@ -290,21 +290,36 @@ union jit_double_imm { #define jit_ordr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETNPr (jit_reg8((d)))) #define jit_unordr_d(d, s1, s2) (XORLrr ((d), (d)), UCOMISDrr ((s1), (s2)), SETPr (jit_reg8((d)))) -#if !defined(_ASM_SAFETY) -#define jit_prepare_f(num) (_jitl.fprssize += (num), _jitl.nextarg_putfp = _XMM0 + _jitl.fprssize) -#define jit_prepare_d(num) (_jitl.fprssize += (num), _jitl.nextarg_putfp = _XMM0 + _jitl.fprssize) -#else -#define jit_prepare_f(num) (_jitl.fprssize += (num) <= JIT_FA_NUM ? (_jitl.nextarg_putfp = _XMM0 + _jitl.fprssize) : JITFAIL("too many float arguments")) -#define jit_prepare_d(num) (_jitl.fprssize += (num) <= JIT_FA_NUM ? (_jitl.nextarg_putfp = _XMM0 + _jitl.fprssize) : JITFAIL("too many float arguments")) -#endif - -#define jit_arg_f() (_XMM0 + _jitl.nextarg_getfp++) -#define jit_arg_d() (_XMM0 + _jitl.nextarg_getfp++) - -#define jit_getarg_f(rd, ofs) (jit_movr_f ((rd), (ofs))) -#define jit_getarg_d(rd, ofs) (jit_movr_d ((rd), (ofs))) - -#define jit_pusharg_f(rs) (--_jitl.nextarg_putfp, jit_movr_f (_jitl.nextarg_putfp, (rs))) -#define jit_pusharg_d(rs) (--_jitl.nextarg_putfp, jit_movr_d (_jitl.nextarg_putfp, (rs))) +#define jit_prepare_f(num) ((_jitl.nextarg_putfp + (num) > JIT_FA_NUM \ + ? (_jitl.argssize += _jitl.nextarg_putfp + (num) - JIT_FA_NUM, \ + _jitl.fprssize = JIT_FA_NUM) \ + : (_jitl.fprssize += (num))), \ + _jitl.nextarg_putfp += (num)) +#define jit_prepare_d(num) ((_jitl.nextarg_putfp + (num) > JIT_FA_NUM \ + ? (_jitl.argssize += _jitl.nextarg_putfp + (num) - JIT_FA_NUM, \ + _jitl.fprssize = JIT_FA_NUM) \ + : (_jitl.fprssize += (num))), \ + _jitl.nextarg_putfp += (num)) + +#define jit_arg_f() (_jitl.nextarg_getfp < JIT_FA_NUM \ + ? _jitl.nextarg_getfp++ \ + : ((_jitl.framesize += sizeof(double)) - sizeof(double))) +#define jit_arg_d() (_jitl.nextarg_getfp < JIT_FA_NUM \ + ? _jitl.nextarg_getfp++ \ + : ((_jitl.framesize += sizeof(double)) - sizeof(double))) + +#define jit_getarg_f(reg, ofs) ((ofs) < JIT_FA_NUM \ + ? jit_movr_f((reg), _XMM0 + (ofs)) \ + : jit_ldxi_f((reg), JIT_FP, (ofs))) +#define jit_getarg_d(reg, ofs) ((ofs) < JIT_FA_NUM \ + ? jit_movr_d((reg), _XMM0 + (ofs)) \ + : jit_ldxi_d((reg), JIT_FP, (ofs))) + +#define jit_pusharg_f(rs) (--_jitl.nextarg_putfp >= JIT_FA_NUM \ + ? (SUBQir(sizeof(double), JIT_SP), jit_str_f(JIT_SP,(rs))) \ + : jit_movr_f(_XMM0 + _jitl.nextarg_putfp, (rs))) +#define jit_pusharg_d(rs) (--_jitl.nextarg_putfp >= JIT_FA_NUM \ + ? (SUBQir(sizeof(double), JIT_SP), jit_str_d(JIT_SP,(rs))) \ + : jit_movr_d(_XMM0 + _jitl.nextarg_putfp, (rs))) #endif /* __lightning_fp_h */ -- 1.7.2.1