static stakumilo_t
generate_push_pop (void)
{
static const char msg[] = "we got %i\n";
stakumilo_t result;
int arg;
int retval;
buffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (buffer == MAP_FAILED) {
perror("mmap");
exit(0);
}
result = (stakumilo_t)(jit_set_ip (buffer).ptr);
jit_prolog (1);
arg = jit_arg_i ();
jit_getarg_i (JIT_R1, arg);
/* Save R1 on the stack. */
jit_pushr_i (JIT_R1);
/* Save two other registers just for the sake of using the stack. */
jit_movi_i (JIT_R0, -1);
jit_movi_i (JIT_R2, -1);
jit_pushr_i (JIT_R0);
jit_pushr_i (JIT_R2);
/* most likely need stack aligned at 16 bytes, dummy push to force align */
jit_pushr_i (JIT_R2);
jit_movr_i (JIT_R0, JIT_R1);
jit_movi_p (JIT_R1, msg);
/* Invoke a function that may modify R1. */
jit_prepare (2);
jit_pusharg_i (JIT_R0);
jit_pusharg_p (JIT_R1);
(void)jit_finish (display_message);
/* dummy pop for the sake of calling function with 16 byte aligned stack */
jit_popr_i (JIT_R2);
/* Restore the dummy registers. */
jit_popr_i (JIT_R2);
jit_popr_i (JIT_R0);
/* Restore R1. */
jit_popr_i (JIT_R1);
jit_movr_i (JIT_RET, JIT_R1);
jit_ret ();
jit_flush_code (buffer, jit_get_ip ().ptr);
return result;
}
static int_return_int_t
generate_function_proxy (int_return_int_t func)
{
static jit_insn buffer[1024];
static jit_state _jit;
int_return_int_t result;
int arg;
result = (int_return_int_t)(jit_set_ip (buffer).ptr);
jit_prolog (1);
arg = jit_arg_i ();
jit_getarg_i (JIT_R1, arg);
/* Reset `JIT_RET'. */
jit_movi_i (JIT_RET, -1);
/* Invoke a FUNC. */
jit_prepare (1);
jit_pusharg_i (JIT_R1);
(void)jit_finish (func);
/* Copy the result of FUNC from `JIT_RET' into our own result register. */
jit_retval_i (JIT_RET);
jit_ret ();
jit_flush_code (buffer, jit_get_ip ().ptr);
return result;
}
static inline void JIT_visit(ASTNode *node, int regs[], int reg) {
switch(node->type) {
case AST_BINARY_OP: {
ASTBinaryOp *binary_op = (ASTBinaryOp*)node;
int a_reg = alloc_reg(regs);
JIT_visit(binary_op->lhs, regs, a_reg);
int b_reg = alloc_reg(regs);
JIT_visit(binary_op->rhs, regs, b_reg);
switch(binary_op->op) {
case '+': jit_addr_i(reg, a_reg, b_reg); break;
case '-': jit_subr_i(reg, a_reg, b_reg); break;
case '*': jit_mulr_i(reg, a_reg, b_reg); break;
case '/': jit_divr_i(reg, a_reg, b_reg); break;
}
free_reg(regs, a_reg);
free_reg(regs, b_reg);
break;
}
case AST_INT: {
jit_movi_i(reg, ((ASTInt*)node)->value);
break;
}
}
}
int main()
{
pifi nfibs;
int in; /* offset of the argument */
jit_insn *ref; /* to patch the forward reference */
jit_insn *mref; /* ref of move to backpatch */
jit_insn *tp; /* location to patch */
codeBuffer = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (codeBuffer == MAP_FAILED) {
perror("mmap");
exit(0);
}
nfibs = (pifi) (jit_set_ip(codeBuffer).iptr);
jit_prolog (1);
in = jit_arg_ui ();
jit_getarg_ui(JIT_V0, in); /* V0 = n */
mref= jit_movi_p(JIT_V2,jit_forward ()); /* Generate a dumb movi */
jit_jmpr(JIT_V2);
/* generate some dump filler that will never be executed!*/
jit_addi_ui(JIT_V0,JIT_V0,1);
jit_addi_ui(JIT_V0,JIT_V0,1);
jit_addi_ui(JIT_V0,JIT_V0,1);
jit_addi_ui(JIT_V0,JIT_V0,1);
tp = jit_get_label ();
ref = jit_blti_ui (jit_forward(), JIT_V0, 2);
jit_subi_ui (JIT_V1, JIT_V0, 1); /* V1 = n-1 */
jit_subi_ui (JIT_V2, JIT_V0, 2); /* V2 = n-2 */
jit_prepare (1);
jit_pusharg_ui(JIT_V1);
jit_finish(nfibs);
jit_retval(JIT_V1); /* V1 = nfibs(n-1) */
jit_prepare(1);
jit_pusharg_ui(JIT_V2);
jit_finish(nfibs);
jit_retval(JIT_V2); /* V2 = nfibs(n-2) */
jit_addi_ui(JIT_V1, JIT_V1, 1);
jit_addr_ui(JIT_RET, JIT_V1, JIT_V2); /* RET = V1 + V2 + 1 */
jit_ret();
jit_patch(ref); /* patch jump */
jit_movi_i(JIT_RET, 1); /* RET = 1 */
jit_ret();
jit_patch_movi(mref,tp); /* Ok. Do the back-patching */
/* call the generated code, passing 32 as an argument */
jit_flush_code(codeBuffer, jit_get_ip().ptr);
#ifdef LIGHTNING_DISASSEMBLE
disassemble(stderr, (char *)codeBuffer, jit_get_ip().ptr);
#endif
#ifndef LIGHTNING_CROSS
printf("nfibs(%d) = %d\n", 32, nfibs(32));
#endif
return 0;
}
static stakumilo_t
generate_push_pop (void)
{
static const char msg[] = "we got %i\n";
static char buffer[1024];
stakumilo_t result;
int arg;
result = (stakumilo_t)(jit_set_ip (buffer).ptr);
jit_prolog (1);
arg = jit_arg_i ();
jit_getarg_i (JIT_R1, arg);
/* Save R1 on the stack. */
jit_pushr_i (JIT_R1);
/* Save two other registers just for the sake of using the stack. */
jit_movi_i (JIT_R0, -1);
jit_movi_i (JIT_R2, -1);
jit_pushr_i (JIT_R0);
jit_pushr_i (JIT_R2);
jit_movr_i (JIT_R0, JIT_R1);
jit_movi_p (JIT_R1, msg);
/* Invoke a function that may modify R1. */
jit_prepare (2);
jit_pusharg_i (JIT_R0);
jit_pusharg_p (JIT_R1);
(void)jit_finish (display_message);
/* Restore the dummy registers. */
jit_popr_i (JIT_R2);
jit_popr_i (JIT_R0);
/* Restore R1. */
jit_popr_i (JIT_R1);
jit_movr_i (JIT_RET, JIT_R1);
jit_ret ();
jit_flush_code (buffer, jit_get_ip ().ptr);
return result;
}
int inst_realloc(Module *state, Token *type, array_t *params)
{
if(array_length(params) != 2)
die(state, "realloc requires 2 parameters.");
if(type) die(state, "Operation realloc does not take a type.");
jit_movi_i(JIT_R0, array_of(Token, params, 1)->value);
jit_prepare_i(2);
jit_pusharg_i(JIT_R0);
jit_pusharg_p(array_of(Token, params, 0)->value);
jit_finish(Allocator_realloc);
jit_retval(array_of(Token, params, 0)->value);
return 1;
}
/* This function does all of lexing, parsing, and picking a good
order of evaluation... Needless to say, this is not the best
possible design, but it avoids cluttering everything with globals. */
pifi
compile_rpn (char *expr)
{
struct stack_element stack[32];
int sp = 0;
int curr_tos = -1; /* stack element currently in R0 */
int spill_base, spill_sp;
pifi fn;
int ofs;
fn = (pifi) (jit_get_ip ().iptr);
jit_leaf (1);
ofs = jit_arg_i ();
spill_sp = spill_base = jit_allocai (32 * sizeof (int));
while (*expr)
{
int with_imm;
int imm;
int tok;
int src1, src2;
/* This is the lexer. */
switch (*expr)
{
case ' ': case '\t':
expr++;
continue;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
stack[sp].kind = IMM;
stack[sp++].imm = strtol (expr, &expr, 0);
continue;
case 'x':
expr++;
stack[sp++].kind = ARG;
continue;
case '~':
/* NOT. Implemented as a XOR with -1. */
stack[sp].kind = IMM;
stack[sp++].imm = ~0;
tok = '^';
break;
case '_':
/* Unary minus. Transform to 0 - X and go on.
Also used to enter negative constants (32_ = -32). */
expr++;
stack[sp] = stack[sp - 1];
/* Ensure CURR_TOS is correct. */
if (curr_tos == sp - 1)
curr_tos = sp;
stack[sp - 1].kind = IMM;
stack[sp - 1].imm = 0;
sp++;
tok = '-';
break;
case '+':
case '-':
case '*':
case '/':
case '%':
case '&':
case '|':
case '^':
case '=':
tok = *expr++;
break;
case '!':
/* Get != */
expr++;
assert (*expr == '=');
tok = NE;
break;
case '<':
/* Get <, <<, <= */
if (expr[1] == '=')
expr += 2, tok = LE;
else if (expr[1] == '<')
expr += 2, tok = LSH;
else
expr++, tok = '<';
break;
case '>':
/* Get >, >>, >>>, >= */
if (expr[1] == '=')
expr += 2, tok = GE;
else if (expr[1] == '>' && expr[2] == '>')
expr += 3, tok = RSHU;
else if (expr[1] == '>')
expr += 2, tok = RSH;
else
expr++, tok = '>';
break;
default:
abort ();
}
assert (sp >= 2);
/* Constant folding. */
if (stack[sp - 1].kind == IMM && stack[sp - 2].kind == IMM)
{
stack[sp - 2].imm =
fold (stack[sp - 2].imm, stack[sp - 1].imm, tok);
sp--;
continue;
}
/* If possible, ensure that the constant is the RHS, possibly
by changing TOK (if it is a comparison). */
if (stack[sp - 2].kind == IMM)
{
int swapped_operation = swap_op (tok);
if (swapped_operation)
{
tok = swapped_operation;
stack[sp - 2].kind = stack[sp - 1].kind;
stack[sp - 1].kind = IMM;
stack[sp - 1].imm = stack[sp - 2].imm;
/* Ensure CURR_TOS is correct. */
if (curr_tos == sp - 1)
curr_tos = sp - 2;
}
}
/* Get the second argument into a register, if not an immediate.
Also decide which argument will be prepared into JIT_R0 and
which will be prepared into JIT_V0. */
with_imm = 0;
src1 = JIT_R0;
src2 = JIT_V0;
switch (stack[sp - 1].kind)
{
case IMM:
/* RHS is an immediate, use an immediate instruction. */
with_imm = 1;
imm = stack[sp - 1].imm;
break;
case EXPR:
/* RHS is an expression, check if it is already in JIT_R0. */
if (curr_tos == sp - 1)
{
/* Invert the two sources. */
src1 = JIT_V0;
src2 = JIT_R0;
}
else
popr (JIT_V0, &spill_sp);
curr_tos = -1;
break;
case ARG:
jit_getarg_i (JIT_V0, ofs);
break;
}
/* Get the first argument into a register indicated by SRC1. */
switch (stack[sp - 2].kind)
{
case IMM:
/* LHS is an immediate, check if we must spill the top of stack. */
if (curr_tos != -1)
{
pushr (JIT_R0, &spill_sp);
curr_tos = -1;
}
jit_movi_i (src1, stack[sp - 2].imm);
break;
case EXPR:
/* LHS is an expression, check if it is already in JIT_R0. */
if (curr_tos != sp - 2)
{
popr (src1, &spill_sp);
curr_tos = -1;
}
else
assert (src1 == JIT_R0);
break;
case ARG:
if (curr_tos != -1)
{
pushr (JIT_R0, &spill_sp);
curr_tos = -1;
}
jit_getarg_i (src1, ofs);
break;
}
/* Set up the new stack entry, which is cached in R0. */
sp -= 2;
curr_tos = sp;
stack[sp++].kind = EXPR;
/* Perform the computation. */
if (with_imm)
gen_reg_imm (src1, imm, tok);
else
gen_reg_reg (src1, src2, tok);
}
assert (sp == 1);
switch (stack[0].kind)
{
case IMM:
jit_movi_i (JIT_RET, stack[0].imm);
break;
case EXPR:
assert (curr_tos == 0);
jit_movr_i (JIT_RET, JIT_R0);
break;
case ARG:
jit_getarg_i (JIT_V0, ofs);
break;
}
jit_ret ();
jit_flush_code ((char *) fn, jit_get_ip ().ptr);
#ifdef LIGHTNING_DISASSEMBLE
disassemble (stderr, (char *) fn, jit_get_ip ().ptr);
#endif
return fn;
}
