You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
982 lines
39 KiB
982 lines
39 KiB
/******************************************************************************
|
|
* Copyright (C) 2015-2020 Dibyendu Majumdar
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
******************************************************************************/
|
|
#include "ravi_llvmcodegen.h"
|
|
|
|
namespace ravi {
|
|
|
|
// R(A+1) := R(B); R(A) := R(B)[RK(C)]
|
|
void RaviCodeGenerator::emit_SELF(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// StkId rb = RB(i);
|
|
// setobjs2s(L, ra + 1, rb);
|
|
// Protect(luaV_gettable(L, rb, RKC(i), ra));
|
|
bool traced = emit_debug_trace(def, OP_SELF, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *ra1 = emit_gep_register(def, A + 1);
|
|
emit_assign(def, ra1, rb);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->luaV_gettableF, def->L, rb, rc, ra);
|
|
}
|
|
|
|
// R(A+1) := R(B); R(A) := R(B)[RK(C)]
|
|
void RaviCodeGenerator::emit_SELF_SK(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// StkId rb = RB(i);
|
|
// setobjs2s(L, ra + 1, rb);
|
|
// Protect(raviV_gettable_sskey(L, rb, RKC(i), ra));
|
|
bool traced = emit_debug_trace(def, OP_RAVI_SELF_SK, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *ra1 = emit_gep_register(def, A + 1);
|
|
emit_assign(def, ra1, rb);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_gettable_sskeyF, def->L, rb, rc, ra);
|
|
}
|
|
|
|
// R(A+1) := R(B); R(A) := R(B)[RK(C)]
|
|
void RaviCodeGenerator::emit_TABLE_SELF_SK(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc, TString *key) {
|
|
// StkId rb = RB(i);
|
|
// setobjs2s(L, ra + 1, rb);
|
|
// TValue *kv = k + INDEXK(GETARG_C(i));
|
|
// TString *key = tsvalue(kv);
|
|
// const TValue *v = luaH_getstr(hvalue(rb), key);
|
|
// setobj2s(L, ra, v);
|
|
emit_debug_trace(def, OP_RAVI_TABLE_SELF_SK, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *ra1 = emit_gep_register(def, A + 1);
|
|
emit_assign(def, ra1, rb);
|
|
emit_common_GETTABLE_S(def, A, B, C, key);
|
|
}
|
|
|
|
// R(A) := length of R(B)
|
|
void RaviCodeGenerator::emit_LEN(RaviFunctionDef *def, int A, int B, int pc) {
|
|
// Protect(luaV_objlen(L, ra, RB(i)));
|
|
bool traced = emit_debug_trace(def, OP_LEN, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
CreateCall3(def->builder, def->luaV_objlenF, def->L, ra, rb);
|
|
}
|
|
|
|
// R(A)[RK(B)] := RK(C)
|
|
// This is a more optimized version that calls
|
|
// luaH_setint() instead of luaV_settable().
|
|
// This relies on two things:
|
|
// a) we know we have a table
|
|
// b) we know the key is an integer
|
|
void RaviCodeGenerator::emit_SETI(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc) {
|
|
bool traced = emit_debug_trace(def, OP_RAVI_SETI, pc);
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register_or_constant(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_settable_iF, def->L, ra, rb, rc);
|
|
}
|
|
|
|
// R(A)[RK(B)] := RK(C)
|
|
void RaviCodeGenerator::emit_SETTABLE(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
|
|
bool traced = emit_debug_trace(def, OP_SETTABLE, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register_or_constant(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->luaV_settableF, def->L, ra, rb, rc);
|
|
}
|
|
|
|
// R(A)[RK(B)] := RK(C)
|
|
void RaviCodeGenerator::emit_SETFIELD(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc) {
|
|
// Protect(raviV_settable_sskey(L, ra, RKB(i), RKC(i)));
|
|
bool traced = emit_debug_trace(def, OP_RAVI_SETFIELD, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register_or_constant(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_settable_sskeyF, def->L, ra, rb, rc);
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
void RaviCodeGenerator::emit_GETTABLE(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// Protect(luaV_gettable(L, RB(i), RKC(i), ra));
|
|
bool traced = emit_debug_trace(def, OP_GETTABLE, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->luaV_gettableF, def->L, rb, rc, ra);
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
void RaviCodeGenerator::emit_GETFIELD(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc, TString *key) {
|
|
bool traced = emit_debug_trace(def, OP_RAVI_GETFIELD, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
#if 0
|
|
// Protect(raviV_gettable_sskey(L, RB(i), RKC(i), ra));
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_gettable_sskeyF, def->L, rb, rc, ra);
|
|
#else
|
|
llvm::Instruction *type = emit_load_type(def, rb);
|
|
|
|
// if table type try fast path
|
|
llvm::Value *cmp1 = emit_is_value_of_type(def, type, RAVI__TLTABLE,
|
|
"GETFIELD_is_table_type");
|
|
llvm::BasicBlock *is_table = llvm::BasicBlock::Create(
|
|
def->jitState->context(), "GETFIELD_is_table", def->f);
|
|
llvm::BasicBlock *not_table = llvm::BasicBlock::Create(
|
|
def->jitState->context(), "GETFIELD_is_not_table");
|
|
llvm::BasicBlock *done =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "GETFIELD_done");
|
|
auto brinst1 = def->builder->CreateCondBr(cmp1, is_table, not_table);
|
|
attach_branch_weights(def, brinst1, 100, 0);
|
|
def->builder->SetInsertPoint(is_table);
|
|
|
|
emit_common_GETTABLE_S_(def, A, rb, C, key);
|
|
|
|
def->builder->CreateBr(done);
|
|
|
|
def->f->getBasicBlockList().push_back(not_table);
|
|
def->builder->SetInsertPoint(not_table);
|
|
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_gettable_sskeyF, def->L, rb, rc, ra);
|
|
|
|
def->builder->CreateBr(done);
|
|
|
|
def->f->getBasicBlockList().push_back(done);
|
|
def->builder->SetInsertPoint(done);
|
|
#endif
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
// This is a more optimized version that attempts to do an inline
|
|
// array get first and only if that fails it falls back on calling
|
|
// luaH_getint(). This relies on two things:
|
|
// a) we know we have a table
|
|
// b) we know the key is an integer
|
|
void RaviCodeGenerator::emit_GETI(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc) {
|
|
// changed to that target may not be a table
|
|
bool traced = emit_debug_trace(def, OP_RAVI_GETI, pc);
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
CreateCall4(def->builder, def->raviV_gettable_iF, def->L, rb, rc, ra);
|
|
|
|
// FIXME following is no longer valid as RB may not be a table
|
|
|
|
// TValue *rb = RB(i);
|
|
// TValue *rc = RKC(i);
|
|
// lua_Integer idx = ivalue(rc);
|
|
// Table *t = hvalue(rb);
|
|
// const TValue *v;
|
|
// if (l_castS2U(idx - 1) < t->sizearray)
|
|
// v = &t->array[idx - 1];
|
|
// else
|
|
// v = luaH_getint(t, idx);
|
|
// if (!ttisnil(v) || metamethod_absent(t->metatable, TM_INDEX)) {
|
|
// setobj2s(L, ra, v);
|
|
//}
|
|
// else {
|
|
// Protect(luaV_finishget(L, rb, rc, ra, v));
|
|
//}
|
|
|
|
//emit_debug_trace(def, OP_RAVI_GETTABLE_I, pc);
|
|
//emit_load_base(def);
|
|
//llvm::Value *ra = emit_gep_register(def, A);
|
|
//llvm::Value *rb = emit_gep_register(def, B);
|
|
//llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
//llvm::Instruction *key = emit_load_reg_i(def, rc);
|
|
//llvm::Instruction *t = emit_load_reg_h(def, rb);
|
|
//llvm::Value *data = emit_table_get_array(def, t);
|
|
//llvm::Value *len = emit_table_get_arraysize(def, t);
|
|
//// As Lua arrays are 1 based we need to subtract by 1
|
|
//llvm::Value *key_minus_1 =
|
|
// def->builder->CreateSub(key, def->types->kluaInteger[1]);
|
|
//// As len is unsigned int we need to truncate
|
|
//llvm::Value *ukey =
|
|
// def->builder->CreateTrunc(key_minus_1, def->types->C_intT);
|
|
//// Do an unsigned comparison with length
|
|
//llvm::Value *cmp = def->builder->CreateICmpULT(ukey, len);
|
|
//llvm::BasicBlock *then_block =
|
|
// llvm::BasicBlock::Create(def->jitState->context(), "if.in.range", def->f);
|
|
//llvm::BasicBlock *else_block =
|
|
// llvm::BasicBlock::Create(def->jitState->context(), "if.not.in.range");
|
|
//llvm::BasicBlock *end_block =
|
|
// llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
//def->builder->CreateCondBr(cmp, then_block, else_block);
|
|
//def->builder->SetInsertPoint(then_block);
|
|
|
|
//// Key is in range so array access possible
|
|
//llvm::Value *value1 = def->builder->CreateGEP(data, ukey);
|
|
//def->builder->CreateBr(end_block);
|
|
|
|
//// Out of range so fall back to luaH_getint()
|
|
//def->f->getBasicBlockList().push_back(else_block);
|
|
//def->builder->SetInsertPoint(else_block);
|
|
//llvm::Value *value2 = CreateCall2(def->builder, def->luaH_getintF, t, key);
|
|
//def->builder->CreateBr(end_block);
|
|
|
|
//// Merge results from the two branches above
|
|
//def->f->getBasicBlockList().push_back(end_block);
|
|
//def->builder->SetInsertPoint(end_block);
|
|
//llvm::PHINode *phi = def->builder->CreatePHI(def->types->pTValueT, 2);
|
|
//phi->addIncoming(value1, then_block);
|
|
//phi->addIncoming(value2, else_block);
|
|
//emit_finish_GETTABLE(def, phi, t, ra, rb, rc);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_finish_GETTABLE(RaviFunctionDef *def,
|
|
llvm::Value *phi, llvm::Value *t,
|
|
llvm::Value *ra, llvm::Value *rb,
|
|
llvm::Value *rc) {
|
|
// We need to test if value is not nil
|
|
// or table has no metatable
|
|
// or if the metatable cached flags indicate metamethod absent
|
|
llvm::Value *value_type = emit_load_type(def, phi);
|
|
llvm::Value *isnotnil = emit_is_not_value_of_type(def, value_type, LUA__TNIL);
|
|
// llvm::Value *metamethod_absent = emit_table_no_metamethod(def, t,
|
|
// TM_INDEX);
|
|
// llvm::Value *cond = def->builder->CreateOr(isnotnil, metamethod_absent);
|
|
llvm::Value *cond = isnotnil;
|
|
|
|
llvm::BasicBlock *if_true_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.not.nil", def->f);
|
|
llvm::BasicBlock *if_false_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.try.metamethod");
|
|
llvm::BasicBlock *if_end_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
auto brinst1 =
|
|
def->builder->CreateCondBr(cond, if_true_block, if_false_block);
|
|
attach_branch_weights(def, brinst1, 100, 0);
|
|
def->builder->SetInsertPoint(if_true_block);
|
|
|
|
// Fast path
|
|
emit_assign(def, ra, phi);
|
|
def->builder->CreateBr(if_end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(if_false_block);
|
|
def->builder->SetInsertPoint(if_false_block);
|
|
|
|
// If value is nil Lua requires that an index event be
|
|
// generated - so we fall back on slow path for that
|
|
CreateCall5(def->builder, def->luaV_finishgetF, def->L, rb, rc, ra, phi);
|
|
def->builder->CreateBr(if_end_block);
|
|
|
|
// Merge results from the two branches above
|
|
def->f->getBasicBlockList().push_back(if_end_block);
|
|
def->builder->SetInsertPoint(if_end_block);
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
// Emit inline code for accessing a table element using a string key
|
|
// We try to access the element using the hash part but if the
|
|
// key is not in the main position then we fall back on luaH_getstr().
|
|
// IMPORTANT - this emitter should only be called when key is known to
|
|
// to be short string
|
|
// NOTE: To add support for GETTABUP_SK we now let caller supply the
|
|
// rb register as it may be a register or an upvalue reference
|
|
// See emit_GETTABUP_SK
|
|
void RaviCodeGenerator::emit_common_GETTABLE_S_(RaviFunctionDef *def, int A,
|
|
llvm::Value *rb, int C,
|
|
TString *key) {
|
|
// The code we want to generate is this:
|
|
// struct Node *n = hashstr(t, key);
|
|
// const struct TValue *k = gkey(n);
|
|
// TValue *v;
|
|
// if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
|
|
// v = gval(n);
|
|
// else
|
|
// v = luaH_getstr(t, key);
|
|
// if (!ttisnil(v) || metamethod_absent(t->metatable, TM_INDEX)) {
|
|
// setobj2s(L, ra, v);
|
|
// }
|
|
// else {
|
|
// Protect(luaV_finishget(L, rb, rc, ra, v));
|
|
// }
|
|
|
|
// A number of macros are involved above do the
|
|
// the generated code is somewhat more complex
|
|
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
|
|
// Get the hash table
|
|
llvm::Instruction *t = emit_load_reg_h(def, rb);
|
|
|
|
// Obtain the offset where the key should be
|
|
llvm::Value *offset = emit_table_get_hashstr(def, t, key);
|
|
|
|
// Get access to the node array
|
|
llvm::Value *node = emit_table_get_nodearray(def, t);
|
|
|
|
// Now we need to get to the right element in the node array
|
|
// and retrieve the type information which is held there
|
|
llvm::Value *ktype = emit_table_get_keytype(def, node, offset);
|
|
|
|
// We need to check that the key type is also short string
|
|
llvm::Value *is_shortstring =
|
|
emit_is_value_of_type(def, ktype, LUA__TSHRSTR, "is_shortstring");
|
|
llvm::BasicBlock *testkey =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "testkey");
|
|
llvm::BasicBlock *testok =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "testok");
|
|
llvm::BasicBlock *testfail =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "testfail");
|
|
llvm::BasicBlock *testend =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "testend");
|
|
auto brinst1 = def->builder->CreateCondBr(is_shortstring, testkey, testfail);
|
|
attach_branch_weights(def, brinst1, 100, 0);
|
|
|
|
// Now we need to compare the keys
|
|
def->f->getBasicBlockList().push_back(testkey);
|
|
def->builder->SetInsertPoint(testkey);
|
|
|
|
// Get the key from the node
|
|
llvm::Value *keyvalue = emit_table_get_strkey(def, node, offset);
|
|
|
|
// Cast the pointer to a intptr so we can compare
|
|
llvm::Value *intptr =
|
|
def->builder->CreatePtrToInt(keyvalue, def->types->C_intptr_t);
|
|
llvm::Value *ourptr =
|
|
llvm::ConstantInt::get(def->types->C_intptr_t, (intptr_t)key);
|
|
// Compare the two pointers
|
|
// If they match then we found the element
|
|
llvm::Value *same = def->builder->CreateICmpEQ(intptr, ourptr);
|
|
auto brinst2 = def->builder->CreateCondBr(same, testok, testfail);
|
|
attach_branch_weights(def, brinst2, 5, 2);
|
|
|
|
// If key found return the value
|
|
def->f->getBasicBlockList().push_back(testok);
|
|
def->builder->SetInsertPoint(testok);
|
|
// Get the value
|
|
llvm::Value *value1 = emit_table_get_value(def, node, offset);
|
|
llvm::Value *rc1 = emit_gep_register_or_constant(def, C);
|
|
def->builder->CreateBr(testend);
|
|
|
|
// Not found so call luaH_getstr
|
|
def->f->getBasicBlockList().push_back(testfail);
|
|
def->builder->SetInsertPoint(testfail);
|
|
llvm::Value *rc2 = emit_gep_register_or_constant(def, C);
|
|
llvm::Value *value2 = CreateCall2(def->builder, def->luaH_getstrF, t,
|
|
emit_load_reg_s(def, rc2));
|
|
def->builder->CreateBr(testend);
|
|
|
|
// merge
|
|
def->f->getBasicBlockList().push_back(testend);
|
|
def->builder->SetInsertPoint(testend);
|
|
llvm::PHINode *phi = def->builder->CreatePHI(def->types->pTValueT, 2);
|
|
phi->addIncoming(value1, testok);
|
|
phi->addIncoming(value2, testfail);
|
|
llvm::PHINode *phi2 = def->builder->CreatePHI(def->types->pTValueT, 2);
|
|
phi2->addIncoming(rc1, testok);
|
|
phi2->addIncoming(rc2, testfail);
|
|
emit_finish_GETTABLE(def, phi, t, ra, rb, phi2);
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
// Emit inline code for accessing a table element using a string key
|
|
// We try to access the element using the hash part but if the
|
|
// key is not in the main position then we fall back on luaH_getstr().
|
|
// IMPORTANT - this emitter should only be called when key is known to
|
|
// to be short string
|
|
void RaviCodeGenerator::emit_common_GETTABLE_S(RaviFunctionDef *def, int A,
|
|
int B, int C, TString *key) {
|
|
// The code we want to generate is this:
|
|
// struct Node *n = hashstr(t, key);
|
|
// const struct TValue *k = gkey(n);
|
|
// TValue *v;
|
|
// if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
|
|
// v = gval(n);
|
|
// else
|
|
// v = luaH_getstr(t, key);
|
|
// if (!ttisnil(v) || metamethod_absent(t->metatable, TM_INDEX)) {
|
|
// setobj2s(L, ra, v);
|
|
// }
|
|
// else {
|
|
// Protect(luaV_finishget(L, rb, rc, ra, v));
|
|
// }
|
|
|
|
// A number of macros are involved above do the
|
|
// the generated code is somewhat more complex
|
|
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
emit_common_GETTABLE_S_(def, A, rb, C, key);
|
|
}
|
|
|
|
// R(A) := R(B)[RK(C)]
|
|
// Emit inline code for accessing a table element using a string key
|
|
// We try to access the element using the hash part but if the
|
|
// key is not in the main position then we fall back on luaH_getstr().
|
|
// IMPORTANT - this emitter should only be called when key is known to
|
|
// to be short string
|
|
void RaviCodeGenerator::emit_GETTABLE_S(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc, TString *key) {
|
|
// The code we want to generate is this:
|
|
// struct Node *n = hashstr(t, key);
|
|
// const struct TValue *k = gkey(n);
|
|
// if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
|
|
// return gval(n);
|
|
// return luaH_getstr(t, key);
|
|
|
|
emit_debug_trace(def, OP_RAVI_TABLE_GETFIELD, pc);
|
|
emit_load_base(def);
|
|
emit_common_GETTABLE_S(def, A, B, C, key);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_FARRAY_GET(RaviFunctionDef *def, int A, int B,
|
|
int C, bool omitArrayGetRangeCheck,
|
|
int pc) {
|
|
//#define raviH_get_float_inline(L, t, key, v)
|
|
//{ unsigned ukey = (unsigned)((key));
|
|
// lua_Number *data = (lua_Number *)t->ravi_array.data;
|
|
// if (ukey < t->ravi_array.len) {
|
|
// setfltvalue(v, data[ukey]);
|
|
// }else
|
|
// luaG_runerror(L, "array out of bounds");
|
|
//}
|
|
|
|
// TValue *rb = RB(i);
|
|
// TValue *rc = RKC(i);
|
|
// lua_Integer idx = ivalue(rc);
|
|
// Table *t = hvalue(rb);
|
|
// raviH_get_float_inline(L, t, idx, ra);
|
|
|
|
emit_debug_trace(def, OP_RAVI_FARRAY_GET, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
llvm::Instruction *key = emit_load_reg_i(def, rc);
|
|
llvm::Instruction *t = emit_load_reg_h(def, rb);
|
|
llvm::Instruction *data = emit_load_reg_h_floatarray(def, t);
|
|
llvm::BasicBlock *then_block = nullptr;
|
|
llvm::BasicBlock *else_block = nullptr;
|
|
llvm::BasicBlock *end_block = nullptr;
|
|
if (!omitArrayGetRangeCheck) {
|
|
llvm::Instruction *len = emit_load_ravi_arraylength(def, t);
|
|
llvm::Value *ulen =
|
|
def->builder->CreateZExt(len, def->types->lua_UnsignedT, "ulen");
|
|
|
|
llvm::Value *cmp = def->builder->CreateICmpULT(key, ulen);
|
|
then_block = llvm::BasicBlock::Create(def->jitState->context(),
|
|
"if.in.range", def->f);
|
|
else_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.not.in.range");
|
|
end_block = llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
auto brinst1 = def->builder->CreateCondBr(cmp, then_block, else_block);
|
|
attach_branch_weights(def, brinst1, 100, 0);
|
|
def->builder->SetInsertPoint(then_block);
|
|
}
|
|
|
|
llvm::Value *ptr = def->builder->CreateGEP(data, key);
|
|
llvm::Instruction *value = def->builder->CreateLoad(ptr);
|
|
value->setMetadata(llvm::LLVMContext::MD_tbaa, def->types->tbaa_pdoubleT);
|
|
emit_store_reg_n_withtype(def, value, ra);
|
|
|
|
if (!omitArrayGetRangeCheck) {
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(else_block);
|
|
def->builder->SetInsertPoint(else_block);
|
|
|
|
emit_raise_lua_error(def, "array out of bounds");
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(end_block);
|
|
def->builder->SetInsertPoint(end_block);
|
|
}
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_IARRAY_GET(RaviFunctionDef *def, int A, int B,
|
|
int C, bool omitArrayGetRangeCheck,
|
|
int pc) {
|
|
//#define raviH_get_int_inline(L, t, key, v)
|
|
//{ unsigned ukey = (unsigned)((key));
|
|
// lua_Integer *data = (lua_Integer *)t->ravi_array.data;
|
|
// if (ukey < t->ravi_array.len) {
|
|
// setivalue(v, data[ukey]);
|
|
// } else
|
|
// luaG_runerror(L, "array out of bounds");
|
|
//}
|
|
|
|
// TValue *rb = RB(i);
|
|
// TValue *rc = RKC(i);
|
|
// lua_Integer idx = ivalue(rc);
|
|
// Table *t = hvalue(rb);
|
|
// raviH_get_int_inline(L, t, idx, ra);
|
|
|
|
emit_debug_trace(def, OP_RAVI_IARRAY_GET, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rb = emit_gep_register(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
llvm::Instruction *key = emit_load_reg_i(def, rc);
|
|
llvm::Instruction *t = emit_load_reg_h(def, rb);
|
|
llvm::Instruction *data = emit_load_reg_h_intarray(def, t);
|
|
|
|
llvm::BasicBlock *then_block = nullptr;
|
|
llvm::BasicBlock *else_block = nullptr;
|
|
llvm::BasicBlock *end_block = nullptr;
|
|
if (!omitArrayGetRangeCheck) {
|
|
llvm::Instruction *len = emit_load_ravi_arraylength(def, t);
|
|
llvm::Value *ulen =
|
|
def->builder->CreateZExt(len, def->types->lua_UnsignedT, "ulen");
|
|
|
|
llvm::Value *cmp = def->builder->CreateICmpULT(key, ulen);
|
|
then_block = llvm::BasicBlock::Create(def->jitState->context(),
|
|
"if.in.range", def->f);
|
|
else_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.not.in.range");
|
|
end_block = llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
auto brinst1 = def->builder->CreateCondBr(cmp, then_block, else_block);
|
|
attach_branch_weights(def, brinst1, 100, 0);
|
|
def->builder->SetInsertPoint(then_block);
|
|
}
|
|
|
|
llvm::Value *ptr = def->builder->CreateGEP(data, key);
|
|
llvm::Instruction *value = def->builder->CreateLoad(ptr);
|
|
value->setMetadata(llvm::LLVMContext::MD_tbaa, def->types->tbaa_plonglongT);
|
|
emit_store_reg_i_withtype(def, value, ra);
|
|
|
|
if (!omitArrayGetRangeCheck) {
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(else_block);
|
|
def->builder->SetInsertPoint(else_block);
|
|
|
|
emit_raise_lua_error(def, "array out of bounds");
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(end_block);
|
|
def->builder->SetInsertPoint(end_block);
|
|
}
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_IARRAY_SET(RaviFunctionDef *def, int A, int B,
|
|
int C, bool known_int, int pc) {
|
|
//#define raviH_set_int_inline(L, t, key, value)
|
|
//{ unsigned ukey = (unsigned)((key));
|
|
// lua_Integer *data = (lua_Integer *)t->ravi_array.data;
|
|
// if (ukey < t->ravi_array.len) {
|
|
// data[ukey] = value;
|
|
// } else
|
|
// raviH_set_int(L, t, ukey, value);
|
|
//}
|
|
|
|
// Table *t = hvalue(ra);
|
|
// TValue *rb = RKB(i);
|
|
// TValue *rc = RKC(i);
|
|
// lua_Integer idx = ivalue(rb);
|
|
// lua_Integer value = ivalue(rc);
|
|
// raviH_set_int_inline(L, t, idx, value);
|
|
|
|
emit_debug_trace(def, known_int ? OP_RAVI_IARRAY_SETI : OP_RAVI_IARRAY_SET,
|
|
pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
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 *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);
|
|
llvm::Value *ulen =
|
|
def->builder->CreateZExt(len, def->types->lua_UnsignedT, "ulen");
|
|
|
|
llvm::Value *cmp = def->builder->CreateICmpULT(key, ulen);
|
|
llvm::BasicBlock *then_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.in.range", def->f);
|
|
llvm::BasicBlock *else_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.not.in.range");
|
|
llvm::BasicBlock *end_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
def->builder->CreateCondBr(cmp, then_block, else_block);
|
|
def->builder->SetInsertPoint(then_block);
|
|
|
|
llvm::Value *ptr = def->builder->CreateGEP(data, key);
|
|
|
|
llvm::Instruction *storeinst = def->builder->CreateStore(value, ptr);
|
|
storeinst->setMetadata(llvm::LLVMContext::MD_tbaa,
|
|
def->types->tbaa_plonglongT);
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(else_block);
|
|
def->builder->SetInsertPoint(else_block);
|
|
|
|
CreateCall4(def->builder, def->raviH_set_intF, def->L, t, key, value);
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(end_block);
|
|
def->builder->SetInsertPoint(end_block);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_FARRAY_SET(RaviFunctionDef *def, int A, int B,
|
|
int C, bool known_float, int pc) {
|
|
//#define raviH_set_float_inline(L, t, key, value)
|
|
//{ unsigned ukey = (unsigned)((key));
|
|
// lua_Number *data = (lua_Number *)t->ravi_array.data;
|
|
// if (ukey < t->ravi_array.len) {
|
|
// data[ukey] = value;
|
|
// } else
|
|
// raviH_set_float(L, t, ukey, value);
|
|
// }
|
|
|
|
// Table *t = hvalue(ra);
|
|
// TValue *rb = RKB(i);
|
|
// TValue *rc = RKC(i);
|
|
// lua_Integer idx = ivalue(rb);
|
|
// if (ttisfloat(rc)) {
|
|
// raviH_set_float_inline(L, t, idx, fltvalue(rc));
|
|
//}
|
|
// else {
|
|
// raviH_set_float_inline(L, t, idx, ((lua_Number)ivalue(rc)));
|
|
//}
|
|
|
|
emit_debug_trace(
|
|
def, known_float ? OP_RAVI_FARRAY_SETF : OP_RAVI_FARRAY_SET, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
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 *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);
|
|
llvm::Value *ulen =
|
|
def->builder->CreateZExt(len, def->types->lua_UnsignedT, "ulen");
|
|
|
|
llvm::Value *cmp = def->builder->CreateICmpULT(key, ulen);
|
|
llvm::BasicBlock *then_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.in.range", def->f);
|
|
llvm::BasicBlock *else_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.not.in.range");
|
|
llvm::BasicBlock *end_block =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
def->builder->CreateCondBr(cmp, then_block, else_block);
|
|
def->builder->SetInsertPoint(then_block);
|
|
|
|
llvm::Value *ptr = def->builder->CreateGEP(data, key);
|
|
|
|
llvm::Instruction *storeinst = def->builder->CreateStore(value, ptr);
|
|
storeinst->setMetadata(llvm::LLVMContext::MD_tbaa, def->types->tbaa_pdoubleT);
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(else_block);
|
|
def->builder->SetInsertPoint(else_block);
|
|
|
|
CreateCall4(def->builder, def->raviH_set_floatF, def->L, t, key, value);
|
|
def->builder->CreateBr(end_block);
|
|
|
|
def->f->getBasicBlockList().push_back(end_block);
|
|
def->builder->SetInsertPoint(end_block);
|
|
}
|
|
|
|
// R(A) := UpValue[B]
|
|
void RaviCodeGenerator::emit_GETUPVAL(RaviFunctionDef *def, int A, int B,
|
|
int pc) {
|
|
// int b = GETARG_B(i);
|
|
// setobj2s(L, ra, cl->upvals[b]->v);
|
|
emit_debug_trace(def, OP_GETUPVAL, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, B);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
emit_assign(def, ra, v);
|
|
}
|
|
|
|
// UpValue[B] := R(A)
|
|
void RaviCodeGenerator::emit_SETUPVAL_Specific(RaviFunctionDef *def, int A,
|
|
int B, int pc, OpCode op,
|
|
llvm::Function *f) {
|
|
emit_debug_trace(def, op, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
CreateCall4(def->builder, f, def->L, def->p_LClosure, ra,
|
|
llvm::ConstantInt::get(def->types->C_intT, B));
|
|
}
|
|
|
|
// UpValue[B] := R(A)
|
|
void RaviCodeGenerator::emit_SETUPVAL(RaviFunctionDef *def, int A, int B,
|
|
int pc) {
|
|
// UpVal *uv = cl->upvals[GETARG_B(i)];
|
|
// setobj(L, uv->v, ra);
|
|
// luaC_upvalbarrier(L, uv);
|
|
|
|
emit_debug_trace(def, OP_SETUPVAL, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, B);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
emit_assign(def, v, ra);
|
|
|
|
llvm::Value *type = emit_load_type(def, v);
|
|
llvm::Value *is_collectible =
|
|
def->builder->CreateAnd(type,
|
|
llvm::ConstantInt::get(def->types->lua_LuaTypeT, BIT_ISCOLLECTABLE));
|
|
|
|
llvm::Value *value = emit_gep_upval_value(def, upval);
|
|
llvm::Value *cmp = def->builder->CreateICmpNE(v, value, "v.ne.value");
|
|
llvm::Value *tobool = def->builder->CreateICmpEQ(
|
|
is_collectible,
|
|
llvm::ConstantInt::get(def->types->lua_LuaTypeT, 0),
|
|
"not.collectible");
|
|
llvm::Value *orcond =
|
|
def->builder->CreateOr(cmp, tobool, "v.ne.value.or.not.collectible");
|
|
|
|
llvm::BasicBlock *then =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.then", def->f);
|
|
llvm::BasicBlock *end =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "if.end");
|
|
|
|
def->builder->CreateCondBr(orcond, end, then);
|
|
def->builder->SetInsertPoint(then);
|
|
|
|
CreateCall2(def->builder, def->luaC_upvalbarrierF, def->L, upval);
|
|
def->builder->CreateBr(end);
|
|
|
|
def->f->getBasicBlockList().push_back(end);
|
|
def->builder->SetInsertPoint(end);
|
|
}
|
|
|
|
// R(A) := UpValue[B][RK(C)]
|
|
void RaviCodeGenerator::emit_GETTABUP(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// int b = GETARG_B(i);
|
|
// Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra));
|
|
bool traced = emit_debug_trace(def, OP_GETTABUP, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, B);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
CreateCall4(def->builder, def->luaV_gettableF, def->L, v, rc, ra);
|
|
}
|
|
|
|
// R(A) := UpValue[B][RK(C)]
|
|
void RaviCodeGenerator::emit_GETTABUP_SK(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc) {
|
|
// int b = GETARG_B(i);
|
|
// Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra));
|
|
bool traced = emit_debug_trace(def, OP_RAVI_GETTABUP_SK, pc);
|
|
// Below may invoke metamethod so we set savedpc
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, B);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
CreateCall4(def->builder, def->raviV_gettable_sskeyF, def->L, v, rc, ra);
|
|
}
|
|
|
|
// UpValue[A][RK(B)] := RK(C)
|
|
void RaviCodeGenerator::emit_SETTABUP(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// int a = GETARG_A(i);
|
|
// Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i)));
|
|
|
|
bool traced = emit_debug_trace(def, OP_SETTABUP, pc);
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register_or_constant(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, A);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
CreateCall4(def->builder, def->luaV_settableF, def->L, v, rb, rc);
|
|
}
|
|
|
|
// UpValue[A][RK(B)] := RK(C)
|
|
void RaviCodeGenerator::emit_SETTABUP_SK(RaviFunctionDef *def, int A, int B,
|
|
int C, int pc) {
|
|
// int a = GETARG_A(i);
|
|
// Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i)));
|
|
|
|
bool traced = emit_debug_trace(def, OP_RAVI_SETFIELD, pc);
|
|
if (!traced) emit_update_savedpc(def, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *rb = emit_gep_register_or_constant(def, B);
|
|
llvm::Value *rc = emit_gep_register_or_constant(def, C);
|
|
|
|
llvm::Value *upval_ptr = emit_gep_upvals(def, A);
|
|
llvm::Instruction *upval = emit_load_pupval(def, upval_ptr);
|
|
llvm::Value *v = emit_load_upval_v(def, upval);
|
|
CreateCall4(def->builder, def->raviV_settable_sskeyF, def->L, v, rb, rc);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_NEWARRAYINT(RaviFunctionDef *def, int A, int pc) {
|
|
emit_debug_trace(def, OP_RAVI_NEW_IARRAY, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
CreateCall3(def->builder, def->raviV_op_newarrayintF, def->L, def->ci_val,
|
|
ra);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_NEWARRAYFLOAT(RaviFunctionDef *def, int A,
|
|
int pc) {
|
|
emit_debug_trace(def, OP_RAVI_NEW_FARRAY, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
CreateCall3(def->builder, def->raviV_op_newarrayfloatF, def->L, def->ci_val,
|
|
ra);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_NEWTABLE(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
// case OP_NEWTABLE: {
|
|
// int b = GETARG_B(i);
|
|
// int c = GETARG_C(i);
|
|
// Table *t = luaH_new(L);
|
|
// sethvalue(L, ra, t);
|
|
// if (b != 0 || c != 0)
|
|
// luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
|
|
// checkGC(L, ra + 1);
|
|
// } break;
|
|
|
|
emit_debug_trace(def, OP_NEWTABLE, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
CreateCall5(def->builder, def->raviV_op_newtableF, def->L, def->ci_val, ra,
|
|
def->types->kInt[B], def->types->kInt[C]);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_SETLIST(RaviFunctionDef *def, int A, int B, int C,
|
|
int pc) {
|
|
emit_debug_trace(def, OP_SETLIST, pc);
|
|
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,
|
|
def->types->kInt[B], def->types->kInt[C]);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_TOARRAY(RaviFunctionDef *def, int A,
|
|
int array_type_expected,
|
|
const char *errmsg, int pc) {
|
|
OpCode op = OP_RAVI_TOTAB;
|
|
LuaTypeCode expectedType = RAVI__TLTABLE;
|
|
switch (array_type_expected) {
|
|
case RAVI_TARRAYINT:
|
|
op = OP_RAVI_TOIARRAY;
|
|
expectedType = RAVI__TIARRAY;
|
|
break;
|
|
case RAVI_TARRAYFLT:
|
|
op = OP_RAVI_TOFARRAY;
|
|
expectedType = RAVI__TFARRAY;
|
|
break;
|
|
case RAVI_TTABLE:
|
|
default: break;
|
|
}
|
|
|
|
emit_debug_trace(def, op, pc);
|
|
emit_load_base(def);
|
|
llvm::Value *ra = emit_gep_register(def, A);
|
|
llvm::Instruction *type = emit_load_type(def, ra);
|
|
|
|
// type != expectedType
|
|
llvm::Value *cmp1 = emit_is_not_value_of_type(def, type, expectedType,
|
|
"is.not.expected.type");
|
|
llvm::BasicBlock *raise_error = llvm::BasicBlock::Create(
|
|
def->jitState->context(), "if.not.expected_type", def->f);
|
|
llvm::BasicBlock *done =
|
|
llvm::BasicBlock::Create(def->jitState->context(), "done");
|
|
auto brinst1 = def->builder->CreateCondBr(cmp1, raise_error, done);
|
|
attach_branch_weights(def, brinst1, 0, 100);
|
|
def->builder->SetInsertPoint(raise_error);
|
|
|
|
// Conversion failed, so raise error
|
|
emit_raise_lua_error(def, errmsg);
|
|
def->builder->CreateBr(done);
|
|
|
|
def->f->getBasicBlockList().push_back(done);
|
|
def->builder->SetInsertPoint(done);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_MOVEIARRAY(RaviFunctionDef *def, int A, int B,
|
|
int pc) {
|
|
emit_debug_trace(def, OP_RAVI_MOVEIARRAY, pc);
|
|
emit_TOARRAY(def, B, RAVI_TARRAYINT, "integer[] expected", pc);
|
|
llvm::Value *src = emit_gep_register(def, B);
|
|
llvm::Value *dest = emit_gep_register(def, A);
|
|
emit_assign(def, dest, src);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_MOVEFARRAY(RaviFunctionDef *def, int A, int B,
|
|
int pc) {
|
|
emit_debug_trace(def, OP_RAVI_MOVEFARRAY, pc);
|
|
emit_TOARRAY(def, B, RAVI_TARRAYFLT, "number[] expected", pc);
|
|
llvm::Value *src = emit_gep_register(def, B);
|
|
llvm::Value *dest = emit_gep_register(def, A);
|
|
emit_assign(def, dest, src);
|
|
}
|
|
|
|
void RaviCodeGenerator::emit_MOVETAB(RaviFunctionDef *def, int A, int B,
|
|
int pc) {
|
|
emit_debug_trace(def, OP_RAVI_MOVETAB, pc);
|
|
emit_TOARRAY(def, B, RAVI_TTABLE, "table expected", pc);
|
|
llvm::Value *src = emit_gep_register(def, B);
|
|
llvm::Value *dest = emit_gep_register(def, A);
|
|
emit_assign(def, dest, src);
|
|
}
|
|
}
|