narayana
/
ravi
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

reformat code

Browse Source
pull/81/head
Dibyendu Majumdar 9 years ago
parent 1090ac63a3
commit 40c3f032d5
16 changed files with 538 additions and 462 deletions
Show Stats Download Patch File Download Diff File

29
include/ravi_gccjit.h
Unescape View File

@ -107,7 +107,7 @@ struct ravi_gcc_types_t {
gcc_jit_type *lua_IntegerT;
gcc_jit_type *plua_IntegerT;
gcc_jit_type *pplua_IntegerT;
//gcc_jit_type *clua_IntegerT;
// gcc_jit_type *clua_IntegerT;
gcc_jit_type *lua_UnsignedT;
gcc_jit_type *lua_KContextT;
@ -449,11 +449,11 @@ extern gcc_jit_rvalue *ravi_emit_get_upvals(ravi_function_def_t *def,
int offset);
// Get upval->v
extern gcc_jit_lvalue *ravi_emit_load_upval_v(ravi_function_def_t *def,
gcc_jit_rvalue *pupval);
gcc_jit_rvalue *pupval);
// Get upval->u.value
extern gcc_jit_lvalue *ravi_emit_load_upval_value(ravi_function_def_t *def,
gcc_jit_rvalue *pupval);
gcc_jit_rvalue *pupval);
extern void ravi_set_current_block(ravi_function_def_t *def,
gcc_jit_block *block);
@ -553,11 +553,9 @@ extern gcc_jit_rvalue *ravi_emit_comparison(ravi_function_def_t *def,
gcc_jit_rvalue *a,
gcc_jit_rvalue *b);
extern gcc_jit_lvalue* ravi_emit_tonumtype(ravi_function_def_t *def,
gcc_jit_rvalue *reg,
lua_typecode_t tt,
int pc);
extern gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def,
gcc_jit_rvalue *reg,
lua_typecode_t tt, int pc);
extern void ravi_emit_conditional_branch(ravi_function_def_t *def,
gcc_jit_rvalue *cond,
@ -619,7 +617,8 @@ extern void ravi_emit_CALL(ravi_function_def_t *def, int A, int B, int C,
extern void ravi_emit_GETTABUP(ravi_function_def_t *def, int A, int B, int C,
int pc);
extern void ravi_emit_SETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc);
extern void ravi_emit_SETTABUP(ravi_function_def_t *def, int A, int B, int C,
int pc);
extern void ravi_emit_SETUPVAL(ravi_function_def_t *def, int A, int B, int pc);
@ -748,7 +747,9 @@ extern void ravi_emit_MOVEAI(ravi_function_def_t *def, int A, int B, int pc);
extern void ravi_emit_MOVEAF(ravi_function_def_t *def, int A, int B, int pc);
extern void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B, int C, bool known_tt, lua_typecode_t tt, int pc);
extern void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B,
int C, bool known_tt, lua_typecode_t tt,
int pc);
extern void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
OpCode op, TMS tms, int pc);
@ -773,15 +774,15 @@ extern void ravi_debug_printf4(ravi_function_def_t *def, const char *str,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4);
extern gcc_jit_rvalue *ravi_int_constant(ravi_function_def_t *def, int value);
extern gcc_jit_rvalue *ravi_bool_constant(ravi_function_def_t *def, int value);
extern gcc_jit_rvalue *ravi_lua_Integer_constant(ravi_function_def_t *def, int value);
extern gcc_jit_rvalue *ravi_lua_Number_constant(ravi_function_def_t *def, double value);
extern gcc_jit_rvalue *ravi_lua_Integer_constant(ravi_function_def_t *def,
int value);
extern gcc_jit_rvalue *ravi_lua_Number_constant(ravi_function_def_t *def,
double value);
#ifdef __cplusplus
};

86
include/ravi_llvmcodegen.h
Unescape View File

@ -69,26 +69,24 @@ extern "C" {
namespace ravi {
enum LuaTypeCode {
LUA__TNIL = LUA_TNIL,
LUA__TBOOLEAN = LUA_TBOOLEAN,
LUA__TLIGHTUSERDATA = LUA_TLIGHTUSERDATA,
LUA__TNUMBER = LUA_TNUMBER,
LUA__TSTRING = ctb(LUA_TSTRING),
LUA__TTABLE = ctb(LUA_TTABLE),
LUA__TFUNCTION = ctb(LUA_TFUNCTION),
LUA__TUSERDATA = ctb(LUA_TUSERDATA),
LUA__TTHREAD = ctb(LUA_TTHREAD),
LUA__TLCL = ctb(LUA_TLCL),
LUA__TLCF = LUA_TLCF,
LUA__TCCL = ctb(LUA_TCCL),
LUA__TSHRSTR = ctb(LUA_TSHRSTR),
LUA__TLNGSTR = ctb(LUA_TLNGSTR),
LUA__TNUMFLT = LUA_TNUMFLT,
LUA__TNUMINT = LUA_TNUMINT
};
enum LuaTypeCode {
LUA__TNIL = LUA_TNIL,
LUA__TBOOLEAN = LUA_TBOOLEAN,
LUA__TLIGHTUSERDATA = LUA_TLIGHTUSERDATA,
LUA__TNUMBER = LUA_TNUMBER,
LUA__TSTRING = ctb(LUA_TSTRING),
LUA__TTABLE = ctb(LUA_TTABLE),
LUA__TFUNCTION = ctb(LUA_TFUNCTION),
LUA__TUSERDATA = ctb(LUA_TUSERDATA),
LUA__TTHREAD = ctb(LUA_TTHREAD),
LUA__TLCL = ctb(LUA_TLCL),
LUA__TLCF = LUA_TLCF,
LUA__TCCL = ctb(LUA_TCCL),
LUA__TSHRSTR = ctb(LUA_TSHRSTR),
LUA__TLNGSTR = ctb(LUA_TLNGSTR),
LUA__TNUMFLT = LUA_TNUMFLT,
LUA__TNUMINT = LUA_TNUMINT
};
// All Lua types are gathered here
struct LuaLLVMTypes {
@ -538,7 +536,7 @@ struct RaviFunctionDef {
// Obtain pointer to Proto->k
llvm::Value *proto_k;
// Load pointer to Proto->k; this does not change
// Load pointer to Proto->k; this does not change
llvm::Instruction *k_ptr;
// Load L->ci
@ -618,21 +616,24 @@ public:
llvm::Value *src);
// Test if value type is of specific Lua type
// Value_type should have been obtained by emit_load_type()
// Value_type should have been obtained by emit_load_type()
// The Lua typecode to check must be in lua_typecode
// The return value is a boolean type as a result of
// The return value is a boolean type as a result of
// integer comparison result which is i1 in LLVM
llvm::Value *emit_is_value_of_type(RaviFunctionDef *def, llvm::Value *value_type,
LuaTypeCode lua_typecode, const char *varname = "value.typeof");
llvm::Value *emit_is_value_of_type(RaviFunctionDef *def,
llvm::Value *value_type,
LuaTypeCode lua_typecode,
const char *varname = "value.typeof");
// Test if value type is NOT of specific Lua type
// Value_type should have been obtained by emit_load_type()
// Value_type should have been obtained by emit_load_type()
// The Lua typecode to check must be in lua_typecode
// The return value is a boolean type as a result of
// The return value is a boolean type as a result of
// integer comparison result which is i1 in LLVM
llvm::Value *emit_is_not_value_of_type(RaviFunctionDef *def, llvm::Value *value_type,
LuaTypeCode lua_typecode, const char *varname = "value.not.typeof");
llvm::Value *
emit_is_not_value_of_type(RaviFunctionDef *def, llvm::Value *value_type,
LuaTypeCode lua_typecode,
const char *varname = "value.not.typeof");
// emit code for (LClosure *)ci->func->value_.gc
llvm::Value *emit_gep_ci_func_value_gc_asLClosure(RaviFunctionDef *def);
@ -660,7 +661,8 @@ public:
llvm::Value *emit_gep_L_top(RaviFunctionDef *def);
// (int)(L->top - ra)
llvm::Value *emit_num_stack_elements(RaviFunctionDef *def, llvm::Value *L_top, llvm::Value *ra);
llvm::Value *emit_num_stack_elements(RaviFunctionDef *def, llvm::Value *L_top,
llvm::Value *ra);
// emit code to load the lua_Number value from register
llvm::Instruction *emit_load_reg_n(RaviFunctionDef *def, llvm::Value *ra);
@ -686,19 +688,19 @@ public:
void emit_store_reg_n(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
void emit_store_reg_n_withtype(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
llvm::Value *dest_ptr);
// emit code to store lua_Integer value into register
void emit_store_reg_i(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
void emit_store_reg_i_withtype(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
llvm::Value *dest_ptr);
// emit code to store bool value into register
void emit_store_reg_b(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
void emit_store_reg_b_withtype(RaviFunctionDef *def, llvm::Value *value,
llvm::Value *dest_ptr);
llvm::Value *dest_ptr);
// emit code to set the type in the register
void emit_store_type_(RaviFunctionDef *def, llvm::Value *value, int type);
@ -777,7 +779,8 @@ public:
void emit_LOADBOOL(RaviFunctionDef *def, int A, int B, int C, int j);
void emit_ARITH(RaviFunctionDef *def, int A, int B, int C, OpCode op, TMS tms);
void emit_ARITH(RaviFunctionDef *def, int A, int B, int C, OpCode op,
TMS tms);
void emit_MOD(RaviFunctionDef *def, int A, int B, int C);
@ -899,7 +902,8 @@ public:
// A, B, C must be operands of the OP_EQ/OP_LT/OP_LE instructions
// j must be the jump target (offset of the code to which we need to jump to)
// jA must be the A operand of the jump instruction
void emit_EQ(RaviFunctionDef *def, int A, int B, int C, int j, int jA, llvm::Constant *callee);
void emit_EQ(RaviFunctionDef *def, int A, int B, int C, int j, int jA,
llvm::Constant *callee);
// OP_TEST is followed by a OP_JMP instruction - both are handled
// together
@ -923,16 +927,18 @@ public:
void emit_GETTABLE_AI(RaviFunctionDef *def, int A, int B, int C);
void emit_SETTABLE_AF(RaviFunctionDef *def, int A, int B, int C, bool known_int);
void emit_SETTABLE_AF(RaviFunctionDef *def, int A, int B, int C,
bool known_int);
void emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int C, bool known_float);
void emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int C,
bool known_float);
void emit_MOVEAI(RaviFunctionDef *def, int A, int B);
void emit_MOVEAF(RaviFunctionDef *def, int A, int B);
void emit_TOARRAY(RaviFunctionDef *def, int A,
int array_type_expected, const char *errmsg);
void emit_TOARRAY(RaviFunctionDef *def, int A, int array_type_expected,
const char *errmsg);
private:
RaviJITStateImpl *jitState_;

185
src/ravi_gccarith2.c
Unescape View File

@ -24,8 +24,8 @@
#include <ravi_gccjit.h>
// OP_ADD, OP_SUB, OP_MUL and OP_DIV
void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
OpCode op, TMS tms, int pc) {
void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C, OpCode op,
TMS tms, int pc) {
// TValue *rb = RKB(i);
// TValue *rc = RKC(i);
@ -39,8 +39,12 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
//}
// else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_ADD)); }
gcc_jit_lvalue *nb = gcc_jit_function_new_local(def->jit_function, NULL, def->ravi->types->lua_NumberT, unique_name(def, "ARITH_nb", pc ));
gcc_jit_lvalue *nc = gcc_jit_function_new_local(def->jit_function, NULL, def->ravi->types->lua_NumberT, unique_name(def, "ARITH_nc", pc));
gcc_jit_lvalue *nb = gcc_jit_function_new_local(
def->jit_function, NULL, def->ravi->types->lua_NumberT,
unique_name(def, "ARITH_nb", pc));
gcc_jit_lvalue *nc = gcc_jit_function_new_local(
def->jit_function, NULL, def->ravi->types->lua_NumberT,
unique_name(def, "ARITH_nc", pc));
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
@ -50,28 +54,28 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
gcc_jit_lvalue *rb_type = ravi_emit_load_type(def, rb);
gcc_jit_lvalue *rc_type = ravi_emit_load_type(def, rc);
gcc_jit_block *float_op =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_float.op", pc));
gcc_jit_block *try_meta =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_try_meta", pc));
gcc_jit_block *done_block =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "done", pc));
gcc_jit_block *float_op = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_float.op", pc));
gcc_jit_block *try_meta = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_try_meta", pc));
gcc_jit_block *done_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "done", pc));
if (op != OP_DIV) {
gcc_jit_rvalue *cmp1 =
ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(rb_type), LUA__TNUMINT);
gcc_jit_rvalue *cmp2 =
ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(rc_type), LUA__TNUMINT);
gcc_jit_rvalue *andvalue = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT, cmp1, cmp2);
gcc_jit_rvalue *cmp1 = ravi_emit_is_value_of_type(
def, gcc_jit_lvalue_as_rvalue(rb_type), LUA__TNUMINT);
gcc_jit_rvalue *cmp2 = ravi_emit_is_value_of_type(
def, gcc_jit_lvalue_as_rvalue(rc_type), LUA__TNUMINT);
gcc_jit_rvalue *andvalue = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT, cmp1, cmp2);
// Check if both RB and RC are integers
gcc_jit_block *then_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_if_integer", pc));
gcc_jit_block *else_block =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_if_not_integer", pc));
def->jit_function, unique_name(def, "ARITH_if_integer", pc));
gcc_jit_block *else_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_if_not_integer", pc));
ravi_emit_conditional_branch(def, andvalue, then_block, else_block);
ravi_set_current_block(def, then_block);
@ -81,23 +85,26 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
gcc_jit_rvalue *result = NULL;
switch (op) {
case OP_ADD:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_PLUS,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_SUB:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_MUL:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_MULT,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
default:
lua_assert(0);
case OP_ADD:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_PLUS,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_SUB:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_MUL:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_MULT,
def->ravi->types->lua_IntegerT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
default:
lua_assert(0);
}
ravi_emit_store_reg_i_withtype(def, result, ra);
@ -109,15 +116,15 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
}
// Is RB a float?
gcc_jit_rvalue *cmp1 =
ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(rb_type), LUA__TNUMFLT);
gcc_jit_rvalue *cmp1 = ravi_emit_is_value_of_type(
def, gcc_jit_lvalue_as_rvalue(rb_type), LUA__TNUMFLT);
gcc_jit_block *convert_rb =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_convert_rb", pc));
gcc_jit_block *test_rc =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_test_rc", pc));
gcc_jit_block *load_rb =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_load_rb", pc));
gcc_jit_block *convert_rb = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_convert_rb", pc));
gcc_jit_block *test_rc = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_test_rc", pc));
gcc_jit_block *load_rb = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_load_rb", pc));
// If RB is floating then load RB, else convert RB
ravi_emit_conditional_branch(def, cmp1, load_rb, convert_rb);
@ -127,9 +134,10 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
// Call luaV_tonumber_()
gcc_jit_rvalue *rb_isnum =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rb, gcc_jit_lvalue_get_address(nb, NULL));
cmp1 =
ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rb_isnum, ravi_int_constant(def, 1));
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rb,
gcc_jit_lvalue_get_address(nb, NULL));
cmp1 = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rb_isnum,
ravi_int_constant(def, 1));
// If not number then go to meta block
// Else proceed to test RC
@ -139,19 +147,21 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
// Copy RB to local nb
gcc_jit_lvalue *src = ravi_emit_load_reg_n(def, rb);
gcc_jit_block_add_assignment(def->current_block, NULL, nb, gcc_jit_lvalue_as_rvalue(src));
gcc_jit_block_add_assignment(def->current_block, NULL, nb,
gcc_jit_lvalue_as_rvalue(src));
ravi_emit_branch(def, test_rc);
ravi_set_current_block(def, test_rc);
// Is RC a float?
cmp1 = ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(rc_type), LUA__TNUMFLT);
cmp1 = ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(rc_type),
LUA__TNUMFLT);
gcc_jit_block *convert_rc =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_convert_rc", pc));
gcc_jit_block *load_rc =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "ARITH_load_rc", pc));
gcc_jit_block *convert_rc = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_convert_rc", pc));
gcc_jit_block *load_rc = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "ARITH_load_rc", pc));
// If RC is float load RC
// else try to convert RC
@ -161,9 +171,10 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
// Call luaV_tonumber_()
gcc_jit_rvalue *rc_isnum =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rc, gcc_jit_lvalue_get_address(nc, NULL));
cmp1 =
ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rc_isnum, ravi_int_constant(def, 1));
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rc,
gcc_jit_lvalue_get_address(nc, NULL));
cmp1 = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rc_isnum,
ravi_int_constant(def, 1));
// If not number then go to meta block
// else both RB and RC float so go to op
@ -173,7 +184,8 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
// Copy RC to local;
src = ravi_emit_load_reg_n(def, rc);
gcc_jit_block_add_assignment(def->current_block, NULL, nc, gcc_jit_lvalue_as_rvalue(src));
gcc_jit_block_add_assignment(def->current_block, NULL, nc,
gcc_jit_lvalue_as_rvalue(src));
ravi_emit_branch(def, float_op);
@ -185,28 +197,32 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
gcc_jit_rvalue *result = NULL;
// Add and set RA
switch (op) {
case OP_ADD:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_PLUS,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_SUB:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_MUL:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_MULT,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_DIV:
result = gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_DIVIDE,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
default:
lua_assert(0);
case OP_ADD:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_PLUS,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_SUB:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_MINUS,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_MUL:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_MULT,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
case OP_DIV:
result = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_DIVIDE,
def->ravi->types->lua_NumberT, gcc_jit_lvalue_as_rvalue(lhs),
gcc_jit_lvalue_as_rvalue(rhs));
break;
default:
lua_assert(0);
}
ravi_emit_store_reg_n_withtype(def, result, ra);
@ -216,10 +232,11 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C,
// Neither integer nor float so try meta
ravi_set_current_block(def, try_meta);
gcc_jit_block_add_eval(def->current_block, NULL, ravi_function_call5_rvalue(def,
def->ravi->types->luaT_trybinTMT,
gcc_jit_param_as_rvalue(def->L),
rb, rc, ra, ravi_int_constant(def, tms)));
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call5_rvalue(def, def->ravi->types->luaT_trybinTMT,
gcc_jit_param_as_rvalue(def->L), rb, rc, ra,
ravi_int_constant(def, tms)));
ravi_emit_branch(def, done_block);
ravi_set_current_block(def, done_block);

3
src/ravi_gcccall.c
Unescape View File

@ -39,7 +39,8 @@ void ravi_emit_JMP(ravi_function_def_t *def, int A, int j, int pc) {
def->jit_function, unique_name(def, "OP_JMP", pc));
ravi_set_current_block(def, jmp_block);
}
//ravi_debug_printf2(def, "OP_JMP(%d) jmp to %d\n", ravi_int_constant(def, pc+1), ravi_int_constant(def, j+1));
// ravi_debug_printf2(def, "OP_JMP(%d) jmp to %d\n", ravi_int_constant(def,
// pc+1), ravi_int_constant(def, j+1));
// if (a > 0) luaF_close(L, ci->u.l.base + a - 1);
if (A > 0) {

126
src/ravi_gcccodegen.c
Unescape View File

@ -163,8 +163,9 @@ static bool create_function(ravi_gcc_codegen_t *codegen,
if (def->dump_asm) {
gcc_jit_context_set_bool_option(def->function_context,
GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, 1);
// gcc_jit_context_set_bool_option(def->function_context,
// GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE, 1);
// gcc_jit_context_set_bool_option(def->function_context,
// GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE,
// 1);
gcc_jit_context_set_bool_option(def->function_context,
GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE, 1);
}
@ -172,7 +173,8 @@ static bool create_function(ravi_gcc_codegen_t *codegen,
gcc_jit_context_set_int_option(def->function_context,
GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
def->opt_level);
gcc_jit_context_add_command_line_option(def->function_context, "-fno-strict-aliasing");
gcc_jit_context_add_command_line_option(def->function_context,
"-fno-strict-aliasing");
/* each function is given a unique name - as Lua functions are closures and do
* not really have names */
@ -679,10 +681,9 @@ static void link_block(ravi_function_def_t *def, int pc) {
}
// Now add the new block and make it current
ravi_set_current_block(def, block);
}
else if (def->current_block_terminated) {
} else if (def->current_block_terminated) {
gcc_jit_block *block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "LINK_BLOCK", pc));
def->jit_function, unique_name(def, "LINK_BLOCK", pc));
ravi_set_current_block(def, block);
}
}
@ -756,14 +757,14 @@ gcc_jit_rvalue *ravi_emit_get_upvals(ravi_function_def_t *def, int offset) {
// Get upval->v
gcc_jit_lvalue *ravi_emit_load_upval_v(ravi_function_def_t *def,
gcc_jit_rvalue *pupval) {
gcc_jit_rvalue *pupval) {
return gcc_jit_rvalue_dereference_field(pupval, NULL,
def->ravi->types->UpVal_v);
}
// Get upval->u.value
gcc_jit_lvalue *ravi_emit_load_upval_value(ravi_function_def_t *def,
gcc_jit_rvalue *pupval) {
gcc_jit_rvalue *pupval) {
gcc_jit_lvalue *u =
gcc_jit_rvalue_dereference_field(pupval, NULL, def->ravi->types->UpVal_u);
return gcc_jit_lvalue_access_field(u, NULL, def->ravi->types->UpVal_u_value);
@ -790,27 +791,29 @@ void ravi_emit_conditional_branch(ravi_function_def_t *def,
def->current_block_terminated = true;
}
gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def, gcc_jit_rvalue *reg, lua_typecode_t tt, int pc) {
gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def,
gcc_jit_rvalue *reg, lua_typecode_t tt,
int pc) {
gcc_jit_lvalue *value = gcc_jit_function_new_local(def->jit_function, NULL,
tt == LUA__TNUMFLT ?
def->ravi->types->lua_NumberT :
def->ravi->types->lua_IntegerT,
unique_name(def, "value", pc));
gcc_jit_lvalue *value = gcc_jit_function_new_local(
def->jit_function, NULL,
tt == LUA__TNUMFLT ? def->ravi->types->lua_NumberT
: def->ravi->types->lua_IntegerT,
unique_name(def, "value", pc));
gcc_jit_lvalue *reg_type = ravi_emit_load_type(def, reg);
// Is reg an number?
gcc_jit_rvalue *cmp1 =
ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(reg_type), tt);
ravi_emit_is_value_of_type(def, gcc_jit_lvalue_as_rvalue(reg_type), tt);
gcc_jit_block *convert_reg =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "convert_reg", pc));
gcc_jit_block *copy_reg =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "copy_reg", pc));
gcc_jit_block *load_val =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "load_val", pc));
gcc_jit_block *failed_conversion = gcc_jit_function_new_block(def->jit_function,
unique_name(def, "if_conversion_failed", pc));
gcc_jit_block *convert_reg = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "convert_reg", pc));
gcc_jit_block *copy_reg = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "copy_reg", pc));
gcc_jit_block *load_val = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "load_val", pc));
gcc_jit_block *failed_conversion = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "if_conversion_failed", pc));
// If reg is integer then copy reg, else convert reg
ravi_emit_conditional_branch(def, cmp1, copy_reg, convert_reg);
@ -819,28 +822,32 @@ gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def, gcc_jit_rvalue *re
ravi_set_current_block(def, convert_reg);
// Do the conversion
gcc_jit_rvalue *var_istt =
ravi_function_call2_rvalue(def, tt == LUA__TNUMFLT ? def->ravi->types->luaV_tonumberT
: def->ravi->types->luaV_tointegerT,
reg, gcc_jit_lvalue_get_address(value, NULL));
gcc_jit_rvalue *var_istt = ravi_function_call2_rvalue(
def, tt == LUA__TNUMFLT ? def->ravi->types->luaV_tonumberT
: def->ravi->types->luaV_tointegerT,
reg, gcc_jit_lvalue_get_address(value, NULL));
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
gcc_jit_rvalue *conversion_failed = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ,
var_istt, zero);
def->function_context, def->ravi->types->C_intT, 0);
gcc_jit_rvalue *conversion_failed =
ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, var_istt, zero);
// Did conversion fail?
ravi_emit_conditional_branch(def, conversion_failed, failed_conversion, load_val);
ravi_emit_conditional_branch(def, conversion_failed, failed_conversion,
load_val);
// Conversion failed, so raise error
ravi_set_current_block(def, failed_conversion);
ravi_emit_raise_lua_error(def, tt == LUA__TNUMFLT ? "number expected" : "integer expected");
ravi_emit_raise_lua_error(def, tt == LUA__TNUMFLT ? "number expected"
: "integer expected");
ravi_emit_branch(def, load_val);
// Conversion OK
ravi_set_current_block(def, copy_reg);
gcc_jit_lvalue *i = tt == LUA__TNUMFLT ? ravi_emit_load_reg_n(def, reg) : ravi_emit_load_reg_i(def, reg);
gcc_jit_block_add_assignment(def->current_block, NULL, value, gcc_jit_lvalue_as_rvalue(i));
gcc_jit_lvalue *i = tt == LUA__TNUMFLT ? ravi_emit_load_reg_n(def, reg)
: ravi_emit_load_reg_i(def, reg);
gcc_jit_block_add_assignment(def->current_block, NULL, value,
gcc_jit_lvalue_as_rvalue(i));
ravi_emit_branch(def, load_val);
ravi_set_current_block(def, load_val);
@ -848,7 +855,6 @@ gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def, gcc_jit_rvalue *re
return value;
}
static void init_def(ravi_function_def_t *def, ravi_gcc_context_t *ravi,
Proto *p) {
def->ravi = ravi;
@ -1304,13 +1310,15 @@ int raviV_compile(struct lua_State *L, struct Proto *p, int manual_request,
case OP_RAVI_SETTABLE_AI: {
int B = GETARG_B(i);
int C = GETARG_C(i);
ravi_emit_SETTABLE_AI_AF(&def, A, B, C, op == OP_RAVI_SETTABLE_AII, LUA__TNUMINT, pc);
ravi_emit_SETTABLE_AI_AF(&def, A, B, C, op == OP_RAVI_SETTABLE_AII,
LUA__TNUMINT, pc);
} break;
case OP_RAVI_SETTABLE_AFF:
case OP_RAVI_SETTABLE_AF: {
int B = GETARG_B(i);
int C = GETARG_C(i);
ravi_emit_SETTABLE_AI_AF(&def, A, B, C, op == OP_RAVI_SETTABLE_AFF, LUA__TNUMFLT, pc);
ravi_emit_SETTABLE_AI_AF(&def, A, B, C, op == OP_RAVI_SETTABLE_AFF,
LUA__TNUMFLT, pc);
} break;
case OP_ADD: {
@ -1348,7 +1356,7 @@ int raviV_compile(struct lua_State *L, struct Proto *p, int manual_request,
if (gcc_jit_context_get_first_error(def.function_context)) {
fprintf(stderr, "aborting due to JIT error: %s\n",
gcc_jit_context_get_first_error(def.function_context));
ravi_print_function(p,1);
ravi_print_function(p, 1);
abort();
}
gcc_jit_result *compilation_result =
@ -1409,42 +1417,48 @@ void ravi_debug_printf2(ravi_function_def_t *def, const char *str,
}
void ravi_debug_printf3(ravi_function_def_t *def, const char *str,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2, gcc_jit_rvalue *arg3) {
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3) {
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(
def, def->ravi->types->printfT,
gcc_jit_context_new_string_literal(def->function_context, str), arg1,
arg2, arg3));
def->current_block, NULL,
ravi_function_call4_rvalue(
def, def->ravi->types->printfT,
gcc_jit_context_new_string_literal(def->function_context, str), arg1,
arg2, arg3));
}
void ravi_debug_printf4(ravi_function_def_t *def, const char *str,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2, gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4) {
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4) {
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call5_rvalue(
def, def->ravi->types->printfT,
gcc_jit_context_new_string_literal(def->function_context, str), arg1,
arg2, arg3, arg4));
def->current_block, NULL,
ravi_function_call5_rvalue(
def, def->ravi->types->printfT,
gcc_jit_context_new_string_literal(def->function_context, str), arg1,
arg2, arg3, arg4));
}
gcc_jit_rvalue *ravi_int_constant(ravi_function_def_t *def, int value) {
return gcc_jit_context_new_rvalue_from_int(def->function_context, def->ravi->types->C_intT, value);
return gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, value);
}
gcc_jit_rvalue *ravi_bool_constant(ravi_function_def_t *def, int value) {
return gcc_jit_context_new_rvalue_from_int(def->function_context, def->ravi->types->C_boolT, value ? 1 : 0);
return gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_boolT, value ? 1 : 0);
}
gcc_jit_rvalue *ravi_lua_Integer_constant(ravi_function_def_t *def, int value) {
return gcc_jit_context_new_rvalue_from_int(def->function_context, def->ravi->types->lua_IntegerT, value);
return gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->lua_IntegerT, value);
}
gcc_jit_rvalue *ravi_lua_Number_constant(ravi_function_def_t *def, double value) {
return gcc_jit_context_new_rvalue_from_double(def->function_context, def->ravi->types->lua_NumberT, value);
gcc_jit_rvalue *ravi_lua_Number_constant(ravi_function_def_t *def,
double value) {
return gcc_jit_context_new_rvalue_from_double(
def->function_context, def->ravi->types->lua_NumberT, value);
}
// Free the JIT compiled function
// Note that this is called by the garbage collector
void raviV_freeproto(struct lua_State *L, struct Proto *p) {

47
src/ravi_gcccomp.c
Unescape View File

@ -92,7 +92,7 @@ void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C, int j,
}
gcc_jit_rvalue *ravi_emit_boolean_testfalse1(ravi_function_def_t *def,
gcc_jit_rvalue *reg, bool negate) {
gcc_jit_rvalue *reg, bool negate) {
// (isnil() || isbool() && b == 0)
gcc_jit_lvalue *var = gcc_jit_function_new_local(
@ -158,48 +158,47 @@ gcc_jit_rvalue *ravi_emit_boolean_testfalse(ravi_function_def_t *def,
// (isnil() || isbool() && b == 0)
gcc_jit_lvalue *var = gcc_jit_function_new_local(
def->jit_function, NULL, def->ravi->types->C_boolT,
unique_name(def, "isfalse", 0));
def->jit_function, NULL, def->ravi->types->C_boolT,
unique_name(def, "isfalse", 0));
gcc_jit_lvalue *type = ravi_emit_load_type(def, reg);
// Test if type == LUA_TNIL (0)
gcc_jit_rvalue *isnil = ravi_emit_is_value_of_type(
def, gcc_jit_lvalue_as_rvalue(type), LUA__TNIL);
def, gcc_jit_lvalue_as_rvalue(type), LUA__TNIL);
// Test if type == LUA_TBOOLEAN
gcc_jit_rvalue *isbool = ravi_emit_is_value_of_type(
def, gcc_jit_lvalue_as_rvalue(type), LUA__TBOOLEAN);
def, gcc_jit_lvalue_as_rvalue(type), LUA__TBOOLEAN);
// Test if bool value == 0
gcc_jit_lvalue *bool_value = ravi_emit_load_reg_b(def, reg);
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
def->function_context, def->ravi->types->C_intT, 0);
gcc_jit_rvalue *boolzero = ravi_emit_comparison(
def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(bool_value), zero);
def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(bool_value), zero);
// Test type == LUA_TBOOLEAN && bool value == 0
gcc_jit_rvalue *andvalue = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT, isbool, boolzero);
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT, isbool, boolzero);
gcc_jit_rvalue *orvalue = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_OR,
def->ravi->types->C_boolT, isnil, andvalue);
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_OR,
def->ravi->types->C_boolT, isnil, andvalue);
gcc_jit_block_add_assignment(def->current_block, NULL, var, orvalue);
gcc_jit_rvalue *result = NULL;
if (negate) {
result = gcc_jit_context_new_unary_op(
def->function_context, NULL, GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
def->ravi->types->C_boolT, gcc_jit_lvalue_as_rvalue(var));
def->function_context, NULL, GCC_JIT_UNARY_OP_LOGICAL_NEGATE,
def->ravi->types->C_boolT, gcc_jit_lvalue_as_rvalue(var));
} else {
result = gcc_jit_lvalue_as_rvalue(var);
}
return result;
}
void ravi_emit_TEST(ravi_function_def_t *def, int A, int B, int C, int j,
int jA, int pc) {
@ -212,14 +211,18 @@ void ravi_emit_TEST(ravi_function_def_t *def, int A, int B, int C, int j,
(void)B;
// if (C) {
// ravi_debug_printf3(def, "OP_TEST(%d C=1)) if (!reg(A=%d)) then skip next else jmp to %d\n", ravi_int_constant(def, pc+1),
// ravi_int_constant(def, A), ravi_int_constant(def, j+1));
// }
// else {
// ravi_debug_printf3(def, "OP_TEST(%d C=0) if (reg(A=%d)) then skip next else jmp to %d\n", ravi_int_constant(def, pc+1),
// ravi_int_constant(def, A), ravi_int_constant(def, j+1));
// }
// if (C) {
// ravi_debug_printf3(def, "OP_TEST(%d C=1)) if (!reg(A=%d)) then skip next
// else jmp to %d\n", ravi_int_constant(def, pc+1),
// ravi_int_constant(def, A), ravi_int_constant(def,
// j+1));
// }
// else {
// ravi_debug_printf3(def, "OP_TEST(%d C=0) if (reg(A=%d)) then skip next
// else jmp to %d\n", ravi_int_constant(def, pc+1),
// ravi_int_constant(def, A), ravi_int_constant(def,
// j+1));
// }
// Load pointer to base
ravi_emit_load_base(def);

5
src/ravi_gccload.c
Unescape View File

@ -116,7 +116,10 @@ void ravi_emit_LOADBOOL(ravi_function_def_t *def, int A, int B, int C, int j,
// setbvalue(ra, GETARG_B(i));
// if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */
// ravi_debug_printf4(def, "LOADBOOL(pc=%d) set reg(A=%d) to boolean(B=%d); if ((C=%d) != 0) skip next\n", ravi_int_constant(def, pc+1), ravi_int_constant(def, A), ravi_int_constant(def, B), ravi_int_constant(def, C));
// ravi_debug_printf4(def, "LOADBOOL(pc=%d) set reg(A=%d) to boolean(B=%d);
// if ((C=%d) != 0) skip next\n", ravi_int_constant(def, pc+1),
// ravi_int_constant(def, A), ravi_int_constant(def, B),
// ravi_int_constant(def, C));
// Load pointer to base
ravi_emit_load_base(def);
// ra

3
src/ravi_gccreturn.c
Unescape View File

@ -53,7 +53,8 @@ void ravi_emit_RETURN(ravi_function_def_t *def, int A, int B, int pc) {
ravi_set_current_block(def, block);
}
// ravi_debug_printf2(def, "OP_RETURN(pc=%d) return %d args\n", ravi_int_constant(def, pc+1), ravi_int_constant(def, B-1));
// ravi_debug_printf2(def, "OP_RETURN(pc=%d) return %d args\n",
// ravi_int_constant(def, pc+1), ravi_int_constant(def, B-1));
// Load pointer to base
ravi_emit_load_base(def);

192
src/ravi_gcctable.c
Unescape View File

@ -36,9 +36,9 @@ void ravi_emit_SELF(ravi_function_def_t *def, int A, int B, int C, int pc) {
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_gettableT,
gcc_jit_param_as_rvalue(def->L), rb, rc, ra));
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_gettableT,
gcc_jit_param_as_rvalue(def->L), rb, rc, ra));
}
// R(A) := length of R(B)
@ -49,9 +49,9 @@ void ravi_emit_LEN(ravi_function_def_t *def, int A, int B, int pc) {
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call3_rvalue(def, def->ravi->types->luaV_objlenT,
gcc_jit_param_as_rvalue(def->L), ra, rb));
def->current_block, NULL,
ravi_function_call3_rvalue(def, def->ravi->types->luaV_objlenT,
gcc_jit_param_as_rvalue(def->L), ra, rb));
}
// R(A)[RK(B)] := RK(C)
@ -63,9 +63,9 @@ void ravi_emit_SETTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_settableT,
gcc_jit_param_as_rvalue(def->L), ra, rb, rc));
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_settableT,
gcc_jit_param_as_rvalue(def->L), ra, rb, rc));
}
// R(A) := R(B)[RK(C)]
@ -77,9 +77,9 @@ void ravi_emit_GETTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_gettableT,
gcc_jit_param_as_rvalue(def->L), rb, rc, ra));
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_gettableT,
gcc_jit_param_as_rvalue(def->L), rb, rc, ra));
}
void ravi_emit_GETTABLE_AF(ravi_function_def_t *def, int A, int B, int C,
@ -108,17 +108,17 @@ void ravi_emit_GETTABLE_AF(ravi_function_def_t *def, int A, int B, int C,
gcc_jit_rvalue *data = ravi_emit_load_reg_h_floatarray(def, t);
gcc_jit_lvalue *len = ravi_emit_load_ravi_arraylength(def, t);
gcc_jit_rvalue *ukey = gcc_jit_context_new_cast(
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
gcc_jit_rvalue *cmp = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LT, ukey,
gcc_jit_lvalue_as_rvalue(len));
gcc_jit_block *then_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AF_if_in_range", pc));
def->jit_function, unique_name(def, "GETTABLE_AF_if_in_range", pc));
gcc_jit_block *else_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AF_if_not_in_range", pc));
def->jit_function, unique_name(def, "GETTABLE_AF_if_not_in_range", pc));
gcc_jit_block *end_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AF_if_end", pc));
def->jit_function, unique_name(def, "GETTABLE_AF_if_end", pc));
ravi_emit_conditional_branch(def, cmp, then_block, else_block);
ravi_set_current_block(def, then_block);
@ -161,17 +161,17 @@ void ravi_emit_GETTABLE_AI(ravi_function_def_t *def, int A, int B, int C,
gcc_jit_rvalue *data = ravi_emit_load_reg_h_intarray(def, t);
gcc_jit_lvalue *len = ravi_emit_load_ravi_arraylength(def, t);
gcc_jit_rvalue *ukey = gcc_jit_context_new_cast(
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
gcc_jit_rvalue *cmp = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LT, ukey,
gcc_jit_lvalue_as_rvalue(len));
gcc_jit_block *then_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AI_if_in_range", pc));
def->jit_function, unique_name(def, "GETTABLE_AI_if_in_range", pc));
gcc_jit_block *else_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AI_if_not_in_range", pc));
def->jit_function, unique_name(def, "GETTABLE_AI_if_not_in_range", pc));
gcc_jit_block *end_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "GETTABLE_AI_if_end", pc));
def->jit_function, unique_name(def, "GETTABLE_AI_if_end", pc));
ravi_emit_conditional_branch(def, cmp, then_block, else_block);
ravi_set_current_block(def, then_block);
@ -188,7 +188,8 @@ void ravi_emit_GETTABLE_AI(ravi_function_def_t *def, int A, int B, int C,
ravi_set_current_block(def, end_block);
}
void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B, int C, bool known_tt, lua_typecode_t tt, int pc) {
void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B, int C,
bool known_tt, lua_typecode_t tt, int pc) {
//#define raviH_set_int_inline(L, t, key, value)
//{ unsigned ukey = (unsigned)((key));
@ -213,81 +214,84 @@ void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B, int C, boo
gcc_jit_lvalue *key = ravi_emit_load_reg_i(def, rb);
gcc_jit_lvalue *value = NULL;
switch(tt) {
case LUA__TNUMINT:
value = known_tt ? ravi_emit_load_reg_i(def, rc) : ravi_emit_tonumtype(def, rc, LUA__TNUMINT, pc);
break;
case LUA__TNUMFLT:
value = known_tt ? ravi_emit_load_reg_n(def, rc) : ravi_emit_tonumtype(def, rc, LUA__TNUMFLT, pc);
break;
default:
assert(false);
abort();
switch (tt) {
case LUA__TNUMINT:
value = known_tt ? ravi_emit_load_reg_i(def, rc)
: ravi_emit_tonumtype(def, rc, LUA__TNUMINT, pc);
break;
case LUA__TNUMFLT:
value = known_tt ? ravi_emit_load_reg_n(def, rc)
: ravi_emit_tonumtype(def, rc, LUA__TNUMFLT, pc);
break;
default:
assert(false);
abort();
}
gcc_jit_rvalue *t = ravi_emit_load_reg_h(def, ra);
gcc_jit_rvalue *data = NULL;
switch(tt) {
case LUA__TNUMINT:
data = ravi_emit_load_reg_h_intarray(def, t);
break;
case LUA__TNUMFLT:
data = ravi_emit_load_reg_h_floatarray(def, t);
break;
default:
assert(false);
abort();
switch (tt) {
case LUA__TNUMINT:
data = ravi_emit_load_reg_h_intarray(def, t);
break;
case LUA__TNUMFLT:
data = ravi_emit_load_reg_h_floatarray(def, t);
break;
default:
assert(false);
abort();
}
gcc_jit_lvalue *len = ravi_emit_load_ravi_arraylength(def, t);
gcc_jit_rvalue *ukey = gcc_jit_context_new_cast(
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
def->function_context, NULL, gcc_jit_lvalue_as_rvalue(key),
def->ravi->types->C_unsigned_intT);
gcc_jit_rvalue *cmp = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LT, ukey,
gcc_jit_lvalue_as_rvalue(len));
gcc_jit_block *then_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "SETTABLE_AX_if_in_range", pc));
def->jit_function, unique_name(def, "SETTABLE_AX_if_in_range", pc));
gcc_jit_block *else_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "SETTABLE_AX_if_not_in_range", pc));
def->jit_function, unique_name(def, "SETTABLE_AX_if_not_in_range", pc));
gcc_jit_block *end_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "SETTABLE_AX_if_end", pc));
def->jit_function, unique_name(def, "SETTABLE_AX_if_end", pc));
ravi_emit_conditional_branch(def, cmp, then_block, else_block);
ravi_set_current_block(def, then_block);
gcc_jit_lvalue *ptr = ravi_emit_array_get_ptr(def, data, ukey);
gcc_jit_block_add_assignment(def->current_block, NULL, ptr, gcc_jit_lvalue_as_rvalue(value));
gcc_jit_block_add_assignment(def->current_block, NULL, ptr,
gcc_jit_lvalue_as_rvalue(value));
ravi_emit_branch(def, end_block);
ravi_set_current_block(def, else_block);
gcc_jit_function *f = NULL;
switch (tt) {
case LUA__TNUMINT:
f = def->ravi->types->raviH_set_intT;
break;
case LUA__TNUMFLT:
f = def->ravi->types->raviH_set_floatT;
break;
default:
assert(false);
abort();
case LUA__TNUMINT:
f = def->ravi->types->raviH_set_intT;
break;
case LUA__TNUMFLT:
f = def->ravi->types->raviH_set_floatT;
break;
default:
assert(false);
abort();
}
gcc_jit_block_add_eval(def->current_block, NULL,
ravi_function_call4_rvalue(def, f,
gcc_jit_param_as_rvalue(def->L), t, ukey, gcc_jit_lvalue_as_rvalue(value)));
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, f, gcc_jit_param_as_rvalue(def->L), t,
ukey, gcc_jit_lvalue_as_rvalue(value)));
ravi_emit_branch(def, end_block);
ravi_set_current_block(def, end_block);
}
// R(A) := UpValue[B]
void ravi_emit_GETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
// int b = GETARG_B(i);
// setobj2s(L, ra, cl->upvals[b]->v);
(void) pc;
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, B);
@ -295,8 +299,6 @@ void ravi_emit_GETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
ravi_emit_struct_assign(def, ra, gcc_jit_lvalue_as_rvalue(v));
}
// UpValue[B] := R(A)
void ravi_emit_SETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
#if 1
@ -305,12 +307,12 @@ void ravi_emit_SETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_block_add_eval(def->current_block, NULL,
ravi_function_call4_rvalue(def,
def->ravi->types->raviV_op_setupvalT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->lua_closure_val),
ra, ravi_int_constant(def, B)));
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->raviV_op_setupvalT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->lua_closure_val),
ra, ravi_int_constant(def, B)));
#else
// UpVal *uv = cl->upvals[GETARG_B(i)];
// setobj(L, uv->v, ra);
@ -326,37 +328,40 @@ void ravi_emit_SETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
// (type & BIT_ISCOLLECTIBLE) != 0
gcc_jit_rvalue *bit_iscollectible = ravi_int_constant(def, BIT_ISCOLLECTABLE);
gcc_jit_rvalue *is_collectible_bit =
gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_BITWISE_AND,
def->ravi->types->C_intT, gcc_jit_lvalue_as_rvalue(type), bit_iscollectible);
gcc_jit_rvalue *is_collectible_bit = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_BITWISE_AND,
def->ravi->types->C_intT, gcc_jit_lvalue_as_rvalue(type),
bit_iscollectible);
gcc_jit_rvalue *zero = ravi_int_constant(def, 0);
gcc_jit_rvalue *is_collectible = ravi_emit_comparison(def, GCC_JIT_COMPARISON_NE,
is_collectible_bit, zero);
gcc_jit_rvalue *is_collectible = ravi_emit_comparison(
def, GCC_JIT_COMPARISON_NE, is_collectible_bit, zero);
// Is upvalue closed?
// (up->v == &up->u.value)
gcc_jit_lvalue *value = ravi_emit_load_upval_value(def, upval);
gcc_jit_rvalue *upisclosed = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(v),
gcc_jit_lvalue_get_address(value, NULL));
gcc_jit_rvalue *upisclosed = ravi_emit_comparison(
def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(v),
gcc_jit_lvalue_get_address(value, NULL));
// Collectible type and upvalue is closed
// ((type & BIT_ISCOLLECTIBLE) != 0) && ((up)->v == &(up)->u.value))
gcc_jit_rvalue *andcond =
gcc_jit_context_new_binary_op(def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT,
is_collectible, upisclosed);
gcc_jit_rvalue *andcond = gcc_jit_context_new_binary_op(
def->function_context, NULL, GCC_JIT_BINARY_OP_LOGICAL_AND,
def->ravi->types->C_boolT, is_collectible, upisclosed);
gcc_jit_block *then =
gcc_jit_function_new_block(def->jit_function,
unique_name(def, "SETUPVAL_if_collectible_and_upval_is_closed", pc));
gcc_jit_block *end =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "SETUPVAL_if_end", pc));
gcc_jit_block *then = gcc_jit_function_new_block(
def->jit_function,
unique_name(def, "SETUPVAL_if_collectible_and_upval_is_closed", pc));
gcc_jit_block *end = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "SETUPVAL_if_end", pc));
ravi_emit_conditional_branch(def, andcond, then, end);
ravi_set_current_block(def, then);
gcc_jit_block_add_eval(def->current_block, NULL, ravi_function_call2_rvalue(def, def->ravi->types->luaC_upvalbarrierT,
gcc_jit_param_as_rvalue(def->L), upval));
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call2_rvalue(def, def->ravi->types->luaC_upvalbarrierT,
gcc_jit_param_as_rvalue(def->L), upval));
ravi_emit_branch(def, end);
ravi_set_current_block(def, end);
@ -377,10 +382,10 @@ void ravi_emit_SETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc) {
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, A);
gcc_jit_lvalue *v = ravi_emit_load_upval_v(def, upval);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_settableT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(v), rb, rc));
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_settableT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(v), rb, rc));
}
// R(A) := UpValue[B][RK(C)]
@ -528,4 +533,3 @@ void ravi_emit_MOVEAF(ravi_function_def_t *def, int A, int B, int pc) {
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
ravi_emit_struct_assign(def, dest, src);
}

21
src/ravi_gcctypes.c
Unescape View File

@ -41,7 +41,7 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
gcc_jit_context_get_int_type(ravi->context, sizeof(lua_Integer), 1);
t->plua_IntegerT = gcc_jit_type_get_pointer(t->lua_IntegerT);
t->pplua_IntegerT = gcc_jit_type_get_pointer(t->plua_IntegerT);
// t->clua_IntegerT = gcc_jit_type_get_const(t->lua_IntegerT);
// t->clua_IntegerT = gcc_jit_type_get_const(t->lua_IntegerT);
t->lua_UnsignedT =
gcc_jit_context_get_int_type(ravi->context, sizeof(lua_Unsigned), 0);
@ -847,8 +847,10 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
// int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2)
params[0] =
gcc_jit_context_new_param(ravi->context, NULL, t->plua_StateT, "L");
params[1] = gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "t1");
params[2] = gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "t2");
params[1] =
gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "t1");
params[2] =
gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "t2");
t->luaV_equalobjT = gcc_jit_context_new_function(
ravi->context, NULL, GCC_JIT_FUNCTION_IMPORTED, t->C_intT,
"luaV_equalobj", 3, params, 0);
@ -923,7 +925,8 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
params[0] =
gcc_jit_context_new_param(ravi->context, NULL, t->plua_StateT, "L");
params[1] = gcc_jit_context_new_param(ravi->context, NULL, t->StkIdT, "ra");
params[2] = gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "rb");
params[2] =
gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "rb");
t->luaV_objlenT = gcc_jit_context_new_function(
ravi->context, NULL, GCC_JIT_FUNCTION_IMPORTED, t->C_voidT, "luaV_objlen",
3, params, 0);
@ -957,8 +960,10 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
// StkId res, TMS event);
params[0] =
gcc_jit_context_new_param(ravi->context, NULL, t->plua_StateT, "L");
params[1] = gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "p1");
params[2] = gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "p2");
params[1] =
gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "p1");
params[2] =
gcc_jit_context_new_param(ravi->context, NULL, t->pcTValueT, "p2");
params[3] = gcc_jit_context_new_param(ravi->context, NULL, t->StkIdT, "res");
params[4] = gcc_jit_context_new_param(ravi->context, NULL, t->tmsT, "event");
t->luaT_trybinTMT = gcc_jit_context_new_function(
@ -1109,8 +1114,7 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
ravi->context, NULL, GCC_JIT_FUNCTION_IMPORTED, t->C_voidT,
"raviH_set_float", 4, params, 0);
//void raviV_op_setupval(lua_State *L, LClosure *cl, TValue *ra, int b)
// void raviV_op_setupval(lua_State *L, LClosure *cl, TValue *ra, int b)
params[0] =
gcc_jit_context_new_param(ravi->context, NULL, t->plua_StateT, "L");
params[1] =
@ -1121,7 +1125,6 @@ bool ravi_setup_lua_types(ravi_gcc_context_t *ravi) {
ravi->context, NULL, GCC_JIT_FUNCTION_IMPORTED, t->C_voidT,
"raviV_op_setupval", 4, params, 0);
params[0] = gcc_jit_context_new_param(ravi->context, NULL, t->C_pconstcharT,
"format");
t->printfT = gcc_jit_context_new_function(ravi->context, NULL,

32
src/ravi_llvmcodegen.cpp
Unescape View File

@ -144,8 +144,7 @@ void RaviCodeGenerator::emit_load_base(RaviFunctionDef *def) {
}
// emit code to obtain address of register at location A
llvm::Value *RaviCodeGenerator::emit_gep_register(RaviFunctionDef *def,
int A) {
llvm::Value *RaviCodeGenerator::emit_gep_register(RaviFunctionDef *def, int A) {
llvm::Value *dest;
if (A == 0) {
// If A is 0 we can use the base pointer which is &base[0]
@ -242,8 +241,8 @@ void RaviCodeGenerator::emit_store_reg_n(RaviFunctionDef *def,
}
void RaviCodeGenerator::emit_store_reg_n_withtype(RaviFunctionDef *def,
llvm::Value *result,
llvm::Value *dest_ptr) {
llvm::Value *result,
llvm::Value *dest_ptr) {
emit_store_reg_n(def, result, dest_ptr);
emit_store_type_(def, dest_ptr, LUA_TNUMFLT);
}
@ -258,8 +257,8 @@ void RaviCodeGenerator::emit_store_reg_i(RaviFunctionDef *def,
}
void RaviCodeGenerator::emit_store_reg_i_withtype(RaviFunctionDef *def,
llvm::Value *result,
llvm::Value *dest_ptr) {
llvm::Value *result,
llvm::Value *dest_ptr) {
emit_store_reg_i(def, result, dest_ptr);
emit_store_type_(def, dest_ptr, LUA_TNUMINT);
}
@ -274,15 +273,14 @@ void RaviCodeGenerator::emit_store_reg_b(RaviFunctionDef *def,
}
void RaviCodeGenerator::emit_store_reg_b_withtype(RaviFunctionDef *def,
llvm::Value *result,
llvm::Value *dest_ptr) {
llvm::Value *result,
llvm::Value *dest_ptr) {
emit_store_reg_b(def, result, dest_ptr);
emit_store_type_(def, dest_ptr, LUA_TBOOLEAN);
}
void RaviCodeGenerator::emit_store_type_(RaviFunctionDef *def,
llvm::Value *value, int type) {
llvm::Value *value, int type) {
lua_assert(type == LUA_TNUMFLT || type == LUA_TNUMINT ||
type == LUA_TBOOLEAN);
#if RAVI_NAN_TAGGING
@ -418,8 +416,8 @@ llvm::Instruction *RaviCodeGenerator::emit_load_local_int(RaviFunctionDef *def,
}
// emit code to obtain address of register or constant at location B
llvm::Value *RaviCodeGenerator::emit_gep_register_or_constant(
RaviFunctionDef *def, int B) {
llvm::Value *
RaviCodeGenerator::emit_gep_register_or_constant(RaviFunctionDef *def, int B) {
// Load pointer to k
llvm::Value *k_ptr = def->k_ptr;
llvm::Value *rb;
@ -458,8 +456,7 @@ llvm::Value *RaviCodeGenerator::emit_gep_L_top(RaviFunctionDef *def) {
}
// L->top = R(B)
void RaviCodeGenerator::emit_set_L_top_toreg(RaviFunctionDef *def,
int B) {
void RaviCodeGenerator::emit_set_L_top_toreg(RaviFunctionDef *def, int B) {
// Get pointer to register at R(B)
llvm::Value *ptr = emit_gep_register(def, B);
// Get pointer to L->top
@ -470,7 +467,7 @@ void RaviCodeGenerator::emit_set_L_top_toreg(RaviFunctionDef *def,
}
llvm::Instruction *RaviCodeGenerator::emit_tointeger(RaviFunctionDef *def,
llvm::Value *reg) {
llvm::Value *reg) {
llvm::IRBuilder<> TmpB(def->entry, def->entry->begin());
llvm::Value *value =
TmpB.CreateAlloca(def->types->lua_IntegerT, nullptr, "value");
@ -525,7 +522,7 @@ llvm::Instruction *RaviCodeGenerator::emit_tointeger(RaviFunctionDef *def,
}
llvm::Instruction *RaviCodeGenerator::emit_tofloat(RaviFunctionDef *def,
llvm::Value *reg) {
llvm::Value *reg) {
llvm::IRBuilder<> TmpB(def->entry, def->entry->begin());
llvm::Value *value =
TmpB.CreateAlloca(def->types->lua_NumberT, nullptr, "value");
@ -1214,8 +1211,7 @@ void RaviCodeGenerator::compile(lua_State *L, Proto *p, bool doDump,
case OP_RAVI_FORLOOP_IP: {
int sbx = GETARG_sBx(i);
int j = sbx + pc + 1;
emit_iFORLOOP(def, A, j, def->jmp_targets[pc],
op == OP_RAVI_FORLOOP_I1);
emit_iFORLOOP(def, A, j, def->jmp_targets[pc], op == OP_RAVI_FORLOOP_I1);
} break;
case OP_FORLOOP: {
int sbx = GETARG_sBx(i);

6
src/ravi_llvmcomp.cpp
Unescape View File

@ -26,8 +26,8 @@ namespace ravi {
// Although the name is EQ this actually
// implements EQ, LE and LT - by using the supplied lua function to call.
void RaviCodeGenerator::emit_EQ(RaviFunctionDef *def, int A, int B, int C, int j,
int jA, llvm::Constant *callee) {
void RaviCodeGenerator::emit_EQ(RaviFunctionDef *def, int A, int B, int C,
int j, int jA, llvm::Constant *callee) {
// case OP_EQ: {
// TValue *rb = RKB(i);
// TValue *rc = RKC(i);
@ -71,7 +71,7 @@ void RaviCodeGenerator::emit_EQ(RaviFunctionDef *def, int A, int B, int C, int j
emit_load_base(def);
// base + a - 1
llvm::Value *val = emit_gep_register(def, jA-1);
llvm::Value *val = emit_gep_register(def, jA - 1);
// Call luaF_close
CreateCall2(def->builder, def->luaF_closeF, def->L, val);

47
src/ravi_llvmforloop.cpp
Unescape View File

@ -69,19 +69,16 @@ void RaviCodeGenerator::emit_FORLOOP2(RaviFunctionDef *def, int A, int pc,
// INTEGER CASE
// lua_Integer step = ivalue(ra + 2);
llvm::Instruction *step_int_value =
emit_load_local_n(def, step_int_ptr);
llvm::Instruction *step_int_value = emit_load_local_n(def, step_int_ptr);
// lua_Integer idx = ivalue(ra) + step; /* increment index */
llvm::Instruction *idx_int_value =
emit_load_local_n(def, idx_int_ptr);
llvm::Instruction *idx_int_value = emit_load_local_n(def, idx_int_ptr);
llvm::Value *new_idx = def->builder->CreateAdd(step_int_value, idx_int_value,
"next.idx", false, true);
emit_store_local_n(def, new_idx, idx_int_ptr);
// lua_Integer limit = ivalue(ra + 1);
llvm::Instruction *limit_int_value =
emit_load_local_n(def, limit_int_ptr);
llvm::Instruction *limit_int_value = emit_load_local_n(def, limit_int_ptr);
// idx > limit?
llvm::Value *new_idx_gt_limit =
@ -141,8 +138,7 @@ void RaviCodeGenerator::emit_FORLOOP2(RaviFunctionDef *def, int A, int pc,
emit_load_local_n(def, step_double_ptr);
// lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */
llvm::Instruction *idx_double_value =
emit_load_local_n(def, idx_double_ptr);
llvm::Instruction *idx_double_value = emit_load_local_n(def, idx_double_ptr);
new_idx =
def->builder->CreateFAdd(step_double_value, idx_double_value, "next.idx");
emit_store_local_n(def, new_idx, idx_double_ptr);
@ -199,7 +195,6 @@ void RaviCodeGenerator::emit_FORLOOP2(RaviFunctionDef *def, int A, int pc,
def->f->getBasicBlockList().push_back(exit_block);
def->builder->SetInsertPoint(exit_block);
}
void RaviCodeGenerator::emit_FORLOOP(RaviFunctionDef *def, int A, int pc) {
@ -245,7 +240,8 @@ void RaviCodeGenerator::emit_FORLOOP(RaviFunctionDef *def, int A, int pc) {
// Is index an integer?
llvm::Instruction *rinit_tt = emit_load_type(def, rinit);
llvm::Value *cmp1 = emit_is_value_of_type(def, rinit_tt, LUA__TNUMINT, "init.is.integer");
llvm::Value *cmp1 =
emit_is_value_of_type(def, rinit_tt, LUA__TNUMINT, "init.is.integer");
// Setup if then else branch for integer
llvm::BasicBlock *if_integer =
@ -377,7 +373,8 @@ void RaviCodeGenerator::emit_FORLOOP(RaviFunctionDef *def, int A, int pc) {
def->builder->SetInsertPoint(exit_block);
}
void RaviCodeGenerator::emit_iFORLOOP(RaviFunctionDef *def, int A, int pc, RaviBranchDef &b, int step_one) {
void RaviCodeGenerator::emit_iFORLOOP(RaviFunctionDef *def, int A, int pc,
RaviBranchDef &b, int step_one) {
// lua_Integer step = ivalue(ra + 2);
// lua_Integer idx = ivalue(ra) + step; /* increment index */
@ -397,39 +394,35 @@ void RaviCodeGenerator::emit_iFORLOOP(RaviFunctionDef *def, int A, int pc, RaviB
// Create the done block
llvm::BasicBlock *exit_block =
llvm::BasicBlock::Create(def->jitState->context(), "exit_iforloop");
llvm::BasicBlock::Create(def->jitState->context(), "exit_iforloop");
// lua_Integer idx = ivalue(ra) + step; /* increment index */
llvm::Instruction *idx_int_value =
emit_load_local_n(def, idx_int_ptr);
llvm::Instruction *idx_int_value = emit_load_local_n(def, idx_int_ptr);
llvm::Value *new_idx;
if (!step_one) {
// lua_Integer step = ivalue(ra + 2);
llvm::Value *step_int_ptr = b.istep;
llvm::Instruction *step_int_value =
emit_load_local_n(def, step_int_ptr);
new_idx = def->builder->CreateAdd(step_int_value, idx_int_value,
"next.idx", false, true);
}
else
llvm::Instruction *step_int_value = emit_load_local_n(def, step_int_ptr);
new_idx = def->builder->CreateAdd(step_int_value, idx_int_value, "next.idx",
false, true);
} else
new_idx = def->builder->CreateAdd(def->types->kluaInteger[1], idx_int_value,
"next.idx", false, true);
"next.idx", false, true);
// save new index
emit_store_local_n(def, new_idx, idx_int_ptr);
// lua_Integer limit = ivalue(ra + 1);
llvm::Instruction *limit_int_value =
emit_load_local_n(def, limit_int_ptr);
llvm::Instruction *limit_int_value = emit_load_local_n(def, limit_int_ptr);
// idx > limit?
llvm::Value *new_idx_gt_limit =
def->builder->CreateICmpSGT(new_idx, limit_int_value, "idx.gt.limit");
def->builder->CreateICmpSGT(new_idx, limit_int_value, "idx.gt.limit");
// If idx > limit we are done
llvm::BasicBlock *update_block =
llvm::BasicBlock::Create(def->jitState->context(), "updatei");
llvm::BasicBlock::Create(def->jitState->context(), "updatei");
def->builder->CreateCondBr(new_idx_gt_limit, exit_block, update_block);
// Merge into update block
@ -451,7 +444,5 @@ void RaviCodeGenerator::emit_iFORLOOP(RaviFunctionDef *def, int A, int pc, RaviB
def->f->getBasicBlockList().push_back(exit_block);
def->builder->SetInsertPoint(exit_block);
}
}

9
src/ravi_llvmload.cpp
Unescape View File

@ -36,8 +36,8 @@ void RaviCodeGenerator::emit_LOADFZ(RaviFunctionDef *def, int A) {
emit_load_base(def);
llvm::Value *dest = emit_gep_register(def, A);
// destvalue->n = 0.0
emit_store_reg_n_withtype(def, llvm::ConstantFP::get(def->types->lua_NumberT, 0.0),
dest);
emit_store_reg_n_withtype(
def, llvm::ConstantFP::get(def->types->lua_NumberT, 0.0), dest);
}
// R(A) := tointeger(0)
@ -58,7 +58,8 @@ void RaviCodeGenerator::emit_LOADBOOL(RaviFunctionDef *def, int A, int B, int C,
emit_load_base(def);
llvm::Value *dest = emit_gep_register(def, A);
// dest->i = 0
emit_store_reg_b_withtype(def, llvm::ConstantInt::get(def->types->C_intT, B), dest);
emit_store_reg_b_withtype(def, llvm::ConstantInt::get(def->types->C_intT, B),
dest);
if (C) {
// Skip next instruction if C
def->builder->CreateBr(def->jmp_targets[j].jmp1);
@ -387,7 +388,7 @@ void RaviCodeGenerator::emit_assign(RaviFunctionDef *def, llvm::Value *dest,
llvm::Instruction *store = def->builder->CreateStore(load, destvalue);
store->setMetadata(llvm::LLVMContext::MD_tbaa, def->types->tbaa_TValue_nT);
// destvalue->type = srcvalue->type
// destvalue->type = srcvalue->type
#if RAVI_NAN_TAGGING
llvm::Value *srctype = emit_gep(def, "srctype", src, 0, 1, 0);
llvm::Value *desttype = emit_gep(def, "desttype", dest, 0, 1, 0);

43
src/ravi_llvmtable.cpp
Unescape View File

@ -48,7 +48,8 @@ void RaviCodeGenerator::emit_LEN(RaviFunctionDef *def, int A, int B) {
}
// R(A)[RK(B)] := RK(C)
void RaviCodeGenerator::emit_SETTABLE(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_SETTABLE(RaviFunctionDef *def, int A, int B,
int C) {
// Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
emit_load_base(def);
llvm::Value *ra = emit_gep_register(def, A);
@ -58,7 +59,8 @@ void RaviCodeGenerator::emit_SETTABLE(RaviFunctionDef *def, int A, int B, int C)
}
// R(A) := R(B)[RK(C)]
void RaviCodeGenerator::emit_GETTABLE(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_GETTABLE(RaviFunctionDef *def, int A, int B,
int C) {
// Protect(luaV_gettable(L, RB(i), RKC(i), ra));
emit_load_base(def);
llvm::Value *ra = emit_gep_register(def, A);
@ -67,7 +69,8 @@ void RaviCodeGenerator::emit_GETTABLE(RaviFunctionDef *def, int A, int B, int C)
CreateCall4(def->builder, def->luaV_gettableF, def->L, rb, rc, ra);
}
void RaviCodeGenerator::emit_GETTABLE_AF(RaviFunctionDef *def,int A, int B, int C) {
void RaviCodeGenerator::emit_GETTABLE_AF(RaviFunctionDef *def, int A, int B,
int C) {
//#define raviH_get_float_inline(L, t, key, v)
//{ unsigned ukey = (unsigned)((key));
// lua_Number *data = (lua_Number *)t->ravi_array.data;
@ -120,7 +123,8 @@ void RaviCodeGenerator::emit_GETTABLE_AF(RaviFunctionDef *def,int A, int B, int
def->builder->SetInsertPoint(end_block);
}
void RaviCodeGenerator::emit_GETTABLE_AI(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_GETTABLE_AI(RaviFunctionDef *def, int A, int B,
int C) {
//#define raviH_get_int_inline(L, t, key, v)
//{ unsigned ukey = (unsigned)((key));
@ -174,7 +178,8 @@ void RaviCodeGenerator::emit_GETTABLE_AI(RaviFunctionDef *def, int A, int B, int
def->builder->SetInsertPoint(end_block);
}
void RaviCodeGenerator::emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int C, bool known_int) {
void RaviCodeGenerator::emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B,
int C, bool known_int) {
//#define raviH_set_int_inline(L, t, key, value)
//{ unsigned ukey = (unsigned)((key));
@ -197,7 +202,8 @@ void RaviCodeGenerator::emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int
llvm::Value *rb = emit_gep_register_or_constant(def, B);
llvm::Value *rc = emit_gep_register_or_constant(def, C);
llvm::Instruction *key = emit_load_reg_i(def, rb);
llvm::Instruction *value = known_int ? emit_load_reg_i(def, rc) : emit_tointeger(def, rc);
llvm::Instruction *value =
known_int ? emit_load_reg_i(def, rc) : emit_tointeger(def, rc);
llvm::Instruction *t = emit_load_reg_h(def, ra);
llvm::Instruction *data = emit_load_reg_h_intarray(def, t);
llvm::Instruction *len = emit_load_ravi_arraylength(def, t);
@ -216,7 +222,8 @@ void RaviCodeGenerator::emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int
llvm::Value *ptr = def->builder->CreateGEP(data, ukey);
llvm::Instruction *storeinst = def->builder->CreateStore(value, ptr);
storeinst->setMetadata(llvm::LLVMContext::MD_tbaa, def->types->tbaa_plonglongT);
storeinst->setMetadata(llvm::LLVMContext::MD_tbaa,
def->types->tbaa_plonglongT);
def->builder->CreateBr(end_block);
def->f->getBasicBlockList().push_back(else_block);
@ -229,7 +236,8 @@ void RaviCodeGenerator::emit_SETTABLE_AI(RaviFunctionDef *def, int A, int B, int
def->builder->SetInsertPoint(end_block);
}
void RaviCodeGenerator::emit_SETTABLE_AF(RaviFunctionDef *def, int A, int B, int C, bool known_float) {
void RaviCodeGenerator::emit_SETTABLE_AF(RaviFunctionDef *def, int A, int B,
int C, bool known_float) {
//#define raviH_set_float_inline(L, t, key, value)
//{ unsigned ukey = (unsigned)((key));
@ -256,7 +264,8 @@ void RaviCodeGenerator::emit_SETTABLE_AF(RaviFunctionDef *def, int A, int B, int
llvm::Value *rb = emit_gep_register_or_constant(def, B);
llvm::Value *rc = emit_gep_register_or_constant(def, C);
llvm::Instruction *key = emit_load_reg_i(def, rb);
llvm::Instruction *value = known_float ? emit_load_reg_n(def, rc) : emit_tofloat(def, rc);
llvm::Instruction *value =
known_float ? emit_load_reg_n(def, rc) : emit_tofloat(def, rc);
llvm::Instruction *t = emit_load_reg_h(def, ra);
llvm::Instruction *data = emit_load_reg_h_floatarray(def, t);
llvm::Instruction *len = emit_load_ravi_arraylength(def, t);
@ -341,7 +350,8 @@ void RaviCodeGenerator::emit_SETUPVAL(RaviFunctionDef *def, int A, int B) {
}
// R(A) := UpValue[B][RK(C)]
void RaviCodeGenerator::emit_GETTABUP(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_GETTABUP(RaviFunctionDef *def, int A, int B,
int C) {
// int b = GETARG_B(i);
// Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra));
emit_load_base(def);
@ -355,7 +365,8 @@ void RaviCodeGenerator::emit_GETTABUP(RaviFunctionDef *def, int A, int B, int C)
}
// UpValue[A][RK(B)] := RK(C)
void RaviCodeGenerator::emit_SETTABUP(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_SETTABUP(RaviFunctionDef *def, int A, int B,
int C) {
// int a = GETARG_A(i);
// Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i)));
@ -384,7 +395,8 @@ void RaviCodeGenerator::emit_NEWARRAYFLOAT(RaviFunctionDef *def, int A) {
ra);
}
void RaviCodeGenerator::emit_NEWTABLE(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_NEWTABLE(RaviFunctionDef *def, int A, int B,
int C) {
// case OP_NEWTABLE: {
// int b = GETARG_B(i);
// int c = GETARG_C(i);
@ -401,7 +413,8 @@ void RaviCodeGenerator::emit_NEWTABLE(RaviFunctionDef *def, int A, int B, int C)
def->types->kInt[B], def->types->kInt[C]);
}
void RaviCodeGenerator::emit_SETLIST(RaviFunctionDef *def, int A, int B, int C) {
void RaviCodeGenerator::emit_SETLIST(RaviFunctionDef *def, int A, int B,
int C) {
emit_load_base(def);
llvm::Value *ra = emit_gep_register(def, A);
CreateCall5(def->builder, def->raviV_op_setlistF, def->L, def->ci_val, ra,
@ -409,8 +422,8 @@ void RaviCodeGenerator::emit_SETLIST(RaviFunctionDef *def, int A, int B, int C)
}
void RaviCodeGenerator::emit_TOARRAY(RaviFunctionDef *def, int A,
int array_type_expected,
const char *errmsg) {
int array_type_expected,
const char *errmsg) {
// if (!ttistable(ra) || hvalue(ra)->ravi_array.type != RAVI_TARRAYINT)
// luaG_runerror(L, "integer[] expected");

166
src/ravi_llvmtypes.cpp
Unescape View File

@ -149,7 +149,7 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
ValueT->setBody(elements);
// TODO Needs to handle big endian
//struct ravi_HiLo {
// struct ravi_HiLo {
// int lo;
// int hi;
//} HiLo;
@ -178,7 +178,6 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
StkIdT = pTValueT;
///*
//** Header for string value; string bytes follow the end of this structure
//** (aligned according to 'UTString'; see next).
@ -289,10 +288,10 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
RaviJITProtoT = llvm::StructType::create(context, "struct.RaviJITProto");
elements.clear();
elements.push_back(lu_byteT); /* jit_status*/
elements.push_back(lu_byteT); /* jit_flags */
elements.push_back(C_shortT); /* execution_count */
elements.push_back(C_pcharT); /* jit_data */
elements.push_back(lu_byteT); /* jit_status*/
elements.push_back(lu_byteT); /* jit_flags */
elements.push_back(C_shortT); /* execution_count */
elements.push_back(C_pcharT); /* jit_data */
elements.push_back(plua_CFunctionT); /* jit_function */
RaviJITProtoT->setBody(elements);
@ -438,14 +437,14 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
NodeT->setBody(elements);
pNodeT = llvm::PointerType::get(NodeT, 0);
//typedef struct RaviArray {
// typedef struct RaviArray {
// char *data;
// unsigned int len; /* RAVI len specialization */
// unsigned int size; /* amount of memory allocated */
// lu_byte array_type; /* RAVI specialization */
// lu_byte array_modifier; /* Flags that affect how the array is handled */
//} RaviArray;
RaviArrayT = llvm::StructType::create(context, "struct.RaviArray");
elements.clear();
elements.push_back(C_pcharT);
@ -566,7 +565,7 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
elements.push_back(C_ptrdiff_t); /* extra */
elements.push_back(llvm::Type::getInt16Ty(context)); /* nresults */
elements.push_back(lu_byteT); /* callstatus */
elements.push_back(lu_byteT); /* jitstatus RAVI extension*/
elements.push_back(lu_byteT); /* jitstatus RAVI extension*/
CallInfoT->setBody(elements);
// typedef struct ravi_State ravi_State;
@ -782,7 +781,6 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
luaV_objlenT =
llvm::FunctionType::get(llvm::Type::getVoidTy(context), elements, false);
// void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val)
elements.push_back(pTValueT);
luaV_gettableT =
@ -821,7 +819,8 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
raviV_op_newarrayfloatT =
llvm::FunctionType::get(llvm::Type::getVoidTy(context), elements, false);
// void raviV_op_newtable(lua_State *L, CallInfo *ci, TValue *ra, int b, int c)
// void raviV_op_newtable(lua_State *L, CallInfo *ci, TValue *ra, int b, int
// c)
// void raviV_op_setlist(lua_State *L, CallInfo *ci, TValue *ra, int b, int c)
elements.push_back(C_intT);
elements.push_back(C_intT);
@ -849,8 +848,10 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
raviV_op_concatT =
llvm::FunctionType::get(llvm::Type::getVoidTy(context), elements, false);
// void raviV_op_closure(lua_State *L, CallInfo *ci, LClosure *cl, int a, int Bx)
// void raviV_op_vararg(lua_State *L, CallInfo *ci, LClosure *cl, int a, int b)
// void raviV_op_closure(lua_State *L, CallInfo *ci, LClosure *cl, int a, int
// Bx)
// void raviV_op_vararg(lua_State *L, CallInfo *ci, LClosure *cl, int a, int
// b)
elements.clear();
elements.push_back(plua_StateT);
elements.push_back(pCallInfoT);
@ -897,35 +898,31 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
//!4 = metadata !{metadata !"omnipotent char", metadata !5, i64 0}
tbaa_charT =
mdbuilder.createTBAAScalarTypeNode("omnipotent char", tbaa_root, 0);
tbaa_pcharT =
mdbuilder.createTBAAStructTagNode(tbaa_charT, tbaa_charT, 0);
tbaa_pcharT = mdbuilder.createTBAAStructTagNode(tbaa_charT, tbaa_charT, 0);
//!3 = metadata !{metadata !"any pointer", metadata !4, i64 0}
tbaa_pointerT =
mdbuilder.createTBAAScalarTypeNode("any pointer", tbaa_charT, 0);
tbaa_ppointerT =
mdbuilder.createTBAAStructTagNode(tbaa_pointerT, tbaa_pointerT, 0);
mdbuilder.createTBAAStructTagNode(tbaa_pointerT, tbaa_pointerT, 0);
//!10 = metadata !{metadata !"short", metadata !4, i64 0}
tbaa_shortT = mdbuilder.createTBAAScalarTypeNode("short", tbaa_charT, 0);
tbaa_pshortT =
mdbuilder.createTBAAStructTagNode(tbaa_shortT, tbaa_shortT, 0);
tbaa_pshortT = mdbuilder.createTBAAStructTagNode(tbaa_shortT, tbaa_shortT, 0);
//!11 = metadata !{metadata !"int", metadata !4, i64 0}
tbaa_intT = mdbuilder.createTBAAScalarTypeNode("int", tbaa_charT, 0);
tbaa_pintT =
mdbuilder.createTBAAStructTagNode(tbaa_intT, tbaa_intT, 0);
tbaa_pintT = mdbuilder.createTBAAStructTagNode(tbaa_intT, tbaa_intT, 0);
//!9 = metadata !{metadata !"long long", metadata !4, i64 0}
tbaa_longlongT =
mdbuilder.createTBAAScalarTypeNode("long long", tbaa_charT, 0);
tbaa_plonglongT =
mdbuilder.createTBAAStructTagNode(tbaa_longlongT, tbaa_longlongT, 0);
mdbuilder.createTBAAStructTagNode(tbaa_longlongT, tbaa_longlongT, 0);
tbaa_doubleT =
mdbuilder.createTBAAScalarTypeNode("double", tbaa_charT, 0);
tbaa_doubleT = mdbuilder.createTBAAScalarTypeNode("double", tbaa_charT, 0);
tbaa_pdoubleT =
mdbuilder.createTBAAStructTagNode(tbaa_doubleT, tbaa_doubleT, 0);
mdbuilder.createTBAAStructTagNode(tbaa_doubleT, tbaa_doubleT, 0);
//!14 = metadata !{metadata !"CallInfoL", metadata !3, i64 0, metadata !3, i64
// 4, metadata !9, i64 8}
@ -941,15 +938,23 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
// 32,
// metadata !10, i64 40, metadata !4, i64 42}
nodes.clear();
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); // func
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); // func
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 4)); // top
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 8)); // previous
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 12)); // next
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_CallInfo_lT, 16)); // l
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_longlongT, 32)); // extra
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_shortT, 40)); // nresults
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 42)); // callstatus
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 43)); // jitstatus
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 8)); // previous
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 12)); // next
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_CallInfo_lT, 16)); // l
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_longlongT, 32)); // extra
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_shortT, 40)); // nresults
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 42)); // callstatus
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 43)); // jitstatus
tbaa_CallInfoT = mdbuilder.createTBAAStructTypeNode("CallInfo", nodes);
//!7 = metadata !{metadata !"lua_State",
@ -1003,7 +1008,7 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
tbaa_CallInfo_func_LClosureT =
mdbuilder.createTBAAStructTagNode(tbaa_pointerT, tbaa_pointerT, 0);
tbaa_CallInfo_topT =
mdbuilder.createTBAAStructTagNode(tbaa_CallInfoT, tbaa_pointerT, 4);
mdbuilder.createTBAAStructTagNode(tbaa_CallInfoT, tbaa_pointerT, 4);
//!20 = metadata !{metadata !"Proto",
// metadata !3, i64 0, metadata !4, i64 4, metadata !4, i64 5,
@ -1020,30 +1025,48 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
// 68,
// metadata !3, i64 72, metadata !3, i64 76}
nodes.clear();
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); // next
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 4)); // tt
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 5)); // marked
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 6)); // numparams
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 7)); // is_vararg
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 8)); // maxstacksize
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 12)); // sizeupvalues
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 16)); // sizek
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 20)); // sizecode
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 24)); // sizelineinfo
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 28)); // sizep
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 32)); // sizelocvars
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 36)); // linedefined
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 40)); // lastlinedefined
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 44)); // k
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 48)); // code
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 52)); // p
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 56)); // lineinfo
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 60)); // locvars
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 64)); // upvalues
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 68)); // cache
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 72)); // source
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 76)); // gclist
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 80)); // ravi_jit
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); // next
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 4)); // tt
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 5)); // marked
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 6)); // numparams
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 7)); // is_vararg
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 8)); // maxstacksize
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 12)); // sizeupvalues
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 16)); // sizek
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 20)); // sizecode
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 24)); // sizelineinfo
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 28)); // sizep
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 32)); // sizelocvars
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 36)); // linedefined
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 40)); // lastlinedefined
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 44)); // k
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 48)); // code
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 52)); // p
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 56)); // lineinfo
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 60)); // locvars
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 64)); // upvalues
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 68)); // cache
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 72)); // source
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 76)); // gclist
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 80)); // ravi_jit
tbaa_ProtoT = mdbuilder.createTBAAStructTypeNode("Proto", nodes);
//!18 = metadata !{metadata !"LClosure",
@ -1070,8 +1093,7 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
tbaa_Proto_kT =
mdbuilder.createTBAAStructTagNode(tbaa_ProtoT, tbaa_pointerT, 44);
tbaa_Proto_sizepT =
mdbuilder.createTBAAStructTagNode(tbaa_ProtoT, tbaa_intT, 28);
mdbuilder.createTBAAStructTagNode(tbaa_ProtoT, tbaa_intT, 28);
nodes.clear();
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_longlongT, 0));
@ -1081,7 +1103,7 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
tbaa_TValue_nT =
mdbuilder.createTBAAStructTagNode(tbaa_TValueT, tbaa_longlongT, 0);
tbaa_TValue_hT =
mdbuilder.createTBAAStructTagNode(tbaa_TValueT, tbaa_pointerT, 0);
mdbuilder.createTBAAStructTagNode(tbaa_TValueT, tbaa_pointerT, 0);
tbaa_TValue_ttT =
mdbuilder.createTBAAStructTagNode(tbaa_TValueT, tbaa_intT, 8);
@ -1098,11 +1120,14 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
// RaviArray
nodes.clear();
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); /* data */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 4)); /* len */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 8)); /* size */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 12)); /* type */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 13)); /* modifiers */
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_pointerT, 0)); /* data */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 4)); /* len */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 8)); /* size */
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 12)); /* type */
nodes.push_back(
std::pair<llvm::MDNode *, uint64_t>(tbaa_charT, 13)); /* modifiers */
tbaa_RaviArrayT = mdbuilder.createTBAAStructTypeNode("RaviArray", nodes);
// Table
@ -1130,14 +1155,11 @@ LuaLLVMTypes::LuaLLVMTypes(llvm::LLVMContext &context) : mdbuilder(context) {
// TODO Needs to handle big endian
nodes.clear();
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 0)); /* lo */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 4)); /* hi */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 0)); /* lo */
nodes.push_back(std::pair<llvm::MDNode *, uint64_t>(tbaa_intT, 4)); /* hi */
tbaa_HiLoT = mdbuilder.createTBAAStructTypeNode("HiLo", nodes);
tbaa_HiLo_loT =
mdbuilder.createTBAAStructTagNode(tbaa_HiLoT, tbaa_intT, 0);
tbaa_HiLo_hiT =
mdbuilder.createTBAAStructTagNode(tbaa_HiLoT, tbaa_intT, 4);
tbaa_HiLo_loT = mdbuilder.createTBAAStructTagNode(tbaa_HiLoT, tbaa_intT, 0);
tbaa_HiLo_hiT = mdbuilder.createTBAAStructTagNode(tbaa_HiLoT, tbaa_intT, 4);
}
void LuaLLVMTypes::dump() {

Write Preview
Loading…
Cancel
Save