void dwarf_method(dwarf_t* dwarf, ast_t* fun, const char* name,
const char* mangled, const char** params, size_t count, LLVMValueRef ir)
{
dwarf_meta_t meta;
memset(&meta, 0, sizeof(dwarf_meta_t));
source_t* source = ast_source(fun);
ast_t* seq = ast_childidx(fun, 6);
meta.file = source->file;
meta.name = name;
meta.mangled = mangled;
meta.params = params;
meta.line = ast_line(fun);
meta.pos = ast_pos(fun);
meta.offset = ast_line(seq);
meta.size = count;
symbols_method(dwarf->symbols, &meta, ir);
}
static void meta_local(dwarf_meta_t* meta, ast_t* ast, const char* name,
const char* type, LLVMBasicBlockRef entry, LLVMValueRef storage,
size_t offset, bool constant)
{
memset(meta, 0, sizeof(dwarf_meta_t));
source_t* source = ast_source(ast);
meta->file = source->file;
meta->name = name;
meta->mangled = type;
meta->line = ast_line(ast);
meta->pos = ast_pos(ast);
meta->offset = offset + 1;
meta->entry = entry;
meta->storage = storage;
if(constant)
meta->flags = DWARF_CONSTANT;
}
void codegen_pushscope(compile_t* c, ast_t* ast)
{
compile_frame_t* frame = push_frame(c);
frame->fun = frame->prev->fun;
frame->break_target = frame->prev->break_target;
frame->continue_target = frame->prev->continue_target;
frame->invoke_target = frame->prev->invoke_target;
frame->di_file = frame->prev->di_file;
if(frame->prev->di_scope != NULL)
{
source_t* source = ast_source(ast);
LLVMMetadataRef file = LLVMDIBuilderCreateFile(c->di, source->file);
frame->di_scope = LLVMDIBuilderCreateLexicalBlock(c->di,
frame->prev->di_scope, file,
(unsigned)ast_line(ast), (unsigned)ast_pos(ast));
}
}
static void setup_type_fields(gentype_t* g)
{
assert(ast_id(g->ast) == TK_NOMINAL);
g->field_count = 0;
g->fields = NULL;
g->field_keys = NULL;
ast_t* def = (ast_t*)ast_data(g->ast);
if(ast_id(def) == TK_PRIMITIVE)
return;
ast_t* typeargs = ast_childidx(g->ast, 2);
ast_t* typeparams = ast_childidx(def, 1);
ast_t* members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
g->field_count++;
break;
}
default: {}
}
member = ast_sibling(member);
}
if(g->field_count == 0)
return;
g->fields = (ast_t**)calloc(g->field_count, sizeof(ast_t*));
g->field_keys = (token_id*)calloc(g->field_count, sizeof(token_id));
member = ast_child(members);
size_t index = 0;
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
AST_GET_CHILDREN(member, name, type, init);
g->fields[index] = reify(ast_type(member), typeparams, typeargs);
// TODO: Are we sure the AST source file is correct?
ast_setpos(g->fields[index], NULL, ast_line(name), ast_pos(name));
g->field_keys[index] = ast_id(member);
index++;
break;
}
default: {}
}
member = ast_sibling(member);
}
}
static void add_fields(reach_t* r, reach_type_t* t, pass_opt_t* opt)
{
ast_t* def = (ast_t*)ast_data(t->ast);
ast_t* typeargs = ast_childidx(t->ast, 2);
ast_t* typeparams = ast_childidx(def, 1);
ast_t* members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
t->field_count++;
break;
}
default: {}
}
member = ast_sibling(member);
}
if(t->field_count == 0)
return;
t->fields = (reach_field_t*)calloc(t->field_count, sizeof(reach_field_t));
member = ast_child(members);
size_t index = 0;
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
case TK_EMBED:
{
ast_t* r_member = lookup(NULL, NULL, t->ast,
ast_name(ast_child(member)));
assert(r_member != NULL);
AST_GET_CHILDREN(r_member, name, type, init);
t->fields[index].embed = ast_id(member) == TK_EMBED;
t->fields[index].ast = reify(ast_type(member), typeparams, typeargs,
opt, true);
ast_setpos(t->fields[index].ast, NULL, ast_line(name), ast_pos(name));
t->fields[index].type = add_type(r, type, opt);
if(r_member != member)
ast_free_unattached(r_member);
index++;
break;
}
default: {}
}
member = ast_sibling(member);
}
}