[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 194/437: Rework to better describe what is used only dur
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 194/437: Rework to better describe what is used only during jit generation. |
|
Date: |
Mon, 2 Jul 2018 05:14:16 -0400 (EDT) |
wingo pushed a commit to branch lightning
in repository guile.
commit 9afca85921522076006a7e901b2a040849f7beb0
Author: pcpa <address@hidden>
Date: Wed Mar 6 16:49:26 2013 -0300
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 | 448 +++++++++++++--------------
lib/jit_disasm.c | 8 +-
lib/jit_mips-cpu.c | 138 ++++-----
lib/jit_mips.c | 266 ++++++++--------
lib/jit_note.c | 70 ++---
lib/jit_ppc-cpu.c | 16 +-
lib/jit_ppc.c | 316 +++++++++----------
lib/jit_print.c | 6 +-
lib/jit_sparc-cpu.c | 40 +--
lib/jit_sparc.c | 268 ++++++++---------
lib/jit_x86-cpu.c | 66 ++--
lib/jit_x86.c | 262 ++++++++--------
lib/lightning.c | 653 ++++++++++++++++++++--------------------
16 files changed, 1333 insertions(+), 1304 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index ecd84bd..87519db 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,18 @@
2013-03-06 Paulo Andrade <address@hidden>
+ * 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 <address@hidden>
+
* lib/lightning.c: Make data and code buffer readonly.
2013-02-20 Paulo Andrade <address@hidden>
diff --git a/include/lightning/jit_private.h b/include/lightning/jit_private.h
index 16a5330..314cf0f 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 499616d..d577679 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 2302286..4e589d0 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));
-
- _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->self.aoff = 0;
+ _jitc->function->self.call = jit_call_default;
+ _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t));
+
+ _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 6230c6e..52c071d 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 0774e97..18ee0d8 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 b646b3f..4372ae2 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));
-
- _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 = _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));
+
+ _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 284f02d..6b30a02 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 1685626..7d21e31 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 5dc8f6a..a71b355 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));
-
- _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->self.aoff = alloca_offset - 8;
+ _jitc->function->self.call = jit_call_default;
+ _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t));
+
+ _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 5cec55b..07b2209 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 960d0b0..8bb20d3 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 cc71698..ca09c2f 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));
-
- _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->self.aoff = -8;
+ _jitc->function->self.call = jit_call_default;
+ _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t));
+
+ _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 708c680..2565e19 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 f33448a..33441f8 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));
-
- _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->self.aoff = -8;
+ _jitc->function->self.call = jit_call_default;
+ _jitc->function->regoff = calloc(_jitc->reglen, sizeof(jit_int32_t));
+
+ _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 d069743..ea37aca 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;
- [Guile-commits] 424/437: Beginnings of build integration of lightning and guile, (continued)
- [Guile-commits] 424/437: Beginnings of build integration of lightning and guile, Andy Wingo, 2018/07/02
- [Guile-commits] 204/437: Add basic Itanium port infrastructure., Andy Wingo, 2018/07/02
- [Guile-commits] 425/437: Remove lightning pkg-config file., Andy Wingo, 2018/07/02
- [Guile-commits] 411/437: Correct issues with 32 bit big endian mips abis, Andy Wingo, 2018/07/02
- [Guile-commits] 233/437: Correct license to properly advertise LGPLv3 and not GPLv3., Andy Wingo, 2018/07/02
- [Guile-commits] 343/437: Implement new, typed, jit_htonr* interfaces, Andy Wingo, 2018/07/02
- [Guile-commits] 423/437: Finish removing get-jit-size, Andy Wingo, 2018/07/02
- [Guile-commits] 320/437: Do not fail gratuitously in jit_init_debug, Andy Wingo, 2018/07/02
- [Guile-commits] 288/437: Add note about jit_set_memory_functions call., Andy Wingo, 2018/07/02
- [Guile-commits] 419/437: Merge GNU lightning to libguile/lightning, Andy Wingo, 2018/07/02
- [Guile-commits] 194/437: Rework to better describe what is used only during jit generation.,
Andy Wingo <=
- [Guile-commits] 386/437: hppa: Add initial jit_va_ calls to hppa, Andy Wingo, 2018/07/02
- [Guile-commits] 25/437: upgrade to autoconf 2.60, Andy Wingo, 2018/07/02
- [Guile-commits] 182/437: Implement the qmul and qdiv instructions., Andy Wingo, 2018/07/02
- [Guile-commits] 321/437: x86: Correct not released temporary register, Andy Wingo, 2018/07/02
- [Guile-commits] 315/437: Add string representation of IR codes to -sz.c files, Andy Wingo, 2018/07/02
- [Guile-commits] 402/437: Correct wrong check for argument of value 2 in check/fib.tst., Andy Wingo, 2018/07/02
- [Guile-commits] 374/437: Add initial support to implement vararg jit functions, Andy Wingo, 2018/07/02
- [Guile-commits] 171/437: Add the new ccall test case to test interleaved C and jit function calls, Andy Wingo, 2018/07/02
- [Guile-commits] 51/437: switch to GPLv3, Andy Wingo, 2018/07/02
- [Guile-commits] 160/437: Correct bogus logic caused by wrong optimizations., Andy Wingo, 2018/07/02