static void genfun_dwarf(compile_t* c, gentype_t* g, const char *name,
ast_t* typeargs, ast_t* fun)
{
if(!codegen_hassource(c))
return;
// Get the function.
const char* funname = genname_fun(g->type_name, name, typeargs);
LLVMValueRef func = LLVMGetNamedFunction(c->module, funname);
assert(func != NULL);
// Count the parameters, including the receiver.
ast_t* params = ast_childidx(fun, 3);
size_t count = ast_childcount(params) + 1;
size_t buf_size = (count + 1) * sizeof(const char*);
const char** pnames = (const char**)pool_alloc_size(buf_size);
count = 0;
// Return value type name and receiver type name.
pnames[count++] = genname_type(ast_childidx(fun, 4));
pnames[count++] = g->type_name;
// Get a type name for each parameter.
ast_t* param = ast_child(params);
while(param != NULL)
{
ast_t* ptype = ast_childidx(param, 1);
pnames[count++] = genname_type(ptype);
param = ast_sibling(param);
}
// Dwarf the method type
dwarf_method(&c->dwarf, fun, name, funname, pnames, count, func);
// Dwarf the receiver pointer.
LLVMBasicBlockRef entry = LLVMGetEntryBasicBlock(codegen_fun(c));
LLVMValueRef argument = codegen_getlocal(c, stringtab("this"));
dwarf_this(&c->dwarf, fun, g->type_name, entry, argument);
// Dwarf locals for parameters
param = ast_child(params);
size_t index = 1;
while(param != NULL)
{
argument = codegen_getlocal(c, ast_name(ast_child(param)));
dwarf_parameter(&c->dwarf, param, pnames[index + 1], entry, argument,
index);
param = ast_sibling(param);
index++;
}
pool_free_size(buf_size, pnames);
}
static LLVMValueRef assign_rvalue(compile_t* c, ast_t* left, ast_t* r_type,
LLVMValueRef r_value)
{
switch(ast_id(left))
{
case TK_VAR:
case TK_LET:
{
// Generate the locals.
if(gen_localdecl(c, left) == NULL)
return NULL;
return assign_rvalue(c, ast_child(left), r_type, r_value);
}
case TK_FVARREF:
case TK_FLETREF:
{
// The result is the previous value of the field.
LLVMValueRef l_value = gen_fieldptr(c, left);
return assign_one(c, l_value, r_value, r_type);
}
case TK_VARREF:
{
// The result is the previous value of the local.
LLVMValueRef l_value = gen_localptr(c, left);
return assign_one(c, l_value, r_value, r_type);
}
case TK_TUPLE:
{
// If the l_value is a tuple, assemble it as the result.
LLVMValueRef result = gen_expr(c, left);
if(result == NULL)
return NULL;
if(!assign_tuple(c, left, r_type, r_value))
return NULL;
// Return the original tuple.
return result;
}
case TK_ID:
{
// We may have recursed here from a VAR or LET or arrived directly.
const char* name = ast_name(left);
LLVMValueRef l_value = codegen_getlocal(c, name);
return assign_one(c, l_value, r_value, r_type);
}
default: {}
}
assert(0);
return NULL;
}
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_localptr(compile_t* c, ast_t* ast)
{
ast_t* id = ast_child(ast);
const char* name = ast_name(id);
LLVMValueRef value = codegen_getlocal(c, name);
pony_assert(value != NULL);
return value;
}
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;
}
static LLVMValueRef assign_rvalue(compile_t* c, ast_t* left, ast_t* r_type,
LLVMValueRef r_value)
{
switch(ast_id(left))
{
case TK_SEQ:
// The actual expression is inside a sequence node.
while(ast_id(left) == TK_SEQ)
{
assert(ast_childcount(left) == 1);
left = ast_child(left);
}
return assign_rvalue(c, left, r_type, r_value);
case TK_VAR:
case TK_LET:
{
// Generate the locals.
if(gen_localdecl(c, left) == NULL)
return NULL;
return assign_rvalue(c, ast_child(left), r_type, r_value);
}
case TK_FVARREF:
case TK_FLETREF:
{
// The result is the previous value of the field.
LLVMValueRef l_value = gen_fieldptr(c, left);
return assign_one(c, l_value, r_value, r_type);
}
case TK_EMBEDREF:
{
// Do nothing. The embed field was already passed as the receiver.
return GEN_NOVALUE;
}
case TK_VARREF:
{
// The result is the previous value of the local.
LLVMValueRef l_value = gen_localptr(c, left);
return assign_one(c, l_value, r_value, r_type);
}
case TK_TUPLE:
{
// If the l_value is a tuple, assemble it as the result.
LLVMValueRef result = gen_expr(c, left);
if(result == NULL)
return NULL;
if(!assign_tuple(c, left, r_type, r_value))
return NULL;
// Return the original tuple.
return result;
}
case TK_ID:
{
// We may have recursed here from a VAR or LET or arrived directly.
const char* name = ast_name(left);
LLVMValueRef l_value = codegen_getlocal(c, name);
return assign_one(c, l_value, r_value, r_type);
}
default: {}
}
assert(0);
return NULL;
}
