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

implement specialized comparison ops and refactor the JIT compiler to avoid unnecessary conversion to pointers

Browse Source
pull/81/head
dibyendumajumdar 9 years ago
parent dbd6856621
commit f8e9265831
14 changed files with 341 additions and 303 deletions
Show Stats Download Patch File Download Diff File

1
CMakeLists.txt
Unescape View File

@ -202,7 +202,6 @@ if (LLVM_JIT)
target_link_libraries(test_llvm ravi)
endif()
if (GCC_JIT)
#GCC JIT playground
add_executable(test_gccjit tests/test_gccjit.c)

52
include/ravi_gccjit.h
Unescape View File

@ -432,11 +432,11 @@ extern bool ravi_jit_has_errored(ravi_gcc_context_t *);
extern void ravi_emit_load_base(ravi_function_def_t *def);
extern gcc_jit_rvalue *ravi_emit_get_register(ravi_function_def_t *def, int A);
extern gcc_jit_lvalue *ravi_emit_get_register(ravi_function_def_t *def, int A);
extern gcc_jit_rvalue *ravi_emit_get_constant(ravi_function_def_t *def, int Bx);
extern gcc_jit_lvalue *ravi_emit_get_constant(ravi_function_def_t *def, int Bx);
extern gcc_jit_rvalue *
extern gcc_jit_lvalue *
ravi_emit_get_register_or_constant(ravi_function_def_t *def, int B);
extern void ravi_emit_set_L_top_toreg(ravi_function_def_t *def, int B);
@ -467,45 +467,45 @@ extern gcc_jit_rvalue *ravi_function_call2_rvalue(ravi_function_def_t *def,
gcc_jit_rvalue *arg1,
gcc_jit_rvalue *arg2);
extern gcc_jit_rvalue *
ravi_function_call5_rvalue(ravi_function_def_t *def, gcc_jit_function *f,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4,
gcc_jit_rvalue *arg5);
extern gcc_jit_rvalue *
ravi_function_call4_rvalue(ravi_function_def_t *def, gcc_jit_function *f,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4);
extern gcc_jit_rvalue *ravi_function_call3_rvalue(ravi_function_def_t *def,
gcc_jit_function *f,
gcc_jit_rvalue *arg1,
gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3);
extern gcc_jit_rvalue *
ravi_function_call4_rvalue(ravi_function_def_t *def, gcc_jit_function *f,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4);
extern gcc_jit_rvalue *
ravi_function_call5_rvalue(ravi_function_def_t *def, gcc_jit_function *f,
gcc_jit_rvalue *arg1, gcc_jit_rvalue *arg2,
gcc_jit_rvalue *arg3, gcc_jit_rvalue *arg4,
gcc_jit_rvalue *arg5);
extern const char *unique_name(ravi_function_def_t *def, const char *prefix,
int pc);
extern gcc_jit_rvalue *ravi_emit_num_stack_elements(ravi_function_def_t *def, gcc_jit_rvalue *ra);
extern void ravi_emit_struct_assign(ravi_function_def_t *def,
gcc_jit_rvalue *dest, gcc_jit_rvalue *src);
gcc_jit_lvalue *reg_dest, gcc_jit_lvalue *reg_src);
/* Store an integer value and set type to TNUMINT */
extern gcc_jit_lvalue *ravi_emit_load_reg_i(ravi_function_def_t *def,
gcc_jit_rvalue *value);
gcc_jit_lvalue *reg);
/* Store a number value and set type to TNUMFLT */
extern gcc_jit_lvalue *ravi_emit_load_reg_n(ravi_function_def_t *def,
gcc_jit_rvalue *tv);
gcc_jit_lvalue *reg);
/* Get TValue->value_.b */
extern gcc_jit_lvalue *ravi_emit_load_reg_b(ravi_function_def_t *def,
gcc_jit_rvalue *tv);
gcc_jit_lvalue *reg);
extern gcc_jit_lvalue *ravi_emit_load_type(ravi_function_def_t *def,
gcc_jit_rvalue *tv);
gcc_jit_lvalue *reg);
extern gcc_jit_rvalue *ravi_emit_is_value_of_type(ravi_function_def_t *def,
gcc_jit_rvalue *value_type,
@ -517,18 +517,18 @@ ravi_emit_is_not_value_of_type(ravi_function_def_t *def,
extern void ravi_emit_store_reg_i_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *ivalue,
gcc_jit_rvalue *reg);
gcc_jit_lvalue *reg);
extern void ravi_emit_store_reg_n_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *nvalue,
gcc_jit_rvalue *reg);
gcc_jit_lvalue *reg);
extern void ravi_emit_store_reg_b_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *bvalue,
gcc_jit_rvalue *reg);
gcc_jit_lvalue *reg);
extern gcc_jit_rvalue *ravi_emit_load_reg_h(ravi_function_def_t *def,
gcc_jit_rvalue *tv);
gcc_jit_lvalue *reg);
extern gcc_jit_rvalue *ravi_emit_load_reg_h_floatarray(ravi_function_def_t *def,
gcc_jit_rvalue *h);
@ -556,7 +556,7 @@ extern gcc_jit_rvalue *ravi_emit_comparison(ravi_function_def_t *def,
gcc_jit_rvalue *b);
extern gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def,
gcc_jit_rvalue *reg,
gcc_jit_lvalue *reg,
lua_typecode_t tt, int pc);
extern void ravi_emit_conditional_branch(ravi_function_def_t *def,
@ -568,7 +568,7 @@ extern void ravi_emit_branch(ravi_function_def_t *def,
gcc_jit_block *target_block);
extern gcc_jit_rvalue *ravi_emit_boolean_testfalse(ravi_function_def_t *def,
gcc_jit_rvalue *reg,
gcc_jit_lvalue *reg,
bool negate);
extern void ravi_emit_raise_lua_error(ravi_function_def_t *def,
@ -608,7 +608,7 @@ extern void ravi_emit_ADDIN(ravi_function_def_t *def, int A, int B, int C,
// implements EQ, LE and LT - by using the supplied lua function to call.
extern void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C,
int j, int jA, gcc_jit_function *callee,
const char *opname, int pc);
const char *opname, OpCode op, int pc);
extern void ravi_emit_JMP(ravi_function_def_t *def, int A, int j, int pc);

2
ravi-tests/fannkuchen.ravi
Unescape View File

@ -69,7 +69,7 @@ local function fannkuch(n: integer)
end
local n = tonumber(arg and arg[1]) or 11
assert(ravi.compile(fannkuch))
assert(ravi.compile(fannkuch,1))
local t1 = os.clock()
local sum, flips = fannkuch(n)
local t2 = os.clock()

124
src/ravi_gccarith1.c
Unescape View File

@ -28,8 +28,8 @@ void ravi_emit_UNMF(ravi_function_def_t *def, int A, int B, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// result = -rb->value_.n;
@ -44,8 +44,8 @@ void ravi_emit_UNMI(ravi_function_def_t *def, int A, int B, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
gcc_jit_rvalue *result = gcc_jit_context_new_unary_op(
@ -59,8 +59,8 @@ void ravi_emit_ADDFN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// result = rb->value_.n + (double)C
@ -79,8 +79,8 @@ void ravi_emit_MULFN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// result = rb->value_.n * (double)C
@ -99,8 +99,8 @@ void ravi_emit_SUBFN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// result = rb->value_.n - (double)C
@ -119,8 +119,8 @@ void ravi_emit_SUBNF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rc->value_.n
gcc_jit_lvalue *rhs = ravi_emit_load_reg_n(def, rc);
// result = (double)C - rc->value_.n
@ -140,8 +140,8 @@ void ravi_emit_SUBIN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// result = rb->value_.i - (lua_Integer)C
@ -160,8 +160,8 @@ void ravi_emit_SUBNI(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rc->value_.i
gcc_jit_lvalue *rhs = ravi_emit_load_reg_i(def, rc);
// result = (lua_Integer)B - rc->value_.i
@ -181,9 +181,9 @@ void ravi_emit_ADDFF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.n
@ -203,9 +203,9 @@ void ravi_emit_MULFF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.n
@ -225,9 +225,9 @@ void ravi_emit_SUBFF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.n
@ -247,9 +247,9 @@ void ravi_emit_DIVFF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.n
@ -269,9 +269,9 @@ void ravi_emit_ADDFI(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.i
@ -293,9 +293,9 @@ void ravi_emit_MULFI(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.i
@ -317,9 +317,9 @@ void ravi_emit_SUBFI(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.i
@ -341,9 +341,9 @@ void ravi_emit_DIVFI(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.n
gcc_jit_lvalue *lhs = ravi_emit_load_reg_n(def, rb);
// rc->value_.i
@ -365,9 +365,9 @@ void ravi_emit_SUBIF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.n
@ -390,9 +390,9 @@ void ravi_emit_DIVIF(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.n
@ -415,9 +415,9 @@ void ravi_emit_ADDII(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.i
@ -437,9 +437,9 @@ void ravi_emit_MULII(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.i
@ -459,9 +459,9 @@ void ravi_emit_SUBII(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.i
@ -481,9 +481,9 @@ void ravi_emit_DIVII(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// rc->value_.i
@ -508,8 +508,8 @@ void ravi_emit_ADDIN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// result = rb->value_.i + (lua_Integer)C
@ -528,8 +528,8 @@ void ravi_emit_MULIN(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
// rb->value_.i
gcc_jit_lvalue *lhs = ravi_emit_load_reg_i(def, rb);
// result = rb->value_.i * (lua_Integer)C

17
src/ravi_gccarith2.c
Unescape View File

@ -47,9 +47,9 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C, OpCode op,
unique_name(def, "ARITH_nc", pc));
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *rb_type = ravi_emit_load_type(def, rb);
gcc_jit_lvalue *rc_type = ravi_emit_load_type(def, rc);
@ -134,7 +134,8 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C, OpCode op,
// Call luaV_tonumber_()
gcc_jit_rvalue *rb_isnum =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rb,
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT,
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(nb, NULL));
cmp1 = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rb_isnum,
ravi_int_constant(def, 1));
@ -171,7 +172,8 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C, OpCode op,
// Call luaV_tonumber_()
gcc_jit_rvalue *rc_isnum =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, rc,
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT,
gcc_jit_lvalue_get_address(rc, NULL),
gcc_jit_lvalue_get_address(nc, NULL));
cmp1 = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, rc_isnum,
ravi_int_constant(def, 1));
@ -235,7 +237,10 @@ void ravi_emit_ARITH(ravi_function_def_t *def, int A, int B, int C, OpCode op,
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,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(rc, NULL),
gcc_jit_lvalue_get_address(ra, NULL),
ravi_int_constant(def, tms)));
ravi_emit_branch(def, done_block);

10
src/ravi_gcccall.c
Unescape View File

@ -46,12 +46,13 @@ void ravi_emit_JMP(ravi_function_def_t *def, int A, int j, int pc) {
if (A > 0) {
ravi_emit_load_base(def);
// base + a - 1
gcc_jit_rvalue *val = ravi_emit_get_register(def, A - 1);
gcc_jit_lvalue *val = ravi_emit_get_register(def, A - 1);
// Call luaF_close
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call2_rvalue(def, def->ravi->types->luaF_closeT,
gcc_jit_param_as_rvalue(def->L), val));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(val, NULL)));
}
ravi_emit_branch(def, def->jmp_targets[j]->jmp);
@ -92,11 +93,12 @@ void ravi_emit_CALL(ravi_function_def_t *def, int A, int B, int C, int pc) {
// 0 - Run interpreter on Lua function
// int c = luaD_precall(L, ra, nresults); /* C or JITed function? */
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *nresults_const = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, nresults);
gcc_jit_rvalue *precall_result = ravi_function_call3_rvalue(
def, def->ravi->types->luaD_precallT, gcc_jit_param_as_rvalue(def->L), ra,
def, def->ravi->types->luaD_precallT, gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(ra, NULL),
nresults_const);
/* Need to save the result of the luaD_precall() so that we can do another
* check later on

85
src/ravi_gcccodegen.c
Unescape View File

@ -310,19 +310,23 @@ void ravi_emit_raise_lua_error(ravi_function_def_t *def, const char *str) {
gcc_jit_context_new_string_literal(def->function_context, str)));
}
void ravi_emit_struct_assign(ravi_function_def_t *def, gcc_jit_rvalue *dest,
gcc_jit_rvalue *src) {
void ravi_emit_struct_assign(ravi_function_def_t *def, gcc_jit_lvalue *dest,
gcc_jit_lvalue *src) {
// gcc_jit_block_add_assignment(def->current_block, NULL,
// gcc_jit_rvalue_dereference(dest, NULL),
// gcc_jit_lvalue_as_rvalue(gcc_jit_rvalue_dereference(src,
// NULL)));
gcc_jit_lvalue *dest_value = gcc_jit_rvalue_dereference_field(
gcc_jit_lvalue *dest_value = gcc_jit_lvalue_access_field(
dest, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *dest_value_i = gcc_jit_lvalue_access_field(
dest_value, NULL, def->ravi->types->Value_value_i);
gcc_jit_lvalue *src_value = gcc_jit_rvalue_dereference_field(
gcc_jit_lvalue *src_value = gcc_jit_lvalue_access_field(
src, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *src_value_i = gcc_jit_lvalue_access_field(
src_value, NULL, def->ravi->types->Value_value_i);
@ -330,9 +334,9 @@ void ravi_emit_struct_assign(ravi_function_def_t *def, gcc_jit_rvalue *dest,
gcc_jit_lvalue_as_rvalue(src_value_i));
gcc_jit_lvalue *dest_tt =
gcc_jit_rvalue_dereference_field(dest, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue_access_field(dest, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue *src_tt =
gcc_jit_rvalue_dereference_field(src, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue_access_field(src, NULL, def->ravi->types->Value_tt);
gcc_jit_block_add_assignment(def->current_block, NULL, dest_tt,
gcc_jit_lvalue_as_rvalue(src_tt));
@ -417,26 +421,26 @@ gcc_jit_lvalue *ravi_emit_array_get_ptr(ravi_function_def_t *def,
/* Get access to the register identified by A - registers as just &base[offset]
*/
gcc_jit_rvalue *ravi_emit_get_register(ravi_function_def_t *def, int A) {
gcc_jit_lvalue *ravi_emit_get_register(ravi_function_def_t *def, int A) {
/* Note we assume that base is correct */
gcc_jit_lvalue *reg = gcc_jit_context_new_array_access(
// def->function_context, NULL, gcc_jit_lvalue_as_rvalue(def->base),
def->function_context, NULL, def->base_ref,
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, A));
return gcc_jit_lvalue_get_address(reg, NULL);
return reg;
}
/* Get access to a constant identify by Bx */
gcc_jit_rvalue *ravi_emit_get_constant(ravi_function_def_t *def, int Bx) {
gcc_jit_lvalue *ravi_emit_get_constant(ravi_function_def_t *def, int Bx) {
gcc_jit_lvalue *kst = gcc_jit_context_new_array_access(
def->function_context, NULL, def->k,
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, Bx));
return gcc_jit_lvalue_get_address(kst, NULL);
return kst;
}
gcc_jit_rvalue *ravi_emit_get_register_or_constant(ravi_function_def_t *def,
gcc_jit_lvalue *ravi_emit_get_register_or_constant(ravi_function_def_t *def,
int B) {
if (ISK(B))
return ravi_emit_get_constant(def, INDEXK(B));
@ -447,12 +451,12 @@ gcc_jit_rvalue *ravi_emit_get_register_or_constant(ravi_function_def_t *def,
// L->top = R(B)
void ravi_emit_set_L_top_toreg(ravi_function_def_t *def, int B) {
// Get pointer to register at R(B)
gcc_jit_rvalue *reg = ravi_emit_get_register(def, B);
gcc_jit_lvalue *reg = ravi_emit_get_register(def, B);
// Get pointer to L->top
gcc_jit_lvalue *top = gcc_jit_rvalue_dereference_field(
gcc_jit_param_as_rvalue(def->L), NULL, def->ravi->types->lua_State_top);
// L->top = R(B)
gcc_jit_block_add_assignment(def->current_block, NULL, top, reg);
gcc_jit_block_add_assignment(def->current_block, NULL, top, gcc_jit_lvalue_get_address(reg, NULL));
}
gcc_jit_rvalue *ravi_emit_num_stack_elements(ravi_function_def_t *def, gcc_jit_rvalue *ra) {
@ -482,9 +486,11 @@ static void emit_getL_base_reference(ravi_function_def_t *def,
/* Get TValue->value_.i */
gcc_jit_lvalue *ravi_emit_load_reg_i(ravi_function_def_t *def,
gcc_jit_rvalue *tv) {
gcc_jit_lvalue *tv) {
gcc_jit_lvalue *value =
gcc_jit_rvalue_dereference_field(tv, NULL, def->ravi->types->Value_value);
gcc_jit_lvalue_access_field(tv, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *i =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_i);
return i;
@ -492,9 +498,10 @@ gcc_jit_lvalue *ravi_emit_load_reg_i(ravi_function_def_t *def,
/* Get TValue->value_.b */
gcc_jit_lvalue *ravi_emit_load_reg_b(ravi_function_def_t *def,
gcc_jit_rvalue *tv) {
gcc_jit_lvalue *tv) {
gcc_jit_lvalue *value =
gcc_jit_rvalue_dereference_field(tv, NULL, def->ravi->types->Value_value);
gcc_jit_lvalue_access_field(tv, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *i =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_b);
return i;
@ -502,9 +509,10 @@ gcc_jit_lvalue *ravi_emit_load_reg_b(ravi_function_def_t *def,
/* Get TValue->value_.n */
gcc_jit_lvalue *ravi_emit_load_reg_n(ravi_function_def_t *def,
gcc_jit_rvalue *tv) {
gcc_jit_lvalue *tv) {
gcc_jit_lvalue *value =
gcc_jit_rvalue_dereference_field(tv, NULL, def->ravi->types->Value_value);
gcc_jit_lvalue_access_field(tv, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *n =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_n);
return n;
@ -512,10 +520,11 @@ gcc_jit_lvalue *ravi_emit_load_reg_n(ravi_function_def_t *def,
/* Get (Table *) TValue->value_.gc */
gcc_jit_rvalue *ravi_emit_load_reg_h(ravi_function_def_t *def,
gcc_jit_rvalue *tv) {
gcc_jit_lvalue *tv) {
gcc_jit_lvalue *value =
gcc_jit_rvalue_dereference_field(tv, NULL, def->ravi->types->Value_value);
gcc_jit_lvalue_access_field(tv, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *gc = gcc_jit_lvalue_access_field(
value, NULL, def->ravi->types->Value_value_gc);
gcc_jit_rvalue *h = gcc_jit_context_new_cast(def->function_context, NULL,
@ -575,8 +584,8 @@ gcc_jit_lvalue *ravi_emit_load_ravi_arraytype(ravi_function_def_t *def,
}
gcc_jit_lvalue *ravi_emit_load_type(ravi_function_def_t *def,
gcc_jit_rvalue *tv) {
return gcc_jit_rvalue_dereference_field(tv, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue *reg) {
return gcc_jit_lvalue_access_field(reg, NULL, def->ravi->types->Value_tt);
}
gcc_jit_rvalue *ravi_emit_comparison(ravi_function_def_t *def,
@ -620,48 +629,52 @@ gcc_jit_rvalue *ravi_emit_is_not_value_of_type(ravi_function_def_t *def,
/* Store an integer value and set type to TNUMINT */
void ravi_emit_store_reg_i_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *ivalue,
gcc_jit_rvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_rvalue_dereference_field(
gcc_jit_lvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_lvalue_access_field(
reg, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *i =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_i);
gcc_jit_block_add_assignment(def->current_block, NULL, i, ivalue);
gcc_jit_rvalue *type = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, LUA_TNUMINT);
gcc_jit_lvalue *tt =
gcc_jit_rvalue_dereference_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue_access_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_block_add_assignment(def->current_block, NULL, tt, type);
}
/* Store a boolean value and set type to TBOOLEAN */
void ravi_emit_store_reg_b_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *bvalue,
gcc_jit_rvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_rvalue_dereference_field(
gcc_jit_lvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_lvalue_access_field(
reg, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *n =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_b);
gcc_jit_block_add_assignment(def->current_block, NULL, n, bvalue);
gcc_jit_rvalue *type = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, LUA__TBOOLEAN);
gcc_jit_lvalue *tt =
gcc_jit_rvalue_dereference_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue_access_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_block_add_assignment(def->current_block, NULL, tt, type);
}
/* Store a number value and set type to TNUMFLT */
void ravi_emit_store_reg_n_withtype(ravi_function_def_t *def,
gcc_jit_rvalue *nvalue,
gcc_jit_rvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_rvalue_dereference_field(
gcc_jit_lvalue *reg) {
gcc_jit_lvalue *value = gcc_jit_lvalue_access_field(
reg, NULL, def->ravi->types->Value_value);
assert(!gcc_jit_context_get_first_error(def->function_context));
gcc_jit_lvalue *n =
gcc_jit_lvalue_access_field(value, NULL, def->ravi->types->Value_value_n);
gcc_jit_block_add_assignment(def->current_block, NULL, n, nvalue);
gcc_jit_rvalue *type = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, LUA_TNUMFLT);
gcc_jit_lvalue *tt =
gcc_jit_rvalue_dereference_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_lvalue_access_field(reg, NULL, def->ravi->types->Value_tt);
gcc_jit_block_add_assignment(def->current_block, NULL, tt, type);
}
@ -812,7 +825,7 @@ void ravi_emit_conditional_branch(ravi_function_def_t *def,
}
gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def,
gcc_jit_rvalue *reg, lua_typecode_t tt,
gcc_jit_lvalue *reg, lua_typecode_t tt,
int pc) {
gcc_jit_lvalue *value = gcc_jit_function_new_local(
@ -845,7 +858,8 @@ gcc_jit_lvalue *ravi_emit_tonumtype(ravi_function_def_t *def,
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_lvalue_get_address(reg, NULL),
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 =
@ -1108,6 +1122,7 @@ int raviV_compile(struct lua_State *L, struct Proto *p, int manual_request,
case OP_EQ: {
int B = GETARG_B(i);
int C = GETARG_C(i);
OpCode comparison_op = op;
const char *opname =
((op == OP_EQ || op == OP_RAVI_EQ_II || op == OP_RAVI_EQ_FF) ? "OP_EQ" :
((op == OP_LT || op == OP_RAVI_LT_II || op == OP_RAVI_LT_FF) ? "OP_LT" : "OP_LE"));
@ -1125,7 +1140,7 @@ int raviV_compile(struct lua_State *L, struct Proto *p, int manual_request,
// j below is the jump target
int j = sbx + pc + 1;
ravi_emit_EQ_LE_LT(&def, A, B, C, j, GETARG_A(i), comparison_function,
opname, pc);
opname, comparison_op, pc);
} break;
case OP_NEWTABLE: {

155
src/ravi_gcccomp.c
Unescape View File

@ -26,7 +26,7 @@
// implements EQ, LE and LT - by using the supplied lua function to call.
void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C, int j,
int jA, gcc_jit_function *callee, const char *opname,
int pc) {
OpCode opCode, int pc) {
// case OP_EQ: {
// TValue *rb = RKB(i);
// TValue *rc = RKC(i);
@ -42,16 +42,69 @@ void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_emit_load_base(def);
// Get pointer to register B
gcc_jit_rvalue *lhs_ptr = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *regB = ravi_emit_get_register_or_constant(def, B);
// Get pointer to register C
gcc_jit_rvalue *rhs_ptr = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *regC = ravi_emit_get_register_or_constant(def, C);
gcc_jit_rvalue *result = NULL;
switch (opCode) {
case OP_RAVI_LT_II:
case OP_RAVI_LE_II:
case OP_RAVI_EQ_II: {
gcc_jit_lvalue *p1 = ravi_emit_load_reg_i(def, regB);
gcc_jit_lvalue *p2 = ravi_emit_load_reg_i(def, regC);
switch (opCode) {
case OP_RAVI_EQ_II:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
case OP_RAVI_LT_II:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LT, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
case OP_RAVI_LE_II:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LE, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
default:
assert(0);
}
result = gcc_jit_context_new_cast(def->function_context, NULL, result, def->ravi->types->C_intT);
} break;
case OP_RAVI_LT_FF:
case OP_RAVI_LE_FF:
case OP_RAVI_EQ_FF: {
gcc_jit_lvalue *p1 = ravi_emit_load_reg_n(def, regB);
gcc_jit_lvalue *p2 = ravi_emit_load_reg_n(def, regC);
switch (opCode) {
case OP_RAVI_EQ_FF:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
case OP_RAVI_LT_FF:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LT, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
case OP_RAVI_LE_FF:
result = ravi_emit_comparison(def, GCC_JIT_COMPARISON_LE, gcc_jit_lvalue_as_rvalue(p1), gcc_jit_lvalue_as_rvalue(p2));
break;
default:
assert(0);
}
result = gcc_jit_context_new_cast(def->function_context, NULL, result, def->ravi->types->C_intT);
} break;
default:
// Call luaV_equalobj with register B and C
result = ravi_function_call3_rvalue(
def, callee, gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(regB, NULL),
gcc_jit_lvalue_get_address(regC, NULL));
}
// Call luaV_equalobj with register B and C
gcc_jit_rvalue *result = ravi_function_call3_rvalue(
def, callee, gcc_jit_param_as_rvalue(def->L), lhs_ptr, rhs_ptr);
// Test if result is equal to operand A
gcc_jit_rvalue *A_const = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, A);
gcc_jit_rvalue *A_const = ravi_int_constant(def, A);
gcc_jit_rvalue *result_eq_A =
ravi_emit_comparison(def, GCC_JIT_COMPARISON_EQ, result, A_const);
// If result == A then we need to execute the next statement which is a jump
@ -76,13 +129,13 @@ void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_emit_load_base(def);
// base + a - 1
gcc_jit_rvalue *val = ravi_emit_get_register(def, jA - 1);
gcc_jit_lvalue *val = ravi_emit_get_register(def, jA - 1);
// Call luaF_close
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call2_rvalue(def, def->ravi->types->luaF_closeT,
gcc_jit_param_as_rvalue(def->L), val));
gcc_jit_param_as_rvalue(def->L), gcc_jit_lvalue_as_rvalue(val)));
}
// Do the jump
ravi_emit_branch(def, def->jmp_targets[j]->jmp);
@ -91,70 +144,8 @@ void ravi_emit_EQ_LE_LT(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_set_current_block(def, else_block);
}
gcc_jit_rvalue *ravi_emit_boolean_testfalse1(ravi_function_def_t *def,
gcc_jit_rvalue *reg, bool negate) {
// (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, "bvalue", 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);
gcc_jit_block *then_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "if.nil", 0));
gcc_jit_block *else_block = gcc_jit_function_new_block(
def->jit_function, unique_name(def, "not.nil", 0));
gcc_jit_block *end_block =
gcc_jit_function_new_block(def->jit_function, unique_name(def, "end", 0));
ravi_emit_conditional_branch(def, isnil, then_block, else_block);
ravi_set_current_block(def, then_block);
gcc_jit_block_add_assignment(def->current_block, NULL, var, isnil);
ravi_emit_branch(def, end_block);
ravi_set_current_block(def, else_block);
// value is not nil
// so check if bool and b == 0
// Test if type == LUA_TBOOLEAN
gcc_jit_rvalue *isbool = ravi_emit_is_value_of_type(
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);
gcc_jit_rvalue *boolzero = ravi_emit_comparison(
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);
gcc_jit_block_add_assignment(def->current_block, NULL, var, andvalue);
ravi_emit_branch(def, end_block);
ravi_set_current_block(def, end_block);
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));
} else {
result = gcc_jit_lvalue_as_rvalue(var);
}
return result;
}
gcc_jit_rvalue *ravi_emit_boolean_testfalse(ravi_function_def_t *def,
gcc_jit_rvalue *reg, bool negate) {
gcc_jit_lvalue *reg, bool negate) {
// (isnil() || isbool() && b == 0)
gcc_jit_lvalue *var = gcc_jit_function_new_local(
@ -228,7 +219,7 @@ void ravi_emit_TEST(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_emit_load_base(def);
// Get pointer to register A
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
// v = C ? is_false(ra) : !is_false(ra)
gcc_jit_rvalue *v = C ? ravi_emit_boolean_testfalse(def, ra, false)
: ravi_emit_boolean_testfalse(def, ra, true);
@ -250,13 +241,13 @@ void ravi_emit_TEST(ravi_function_def_t *def, int A, int B, int C, int j,
// jA is the A operand of the Jump instruction
// base + a - 1
gcc_jit_rvalue *val = ravi_emit_get_register(def, jA - 1);
gcc_jit_lvalue *val = ravi_emit_get_register(def, jA - 1);
// Call luaF_close
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call2_rvalue(def, def->ravi->types->luaF_closeT,
gcc_jit_param_as_rvalue(def->L), val));
gcc_jit_param_as_rvalue(def->L), gcc_jit_lvalue_as_rvalue(val)));
}
// Do the jump
ravi_emit_branch(def, def->jmp_targets[j]->jmp);
@ -276,9 +267,9 @@ void ravi_emit_NOT(ravi_function_def_t *def, int A, int B, int pc) {
ravi_emit_load_base(def);
// Get pointer to register B
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *v = ravi_emit_boolean_testfalse(def, rb, false);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
ravi_emit_store_reg_b_withtype(
def, gcc_jit_context_new_cast(def->function_context, NULL, v,
def->ravi->types->C_intT),
@ -303,7 +294,7 @@ void ravi_emit_TESTSET(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_emit_load_base(def);
// Get pointer to register B
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
// v = C ? is_false(ra) : !is_false(ra)
gcc_jit_rvalue *v = C ? ravi_emit_boolean_testfalse(def, rb, false)
: ravi_emit_boolean_testfalse(def, rb, true);
@ -322,7 +313,7 @@ void ravi_emit_TESTSET(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_set_current_block(def, then_block);
// Get pointer to register A
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
ravi_emit_struct_assign(def, ra, rb);
// if (a > 0) luaF_close(L, ci->u.l.base + a - 1);
@ -330,13 +321,13 @@ void ravi_emit_TESTSET(ravi_function_def_t *def, int A, int B, int C, int j,
// jA is the A operand of the Jump instruction
// base + a - 1
gcc_jit_rvalue *val = ravi_emit_get_register(def, jA - 1);
gcc_jit_lvalue *val = ravi_emit_get_register(def, jA - 1);
// Call luaF_close
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call2_rvalue(def, def->ravi->types->luaF_closeT,
gcc_jit_param_as_rvalue(def->L), val));
gcc_jit_param_as_rvalue(def->L), gcc_jit_lvalue_get_address(val, NULL)));
}
// Do the jump
ravi_emit_branch(def, def->jmp_targets[j]->jmp);

2
src/ravi_gccforloop.c
Unescape View File

@ -78,7 +78,7 @@ void ravi_emit_iFORLOOP(ravi_function_def_t *def, int A, int pc,
ravi_emit_load_base(def);
// setivalue(ra + 3, idx); /* ...and external index */
gcc_jit_rvalue *rvar = ravi_emit_get_register(def, A + 3);
gcc_jit_lvalue *rvar = ravi_emit_get_register(def, A + 3);
ravi_emit_store_reg_i_withtype(def, gcc_jit_lvalue_as_rvalue(b->iidx), rvar);
// ci->u.l.savedpc += GETARG_sBx(i); /* jump back */

6
src/ravi_gccforprep.c
Unescape View File

@ -46,9 +46,9 @@ void ravi_emit_iFORPREP(ravi_function_def_t *def, int A, int pc, int step_one) {
// TValue *init = ra;
// TValue *pstep = ra + 2;
gcc_jit_rvalue *init = ravi_emit_get_register(def, A);
gcc_jit_rvalue *plimit = ravi_emit_get_register(def, A + 1);
gcc_jit_rvalue *pstep = NULL;
gcc_jit_lvalue *init = ravi_emit_get_register(def, A);
gcc_jit_lvalue *plimit = ravi_emit_get_register(def, A + 1);
gcc_jit_lvalue *pstep = NULL;
if (!step_one)
pstep = ravi_emit_get_register(def, A + 2);
// Get ivalue(pstep)

42
src/ravi_gccload.c
Unescape View File

@ -46,7 +46,7 @@ void ravi_emit_LOADFZ(ravi_function_def_t *def, int A, int pc) {
ravi_emit_load_base(def);
// ra
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
// destvalue->value_.n = 0.0
ravi_emit_store_reg_n_withtype(
@ -63,7 +63,7 @@ void ravi_emit_LOADIZ(ravi_function_def_t *def, int A, int pc) {
ravi_emit_load_base(def);
// ra
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
// destvalue->value_.i =
ravi_emit_store_reg_i_withtype(
@ -83,7 +83,7 @@ void ravi_emit_LOADK(ravi_function_def_t *def, int A, int Bx, int pc) {
ravi_emit_load_base(def);
// ra
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
#if 1
TValue *Konst = &def->p->k[Bx];
@ -112,7 +112,7 @@ void ravi_emit_LOADK(ravi_function_def_t *def, int A, int Bx, int pc) {
default: {
#endif
// rb
gcc_jit_rvalue *src = ravi_emit_get_constant(def, Bx);
gcc_jit_lvalue *src = ravi_emit_get_constant(def, Bx);
// *ra = *rb
ravi_emit_struct_assign(def, dest, src);
@ -132,9 +132,9 @@ void ravi_emit_MOVE(ravi_function_def_t *def, int A, int B) {
ravi_emit_load_base(def);
// rb
gcc_jit_rvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *src = ravi_emit_get_register(def, B);
// ra
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
// *ra = *rb
ravi_emit_struct_assign(def, dest, src);
@ -154,7 +154,7 @@ void ravi_emit_LOADBOOL(ravi_function_def_t *def, int A, int B, int C, int j,
// Load pointer to base
ravi_emit_load_base(def);
// ra
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
// dest->i = 0
ravi_emit_store_reg_b_withtype(
def, gcc_jit_context_new_rvalue_from_int(def->function_context,
@ -188,8 +188,8 @@ void ravi_emit_MOVEI(ravi_function_def_t *def, int A, int B, int pc) {
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_rvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *src_type = ravi_emit_load_type(def, src);
@ -218,7 +218,8 @@ void ravi_emit_MOVEI(ravi_function_def_t *def, int A, int B, int pc) {
// Call luaV_tointeger_()
gcc_jit_rvalue *var_isint =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tointegerT, src,
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tointegerT,
gcc_jit_lvalue_get_address(src, NULL),
gcc_jit_lvalue_get_address(var, NULL));
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
@ -263,8 +264,8 @@ void ravi_emit_MOVEF(ravi_function_def_t *def, int A, int B, int pc) {
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_rvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *src_type = ravi_emit_load_type(def, src);
@ -293,7 +294,8 @@ void ravi_emit_MOVEF(ravi_function_def_t *def, int A, int B, int pc) {
// Call luaV_tonumber()
gcc_jit_rvalue *var_isflt =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT, src,
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tonumberT,
gcc_jit_lvalue_get_address(src, NULL),
gcc_jit_lvalue_get_address(var, NULL));
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
@ -337,8 +339,8 @@ void ravi_emit_TOINT(ravi_function_def_t *def, int A, int pc) {
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_rvalue *src = dest;
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = dest;
gcc_jit_lvalue *src_type = ravi_emit_load_type(def, src);
@ -356,7 +358,8 @@ void ravi_emit_TOINT(ravi_function_def_t *def, int A, int pc) {
// Call luaV_tointeger_()
gcc_jit_rvalue *var_isint =
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tointegerT, src,
ravi_function_call2_rvalue(def, def->ravi->types->luaV_tointegerT,
gcc_jit_lvalue_get_address(src, NULL),
gcc_jit_lvalue_get_address(var, NULL));
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
@ -407,8 +410,8 @@ void ravi_emit_TOFLT(ravi_function_def_t *def, int A, int pc) {
// Load pointer to base
ravi_emit_load_base(def);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_rvalue *src = dest;
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = dest;
gcc_jit_lvalue *src_type = ravi_emit_load_type(def, src);
@ -429,7 +432,8 @@ void ravi_emit_TOFLT(ravi_function_def_t *def, int A, int pc) {
// ravi_debug_printf3(def, "number %p = %f before call to luaV_number\n",
// var_ptr, gcc_jit_lvalue_as_rvalue(var));
gcc_jit_rvalue *var_isflt = ravi_function_call2_rvalue(
def, def->ravi->types->luaV_tonumberT, src, var_ptr);
def, def->ravi->types->luaV_tonumberT,
gcc_jit_lvalue_get_address(src, NULL), var_ptr);
gcc_jit_rvalue *zero = gcc_jit_context_new_rvalue_from_int(
def->function_context, def->ravi->types->C_intT, 0);
gcc_jit_rvalue *failed_conversion =

7
src/ravi_gccreturn.c
Unescape View File

@ -56,7 +56,7 @@ void ravi_emit_RETURN(ravi_function_def_t *def, int A, int B, int pc) {
ravi_emit_load_base(def);
// Get pointer to register A
gcc_jit_rvalue *ra_ptr = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra_ptr = ravi_emit_get_register(def, A);
// if (cl->p->sizep > 0) luaF_close(L, base);
// Get pointer to Proto->sizep
@ -90,13 +90,14 @@ void ravi_emit_RETURN(ravi_function_def_t *def, int A, int B, int pc) {
if (B != 0)
nresults = ravi_int_constant(def, B - 1);
else
nresults = ravi_emit_num_stack_elements(def, ra_ptr);
nresults = ravi_emit_num_stack_elements(def, gcc_jit_lvalue_get_address(ra_ptr, NULL));
//* b = luaD_poscall(L, ra, (b != 0 ? b - 1 : L->top - ra));
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call3_rvalue(def, def->ravi->types->luaD_poscallT,
gcc_jit_param_as_rvalue(def->L), ra_ptr, nresults));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(ra_ptr, NULL), nresults));
gcc_jit_block_end_with_return(
def->current_block, NULL,

122
src/ravi_gcctable.c
Unescape View File

@ -30,15 +30,18 @@ void ravi_emit_SELF(ravi_function_def_t *def, int A, int B, int C, int pc) {
// Protect(luaV_gettable(L, rb, RKC(i), ra));
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *ra1 = ravi_emit_get_register(def, A + 1);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *ra1 = ravi_emit_get_register(def, A + 1);
ravi_emit_struct_assign(def, ra1, rb);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *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));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(rc, NULL),
gcc_jit_lvalue_get_address(ra, NULL)));
}
// R(A) := length of R(B)
@ -46,12 +49,14 @@ void ravi_emit_LEN(ravi_function_def_t *def, int A, int B, int pc) {
// Protect(luaV_objlen(L, ra, RB(i)));
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *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));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(ra, NULL),
gcc_jit_lvalue_get_address(rb, NULL)));
}
// R(A)[RK(B)] := RK(C)
@ -59,13 +64,16 @@ void ravi_emit_SETTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
// Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *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));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(ra, NULL),
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(rc, NULL)));
}
// R(A) := R(B)[RK(C)]
@ -73,13 +81,16 @@ void ravi_emit_GETTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
// Protect(luaV_gettable(L, RB(i), RKC(i), ra));
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *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));
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(rc, NULL),
gcc_jit_lvalue_get_address(ra, NULL)));
}
void ravi_emit_GETTABLE_AF(ravi_function_def_t *def, int A, int B, int C,
@ -100,9 +111,9 @@ void ravi_emit_GETTABLE_AF(ravi_function_def_t *def, int A, int B, int C,
// raviH_get_float_inline(L, t, idx, ra);
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *key = ravi_emit_load_reg_i(def, rc);
gcc_jit_rvalue *t = ravi_emit_load_reg_h(def, rb);
gcc_jit_rvalue *data = ravi_emit_load_reg_h_floatarray(def, t);
@ -155,9 +166,9 @@ void ravi_emit_GETTABLE_AI(ravi_function_def_t *def, int A, int B, int C,
// raviH_get_int_inline(L, t, idx, ra);
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *key = ravi_emit_load_reg_i(def, rc);
gcc_jit_rvalue *t = ravi_emit_load_reg_h(def, rb);
gcc_jit_rvalue *data = ravi_emit_load_reg_h_intarray(def, t);
@ -212,9 +223,9 @@ void ravi_emit_SETTABLE_AI_AF(ravi_function_def_t *def, int A, int B, int C,
// raviH_set_int_inline(L, t, idx, value);
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
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_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *key = ravi_emit_load_reg_i(def, rb);
gcc_jit_lvalue *value = NULL;
@ -299,10 +310,10 @@ void ravi_emit_GETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
// setobj2s(L, ra, cl->upvals[b]->v);
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, B);
gcc_jit_lvalue *v = ravi_emit_load_upval_v(def, upval);
ravi_emit_struct_assign(def, ra, gcc_jit_lvalue_as_rvalue(v));
ravi_emit_struct_assign(def, ra, gcc_jit_rvalue_dereference(gcc_jit_lvalue_as_rvalue(v), NULL));
}
// UpValue[B] := R(A)
@ -312,25 +323,26 @@ void ravi_emit_SETUPVAL(ravi_function_def_t *def, int A, int B, int pc) {
// The inline version causes segmentation fault during compilation
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *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_lvalue_get_address(ra, NULL),
ravi_int_constant(def, B)));
#else
// UpVal *uv = cl->upvals[GETARG_B(i)];
// setobj(L, uv->v, ra);
// luaC_upvalbarrier(L, uv);
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, B);
gcc_jit_lvalue *v = ravi_emit_load_upval_v(def, upval);
ravi_emit_struct_assign(def, gcc_jit_lvalue_as_rvalue(v), ra);
ravi_emit_struct_assign(def, v, ra);
gcc_jit_lvalue *type = ravi_emit_load_type(def, gcc_jit_lvalue_as_rvalue(v));
gcc_jit_lvalue *type = ravi_emit_load_type(def, v);
// (type & BIT_ISCOLLECTIBLE) != 0
gcc_jit_rvalue *bit_iscollectible = ravi_int_constant(def, BIT_ISCOLLECTABLE);
@ -382,8 +394,8 @@ void ravi_emit_SETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
ravi_emit_load_base(def);
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_lvalue *rb = ravi_emit_get_register_or_constant(def, B);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, A);
gcc_jit_lvalue *v = ravi_emit_load_upval_v(def, upval);
@ -391,7 +403,9 @@ void ravi_emit_SETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc) {
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));
gcc_jit_lvalue_as_rvalue(v),
gcc_jit_lvalue_get_address(rb, NULL),
gcc_jit_lvalue_get_address(rc, NULL)));
}
// R(A) := UpValue[B][RK(C)]
@ -401,8 +415,8 @@ void ravi_emit_GETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *rc = ravi_emit_get_register_or_constant(def, C);
gcc_jit_rvalue *upval = ravi_emit_get_upvals(def, B);
gcc_jit_lvalue *v = ravi_emit_load_upval_v(def, upval);
@ -410,7 +424,9 @@ void ravi_emit_GETTABUP(ravi_function_def_t *def, int A, int B, int C, int pc) {
def->current_block, NULL,
ravi_function_call4_rvalue(def, def->ravi->types->luaV_gettableT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(v), rc, ra));
gcc_jit_lvalue_as_rvalue(v),
gcc_jit_lvalue_get_address(rc, NULL),
gcc_jit_lvalue_get_address(ra, NULL)));
}
void ravi_emit_NEWTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
@ -426,13 +442,14 @@ void ravi_emit_NEWTABLE(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call5_rvalue(
def, def->ravi->types->raviV_op_newtableT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->ci_val), ra,
gcc_jit_lvalue_as_rvalue(def->ci_val),
gcc_jit_lvalue_get_address(ra, NULL),
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, B),
gcc_jit_context_new_rvalue_from_int(def->function_context,
@ -443,36 +460,39 @@ void ravi_emit_NEWARRAYINT(ravi_function_def_t *def, int A, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call3_rvalue(def, def->ravi->types->raviV_op_newarrayintT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->ci_val), ra));
gcc_jit_lvalue_as_rvalue(def->ci_val),
gcc_jit_lvalue_get_address(ra, NULL)));
}
void ravi_emit_NEWARRAYFLOAT(ravi_function_def_t *def, int A, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call3_rvalue(def, def->ravi->types->raviV_op_newarrayfloatT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->ci_val), ra));
gcc_jit_lvalue_as_rvalue(def->ci_val),
gcc_jit_lvalue_get_address(ra, NULL)));
}
void ravi_emit_SETLIST(ravi_function_def_t *def, int A, int B, int C, int pc) {
(void)pc;
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_block_add_eval(
def->current_block, NULL,
ravi_function_call5_rvalue(
def, def->ravi->types->raviV_op_setlistT,
gcc_jit_param_as_rvalue(def->L),
gcc_jit_lvalue_as_rvalue(def->ci_val), ra,
gcc_jit_lvalue_as_rvalue(def->ci_val),
gcc_jit_lvalue_get_address(ra, NULL),
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, B),
gcc_jit_context_new_rvalue_from_int(def->function_context,
@ -486,7 +506,7 @@ void ravi_emit_TOARRAY(ravi_function_def_t *def, int A, int array_type_expected,
// luaG_runerror(L, "integer[] expected");
ravi_emit_load_base(def);
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *type = ravi_emit_load_type(def, ra);
// type != LUA_TTABLE ?
@ -528,14 +548,14 @@ void ravi_emit_TOARRAY(ravi_function_def_t *def, int A, int array_type_expected,
void ravi_emit_MOVEAI(ravi_function_def_t *def, int A, int B, int pc) {
ravi_emit_TOARRAY(def, B, RAVI_TARRAYINT, "integer[] expected", pc);
gcc_jit_rvalue *src = ravi_emit_get_register(def, B);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
ravi_emit_struct_assign(def, dest, src);
}
void ravi_emit_MOVEAF(ravi_function_def_t *def, int A, int B, int pc) {
ravi_emit_TOARRAY(def, B, RAVI_TARRAYFLT, "number[] expected", pc);
gcc_jit_rvalue *src = ravi_emit_get_register(def, B);
gcc_jit_rvalue *dest = ravi_emit_get_register(def, A);
gcc_jit_lvalue *src = ravi_emit_get_register(def, B);
gcc_jit_lvalue *dest = ravi_emit_get_register(def, A);
ravi_emit_struct_assign(def, dest, src);
}

19
src/ravi_gcctforcall.c
Unescape View File

@ -52,12 +52,12 @@ void ravi_emit_TFORCALL(ravi_function_def_t *def, int A, int B, int C, int j,
ravi_emit_load_base(def);
// Get pointer to register A
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *ra1 = ravi_emit_get_register(def, A + 1);
gcc_jit_rvalue *ra2 = ravi_emit_get_register(def, A + 2);
gcc_jit_rvalue *cb = ravi_emit_get_register(def, A + 3);
gcc_jit_rvalue *cb1 = ravi_emit_get_register(def, A + 4);
gcc_jit_rvalue *cb2 = ravi_emit_get_register(def, A + 5);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra1 = ravi_emit_get_register(def, A + 1);
gcc_jit_lvalue *ra2 = ravi_emit_get_register(def, A + 2);
gcc_jit_lvalue *cb = ravi_emit_get_register(def, A + 3);
gcc_jit_lvalue *cb1 = ravi_emit_get_register(def, A + 4);
gcc_jit_lvalue *cb2 = ravi_emit_get_register(def, A + 5);
ravi_emit_struct_assign(def, cb2, ra2);
ravi_emit_struct_assign(def, cb1, ra1);
@ -71,7 +71,8 @@ void ravi_emit_TFORCALL(ravi_function_def_t *def, int A, int B, int C, int j,
def->current_block, NULL,
ravi_function_call4_rvalue(
def, def->ravi->types->luaD_callT, gcc_jit_param_as_rvalue(def->L),
cb, gcc_jit_context_new_rvalue_from_int(def->function_context,
gcc_jit_lvalue_get_address(cb, NULL),
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, C),
gcc_jit_context_new_rvalue_from_int(def->function_context,
def->ravi->types->C_intT, 1)));
@ -116,8 +117,8 @@ void ravi_emit_TFORLOOP(ravi_function_def_t *def, int A, int j, int pc) {
ravi_emit_load_base(def);
// Get pointer to register A
gcc_jit_rvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_rvalue *ra1 = ravi_emit_get_register(def, A + 1);
gcc_jit_lvalue *ra = ravi_emit_get_register(def, A);
gcc_jit_lvalue *ra1 = ravi_emit_get_register(def, A + 1);
gcc_jit_lvalue *type = ravi_emit_load_type(def, ra1);
// Test if type != LUA_TNIL (0)

Write Preview
Loading…
Cancel
Save