lightning.git - Portable just-in-time compiler library

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;

}