LLVMValueRef gencall_allocstruct(compile_t* c, gentype_t* g)
{
// Disable debug anchor
dwarf_location(&c->dwarf, NULL);
// We explicitly want a boxed version.
// Get the size of the structure.
size_t size = (size_t)LLVMABISizeOfType(c->target_data, g->structure);
// Get the finaliser, if there is one.
const char* final = genname_finalise(g->type_name);
LLVMValueRef final_fun = LLVMGetNamedFunction(c->module, final);
// Allocate the object.
LLVMValueRef args[3];
args[0] = codegen_ctx(c);
LLVMValueRef result;
if(final_fun == NULL)
{
if(size <= HEAP_MAX)
{
uint32_t index = heap_index(size);
args[1] = LLVMConstInt(c->i32, index, false);
result = gencall_runtime(c, "pony_alloc_small", args, 2, "");
} else {
args[1] = LLVMConstInt(c->intptr, size, false);
result = gencall_runtime(c, "pony_alloc_large", args, 2, "");
}
} else {
args[1] = LLVMConstInt(c->intptr, size, false);
args[2] = LLVMConstBitCast(final_fun, c->final_fn);
result = gencall_runtime(c, "pony_alloc_final", args, 3, "");
}
result = LLVMBuildBitCast(c->builder, result, g->structure_ptr, "");
// Set the descriptor.
if(g->underlying != TK_STRUCT)
{
LLVMValueRef desc_ptr = LLVMBuildStructGEP(c->builder, result, 0, "");
LLVMBuildStore(c->builder, g->desc, desc_ptr);
}
return result;
}
void gen_send_message(compile_t* c, reach_method_t* m, LLVMValueRef orig_args[],
LLVMValueRef cast_args[], ast_t* args_ast)
{
// Allocate the message, setting its size and ID.
size_t msg_size = (size_t)LLVMABISizeOfType(c->target_data, m->msg_type);
LLVMTypeRef msg_type_ptr = LLVMPointerType(m->msg_type, 0);
LLVMValueRef msg_args[3];
msg_args[0] = LLVMConstInt(c->i32, ponyint_pool_index(msg_size), false);
msg_args[1] = LLVMConstInt(c->i32, m->vtable_index, false);
LLVMValueRef msg = gencall_runtime(c, "pony_alloc_msg", msg_args, 2, "");
LLVMValueRef msg_ptr = LLVMBuildBitCast(c->builder, msg, msg_type_ptr, "");
for(unsigned int i = 0; i < m->param_count; i++)
{
LLVMValueRef arg_ptr = LLVMBuildStructGEP(c->builder, msg_ptr, i + 3, "");
LLVMBuildStore(c->builder, cast_args[i+1], arg_ptr);
}
// Trace while populating the message contents.
ast_t* params = ast_childidx(m->r_fun, 3);
ast_t* param = ast_child(params);
ast_t* arg_ast = ast_child(args_ast);
bool need_trace = false;
while(param != NULL)
{
if(gentrace_needed(c, ast_type(arg_ast), ast_type(param)))
{
need_trace = true;
break;
}
param = ast_sibling(param);
arg_ast = ast_sibling(arg_ast);
}
LLVMValueRef ctx = codegen_ctx(c);
if(need_trace)
{
gencall_runtime(c, "pony_gc_send", &ctx, 1, "");
param = ast_child(params);
arg_ast = ast_child(args_ast);
for(size_t i = 0; i < m->param_count; i++)
{
gentrace(c, ctx, orig_args[i+1], cast_args[i+1], ast_type(arg_ast),
ast_type(param));
param = ast_sibling(param);
arg_ast = ast_sibling(arg_ast);
}
gencall_runtime(c, "pony_send_done", &ctx, 1, "");
}
// Send the message.
msg_args[0] = ctx;
msg_args[1] = LLVMBuildBitCast(c->builder, cast_args[0], c->object_ptr, "");
msg_args[2] = msg;
gencall_runtime(c, "pony_sendv", msg_args, 3, "");
}
static LLVMTypeRef send_message(compile_t* c, ast_t* fun, LLVMValueRef to,
LLVMValueRef func, uint32_t index)
{
// Get the parameter types.
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
int count = LLVMCountParamTypes(f_type) + 2;
size_t buf_size = count *sizeof(LLVMTypeRef);
LLVMTypeRef* f_params = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, &f_params[2]);
// The first one becomes the message size, the second the message ID.
f_params[0] = c->i32;
f_params[1] = c->i32;
f_params[2] = c->void_ptr;
LLVMTypeRef msg_type = LLVMStructTypeInContext(c->context, f_params, count,
false);
LLVMTypeRef msg_type_ptr = LLVMPointerType(msg_type, 0);
pool_free_size(buf_size, f_params);
// Allocate the message, setting its size and ID.
size_t msg_size = LLVMABISizeOfType(c->target_data, msg_type);
LLVMValueRef args[3];
args[0] = LLVMConstInt(c->i32, 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, "");
// Trace while populating the message contents.
LLVMValueRef ctx = codegen_ctx(c);
LLVMValueRef start_trace = gencall_runtime(c, "pony_gc_send", &ctx, 1, "");
ast_t* params = ast_childidx(fun, 3);
ast_t* param = ast_child(params);
bool need_trace = false;
for(int i = 3; i < count; i++)
{
LLVMValueRef arg = LLVMGetParam(func, i - 2);
LLVMValueRef arg_ptr = LLVMBuildStructGEP(c->builder, msg_ptr, i, "");
LLVMBuildStore(c->builder, arg, arg_ptr);
need_trace |= gentrace(c, ctx, arg, ast_type(param));
param = ast_sibling(param);
}
if(need_trace)
{
gencall_runtime(c, "pony_send_done", &ctx, 1, "");
} else {
LLVMInstructionEraseFromParent(start_trace);
}
// Send the message.
args[0] = ctx;
args[1] = LLVMBuildBitCast(c->builder, to, c->object_ptr, "");
args[2] = msg;
gencall_runtime(c, "pony_sendv", args, 3, "");
// Return the type of the message.
return msg_type_ptr;
}
void gen_send_message(compile_t* c, reach_method_t* m, LLVMValueRef args[],
ast_t* args_ast)
{
// Allocate the message, setting its size and ID.
compile_method_t* c_m = (compile_method_t*)m->c_method;
size_t msg_size = (size_t)LLVMABISizeOfType(c->target_data, c_m->msg_type);
LLVMTypeRef msg_type_ptr = LLVMPointerType(c_m->msg_type, 0);
size_t params_buf_size = (m->param_count + 3) * sizeof(LLVMTypeRef);
LLVMTypeRef* param_types =
(LLVMTypeRef*)ponyint_pool_alloc_size(params_buf_size);
LLVMGetStructElementTypes(c_m->msg_type, param_types);
size_t args_buf_size = (m->param_count + 1) * sizeof(LLVMValueRef);
LLVMValueRef* cast_args =
(LLVMValueRef*)ponyint_pool_alloc_size(args_buf_size);
size_t arg_types_buf_size = m->param_count * sizeof(ast_t*);
ast_t** arg_types = (ast_t**)ponyint_pool_alloc_size(arg_types_buf_size);
ast_t* arg_ast = ast_child(args_ast);
deferred_reification_t* reify = c->frame->reify;
for(size_t i = 0; i < m->param_count; i++)
{
arg_types[i] = deferred_reify(reify, ast_type(arg_ast), c->opt);
cast_args[i+1] = gen_assign_cast(c, param_types[i+3], args[i+1],
arg_types[i]);
arg_ast = ast_sibling(arg_ast);
}
LLVMValueRef msg_args[5];
msg_args[0] = LLVMConstInt(c->i32, ponyint_pool_index(msg_size), false);
msg_args[1] = LLVMConstInt(c->i32, m->vtable_index, false);
LLVMValueRef msg = gencall_runtime(c, "pony_alloc_msg", msg_args, 2, "");
LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);
LLVMSetMetadataStr(msg, "pony.msgsend", md);
LLVMValueRef msg_ptr = LLVMBuildBitCast(c->builder, msg, msg_type_ptr, "");
for(unsigned int i = 0; i < m->param_count; i++)
{
LLVMValueRef arg_ptr = LLVMBuildStructGEP(c->builder, msg_ptr, i + 3, "");
LLVMBuildStore(c->builder, cast_args[i+1], arg_ptr);
}
// Trace while populating the message contents.
bool need_trace = false;
for(size_t i = 0; i < m->param_count; i++)
{
if(gentrace_needed(c, arg_types[i], m->params[i].ast))
{
need_trace = true;
break;
}
}
LLVMValueRef ctx = codegen_ctx(c);
if(need_trace)
{
LLVMValueRef gc = gencall_runtime(c, "pony_gc_send", &ctx, 1, "");
LLVMSetMetadataStr(gc, "pony.msgsend", md);
for(size_t i = 0; i < m->param_count; i++)
{
gentrace(c, ctx, args[i+1], cast_args[i+1], arg_types[i],
m->params[i].ast);
}
gc = gencall_runtime(c, "pony_send_done", &ctx, 1, "");
LLVMSetMetadataStr(gc, "pony.msgsend", md);
}
// Send the message.
msg_args[0] = ctx;
msg_args[1] = LLVMBuildBitCast(c->builder, args[0], c->object_ptr, "");
msg_args[2] = msg;
msg_args[3] = msg;
msg_args[4] = LLVMConstInt(c->i1, 1, false);
LLVMValueRef send;
if(ast_id(m->fun->ast) == TK_NEW)
send = gencall_runtime(c, "pony_sendv_single", msg_args, 5, "");
else
send = gencall_runtime(c, "pony_sendv", msg_args, 5, "");
LLVMSetMetadataStr(send, "pony.msgsend", md);
ponyint_pool_free_size(params_buf_size, param_types);
ponyint_pool_free_size(args_buf_size, cast_args);
for(size_t i = 0; i < m->param_count; i++)
ast_free_unattached(arg_types[i]);
ponyint_pool_free_size(arg_types_buf_size, arg_types);
}
