LLVMValueRef gen_localdecl(compile_t* c, ast_t* ast)
{
ast_t* id = ast_child(ast);
ast_t* type = ast_type(id);
gentype_t g;
if(!gentype(c, type, &g))
return NULL;
// All alloca should happen in the entry block of a function.
LLVMBasicBlockRef this_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef entry_block = LLVMGetEntryBasicBlock(codegen_fun(c));
LLVMValueRef inst = LLVMGetFirstInstruction(entry_block);
if(inst != NULL)
LLVMPositionBuilderBefore(c->builder, inst);
else
LLVMPositionBuilderAtEnd(c->builder, entry_block);
const char* name = ast_name(id);
LLVMValueRef l_value = LLVMBuildAlloca(c->builder, g.use_type, name);
// Store the alloca to use when we reference this local.
codegen_setlocal(c, name, l_value);
// Emit debug info for local variable declaration.
dwarf_local(&c->dwarf, ast, g.type_name, entry_block, inst, l_value);
// Put the builder back where it was.
LLVMPositionBuilderAtEnd(c->builder, this_block);
return GEN_NOVALUE;
}
static void name_param(compile_t* c, reachable_type_t* t,
reachable_method_t* m, LLVMValueRef func, const char* name, unsigned index,
size_t line, size_t pos)
{
LLVMValueRef value = LLVMGetParam(func, index);
LLVMSetValueName(value, name);
LLVMValueRef alloc = LLVMBuildAlloca(c->builder, t->use_type, name);
LLVMBuildStore(c->builder, value, alloc);
codegen_setlocal(c, name, alloc);
LLVMMetadataRef info;
if(index == 0)
{
info = LLVMDIBuilderCreateArtificialVariable(c->di,
m->di_method, name, index + 1, m->di_file, (unsigned)ast_line(m->r_fun),
t->di_type);
} else {
info = LLVMDIBuilderCreateParameterVariable(c->di,
m->di_method, name, index + 1, m->di_file, (unsigned)ast_line(m->r_fun),
t->di_type);
}
LLVMMetadataRef expr = LLVMDIBuilderCreateExpression(c->di, NULL, 0);
LLVMDIBuilderInsertDeclare(c->di, alloc, info, expr,
(unsigned)line, (unsigned)pos, m->di_method,
LLVMGetInsertBlock(c->builder));
}
static void translateBlock(std::deque<llvm::MCInst>& block) {
typedef std::map<std::string, LLVMValueRef>::const_iterator ValRef;
std::map<std::string, LLVMValueRef> locals;
std::map<std::string, LLVMValueRef> regs;
for (InstIter it = block.begin(); it != block.end(); ++it) {
llvm::MCInst& inst = *it;
const llvm::MCInstrDesc& id = MII->get(inst.getOpcode());
llvm::StringRef iname = MII->getName(inst.getOpcode());
if (iname.startswith("MOV")) {
LLVMValueRef lhs;
unsigned iop = 0;
if (id.OpInfo[0].OperandType == llvm::MCOI::OPERAND_MEMORY) {
std::string localName = getLocalName(inst, 0);
ValRef pval = locals.find(localName);
if (pval == locals.end()) {
lhs = LLVMBuildAlloca(llvmBuilder, LLVMInt32Type(), localName.c_str());
locals[localName] = lhs;
} else {
lhs = pval->second;
}
if (id.OpInfo[5].OperandType == llvm::MCOI::OPERAND_IMMEDIATE) {
const llvm::MCOperand& op = inst.getOperand(5);
LLVMBuildStore(llvmBuilder, lhs, LLVMConstInt(LLVMInt32Type(), op.getImm(), 0));
}
if (id.OpInfo[5].OperandType == llvm::MCOI::OPERAND_REGISTER) {
LLVMBuildStore(llvmBuilder, lhs, regs[getRegName(inst, 5)]);
}
} else if (id.OpInfo[0].OperandType == llvm::MCOI::OPERAND_REGISTER) {
LLVMValueRef rhs;
printInst(inst);
if (id.OpInfo[1].OperandType == llvm::MCOI::OPERAND_IMMEDIATE) {
rhs = LLVMConstInt(LLVMInt32Type(), inst.getOperand(1).getImm(), 0);
} else if (id.OpInfo[1].OperandType == llvm::MCOI::OPERAND_MEMORY) {
ValRef pval = locals.find(getLocalName(inst, 1));
if (pval == locals.end()) {
llvm::outs() << "No such local " << getLocalName(inst, 1) << "\n";
break;
}
rhs = LLVMBuildLoad(llvmBuilder, pval->second, getRegName(inst, 0));
} else {
continue;
}
regs[getRegName(inst, 0)] = rhs;
}
}
}
}
LLVMValueRef gen_localdecl(compile_t* c, ast_t* ast)
{
ast_t* id = ast_child(ast);
const char* name = ast_name(id);
// If this local has already been generated, don't create another copy. This
// can happen when the same ast node is generated more than once, such as
// the condition block of a while expression.
LLVMValueRef value = codegen_getlocal(c, name);
if(value != NULL)
return GEN_NOVALUE;
ast_t* type = deferred_reify(c->frame->reify, ast_type(id), c->opt);
reach_type_t* t = reach_type(c->reach, type);
ast_free_unattached(type);
compile_type_t* c_t = (compile_type_t*)t->c_type;
// All alloca should happen in the entry block of a function.
LLVMBasicBlockRef this_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef entry_block = LLVMGetEntryBasicBlock(codegen_fun(c));
LLVMValueRef inst = LLVMGetFirstInstruction(entry_block);
if(inst != NULL)
LLVMPositionBuilderBefore(c->builder, inst);
else
LLVMPositionBuilderAtEnd(c->builder, entry_block);
LLVMValueRef alloc = LLVMBuildAlloca(c->builder, c_t->mem_type, name);
// Store the alloca to use when we reference this local.
codegen_setlocal(c, name, alloc);
LLVMMetadataRef file = codegen_difile(c);
LLVMMetadataRef scope = codegen_discope(c);
#if PONY_LLVM >= 700
uint32_t align_bytes = LLVMABIAlignmentOfType(c->target_data, c_t->mem_type);
LLVMMetadataRef info = LLVMDIBuilderCreateAutoVariable(c->di, scope,
name, strlen(name), file, (unsigned)ast_line(ast), c_t->di_type,
true, LLVMDIFlagZero, align_bytes * 8);
#else
LLVMMetadataRef info = LLVMDIBuilderCreateAutoVariable(c->di, scope, name,
file, (unsigned)ast_line(ast), c_t->di_type);
#endif
LLVMMetadataRef expr = LLVMDIBuilderCreateExpression(c->di, NULL, 0);
LLVMDIBuilderInsertDeclare(c->di, alloc, info, expr,
(unsigned)ast_line(ast), (unsigned)ast_pos(ast), scope,
LLVMGetInsertBlock(c->builder));
// Put the builder back where it was.
LLVMPositionBuilderAtEnd(c->builder, this_block);
return GEN_NOTNEEDED;
}
LLVMValueRef gen_init(struct node *ast)
{
LLVMValueRef var, array;
char *name;
int size;
name = ast->one->val;
var = LLVMBuildAlloca(builder, TYPE_INT, name);
if (ast->two) {
size = LLVMConstIntGetZExtValue(codegen(ast->two));
array = LLVMBuildAlloca(builder, TYPE_ARRAY(size), "");
LLVMBuildStore(builder, lvalue_to_rvalue(array), var);
}
symtab_enter(name, var);
return NULL;
}
SCM llvm_build_alloca(SCM scm_function, SCM scm_type)
{
SCM retval;
struct llvm_function_t *function = get_llvm_function(scm_function);
struct llvm_value_t *result = (struct llvm_value_t *)scm_gc_calloc(sizeof(struct llvm_value_t), "llvm value");
SCM_NEWSMOB(retval, llvm_value_tag, result);
int type = scm_to_int(scm_type);
result->value = LLVMBuildAlloca(function->builder, llvm_type(type), "x");
return retval;
}
static LLVMValueRef
translateFunCallExpr(SymbolTable *TyTable, SymbolTable *ValTable, ASTNode *Node) {
PtrVector *V = &(Node->Child);
ASTNode *ExprNode = (ASTNode*) ptrVectorGet(V, 0),
*ParamsNode = (ASTNode*) ptrVectorGet(V, 1);
LLVMTypeRef ReturnType = toTransitionType(getLLVMTypeFromType(TyTable, Node->Value)),
*ParamsType = NULL, FunctionType;
LLVMValueRef *ParamsValue = NULL;
unsigned Count = 0;
if (ParamsNode) {
ParamsValue = (LLVMValueRef*) malloc(sizeof(LLVMValueRef) * ParamsNode->Child.Size);
for (Count = 0; Count < ParamsNode->Child.Size; ++Count) {
LLVMValueRef ExprVal = translateExpr(TyTable, ValTable, ptrVectorGet(&(ParamsNode->Child), Count));
LLVMTypeRef ExprType = LLVMGetElementType(LLVMTypeOf(ExprVal));
switch (LLVMGetTypeKind(ExprType)) {
case LLVMIntegerTypeKind:
case LLVMFloatTypeKind:
case LLVMPointerTypeKind: ExprVal = LLVMBuildLoad(Builder, ExprVal, "load.4.call"); break;
default: break;
}
ParamsValue[Count] = ExprVal;
if (!ParamsType)
ParamsType = (LLVMTypeRef*) malloc(sizeof(LLVMTypeRef) * ParamsNode->Child.Size);
ParamsType[Count] = LLVMTypeOf(ExprVal);
}
}
FunctionType = LLVMFunctionType(ReturnType, ParamsType, Count, 0);
FunctionType = LLVMPointerType(FunctionType, 0);
LLVMValueRef Closure = translateExpr(TyTable, ValTable, ExprNode);
LLVMValueRef CallValue = callClosure(FunctionType, Closure, ParamsValue, Count);
switch (getLLVMValueTypeKind(CallValue)) {
case LLVMIntegerTypeKind:
case LLVMFloatTypeKind:
case LLVMPointerTypeKind:
{
if (getLLVMValueTypeKind(CallValue) == LLVMPointerTypeKind &&
getLLVMElementTypeKind(CallValue) == LLVMStructTypeKind)
break;
LLVMValueRef PtrMem = LLVMBuildAlloca(Builder, LLVMTypeOf(CallValue), "");
LLVMBuildStore(Builder, CallValue, PtrMem);
return PtrMem;
}
}
return CallValue;
}
static LLVMValueRef
translateStringLit(ASTNode *Node) {
int Length = strlen(Node->Value);
LLVMValueRef GlobVar = LLVMAddGlobal(Module, LLVMArrayType(LLVMInt8Type(), Length+1), "global.var");
LLVMSetInitializer(GlobVar, LLVMConstString(Node->Value, Length, 0));
LLVMValueRef LocalVar = LLVMBuildAlloca(Builder, LLVMArrayType(LLVMInt8Type(), Length+1), "local.string.");
LLVMValueRef LocalI8 = LLVMBuildBitCast(Builder, LocalVar, LLVMPointerType(LLVMInt8Type(), 0), "");
copyMemory(LocalI8, GlobVar, getSConstInt(Length+1));
return wrapValue(LocalI8);
}
LLVMValueRef
vm_value_alloca(struct vm_state *vm, struct vm_value *vmval)
{
const char *identifier = vmval->identifier;
if (identifier == NULL)
identifier = "";
vmval->llvm_value = LLVMBuildAlloca(vm->builder, vmval->llvm_type,
identifier);
return vmval->llvm_value;
}
static void name_param(compile_t* c, LLVMValueRef func, const char* name,
ast_t* type, int index)
{
gentype_t g;
gentype(c, type, &g);
LLVMValueRef param = LLVMGetParam(func, index);
LLVMSetValueName(param, name);
LLVMValueRef value = LLVMBuildAlloca(c->builder, g.use_type, name);
LLVMBuildStore(c->builder, param, value);
codegen_setlocal(c, name, value);
}
/**
* Like lp_build_alloca, but do not zero-initialize the variable.
*/
LLVMValueRef
lp_build_alloca_undef(struct gallivm_state *gallivm,
LLVMTypeRef type,
const char *name)
{
LLVMBuilderRef first_builder = create_builder_at_entry(gallivm);
LLVMValueRef res;
res = LLVMBuildAlloca(first_builder, type, name);
LLVMDisposeBuilder(first_builder);
return res;
}
static LLVMValueRef
translateArrayExpr(SymbolTable *TyTable, SymbolTable *ValTable, ASTNode *Node) {
PtrVector *V = &(Node->Child);
ASTNode *SizeNode = (ASTNode*) ptrVectorGet(V, 0),
*InitNode = (ASTNode*) ptrVectorGet(V, 1);
Type *ThisType = createType(IdTy, Node->Value);
LLVMTypeRef ArrayType = getLLVMTypeFromType(TyTable, ThisType);
LLVMValueRef SizeVal = translateExpr(TyTable, ValTable, SizeNode),
InitVal = translateExpr(TyTable, ValTable, InitNode);
LLVMValueRef ArrayVal = LLVMBuildArrayMalloc(Builder, ArrayType, SizeVal, "");
// This BasicBlock and ThisFunction
LLVMBasicBlockRef ThisBB = LLVMGetInsertBlock(Builder);
LLVMValueRef ThisFn = LLVMGetBasicBlockParent(ThisBB);
LLVMValueRef Counter = LLVMBuildAlloca(Builder, LLVMInt32Type(), "");
LLVMBuildStore(Builder, LLVMConstInt(LLVMInt32Type(), 0, 1), Counter);
LLVMTargetDataRef DataRef = LLVMCreateTargetData(LLVMGetDataLayout(Module));
unsigned long long Size = LLVMStoreSizeOfType(DataRef, ArrayType);
LLVMBasicBlockRef InitBB, MidBB, EndBB;
InitBB = LLVMAppendBasicBlock(ThisFn, "for.init");
EndBB = LLVMAppendBasicBlock(ThisFn, "for.end");
MidBB = LLVMAppendBasicBlock(ThisFn, "for.mid");
LLVMBuildBr(Builder, InitBB);
LLVMPositionBuilderAtEnd(Builder, InitBB);
LLVMValueRef CurrentCounter = LLVMBuildLoad(Builder, Counter, "");
LLVMValueRef Comparation = LLVMBuildICmp(Builder, LLVMIntSLT, CurrentCounter, SizeVal, "");
LLVMBuildCondBr(Builder, Comparation, MidBB, EndBB);
LLVMPositionBuilderAtEnd(Builder, MidBB);
CurrentCounter = LLVMBuildLoad(Builder, Counter, "");
LLVMValueRef TheValue = LLVMBuildLoad(Builder, InitVal, "");
LLVMValueRef ElemIdx[] = { LLVMConstInt(LLVMInt32Type(), 0, 1), CurrentCounter };
LLVMValueRef Elem = LLVMBuildInBoundsGEP(Builder, ArrayVal, ElemIdx, 2, "");
copyMemory(Elem, TheValue, getSConstInt(Size));
LLVMBuildBr(Builder, InitBB);
LLVMPositionBuilderAtEnd(Builder, EndBB);
return ArrayVal;
}
/**
* Allocate a scalar (or vector) variable.
*
* Although not strictly part of control flow, control flow has deep impact in
* how variables should be allocated.
*
* The mem2reg optimization pass is the recommended way to dealing with mutable
* variables, and SSA. It looks for allocas and if it can handle them, it
* promotes them, but only looks for alloca instructions in the entry block of
* the function. Being in the entry block guarantees that the alloca is only
* executed once, which makes analysis simpler.
*
* See also:
* - http://www.llvm.org/docs/tutorial/OCamlLangImpl7.html#memory
*/
LLVMValueRef
lp_build_alloca(struct gallivm_state *gallivm,
LLVMTypeRef type,
const char *name)
{
LLVMBuilderRef builder = gallivm->builder;
LLVMBuilderRef first_builder = create_builder_at_entry(gallivm);
LLVMValueRef res;
res = LLVMBuildAlloca(first_builder, type, name);
LLVMBuildStore(builder, LLVMConstNull(type), res);
LLVMDisposeBuilder(first_builder);
return res;
}
LLVMValueRef gen_localdecl(compile_t* c, ast_t* ast)
{
ast_t* id = ast_child(ast);
ast_t* type = ast_type(id);
const char* name = ast_name(id);
// If this local has already been generated, don't create another copy. This
// can happen when the same ast node is generated more than once, such as
// the condition block of a while expression.
LLVMValueRef value = codegen_getlocal(c, name);
if(value != NULL)
return GEN_NOVALUE;
reach_type_t* t = reach_type(c->reach, type);
// All alloca should happen in the entry block of a function.
LLVMBasicBlockRef this_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef entry_block = LLVMGetEntryBasicBlock(codegen_fun(c));
LLVMValueRef inst = LLVMGetFirstInstruction(entry_block);
if(inst != NULL)
LLVMPositionBuilderBefore(c->builder, inst);
else
LLVMPositionBuilderAtEnd(c->builder, entry_block);
LLVMValueRef alloc = LLVMBuildAlloca(c->builder, t->use_type, name);
// Store the alloca to use when we reference this local.
codegen_setlocal(c, name, alloc);
LLVMMetadataRef file = codegen_difile(c);
LLVMMetadataRef scope = codegen_discope(c);
LLVMMetadataRef info = LLVMDIBuilderCreateAutoVariable(c->di, scope, name,
file, (unsigned)ast_line(ast), t->di_type);
LLVMMetadataRef expr = LLVMDIBuilderCreateExpression(c->di, NULL, 0);
LLVMDIBuilderInsertDeclare(c->di, alloc, info, expr,
(unsigned)ast_line(ast), (unsigned)ast_pos(ast), scope,
LLVMGetInsertBlock(c->builder));
// Put the builder back where it was.
LLVMPositionBuilderAtEnd(c->builder, this_block);
return GEN_NOVALUE;
}
// Generates the allocas for the function arguments. This has to be called
// from the block since that is where the entry block is created.
//
// node - The function node.
// module - The compilation unit this node is a part of.
//
// Returns 0 if successful, otherwise returns -1.
int qip_ast_function_codegen_args(qip_ast_node *node, qip_module *module)
{
int rc;
unsigned int i;
check(node != NULL, "Node required");
check(node->type == QIP_AST_TYPE_FUNCTION, "Node type expected to be 'function'");
check(module != NULL, "Module required");
LLVMBuilderRef builder = module->compiler->llvm_builder;
LLVMContextRef context = LLVMGetModuleContext(module->llvm_module);
// Retrieve current function scope.
qip_scope *scope = NULL;
rc = qip_module_get_current_function_scope(module, &scope);
check(rc == 0 && scope != NULL, "Unable to retrieve current function scope");
// Codegen allocas.
LLVMValueRef *values = malloc(sizeof(LLVMValueRef) * node->function.arg_count);
check_mem(values);
for(i=0; i<node->function.arg_count; i++) {
rc = qip_ast_node_codegen(node->function.args[i], module, &values[i]);
check(rc == 0, "Unable to determine function argument type");
}
scope->llvm_last_alloca = LLVMBuildAlloca(builder, LLVMInt1TypeInContext(context), "nop");
// Codegen store instructions.
for(i=0; i<node->function.arg_count; i++) {
LLVMValueRef param = LLVMGetParam(scope->llvm_function, i);
LLVMValueRef build_value = LLVMBuildStore(builder, param, values[i]);
check(build_value != NULL, "Unable to create store instruction");
}
free(values);
return 0;
error:
if(values) free(values);
return -1;
}
LLVMValueRef gen_names(struct node *ast)
{
LLVMValueRef func, pam, var;
char *name;
func = LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder));
/* Pam param, pam pam param... */
for (pam = LLVMGetLastParam(func); pam; pam = LLVMGetPreviousParam(pam))
{
name = ast->one->val;
var = LLVMBuildAlloca(builder, TYPE_INT, name);
symtab_enter(name, var);
LLVMBuildStore(builder, pam, var);
ast = ast->two;
}
return NULL;
}
static void analyzeStackReferences(std::deque<llvm::MCInst>& block) {
for (InstIter it = block.begin(); it != block.end(); ++it) {
llvm::MCInst& inst = *it;
const llvm::MCInstrDesc& id = MII->get(inst.getOpcode());
llvm::StringRef iname = MII->getName(inst.getOpcode());
for (unsigned iop = 0; iop < inst.getNumOperands(); ++iop) {
if (id.OpInfo[iop].OperandType == llvm::MCOI::OPERAND_MEMORY) {
const llvm::MCOperand& op = inst.getOperand(iop);
if (op.isReg() && strcmp(MRI->getName(op.getReg()), "RBP") == 0) {
LLVMBuildAlloca(llvmBuilder, LLVMInt32Type(), "");
//printInst(inst);
}
iop += 5;
break;
}
}
}
}
/*
* Create a function that deforms a tuple of type desc up to natts columns.
*/
LLVMValueRef
slot_compile_deform(LLVMJitContext *context, TupleDesc desc, int natts)
{
char *funcname;
LLVMModuleRef mod;
LLVMBuilderRef b;
LLVMTypeRef deform_sig;
LLVMValueRef v_deform_fn;
LLVMBasicBlockRef b_entry;
LLVMBasicBlockRef b_adjust_unavail_cols;
LLVMBasicBlockRef b_find_start;
LLVMBasicBlockRef b_out;
LLVMBasicBlockRef b_dead;
LLVMBasicBlockRef *attcheckattnoblocks;
LLVMBasicBlockRef *attstartblocks;
LLVMBasicBlockRef *attisnullblocks;
LLVMBasicBlockRef *attcheckalignblocks;
LLVMBasicBlockRef *attalignblocks;
LLVMBasicBlockRef *attstoreblocks;
LLVMValueRef v_offp;
LLVMValueRef v_tupdata_base;
LLVMValueRef v_tts_values;
LLVMValueRef v_tts_nulls;
LLVMValueRef v_slotoffp;
LLVMValueRef v_slowp;
LLVMValueRef v_nvalidp;
LLVMValueRef v_nvalid;
LLVMValueRef v_maxatt;
LLVMValueRef v_slot;
LLVMValueRef v_tupleheaderp;
LLVMValueRef v_tuplep;
LLVMValueRef v_infomask1;
LLVMValueRef v_infomask2;
LLVMValueRef v_bits;
LLVMValueRef v_hoff;
LLVMValueRef v_hasnulls;
/* last column (0 indexed) guaranteed to exist */
int guaranteed_column_number = -1;
/* current known alignment */
int known_alignment = 0;
/* if true, known_alignment describes definite offset of column */
bool attguaranteedalign = true;
int attnum;
mod = llvm_mutable_module(context);
funcname = llvm_expand_funcname(context, "deform");
/*
* Check which columns do have to exist, so we don't have to check the
* rows natts unnecessarily.
*/
for (attnum = 0; attnum < desc->natts; attnum++)
{
Form_pg_attribute att = TupleDescAttr(desc, attnum);
/*
* If the column is possibly missing, we can't rely on its (or
* subsequent) NOT NULL constraints to indicate minimum attributes in
* the tuple, so stop here.
*/
if (att->atthasmissing)
break;
/*
* Column is NOT NULL and there've been no preceding missing columns,
* it's guaranteed that all columns up to here exist at least in the
* NULL bitmap.
*/
if (att->attnotnull)
guaranteed_column_number = attnum;
}
/* Create the signature and function */
{
LLVMTypeRef param_types[1];
param_types[0] = l_ptr(StructTupleTableSlot);
deform_sig = LLVMFunctionType(LLVMVoidType(), param_types,
lengthof(param_types), 0);
}
v_deform_fn = LLVMAddFunction(mod, funcname, deform_sig);
LLVMSetLinkage(v_deform_fn, LLVMInternalLinkage);
LLVMSetParamAlignment(LLVMGetParam(v_deform_fn, 0), MAXIMUM_ALIGNOF);
llvm_copy_attributes(AttributeTemplate, v_deform_fn);
b_entry =
LLVMAppendBasicBlock(v_deform_fn, "entry");
b_adjust_unavail_cols =
LLVMAppendBasicBlock(v_deform_fn, "adjust_unavail_cols");
b_find_start =
LLVMAppendBasicBlock(v_deform_fn, "find_startblock");
b_out =
LLVMAppendBasicBlock(v_deform_fn, "outblock");
b_dead =
LLVMAppendBasicBlock(v_deform_fn, "deadblock");
b = LLVMCreateBuilder();
attcheckattnoblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attstartblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attisnullblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attcheckalignblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attalignblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
attstoreblocks = palloc(sizeof(LLVMBasicBlockRef) * natts);
known_alignment = 0;
LLVMPositionBuilderAtEnd(b, b_entry);
/* perform allocas first, llvm only converts those to registers */
v_offp = LLVMBuildAlloca(b, TypeSizeT, "v_offp");
v_slot = LLVMGetParam(v_deform_fn, 0);
v_tts_values =
l_load_struct_gep(b, v_slot, FIELDNO_TUPLETABLESLOT_VALUES,
"tts_values");
v_tts_nulls =
l_load_struct_gep(b, v_slot, FIELDNO_TUPLETABLESLOT_ISNULL,
"tts_ISNULL");
v_slotoffp = LLVMBuildStructGEP(b, v_slot, FIELDNO_TUPLETABLESLOT_OFF, "");
v_slowp = LLVMBuildStructGEP(b, v_slot, FIELDNO_TUPLETABLESLOT_SLOW, "");
v_nvalidp = LLVMBuildStructGEP(b, v_slot, FIELDNO_TUPLETABLESLOT_NVALID, "");
v_tupleheaderp =
l_load_struct_gep(b, v_slot, FIELDNO_TUPLETABLESLOT_TUPLE,
"tupleheader");
v_tuplep =
l_load_struct_gep(b, v_tupleheaderp, FIELDNO_HEAPTUPLEDATA_DATA,
"tuple");
v_bits =
LLVMBuildBitCast(b,
LLVMBuildStructGEP(b, v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_BITS,
""),
l_ptr(LLVMInt8Type()),
"t_bits");
v_infomask1 =
l_load_struct_gep(b, v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK,
"infomask1");
v_infomask2 =
l_load_struct_gep(b,
v_tuplep, FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2,
"infomask2");
/* t_infomask & HEAP_HASNULL */
v_hasnulls =
LLVMBuildICmp(b, LLVMIntNE,
LLVMBuildAnd(b,
l_int16_const(HEAP_HASNULL),
v_infomask1, ""),
l_int16_const(0),
"hasnulls");
/* t_infomask2 & HEAP_NATTS_MASK */
v_maxatt = LLVMBuildAnd(b,
l_int16_const(HEAP_NATTS_MASK),
v_infomask2,
"maxatt");
v_hoff =
l_load_struct_gep(b, v_tuplep,
FIELDNO_HEAPTUPLEHEADERDATA_HOFF,
"t_hoff");
v_tupdata_base =
LLVMBuildGEP(b,
LLVMBuildBitCast(b,
v_tuplep,
l_ptr(LLVMInt8Type()),
""),
&v_hoff, 1,
"v_tupdata_base");
/*
* Load tuple start offset from slot. Will be reset below in case there's
* no existing deformed columns in slot.
*/
{
LLVMValueRef v_off_start;
v_off_start = LLVMBuildLoad(b, v_slotoffp, "v_slot_off");
v_off_start = LLVMBuildZExt(b, v_off_start, TypeSizeT, "");
LLVMBuildStore(b, v_off_start, v_offp);
}
/* build the basic block for each attribute, need them as jump target */
for (attnum = 0; attnum < natts; attnum++)
{
attcheckattnoblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.attcheckattno", attnum);
attstartblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.start", attnum);
attisnullblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.attisnull", attnum);
attcheckalignblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.attcheckalign", attnum);
attalignblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.align", attnum);
attstoreblocks[attnum] =
l_bb_append_v(v_deform_fn, "block.attr.%d.store", attnum);
}
/*
* Check if's guaranteed the all the desired attributes are available in
* tuple. If so, we can start deforming. If not, need to make sure to
* fetch the missing columns.
*/
if ((natts - 1) <= guaranteed_column_number)
{
/* just skip through unnecessary blocks */
LLVMBuildBr(b, b_adjust_unavail_cols);
LLVMPositionBuilderAtEnd(b, b_adjust_unavail_cols);
LLVMBuildBr(b, b_find_start);
}
else
{
LLVMValueRef v_params[3];
/* branch if not all columns available */
LLVMBuildCondBr(b,
LLVMBuildICmp(b, LLVMIntULT,
v_maxatt,
l_int16_const(natts),
""),
b_adjust_unavail_cols,
b_find_start);
/* if not, memset tts_isnull of relevant cols to true */
LLVMPositionBuilderAtEnd(b, b_adjust_unavail_cols);
v_params[0] = v_slot;
v_params[1] = LLVMBuildZExt(b, v_maxatt, LLVMInt32Type(), "");
v_params[2] = l_int32_const(natts);
LLVMBuildCall(b, llvm_get_decl(mod, FuncSlotGetmissingattrs),
v_params, lengthof(v_params), "");
LLVMBuildBr(b, b_find_start);
}
LLVMPositionBuilderAtEnd(b, b_find_start);
v_nvalid = LLVMBuildLoad(b, v_nvalidp, "");
/*
* Build switch to go from nvalid to the right startblock. Callers
* currently don't have the knowledge, but it'd be good for performance to
* avoid this check when it's known that the slot is empty (e.g. in scan
* nodes).
*/
if (true)
{
LLVMValueRef v_switch = LLVMBuildSwitch(b, v_nvalid,
b_dead, natts);
for (attnum = 0; attnum < natts; attnum++)
{
LLVMValueRef v_attno = l_int32_const(attnum);
LLVMAddCase(v_switch, v_attno, attcheckattnoblocks[attnum]);
}
}
else
{
/* jump from entry block to first block */
LLVMBuildBr(b, attcheckattnoblocks[0]);
}
LLVMPositionBuilderAtEnd(b, b_dead);
LLVMBuildUnreachable(b);
/*
* Iterate over each attribute that needs to be deformed, build code to
* deform it.
*/
for (attnum = 0; attnum < natts; attnum++)
{
Form_pg_attribute att = TupleDescAttr(desc, attnum);
LLVMValueRef v_incby;
int alignto;
LLVMValueRef l_attno = l_int16_const(attnum);
LLVMValueRef v_attdatap;
LLVMValueRef v_resultp;
/* build block checking whether we did all the necessary attributes */
LLVMPositionBuilderAtEnd(b, attcheckattnoblocks[attnum]);
/*
* If this is the first attribute, slot->tts_nvalid was 0. Therefore
* reset offset to 0 to, it be from a previous execution.
*/
if (attnum == 0)
{
LLVMBuildStore(b, l_sizet_const(0), v_offp);
}
/*
* Build check whether column is available (i.e. whether the tuple has
* that many columns stored). We can avoid the branch if we know
* there's a subsequent NOT NULL column.
*/
if (attnum <= guaranteed_column_number)
{
LLVMBuildBr(b, attstartblocks[attnum]);
}
else
{
LLVMValueRef v_islast;
v_islast = LLVMBuildICmp(b, LLVMIntUGE,
l_attno,
v_maxatt,
"heap_natts");
LLVMBuildCondBr(b, v_islast, b_out, attstartblocks[attnum]);
}
LLVMPositionBuilderAtEnd(b, attstartblocks[attnum]);
/*
* Check for nulls if necessary. No need to take missing attributes
* into account, because in case they're present the heaptuple's natts
* would have indicated that a slot_getmissingattrs() is needed.
*/
if (!att->attnotnull)
{
LLVMBasicBlockRef b_ifnotnull;
LLVMBasicBlockRef b_ifnull;
LLVMBasicBlockRef b_next;
LLVMValueRef v_attisnull;
LLVMValueRef v_nullbyteno;
LLVMValueRef v_nullbytemask;
LLVMValueRef v_nullbyte;
LLVMValueRef v_nullbit;
b_ifnotnull = attcheckalignblocks[attnum];
b_ifnull = attisnullblocks[attnum];
if (attnum + 1 == natts)
b_next = b_out;
else
b_next = attcheckattnoblocks[attnum + 1];
v_nullbyteno = l_int32_const(attnum >> 3);
v_nullbytemask = l_int8_const(1 << ((attnum) & 0x07));
v_nullbyte = l_load_gep1(b, v_bits, v_nullbyteno, "attnullbyte");
v_nullbit = LLVMBuildICmp(b,
LLVMIntEQ,
LLVMBuildAnd(b, v_nullbyte, v_nullbytemask, ""),
l_int8_const(0),
"attisnull");
v_attisnull = LLVMBuildAnd(b, v_hasnulls, v_nullbit, "");
LLVMBuildCondBr(b, v_attisnull, b_ifnull, b_ifnotnull);
LLVMPositionBuilderAtEnd(b, b_ifnull);
/* store null-byte */
LLVMBuildStore(b,
l_int8_const(1),
LLVMBuildGEP(b, v_tts_nulls, &l_attno, 1, ""));
/* store zero datum */
LLVMBuildStore(b,
l_sizet_const(0),
LLVMBuildGEP(b, v_tts_values, &l_attno, 1, ""));
LLVMBuildBr(b, b_next);
attguaranteedalign = false;
}
else
{
LLVMValueRef gen_funcdef(struct node *ast)
{
LLVMValueRef global, func, retval;
LLVMTypeRef func_type, *param_types;
LLVMBasicBlockRef body_block, ret_block;
int param_count, i;
if (hcreate(SYMTAB_SIZE) == 0)
generror(">s");
param_count = count_chain(ast->two);
param_types = calloc(sizeof(LLVMTypeRef), param_count);
if (param_count > 0 && param_types == NULL)
generror("out of memory");
for (i = 0; i < param_count; i++)
param_types[i] = TYPE_INT;
func_type = LLVMFunctionType(TYPE_INT, param_types, param_count, 0);
func = LLVMAddFunction(module, ".gfunc", func_type);
LLVMSetLinkage(func, LLVMPrivateLinkage);
/* TODO: How to specify stack alignment? Should be 16 bytes */
LLVMAddFunctionAttr(func, LLVMStackAlignment);
global = find_or_add_global(ast->one->val);
LLVMSetInitializer(global, LLVMBuildPtrToInt(builder, func, TYPE_INT, ""));
body_block = LLVMAppendBasicBlock(func, "");
ret_block = LLVMAppendBasicBlock(func, "");
LLVMPositionBuilderAtEnd(builder, body_block);
retval = LLVMBuildAlloca(builder, TYPE_INT, "");
LLVMBuildStore(builder, CONST(0), retval);
symtab_enter(ast->one->val, global);
symtab_enter(".return", ret_block);
symtab_enter(".retval", retval);
label_count = 0;
predeclare_labels(ast->three);
if (ast->two)
codegen(ast->two);
codegen(ast->three);
LLVMBuildBr(builder, ret_block);
/* TODO: Untangle out-of-order blocks */
LLVMPositionBuilderAtEnd(builder, ret_block);
LLVMBuildRet(builder, LLVMBuildLoad(builder, retval, ""));
LLVMMoveBasicBlockAfter(ret_block, LLVMGetLastBasicBlock(func));
/* TODO: Handle failed verification and print internal compiler error */
LLVMVerifyFunction(func, LLVMPrintMessageAction);
hdestroy();
return NULL;
}
struct cl2llvm_val_t *llvm_type_cast(struct cl2llvm_val_t * original_val,
struct cl2llvmTypeWrap *totype_w_sign)
{
struct cl2llvm_val_t *llvm_val = cl2llvm_val_create();
int i;
struct cl2llvmTypeWrap *elem_type;
struct cl2llvm_val_t *cast_original_val;
LLVMValueRef index;
LLVMValueRef vector_addr;
LLVMValueRef vector;
LLVMValueRef const_elems[16];
LLVMTypeRef fromtype = cl2llvmTypeWrapGetLlvmType(original_val->type);
LLVMTypeRef totype = cl2llvmTypeWrapGetLlvmType(totype_w_sign);
int fromsign = cl2llvmTypeWrapGetSign(original_val->type);
int tosign = cl2llvmTypeWrapGetSign(totype_w_sign);
/*By default the return value is the same as the original_val*/
llvm_val->val = original_val->val;
cl2llvmTypeWrapSetLlvmType(llvm_val->type, cl2llvmTypeWrapGetLlvmType(original_val->type));
cl2llvmTypeWrapSetSign(llvm_val->type, cl2llvmTypeWrapGetSign(original_val->type));
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
/* Check that fromtype is not a vector, unless both types are identical. */
if (LLVMGetTypeKind(fromtype) == LLVMVectorTypeKind)
{
if ((LLVMGetVectorSize(fromtype) != LLVMGetVectorSize(totype)
|| LLVMGetElementType(fromtype)
!= LLVMGetElementType(totype))
|| fromsign != tosign)
{
if (LLVMGetTypeKind(totype) == LLVMVectorTypeKind)
cl2llvm_yyerror("Casts between vector types are forbidden");
cl2llvm_yyerror("A vector may not be cast to any other type.");
}
}
/* If totype is a vector, create a vector whose components are equal to
original_val */
if (LLVMGetTypeKind(totype) == LLVMVectorTypeKind
&& LLVMGetTypeKind(fromtype) != LLVMVectorTypeKind)
{
/*Go to entry block and declare vector*/
LLVMPositionBuilder(cl2llvm_builder, cl2llvm_current_function->entry_block,
cl2llvm_current_function->branch_instr);
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector_addr = LLVMBuildAlloca(cl2llvm_builder,
totype, temp_var_name);
LLVMPositionBuilderAtEnd(cl2llvm_builder, current_basic_block);
/* Load vector */
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector = LLVMBuildLoad(cl2llvm_builder, vector_addr, temp_var_name);
/* Create object to represent element type of totype */
elem_type = cl2llvmTypeWrapCreate(LLVMGetElementType(totype), tosign);
/* If original_val is constant create a constant vector */
if (LLVMIsConstant(original_val->val))
{
cast_original_val = llvm_type_cast(original_val, elem_type);
for (i = 0; i < LLVMGetVectorSize(totype); i++)
const_elems[i] = cast_original_val->val;
vector = LLVMConstVector(const_elems,
LLVMGetVectorSize(totype));
llvm_val->val = vector;
cl2llvm_val_free(cast_original_val);
}
/* If original value is not constant insert elements */
else
{
for (i = 0; i < LLVMGetVectorSize(totype); i++)
{
index = LLVMConstInt(LLVMInt32Type(), i, 0);
cast_original_val = llvm_type_cast(original_val, elem_type);
snprintf(temp_var_name, sizeof temp_var_name,
"tmp_%d", temp_var_count++);
vector = LLVMBuildInsertElement(cl2llvm_builder,
vector, cast_original_val->val, index, temp_var_name);
cl2llvm_val_free(cast_original_val);
}
}
cl2llvmTypeWrapFree(elem_type);
llvm_val->val = vector;
}
if (fromtype == LLVMInt64Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt32Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt16Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt8Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildTrunc(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
}
else if (fromtype == LLVMInt1Type())
{
if (totype == LLVMDoubleType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMDoubleType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMFloatType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
if (fromsign)
{
llvm_val->val =
LLVMBuildSIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
else
{
llvm_val->val =
LLVMBuildUIToFP(cl2llvm_builder,
original_val->val, LLVMHalfType(),
temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMInt64Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt64Type(),
temp_var_name);
}
if (tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt32Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt32Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt16Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt16Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt8Type())
{
if (fromsign)
{
llvm_val->val = LLVMBuildSExt(cl2llvm_builder,
original_val->val, LLVMInt8Type(),
temp_var_name);
}
else
{
llvm_val->val = LLVMBuildZExt(cl2llvm_builder,
original_val->val, LLVMInt8Type(),
temp_var_name);
}
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMInt1Type())
{
if(tosign)
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
else
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
temp_var_count--;
}
}
/*We now know that from type must be a floating point.*/
/*Floating point to signed integer conversions*/
else if (tosign && LLVMGetTypeKind(totype) == 8)
{
if (totype == LLVMInt64Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt64Type(), temp_var_name);
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildFPToSI(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
/*Floating point to unsigned integer conversions*/
else if (!tosign)
{
if (totype == LLVMInt64Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt64Type(), temp_var_name);
}
else if (totype == LLVMInt32Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt32Type(), temp_var_name);
}
else if (totype == LLVMInt16Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt16Type(), temp_var_name);
}
else if (totype == LLVMInt8Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt8Type(), temp_var_name);
}
else if (totype == LLVMInt1Type())
{
llvm_val->val = LLVMBuildFPToUI(cl2llvm_builder,
original_val->val, LLVMInt1Type(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 0);
}
else if (totype == LLVMDoubleType())
{
llvm_val->val = LLVMBuildFPExt(cl2llvm_builder,
original_val->val, LLVMDoubleType(), temp_var_name);
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMFloatType())
{
if (fromtype == LLVMDoubleType())
{
llvm_val->val = LLVMBuildFPTrunc(cl2llvm_builder,
original_val->val, LLVMFloatType(), temp_var_name);
}
else if (fromtype == LLVMHalfType())
{
llvm_val->val = LLVMBuildFPExt(cl2llvm_builder,
original_val->val, LLVMFloatType(), temp_var_name);
}
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
else if (totype == LLVMHalfType())
{
llvm_val->val = LLVMBuildFPTrunc(cl2llvm_builder,
original_val->val, LLVMHalfType(), temp_var_name);
cl2llvmTypeWrapSetSign(llvm_val->type, 1);
}
cl2llvmTypeWrapSetLlvmType(llvm_val->type, totype);
cl2llvmTypeWrapSetSign(llvm_val->type, tosign);
return llvm_val;
}
static LLVMValueRef
translateFloatLit(ASTNode *Node) {
LLVMValueRef Container = LLVMBuildAlloca(Builder, LLVMFloatType(), "");
LLVMBuildStore(Builder, LLVMConstReal(LLVMFloatType(), *((float*)Node->Value)), Container);
return Container;
}
static LLVMValueRef
translateIntLit(ASTNode *Node) {
LLVMValueRef Container = LLVMBuildAlloca(Builder, LLVMInt32Type(), "");
LLVMBuildStore(Builder, getSConstInt(*((int*)Node->Value)), Container);
return Container;
}
void genprim_array_serialise(compile_t* c, reach_type_t* t)
{
// Generate the serialise function.
t->serialise_fn = codegen_addfun(c, genname_serialise(t->name),
c->serialise_type);
codegen_startfun(c, t->serialise_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->serialise_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(t->serialise_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->serialise_fn, 1);
LLVMValueRef addr = LLVMGetParam(t->serialise_fn, 2);
LLVMValueRef offset = LLVMGetParam(t->serialise_fn, 3);
LLVMValueRef mut = LLVMGetParam(t->serialise_fn, 4);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"");
LLVMValueRef offset_addr = LLVMBuildAdd(c->builder,
LLVMBuildPtrToInt(c->builder, addr, c->intptr, ""), offset, "");
genserialise_typeid(c, t, offset_addr);
// Don't serialise our contents if we are opaque.
LLVMBasicBlockRef body_block = codegen_block(c, "body");
LLVMBasicBlockRef post_block = codegen_block(c, "post");
LLVMValueRef test = LLVMBuildICmp(c->builder, LLVMIntNE, mut,
LLVMConstInt(c->i32, PONY_TRACE_OPAQUE, false), "");
LLVMBuildCondBr(c->builder, test, body_block, post_block);
LLVMPositionBuilderAtEnd(c->builder, body_block);
// Write the size twice, effectively rewriting alloc to be the same as size.
LLVMValueRef size = field_value(c, object, 1);
LLVMValueRef size_loc = field_loc(c, offset_addr, t->structure,
c->intptr, 1);
LLVMBuildStore(c->builder, size, size_loc);
LLVMValueRef alloc_loc = field_loc(c, offset_addr, t->structure,
c->intptr, 2);
LLVMBuildStore(c->builder, size, alloc_loc);
// Write the pointer.
LLVMValueRef ptr = field_value(c, object, 3);
// The resulting offset will only be invalid (i.e. have the high bit set) if
// the size is zero. For an opaque array, we don't serialise the contents,
// so we don't get here, so we don't end up with an invalid offset.
LLVMValueRef args[5];
args[0] = ctx;
args[1] = ptr;
LLVMValueRef ptr_offset = gencall_runtime(c, "pony_serialise_offset",
args, 2, "");
LLVMValueRef ptr_loc = field_loc(c, offset_addr, t->structure, c->intptr, 3);
LLVMBuildStore(c->builder, ptr_offset, ptr_loc);
LLVMValueRef ptr_offset_addr = LLVMBuildAdd(c->builder, ptr_offset,
LLVMBuildPtrToInt(c->builder, addr, c->intptr, ""), "");
// Serialise elements.
ast_t* typeargs = ast_childidx(t->ast, 2);
ast_t* typearg = ast_child(typeargs);
reach_type_t* t_elem = reach_type(c->reach, typearg);
size_t abisize = (size_t)LLVMABISizeOfType(c->target_data, t_elem->use_type);
LLVMValueRef l_size = LLVMConstInt(c->intptr, abisize, false);
if((t_elem->underlying == TK_PRIMITIVE) && (t_elem->primitive != NULL))
{
// memcpy machine words
args[0] = LLVMBuildIntToPtr(c->builder, ptr_offset_addr, c->void_ptr, "");
args[1] = LLVMBuildBitCast(c->builder, ptr, c->void_ptr, "");
args[2] = LLVMBuildMul(c->builder, size, l_size, "");
args[3] = LLVMConstInt(c->i32, 1, false);
args[4] = LLVMConstInt(c->i1, 0, false);
if(target_is_ilp32(c->opt->triple))
{
gencall_runtime(c, "llvm.memcpy.p0i8.p0i8.i32", args, 5, "");
} else {
gencall_runtime(c, "llvm.memcpy.p0i8.p0i8.i64", args, 5, "");
}
} else {
ptr = LLVMBuildBitCast(c->builder, ptr,
LLVMPointerType(t_elem->use_type, 0), "");
LLVMBasicBlockRef entry_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef cond_block = codegen_block(c, "cond");
LLVMBasicBlockRef body_block = codegen_block(c, "body");
LLVMBasicBlockRef post_block = codegen_block(c, "post");
LLVMValueRef offset_var = LLVMBuildAlloca(c->builder, c->intptr, "");
LLVMBuildStore(c->builder, ptr_offset_addr, offset_var);
LLVMBuildBr(c->builder, cond_block);
// While the index is less than the size, serialise an element. The
// initial index when coming from the entry block is zero.
LLVMPositionBuilderAtEnd(c->builder, cond_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->intptr, "");
LLVMValueRef zero = LLVMConstInt(c->intptr, 0, false);
LLVMAddIncoming(phi, &zero, &entry_block, 1);
LLVMValueRef test = LLVMBuildICmp(c->builder, LLVMIntULT, phi, size, "");
LLVMBuildCondBr(c->builder, test, body_block, post_block);
// The phi node is the index. Get the element and serialise it.
LLVMPositionBuilderAtEnd(c->builder, body_block);
LLVMValueRef elem_ptr = LLVMBuildGEP(c->builder, ptr, &phi, 1, "");
ptr_offset_addr = LLVMBuildLoad(c->builder, offset_var, "");
genserialise_element(c, t_elem, false, ctx, elem_ptr, ptr_offset_addr);
ptr_offset_addr = LLVMBuildAdd(c->builder, ptr_offset_addr, l_size, "");
LLVMBuildStore(c->builder, ptr_offset_addr, offset_var);
// Add one to the phi node and branch back to the cond block.
LLVMValueRef one = LLVMConstInt(c->intptr, 1, false);
LLVMValueRef inc = LLVMBuildAdd(c->builder, phi, one, "");
body_block = LLVMGetInsertBlock(c->builder);
LLVMAddIncoming(phi, &inc, &body_block, 1);
LLVMBuildBr(c->builder, cond_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
}
LLVMBuildBr(c->builder, post_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}