static void primitive_call(compile_t* c, const char* method, LLVMValueRef arg)
{
size_t count = 1;
if(arg != NULL)
count++;
size_t i = HASHMAP_BEGIN;
reachable_type_t* t;
while((t = reachable_types_next(c->reachable, &i)) != NULL)
{
if(t->underlying != TK_PRIMITIVE)
continue;
reachable_method_t* m = reach_method(t, method, NULL);
if(m == NULL)
continue;
LLVMValueRef args[2];
args[0] = t->instance;
args[1] = arg;
codegen_call(c, m->func, args, count);
}
}
LLVMValueRef gen_pattern_eq(compile_t* c, ast_t* pattern, LLVMValueRef r_value)
{
// This is used for structural equality in pattern matching.
ast_t* pattern_type = ast_type(pattern);
AST_GET_CHILDREN(pattern_type, package, id);
// Special case equality on primitive types.
if(ast_name(package) == c->str_builtin)
{
const char* name = ast_name(id);
if((name == c->str_Bool) ||
(name == c->str_I8) ||
(name == c->str_I16) ||
(name == c->str_I32) ||
(name == c->str_I64) ||
(name == c->str_I128) ||
(name == c->str_ILong) ||
(name == c->str_ISize) ||
(name == c->str_U8) ||
(name == c->str_U16) ||
(name == c->str_U32) ||
(name == c->str_U64) ||
(name == c->str_U128) ||
(name == c->str_ULong) ||
(name == c->str_USize) ||
(name == c->str_F32) ||
(name == c->str_F64)
)
{
return gen_eq_rvalue(c, pattern, r_value);
}
}
// Generate the receiver.
LLVMValueRef l_value = gen_expr(c, pattern);
gentype_t g;
if(!gentype(c, pattern_type, &g))
return NULL;
// Static or virtual dispatch.
LLVMValueRef func = dispatch_function(c, pattern, &g, l_value,
stringtab("eq"), NULL);
if(func == NULL)
return NULL;
// Call the function. We know it isn't partial.
LLVMValueRef args[2];
args[0] = l_value;
args[1] = r_value;
// Emit debug location for calls to test for structural equality
dwarf_location(&c->dwarf, pattern);
return codegen_call(c, func, args, 2);
}
static LLVMValueRef gen_digestof_box(compile_t* c, reach_type_t* type,
LLVMValueRef value, int boxed_subtype)
{
pony_assert(LLVMGetTypeKind(LLVMTypeOf(value)) == LLVMPointerTypeKind);
LLVMBasicBlockRef box_block = NULL;
LLVMBasicBlockRef nonbox_block = NULL;
LLVMBasicBlockRef post_block = NULL;
LLVMValueRef desc = gendesc_fetch(c, value);
if((boxed_subtype & SUBTYPE_KIND_UNBOXED) != 0)
{
box_block = codegen_block(c, "digestof_box");
nonbox_block = codegen_block(c, "digestof_nonbox");
post_block = codegen_block(c, "digestof_post");
// Check if it's a boxed value.
LLVMValueRef type_id = gendesc_typeid(c, desc);
LLVMValueRef boxed_mask = LLVMConstInt(c->i32, 1, false);
LLVMValueRef is_boxed = LLVMBuildAnd(c->builder, type_id, boxed_mask, "");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
is_boxed = LLVMBuildICmp(c->builder, LLVMIntEQ, is_boxed, zero, "");
LLVMBuildCondBr(c->builder, is_boxed, box_block, nonbox_block);
LLVMPositionBuilderAtEnd(c->builder, box_block);
}
// Call the type-specific __digestof function, which will unbox the value.
reach_method_t* digest_fn = reach_method(type, TK_BOX,
stringtab("__digestof"), NULL);
pony_assert(digest_fn != NULL);
LLVMValueRef func = gendesc_vtable(c, desc, digest_fn->vtable_index);
LLVMTypeRef fn_type = LLVMFunctionType(c->intptr, &c->object_ptr, 1, false);
func = LLVMBuildBitCast(c->builder, func, LLVMPointerType(fn_type, 0), "");
LLVMValueRef box_digest = codegen_call(c, func, &value, 1, true);
if((boxed_subtype & SUBTYPE_KIND_UNBOXED) != 0)
{
LLVMBuildBr(c->builder, post_block);
// Just cast the address.
LLVMPositionBuilderAtEnd(c->builder, nonbox_block);
LLVMValueRef nonbox_digest = LLVMBuildPtrToInt(c->builder, value, c->intptr,
"");
LLVMBuildBr(c->builder, post_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->intptr, "");
LLVMAddIncoming(phi, &box_digest, &box_block, 1);
LLVMAddIncoming(phi, &nonbox_digest, &nonbox_block, 1);
return phi;
} else {
return box_digest;
}
}
static LLVMValueRef make_unbox_function(compile_t* c, gentype_t* g,
const char* name)
{
LLVMValueRef fun = LLVMGetNamedFunction(c->module, name);
if(fun == NULL)
return LLVMConstNull(c->void_ptr);
// Create a new unboxing function that forwards to the real function.
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(fun));
int count = LLVMCountParamTypes(f_type);
// If it takes no arguments, it's a special number constructor. Don't put it
// in the vtable.
if(count == 0)
return LLVMConstNull(c->void_ptr);
size_t buf_size = count *sizeof(LLVMTypeRef);
LLVMTypeRef* params = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
LLVMTypeRef ret_type = LLVMGetReturnType(f_type);
// It's the same type, but it takes the boxed type instead of the primitive
// type as the receiver.
params[0] = g->structure_ptr;
const char* unbox_name = genname_unbox(name);
LLVMTypeRef unbox_type = LLVMFunctionType(ret_type, params, count, false);
LLVMValueRef unbox_fun = codegen_addfun(c, unbox_name, unbox_type);
codegen_startfun(c, unbox_fun, false);
// Extract the primitive type from element 1 and call the real function.
LLVMValueRef this_ptr = LLVMGetParam(unbox_fun, 0);
LLVMValueRef primitive_ptr = LLVMBuildStructGEP(c->builder, this_ptr, 1, "");
LLVMValueRef primitive = LLVMBuildLoad(c->builder, primitive_ptr, "");
LLVMValueRef* args = (LLVMValueRef*)pool_alloc_size(buf_size);
args[0] = primitive;
for(int i = 1; i < count; i++)
args[i] = LLVMGetParam(unbox_fun, i);
LLVMValueRef result = codegen_call(c, fun, args, count);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
pool_free_size(buf_size, params);
pool_free_size(buf_size, args);
return LLVMConstBitCast(unbox_fun, c->void_ptr);
}
static void add_dispatch_case(compile_t* c, gentype_t* g, ast_t* fun,
uint32_t index, LLVMValueRef handler, LLVMTypeRef type)
{
// Add a case to the dispatch function to handle this message.
codegen_startfun(c, g->dispatch_fn, false);
LLVMBasicBlockRef block = codegen_block(c, "handler");
LLVMValueRef id = LLVMConstInt(c->i32, index, false);
LLVMAddCase(g->dispatch_switch, id, block);
// Destructure the message.
LLVMPositionBuilderAtEnd(c->builder, block);
LLVMValueRef ctx = LLVMGetParam(g->dispatch_fn, 0);
LLVMValueRef this_ptr = LLVMGetParam(g->dispatch_fn, 1);
LLVMValueRef msg = LLVMBuildBitCast(c->builder,
LLVMGetParam(g->dispatch_fn, 2), type, "");
int count = LLVMCountParams(handler);
size_t buf_size = count * sizeof(LLVMValueRef);
LLVMValueRef* args = (LLVMValueRef*)pool_alloc_size(buf_size);
args[0] = LLVMBuildBitCast(c->builder, this_ptr, g->use_type, "");
// Trace the message.
LLVMValueRef start_trace = gencall_runtime(c, "pony_gc_recv", &ctx, 1, "");
ast_t* params = ast_childidx(fun, 3);
ast_t* param = ast_child(params);
bool need_trace = false;
for(int i = 1; i < count; i++)
{
LLVMValueRef field = LLVMBuildStructGEP(c->builder, msg, i + 2, "");
args[i] = LLVMBuildLoad(c->builder, field, "");
need_trace |= gentrace(c, ctx, args[i], ast_type(param));
param = ast_sibling(param);
}
if(need_trace)
{
gencall_runtime(c, "pony_recv_done", &ctx, 1, "");
} else {
LLVMInstructionEraseFromParent(start_trace);
}
// Call the handler.
codegen_call(c, handler, args, count);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
pool_free_size(buf_size, args);
}
static void primitive_call(compile_t* c, const char* method, LLVMValueRef arg)
{
size_t count = 1;
if(arg != NULL)
count++;
size_t i = HASHMAP_BEGIN;
reachable_type_t* t;
while((t = reachable_types_next(c->reachable, &i)) != NULL)
{
if(ast_id(t->type) == TK_TUPLETYPE)
continue;
ast_t* def = (ast_t*)ast_data(t->type);
if(ast_id(def) != TK_PRIMITIVE)
continue;
reachable_method_name_t* n = reach_method_name(t, method);
if(n == NULL)
continue;
gentype_t g;
if(!gentype(c, t->type, &g))
{
assert(0);
return;
}
LLVMValueRef fun = genfun_proto(c, &g, method, NULL);
assert(fun != NULL);
LLVMValueRef args[2];
args[0] = g.instance;
args[1] = arg;
codegen_call(c, fun, args, count);
}
}
static void primitive_call(compile_t* c, const char* method)
{
size_t i = HASHMAP_BEGIN;
reach_type_t* t;
while((t = reach_types_next(&c->reach->types, &i)) != NULL)
{
if(t->underlying != TK_PRIMITIVE)
continue;
reach_method_t* m = reach_method(t, TK_NONE, method, NULL);
if(m == NULL)
continue;
LLVMValueRef value = codegen_call(c, m->func, &t->instance, 1);
if(c->str__final == method)
LLVMSetInstructionCallConv(value, LLVMCCallConv);
}
}
static LLVMValueRef make_unbox_function(compile_t* c, reach_type_t* t,
reach_method_t* m)
{
// Create a new unboxing function that forwards to the real function.
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(m->func));
int count = LLVMCountParamTypes(f_type);
// Leave space for a receiver if it's a constructor vtable entry.
size_t buf_size = (count + 1) * sizeof(LLVMTypeRef);
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
LLVMTypeRef ret_type = LLVMGetReturnType(f_type);
const char* unbox_name = genname_unbox(m->full_name);
if(ast_id(m->r_fun) != TK_NEW)
{
// It's the same type, but it takes the boxed type instead of the primitive
// type as the receiver.
params[0] = t->structure_ptr;
} else {
// For a constructor, the unbox_fun has a receiver, even though the real
// method does not.
memmove(¶ms[1], ¶ms[0], count * sizeof(LLVMTypeRef*));
params[0] = t->structure_ptr;
count++;
}
LLVMTypeRef unbox_type = LLVMFunctionType(ret_type, params, count, false);
LLVMValueRef unbox_fun = codegen_addfun(c, unbox_name, unbox_type);
codegen_startfun(c, unbox_fun, NULL, NULL);
// Extract the primitive type from element 1 and call the real function.
LLVMValueRef this_ptr = LLVMGetParam(unbox_fun, 0);
LLVMValueRef primitive_ptr = LLVMBuildStructGEP(c->builder, this_ptr, 1, "");
LLVMValueRef primitive = LLVMBuildLoad(c->builder, primitive_ptr, "");
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
if(ast_id(m->r_fun) != TK_NEW)
{
// If it's not a constructor, pass the extracted primitive as the receiver.
args[0] = primitive;
for(int i = 1; i < count; i++)
args[i] = LLVMGetParam(unbox_fun, i);
} else {
count--;
for(int i = 0; i < count; i++)
args[i] = LLVMGetParam(unbox_fun, i + 1);
}
LLVMValueRef result = codegen_call(c, m->func, args, count);
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
ponyint_pool_free_size(buf_size, params);
ponyint_pool_free_size(buf_size, args);
return LLVMConstBitCast(unbox_fun, c->void_ptr);
}
/*
* codegen_statement: Generate code for a single statement.
* numlocals should be # of local variables for message excluding temps.
* Returns highest # local variable used in code for statement.
*/
int codegen_statement(stmt_type s, int numlocals)
{
opcode_type opcode;
int our_maxtemp = numlocals; /* highest numbered temporary required for this statement alone */
/* Save line # debugging information */
if (debug_bof && s->lineno != 0)
{
DebugLine *d = (DebugLine *) SafeMalloc(sizeof(DebugLine));
d->lineno = s->lineno;
d->offset = FileCurPos(outfile);
debug_lines = list_add_item(debug_lines, d);
}
memset(&opcode, 0, sizeof(opcode)); /* Set opcode to all zeros */
switch (s->type)
{
case S_ASSIGN:
{
assign_stmt_type stmt = s->value.assign_stmt_val;
/* Place result directly in lhs */
our_maxtemp = flatten_expr(stmt->rhs, stmt->lhs, numlocals);
break;
}
case S_CALL:
our_maxtemp = codegen_call(s->value.call_stmt_val, NULL, numlocals);
break;
case S_PROP:
opcode.command = RETURN;
opcode.dest = PROPAGATE;
OutputOpcode(outfile, opcode);
break;
case S_RETURN:
our_maxtemp = codegen_return(s->value.return_stmt_val, numlocals);
break;
case S_IF:
our_maxtemp = codegen_if(s->value.if_stmt_val, numlocals);
break;
case S_FOREACH:
our_maxtemp = codegen_foreach(s->value.foreach_stmt_val, numlocals);
break;
case S_FOR:
our_maxtemp = codegen_for(s->value.for_stmt_val, numlocals);
break;
case S_SWITCH:
our_maxtemp = codegen_switch(s->value.switch_stmt_val, numlocals);
break;
case S_WHILE:
our_maxtemp = codegen_while(s->value.while_stmt_val, numlocals);
break;
case S_DOWHILE:
our_maxtemp = codegen_dowhile(s->value.while_stmt_val, numlocals);
break;
case S_BREAK:
/* Goto end of loop */
opcode.command = GOTO;
opcode.source1 = 0;
opcode.source2 = GOTO_UNCONDITIONAL;
OutputOpcode(outfile, opcode);
/* Add to list of gotos to be backpatched later, and leave space */
current_loop->break_list =
list_add_item(current_loop->break_list, (void *) FileCurPos(outfile));
OutputInt(outfile, 0);
break;
case S_CONTINUE:
/* Goto top of loop */
opcode.command = GOTO;
opcode.source1 = 0;
opcode.source2 = GOTO_UNCONDITIONAL;
OutputOpcode(outfile, opcode);
/* In for loops, continue statements actually jump forward, but in while loops
* they jump backward. Save address of goto for backpatching; if we are
* in a for loop, the offset written out below will be written over during
* backpatching in codegen_foreach().
*/
current_loop->for_continue_list =
list_add_item(current_loop->for_continue_list, (void *) FileCurPos(outfile));
OutputGotoOffset(outfile, FileCurPos(outfile), current_loop->toppos);
break;
default:
simple_error("Unknown statement type (%d) encountered", s->type);
break;
}
return our_maxtemp;
}
/*
* codegen_foreach: Generate code for a for loop statement.
* numlocals should be # of local variables for message excluding temps.
* Returns highest # local variable used in code for statement.
* Here is how code is generated for a FOR statement:
* for i in list ===> temp = list 1
* {body} top: if (temp = $) goto end 2
* i = First(temp) 3
* { body }
* temp = Rest(temp) 4
* goto top 5
* end:
*
* Note that continue statements need to jump to statement 4.
*/
int codegen_foreach(foreach_stmt_type s, int numlocals)
{
opcode_type opcode;
int our_maxlocal, numtemps;
stmt_type temp_stmt = (stmt_type) SafeMalloc(sizeof(stmt_struct));
expr_type temp_expr = (expr_type) SafeMalloc(sizeof(expr_struct));
expr_type temp2_expr = (expr_type) SafeMalloc(sizeof(expr_struct));
assign_stmt_type assign_stmt = (assign_stmt_type) SafeMalloc(sizeof(assign_stmt_struct));
call_stmt_type call_stmt = (call_stmt_type) SafeMalloc(sizeof(call_stmt_struct));
arg_type arg = (arg_type) SafeMalloc(sizeof(arg_struct));
id_type temp_id, temp2_id;
long toppos;
list_type p;
/* Make variable "temp" */
temp_id = make_temp_var(numlocals + 1);
/**** Statement #1: temp = list ****/
assign_stmt->lhs = temp_id;
assign_stmt->rhs = s->condition;
temp_stmt->type = S_ASSIGN;
temp_stmt->value.assign_stmt_val = assign_stmt;
temp_stmt->lineno = 0;
numtemps = codegen_statement(temp_stmt, numlocals);
/* Reserve variable "temp" through entire loop by incrementing numlocals */
our_maxlocal = ++numlocals;
if (numtemps > our_maxlocal)
our_maxlocal = numtemps;
toppos = FileCurPos(outfile);
codegen_enter_loop();
/**** Statement #2: if (temp = $) goto end ****/
/* First put result of temp = $ into temp2 */
temp2_id = make_temp_var(numlocals + 1);
if (numlocals + 1 > our_maxlocal)
our_maxlocal = numlocals + 1;
temp2_expr->type = E_IDENTIFIER;
temp2_expr->value.idval = temp_id;
temp_expr->type = E_BINARY_OP;
temp_expr->value.binary_opval.op = EQ_OP;
temp_expr->value.binary_opval.left_exp = temp2_expr;
temp_expr->value.binary_opval.right_exp = make_expr_from_constant(make_nil_constant());
assign_stmt->lhs = temp2_id;
assign_stmt->rhs = temp_expr;
temp_stmt->type = S_ASSIGN;
temp_stmt->value.assign_stmt_val = assign_stmt; /* YECHHH! */
temp_stmt->lineno = 0;
codegen_statement(temp_stmt, numlocals); /* Won't require more temps */
/* Now perform jump if temp = $ is true */
memset(&opcode, 0, sizeof(opcode)); /* Set opcode to all zeros */
opcode.command = GOTO;
opcode.source1 = LOCAL_VAR;
opcode.dest = GOTO_IF_TRUE;
OutputOpcode(outfile, opcode);
/* Make believe goto is a break statement & leave space for backpatching */
current_loop->break_list =
list_add_item(current_loop->break_list, (void *) FileCurPos(outfile));
OutputInt(outfile, 0);
OutputInt(outfile, temp2_id->idnum); /* Jump if temp2 = TRUE */
/**** Statement #3: i = First(temp) ****/
temp_expr->type = E_IDENTIFIER;
temp_expr->value.idval = temp_id;
arg->type = ARG_EXPR;
arg->value.expr_val = temp_expr;
call_stmt->function = FIRST;
call_stmt->args = list_create(arg);
codegen_call(call_stmt, s->id, numlocals); /* Won't require more temps */
/* Write code for loop body */
for (p = s->body; p != NULL; p = p->next)
{
numtemps = codegen_statement( (stmt_type) p->data, numlocals);
if (numtemps > our_maxlocal)
our_maxlocal = numtemps;
}
/* Backpatch continue statements in loop body */
for (p = current_loop->for_continue_list; p != NULL; p = p->next)
BackpatchGoto(outfile, (int) p->data, FileCurPos(outfile));
/**** Statement #4: temp = Rest(temp) ****/
/* Can reuse most of statement #3 above */
call_stmt->function = REST;
codegen_call(call_stmt, temp_id, numlocals); /* Won't require more temps */
/**** Statement #5: goto top ****/
opcode.source1 = 0;
opcode.source2 = GOTO_UNCONDITIONAL;
opcode.dest = 0;
OutputOpcode(outfile, opcode);
OutputGotoOffset(outfile, FileCurPos(outfile), toppos);
codegen_exit_loop(); /* Takes care of break statements */
return our_maxlocal;
}
LLVMValueRef gen_pattern_eq(compile_t* c, ast_t* pattern, LLVMValueRef r_value)
{
// This is used for structural equality in pattern matching.
ast_t* pattern_type = ast_type(pattern);
if(ast_id(pattern_type) == TK_NOMINAL)
{
AST_GET_CHILDREN(pattern_type, package, id);
// Special case equality on primitive types.
if(ast_name(package) == c->str_builtin)
{
const char* name = ast_name(id);
if((name == c->str_Bool) ||
(name == c->str_I8) ||
(name == c->str_I16) ||
(name == c->str_I32) ||
(name == c->str_I64) ||
(name == c->str_I128) ||
(name == c->str_ILong) ||
(name == c->str_ISize) ||
(name == c->str_U8) ||
(name == c->str_U16) ||
(name == c->str_U32) ||
(name == c->str_U64) ||
(name == c->str_U128) ||
(name == c->str_ULong) ||
(name == c->str_USize) ||
(name == c->str_F32) ||
(name == c->str_F64)
)
{
return gen_eq_rvalue(c, pattern, r_value, true);
}
}
}
// Generate the receiver.
LLVMValueRef l_value = gen_expr(c, pattern);
reach_type_t* t = reach_type(c->reach, pattern_type);
pony_assert(t != NULL);
// Static or virtual dispatch.
token_id cap = cap_dispatch(pattern_type);
reach_method_t* m = reach_method(t, cap, c->str_eq, NULL);
LLVMValueRef func = dispatch_function(c, t, m, l_value);
if(func == NULL)
return NULL;
// Call the function. We know it isn't partial.
LLVMValueRef args[2];
args[0] = l_value;
args[1] = r_value;
codegen_debugloc(c, pattern);
LLVMValueRef result = codegen_call(c, func, args, 2);
codegen_debugloc(c, NULL);
return result;
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, positional, named, postfix);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
typeargs = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Get the receiver type.
const char* method_name = ast_name(method);
ast_t* type = ast_type(receiver);
reach_type_t* t = reach_type(c->reach, type);
pony_assert(t != NULL);
// Generate the arguments.
size_t count = ast_childcount(positional) + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = gen_expr(c, arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
bool is_new_call = false;
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, t))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
{
call_tuple_indices_t tuple_indices = {NULL, 0, 4};
tuple_indices.data =
(size_t*)ponyint_pool_alloc_size(4 * sizeof(size_t));
ast_t* current = ast;
ast_t* parent = ast_parent(current);
while((parent != NULL) && (ast_id(parent) != TK_ASSIGN) &&
(ast_id(parent) != TK_CALL))
{
if(ast_id(parent) == TK_TUPLE)
{
size_t index = 0;
ast_t* child = ast_child(parent);
while(current != child)
{
++index;
child = ast_sibling(child);
}
tuple_indices_push(&tuple_indices, index);
}
current = parent;
parent = ast_parent(current);
}
// If we're constructing an embed field, pass a pointer to the field
// as the receiver. Otherwise, allocate an object.
if((parent != NULL) && (ast_id(parent) == TK_ASSIGN))
{
size_t index = 1;
current = ast_childidx(parent, 1);
while((ast_id(current) == TK_TUPLE) || (ast_id(current) == TK_SEQ))
{
parent = current;
if(ast_id(current) == TK_TUPLE)
{
// If there are no indices left, we're destructuring a tuple.
// Errors in those cases have already been catched by the expr
// pass.
if(tuple_indices.count == 0)
break;
index = tuple_indices_pop(&tuple_indices);
current = ast_childidx(parent, index);
} else {
current = ast_childlast(parent);
}
}
if(ast_id(current) == TK_EMBEDREF)
{
args[0] = gen_fieldptr(c, current);
set_descriptor(c, t, args[0]);
} else {
args[0] = gencall_alloc(c, t);
}
} else {
args[0] = gencall_alloc(c, t);
}
is_new_call = true;
ponyint_pool_free_size(tuple_indices.alloc * sizeof(size_t),
tuple_indices.data);
break;
}
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
args[0] = gen_expr(c, receiver);
break;
default:
pony_assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(t->use_type);
}
// Static or virtual dispatch.
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
LLVMValueRef func = dispatch_function(c, t, m, args[0]);
bool is_message = false;
if((ast_id(postfix) == TK_NEWBEREF) || (ast_id(postfix) == TK_BEREF) ||
(ast_id(postfix) == TK_BECHAIN))
{
switch(t->underlying)
{
case TK_ACTOR:
is_message = true;
break;
case TK_UNIONTYPE:
case TK_ISECTTYPE:
case TK_INTERFACE:
case TK_TRAIT:
if(m->cap == TK_TAG)
is_message = can_inline_message_send(t, m, method_name);
break;
default: {}
}
}
// Cast the arguments to the parameter types.
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
arg = ast_child(positional);
i = 1;
LLVMValueRef r = NULL;
if(is_message)
{
// If we're sending a message, trace and send here instead of calling the
// sender to trace the most specific types possible.
LLVMValueRef* cast_args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
cast_args[0] = args[0];
while(arg != NULL)
{
cast_args[i] = gen_assign_cast(c, params[i], args[i], ast_type(arg));
arg = ast_sibling(arg);
i++;
}
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
codegen_debugloc(c, ast);
gen_send_message(c, m, args, cast_args, positional);
codegen_debugloc(c, NULL);
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
r = args[0];
break;
default:
r = c->none_instance;
break;
}
ponyint_pool_free_size(buf_size, cast_args);
} else {
while(arg != NULL)
{
args[i] = gen_assign_cast(c, params[i], args[i], ast_type(arg));
arg = ast_sibling(arg);
i++;
}
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
codegen_debugloc(c, ast);
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args, i, "", true);
else
r = codegen_call(c, func, args, i);
if(is_new_call)
{
LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);
LLVMSetMetadataStr(r, "pony.newcall", md);
}
codegen_debugloc(c, NULL);
}
}
// Class constructors return void, expression result is the receiver.
if(((ast_id(postfix) == TK_NEWREF) || (ast_id(postfix) == TK_NEWBEREF)) &&
(t->underlying == TK_CLASS))
r = args[0];
// Chained methods forward their receiver.
if((ast_id(postfix) == TK_BECHAIN) || (ast_id(postfix) == TK_FUNCHAIN))
r = args[0];
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return r;
}
static void gen_main(compile_t* c, reach_type_t* t_main,
reach_type_t* t_env)
{
LLVMTypeRef params[3];
params[0] = c->i32;
params[1] = LLVMPointerType(LLVMPointerType(c->i8, 0), 0);
params[2] = LLVMPointerType(LLVMPointerType(c->i8, 0), 0);
LLVMTypeRef ftype = LLVMFunctionType(c->i32, params, 3, false);
LLVMValueRef func = LLVMAddFunction(c->module, "main", ftype);
codegen_startfun(c, func, NULL, NULL);
LLVMValueRef args[4];
args[0] = LLVMGetParam(func, 0);
LLVMSetValueName(args[0], "argc");
args[1] = LLVMGetParam(func, 1);
LLVMSetValueName(args[1], "argv");
args[2] = LLVMGetParam(func, 2);
LLVMSetValueName(args[2], "envp");
// Initialise the pony runtime with argc and argv, getting a new argc.
args[0] = gencall_runtime(c, "pony_init", args, 2, "argc");
// Create the main actor and become it.
LLVMValueRef ctx = gencall_runtime(c, "pony_ctx", NULL, 0, "");
codegen_setctx(c, ctx);
LLVMValueRef main_actor = create_main(c, t_main, ctx);
// Create an Env on the main actor's heap.
reach_method_t* m = reach_method(t_env, TK_NONE, c->str__create, NULL);
LLVMValueRef env_args[4];
env_args[0] = gencall_alloc(c, t_env);
env_args[1] = args[0];
env_args[2] = LLVMBuildBitCast(c->builder, args[1], c->void_ptr, "");
env_args[3] = LLVMBuildBitCast(c->builder, args[2], c->void_ptr, "");
codegen_call(c, m->func, env_args, 4);
LLVMValueRef env = env_args[0];
// Run primitive initialisers using the main actor's heap.
primitive_call(c, c->str__init);
// Create a type for the message.
LLVMTypeRef f_params[4];
f_params[0] = c->i32;
f_params[1] = c->i32;
f_params[2] = c->void_ptr;
f_params[3] = LLVMTypeOf(env);
LLVMTypeRef msg_type = LLVMStructTypeInContext(c->context, f_params, 4,
false);
LLVMTypeRef msg_type_ptr = LLVMPointerType(msg_type, 0);
// Allocate the message, setting its size and ID.
uint32_t index = reach_vtable_index(t_main, c->str_create);
size_t msg_size = (size_t)LLVMABISizeOfType(c->target_data, msg_type);
args[0] = LLVMConstInt(c->i32, ponyint_pool_index(msg_size), false);
args[1] = LLVMConstInt(c->i32, index, false);
LLVMValueRef msg = gencall_runtime(c, "pony_alloc_msg", args, 2, "");
LLVMValueRef msg_ptr = LLVMBuildBitCast(c->builder, msg, msg_type_ptr, "");
// Set the message contents.
LLVMValueRef env_ptr = LLVMBuildStructGEP(c->builder, msg_ptr, 3, "");
LLVMBuildStore(c->builder, env, env_ptr);
// Trace the message.
args[0] = ctx;
gencall_runtime(c, "pony_gc_send", args, 1, "");
args[0] = ctx;
args[1] = LLVMBuildBitCast(c->builder, env, c->object_ptr, "");
args[2] = LLVMBuildBitCast(c->builder, t_env->desc, c->descriptor_ptr, "");
args[3] = LLVMConstInt(c->i32, PONY_TRACE_IMMUTABLE, false);
gencall_runtime(c, "pony_traceknown", args, 4, "");
args[0] = ctx;
gencall_runtime(c, "pony_send_done", args, 1, "");
// Send the message.
args[0] = ctx;
args[1] = main_actor;
args[2] = msg;
gencall_runtime(c, "pony_sendv", args, 3, "");
// Start the runtime.
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
LLVMValueRef rc = gencall_runtime(c, "pony_start", &zero, 1, "");
// Run primitive finalisers. We create a new main actor as a context to run
// the finalisers in, but we do not initialise or schedule it.
if(need_primitive_call(c, c->str__final))
{
LLVMValueRef final_actor = create_main(c, t_main, ctx);
primitive_call(c, c->str__final);
args[0] = final_actor;
gencall_runtime(c, "ponyint_destroy", args, 1, "");
}
// Return the runtime exit code.
LLVMBuildRet(c->builder, rc);
codegen_finishfun(c);
// External linkage for main().
LLVMSetLinkage(func, LLVMExternalLinkage);
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, positional, named, postfix);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
typeargs = method;
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Generate the receiver type.
const char* method_name = ast_name(method);
ast_t* type = ast_type(receiver);
gentype_t g;
if(!gentype(c, type, &g))
return NULL;
// Generate the arguments.
LLVMTypeRef f_type = genfun_sig(c, &g, method_name, typeargs);
if(f_type == NULL)
{
ast_error(ast, "couldn't create a signature for '%s'", method_name);
return NULL;
}
size_t count = ast_childcount(positional) + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = make_arg(c, params[i], arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, &g))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
{
ast_t* parent = ast_parent(ast);
ast_t* sibling = ast_sibling(ast);
// If we're constructing an embed field, pass a pointer to the field
// as the receiver. Otherwise, allocate an object.
if((ast_id(parent) == TK_ASSIGN) && (ast_id(sibling) == TK_EMBEDREF))
args[0] = gen_fieldptr(c, sibling);
else
args[0] = gencall_alloc(c, &g);
break;
}
case TK_BEREF:
case TK_FUNREF:
args[0] = gen_expr(c, receiver);
break;
default:
assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(g.use_type);
}
// Always emit location info for a call, to prevent inlining errors. This may
// be disabled in dispatch_function, if the target function has no debug
// info set.
ast_setdebug(ast, true);
dwarf_location(&c->dwarf, ast);
// Static or virtual dispatch.
LLVMValueRef func = dispatch_function(c, ast, &g, args[0], method_name,
typeargs);
LLVMValueRef r = NULL;
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args, i, "", true);
else
r = codegen_call(c, func, args, i);
}
ponyint_pool_free_size(buf_size, args);
ponyint_pool_free_size(buf_size, params);
return r;
}
static LLVMValueRef box_is_box(compile_t* c, ast_t* left_type,
LLVMValueRef l_value, LLVMValueRef r_value, int possible_boxes)
{
pony_assert(LLVMGetTypeKind(LLVMTypeOf(l_value)) == LLVMPointerTypeKind);
pony_assert(LLVMGetTypeKind(LLVMTypeOf(r_value)) == LLVMPointerTypeKind);
LLVMBasicBlockRef this_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef checkbox_block = codegen_block(c, "is_checkbox");
LLVMBasicBlockRef box_block = codegen_block(c, "is_box");
LLVMBasicBlockRef num_block = NULL;
if((possible_boxes & BOXED_SUBTYPES_NUMERIC) != 0)
num_block = codegen_block(c, "is_num");
LLVMBasicBlockRef tuple_block = NULL;
if((possible_boxes & BOXED_SUBTYPES_TUPLE) != 0)
tuple_block = codegen_block(c, "is_tuple");
LLVMBasicBlockRef post_block = codegen_block(c, "is_post");
LLVMValueRef eq_addr = LLVMBuildICmp(c->builder, LLVMIntEQ, l_value, r_value,
"");
LLVMBuildCondBr(c->builder, eq_addr, post_block, checkbox_block);
// Check whether we have two boxed objects of the same type.
LLVMPositionBuilderAtEnd(c->builder, checkbox_block);
LLVMValueRef l_desc = gendesc_fetch(c, l_value);
LLVMValueRef r_desc = gendesc_fetch(c, r_value);
LLVMValueRef same_type = LLVMBuildICmp(c->builder, LLVMIntEQ, l_desc, r_desc,
"");
LLVMValueRef l_typeid = NULL;
if((possible_boxes & BOXED_SUBTYPES_UNBOXED) != 0)
{
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef boxed_mask = LLVMConstInt(c->i32, 1, false);
LLVMValueRef left_boxed = LLVMBuildAnd(c->builder, l_typeid, boxed_mask,
"");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
left_boxed = LLVMBuildICmp(c->builder, LLVMIntEQ, left_boxed, zero, "");
LLVMValueRef both_boxed = LLVMBuildAnd(c->builder, same_type, left_boxed,
"");
LLVMBuildCondBr(c->builder, both_boxed, box_block, post_block);
} else {
LLVMBuildCondBr(c->builder, same_type, box_block, post_block);
}
// Check whether it's a numeric primitive or a tuple.
LLVMPositionBuilderAtEnd(c->builder, box_block);
if((possible_boxes & BOXED_SUBTYPES_BOXED) == BOXED_SUBTYPES_BOXED)
{
if(l_typeid == NULL)
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef num_mask = LLVMConstInt(c->i32, 2, false);
LLVMValueRef boxed_num = LLVMBuildAnd(c->builder, l_typeid, num_mask, "");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
boxed_num = LLVMBuildICmp(c->builder, LLVMIntEQ, boxed_num, zero, "");
LLVMBuildCondBr(c->builder, boxed_num, num_block, tuple_block);
} else if((possible_boxes & BOXED_SUBTYPES_NUMERIC) != 0) {
LLVMBuildBr(c->builder, num_block);
} else {
pony_assert((possible_boxes & BOXED_SUBTYPES_TUPLE) != 0);
LLVMBuildBr(c->builder, tuple_block);
}
LLVMValueRef args[3];
LLVMValueRef is_num = NULL;
if(num_block != NULL)
{
// Get the machine word size and memcmp without unboxing.
LLVMPositionBuilderAtEnd(c->builder, num_block);
if(l_typeid == NULL)
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef num_sizes = LLVMBuildBitCast(c->builder, c->numeric_sizes,
c->void_ptr, "");
args[0] = LLVMBuildZExt(c->builder, l_typeid, c->intptr, "");
LLVMValueRef size = LLVMBuildInBoundsGEP(c->builder, num_sizes, args, 1,
"");
size = LLVMBuildBitCast(c->builder, size, LLVMPointerType(c->i32, 0), "");
size = LLVMBuildLoad(c->builder, size, "");
LLVMSetAlignment(size, 4);
LLVMValueRef one = LLVMConstInt(c->i32, 1, false);
args[0] = LLVMBuildInBoundsGEP(c->builder, l_value, &one, 1, "");
args[0] = LLVMBuildBitCast(c->builder, args[0], c->void_ptr, "");
args[1] = LLVMBuildInBoundsGEP(c->builder, r_value, &one, 1, "");
args[1] = LLVMBuildBitCast(c->builder, args[1], c->void_ptr, "");
args[2] = LLVMBuildZExt(c->builder, size, c->intptr, "");
is_num = gencall_runtime(c, "memcmp", args, 3, "");
is_num = LLVMBuildICmp(c->builder, LLVMIntEQ, is_num,
LLVMConstInt(c->i32, 0, false), "");
LLVMBuildBr(c->builder, post_block);
}
LLVMValueRef is_tuple = NULL;
if(tuple_block != NULL)
{
// Call the type-specific __is function, which will unbox the tuples.
LLVMPositionBuilderAtEnd(c->builder, tuple_block);
reach_type_t* r_left = reach_type(c->reach, left_type);
reach_method_t* is_fn = reach_method(r_left, TK_BOX, stringtab("__is"),
NULL);
pony_assert(is_fn != NULL);
LLVMValueRef func = gendesc_vtable(c, l_value, is_fn->vtable_index);
LLVMTypeRef params[2];
params[0] = c->object_ptr;
params[1] = c->object_ptr;
LLVMTypeRef type = LLVMFunctionType(c->i1, params, 2, false);
func = LLVMBuildBitCast(c->builder, func, LLVMPointerType(type, 0), "");
args[0] = l_value;
args[1] = r_value;
is_tuple = codegen_call(c, func, args, 2);
LLVMBuildBr(c->builder, post_block);
}
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->i1, "");
LLVMValueRef one = LLVMConstInt(c->i1, 1, false);
LLVMValueRef zero = LLVMConstInt(c->i1, 0, false);
LLVMAddIncoming(phi, &one, &this_block, 1);
if(is_num != NULL)
LLVMAddIncoming(phi, &is_num, &num_block, 1);
if(is_tuple != NULL)
LLVMAddIncoming(phi, &is_tuple, &tuple_block, 1);
LLVMAddIncoming(phi, &zero, &checkbox_block, 1);
return phi;
}
LLVMValueRef gen_call(compile_t* c, ast_t* ast)
{
// Special case calls.
LLVMValueRef special;
if(special_case_call(c, ast, &special))
return special;
AST_GET_CHILDREN(ast, postfix, positional, named, question);
AST_GET_CHILDREN(postfix, receiver, method);
ast_t* typeargs = NULL;
deferred_reification_t* reify = c->frame->reify;
// Dig through function qualification.
switch(ast_id(receiver))
{
case TK_NEWREF:
case TK_NEWBEREF:
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
typeargs = deferred_reify(reify, method, c->opt);
AST_GET_CHILDREN_NO_DECL(receiver, receiver, method);
break;
default: {}
}
// Get the receiver type.
const char* method_name = ast_name(method);
ast_t* type = deferred_reify(reify, ast_type(receiver), c->opt);
reach_type_t* t = reach_type(c->reach, type);
pony_assert(t != NULL);
token_id cap = cap_dispatch(type);
reach_method_t* m = reach_method(t, cap, method_name, typeargs);
ast_free_unattached(type);
ast_free_unattached(typeargs);
// Generate the arguments.
size_t count = m->param_count + 1;
size_t buf_size = count * sizeof(void*);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
ast_t* arg = ast_child(positional);
int i = 1;
while(arg != NULL)
{
LLVMValueRef value = gen_expr(c, arg);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, args);
return NULL;
}
args[i] = value;
arg = ast_sibling(arg);
i++;
}
bool is_new_call = false;
// Generate the receiver. Must be done after the arguments because the args
// could change things in the receiver expression that must be accounted for.
if(call_needs_receiver(postfix, t))
{
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
args[0] = gen_constructor_receiver(c, t, ast);
is_new_call = true;
break;
case TK_BEREF:
case TK_FUNREF:
case TK_BECHAIN:
case TK_FUNCHAIN:
args[0] = gen_expr(c, receiver);
break;
default:
pony_assert(0);
return NULL;
}
} else {
// Use a null for the receiver type.
args[0] = LLVMConstNull(((compile_type_t*)t->c_type)->use_type);
}
// Static or virtual dispatch.
LLVMValueRef func = dispatch_function(c, t, m, args[0]);
bool is_message = false;
if((ast_id(postfix) == TK_NEWBEREF) || (ast_id(postfix) == TK_BEREF) ||
(ast_id(postfix) == TK_BECHAIN))
{
switch(t->underlying)
{
case TK_ACTOR:
is_message = true;
break;
case TK_UNIONTYPE:
case TK_ISECTTYPE:
case TK_INTERFACE:
case TK_TRAIT:
if(m->cap == TK_TAG)
is_message = can_inline_message_send(t, m, method_name);
break;
default: {}
}
}
bool bare = m->cap == TK_AT;
LLVMValueRef r = NULL;
if(is_message)
{
// If we're sending a message, trace and send here instead of calling the
// sender to trace the most specific types possible.
codegen_debugloc(c, ast);
gen_send_message(c, m, args, positional);
codegen_debugloc(c, NULL);
switch(ast_id(postfix))
{
case TK_NEWREF:
case TK_NEWBEREF:
r = args[0];
break;
default:
r = c->none_instance;
break;
}
} else {
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef* params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, params + (bare ? 1 : 0));
arg = ast_child(positional);
i = 1;
while(arg != NULL)
{
ast_t* arg_type = deferred_reify(reify, ast_type(arg), c->opt);
args[i] = gen_assign_cast(c, params[i], args[i], arg_type);
ast_free_unattached(arg_type);
arg = ast_sibling(arg);
i++;
}
uintptr_t arg_offset = 0;
if(bare)
{
arg_offset = 1;
i--;
}
if(func != NULL)
{
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
codegen_debugloc(c, ast);
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
r = invoke_fun(c, func, args + arg_offset, i, "", !bare);
else
r = codegen_call(c, func, args + arg_offset, i, !bare);
if(is_new_call)
{
LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);
LLVMSetMetadataStr(r, "pony.newcall", md);
}
codegen_debugloc(c, NULL);
ponyint_pool_free_size(buf_size, params);
}
}
// Bare methods with None return type return void, special case a None return
// value.
if(bare && is_none(m->result->ast))
r = c->none_instance;
// Class constructors return void, expression result is the receiver.
if(((ast_id(postfix) == TK_NEWREF) || (ast_id(postfix) == TK_NEWBEREF)) &&
(t->underlying == TK_CLASS))
r = args[0];
// Chained methods forward their receiver.
if((ast_id(postfix) == TK_BECHAIN) || (ast_id(postfix) == TK_FUNCHAIN))
r = args[0];
ponyint_pool_free_size(buf_size, args);
return r;
}
