From 9afca85921522076006a7e901b2a040849f7beb0 Mon Sep 17 00:00:00 2001 From: pcpa Date: Wed, 6 Mar 2013 16:49:26 -0300 Subject: [PATCH] Rework to better describe what is used only during jit generation. * include/lightning/jit_private.h, lib/jit_arm-cpu.c, lib/jit_arm.c, lib/jit_disasm.c, lib/jit_mips-cpu.c, lib/jit_mips.c, lib/jit_note.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: Add an extra structure for data storage during jit generation, and release it after generating jit, to reduce a bit memory usage, and also to make it easier to understand what data is available during jit runtime. --- ChangeLog | 13 + include/lightning/jit_private.h | 51 ++- lib/jit_arm-cpu.c | 16 +- lib/jit_arm.c | 446 +++++++++++----------- lib/jit_disasm.c | 8 +- lib/jit_mips-cpu.c | 138 +++---- lib/jit_mips.c | 264 ++++++------- lib/jit_note.c | 70 ++-- lib/jit_ppc-cpu.c | 16 +- lib/jit_ppc.c | 314 +++++++-------- lib/jit_print.c | 6 +- lib/jit_sparc-cpu.c | 40 +- lib/jit_sparc.c | 266 ++++++------- lib/jit_x86-cpu.c | 66 ++-- lib/jit_x86.c | 260 ++++++------- lib/lightning.c | 653 ++++++++++++++++---------------- 16 files changed, 1328 insertions(+), 1299 deletions(-) diff --git a/ChangeLog b/ChangeLog index ecd84bde2..87519db9a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +2013-03-06 Paulo Andrade + + * include/lightning/jit_private.h, lib/jit_arm-cpu.c, + lib/jit_arm.c, lib/jit_disasm.c, lib/jit_mips-cpu.c, + lib/jit_mips.c, lib/jit_note.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: Add an extra structure for data storage + during jit generation, and release it after generating + jit, to reduce a bit memory usage, and also to make it + easier to understand what data is available during + jit runtime. + 2013-03-06 Paulo Andrade * lib/lightning.c: Make data and code buffer readonly. diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h index 16a53300c..314cf0f1d 100644 --- a/include/lightning/jit_private.h +++ b/include/lightning/jit_private.h @@ -79,9 +79,9 @@ #define jit_size(vector) (sizeof(vector) / sizeof((vector)[0])) #define jit_reg_free_p(regno) \ - (!jit_regset_tstbit(_jit->reglive, regno) && \ - !jit_regset_tstbit(_jit->regarg, regno) && \ - !jit_regset_tstbit(_jit->regsav, regno)) + (!jit_regset_tstbit(_jitc->reglive, regno) && \ + !jit_regset_tstbit(_jitc->regarg, regno) && \ + !jit_regset_tstbit(_jitc->regsav, regno)) /* * Private jit_class bitmasks @@ -152,8 +152,8 @@ jit_regset_scan1(jit_regset_t, jit_int32_t); #define jit_reglive_setup() \ do { \ - jit_regset_set_ui(_jit->reglive, 0); \ - jit_regset_set_ui(_jit->regmask, 0); \ + jit_regset_set_ui(_jitc->reglive, 0); \ + jit_regset_set_ui(_jitc->regmask, 0); \ } while (0) /* @@ -164,6 +164,7 @@ typedef struct jit_note jit_note_t; typedef struct jit_line jit_line_t; typedef struct jit_block jit_block_t; typedef struct jit_value jit_value_t; +typedef struct jit_compiler jit_compiler_t; typedef struct jit_function jit_function_t; typedef struct jit_register jit_register_t; #if __arm__ @@ -264,14 +265,8 @@ struct jit_function { jit_int32_t stack; }; -struct jit_state { - union { - jit_uint8_t *uc; - jit_uint16_t *us; - jit_uint32_t *ui; - jit_uint64_t *ul; - jit_word_t w; - } pc; +/* data used only during jit generation */ +struct jit_compiler { jit_node_t *head; jit_node_t *tail; jit_uint32_t done : 1; /* emit state finished */ @@ -285,17 +280,13 @@ struct jit_state { jit_regset_t regmask; /* register mask to update reglive */ mpz_t blockmask; /* mask of visited basic blocks */ struct { - jit_uint8_t *ptr; jit_uint8_t *end; - jit_word_t length; } code; struct { - jit_uint8_t *ptr; /* constant pool */ jit_node_t **table; /* very simple hash table */ jit_word_t size; /* number of vectors in table */ jit_word_t count; /* number of hash table entries */ jit_word_t offset; /* offset in bytes in ptr */ - jit_word_t length; /* length in bytes of ptr */ } data; jit_node_t **spill; jit_int32_t *gen; /* ssa like "register version" */ @@ -323,10 +314,8 @@ struct jit_state { } pool; jit_node_t *list; struct { - jit_note_t *ptr; jit_node_t *head; /* first note node */ jit_node_t *tail; /* linked list insertion */ - jit_word_t length; /* fields to store temporary state information */ jit_word_t size; @@ -361,6 +350,30 @@ struct jit_state { #endif }; +#define _jitc _jit->comp +struct jit_state { + union { + jit_uint8_t *uc; + jit_uint16_t *us; + jit_uint32_t *ui; + jit_uint64_t *ul; + jit_word_t w; + } pc; + struct { + jit_uint8_t *ptr; + jit_word_t length; + } code; + struct { + jit_uint8_t *ptr; + jit_word_t length; + } data; + struct { + jit_note_t *ptr; + jit_word_t length; + } note; + jit_compiler_t *comp; +}; + struct jit_register { jit_reg_t spec; char *name; diff --git a/lib/jit_arm-cpu.c b/lib/jit_arm-cpu.c index 499616dd8..d5776792e 100644 --- a/lib/jit_arm-cpu.c +++ b/lib/jit_arm-cpu.c @@ -2558,7 +2558,7 @@ _jmpi(jit_state_t *_jit, jit_word_t i0) jit_word_t d; w = _jit->pc.w; /* if thumb and in thumb mode */ - if (jit_thumb_p() && _jit->thumb) { + if (jit_thumb_p() && _jitc->thumb) { d = ((i0 - w) >> 1) - 2; if (d >= -1024 && d <= 1023) T1_B(d & 0x7ff); @@ -2590,7 +2590,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0) jit_word_t d; w = _jit->pc.w; /* if thumb and in thumb mode */ - if (jit_thumb_p() && _jit->thumb) { + if (jit_thumb_p() && _jitc->thumb) { d = ((i0 - w) >> 1) - 2; assert(_s24P(d)); T2_B(encode_thumb_jump(d)); @@ -3692,9 +3692,9 @@ _calli_p(jit_state_t *_jit, jit_word_t i0) static void _prolog(jit_state_t *_jit, jit_node_t *node) { - _jit->function->stack = ((_jit->function->self.alen - + _jitc->function->stack = ((_jitc->function->self.alen - /* align stack at 8 bytes */ - _jit->function->self.aoff) + 7) & -8; + _jitc->function->self.aoff) + 7) & -8; if (jit_thumb_p()) { /* switch to thumb mode (better approach would be to @@ -3703,8 +3703,8 @@ _prolog(jit_state_t *_jit, jit_node_t *node) * a pointer to a jit function) */ ADDI(_R12_REGNO, _R15_REGNO, 1); BX(_R12_REGNO); - if (!_jit->thumb) - _jit->thumb = _jit->pc.w; + if (!_jitc->thumb) + _jitc->thumb = _jit->pc.w; if (jit_cpu.abi) { T2_PUSH(0x3f0|(1<<_FP_REGNO)|(1<<_LR_REGNO)); VPUSH_F64(_D8_REGNO, 8); @@ -3723,7 +3723,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node) PUSH(0x3ff|(1<<_FP_REGNO)|(1<<_LR_REGNO)); } movr(_FP_REGNO, _SP_REGNO); - subi(_SP_REGNO, _SP_REGNO, _jit->function->stack); + subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack); } static void @@ -3753,7 +3753,7 @@ _patch_at(jit_state_t *_jit, } u; u.w = instr; if (kind == arm_patch_jump) { - if (jit_thumb_p() && instr >= _jit->thumb) { + if (jit_thumb_p() && instr >= _jitc->thumb) { code2thumb(thumb.s[0], thumb.s[1], u.s[0], u.s[1]); if ((thumb.i & THUMB2_B) == THUMB2_B) { d = ((label - instr) >> 1) - 2; diff --git a/lib/jit_arm.c b/lib/jit_arm.c index 230228632..4e589d0cc 100644 --- a/lib/jit_arm.c +++ b/lib/jit_arm.c @@ -187,7 +187,7 @@ _jit_init(jit_state_t *_jit) jit_int32_t regno; static jit_bool_t first = 1; - _jit->reglen = jit_size(_rvs) - 1; + _jitc->reglen = jit_size(_rvs) - 1; if (first) { /* jit_get_cpu() should have been already called, and only once */ if (!jit_cpu.vfp) { @@ -209,58 +209,58 @@ _jit_prolog(jit_state_t *_jit) { jit_int32_t offset; - if (_jit->function) + if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jit->regarg, 0) == 0); - jit_regset_set_ui(_jit->regsav, 0); - offset = _jit->functions.offset; - if (offset >= _jit->functions.length) { - _jit->functions.ptr = realloc(_jit->functions.ptr, - (_jit->functions.length + 16) * + 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) { + _jitc->functions.ptr = realloc(_jitc->functions.ptr, + (_jitc->functions.length + 16) * sizeof(jit_function_t)); - memset(_jit->functions.ptr + _jit->functions.length, 0, + memset(_jitc->functions.ptr + _jitc->functions.length, 0, 16 * sizeof(jit_function_t)); - _jit->functions.length += 16; + _jitc->functions.length += 16; } - _jit->function = _jit->functions.ptr + _jit->functions.offset++; - _jit->function->self.size = stack_framesize; + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = stack_framesize; if (jit_cpu.abi) - _jit->function->self.size += 64; - _jit->function->self.argi = _jit->function->self.argf = - _jit->function->self.alen = 0; + _jitc->function->self.size += 64; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.alen = 0; if (jit_swf_p()) /* 8 soft float registers */ - _jit->function->self.aoff = -64; + _jitc->function->self.aoff = -64; else - _jit->function->self.aoff = 0; - _jit->function->self.call = jit_call_default; - _jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t)); + _jitc->function->self.aoff = 0; + _jitc->function->self.call = jit_call_default; + _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t)); - _jit->function->prolog = jit_new_node_no_link(jit_code_prolog); - jit_link(_jit->function->prolog); - _jit->function->prolog->w.w = offset; - _jit->function->epilog = jit_new_node_no_link(jit_code_epilog); + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); /* u: label value * v: offset in blocks vector * w: offset in functions vector */ - _jit->function->epilog->w.w = offset; + _jitc->function->epilog->w.w = offset; - jit_regset_new(_jit->function->regset); + jit_regset_new(_jitc->function->regset); } jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { - assert(_jit->function); + assert(_jitc->function); switch (length) { case 0: case 1: break; - case 2: _jit->function->self.aoff &= -2; break; - case 3: case 4: _jit->function->self.aoff &= -4; break; - default: _jit->function->self.aoff &= -8; break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; } - _jit->function->self.aoff -= length; - return (_jit->function->self.aoff); + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); } void @@ -268,11 +268,11 @@ _jit_ret(jit_state_t *_jit) { jit_node_t *instr; - assert(_jit->function); + assert(_jitc->function); /* jump to epilog */ instr = jit_jmpi(); - jit_patch_at(instr, _jit->function->epilog); + jit_patch_at(instr, _jitc->function->epilog); } void @@ -352,10 +352,10 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u) void _jit_epilog(jit_state_t *_jit) { - assert(_jit->function); - assert(_jit->function->epilog->next == NULL); - jit_link(_jit->function->epilog); - _jit->function = NULL; + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; } jit_node_t * @@ -363,12 +363,12 @@ _jit_arg(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argi < 4) - offset = _jit->function->self.argi++; + assert(_jitc->function); + if (_jitc->function->self.argi < 4) + offset = _jitc->function->self.argi++; else { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_word_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); } return (jit_new_node_w(jit_code_arg, offset)); } @@ -384,21 +384,21 @@ _jit_arg_f(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) { - if (_jit->function->self.argf < 16) { - offset = _jit->function->self.argf++; + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) { + if (_jitc->function->self.argf < 16) { + offset = _jitc->function->self.argf++; goto done; } } else { - if (_jit->function->self.argi < 4) { - offset = _jit->function->self.argi++; + if (_jitc->function->self.argi < 4) { + offset = _jitc->function->self.argi++; goto done; } } - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float32_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float32_t); done: return (jit_new_node_w(jit_code_arg_f, offset)); } @@ -414,29 +414,29 @@ _jit_arg_d(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->self.call & jit_call_varargs)) { - if (_jit->function->self.argf < 15) { - if (_jit->function->self.argf & 1) - ++_jit->function->self.argf; - offset = _jit->function->self.argf; - _jit->function->self.argf += 2; + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) { + if (_jitc->function->self.argf < 15) { + if (_jitc->function->self.argf & 1) + ++_jitc->function->self.argf; + offset = _jitc->function->self.argf; + _jitc->function->self.argf += 2; goto done; } } else { - if (_jit->function->self.argi < 3) { - if (_jit->function->self.argi & 1) - ++_jit->function->self.argi; - offset = _jit->function->self.argi; - _jit->function->self.argi += 2; + if (_jitc->function->self.argi < 3) { + if (_jitc->function->self.argi & 1) + ++_jitc->function->self.argi; + offset = _jitc->function->self.argi; + _jitc->function->self.argi += 2; goto done; } } - if (_jit->function->self.size & 7) - _jit->function->self.size += 4; - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float64_t); + if (_jitc->function->self.size & 7) + _jitc->function->self.size += 4; + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float64_t); done: return (jit_new_node_w(jit_code_arg_d, offset)); } @@ -543,14 +543,14 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_pushargr(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (_jit->function->call.argi < 4) { - jit_movr(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + assert(_jitc->function); + if (_jitc->function->call.argi < 4) { + jit_movr(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else { - jit_stxi(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); } } @@ -559,40 +559,40 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u) { jit_int32_t regno; - assert(_jit->function); - if (_jit->function->call.argi < 4) { - jit_movi(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + assert(_jitc->function); + if (_jitc->function->call.argi < 4) { + jit_movi(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else { regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); - jit_stxi(_jit->function->call.size, JIT_SP, regno); + jit_stxi(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); - _jit->function->call.size += sizeof(jit_word_t); + _jitc->function->call.size += sizeof(jit_word_t); } } void _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->call.call & jit_call_varargs)) { - if (_jit->function->call.argf < 16) { - jit_movr_f(JIT_FA0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) { + if (_jitc->function->call.argf < 16) { + jit_movr_f(JIT_FA0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; return; } } else { - if (_jit->function->call.argi < 4) { - jit_movr_f_w(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 4) { + jit_movr_f_w(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; return; } } - jit_stxi_f(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi_f(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); } void @@ -600,63 +600,63 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) { jit_int32_t regno; - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->call.call & jit_call_varargs)) { - if (_jit->function->call.argf < 16) { + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) { + if (_jitc->function->call.argf < 16) { /* cannot jit_movi_f in the argument register because * float arguments are packed, and that would cause * either an assertion in debug mode, or overwritting * two registers */ regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - jit_movr_f(JIT_FA0 - _jit->function->call.argf, regno); + jit_movr_f(JIT_FA0 - _jitc->function->call.argf, regno); jit_unget_reg(regno); - ++_jit->function->call.argf; + ++_jitc->function->call.argf; return; } } else { - if (_jit->function->call.argi < 4) { - jit_movi_f_w(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 4) { + jit_movi_f_w(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; return; } } regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - jit_stxi_f(_jit->function->call.size, JIT_SP, regno); + jit_stxi_f(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); - _jit->function->call.size += sizeof(jit_word_t); + _jitc->function->call.size += sizeof(jit_word_t); } void _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->call.call & jit_call_varargs)) { - if (_jit->function->call.argf < 15) { - if (_jit->function->call.argf & 1) - ++_jit->function->call.argf; - jit_movr_d(JIT_FA0 - _jit->function->call.argf, u); - _jit->function->call.argf += 2; + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) { + if (_jitc->function->call.argf < 15) { + if (_jitc->function->call.argf & 1) + ++_jitc->function->call.argf; + jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u); + _jitc->function->call.argf += 2; return; } } else { - if (_jit->function->call.argi & 1) - ++_jit->function->call.argi; - if (_jit->function->call.argi < 4) { - jit_movr_d_ww(JIT_RA0 - _jit->function->call.argi, - JIT_RA0 - (_jit->function->call.argi + 1), + if (_jitc->function->call.argi & 1) + ++_jitc->function->call.argi; + if (_jitc->function->call.argi < 4) { + jit_movr_d_ww(JIT_RA0 - _jitc->function->call.argi, + JIT_RA0 - (_jitc->function->call.argi + 1), u); - _jit->function->call.argi += 2; + _jitc->function->call.argi += 2; return; } } - if (_jit->function->call.size & 7) - _jit->function->call.size += 4; - jit_stxi_d(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float64_t); + if (_jitc->function->call.size & 7) + _jitc->function->call.size += 4; + jit_stxi_d(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float64_t); } void @@ -664,34 +664,34 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) { jit_int32_t regno; - assert(_jit->function); - if (jit_cpu.abi && !(_jit->function->call.call & jit_call_varargs)) { - if (_jit->function->call.argf < 15) { - if (_jit->function->call.argf & 1) - ++_jit->function->call.argf; - jit_movi_d(JIT_FA0 - _jit->function->call.argf, u); - _jit->function->call.argf += 2; + assert(_jitc->function); + if (jit_cpu.abi && !(_jitc->function->call.call & jit_call_varargs)) { + if (_jitc->function->call.argf < 15) { + if (_jitc->function->call.argf & 1) + ++_jitc->function->call.argf; + jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u); + _jitc->function->call.argf += 2; return; } } else { - if (_jit->function->call.argi & 1) - ++_jit->function->call.argi; - if (_jit->function->call.argi < 4) { - jit_movi_d_ww(JIT_RA0 - _jit->function->call.argi, - JIT_RA0 - (_jit->function->call.argi + 1), + if (_jitc->function->call.argi & 1) + ++_jitc->function->call.argi; + if (_jitc->function->call.argi < 4) { + jit_movi_d_ww(JIT_RA0 - _jitc->function->call.argi, + JIT_RA0 - (_jitc->function->call.argi + 1), u); - _jit->function->call.argi += 2; + _jitc->function->call.argi += 2; return; } } - if (_jit->function->call.size & 7) - _jit->function->call.size += 4; + if (_jitc->function->call.size & 7) + _jitc->function->call.size += 4; regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); - jit_stxi_d(_jit->function->call.size, JIT_SP, regno); + jit_stxi_d(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); - _jit->function->call.size += sizeof(jit_float64_t); + _jitc->function->call.size += sizeof(jit_float64_t); } jit_bool_t @@ -719,15 +719,15 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0) { jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; node = jit_callr(r0); - node->v.w = _jit->function->self.argi; - node->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + node->v.w = _jitc->function->self.argi; + node->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; } jit_node_t * @@ -735,15 +735,15 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) { jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; node = jit_calli(i0); - node->v.w = _jit->function->call.argi; - node->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + node->v.w = _jitc->function->call.argi; + node->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; return (node); } @@ -818,7 +818,7 @@ _emit_code(jit_state_t *_jit) jit_int32_t patch_offset; } undo; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); @@ -1034,8 +1034,8 @@ _emit_code(jit_state_t *_jit) patch(word, node); \ } \ break - for (node = _jit->head; node; node = node->next) { - if (_jit->pc.uc >= _jit->code.end) + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end) return (NULL); value = jit_classify(node->code); @@ -1415,22 +1415,22 @@ _emit_code(jit_state_t *_jit) calli(node->u.w); break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; undo.node = node; undo.word = _jit->pc.w; - undo.data = _jit->consts.data; - undo.thumb = _jit->thumb; - undo.const_offset = _jit->consts.offset; - undo.patch_offset = _jit->patches.offset; - if (_jit->data_info.ptr) - undo.info_offset = _jit->data_info.offset; + undo.data = _jitc->consts.data; + undo.thumb = _jitc->thumb; + undo.const_offset = _jitc->consts.offset; + undo.patch_offset = _jitc->patches.offset; + if (_jitc->data_info.ptr) + undo.info_offset = _jitc->data_info.offset; restart_function: - _jit->again = 0; + _jitc->again = 0; prolog(node); break; case jit_code_epilog: - assert(_jit->function == _jit->functions.ptr + node->w.w); - if (_jit->again) { + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { for (temp = undo.node->next; temp != node; temp = temp->next) { if (temp->code == jit_code_label || @@ -1440,19 +1440,19 @@ _emit_code(jit_state_t *_jit) node = undo.node; _jit->pc.w = undo.word; invalidate_consts(); - _jit->consts.data = undo.data; - _jit->thumb = undo.thumb; - _jit->consts.offset = undo.const_offset; - _jit->patches.offset = undo.patch_offset; - if (_jit->data_info.ptr) - _jit->data_info.offset = undo.info_offset; + _jitc->consts.data = undo.data; + _jitc->thumb = undo.thumb; + _jitc->consts.offset = undo.const_offset; + _jitc->patches.offset = undo.patch_offset; + if (_jitc->data_info.ptr) + _jitc->data_info.offset = undo.info_offset; goto restart_function; } /* remember label is defined */ node->flag |= jit_flag_patch; node->u.w = _jit->pc.w; epilog(node); - _jit->function = NULL; + _jitc->function = NULL; flush_consts(); break; case jit_code_movr_w_f: @@ -1504,7 +1504,7 @@ _emit_code(jit_state_t *_jit) /* update register live state */ jit_reglive(node); - if (_jit->consts.length && _jit->pc.uc - _jit->consts.data >= 3968) { + if (_jitc->consts.length && _jit->pc.uc - _jitc->consts.data >= 3968) { /* longest sequence should be 64 bytes, but preventively * do not let it go past 128 remaining bytes before a flush */ if (node->next && @@ -1541,10 +1541,10 @@ _emit_code(jit_state_t *_jit) #undef case_rr flush_consts(); - for (offset = 0; offset < _jit->patches.offset; offset++) { - assert(_jit->patches.ptr[offset].kind & arm_patch_node); - node = _jit->patches.ptr[offset].node; - word = _jit->patches.ptr[offset].inst; + for (offset = 0; offset < _jitc->patches.offset; offset++) { + assert(_jitc->patches.ptr[offset].kind & arm_patch_node); + node = _jitc->patches.ptr[offset].node; + word = _jitc->patches.ptr[offset].inst; if (!jit_thumb_p() && (node->code == jit_code_movi || node->code == jit_code_calli)) { /* calculate where to patch word */ @@ -1560,7 +1560,7 @@ _emit_code(jit_state_t *_jit) word = word + 8 + value; } value = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; - patch_at(_jit->patches.ptr[offset].kind & ~arm_patch_node, word, value); + patch_at(_jitc->patches.ptr[offset].kind & ~arm_patch_node, word, value); } __clear_cache(_jit->code.ptr, _jit->pc.uc); @@ -1612,28 +1612,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(_jit->regarg, _R0); - jit_regset_setbit(_jit->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(_jit->regarg, _R2); - jit_regset_setbit(_jit->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(_jit->regarg, _R4); - jit_regset_setbit(_jit->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(_jit->regarg, _R6); - jit_regset_setbit(_jit->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(_jit->regarg, _R8); - jit_regset_setbit(_jit->regarg, _R9); + jit_regset_setbit(_jitc->regarg, _R8); + jit_regset_setbit(_jitc->regarg, _R9); return (_R8); } return (JIT_NOREG); @@ -1680,7 +1680,7 @@ _load_const(jit_state_t *_jit, jit_bool_t uniq, jit_int32_t r0, jit_word_t i0) */ /* search in previous constant pool */ - if ((data = (jit_int32_t *)_jit->consts.data)) { + if ((data = (jit_int32_t *)_jitc->consts.data)) { w = (jit_word_t)data; /* maximum backwards offset */ base = (_jit->pc.w + 8) - 4092; @@ -1689,7 +1689,7 @@ _load_const(jit_state_t *_jit, jit_bool_t uniq, jit_int32_t r0, jit_word_t i0) base = 0; else base = (base - w) >> 2; - size = _jit->consts.size >> 2; + size = _jitc->consts.size >> 2; for (offset = size - 1; offset >= base; offset--) { if (data[offset] == i0) { w = (jit_word_t)(data + offset); @@ -1703,15 +1703,15 @@ _load_const(jit_state_t *_jit, jit_bool_t uniq, jit_int32_t r0, jit_word_t i0) else assert(i0 == 0); - _jit->consts.patches[_jit->consts.offset++] = _jit->pc.w; + _jitc->consts.patches[_jitc->consts.offset++] = _jit->pc.w; /* (probably) positive forward offset */ LDRI(r0, _R15_REGNO, 0); if (!uniq) { /* search already requested values */ - for (offset = 0; offset < _jit->consts.length; offset++) { - if (_jit->consts.values[offset] == i0) { - _jit->consts.patches[_jit->consts.offset++] = offset; + for (offset = 0; offset < _jitc->consts.length; offset++) { + if (_jitc->consts.values[offset] == i0) { + _jitc->consts.patches[_jitc->consts.offset++] = offset; return; } } @@ -1720,11 +1720,11 @@ _load_const(jit_state_t *_jit, jit_bool_t uniq, jit_int32_t r0, jit_word_t i0) #if DEBUG /* cannot run out of space because of limited range * but assert anyway to catch logic errors */ - assert(_jit->consts.length < 1024); - assert(_jit->consts.offset < 2048); + assert(_jitc->consts.length < 1024); + assert(_jitc->consts.offset < 2048); #endif - _jit->consts.patches[_jit->consts.offset++] = _jit->consts.length; - _jit->consts.values[_jit->consts.length++] = i0; + _jitc->consts.patches[_jitc->consts.offset++] = _jitc->consts.length; + _jitc->consts.values[_jitc->consts.length++] = i0; } static void @@ -1734,35 +1734,35 @@ _flush_consts(jit_state_t *_jit) jit_int32_t offset; /* if no forward constants */ - if (!_jit->consts.length) + if (!_jitc->consts.length) return; assert(!jit_thumb_p()); word = _jit->pc.w; - _jit->consts.data = _jit->pc.uc; - _jit->consts.size = _jit->consts.length << 2; + _jitc->consts.data = _jit->pc.uc; + _jitc->consts.size = _jitc->consts.length << 2; /* FIXME check will not overrun, otherwise, need to reallocate * code buffer and start over */ - memcpy(_jit->consts.data, _jit->consts.values, _jit->consts.size); - _jit->pc.w += _jit->consts.size; + memcpy(_jitc->consts.data, _jitc->consts.values, _jitc->consts.size); + _jit->pc.w += _jitc->consts.size; - if (_jit->data_info.ptr) { - if (_jit->data_info.offset >= _jit->data_info.length) { - _jit->data_info.ptr = realloc(_jit->data_info.ptr, - (_jit->data_info.length + 1024) * + if (_jitc->data_info.ptr) { + if (_jitc->data_info.offset >= _jitc->data_info.length) { + _jitc->data_info.ptr = realloc(_jitc->data_info.ptr, + (_jitc->data_info.length + 1024) * sizeof(jit_data_info_t)); - memset(_jit->data_info.ptr + _jit->data_info.length, 0, + memset(_jitc->data_info.ptr + _jitc->data_info.length, 0, 1024 * sizeof(jit_data_info_t)); - _jit->data_info.length += 1024; + _jitc->data_info.length += 1024; } - _jit->data_info.ptr[_jit->data_info.offset].code = word; - _jit->data_info.ptr[_jit->data_info.offset].length = _jit->consts.size; - ++_jit->data_info.offset; + _jitc->data_info.ptr[_jitc->data_info.offset].code = word; + _jitc->data_info.ptr[_jitc->data_info.offset].length = _jitc->consts.size; + ++_jitc->data_info.offset; } - for (offset = 0; offset < _jit->consts.offset; offset += 2) - patch_at(arm_patch_load, _jit->consts.patches[offset], - word + (_jit->consts.patches[offset + 1] << 2)); - _jit->consts.length = _jit->consts.offset = 0; + for (offset = 0; offset < _jitc->consts.offset; offset += 2) + patch_at(arm_patch_load, _jitc->consts.patches[offset], + word + (_jitc->consts.patches[offset + 1] << 2)); + _jitc->consts.length = _jitc->consts.offset = 0; } /* to be called if needing to start over a function */ @@ -1770,8 +1770,8 @@ static void _invalidate_consts(jit_state_t *_jit) { /* if no forward constants */ - if (_jit->consts.length) - _jit->consts.length = _jit->consts.offset = 0; + if (_jitc->consts.length) + _jitc->consts.length = _jitc->consts.offset = 0; } static void @@ -1794,16 +1794,16 @@ _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) } assert(!(flag & jit_flag_patch)); kind |= arm_patch_node; - if (_jit->patches.offset >= _jit->patches.length) { - _jit->patches.ptr = realloc(_jit->patches.ptr, - (_jit->patches.length + 1024) * + if (_jitc->patches.offset >= _jitc->patches.length) { + _jitc->patches.ptr = realloc(_jitc->patches.ptr, + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); - memset(_jit->patches.ptr + _jit->patches.length, 0, + memset(_jitc->patches.ptr + _jitc->patches.length, 0, 1024 * sizeof(jit_patch_t)); - _jit->patches.length += 1024; + _jitc->patches.length += 1024; } - _jit->patches.ptr[_jit->patches.offset].kind = kind; - _jit->patches.ptr[_jit->patches.offset].inst = instr; - _jit->patches.ptr[_jit->patches.offset].node = node; - ++_jit->patches.offset; + _jitc->patches.ptr[_jitc->patches.offset].kind = kind; + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; } diff --git a/lib/jit_disasm.c b/lib/jit_disasm.c index 6230c6ea0..52c071d07 100644 --- a/lib/jit_disasm.c +++ b/lib/jit_disasm.c @@ -287,15 +287,15 @@ _disassemble(jit_state_t *_jit, jit_pointer_t code, jit_int32_t length) #if __arm__ again: if (data_info) { - while (_jit->data_info.ptr[data_offset].code < pc) { + while (_jitc->data_info.ptr[data_offset].code < pc) { data_offset += 2; - if (data_offset >= _jit->data_info.length) { + if (data_offset >= _jitc->data_info.length) { data_info = 0; goto again; } } - if (pc == _jit->data_info.ptr[data_offset].code) { - offset = _jit->data_info.ptr[data_offset].length; + if (pc == _jitc->data_info.ptr[data_offset].code) { + offset = _jitc->data_info.ptr[data_offset].length; for (; offset >= 4; offset -= 4, pc += 4) { bytes = sprintf(buffer, address_buffer_format, pc); (*disasm_info.fprintf_func)(disasm_stream, diff --git a/lib/jit_mips-cpu.c b/lib/jit_mips-cpu.c index 0774e9758..18ee0d8ea 100644 --- a/lib/jit_mips-cpu.c +++ b/lib/jit_mips-cpu.c @@ -2773,79 +2773,79 @@ _calli_p(jit_state_t *_jit, jit_word_t i0) static void _prolog(jit_state_t *_jit, jit_node_t *node) { - _jit->function->stack = ((/* first 16 bytes must be allocated */ - (_jit->function->self.alen > 16 ? - _jit->function->self.alen : 16) - + _jitc->function->stack = ((/* first 16 bytes must be allocated */ + (_jitc->function->self.alen > 16 ? + _jitc->function->self.alen : 16) - /* align stack at 8 bytes */ - _jit->function->self.aoff) + 7) & -8; + _jitc->function->self.aoff) + 7) & -8; /* callee save registers */ subi(_SP_REGNO, _SP_REGNO, stack_framesize); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jit->function->regset, _F30)) + if (jit_regset_tstbit(_jitc->function->regset, _F30)) stxi_d(96, _SP_REGNO, _F30_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F28)) + if (jit_regset_tstbit(_jitc->function->regset, _F28)) stxi_d(88, _SP_REGNO, _F28_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F26)) + if (jit_regset_tstbit(_jitc->function->regset, _F26)) stxi_d(80, _SP_REGNO, _F26_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F24)) + if (jit_regset_tstbit(_jitc->function->regset, _F24)) stxi_d(72, _SP_REGNO, _F24_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F22)) + if (jit_regset_tstbit(_jitc->function->regset, _F22)) stxi_d(64, _SP_REGNO, _F22_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F20)) + if (jit_regset_tstbit(_jitc->function->regset, _F20)) stxi_d(56, _SP_REGNO, _F20_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F18)) + if (jit_regset_tstbit(_jitc->function->regset, _F18)) stxi_d(48, _SP_REGNO, _F18_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F16)) + if (jit_regset_tstbit(_jitc->function->regset, _F16)) stxi_d(40, _SP_REGNO, _F16_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S7)) + if (jit_regset_tstbit(_jitc->function->regset, _S7)) stxi(36, _SP_REGNO, _S7_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S6)) + if (jit_regset_tstbit(_jitc->function->regset, _S6)) stxi(32, _SP_REGNO, _S6_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S5)) + if (jit_regset_tstbit(_jitc->function->regset, _S5)) stxi(28, _SP_REGNO, _S5_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S4)) + if (jit_regset_tstbit(_jitc->function->regset, _S4)) stxi(24, _SP_REGNO, _S4_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S3)) + if (jit_regset_tstbit(_jitc->function->regset, _S3)) stxi(20, _SP_REGNO, _S3_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S2)) + if (jit_regset_tstbit(_jitc->function->regset, _S2)) stxi(16, _SP_REGNO, _S2_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S1)) + if (jit_regset_tstbit(_jitc->function->regset, _S1)) stxi(12, _SP_REGNO, _S1_REGNO); - if (jit_regset_tstbit(_jit->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(_jit->function->regset, _F30)) + if (jit_regset_tstbit(_jitc->function->regset, _F30)) stxi_d(136, _SP_REGNO, _F30_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F28)) + if (jit_regset_tstbit(_jitc->function->regset, _F28)) stxi_d(128, _SP_REGNO, _F28_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F26)) + if (jit_regset_tstbit(_jitc->function->regset, _F26)) stxi_d(120, _SP_REGNO, _F26_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F24)) + if (jit_regset_tstbit(_jitc->function->regset, _F24)) stxi_d(112, _SP_REGNO, _F24_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F22)) + if (jit_regset_tstbit(_jitc->function->regset, _F22)) stxi_d(104, _SP_REGNO, _F22_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F20)) + if (jit_regset_tstbit(_jitc->function->regset, _F20)) stxi_d(96, _SP_REGNO, _F20_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F18)) + if (jit_regset_tstbit(_jitc->function->regset, _F18)) stxi_d(88, _SP_REGNO, _F18_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _F16)) + if (jit_regset_tstbit(_jitc->function->regset, _F16)) stxi_d(80, _SP_REGNO, _F16_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S7)) + if (jit_regset_tstbit(_jitc->function->regset, _S7)) stxi(72, _SP_REGNO, _S7_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S6)) + if (jit_regset_tstbit(_jitc->function->regset, _S6)) stxi(64, _SP_REGNO, _S6_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S5)) + if (jit_regset_tstbit(_jitc->function->regset, _S5)) stxi(56, _SP_REGNO, _S5_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S4)) + if (jit_regset_tstbit(_jitc->function->regset, _S4)) stxi(48, _SP_REGNO, _S4_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S3)) + if (jit_regset_tstbit(_jitc->function->regset, _S3)) stxi(40, _SP_REGNO, _S3_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S2)) + if (jit_regset_tstbit(_jitc->function->regset, _S2)) stxi(32, _SP_REGNO, _S2_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S1)) + if (jit_regset_tstbit(_jitc->function->regset, _S1)) stxi(24, _SP_REGNO, _S1_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _S0)) + if (jit_regset_tstbit(_jitc->function->regset, _S0)) stxi(16, _SP_REGNO, _S0_REGNO); stxi( 8, _SP_REGNO, _RA_REGNO); #endif @@ -2853,7 +2853,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node) movr(_BP_REGNO, _SP_REGNO); /* alloca */ - subi(_SP_REGNO, _SP_REGNO, _jit->function->stack); + subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack); } static void @@ -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(_jit->function->regset, _F30)) + if (jit_regset_tstbit(_jitc->function->regset, _F30)) ldxi_d(_F30_REGNO, _SP_REGNO, 96); - if (jit_regset_tstbit(_jit->function->regset, _F28)) + if (jit_regset_tstbit(_jitc->function->regset, _F28)) ldxi_d(_F28_REGNO, _SP_REGNO, 88); - if (jit_regset_tstbit(_jit->function->regset, _F26)) + if (jit_regset_tstbit(_jitc->function->regset, _F26)) ldxi_d(_F26_REGNO, _SP_REGNO, 80); - if (jit_regset_tstbit(_jit->function->regset, _F24)) + if (jit_regset_tstbit(_jitc->function->regset, _F24)) ldxi_d(_F24_REGNO, _SP_REGNO, 72); - if (jit_regset_tstbit(_jit->function->regset, _F22)) + if (jit_regset_tstbit(_jitc->function->regset, _F22)) ldxi_d(_F22_REGNO, _SP_REGNO, 64); - if (jit_regset_tstbit(_jit->function->regset, _F20)) + if (jit_regset_tstbit(_jitc->function->regset, _F20)) ldxi_d(_F20_REGNO, _SP_REGNO, 56); - if (jit_regset_tstbit(_jit->function->regset, _F18)) + if (jit_regset_tstbit(_jitc->function->regset, _F18)) ldxi_d(_F18_REGNO, _SP_REGNO, 48); - if (jit_regset_tstbit(_jit->function->regset, _F16)) + if (jit_regset_tstbit(_jitc->function->regset, _F16)) ldxi_d(_F16_REGNO, _SP_REGNO, 40); - if (jit_regset_tstbit(_jit->function->regset, _S7)) + if (jit_regset_tstbit(_jitc->function->regset, _S7)) ldxi(_S7_REGNO, _SP_REGNO, 36); - if (jit_regset_tstbit(_jit->function->regset, _S6)) + if (jit_regset_tstbit(_jitc->function->regset, _S6)) ldxi(_S6_REGNO, _SP_REGNO, 32); - if (jit_regset_tstbit(_jit->function->regset, _S5)) + if (jit_regset_tstbit(_jitc->function->regset, _S5)) ldxi(_S5_REGNO, _SP_REGNO, 28); - if (jit_regset_tstbit(_jit->function->regset, _S4)) + if (jit_regset_tstbit(_jitc->function->regset, _S4)) ldxi(_S4_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jit->function->regset, _S3)) + if (jit_regset_tstbit(_jitc->function->regset, _S3)) ldxi(_S3_REGNO, _SP_REGNO, 20); - if (jit_regset_tstbit(_jit->function->regset, _S2)) + if (jit_regset_tstbit(_jitc->function->regset, _S2)) ldxi(_S2_REGNO, _SP_REGNO, 16); - if (jit_regset_tstbit(_jit->function->regset, _S1)) + if (jit_regset_tstbit(_jitc->function->regset, _S1)) ldxi(_S1_REGNO, _SP_REGNO, 12); - if (jit_regset_tstbit(_jit->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(_jit->function->regset, _F30)) + if (jit_regset_tstbit(_jitc->function->regset, _F30)) ldxi_d(_F30_REGNO, _SP_REGNO, 136); - if (jit_regset_tstbit(_jit->function->regset, _F28)) + if (jit_regset_tstbit(_jitc->function->regset, _F28)) ldxi_d(_F28_REGNO, _SP_REGNO, 128); - if (jit_regset_tstbit(_jit->function->regset, _F26)) + if (jit_regset_tstbit(_jitc->function->regset, _F26)) ldxi_d(_F26_REGNO, _SP_REGNO, 120); - if (jit_regset_tstbit(_jit->function->regset, _F24)) + if (jit_regset_tstbit(_jitc->function->regset, _F24)) ldxi_d(_F24_REGNO, _SP_REGNO, 112); - if (jit_regset_tstbit(_jit->function->regset, _F22)) + if (jit_regset_tstbit(_jitc->function->regset, _F22)) ldxi_d(_F22_REGNO, _SP_REGNO, 104); - if (jit_regset_tstbit(_jit->function->regset, _F20)) + if (jit_regset_tstbit(_jitc->function->regset, _F20)) ldxi_d(_F20_REGNO, _SP_REGNO, 96); - if (jit_regset_tstbit(_jit->function->regset, _F18)) + if (jit_regset_tstbit(_jitc->function->regset, _F18)) ldxi_d(_F18_REGNO, _SP_REGNO, 88); - if (jit_regset_tstbit(_jit->function->regset, _F16)) + if (jit_regset_tstbit(_jitc->function->regset, _F16)) ldxi_d(_F16_REGNO, _SP_REGNO, 80); - if (jit_regset_tstbit(_jit->function->regset, _S7)) + if (jit_regset_tstbit(_jitc->function->regset, _S7)) ldxi(_S7_REGNO, _SP_REGNO, 72); - if (jit_regset_tstbit(_jit->function->regset, _S6)) + if (jit_regset_tstbit(_jitc->function->regset, _S6)) ldxi(_S6_REGNO, _SP_REGNO, 64); - if (jit_regset_tstbit(_jit->function->regset, _S5)) + if (jit_regset_tstbit(_jitc->function->regset, _S5)) ldxi(_S5_REGNO, _SP_REGNO, 56); - if (jit_regset_tstbit(_jit->function->regset, _S4)) + if (jit_regset_tstbit(_jitc->function->regset, _S4)) ldxi(_S4_REGNO, _SP_REGNO, 48); - if (jit_regset_tstbit(_jit->function->regset, _S3)) + if (jit_regset_tstbit(_jitc->function->regset, _S3)) ldxi(_S3_REGNO, _SP_REGNO, 40); - if (jit_regset_tstbit(_jit->function->regset, _S2)) + if (jit_regset_tstbit(_jitc->function->regset, _S2)) ldxi(_S2_REGNO, _SP_REGNO, 32); - if (jit_regset_tstbit(_jit->function->regset, _S1)) + if (jit_regset_tstbit(_jitc->function->regset, _S1)) ldxi(_S1_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jit->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 b646b3fe6..4372ae240 100644 --- a/lib/jit_mips.c +++ b/lib/jit_mips.c @@ -109,7 +109,7 @@ jit_get_cpu(void) void _jit_init(jit_state_t *_jit) { - _jit->reglen = jit_size(_rvs) - 1; + _jitc->reglen = jit_size(_rvs) - 1; jit_carry = _NOREG; } @@ -118,51 +118,51 @@ _jit_prolog(jit_state_t *_jit) { jit_int32_t offset; - if (_jit->function) + if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jit->regarg, 0) == 0); - jit_regset_set_ui(_jit->regsav, 0); - offset = _jit->functions.offset; - if (offset >= _jit->functions.length) { - _jit->functions.ptr = realloc(_jit->functions.ptr, - (_jit->functions.length + 16) * + 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) { + _jitc->functions.ptr = realloc(_jitc->functions.ptr, + (_jitc->functions.length + 16) * sizeof(jit_function_t)); - memset(_jit->functions.ptr + _jit->functions.length, 0, + memset(_jitc->functions.ptr + _jitc->functions.length, 0, 16 * sizeof(jit_function_t)); - _jit->functions.length += 16; + _jitc->functions.length += 16; } - _jit->function = _jit->functions.ptr + _jit->functions.offset++; - _jit->function->self.size = stack_framesize; - _jit->function->self.argi = _jit->function->self.argf = - _jit->function->self.aoff = _jit->function->self.alen = 0; - _jit->function->self.call = jit_call_default; - _jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t)); + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = stack_framesize; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.aoff = _jitc->function->self.alen = 0; + _jitc->function->self.call = jit_call_default; + _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t)); - _jit->function->prolog = jit_new_node_no_link(jit_code_prolog); - jit_link(_jit->function->prolog); - _jit->function->prolog->w.w = offset; - _jit->function->epilog = jit_new_node_no_link(jit_code_epilog); + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); /* u: label value * v: offset in blocks vector * w: offset in functions vector */ - _jit->function->epilog->w.w = offset; + _jitc->function->epilog->w.w = offset; - jit_regset_new(_jit->function->regset); + jit_regset_new(_jitc->function->regset); } jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { - assert(_jit->function); + assert(_jitc->function); switch (length) { case 0: case 1: break; - case 2: _jit->function->self.aoff &= -2; break; - case 3: case 4: _jit->function->self.aoff &= -4; break; - default: _jit->function->self.aoff &= -8; break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; } - _jit->function->self.aoff -= length; - return (_jit->function->self.aoff); + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); } void @@ -170,11 +170,11 @@ _jit_ret(jit_state_t *_jit) { jit_node_t *instr; - assert(_jit->function); + assert(_jitc->function); /* jump to epilog */ instr = jit_jmpi(); - jit_patch_at(instr, _jit->function->epilog); + jit_patch_at(instr, _jitc->function->epilog); } void @@ -232,10 +232,10 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u) void _jit_epilog(jit_state_t *_jit) { - assert(_jit->function); - assert(_jit->function->epilog->next == NULL); - jit_link(_jit->function->epilog); - _jit->function = NULL; + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; } jit_node_t * @@ -243,12 +243,12 @@ _jit_arg(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - offset = (_jit->function->self.size - stack_framesize) >> 2; - _jit->function->self.argi = 1; + assert(_jitc->function); + offset = (_jitc->function->self.size - stack_framesize) >> 2; + _jitc->function->self.argi = 1; if (offset >= 4) - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_word_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); return (jit_new_node_w(jit_code_arg, offset)); } @@ -263,21 +263,21 @@ _jit_arg_f(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - offset = (_jit->function->self.size - stack_framesize) >> 2; + assert(_jitc->function); + offset = (_jitc->function->self.size - stack_framesize) >> 2; if (offset < 4) { - if (!_jit->function->self.argi) { + if (!_jitc->function->self.argi) { if (offset == 0) offset = 4; else { offset = 6; - _jit->function->self.argi = 1; + _jitc->function->self.argi = 1; } } } else - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float32_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float32_t); return (jit_new_node_w(jit_code_arg_f, offset)); } @@ -294,19 +294,19 @@ _jit_arg_d(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.size & 7) { - _jit->function->self.size += 4; - _jit->function->self.argi = 1; + assert(_jitc->function); + if (_jitc->function->self.size & 7) { + _jitc->function->self.size += 4; + _jitc->function->self.argi = 1; } - offset = (_jit->function->self.size - stack_framesize) >> 2; + offset = (_jitc->function->self.size - stack_framesize) >> 2; if (offset < 4) { - if (!_jit->function->self.argi) + if (!_jitc->function->self.argi) offset += 4; } else - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float64_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float64_t); return (jit_new_node_w(jit_code_arg_d, offset)); } @@ -413,14 +413,14 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u) { jit_word_t offset; - assert(_jit->function); - offset = _jit->function->call.size >> 2; - _jit->function->call.argi = 1; + assert(_jitc->function); + offset = _jitc->function->call.size >> 2; + _jitc->function->call.argi = 1; if (offset < 4) jit_movr(_A0 - offset, u); else - jit_stxi(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); } void @@ -429,18 +429,18 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u) jit_int32_t regno; jit_word_t offset; - assert(_jit->function); - offset = _jit->function->call.size >> 2; - ++_jit->function->call.argi; + assert(_jitc->function); + offset = _jitc->function->call.size >> 2; + ++_jitc->function->call.argi; if (offset < 4) jit_movi(_A0 - offset, u); else { regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); - jit_stxi(_jit->function->call.size, JIT_SP, regno); + jit_stxi(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); } - _jit->function->call.size += sizeof(jit_word_t); + _jitc->function->call.size += sizeof(jit_word_t); } void @@ -448,19 +448,19 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) { jit_word_t offset; - assert(_jit->function); - offset = _jit->function->call.size >> 2; - if (offset < 2 && !_jit->function->call.argi) { - ++_jit->function->call.argf; + assert(_jitc->function); + offset = _jitc->function->call.size >> 2; + if (offset < 2 && !_jitc->function->call.argi) { + ++_jitc->function->call.argf; jit_movr_f(_F12 - offset, u); } else if (offset < 4) { - ++_jit->function->call.argi; + ++_jitc->function->call.argi; jit_movr_f_w(_A0 - offset, u); } else - jit_stxi_f(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float32_t); + jit_stxi_f(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float32_t); } void @@ -469,23 +469,23 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) jit_int32_t regno; jit_word_t offset; - assert(_jit->function); - offset = _jit->function->call.size >> 2; - if (offset < 2 && !_jit->function->call.argi) { - ++_jit->function->call.argf; + assert(_jitc->function); + offset = _jitc->function->call.size >> 2; + if (offset < 2 && !_jitc->function->call.argi) { + ++_jitc->function->call.argf; jit_movi_f(_F12 - offset, u); } else if (offset < 4) { - ++_jit->function->call.argi; + ++_jitc->function->call.argi; jit_movi_f_w(_A0 - offset, u); } else { regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - jit_stxi_f(_jit->function->call.size, JIT_SP, regno); + jit_stxi_f(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); } - _jit->function->call.size += sizeof(jit_float32_t); + _jitc->function->call.size += sizeof(jit_float32_t); } void @@ -494,26 +494,26 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) jit_bool_t adjust; jit_word_t offset; - assert(_jit->function); - adjust = !!_jit->function->call.argi; - if (_jit->function->call.size & 7) { - _jit->function->call.size += 4; + assert(_jitc->function); + adjust = !!_jitc->function->call.argi; + if (_jitc->function->call.size & 7) { + _jitc->function->call.size += 4; adjust = 1; } - offset = _jit->function->call.size >> 2; + offset = _jitc->function->call.size >> 2; if (offset < 3) { if (adjust) { jit_movr_d_ww(_A0 - offset, _A0 - (offset + 1), u); - _jit->function->call.argi += 2; + _jitc->function->call.argi += 2; } else { jit_movr_d(_F12 - (offset >> 1), u); - ++_jit->function->call.argf; + ++_jitc->function->call.argf; } } else - jit_stxi_d(_jit->function->call.size, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float64_t); } void @@ -523,30 +523,30 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) jit_bool_t adjust; jit_word_t offset; - assert(_jit->function); - adjust = !!_jit->function->call.argi; - if (_jit->function->call.size & 7) { - _jit->function->call.size += 4; + assert(_jitc->function); + adjust = !!_jitc->function->call.argi; + if (_jitc->function->call.size & 7) { + _jitc->function->call.size += 4; adjust = 1; } - offset = _jit->function->call.size >> 2; + offset = _jitc->function->call.size >> 2; if (offset < 3) { if (adjust) { jit_movi_d_ww(_A0 - offset, _A0 - (offset + 1), u); - _jit->function->call.argi += 2; + _jitc->function->call.argi += 2; } else { jit_movi_d(_F12 - (offset >> 1), u); - ++_jit->function->call.argf; + ++_jitc->function->call.argf; } } else { regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); - jit_stxi_d(_jit->function->call.size, JIT_SP, regno); + jit_stxi_d(_jitc->function->call.size, JIT_SP, regno); jit_unget_reg(regno); } - _jit->function->call.size += sizeof(jit_float64_t); + _jitc->function->call.size += sizeof(jit_float64_t); } jit_bool_t @@ -576,16 +576,16 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0) { jit_node_t *call; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; jit_movr(_T9, r0); call = jit_callr(_T9); - call->v.w = _jit->function->self.argi; - call->w.w = _jit->function->self.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + call->v.w = _jitc->function->self.argi; + call->w.w = _jitc->function->self.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; } jit_node_t * @@ -594,16 +594,16 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) jit_node_t *call; jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; node = jit_movi(_T9, (jit_word_t)i0); call = jit_callr(_T9); - call->v.w = _jit->function->call.argi; - call->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + call->v.w = _jitc->function->call.argi; + call->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; return (node); } @@ -685,7 +685,7 @@ _emit_code(jit_state_t *_jit) jit_int32_t patch_offset; } undo; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); @@ -775,8 +775,8 @@ _emit_code(jit_state_t *_jit) patch(word, node); \ } \ break - for (node = _jit->head; node; node = node->next) { - if (_jit->pc.uc >= _jit->code.end) + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end) return (NULL); value = jit_classify(node->code); @@ -1169,17 +1169,17 @@ _emit_code(jit_state_t *_jit) calli(node->u.w); break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; undo.node = node; undo.word = _jit->pc.w; - undo.patch_offset = _jit->patches.offset; + undo.patch_offset = _jitc->patches.offset; restart_function: - _jit->again = 0; + _jitc->again = 0; prolog(node); break; case jit_code_epilog: - assert(_jit->function == _jit->functions.ptr + node->w.w); - if (_jit->again) { + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { for (temp = undo.node->next; temp != node; temp = temp->next) { if (temp->code == jit_code_label || @@ -1188,14 +1188,14 @@ _emit_code(jit_state_t *_jit) } node = undo.node; _jit->pc.w = undo.word; - _jit->patches.offset = undo.patch_offset; + _jitc->patches.offset = undo.patch_offset; goto restart_function; } /* remember label is defined */ node->flag |= jit_flag_patch; node->u.w = _jit->pc.w; epilog(node); - _jit->function = NULL; + _jitc->function = NULL; break; case jit_code_movr_w_f: movr_w_f(rn(node->u.w), rn(node->v.w)); @@ -1254,10 +1254,10 @@ _emit_code(jit_state_t *_jit) #undef case_rw #undef case_rr - for (offset = 0; offset < _jit->patches.offset; offset++) { - node = _jit->patches.ptr[offset].node; + for (offset = 0; offset < _jitc->patches.offset; offset++) { + node = _jitc->patches.ptr[offset].node; word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; - patch_at(_jit->patches.ptr[offset].inst, word); + patch_at(_jitc->patches.ptr[offset].inst, word); } #if defined(__linux__) @@ -1315,15 +1315,15 @@ _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) else flag = node->u.n->flag; assert(!(flag & jit_flag_patch)); - if (_jit->patches.offset >= _jit->patches.length) { - _jit->patches.ptr = realloc(_jit->patches.ptr, - (_jit->patches.length + 1024) * + if (_jitc->patches.offset >= _jitc->patches.length) { + _jitc->patches.ptr = realloc(_jitc->patches.ptr, + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); - memset(_jit->patches.ptr + _jit->patches.length, 0, + memset(_jitc->patches.ptr + _jitc->patches.length, 0, 1024 * sizeof(jit_patch_t)); - _jit->patches.length += 1024; + _jitc->patches.length += 1024; } - _jit->patches.ptr[_jit->patches.offset].inst = instr; - _jit->patches.ptr[_jit->patches.offset].node = node; - ++_jit->patches.offset; + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; } diff --git a/lib/jit_note.c b/lib/jit_note.c index 284f02d38..6b30a02c1 100644 --- a/lib/jit_note.c +++ b/lib/jit_note.c @@ -54,17 +54,17 @@ _jit_name(jit_state_t *_jit, char *name) node->v.n = jit_data(name, strlen(name) + 1, 1); else node->v.p = NULL; - if (_jit->note.head == NULL) - _jit->note.head = _jit->note.tail = node; + if (_jitc->note.head == NULL) + _jitc->note.head = _jitc->note.tail = node; else { - _jit->note.tail->link = node; - _jit->note.tail = node; + _jitc->note.tail->link = node; + _jitc->note.tail = node; } ++_jit->note.length; - _jit->note.size += sizeof(jit_note_t); + _jitc->note.size += sizeof(jit_note_t); /* remember previous note is invalid due to name change */ - _jit->note.note = NULL; - return (_jit->note.name = node); + _jitc->note.note = NULL; + return (_jitc->note.name = node); } jit_node_t * @@ -78,20 +78,20 @@ _jit_note(jit_state_t *_jit, char *name, int line) else node->v.p = NULL; node->w.w = line; - if (_jit->note.head == NULL) - _jit->note.head = _jit->note.tail = node; + if (_jitc->note.head == NULL) + _jitc->note.head = _jitc->note.tail = node; else { - _jit->note.tail->link = node; - _jit->note.tail = node; + _jitc->note.tail->link = node; + _jitc->note.tail = node; } - if (_jit->note.note == NULL || - (name == NULL && _jit->note.note != NULL) || - (name != NULL && _jit->note.note == NULL) || - (name != NULL && _jit->note.note != NULL && - strcmp(name, (char *)_jit->data.ptr + _jit->note.note->v.n->u.w))) - _jit->note.size += sizeof(jit_line_t); - _jit->note.size += sizeof(jit_int32_t) * 2; - return (_jit->note.note = node); + if (_jitc->note.note == NULL || + (name == NULL && _jitc->note.note != NULL) || + (name != NULL && _jitc->note.note == NULL) || + (name != NULL && _jitc->note.note != NULL && + strcmp(name, (char *)_jit->data.ptr + _jitc->note.note->v.n->u.w))) + _jitc->note.size += sizeof(jit_line_t); + _jitc->note.size += sizeof(jit_int32_t) * 2; + return (_jitc->note.note = node); } void @@ -105,11 +105,11 @@ _jit_annotate(jit_state_t *_jit) jit_word_t line_offset; /* initialize pointers in mmaped data area */ - _jit->note.ptr = (jit_note_t *)_jit->note.base; + _jit->note.ptr = (jit_note_t *)_jitc->note.base; _jit->note.length = 0; note = NULL; - for (node = _jit->note.head; node; node = node->link) { + for (node = _jitc->note.head; node; node = node->link) { if (node->code == jit_code_name) note = new_note(node->u.p, node->v.p ? node->v.n->u.p : NULL); else if (node->v.p) { @@ -132,11 +132,11 @@ _jit_annotate(jit_state_t *_jit) for (note_offset = 0; note_offset < _jit->note.length; note_offset++) { note = _jit->note.ptr + note_offset; length = sizeof(jit_line_t) * note->length; - assert(_jit->note.base + length < _jit->data.ptr + _jit->data.length); - memcpy(_jit->note.base, note->lines, length); + assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length); + memcpy(_jitc->note.base, note->lines, length); free(note->lines); - note->lines = (jit_line_t *)_jit->note.base; - _jit->note.base += length; + note->lines = (jit_line_t *)_jitc->note.base; + _jitc->note.base += length; } /* relocate offset and line number information */ @@ -145,18 +145,18 @@ _jit_annotate(jit_state_t *_jit) for (line_offset = 0; line_offset < note->length; line_offset++) { line = note->lines + line_offset; length = sizeof(jit_int32_t) * line->length; - assert(_jit->note.base + length < + assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length); - memcpy(_jit->note.base, line->linenos, length); + memcpy(_jitc->note.base, line->linenos, length); free(line->linenos); - line->linenos = (jit_int32_t *)_jit->note.base; - _jit->note.base += length; - assert(_jit->note.base + length < + line->linenos = (jit_int32_t *)_jitc->note.base; + _jitc->note.base += length; + assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length); - memcpy(_jit->note.base, line->offsets, length); + memcpy(_jitc->note.base, line->offsets, length); free(line->offsets); - line->offsets = (jit_int32_t *)_jit->note.base; - _jit->note.base += length; + line->offsets = (jit_int32_t *)_jitc->note.base; + _jitc->note.base += length; } } } @@ -252,8 +252,8 @@ _new_note(jit_state_t *_jit, jit_uint8_t *code, char *name) assert(code >= prev->code); prev->size = code - prev->code; } - note = (jit_note_t *)_jit->note.base; - _jit->note.base += sizeof(jit_note_t); + note = (jit_note_t *)_jitc->note.base; + _jitc->note.base += sizeof(jit_note_t); ++_jit->note.length; note->code = code; note->name = name; diff --git a/lib/jit_ppc-cpu.c b/lib/jit_ppc-cpu.c index 16856268e..7d21e31ac 100644 --- a/lib/jit_ppc-cpu.c +++ b/lib/jit_ppc-cpu.c @@ -2471,20 +2471,20 @@ _prolog(jit_state_t *_jit, jit_node_t *node) unsigned long regno; jit_word_t offset; - _jit->function->stack = ((_jit->function->self.alen + - _jit->function->self.size - - _jit->function->self.aoff) + 15) & -16; + _jitc->function->stack = ((_jitc->function->self.alen + + _jitc->function->self.size - + _jitc->function->self.aoff) + 15) & -16; /* return address */ MFLR(_R0_REGNO); /* save any clobbered callee save gpr register */ - regno = jit_regset_scan1(_jit->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(_jit->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)); } @@ -2494,7 +2494,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node) * alloca < %r31-80 */ movr(_FP_REGNO, _SP_REGNO); - STWU(_SP_REGNO, _SP_REGNO, -_jit->function->stack); + STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack); } static void @@ -2508,12 +2508,12 @@ _epilog(jit_state_t *_jit, jit_node_t *node) MTLR(_R0_REGNO); - regno = jit_regset_scan1(_jit->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(_jit->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); } BLR(); diff --git a/lib/jit_ppc.c b/lib/jit_ppc.c index 5dc8f6af2..a71b3552c 100644 --- a/lib/jit_ppc.c +++ b/lib/jit_ppc.c @@ -114,7 +114,7 @@ jit_get_cpu(void) void _jit_init(jit_state_t *_jit) { - _jit->reglen = jit_size(_rvs) - 1; + _jitc->reglen = jit_size(_rvs) - 1; } void @@ -122,53 +122,53 @@ _jit_prolog(jit_state_t *_jit) { jit_int32_t offset; - if (_jit->function) + if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jit->regarg, 0) == 0); - jit_regset_set_ui(_jit->regsav, 0); - offset = _jit->functions.offset; - if (offset >= _jit->functions.length) { - _jit->functions.ptr = realloc(_jit->functions.ptr, - (_jit->functions.length + 16) * + 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) { + _jitc->functions.ptr = realloc(_jitc->functions.ptr, + (_jitc->functions.length + 16) * sizeof(jit_function_t)); - memset(_jit->functions.ptr + _jit->functions.length, 0, + memset(_jitc->functions.ptr + _jitc->functions.length, 0, 16 * sizeof(jit_function_t)); - _jit->functions.length += 16; + _jitc->functions.length += 16; } - _jit->function = _jit->functions.ptr + _jit->functions.offset++; - _jit->function->self.size = params_offset; - _jit->function->self.argi = _jit->function->self.argf = - _jit->function->self.alen = 0; + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = params_offset; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.alen = 0; /* float conversion */ - _jit->function->self.aoff = alloca_offset - 8; - _jit->function->self.call = jit_call_default; - _jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t)); + _jitc->function->self.aoff = alloca_offset - 8; + _jitc->function->self.call = jit_call_default; + _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t)); - _jit->function->prolog = jit_new_node_no_link(jit_code_prolog); - jit_link(_jit->function->prolog); - _jit->function->prolog->w.w = offset; - _jit->function->epilog = jit_new_node_no_link(jit_code_epilog); + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); /* u: label value * v: offset in blocks vector * w: offset in functions vector */ - _jit->function->epilog->w.w = offset; + _jitc->function->epilog->w.w = offset; - jit_regset_new(_jit->function->regset); + jit_regset_new(_jitc->function->regset); } jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { - assert(_jit->function); + assert(_jitc->function); switch (length) { case 0: case 1: break; - case 2: _jit->function->self.aoff &= -2; break; - case 3: case 4: _jit->function->self.aoff &= -4; break; - default: _jit->function->self.aoff &= -8; break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; } - _jit->function->self.aoff -= length; - return (_jit->function->self.aoff); + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); } void @@ -176,11 +176,11 @@ _jit_ret(jit_state_t *_jit) { jit_node_t *instr; - assert(_jit->function); + assert(_jitc->function); /* jump to epilog */ instr = jit_jmpi(); - jit_patch_at(instr, _jit->function->epilog); + jit_patch_at(instr, _jitc->function->epilog); } void @@ -238,22 +238,22 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u) void _jit_epilog(jit_state_t *_jit) { - assert(_jit->function); - assert(_jit->function->epilog->next == NULL); - jit_link(_jit->function->epilog); - _jit->function = NULL; + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; } jit_node_t * _jit_arg(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argi < 8) - offset = _jit->function->self.argi++; + assert(_jitc->function); + if (_jitc->function->self.argi < 8) + offset = _jitc->function->self.argi++; else - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_word_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); return (jit_new_node_w(jit_code_arg, offset)); } @@ -267,12 +267,12 @@ jit_node_t * _jit_arg_f(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argf < 13) - offset = _jit->function->self.argf++; + assert(_jitc->function); + if (_jitc->function->self.argf < 13) + offset = _jitc->function->self.argf++; else - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float32_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float32_t); return (jit_new_node_w(jit_code_arg_f, offset)); } @@ -286,12 +286,12 @@ jit_node_t * _jit_arg_d(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argf < 13) - offset = _jit->function->self.argf++; + assert(_jitc->function); + if (_jitc->function->self.argf < 13) + offset = _jitc->function->self.argf++; else - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float64_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float64_t); return (jit_new_node_w(jit_code_arg_d, offset)); } @@ -423,62 +423,62 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_pushargr(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (_jit->function->call.argi < 8) { - jit_movr(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + assert(_jitc->function); + if (_jitc->function->call.argi < 8) { + jit_movr(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else - jit_stxi(_jit->function->call.size + params_offset, JIT_SP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); } void _jit_pushargi(jit_state_t *_jit, jit_word_t u) { jit_int32_t regno; - assert(_jit->function); - if (_jit->function->call.argi < 8) { - jit_movi(JIT_RA0 - _jit->function->call.argi, u); - ++_jit->function->call.argi; + assert(_jitc->function); + if (_jitc->function->call.argi < 8) { + jit_movi(JIT_RA0 - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else { regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); - jit_stxi(_jit->function->call.size + params_offset, JIT_SP, regno); + jit_stxi(_jitc->function->call.size + params_offset, JIT_SP, regno); jit_unget_reg(regno); } - _jit->function->call.size += sizeof(jit_word_t); + _jitc->function->call.size += sizeof(jit_word_t); } void _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (_jit->function->call.argf < 13) { - jit_movr_d(JIT_FA0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; - if (!(_jit->function->call.call & jit_call_varargs)) { + assert(_jitc->function); + if (_jitc->function->call.argf < 13) { + jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; + if (!(_jitc->function->call.call & jit_call_varargs)) { /* in case of excess arguments */ - if (_jit->function->call.argi < 8) - _jit->function->call.argi += 2; - _jit->function->call.size += sizeof(jit_float32_t); + if (_jitc->function->call.argi < 8) + _jitc->function->call.argi += 2; + _jitc->function->call.size += sizeof(jit_float32_t); return; } } - if (_jit->function->call.argi < 8) { + if (_jitc->function->call.argi < 8) { /* use reserved 8 bytes area */ jit_stxi_d(alloca_offset - 8, JIT_FP, u); - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 8); - _jit->function->call.argi++; - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + _jitc->function->call.argi++; + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 4); - _jit->function->call.argi++; + _jitc->function->call.argi++; } else - jit_stxi_f(_jit->function->call.size + params_offset, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float32_t); + jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float32_t); } void @@ -486,64 +486,64 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) { jit_int32_t regno; - assert(_jit->function); - if (_jit->function->call.argf < 13) { - jit_movi_d(JIT_FA0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; - if (!(_jit->function->call.call & jit_call_varargs)) { + assert(_jitc->function); + if (_jitc->function->call.argf < 13) { + jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; + if (!(_jitc->function->call.call & jit_call_varargs)) { /* in case of excess arguments */ - if (_jit->function->call.argi < 8) - _jit->function->call.argi += 2; - _jit->function->call.size += sizeof(jit_float32_t); + if (_jitc->function->call.argi < 8) + _jitc->function->call.argi += 2; + _jitc->function->call.size += sizeof(jit_float32_t); return; } } regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - if (_jit->function->call.argi < 8) { + if (_jitc->function->call.argi < 8) { /* use reserved 8 bytes area */ jit_stxi_d(alloca_offset - 8, JIT_FP, regno); - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 8); - _jit->function->call.argi++; - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + _jitc->function->call.argi++; + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 4); - _jit->function->call.argi++; + _jitc->function->call.argi++; } else - jit_stxi_f(_jit->function->call.size + params_offset, JIT_SP, regno); - _jit->function->call.size += sizeof(jit_float32_t); + jit_stxi_f(_jitc->function->call.size + params_offset, JIT_SP, regno); + _jitc->function->call.size += sizeof(jit_float32_t); jit_unget_reg(regno); } void _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); - if (_jit->function->call.argf < 13) { - jit_movr_d(JIT_FA0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; - if (!(_jit->function->call.call & jit_call_varargs)) { + assert(_jitc->function); + if (_jitc->function->call.argf < 13) { + jit_movr_d(JIT_FA0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; + if (!(_jitc->function->call.call & jit_call_varargs)) { /* in case of excess arguments */ - if (_jit->function->call.argi < 8) - _jit->function->call.argi += 2; - _jit->function->call.size += sizeof(jit_float64_t); + if (_jitc->function->call.argi < 8) + _jitc->function->call.argi += 2; + _jitc->function->call.size += sizeof(jit_float64_t); return; } } - if (_jit->function->call.argi < 8) { + if (_jitc->function->call.argi < 8) { /* use reserved 8 bytes area */ jit_stxi_d(alloca_offset - 8, JIT_FP, u); - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 8); - _jit->function->call.argi++; - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + _jitc->function->call.argi++; + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 4); - _jit->function->call.argi++; + _jitc->function->call.argi++; } else - jit_stxi_d(_jit->function->call.size + params_offset, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float64_t); } void @@ -551,33 +551,33 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) { jit_int32_t regno; - assert(_jit->function); - if (_jit->function->call.argf < 13) { - jit_movi_d(JIT_FA0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; - if (!(_jit->function->call.call & jit_call_varargs)) { + assert(_jitc->function); + if (_jitc->function->call.argf < 13) { + jit_movi_d(JIT_FA0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; + if (!(_jitc->function->call.call & jit_call_varargs)) { /* in case of excess arguments */ - if (_jit->function->call.argi < 8) - _jit->function->call.argi += 2; - _jit->function->call.size += sizeof(jit_float64_t); + if (_jitc->function->call.argi < 8) + _jitc->function->call.argi += 2; + _jitc->function->call.size += sizeof(jit_float64_t); return; } } regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); - if (_jit->function->call.argi < 8) { + if (_jitc->function->call.argi < 8) { /* use reserved 8 bytes area */ jit_stxi_d(alloca_offset - 8, JIT_FP, regno); - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 8); - _jit->function->call.argi++; - jit_ldxi(JIT_RA0 - _jit->function->call.argi, JIT_FP, + _jitc->function->call.argi++; + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, alloca_offset - 4); - _jit->function->call.argi++; + _jitc->function->call.argi++; } else - jit_stxi_d(_jit->function->call.size + params_offset, JIT_SP, regno); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size + params_offset, JIT_SP, regno); + _jitc->function->call.size += sizeof(jit_float64_t); jit_unget_reg(regno); } @@ -605,28 +605,28 @@ void _jit_finishr(jit_state_t *_jit, jit_int32_t r0) { jit_node_t *call; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; call = jit_callr(r0); - call->v.w = _jit->function->call.argi; - call->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = 0; - _jit->prepare = 0; + call->v.w = _jitc->function->call.argi; + call->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = 0; + _jitc->prepare = 0; } jit_node_t * _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) { jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; node = jit_calli(i0); - node->v.w = _jit->function->call.argi; - node->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = 0; - _jit->prepare = 0; + node->v.w = _jitc->function->call.argi; + node->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = 0; + _jitc->prepare = 0; return (node); } @@ -707,7 +707,7 @@ _emit_code(jit_state_t *_jit) jit_int32_t patch_offset; } undo; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); @@ -798,8 +798,8 @@ _emit_code(jit_state_t *_jit) patch(word, node); \ } \ break - for (node = _jit->head; node; node = node->next) { - if (_jit->pc.uc >= _jit->code.end) + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end) return (NULL); value = jit_classify(node->code); @@ -1169,17 +1169,17 @@ _emit_code(jit_state_t *_jit) calli(node->u.w); break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; undo.node = node; undo.word = _jit->pc.w; - undo.patch_offset = _jit->patches.offset; + undo.patch_offset = _jitc->patches.offset; restart_function: - _jit->again = 0; + _jitc->again = 0; prolog(node); break; case jit_code_epilog: - assert(_jit->function == _jit->functions.ptr + node->w.w); - if (_jit->again) { + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { for (temp = undo.node->next; temp != node; temp = temp->next) { if (temp->code == jit_code_label || @@ -1188,14 +1188,14 @@ _emit_code(jit_state_t *_jit) } node = undo.node; _jit->pc.w = undo.word; - _jit->patches.offset = undo.patch_offset; + _jitc->patches.offset = undo.patch_offset; goto restart_function; } /* remember label is defined */ node->flag |= jit_flag_patch; node->u.w = _jit->pc.w; epilog(node); - _jit->function = NULL; + _jitc->function = NULL; break; case jit_code_live: case jit_code_arg: @@ -1219,10 +1219,10 @@ _emit_code(jit_state_t *_jit) #undef case_rw #undef case_rr - for (offset = 0; offset < _jit->patches.offset; offset++) { - node = _jit->patches.ptr[offset].node; + for (offset = 0; offset < _jitc->patches.offset; offset++) { + node = _jitc->patches.ptr[offset].node; word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; - patch_at(_jit->patches.ptr[offset].inst, word); + patch_at(_jitc->patches.ptr[offset].inst, word); } __clear_cache(_jit->code.ptr, _jit->pc.uc); @@ -1279,15 +1279,15 @@ _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) else flag = node->u.n->flag; assert(!(flag & jit_flag_patch)); - if (_jit->patches.offset >= _jit->patches.length) { - _jit->patches.ptr = realloc(_jit->patches.ptr, - (_jit->patches.length + 1024) * + if (_jitc->patches.offset >= _jitc->patches.length) { + _jitc->patches.ptr = realloc(_jitc->patches.ptr, + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); - memset(_jit->patches.ptr + _jit->patches.length, 0, + memset(_jitc->patches.ptr + _jitc->patches.length, 0, 1024 * sizeof(jit_patch_t)); - _jit->patches.length += 1024; + _jitc->patches.length += 1024; } - _jit->patches.ptr[_jit->patches.offset].inst = instr; - _jit->patches.ptr[_jit->patches.offset].node = node; - ++_jit->patches.offset; + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; } diff --git a/lib/jit_print.c b/lib/jit_print.c index 5cec55b6a..07b22094d 100644 --- a/lib/jit_print.c +++ b/lib/jit_print.c @@ -227,7 +227,7 @@ _jit_print(jit_state_t *_jit) jit_int32_t offset; first = 0; - for (node = _jit->head; node; node = node->next) { + for (node = _jitc->head; node; node = node->next) { if (!first) print_chr('\n'); else @@ -237,8 +237,8 @@ _jit_print(jit_state_t *_jit) print_chr('L'); print_dec(node->v.w); print_chr(':'); - block = _jit->blocks.ptr + node->v.w; - for (offset = 0; offset < _jit->reglen; offset++) { + block = _jitc->blocks.ptr + node->v.w; + for (offset = 0; offset < _jitc->reglen; 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 960d0b08a..8bb20d318 100644 --- a/lib/jit_sparc-cpu.c +++ b/lib/jit_sparc-cpu.c @@ -1619,28 +1619,28 @@ static void _prolog(jit_state_t *_jit, jit_node_t *node) { /* align at 16 bytes boundary */ - _jit->function->stack = ((stack_framesize + - _jit->function->self.alen - - _jit->function->self.aoff) + 15) & -16; - SAVEI(_SP_REGNO, -_jit->function->stack, _SP_REGNO); + _jitc->function->stack = ((stack_framesize + + _jitc->function->self.alen - + _jitc->function->self.aoff) + 15) & -16; + SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO); /* (most) other backends do not save incoming arguments, so, * only save locals here */ - if (jit_regset_tstbit(_jit->function->regset, _L0)) + if (jit_regset_tstbit(_jitc->function->regset, _L0)) stxi(0, _SP_REGNO, _L0_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L1)) + if (jit_regset_tstbit(_jitc->function->regset, _L1)) stxi(4, _SP_REGNO, _L1_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L2)) + if (jit_regset_tstbit(_jitc->function->regset, _L2)) stxi(8, _SP_REGNO, _L2_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L3)) + if (jit_regset_tstbit(_jitc->function->regset, _L3)) stxi(12, _SP_REGNO, _L3_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L4)) + if (jit_regset_tstbit(_jitc->function->regset, _L4)) stxi(16, _SP_REGNO, _L4_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L5)) + if (jit_regset_tstbit(_jitc->function->regset, _L5)) stxi(20, _SP_REGNO, _L5_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _L6)) + if (jit_regset_tstbit(_jitc->function->regset, _L6)) stxi(24, _SP_REGNO, _L6_REGNO); - if (jit_regset_tstbit(_jit->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(_jit->function->regset, _L0)) + if (jit_regset_tstbit(_jitc->function->regset, _L0)) ldxi(_L0_REGNO, _SP_REGNO, 0); - if (jit_regset_tstbit(_jit->function->regset, _L1)) + if (jit_regset_tstbit(_jitc->function->regset, _L1)) ldxi(_L1_REGNO, _SP_REGNO, 4); - if (jit_regset_tstbit(_jit->function->regset, _L2)) + if (jit_regset_tstbit(_jitc->function->regset, _L2)) ldxi(_L2_REGNO, _SP_REGNO, 8); - if (jit_regset_tstbit(_jit->function->regset, _L3)) + if (jit_regset_tstbit(_jitc->function->regset, _L3)) ldxi(_L3_REGNO, _SP_REGNO, 12); - if (jit_regset_tstbit(_jit->function->regset, _L4)) + if (jit_regset_tstbit(_jitc->function->regset, _L4)) ldxi(_L4_REGNO, _SP_REGNO, 16); - if (jit_regset_tstbit(_jit->function->regset, _L5)) + if (jit_regset_tstbit(_jitc->function->regset, _L5)) ldxi(_L5_REGNO, _SP_REGNO, 20); - if (jit_regset_tstbit(_jit->function->regset, _L6)) + if (jit_regset_tstbit(_jitc->function->regset, _L6)) ldxi(_L6_REGNO, _SP_REGNO, 24); - if (jit_regset_tstbit(_jit->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 cc71698a9..ca09c2f46 100644 --- a/lib/jit_sparc.c +++ b/lib/jit_sparc.c @@ -95,7 +95,7 @@ jit_get_cpu(void) void _jit_init(jit_state_t *_jit) { - _jit->reglen = jit_size(_rvs) - 1; + _jitc->reglen = jit_size(_rvs) - 1; } void @@ -103,53 +103,53 @@ _jit_prolog(jit_state_t *_jit) { jit_int32_t offset; - if (_jit->function) + if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jit->regarg, 0) == 0); - jit_regset_set_ui(_jit->regsav, 0); - offset = _jit->functions.offset; - if (offset >= _jit->functions.length) { - _jit->functions.ptr = realloc(_jit->functions.ptr, - (_jit->functions.length + 16) * + 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) { + _jitc->functions.ptr = realloc(_jitc->functions.ptr, + (_jitc->functions.length + 16) * sizeof(jit_function_t)); - memset(_jit->functions.ptr + _jit->functions.length, 0, + memset(_jitc->functions.ptr + _jitc->functions.length, 0, 16 * sizeof(jit_function_t)); - _jit->functions.length += 16; + _jitc->functions.length += 16; } - _jit->function = _jit->functions.ptr + _jit->functions.offset++; - _jit->function->self.size = stack_framesize; - _jit->function->self.argi = _jit->function->self.argf = - _jit->function->self.aoff = _jit->function->self.alen = 0; + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = stack_framesize; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.aoff = _jitc->function->self.alen = 0; /* float conversion */ - _jit->function->self.aoff = -8; - _jit->function->self.call = jit_call_default; - _jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t)); + _jitc->function->self.aoff = -8; + _jitc->function->self.call = jit_call_default; + _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t)); - _jit->function->prolog = jit_new_node_no_link(jit_code_prolog); - jit_link(_jit->function->prolog); - _jit->function->prolog->w.w = offset; - _jit->function->epilog = jit_new_node_no_link(jit_code_epilog); + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); /* u: label value * v: offset in blocks vector * w: offset in functions vector */ - _jit->function->epilog->w.w = offset; + _jitc->function->epilog->w.w = offset; - jit_regset_new(_jit->function->regset); + jit_regset_new(_jitc->function->regset); } jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { - assert(_jit->function); + assert(_jitc->function); switch (length) { case 0: case 1: break; - case 2: _jit->function->self.aoff &= -2; break; - case 3: case 4: _jit->function->self.aoff &= -4; break; - default: _jit->function->self.aoff &= -8; break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; } - _jit->function->self.aoff -= length; - return (_jit->function->self.aoff); + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); } void @@ -157,11 +157,11 @@ _jit_ret(jit_state_t *_jit) { jit_node_t *instr; - assert(_jit->function); + assert(_jitc->function); /* jump to epilog */ instr = jit_jmpi(); - jit_patch_at(instr, _jit->function->epilog); + jit_patch_at(instr, _jitc->function->epilog); } void @@ -218,22 +218,22 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u) void _jit_epilog(jit_state_t *_jit) { - assert(_jit->function); - assert(_jit->function->epilog->next == NULL); - jit_link(_jit->function->epilog); - _jit->function = NULL; + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; } jit_node_t * _jit_arg(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argi < 6) - offset = _jit->function->self.argi++; + assert(_jitc->function); + if (_jitc->function->self.argi < 6) + offset = _jitc->function->self.argi++; else { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_word_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); } return (jit_new_node_w(jit_code_arg, offset)); } @@ -248,12 +248,12 @@ jit_node_t * _jit_arg_f(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argi < 6) - offset = _jit->function->self.argi++; + assert(_jitc->function); + if (_jitc->function->self.argi < 6) + offset = _jitc->function->self.argi++; else { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float32_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float32_t); } return (jit_new_node_w(jit_code_arg_f, offset)); } @@ -268,18 +268,18 @@ jit_node_t * _jit_arg_d(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); - if (_jit->function->self.argi < 5) { - offset = _jit->function->self.argi; - _jit->function->self.argi += 2; + assert(_jitc->function); + if (_jitc->function->self.argi < 5) { + offset = _jitc->function->self.argi; + _jitc->function->self.argi += 2; } - else if (_jit->function->self.argi < 6) { - offset = _jit->function->self.argi++; - _jit->function->self.size += sizeof(jit_float32_t); + else if (_jitc->function->self.argi < 6) { + offset = _jitc->function->self.argi++; + _jitc->function->self.size += sizeof(jit_float32_t); } else { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float64_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float64_t); } return (jit_new_node_w(jit_code_arg_d, offset)); } @@ -350,7 +350,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) { - assert(_jit->function); + assert(_jitc->function); if (v->u.w < 6) { jit_stxi(-4, JIT_FP, _I0 + v->u.w); jit_ldxi_f(u, JIT_FP, -4); @@ -362,7 +362,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) { - assert(_jit->function); + assert(_jitc->function); if (v->u.w < 5) { jit_stxi(-8, JIT_FP, _I0 + v->u.w); jit_stxi(-4, JIT_FP, _I0 + v->u.w + 1); @@ -380,13 +380,13 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_pushargr(jit_state_t *_jit, jit_int32_t u) { - if (_jit->function->call.argi < 6) { - jit_movr(_O0 + _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 6) { + jit_movr(_O0 + _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else { - jit_stxi(_jit->function->call.size + stack_framesize, JIT_SP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size + stack_framesize, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_word_t); } } @@ -394,30 +394,30 @@ void _jit_pushargi(jit_state_t *_jit, jit_word_t u) { jit_int32_t regno; - if (_jit->function->call.argi < 6) { - jit_movi(_O0 + _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 6) { + jit_movi(_O0 + _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else { regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); - jit_stxi(_jit->function->call.size + stack_framesize, JIT_SP, regno); + jit_stxi(_jitc->function->call.size + stack_framesize, JIT_SP, regno); jit_unget_reg(regno); - _jit->function->call.size += sizeof(jit_word_t); + _jitc->function->call.size += sizeof(jit_word_t); } } void _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) { - if (_jit->function->call.argi < 6) { + if (_jitc->function->call.argi < 6) { jit_stxi_f(-4, JIT_FP, u); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -4); - ++_jit->function->call.argi; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -4); + ++_jitc->function->call.argi; } else { - jit_stxi_f(_jit->function->call.size + stack_framesize, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float32_t); + jit_stxi_f(_jitc->function->call.size + stack_framesize, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float32_t); } } @@ -427,14 +427,14 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) jit_int32_t regno; regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - if (_jit->function->call.argi < 6) { + if (_jitc->function->call.argi < 6) { jit_stxi_f(-4, JIT_FP, regno); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -4); - ++_jit->function->call.argi; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -4); + ++_jitc->function->call.argi; } else { - jit_stxi_f(_jit->function->call.size + stack_framesize, JIT_SP, regno); - _jit->function->call.size += sizeof(jit_float32_t); + jit_stxi_f(_jitc->function->call.size + stack_framesize, JIT_SP, regno); + _jitc->function->call.size += sizeof(jit_float32_t); } jit_unget_reg(regno); } @@ -442,22 +442,22 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) void _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) { - if (_jit->function->call.argi < 5) { + if (_jitc->function->call.argi < 5) { jit_stxi_d(-8, JIT_FP, u); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8); - jit_ldxi(_O0 + _jit->function->call.argi + 1, JIT_FP, -4); - _jit->function->call.argi += 2; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); + jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4); + _jitc->function->call.argi += 2; } - else if (_jit->function->call.argi < 6) { + else if (_jitc->function->call.argi < 6) { jit_stxi_f(-8, JIT_FP, u); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8); - ++_jit->function->call.argi; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); + ++_jitc->function->call.argi; jit_stxi_f(stack_framesize, JIT_SP, u + 1); - _jit->function->call.size += sizeof(jit_float32_t); + _jitc->function->call.size += sizeof(jit_float32_t); } else { - jit_stxi_d(_jit->function->call.size + stack_framesize, JIT_SP, u); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size + stack_framesize, JIT_SP, u); + _jitc->function->call.size += sizeof(jit_float64_t); } } @@ -467,22 +467,22 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) jit_int32_t regno; regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); - if (_jit->function->call.argi < 5) { + if (_jitc->function->call.argi < 5) { jit_stxi_d(-8, JIT_FP, regno); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8); - jit_ldxi(_O0 + _jit->function->call.argi + 1, JIT_FP, -4); - _jit->function->call.argi += 2; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); + jit_ldxi(_O0 + _jitc->function->call.argi + 1, JIT_FP, -4); + _jitc->function->call.argi += 2; } - else if (_jit->function->call.argi < 6) { + else if (_jitc->function->call.argi < 6) { jit_stxi_f(-8, JIT_FP, regno); - jit_ldxi(_O0 + _jit->function->call.argi, JIT_FP, -8); - ++_jit->function->call.argi; + jit_ldxi(_O0 + _jitc->function->call.argi, JIT_FP, -8); + ++_jitc->function->call.argi; jit_stxi_f(stack_framesize, JIT_SP, regno + 1); - _jit->function->call.size += sizeof(jit_float32_t); + _jitc->function->call.size += sizeof(jit_float32_t); } else { - jit_stxi_d(_jit->function->call.size + stack_framesize, JIT_SP, regno); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size + stack_framesize, JIT_SP, regno); + _jitc->function->call.size += sizeof(jit_float64_t); } jit_unget_reg(regno); } @@ -508,15 +508,15 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0) { jit_node_t *call; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; call = jit_callr(r0); - call->v.w = _jit->function->self.argi; - call->w.w = _jit->function->self.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + call->v.w = _jitc->function->self.argi; + call->w.w = _jitc->function->self.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; } jit_node_t * @@ -524,15 +524,15 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) { jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; node = jit_calli(i0); - node->v.w = _jit->function->call.argi; - node->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + node->v.w = _jitc->function->call.argi; + node->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; return (node); } @@ -595,7 +595,7 @@ _emit_code(jit_state_t *_jit) jit_int32_t patch_offset; } undo; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); @@ -692,8 +692,8 @@ _emit_code(jit_state_t *_jit) patch(word, node); \ } \ break - for (node = _jit->head; node; node = node->next) { - if (_jit->pc.uc >= _jit->code.end) + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end) return (NULL); value = jit_classify(node->code); @@ -1059,17 +1059,17 @@ _emit_code(jit_state_t *_jit) calli(node->u.w); break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; undo.node = node; undo.word = _jit->pc.w; - undo.patch_offset = _jit->patches.offset; + undo.patch_offset = _jitc->patches.offset; restart_function: - _jit->again = 0; + _jitc->again = 0; prolog(node); break; case jit_code_epilog: - assert(_jit->function == _jit->functions.ptr + node->w.w); - if (_jit->again) { + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { for (temp = undo.node->next; temp != node; temp = temp->next) { if (temp->code == jit_code_label || @@ -1078,14 +1078,14 @@ _emit_code(jit_state_t *_jit) } node = undo.node; _jit->pc.w = undo.word; - _jit->patches.offset = undo.patch_offset; + _jitc->patches.offset = undo.patch_offset; goto restart_function; } /* remember label is defined */ node->flag |= jit_flag_patch; node->u.w = _jit->pc.w; epilog(node); - _jit->function = NULL; + _jitc->function = NULL; break; case jit_code_live: case jit_code_arg: @@ -1112,10 +1112,10 @@ _emit_code(jit_state_t *_jit) #undef case_rw #undef case_rr - for (offset = 0; offset < _jit->patches.offset; offset++) { - node = _jit->patches.ptr[offset].node; + for (offset = 0; offset < _jitc->patches.offset; offset++) { + node = _jitc->patches.ptr[offset].node; word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; - patch_at(_jit->patches.ptr[offset].inst, word); + patch_at(_jitc->patches.ptr[offset].inst, word); } return (_jit->code.ptr); @@ -1161,15 +1161,15 @@ _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) else flag = node->u.n->flag; assert(!(flag & jit_flag_patch)); - if (_jit->patches.offset >= _jit->patches.length) { - _jit->patches.ptr = realloc(_jit->patches.ptr, - (_jit->patches.length + 1024) * + if (_jitc->patches.offset >= _jitc->patches.length) { + _jitc->patches.ptr = realloc(_jitc->patches.ptr, + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); - memset(_jit->patches.ptr + _jit->patches.length, 0, + memset(_jitc->patches.ptr + _jitc->patches.length, 0, 1024 * sizeof(jit_patch_t)); - _jit->patches.length += 1024; + _jitc->patches.length += 1024; } - _jit->patches.ptr[_jit->patches.offset].inst = instr; - _jit->patches.ptr[_jit->patches.offset].node = node; - ++_jit->patches.offset; + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; } diff --git a/lib/jit_x86-cpu.c b/lib/jit_x86-cpu.c index 708c68053..2565e195f 100644 --- a/lib/jit_x86-cpu.c +++ b/lib/jit_x86-cpu.c @@ -863,22 +863,22 @@ _alui(jit_state_t *_jit, jit_int32_t code, jit_int32_t r0, jit_word_t i0) static void _save(jit_state_t *_jit, jit_int32_t r0) { - if (!_jit->function->regoff[r0]) { - _jit->function->regoff[r0] = jit_allocai(sizeof(jit_word_t)); - _jit->again = 1; + if (!_jitc->function->regoff[r0]) { + _jitc->function->regoff[r0] = jit_allocai(sizeof(jit_word_t)); + _jitc->again = 1; } - assert(!jit_regset_tstbit(_jit->regsav, r0)); - jit_regset_setbit(_jit->regsav, r0); - stxi(_jit->function->regoff[r0], _RBP_REGNO, r0); + assert(!jit_regset_tstbit(_jitc->regsav, r0)); + jit_regset_setbit(_jitc->regsav, r0); + stxi(_jitc->function->regoff[r0], _RBP_REGNO, r0); } static void _load(jit_state_t *_jit, jit_int32_t r0) { - assert(_jit->function->regoff[r0]); - assert(jit_regset_tstbit(_jit->regsav, r0)); - jit_regset_clrbit(_jit->regsav, r0); - ldxi(r0, _RBP_REGNO, _jit->function->regoff[r0]); + assert(_jitc->function->regoff[r0]); + assert(jit_regset_tstbit(_jitc->regsav, r0)); + jit_regset_clrbit(_jitc->regsav, r0); + ldxi(r0, _RBP_REGNO, _jitc->function->regoff[r0]); } static void @@ -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(_jit->regsav, rv) || \ - !jit_regset_tstbit(_jit->reglive, rv)) \ + if ( jit_regset_tstbit(_jitc->regsav, rv) || \ + !jit_regset_tstbit(_jitc->reglive, rv)) \ sav &= ~(1 << rn); \ else \ save(rv); \ @@ -3303,39 +3303,39 @@ static void _prolog(jit_state_t *_jit, jit_node_t *node) { #if __WORDSIZE == 32 - _jit->function->stack = (((_jit->function->self.alen - - _jit->function->self.aoff) + 15) & -16) + 12; + _jitc->function->stack = (((_jitc->function->self.alen - + _jitc->function->self.aoff) + 15) & -16) + 12; #else - _jit->function->stack = (((_jit->function->self.alen - - _jit->function->self.aoff) + 15) & -16) + 8; + _jitc->function->stack = (((_jitc->function->self.alen - + _jitc->function->self.aoff) + 15) & -16) + 8; #endif /* callee save registers */ subi(_RSP_REGNO, _RSP_REGNO, stack_framesize - sizeof(jit_word_t)); #if __WORDSIZE == 32 - if (jit_regset_tstbit(_jit->function->regset, _RDI)) + if (jit_regset_tstbit(_jitc->function->regset, _RDI)) stxi(12, _RSP_REGNO, _RDI_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _RSI)) + if (jit_regset_tstbit(_jitc->function->regset, _RSI)) stxi( 8, _RSP_REGNO, _RSI_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _RBX)) + if (jit_regset_tstbit(_jitc->function->regset, _RBX)) stxi( 4, _RSP_REGNO, _RBX_REGNO); #else - if (jit_regset_tstbit(_jit->function->regset, _RBX)) + if (jit_regset_tstbit(_jitc->function->regset, _RBX)) stxi(40, _RSP_REGNO, _RBX_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _R12)) + if (jit_regset_tstbit(_jitc->function->regset, _R12)) stxi(32, _RSP_REGNO, _R12_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _R13)) + if (jit_regset_tstbit(_jitc->function->regset, _R13)) stxi(24, _RSP_REGNO, _R13_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _R14)) + if (jit_regset_tstbit(_jitc->function->regset, _R14)) stxi(16, _RSP_REGNO, _R14_REGNO); - if (jit_regset_tstbit(_jit->function->regset, _R15)) + if (jit_regset_tstbit(_jitc->function->regset, _R15)) stxi( 8, _RSP_REGNO, _R15_REGNO); #endif stxi(0, _RSP_REGNO, _RBP_REGNO); movr(_RBP_REGNO, _RSP_REGNO); /* alloca */ - subi(_RSP_REGNO, _RSP_REGNO, _jit->function->stack); + subi(_RSP_REGNO, _RSP_REGNO, _jitc->function->stack); } static void @@ -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(_jit->function->regset, _RDI)) + if (jit_regset_tstbit(_jitc->function->regset, _RDI)) ldxi(_RDI_REGNO, _RSP_REGNO, 12); - if (jit_regset_tstbit(_jit->function->regset, _RSI)) + if (jit_regset_tstbit(_jitc->function->regset, _RSI)) ldxi(_RSI_REGNO, _RSP_REGNO, 8); - if (jit_regset_tstbit(_jit->function->regset, _RBX)) + if (jit_regset_tstbit(_jitc->function->regset, _RBX)) ldxi(_RBX_REGNO, _RSP_REGNO, 4); #else - if (jit_regset_tstbit(_jit->function->regset, _RBX)) + if (jit_regset_tstbit(_jitc->function->regset, _RBX)) ldxi(_RBX_REGNO, _RSP_REGNO, 40); - if (jit_regset_tstbit(_jit->function->regset, _R12)) + if (jit_regset_tstbit(_jitc->function->regset, _R12)) ldxi(_R12_REGNO, _RSP_REGNO, 32); - if (jit_regset_tstbit(_jit->function->regset, _R13)) + if (jit_regset_tstbit(_jitc->function->regset, _R13)) ldxi(_R13_REGNO, _RSP_REGNO, 24); - if (jit_regset_tstbit(_jit->function->regset, _R14)) + if (jit_regset_tstbit(_jitc->function->regset, _R14)) ldxi(_R14_REGNO, _RSP_REGNO, 16); - if (jit_regset_tstbit(_jit->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 f33448a76..33441f8d3 100644 --- a/lib/jit_x86.c +++ b/lib/jit_x86.c @@ -273,11 +273,11 @@ _jit_init(jit_state_t *_jit) static jit_bool_t first = 1; #endif - _jit->reglen = jit_size(_rvs) - 1; + _jitc->reglen = jit_size(_rvs) - 1; #if __WORDSIZE == 32 if (first) { if (!jit_cpu.sse2) { - for (regno = _jit->reglen; regno >= 0; regno--) { + for (regno = _jitc->reglen; regno >= 0; regno--) { if (_rvs[regno].spec & jit_class_xpr) _rvs[regno].spec = 0; } @@ -292,53 +292,53 @@ _jit_prolog(jit_state_t *_jit) { jit_int32_t offset; - if (_jit->function) + if (_jitc->function) jit_epilog(); - assert(jit_regset_cmp_ui(_jit->regarg, 0) == 0); - jit_regset_set_ui(_jit->regsav, 0); - offset = _jit->functions.offset; - if (offset >= _jit->functions.length) { - _jit->functions.ptr = realloc(_jit->functions.ptr, - (_jit->functions.length + 16) * + 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) { + _jitc->functions.ptr = realloc(_jitc->functions.ptr, + (_jitc->functions.length + 16) * sizeof(jit_function_t)); - memset(_jit->functions.ptr + _jit->functions.length, 0, + memset(_jitc->functions.ptr + _jitc->functions.length, 0, 16 * sizeof(jit_function_t)); - _jit->functions.length += 16; + _jitc->functions.length += 16; } - _jit->function = _jit->functions.ptr + _jit->functions.offset++; - _jit->function->self.size = stack_framesize; - _jit->function->self.argi = _jit->function->self.argf = - _jit->function->self.aoff = _jit->function->self.alen = 0; + _jitc->function = _jitc->functions.ptr + _jitc->functions.offset++; + _jitc->function->self.size = stack_framesize; + _jitc->function->self.argi = _jitc->function->self.argf = + _jitc->function->self.aoff = _jitc->function->self.alen = 0; /* sse/x87 conversion */ - _jit->function->self.aoff = -8; - _jit->function->self.call = jit_call_default; - _jit->function->regoff = calloc(_jit->reglen, sizeof(jit_int32_t)); + _jitc->function->self.aoff = -8; + _jitc->function->self.call = jit_call_default; + _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t)); - _jit->function->prolog = jit_new_node_no_link(jit_code_prolog); - jit_link(_jit->function->prolog); - _jit->function->prolog->w.w = offset; - _jit->function->epilog = jit_new_node_no_link(jit_code_epilog); + _jitc->function->prolog = jit_new_node_no_link(jit_code_prolog); + jit_link(_jitc->function->prolog); + _jitc->function->prolog->w.w = offset; + _jitc->function->epilog = jit_new_node_no_link(jit_code_epilog); /* u: label value * v: offset in blocks vector * w: offset in functions vector */ - _jit->function->epilog->w.w = offset; + _jitc->function->epilog->w.w = offset; - jit_regset_new(_jit->function->regset); + jit_regset_new(_jitc->function->regset); } jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { - assert(_jit->function); + assert(_jitc->function); switch (length) { case 0: case 1: break; - case 2: _jit->function->self.aoff &= -2; break; - case 3: case 4: _jit->function->self.aoff &= -4; break; - default: _jit->function->self.aoff &= -8; break; + case 2: _jitc->function->self.aoff &= -2; break; + case 3: case 4: _jitc->function->self.aoff &= -4; break; + default: _jitc->function->self.aoff &= -8; break; } - _jit->function->self.aoff -= length; - return (_jit->function->self.aoff); + _jitc->function->self.aoff -= length; + return (_jitc->function->self.aoff); } void @@ -346,11 +346,11 @@ _jit_ret(jit_state_t *_jit) { jit_node_t *instr; - assert(_jit->function); + assert(_jitc->function); /* jump to epilog */ instr = jit_jmpi(); - jit_patch_at(instr, _jit->function->epilog); + jit_patch_at(instr, _jitc->function->epilog); } void @@ -409,10 +409,10 @@ _jit_reti_d(jit_state_t *_jit, jit_float64_t u) void _jit_epilog(jit_state_t *_jit) { - assert(_jit->function); - assert(_jit->function->epilog->next == NULL); - jit_link(_jit->function->epilog); - _jit->function = NULL; + assert(_jitc->function); + assert(_jitc->function->epilog->next == NULL); + jit_link(_jitc->function->epilog); + _jitc->function = NULL; } jit_node_t * @@ -420,15 +420,15 @@ _jit_arg(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->self.argi < 6) - offset = _jit->function->self.argi++; + if (_jitc->function->self.argi < 6) + offset = _jitc->function->self.argi++; else #endif { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_word_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_word_t); } return (jit_new_node_w(jit_code_arg, offset)); } @@ -448,18 +448,18 @@ _jit_arg_f(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->self.argf < 8) - offset = _jit->function->self.argf++; + if (_jitc->function->self.argf < 8) + offset = _jitc->function->self.argf++; else #endif { - offset = _jit->function->self.size; + offset = _jitc->function->self.size; #if __WORDSIZE == 32 - _jit->function->self.size += sizeof(jit_float32_t); + _jitc->function->self.size += sizeof(jit_float32_t); #else - _jit->function->self.size += sizeof(jit_float64_t); + _jitc->function->self.size += sizeof(jit_float64_t); #endif } return (jit_new_node_w(jit_code_arg_f, offset)); @@ -480,15 +480,15 @@ _jit_arg_d(jit_state_t *_jit) { jit_int32_t offset; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->self.argf < 8) - offset = _jit->function->self.argf++; + if (_jitc->function->self.argf < 8) + offset = _jitc->function->self.argf++; else #endif { - offset = _jit->function->self.size; - _jit->function->self.size += sizeof(jit_float64_t); + offset = _jitc->function->self.size; + _jitc->function->self.size += sizeof(jit_float64_t); } return (jit_new_node_w(jit_code_arg_d, offset)); } @@ -599,17 +599,17 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) void _jit_pushargr(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argi < 6) { - jit_movr(_RDI - _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 6) { + jit_movr(_RDI - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else #endif { - jit_stxi(_jit->function->call.size, _RSP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size, _RSP, u); + _jitc->function->call.size += sizeof(jit_word_t); } } @@ -618,19 +618,19 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u) { jit_int32_t regno; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argi < 6) { - jit_movi(_RDI - _jit->function->call.argi, u); - ++_jit->function->call.argi; + if (_jitc->function->call.argi < 6) { + jit_movi(_RDI - _jitc->function->call.argi, u); + ++_jitc->function->call.argi; } else #endif { regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); - jit_stxi(_jit->function->call.size, _RSP, regno); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi(_jitc->function->call.size, _RSP, regno); + _jitc->function->call.size += sizeof(jit_word_t); jit_unget_reg(regno); } } @@ -638,17 +638,17 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u) void _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argf < 8) { - jit_movr_f(_XMM0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; + if (_jitc->function->call.argf < 8) { + jit_movr_f(_XMM0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; } else #endif { - jit_stxi_f(_jit->function->call.size, _RSP, u); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi_f(_jitc->function->call.size, _RSP, u); + _jitc->function->call.size += sizeof(jit_word_t); } } @@ -657,19 +657,19 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) { jit_int32_t regno; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argf < 8) { - jit_movi_f(_XMM0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; + if (_jitc->function->call.argf < 8) { + jit_movi_f(_XMM0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; } else #endif { regno = jit_get_reg(jit_class_fpr); jit_movi_f(regno, u); - jit_stxi_f(_jit->function->call.size, _RSP, regno); - _jit->function->call.size += sizeof(jit_word_t); + jit_stxi_f(_jitc->function->call.size, _RSP, regno); + _jitc->function->call.size += sizeof(jit_word_t); jit_unget_reg(regno); } } @@ -677,17 +677,17 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) void _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) { - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argf < 8) { - jit_movr_d(_XMM0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; + if (_jitc->function->call.argf < 8) { + jit_movr_d(_XMM0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; } else #endif { - jit_stxi_d(_jit->function->call.size, _RSP, u); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size, _RSP, u); + _jitc->function->call.size += sizeof(jit_float64_t); } } @@ -696,19 +696,19 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) { jit_int32_t regno; - assert(_jit->function); + assert(_jitc->function); #if __WORDSIZE == 64 - if (_jit->function->call.argf < 8) { - jit_movi_d(_XMM0 - _jit->function->call.argf, u); - ++_jit->function->call.argf; + if (_jitc->function->call.argf < 8) { + jit_movi_d(_XMM0 - _jitc->function->call.argf, u); + ++_jitc->function->call.argf; } else #endif { regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); - jit_stxi_d(_jit->function->call.size, _RSP, regno); - _jit->function->call.size += sizeof(jit_float64_t); + jit_stxi_d(_jitc->function->call.size, _RSP, regno); + _jitc->function->call.size += sizeof(jit_float64_t); jit_unget_reg(regno); } } @@ -743,17 +743,17 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0) jit_node_t *call; reg = r0; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; #if __WORDSIZE == 64 - if (_jit->function->call.call & jit_call_varargs) { + if (_jitc->function->call.call & jit_call_varargs) { if (jit_regno(reg) == _RAX) { reg = jit_get_reg(jit_class_gpr); jit_movr(reg, _RAX); } - if (_jit->function->call.argf) - jit_movi(_RAX, _jit->function->call.argf); + if (_jitc->function->call.argf) + jit_movi(_RAX, _jitc->function->call.argf); else jit_movi(_RAX, 0); if (reg != r0) @@ -761,11 +761,11 @@ _jit_finishr(jit_state_t *_jit, jit_int32_t r0) } #endif call = jit_callr(reg); - call->v.w = _jit->function->call.argi; - call->w.w = _jit->function->call.argf; - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + call->v.w = _jitc->function->call.argi; + call->w.w = _jitc->function->call.argf; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; } jit_node_t * @@ -776,30 +776,30 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) #endif jit_node_t *node; - assert(_jit->function); - if (_jit->function->self.alen < _jit->function->call.size) - _jit->function->self.alen = _jit->function->call.size; + assert(_jitc->function); + if (_jitc->function->self.alen < _jitc->function->call.size) + _jitc->function->self.alen = _jitc->function->call.size; #if __WORDSIZE == 64 /* FIXME preventing %rax allocation is good enough, but for consistency * it should automatically detect %rax is dead, in case it has run out * 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(_jit->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(_jit->regarg, _RAX); + jit_regset_clrbit(_jitc->regarg, _RAX); #else node = jit_calli(i0); - node->v.w = _jit->function->call.argi; - node->w.w = _jit->function->call.argf; + node->v.w = _jitc->function->call.argi; + node->w.w = _jitc->function->call.argf; #endif - _jit->function->call.argi = _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 0; + _jitc->function->call.argi = _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 0; return (node); } @@ -889,7 +889,7 @@ _emit_code(jit_state_t *_jit) jit_int32_t patch_offset; } undo; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); @@ -1125,8 +1125,8 @@ _emit_code(jit_state_t *_jit) patch(word, node); \ } \ break - for (node = _jit->head; node; node = node->next) { - if (_jit->pc.uc >= _jit->code.end) + for (node = _jitc->head; node; node = node->next) { + if (_jit->pc.uc >= _jitc->code.end) return (NULL); value = jit_classify(node->code); @@ -1558,17 +1558,17 @@ _emit_code(jit_state_t *_jit) calli(node->u.w); break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; undo.node = node; undo.word = _jit->pc.w; - undo.patch_offset = _jit->patches.offset; + undo.patch_offset = _jitc->patches.offset; restart_function: - _jit->again = 0; + _jitc->again = 0; prolog(node); break; case jit_code_epilog: - assert(_jit->function == _jit->functions.ptr + node->w.w); - if (_jit->again) { + assert(_jitc->function == _jitc->functions.ptr + node->w.w); + if (_jitc->again) { for (temp = undo.node->next; temp != node; temp = temp->next) { if (temp->code == jit_code_label || @@ -1577,7 +1577,7 @@ _emit_code(jit_state_t *_jit) } node = undo.node; _jit->pc.w = undo.word; - _jit->patches.offset = undo.patch_offset; + _jitc->patches.offset = undo.patch_offset; goto restart_function; } if (node->link && @@ -1587,7 +1587,7 @@ _emit_code(jit_state_t *_jit) node->flag |= jit_flag_patch; node->u.w = _jit->pc.w; epilog(node); - _jit->function = NULL; + _jitc->function = NULL; break; #if __WORDSIZE == 32 case jit_code_x86_retval_f: @@ -1637,10 +1637,10 @@ _emit_code(jit_state_t *_jit) #undef case_fr #undef case_rr - for (offset = 0; offset < _jit->patches.offset; offset++) { - node = _jit->patches.ptr[offset].node; + for (offset = 0; offset < _jitc->patches.offset; offset++) { + node = _jitc->patches.ptr[offset].node; word = node->code == jit_code_movi ? node->v.n->u.w : node->u.n->u.w; - patch_at(node, _jit->patches.ptr[offset].inst, word); + patch_at(node, _jitc->patches.ptr[offset].inst, word); } return (_jit->code.ptr); @@ -1693,17 +1693,17 @@ _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node) else flag = node->u.n->flag; assert(!(flag & jit_flag_patch)); - if (_jit->patches.offset >= _jit->patches.length) { - _jit->patches.ptr = realloc(_jit->patches.ptr, - (_jit->patches.length + 1024) * + if (_jitc->patches.offset >= _jitc->patches.length) { + _jitc->patches.ptr = realloc(_jitc->patches.ptr, + (_jitc->patches.length + 1024) * sizeof(jit_patch_t)); - memset(_jit->patches.ptr + _jit->patches.length, 0, + memset(_jitc->patches.ptr + _jitc->patches.length, 0, 1024 * sizeof(jit_patch_t)); - _jit->patches.length += 1024; + _jitc->patches.length += 1024; } - _jit->patches.ptr[_jit->patches.offset].inst = instr; - _jit->patches.ptr[_jit->patches.offset].node = node; - ++_jit->patches.offset; + _jitc->patches.ptr[_jitc->patches.offset].inst = instr; + _jitc->patches.ptr[_jitc->patches.offset].node = node; + ++_jitc->patches.offset; } static void diff --git a/lib/lightning.c b/lib/lightning.c index d0697438f..ea37aca12 100644 --- a/lib/lightning.c +++ b/lib/lightning.c @@ -157,68 +157,68 @@ _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(_jit->regsav, regno)) + if (jit_regset_tstbit(_jitc->regsav, regno)) /* fail if register is spilled */ goto fail; - if (jit_regset_tstbit(_jit->regarg, regno)) + if (jit_regset_tstbit(_jitc->regarg, regno)) /* fail if register is an argument to current instruction */ goto fail; - if (jit_regset_tstbit(_jit->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(_jit->regarg, regno); + jit_regset_setbit(_jitc->regarg, regno); return (regno); } else assert(jit_class(spec) != 0); - if (_jit->emit) { + if (_jitc->emit) { /* search for a free register matching spec */ - for (regno = 0; regno < _jit->reglen; regno++) { + for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jit->regarg, regno) && - !jit_regset_tstbit(_jit->reglive, regno)) + !jit_regset_tstbit(_jitc->regarg, regno) && + !jit_regset_tstbit(_jitc->reglive, regno)) goto regarg; } /* search for a register matching spec that is not an argument * for the current instruction */ - for (regno = 0; regno < _jit->reglen; regno++) { + for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jit->regsav, regno) && - !jit_regset_tstbit(_jit->regarg, regno) && + !jit_regset_tstbit(_jitc->regsav, regno) && + !jit_regset_tstbit(_jitc->regarg, regno) && !(regspec & jit_class_nospill)) { spill: - assert(_jit->function); + assert(_jitc->function); if (spec & jit_class_gpr) { - if (!_jit->function->regoff[regno]) { - _jit->function->regoff[regno] = + if (!_jitc->function->regoff[regno]) { + _jitc->function->regoff[regno] = jit_allocai(sizeof(jit_word_t)); - _jit->again = 1; + _jitc->again = 1; } - emit_stxi(_jit->function->regoff[regno], JIT_FP, regno); + emit_stxi(_jitc->function->regoff[regno], JIT_FP, regno); } else { - if (!_jit->function->regoff[regno]) { - _jit->function->regoff[regno] = + if (!_jitc->function->regoff[regno]) { + _jitc->function->regoff[regno] = jit_allocai(sizeof(jit_float64_t)); - _jit->again = 1; + _jitc->again = 1; } - emit_stxi_d(_jit->function->regoff[regno], JIT_FP, regno); + emit_stxi_d(_jitc->function->regoff[regno], JIT_FP, regno); } - jit_regset_setbit(_jit->regsav, regno); + jit_regset_setbit(_jitc->regsav, regno); regarg: - jit_regset_setbit(_jit->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(_jit->function); - if (!jit_regset_tstbit(_jit->function->regset, regno)) { - jit_regset_setbit(_jit->function->regset, regno); - _jit->again = 1; + assert(_jitc->function); + if (!jit_regset_tstbit(_jitc->function->regset, regno)) { + jit_regset_setbit(_jitc->function->regset, regno); + _jitc->again = 1; } } return (regno); @@ -228,12 +228,12 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec) else { /* nospill hint only valid during emit" */ assert(!(regspec & jit_class_nospill)); - for (regno = 0; regno < _jit->reglen; regno++) { + for (regno = 0; regno < _jitc->reglen; regno++) { if ((jit_class(_rvs[regno].spec) & spec) == spec && - !jit_regset_tstbit(_jit->regsav, regno) && - !jit_regset_tstbit(_jit->regarg, regno)) { - jit_regset_setbit(_jit->regarg, regno); - jit_regset_setbit(_jit->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); } @@ -250,19 +250,19 @@ void _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno) { regno = jit_regno(regno); - if (jit_regset_tstbit(_jit->regsav, regno)) { - if (_jit->emit) { + if (jit_regset_tstbit(_jitc->regsav, regno)) { + if (_jitc->emit) { if (jit_class(_rvs[regno].spec) & jit_class_gpr) - emit_ldxi(regno, JIT_FP, _jit->function->regoff[regno]); + emit_ldxi(regno, JIT_FP, _jitc->function->regoff[regno]); else - emit_ldxi_d(regno, JIT_FP, _jit->function->regoff[regno]); + emit_ldxi_d(regno, JIT_FP, _jitc->function->regoff[regno]); } else jit_load(regno); - jit_regset_clrbit(_jit->regsav, regno); + jit_regset_clrbit(_jitc->regsav, regno); } - assert(jit_regset_tstbit(_jit->regarg, regno)); - jit_regset_clrbit(_jit->regarg, regno); + assert(jit_regset_tstbit(_jitc->regarg, regno)); + jit_regset_clrbit(_jitc->regarg, regno); } unsigned long @@ -280,8 +280,8 @@ void _jit_save(jit_state_t *_jit, jit_int32_t reg) { reg = jit_regno(reg); - assert(!_jit->emit); - _jit->spill[reg] = jit_new_node_w(jit_code_save, reg); + assert(!_jitc->emit); + _jitc->spill[reg] = jit_new_node_w(jit_code_save, reg); } void @@ -290,13 +290,13 @@ _jit_load(jit_state_t *_jit, jit_int32_t reg) jit_node_t *node; reg = jit_regno(reg); - assert(!_jit->emit); - assert(_jit->spill[reg]); + assert(!_jitc->emit); + assert(_jitc->spill[reg]); node = jit_new_node_w(jit_code_load, reg); /* create a path to flag the save/load is not required */ - node->link = _jit->spill[reg]; + node->link = _jitc->spill[reg]; node->link->link = node; - _jit->spill[reg] = NULL; + _jitc->spill[reg] = NULL; } static jit_word_t @@ -312,7 +312,7 @@ hash_data(jit_pointer_t data, jit_word_t length) jit_pointer_t _jit_address(jit_state_t *_jit, jit_node_t *node) { - assert(_jit->done); + assert(_jitc->done); assert(node && (node->code == jit_code_note || node->code == jit_code_name)); return ((jit_pointer_t)node->u.w); @@ -325,10 +325,10 @@ _jit_data(jit_state_t *_jit, jit_pointer_t data, jit_word_t key; jit_node_t *node; - assert(!_jit->emit); + assert(!_jitc->emit); /* Ensure there is space even if asking for a duplicate */ - if (((_jit->data.offset + 7) & -8) + length > _jit->data.length) { + if (((_jitc->data.offset + 7) & -8) + length > _jit->data.length) { jit_word_t size; size = (_jit->data.length + length + 4096) & - 4095; @@ -342,11 +342,11 @@ _jit_data(jit_state_t *_jit, jit_pointer_t data, } _jit->data.length = size; } - if (_jit->data.table == NULL) - _jit->data.table = calloc(_jit->data.size = 16, sizeof(jit_node_t*)); + if (_jitc->data.table == NULL) + _jitc->data.table = calloc(_jitc->data.size = 16, sizeof(jit_node_t*)); - key = hash_data(data, length) & (_jit->data.size - 1); - node = _jit->data.table[key]; + key = hash_data(data, length) & (_jitc->data.size - 1); + node = _jitc->data.table[key]; for (; node; node = node->next) { if (node->v.w == length && memcmp(_jit->data.ptr + node->u.w, data, length) == 0) @@ -361,47 +361,47 @@ _jit_data(jit_state_t *_jit, jit_pointer_t data, case 0: case 1: break; case 2: - _jit->data.offset = (_jit->data.offset + 1) & -2; + _jitc->data.offset = (_jitc->data.offset + 1) & -2; break; case 3: case 4: - _jit->data.offset = (_jit->data.offset + 3) & -4; + _jitc->data.offset = (_jitc->data.offset + 3) & -4; break; default: - _jit->data.offset = (_jit->data.offset + 7) & -8; + _jitc->data.offset = (_jitc->data.offset + 7) & -8; break; } - node->u.w = _jit->data.offset; + node->u.w = _jitc->data.offset; node->v.w = length; - memcpy(_jit->data.ptr + _jit->data.offset, data, length); - _jit->data.offset += length; + memcpy(_jit->data.ptr + _jitc->data.offset, data, length); + _jitc->data.offset += length; - node->next = _jit->data.table[key]; - _jit->data.table[key] = node; - ++_jit->data.count; + node->next = _jitc->data.table[key]; + _jitc->data.table[key] = node; + ++_jitc->data.count; /* Rehash if more than 75% used table */ - if (_jit->data.count > - (_jit->data.size >> 1) + (_jit->data.size >> 2) && - (_jit->data.size << 1) > _jit->data.size) { + if (_jitc->data.count > + (_jitc->data.size >> 1) + (_jitc->data.size >> 2) && + (_jitc->data.size << 1) > _jitc->data.size) { jit_word_t i; jit_node_t **hash; jit_node_t *next; jit_node_t *temp; - hash = calloc(_jit->data.size << 1, sizeof(jit_node_t*)); - for (i = 0; i < _jit->data.size; i++) { - temp = _jit->data.table[i]; + hash = calloc(_jitc->data.size << 1, sizeof(jit_node_t*)); + for (i = 0; i < _jitc->data.size; i++) { + temp = _jitc->data.table[i]; for (; temp; temp = next) { next = temp->next; key = hash_data(_jit->data.ptr + temp->u.w, temp->v.w) & - ((_jit->data.size << 1) - 1); + ((_jitc->data.size << 1) - 1); temp->next = hash[key]; hash[key] = temp; } } - free(_jit->data.table); - _jit->data.table = hash; - _jit->data.size <<= 1; + free(_jitc->data.table); + _jitc->data.table = hash; + _jitc->data.size <<= 1; } } @@ -414,23 +414,23 @@ _new_pool(jit_state_t *_jit) jit_node_t *list; jit_int32_t offset; - if (_jit->pool.offset >= _jit->pool.length) { + if (_jitc->pool.offset >= _jitc->pool.length) { jit_node_t **ptr; jit_int32_t length; - length = _jit->pool.length + 16; - ptr = realloc(_jit->pool.ptr, length * sizeof(jit_node_t)); - memset(ptr + _jit->pool.length, 0, 16 * sizeof(jit_node_t)); - _jit->pool.ptr = ptr; - _jit->pool.length = length; + length = _jitc->pool.length + 16; + ptr = realloc(_jitc->pool.ptr, length * sizeof(jit_node_t)); + memset(ptr + _jitc->pool.length, 0, 16 * sizeof(jit_node_t)); + _jitc->pool.ptr = ptr; + _jitc->pool.length = length; } - _jit->pool.ptr[_jit->pool.offset] = calloc(sizeof(jit_node_t), 1024); - list = _jit->pool.ptr[_jit->pool.offset]; + _jitc->pool.ptr[_jitc->pool.offset] = calloc(sizeof(jit_node_t), 1024); + list = _jitc->pool.ptr[_jitc->pool.offset]; for (offset = 1; offset < 1024; offset++, list++) list->next = list + 1; - list->next = _jit->list; - _jit->list = _jit->pool.ptr[_jit->pool.offset]; - ++_jit->pool.offset; + list->next = _jitc->list; + _jitc->list = _jitc->pool.ptr[_jitc->pool.offset]; + ++_jitc->pool.offset; } static jit_node_t * @@ -438,10 +438,10 @@ _new_node(jit_state_t *_jit, jit_code_t code) { jit_node_t *node; - if (_jit->list == NULL) + if (_jitc->list == NULL) new_pool(); - node = _jit->list; - _jit->list = node->next; + node = _jitc->list; + _jitc->list = node->next; node->next = NULL; node->code = code; @@ -451,25 +451,25 @@ _new_node(jit_state_t *_jit, jit_code_t code) static inline jit_node_t * _link_node(jit_state_t *_jit, jit_node_t *node) { - if (_jit->tail) - _jit->tail->next = node; + if (_jitc->tail) + _jitc->tail->next = node; else - _jit->head = node; - return (_jit->tail = node); + _jitc->head = node; + return (_jitc->tail = node); } static inline void _del_node(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) { if (prev == node) { - assert(prev == _jit->head); - _jit->head = node->next; + assert(prev == _jitc->head); + _jitc->head = node->next; } else prev->next = node->next; memset(node, 0, sizeof(jit_node_t)); - node->next = _jit->list; - _jit->list = node; + node->next = _jitc->list; + _jitc->list = node; } static void @@ -478,7 +478,7 @@ _del_label(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) jit_block_t *block; /* only allow call to del_label on linked labels */ - block = _jit->blocks.ptr + node->v.w; + block = _jitc->blocks.ptr + node->v.w; assert(block->label == node); /* del_label() should only be called when optimizing. @@ -498,35 +498,36 @@ jit_new_state(void) jit_state_t *_jit; _jit = calloc(1, sizeof(jit_state_t)); - jit_regset_new(_jit->regarg); - jit_regset_new(_jit->regsav); - jit_regset_new(_jit->reglive); - jit_regset_new(_jit->regmask); - mpz_init(_jit->blockmask); + _jitc = calloc(1, sizeof(jit_compiler_t)); + jit_regset_new(_jitc->regarg); + jit_regset_new(_jitc->regsav); + jit_regset_new(_jitc->reglive); + jit_regset_new(_jitc->regmask); + mpz_init(_jitc->blockmask); jit_init(); - _jit->spill = calloc(_jit->reglen, sizeof(jit_node_t*)); - _jit->gen = calloc(_jit->reglen, sizeof(jit_int32_t)); - _jit->values = calloc(_jit->reglen, sizeof(jit_value_t)); + _jitc->spill = calloc(_jitc->reglen, sizeof(jit_node_t*)); + _jitc->gen = calloc(_jitc->reglen, sizeof(jit_int32_t)); + _jitc->values = calloc(_jitc->reglen, sizeof(jit_value_t)); - _jit->patches.ptr = calloc(_jit->patches.length = 1024, + _jitc->patches.ptr = calloc(_jitc->patches.length = 1024, sizeof(jit_patch_t)); - _jit->functions.ptr = calloc(_jit->functions.length = 16, + _jitc->functions.ptr = calloc(_jitc->functions.length = 16, sizeof(jit_function_t)); - _jit->pool.ptr = calloc(_jit->pool.length = 16, + _jitc->pool.ptr = calloc(_jitc->pool.length = 16, sizeof(jit_node_t*)); - _jit->blocks.ptr = calloc(_jit->blocks.length = 16, + _jitc->blocks.ptr = calloc(_jitc->blocks.length = 16, sizeof(jit_block_t)); #if __arm__ && DISASSEMBLER - _jit->data_info.ptr = calloc(_jit->data_info.length = 1024, + _jitc->data_info.ptr = calloc(_jitc->data_info.length = 1024, sizeof(jit_data_info_t)); #endif /* allocate at most one extra note in case jit_name() is * never called, or called after adding at least one note */ _jit->note.length = 1; - _jit->note.size = sizeof(jit_note_t); + _jitc->note.size = sizeof(jit_note_t); return (_jit); } @@ -539,52 +540,54 @@ _jit_clear_state(jit_state_t *_jit) /* release memory not required at jit execution time and set * pointers to NULL to explicitly know they are released */ - _jit->head = _jit->tail = NULL; + _jitc->head = _jitc->tail = NULL; - mpz_clear(_jit->blockmask); + mpz_clear(_jitc->blockmask); - free(_jit->data.table); - _jit->data.table = NULL; - _jit->data.size = _jit->data.count = 0; + free(_jitc->data.table); + _jitc->data.table = NULL; + _jitc->data.size = _jitc->data.count = 0; - free(_jit->spill); - _jit->spill = NULL; - free(_jit->gen); - _jit->gen = NULL; - free(_jit->values); - _jit->values = NULL; + free(_jitc->spill); + _jitc->spill = NULL; + free(_jitc->gen); + _jitc->gen = NULL; + free(_jitc->values); + _jitc->values = NULL; - free(_jit->blocks.ptr); - _jit->blocks.ptr = NULL; + free(_jitc->blocks.ptr); + _jitc->blocks.ptr = NULL; - free(_jit->patches.ptr); - _jit->patches.ptr = NULL; - _jit->patches.offset = _jit->patches.length = 0; + free(_jitc->patches.ptr); + _jitc->patches.ptr = NULL; + _jitc->patches.offset = _jitc->patches.length = 0; - for (offset = 0; offset < _jit->functions.offset; offset++) { - function = _jit->functions.ptr + offset; + for (offset = 0; offset < _jitc->functions.offset; offset++) { + function = _jitc->functions.ptr + offset; free(function->regoff); function->regoff = NULL; } - free(_jit->functions.ptr); - _jit->functions.offset = _jit->functions.length = 0; - _jit->function = NULL; + free(_jitc->functions.ptr); + _jitc->functions.offset = _jitc->functions.length = 0; + _jitc->function = NULL; - for (offset = 0; offset < _jit->pool.length; offset++) - free(_jit->pool.ptr[offset]); - free(_jit->pool.ptr); - _jit->pool.ptr = NULL; - _jit->pool.offset = _jit->pool.length = 0; - _jit->list = NULL; + for (offset = 0; offset < _jitc->pool.length; offset++) + free(_jitc->pool.ptr[offset]); + free(_jitc->pool.ptr); + _jitc->pool.ptr = NULL; + _jitc->pool.offset = _jitc->pool.length = 0; + _jitc->list = NULL; - _jit->note.head = _jit->note.tail = - _jit->note.name = _jit->note.note = NULL; - _jit->note.base = NULL; + _jitc->note.head = _jitc->note.tail = + _jitc->note.name = _jitc->note.note = NULL; + _jitc->note.base = NULL; #if __arm__ && DISASSEMBLER - free(_jit->data_info.ptr); - _jit->data_info.ptr = NULL; + free(_jitc->data_info.ptr); + _jitc->data_info.ptr = NULL; #endif + + free(_jitc); } void @@ -598,21 +601,21 @@ _jit_destroy_state(jit_state_t *_jit) jit_node_t * _jit_new_node(jit_state_t *_jit, jit_code_t code) { - assert(!_jit->emit); + assert(!_jitc->emit); return (link_node(new_node(code))); } jit_node_t * _jit_new_node_no_link(jit_state_t *_jit, jit_code_t code) { - assert(!_jit->emit); + assert(!_jitc->emit); return (new_node(code)); } void _jit_link_node(jit_state_t *_jit, jit_node_t *node) { - assert(!_jit->emit); + assert(!_jitc->emit); link_node(node); } @@ -621,7 +624,7 @@ _jit_new_node_w(jit_state_t *_jit, jit_code_t code, jit_word_t u) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; return (link_node(node)); } @@ -631,7 +634,7 @@ _jit_new_node_p(jit_state_t *_jit, jit_code_t code, jit_pointer_t u) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.p = u; return (link_node(node)); } @@ -641,7 +644,7 @@ _jit_new_node_ww(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.w = v; return (link_node(node)); @@ -666,7 +669,7 @@ _jit_new_node_wf(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_float32_t v) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.f = v; return (link_node(node)); @@ -677,7 +680,7 @@ _jit_new_node_wd(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_float64_t v) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.d = v; return (link_node(node)); @@ -688,7 +691,7 @@ _jit_new_node_www(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v, jit_word_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.w = v; node->w.w = w; @@ -701,7 +704,7 @@ _jit_new_node_qww(jit_state_t *_jit, jit_code_t code, jit_word_t v, jit_word_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); assert(l != h); node->u.q.l = l; node->u.q.h = h; @@ -715,7 +718,7 @@ _jit_new_node_wwf(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v, jit_float32_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.w = v; node->w.f = w; @@ -727,7 +730,7 @@ _jit_new_node_wwd(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v, jit_float64_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.w = u; node->v.w = v; node->w.d = w; @@ -739,7 +742,7 @@ _jit_new_node_pww(jit_state_t *_jit, jit_code_t code, jit_pointer_t u, jit_word_t v, jit_word_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.p = u; node->v.w = v; node->w.w = w; @@ -751,7 +754,7 @@ _jit_new_node_pwf(jit_state_t *_jit, jit_code_t code, jit_pointer_t u, jit_word_t v, jit_float32_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.p = u; node->v.w = v; node->w.f = w; @@ -763,7 +766,7 @@ _jit_new_node_pwd(jit_state_t *_jit, jit_code_t code, jit_pointer_t u, jit_word_t v, jit_float64_t w) { jit_node_t *node = new_node(code); - assert(!_jit->emit); + assert(!_jitc->emit); node->u.p = u; node->v.w = v; node->w.d = w; @@ -775,7 +778,7 @@ _jit_label(jit_state_t *_jit) { jit_node_t *node; - if (!(node = _jit->tail) || node->code != jit_code_label) { + if (!(node = _jitc->tail) || node->code != jit_code_label) { node = jit_forward(); jit_link(node); } @@ -798,32 +801,32 @@ _jit_link(jit_state_t *_jit, jit_node_t *node) node->code == jit_code_prolog || node->code == jit_code_epilog) && !node->next); jit_link_node(node); - if (_jit->blocks.offset >= _jit->blocks.length) { + if (_jitc->blocks.offset >= _jitc->blocks.length) { jit_word_t length; - length = _jit->blocks.length + 16; - block = realloc(_jit->blocks.ptr, length * sizeof(jit_block_t)); - memset(block + _jit->blocks.length, 0, 16 * sizeof(jit_block_t)); - _jit->blocks.ptr = block; - _jit->blocks.length = length; + length = _jitc->blocks.length + 16; + block = realloc(_jitc->blocks.ptr, length * sizeof(jit_block_t)); + memset(block + _jitc->blocks.length, 0, 16 * sizeof(jit_block_t)); + _jitc->blocks.ptr = block; + _jitc->blocks.length = length; } - block = _jit->blocks.ptr + _jit->blocks.offset; + block = _jitc->blocks.ptr + _jitc->blocks.offset; block->label = node; - node->v.w = _jit->blocks.offset; + node->v.w = _jitc->blocks.offset; jit_regset_new(block->reglive); jit_regset_new(block->regmask); - ++_jit->blocks.offset; + ++_jitc->blocks.offset; } void _jit_prepare(jit_state_t *_jit) { - assert(_jit->function); - _jit->function->call.call = jit_call_default; - _jit->function->call.argi = - _jit->function->call.argf = - _jit->function->call.size = 0; - _jit->prepare = 1; + assert(_jitc->function); + _jitc->function->call.call = jit_call_default; + _jitc->function->call.argi = + _jitc->function->call.argf = + _jitc->function->call.size = 0; + _jitc->prepare = 1; } /* If declaring a jit function as varargs, in most backends it does @@ -839,13 +842,13 @@ _jit_prepare(jit_state_t *_jit) void _jit_ellipsis(jit_state_t *_jit) { - if (_jit->prepare) { - assert(!_jit->function->call.call & jit_call_varargs); - _jit->function->call.call |= jit_call_varargs; + if (_jitc->prepare) { + assert(!_jitc->function->call.call & jit_call_varargs); + _jitc->function->call.call |= jit_call_varargs; } else { - assert(!_jit->function->self.call & jit_call_varargs); - _jit->function->self.call |= jit_call_varargs; + assert(!_jitc->function->self.call & jit_call_varargs); + _jitc->function->self.call |= jit_call_varargs; } } @@ -854,7 +857,7 @@ _jit_patch(jit_state_t* _jit, jit_node_t *instr) { jit_node_t *label; - if (!(label = _jit->tail) || label->code != jit_code_label) + if (!(label = _jitc->tail) || label->code != jit_code_label) label = jit_label(); jit_patch_at(instr, label); } @@ -1113,15 +1116,15 @@ _jit_optimize(jit_state_t *_jit) jit_block_t *block; jit_word_t offset; - _jit->function = NULL; + _jitc->function = NULL; thread_jumps(); sequential_labels(); /* create initial mapping of live register values * at the start of a basic block */ - for (offset = 0; offset < _jit->blocks.offset; offset++) { - block = _jit->blocks.ptr + offset; + for (offset = 0; offset < _jitc->blocks.offset; offset++) { + block = _jitc->blocks.ptr + offset; if (!block->label) continue; if (block->label->code != jit_code_epilog) @@ -1130,13 +1133,13 @@ _jit_optimize(jit_state_t *_jit) /* call jit_update resolving undefined values in reverse * order so that sequential code would find most data already * resolved when reaching the start of a new basic block */ - for (offset = _jit->blocks.offset - 1; offset >= 0; offset--) { - block = _jit->blocks.ptr + offset; + for (offset = _jitc->blocks.offset - 1; offset >= 0; offset--) { + block = _jitc->blocks.ptr + offset; if (!block->label) continue; if (block->label->code != jit_code_epilog) { - jit_regset_set(_jit->regmask, block->regmask); - jit_update(block->label->next, &block->reglive, &_jit->regmask); + jit_regset_set(_jitc->regmask, block->regmask); + jit_update(block->label->next, &block->reglive, &_jitc->regmask); } } @@ -1147,7 +1150,7 @@ _jit_optimize(jit_state_t *_jit) * and is required to do a simple redundant_store removal * on jit_beqi below */ jump = 1; - for (node = _jit->head; node; node = node->next) { + for (node = _jitc->head; node; node = node->next) { switch (node->code) { case jit_code_label: if (!jump) @@ -1165,13 +1168,13 @@ _jit_optimize(jit_state_t *_jit) } } - for (node = _jit->head; node; node = node->next) { + for (node = _jitc->head; node; node = node->next) { switch (node->code) { case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; break; case jit_code_epilog: - _jit->function = NULL; + _jitc->function = NULL; break; case jit_code_beqi: redundant_store(node, 1); @@ -1199,14 +1202,14 @@ _jit_optimize(jit_state_t *_jit) node->flag |= jit_flag_node | jit_flag_data; } #endif - if (_jit->function) { + if (_jitc->function) { if ((mask & (jit_cc_a0_reg|jit_cc_a0_chg)) == (jit_cc_a0_reg|jit_cc_a0_chg)) - jit_regset_setbit(_jit->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(_jit->function->regset, + jit_regset_setbit(_jitc->function->regset, jit_regno(node->v.w)); } break; @@ -1214,26 +1217,26 @@ _jit_optimize(jit_state_t *_jit) } /* ensure it is aligned */ - _jit->data.offset = (_jit->data.offset + 7) & -8; + _jitc->data.offset = (_jitc->data.offset + 7) & -8; /* create read only data buffer */ - _jit->data.length = (_jit->data.offset + + _jit->data.length = (_jitc->data.offset + /* reserve space for annotations */ - _jit->note.size + 4095) & -4096; + _jitc->note.size + 4095) & -4096; ptr = mmap(NULL, _jit->data.length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); assert(ptr != MAP_FAILED); - memcpy(ptr, _jit->data.ptr, _jit->data.offset); + memcpy(ptr, _jit->data.ptr, _jitc->data.offset); free(_jit->data.ptr); _jit->data.ptr = ptr; /* to be filled with note contents once offsets are known */ - _jit->note.base = ptr + _jit->data.offset; - memset(_jit->note.base, 0, _jit->data.length - _jit->data.offset); + _jitc->note.base = ptr + _jitc->data.offset; + memset(_jitc->note.base, 0, _jit->data.length - _jitc->data.offset); - for (offset = 0; offset < _jit->data.size; offset++) { - for (node = _jit->data.table[offset]; node; node = node->next) { + for (offset = 0; offset < _jitc->data.size; offset++) { + for (node = _jitc->data.table[offset]; node; node = node->next) { node->flag |= jit_flag_patch; node->u.w = (jit_word_t)(_jit->data.ptr + node->u.w); } @@ -1249,35 +1252,35 @@ _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 = _jit->blocks.ptr + node->v.w; - jit_regset_set(_jit->reglive, block->reglive); + block = _jitc->blocks.ptr + node->v.w; + 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(_jit->reglive, value); + jit_regset_setbit(_jitc->reglive, value); } case jit_code_calli: - for (value = 0; value < _jit->reglen; value++) { + 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(_jit->reglive, value); + jit_regset_setbit(_jitc->reglive, value); else if (!(spec & jit_class_sav)) - jit_regset_clrbit(_jit->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(_jit->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(_jit->reglive, _R1); + jit_regset_setbit(_jitc->reglive, _R1); # endif #endif #if defined(JIT_FRET) - jit_regset_setbit(_jit->reglive, JIT_FRET); + jit_regset_setbit(_jitc->reglive, JIT_FRET); #endif break; default: @@ -1286,49 +1289,49 @@ _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(_jit->reglive, node->u.q.l); - jit_regset_setbit(_jit->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(_jit->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(_jit->reglive, node->u.q.h); - jit_regset_setbit(_jit->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(_jit->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(_jit->reglive, node->u.w); - jit_regset_setbit(_jit->regmask, node->u.w); + jit_regset_clrbit(_jitc->reglive, node->u.w); + jit_regset_setbit(_jitc->regmask, node->u.w); } else - jit_regset_setbit(_jit->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(_jit->reglive, node->v.w); - jit_regset_setbit(_jit->regmask, node->v.w); + jit_regset_clrbit(_jitc->reglive, node->v.w); + jit_regset_setbit(_jitc->regmask, node->v.w); } else - jit_regset_setbit(_jit->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(_jit->reglive, node->w.w); - if (jit_regset_set_p(_jit->regmask)) { - mpz_set_ui(_jit->blockmask, 0); - jit_update(node->next, &_jit->reglive, &_jit->regmask); - if (jit_regset_set_p(_jit->regmask)) { + jit_regset_setbit(_jitc->reglive, node->w.w); + if (jit_regset_set_p(_jitc->regmask)) { + mpz_set_ui(_jitc->blockmask, 0); + jit_update(node->next, &_jitc->reglive, &_jitc->regmask); + if (jit_regset_set_p(_jitc->regmask)) { /* any unresolved live state is considered as live */ - jit_regset_ior(_jit->reglive, _jit->reglive, _jit->regmask); - jit_regset_set_ui(_jit->regmask, 0); + jit_regset_ior(_jitc->reglive, _jitc->reglive, _jitc->regmask); + jit_regset_set_ui(_jitc->regmask, 0); } } break; @@ -1340,16 +1343,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(_jit->regarg, jit_regno(node->u.q.l)); - jit_regset_setbit(_jit->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(_jit->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(_jit->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(_jit->regarg, jit_regno(node->w.w)); + jit_regset_setbit(_jitc->regarg, jit_regno(node->w.w)); } void @@ -1357,16 +1360,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(_jit->regarg, jit_regno(node->u.q.l)); - jit_regset_clrbit(_jit->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(_jit->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(_jit->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(_jit->regarg, jit_regno(node->w.w)); + jit_regset_clrbit(_jitc->regarg, jit_regno(node->w.w)); } jit_pointer_t @@ -1378,32 +1381,32 @@ _jit_emit(jit_state_t *_jit) size_t length; int result; - if (_jit->function) + if (_jitc->function) jit_epilog(); jit_optimize(); /* Heuristic to guess code buffer size */ mult = 4; - _jit->emit = 1; + _jitc->emit = 1; - _jit->code.length = _jit->pool.length * 1024 * mult; + _jit->code.length = _jitc->pool.length * 1024 * mult; _jit->code.ptr = mmap(NULL, _jit->code.length, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); assert(_jit->code.ptr != MAP_FAILED); - _jit->code.end = _jit->code.ptr + _jit->code.length - 64; + _jitc->code.end = _jit->code.ptr + _jit->code.length - 64; _jit->pc.uc = _jit->code.ptr; for (;;) { if ((code = emit_code()) == NULL) { - for (node = _jit->head; node; node = node->next) { + for (node = _jitc->head; node; node = node->next) { if (node->code == jit_code_label && node->link) node->flag &= ~jit_flag_patch; } ++mult; - length = _jit->pool.length * 1024 * mult; + length = _jitc->pool.length * 1024 * mult; #if !HAVE_MREMAP munmap(_jit->code.ptr, _jit->code.length); @@ -1420,15 +1423,15 @@ _jit_emit(jit_state_t *_jit) assert(_jit->code.ptr != MAP_FAILED); _jit->code.length = length; - _jit->code.end = _jit->code.ptr + _jit->code.length - 64; + _jitc->code.end = _jit->code.ptr + _jit->code.length - 64; _jit->pc.uc = _jit->code.ptr; - _jit->patches.offset = 0; + _jitc->patches.offset = 0; } else break; } - _jit->done = 1; + _jitc->done = 1; jit_annotate(); result = mprotect(_jit->data.ptr, _jit->data.length, PROT_READ); @@ -1454,7 +1457,7 @@ _jit_setup(jit_state_t *_jit, jit_block_t *block) unsigned long value; jump = 0; - jit_regset_set_ui(regmask, (1LL << _jit->reglen) - 1); + jit_regset_set_ui(regmask, (1LL << _jitc->reglen) - 1); for (node = block->label->next; node; node = node->next) { switch (node->code) { case jit_code_label: case jit_code_prolog: @@ -1537,10 +1540,10 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, break; switch (node->code) { case jit_code_label: - block = _jit->blocks.ptr + node->v.w; - if (mpz_tstbit(_jit->blockmask, node->v.w)) + block = _jitc->blocks.ptr + node->v.w; + if (mpz_tstbit(_jitc->blockmask, node->v.w)) return; - mpz_setbit(_jit->blockmask, node->v.w); + mpz_setbit(_jitc->blockmask, node->v.w); jit_regset_and(ztmp, *mask, block->reglive); if (jit_regset_set_p(ztmp)) { jit_regset_ior(*live, *live, ztmp); @@ -1562,25 +1565,25 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, case jit_code_calli: #if defined(JIT_RET) if (jit_regset_tstbit(*mask, JIT_RET)) { - jit_regset_setbit(_jit->reglive, 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(_jit->reglive, _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(_jit->reglive, JIT_FRET); + jit_regset_setbit(_jitc->reglive, JIT_FRET); jit_regset_clrbit(*mask, JIT_FRET); } #endif - for (value = 0; value < _jit->reglen; ++value) { + for (value = 0; value < _jitc->reglen; ++value) { value = jit_regset_scan1(*mask, value); - if (value >= _jit->reglen) + if (value >= _jitc->reglen) break; spec = jit_class(_rvs[value].spec); if (!(spec & jit_class_sav)) @@ -1642,10 +1645,10 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, node = label; goto restart; } - block = _jit->blocks.ptr + label->v.w; - if (mpz_tstbit(_jit->blockmask, label->v.w)) + block = _jitc->blocks.ptr + label->v.w; + if (mpz_tstbit(_jitc->blockmask, label->v.w)) continue; - mpz_setbit(_jit->blockmask, label->v.w); + mpz_setbit(_jitc->blockmask, label->v.w); jit_regset_and(ztmp, *mask, block->reglive); if (jit_regset_set_p(ztmp)) { jit_regset_ior(*live, *live, ztmp); @@ -1684,7 +1687,7 @@ _thread_jumps(jit_state_t *_jit) jit_node_t *next; jit_int32_t mask; - for (prev = node = _jit->head; node;) { + for (prev = node = _jitc->head; node;) { next = node->next; switch (node->code) { case jit_code_jmpi: @@ -1722,7 +1725,7 @@ _sequential_labels(jit_state_t *_jit) jit_node_t *next; jit_node_t *node; - for (prev = node = _jit->head; node; node = next) { + for (prev = node = _jitc->head; node; node = next) { next = node->next; if (node->code == jit_code_label) { if (!node->flag) { @@ -2093,23 +2096,23 @@ _simplify_movr(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, regno = jit_regno(node->u.w); right = jit_regno(node->v.w); - value = _jit->values + regno; + value = _jitc->values + regno; if ((value->kind == jit_kind_register && jit_regno(value->base.q.l) == right && - value->base.q.h == _jit->gen[right]) || - (value->kind == kind && _jit->values[right].kind == kind && - memcmp(&value->base.w, &_jit->values[right].base.w, size) == 0)) { + value->base.q.h == _jitc->gen[right]) || + (value->kind == kind && _jitc->values[right].kind == kind && + memcmp(&value->base.w, &_jitc->values[right].base.w, size) == 0)) { del_node(prev, node); return (1); } - if (_jit->values[right].kind == jit_kind_word) - memcpy(value, _jit->values + right, sizeof(jit_value_t)); + if (_jitc->values[right].kind == jit_kind_word) + memcpy(value, _jitc->values + right, sizeof(jit_value_t)); else { value->kind = jit_kind_register; value->base.q.l = right; - value->base.q.h = _jit->gen[regno]; + value->base.q.h = _jitc->gen[regno]; } - ++_jit->gen[regno]; + ++_jitc->gen[regno]; return (0); } @@ -2124,11 +2127,11 @@ _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, jit_int32_t offset; regno = jit_regno(node->u.w); - value = _jit->values + regno; + value = _jitc->values + regno; if (node->flag & jit_flag_node) { /* set to undefined if value will be patched */ value->kind = 0; - ++_jit->gen[regno]; + ++_jitc->gen[regno]; return (0); } if (value->kind == kind) { @@ -2141,9 +2144,9 @@ _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, spec &= jit_class_gpr; else spec &= (jit_class_xpr | jit_class_fpr); - for (offset = 0; offset < _jit->reglen; offset++) { - if (_jit->values[offset].kind == kind && - memcmp(&node->v.w, &_jit->values[offset].base.w, size) == 0 && + for (offset = 0; offset < _jitc->reglen; offset++) { + if (_jitc->values[offset].kind == kind && + memcmp(&node->v.w, &_jitc->values[offset].base.w, size) == 0 && (jit_class(_rvs[offset].spec) & spec) == spec) { if (kind == jit_kind_word) node->code = jit_code_movr; @@ -2152,15 +2155,15 @@ _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, else node->code = jit_code_movr_d; node->v.w = offset; - memcpy(value, _jit->values + offset, sizeof(jit_value_t)); - ++_jit->gen[regno]; + memcpy(value, _jitc->values + offset, sizeof(jit_value_t)); + ++_jitc->gen[regno]; return (0); } } } value->kind = kind; memcpy(&value->base.w, &node->v.w, size); - ++_jit->gen[regno]; + ++_jitc->gen[regno]; return (0); } @@ -2177,9 +2180,9 @@ _simplify_ldxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) regno = jit_regno(node->u.w); right = jit_regno(node->v.w); - value = _jit->values + regno; + value = _jitc->values + regno; if (value->kind == jit_kind_code && value->code == node->code && - value->base.q.l == right && value->base.q.h == _jit->gen[right] && + value->base.q.l == right && value->base.q.h == _jitc->gen[right] && node->w.w == value->disp.w) { del_node(prev, node); return (1); @@ -2187,9 +2190,9 @@ _simplify_ldxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) value->kind = jit_kind_code; value->code = node->code; value->base.q.l = right; - value->base.q.h = _jit->gen[right]; + value->base.q.h = _jitc->gen[right]; value->disp.w = node->w.w; - ++_jit->gen[regno]; + ++_jitc->gen[regno]; return (0); } @@ -2204,21 +2207,21 @@ _simplify_stxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) regno = jit_regno(node->w.w); right = jit_regno(node->v.w); - value = _jit->values + regno; + value = _jitc->values + regno; /* check for redundant store after load */ if (value->kind == jit_kind_code && value->code == node->code && - value->base.q.l == right && value->base.q.h == _jit->gen[right] && + value->base.q.l == right && value->base.q.h == _jitc->gen[right] && node->w.w == value->disp.w) { del_node(prev, node); return (1); } /* assume anything can alias, and invalidate tracked values */ - for (offset = 0; offset < _jit->reglen; offset++) { - if (_jit->values[offset].kind == jit_kind_code) { - _jit->values[offset].kind = 0; - ++_jit->gen[offset]; + for (offset = 0; offset < _jitc->reglen; offset++) { + if (_jitc->values[offset].kind == jit_kind_code) { + _jitc->values[offset].kind = 0; + ++_jitc->gen[offset]; } } @@ -2239,7 +2242,7 @@ _simplify_stxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node) value->kind = jit_kind_code; value->code = node->code; value->base.q.l = right; - value->base.q.h = _jit->gen[right]; + value->base.q.h = _jitc->gen[right]; value->disp.w = node->u.w; } @@ -2255,11 +2258,11 @@ _simplify_spill(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno) jit_node_t *save; jit_node_t *temp; - if ((temp = _jit->spill[regno]) && (save = temp->next) != node) { + if ((temp = _jitc->spill[regno]) && (save = temp->next) != node) { temp->next = save->next; save->next = node->next; node->next = save; - _jit->spill[regno] = node; + _jitc->spill[regno] = node; } } @@ -2277,16 +2280,16 @@ _simplify(jit_state_t *_jit) jit_int32_t regno; jit_int32_t offset; - for (prev = NULL, node = _jit->head; node; prev = node, node = next) { + for (prev = NULL, node = _jitc->head; node; prev = node, node = next) { next = node->next; switch (node->code) { case jit_code_label: case jit_code_prolog: reset: - memset(_jit->gen, 0, sizeof(jit_int32_t) * _jit->reglen); - memset(_jit->values, 0, sizeof(jit_value_t) * _jit->reglen); + memset(_jitc->gen, 0, sizeof(jit_int32_t) * _jitc->reglen); + memset(_jitc->values, 0, sizeof(jit_value_t) * _jitc->reglen); break; case jit_code_save: - _jit->spill[jit_regno(node->u.w)] = prev; + _jitc->spill[jit_regno(node->u.w)] = prev; break; case jit_code_load: regno = jit_regno(node->u.w); @@ -2298,11 +2301,11 @@ _simplify(jit_state_t *_jit) * already holding */ patch_register(node->link->next, node, jit_regno_patch|regno, regno); - del_node(_jit->spill[regno], node->link); + del_node(_jitc->spill[regno], node->link); del_node(prev, node); node = prev; } - _jit->spill[regno] = NULL; + _jitc->spill[regno] = NULL; break; case jit_code_movr: regno = jit_regno(node->u.w); @@ -2357,10 +2360,10 @@ _simplify(jit_state_t *_jit) simplify_spill(node = prev, regno); break; case jit_code_callr: case jit_code_calli: - for (offset = 0; offset < _jit->reglen; offset++) { + for (offset = 0; offset < _jitc->reglen; offset++) { if (!(jit_class(_rvs[offset].spec) & jit_class_sav)) { - _jit->values[offset].kind = 0; - ++_jit->gen[offset]; + _jitc->values[offset].kind = 0; + ++_jitc->gen[offset]; } } break; @@ -2373,22 +2376,22 @@ _simplify(jit_state_t *_jit) if (info & jit_cc_a0_chg) { if (info & jit_cc_a0_rlh) { regno = jit_regno(node->u.q.l); - _jit->values[regno].kind = 0; - ++_jit->gen[regno]; + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; regno = jit_regno(node->u.q.h); - _jit->values[regno].kind = 0; - ++_jit->gen[regno]; + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; } else { regno = jit_regno(node->u.w); - _jit->values[regno].kind = 0; - ++_jit->gen[regno]; + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; } } if (info & jit_cc_a1_chg) { regno = jit_regno(node->v.w); - _jit->values[regno].kind = 0; - ++_jit->gen[regno]; + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; } break; } @@ -2437,11 +2440,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(_jit->reglive, regno)) { - mpz_set_ui(_jit->blockmask, 0); - jit_regset_setbit(_jit->regmask, regno); - jit_update(node->next, &_jit->reglive, &_jit->regmask); - if (!jit_regset_tstbit(_jit->reglive, regno) && + if (!jit_regset_tstbit(_jitc->reglive, regno)) { + mpz_set_ui(_jitc->blockmask, 0); + jit_regset_setbit(_jitc->regmask, regno); + jit_update(node->next, &_jitc->reglive, &_jitc->regmask); + if (!jit_regset_tstbit(_jitc->reglive, regno) && register_change_p(node->next, node->link, regno) != jit_reg_change) return (0); } @@ -2460,10 +2463,10 @@ _patch_registers(jit_state_t *_jit) jit_int32_t regno; jit_int32_t value; - _jit->function = NULL; + _jitc->function = NULL; jit_reglive_setup(); - for (prev = NULL, node = _jit->head; node; node = next) { + for (prev = NULL, node = _jitc->head; node; node = next) { next = node->next; info = jit_classify(node->code); @@ -2482,15 +2485,15 @@ _patch_registers(jit_state_t *_jit) else { /* try to find a free register of the same class */ spec = jit_class(_rvs[regno].spec) & ~jit_class_arg; - for (value = 0; value < _jit->reglen; value++) { + for (value = 0; value < _jitc->reglen; value++) { if (value != regno && ((jit_class(_rvs[value].spec) & spec) & ~jit_class_arg) == spec && - !jit_regset_tstbit(_jit->regarg, value) && + !jit_regset_tstbit(_jitc->regarg, value) && !spill_reglive_p(node, value)) break; } - if (value < _jit->reglen) { + if (value < _jitc->reglen) { jit_regarg_clr(node, info); patch_register(node->next, node->link, jit_regno_patch|node->u.w, @@ -2498,7 +2501,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(_jit->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); @@ -2507,8 +2510,8 @@ _patch_registers(jit_state_t *_jit) else { /* failed to find a free register */ if (spec & jit_class_gpr) { - if (!_jit->function->regoff[regno]) - _jit->function->regoff[regno] = + if (!_jitc->function->regoff[regno]) + _jitc->function->regoff[regno] = jit_allocai(sizeof(jit_word_t)); #if __WORDSIZE == 32 node->code = jit_code_stxi_i; @@ -2518,11 +2521,11 @@ _patch_registers(jit_state_t *_jit) } else { node->code = jit_code_stxi_d; - if (!_jit->function->regoff[regno]) - _jit->function->regoff[regno] = + if (!_jitc->function->regoff[regno]) + _jitc->function->regoff[regno] = jit_allocai(sizeof(jit_float64_t)); } - node->u.w = _jit->function->regoff[regno]; + node->u.w = _jitc->function->regoff[regno]; node->v.w = JIT_FP; node->w.w = regno; node->link = NULL; @@ -2533,7 +2536,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(_jit->reglive, regno); + jit_regset_clrbit(_jitc->reglive, regno); del_node(prev, node); continue; } @@ -2549,14 +2552,14 @@ _patch_registers(jit_state_t *_jit) node->code = jit_code_ldxi_d; node->v.w = regno; node->v.w = JIT_FP; - node->w.w = _jit->function->regoff[regno]; + node->w.w = _jitc->function->regoff[regno]; node->link = NULL; break; case jit_code_prolog: - _jit->function = _jit->functions.ptr + node->w.w; + _jitc->function = _jitc->functions.ptr + node->w.w; break; case jit_code_epilog: - _jit->function = NULL; + _jitc->function = NULL; break; default: break;