static LLVMValueRef genfun_newbe(compile_t* c, gentype_t* g, const char *name,
ast_t* typeargs)
{
ast_t* fun = get_fun(g, name, typeargs);
LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);
if(func == NULL)
{
ast_free_unattached(fun);
return NULL;
}
codegen_startfun(c, func, ast_debug(fun));
name_params(c, g->ast, ast_childidx(fun, 3), func);
genfun_dwarf(c, g, name, typeargs, fun);
if(!gen_field_init(c, g))
{
ast_free_unattached(fun);
return NULL;
}
ast_t* body = ast_childidx(fun, 6);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
{
ast_free_unattached(fun);
return NULL;
}
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
// Generate the sender.
LLVMValueRef sender = get_sender(c, g, name, typeargs);
codegen_startfun(c, sender, false);
LLVMValueRef this_ptr = LLVMGetParam(sender, 0);
// Send the arguments in a message to 'this'.
uint32_t index = genfun_vtable_index(c, g, name, typeargs);
LLVMTypeRef msg_type_ptr = send_message(c, fun, this_ptr, sender, index);
genfun_dwarf_return(c, body);
// Return 'this'.
LLVMBuildRet(c->builder, this_ptr);
codegen_finishfun(c);
// Add the dispatch case.
add_dispatch_case(c, g, fun, index, func, msg_type_ptr);
ast_free_unattached(fun);
return func;
}
void genprim_string_deserialise(compile_t* c, reach_type_t* t)
{
// Generate the deserisalise function.
t->deserialise_fn = codegen_addfun(c, genname_serialise(t->name),
c->trace_type);
codegen_startfun(c, t->deserialise_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->deserialise_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(t->deserialise_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->deserialise_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"");
gendeserialise_typeid(c, t, object);
// Deserialise the string contents.
LLVMValueRef alloc = field_value(c, object, 2);
LLVMValueRef ptr_offset = field_value(c, object, 3);
ptr_offset = LLVMBuildPtrToInt(c->builder, ptr_offset, c->intptr, "");
LLVMValueRef args[3];
args[0] = ctx;
args[1] = ptr_offset;
args[2] = alloc;
LLVMValueRef ptr_addr = gencall_runtime(c, "pony_deserialise_block", args, 3,
"");
LLVMValueRef ptr = LLVMBuildStructGEP(c->builder, object, 3, "");
LLVMBuildStore(c->builder, ptr_addr, ptr);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
static void start_function(compile_t* c, reach_method_t* m,
LLVMTypeRef result, LLVMTypeRef* params, unsigned count)
{
m->func_type = LLVMFunctionType(result, params, count, false);
m->func = codegen_addfun(c, m->full_name, m->func_type);
codegen_startfun(c, m->func, NULL, NULL);
}
static void make_rdtscp(compile_t* c)
{
if(target_is_x86(c->opt->triple))
{
// i64 @llvm.x86.rdtscp(i8*)
LLVMTypeRef f_type = LLVMFunctionType(c->i64, &c->void_ptr, 1, false);
LLVMValueRef rdtscp = LLVMAddFunction(c->module, "llvm.x86.rdtscp",
f_type);
// i64 @internal.x86.rdtscp(i32*)
LLVMTypeRef i32_ptr = LLVMPointerType(c->i32, 0);
f_type = LLVMFunctionType(c->i64, &i32_ptr, 1, false);
LLVMValueRef fun = codegen_addfun(c, "internal.x86.rdtscp", f_type);
LLVMSetFunctionCallConv(fun, LLVMCCallConv);
codegen_startfun(c, fun, NULL, NULL);
// Cast i32* to i8* and call the intrinsic.
LLVMValueRef arg = LLVMGetParam(fun, 0);
arg = LLVMBuildBitCast(c->builder, arg, c->void_ptr, "");
LLVMValueRef result = LLVMBuildCall(c->builder, rdtscp, &arg, 1, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
} else {
(void)c;
}
}
static void make_dispatch(compile_t* c, gentype_t* g)
{
// Do nothing if we're not an actor.
if(g->underlying != TK_ACTOR)
return;
// Create a dispatch function.
const char* dispatch_name = genname_dispatch(g->type_name);
g->dispatch_fn = codegen_addfun(c, dispatch_name, c->dispatch_type);
LLVMSetFunctionCallConv(g->dispatch_fn, LLVMCCallConv);
codegen_startfun(c, g->dispatch_fn, false);
LLVMBasicBlockRef unreachable = codegen_block(c, "unreachable");
// Read the message ID.
LLVMValueRef msg = LLVMGetParam(g->dispatch_fn, 2);
LLVMValueRef id_ptr = LLVMBuildStructGEP(c->builder, msg, 1, "");
LLVMValueRef id = LLVMBuildLoad(c->builder, id_ptr, "id");
// Store a reference to the dispatch switch. When we build behaviours, we
// will add cases to this switch statement based on message ID.
g->dispatch_switch = LLVMBuildSwitch(c->builder, id, unreachable, 0);
// Mark the default case as unreachable.
LLVMPositionBuilderAtEnd(c->builder, unreachable);
LLVMBuildUnreachable(c->builder);
codegen_finishfun(c);
}
static bool genfun_allocator(compile_t* c, gentype_t* g)
{
// No allocator for primitive types or pointers.
if((g->primitive != NULL) || is_pointer(g->ast))
return true;
const char* funname = genname_fun(g->type_name, "Alloc", NULL);
LLVMTypeRef ftype = LLVMFunctionType(g->use_type, NULL, 0, false);
LLVMValueRef fun = codegen_addfun(c, funname, ftype);
codegen_startfun(c, fun, false);
LLVMValueRef result;
switch(g->underlying)
{
case TK_PRIMITIVE:
case TK_CLASS:
// Allocate the object or return the global instance.
result = gencall_alloc(c, g);
break;
case TK_ACTOR:
// Allocate the actor.
result = gencall_create(c, g);
break;
default:
assert(0);
return false;
}
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
return true;
}
static bool genfun_new(compile_t* c, reachable_type_t* t,
reachable_method_t* m)
{
assert(m->func != NULL);
AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, result, can_error,
body);
codegen_startfun(c, m->func, m->di_file, m->di_method);
name_params(c, t, m, params, m->func);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
return false;
// Return 'this'.
if(t->primitive == NULL)
value = LLVMGetParam(m->func, 0);
codegen_debugloc(c, ast_childlast(body));
LLVMBuildRet(c->builder, value);
codegen_debugloc(c, NULL);
codegen_finishfun(c);
return true;
}
void genprim_string_serialise_trace(compile_t* c, reach_type_t* t)
{
// Generate the serialise_trace function.
t->serialise_trace_fn = codegen_addfun(c, genname_serialise_trace(t->name),
c->serialise_type);
codegen_startfun(c, t->serialise_trace_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->serialise_trace_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(t->serialise_trace_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->serialise_trace_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->use_type, "");
// Read the size.
LLVMValueRef size = field_value(c, object, 1);
LLVMValueRef alloc = LLVMBuildAdd(c->builder, size,
LLVMConstInt(c->intptr, 1, false), "");
// Reserve space for the contents.
LLVMValueRef ptr = field_value(c, object, 3);
LLVMValueRef args[3];
args[0] = ctx;
args[1] = ptr;
args[2] = alloc;
gencall_runtime(c, "pony_serialise_reserve", args, 3, "");
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
static void make_serialise(compile_t* c, reach_type_t* t)
{
// Use the trace function as the serialise_trace function.
t->serialise_trace_fn = t->trace_fn;
// 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);
LLVMSetLinkage(t->serialise_fn, LLVMExternalLinkage);
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 object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"");
LLVMValueRef offset_addr = LLVMBuildInBoundsGEP(c->builder, addr, &offset, 1,
"");
serialise(c, t, ctx, object, offset_addr);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
static bool genfun_newbe(compile_t* c, reachable_type_t* t,
reachable_method_t* m)
{
assert(m->func != NULL);
assert(m->func_handler != NULL);
AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, result, can_error,
body);
// Generate the handler.
codegen_startfun(c, m->func_handler, m->di_file, m->di_method);
name_params(c, t, m, params, m->func_handler);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
return false;
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
// Generate the sender.
codegen_startfun(c, m->func, NULL, NULL);
LLVMValueRef this_ptr = LLVMGetParam(m->func, 0);
// Send the arguments in a message to 'this'.
LLVMTypeRef msg_type_ptr = send_message(c, params, this_ptr, m->func,
m->vtable_index);
// Return 'this'.
codegen_debugloc(c, ast_childlast(body));
LLVMBuildRet(c->builder, this_ptr);
codegen_debugloc(c, NULL);
codegen_finishfun(c);
// Add the dispatch case.
add_dispatch_case(c, t, params, m->vtable_index, m->func_handler,
msg_type_ptr);
return true;
}
static bool make_trace(compile_t* c, gentype_t* g)
{
// Do nothing if we have no fields.
if(g->field_count == 0)
return true;
if(g->underlying == TK_CLASS)
{
// Special case the array trace function.
AST_GET_CHILDREN(g->ast, pkg, id);
const char* package = ast_name(pkg);
const char* name = ast_name(id);
if((package == c->str_builtin) && (name == c->str_Array))
{
genprim_array_trace(c, g);
return true;
}
}
// Create a trace function.
const char* trace_name = genname_trace(g->type_name);
LLVMValueRef trace_fn = codegen_addfun(c, trace_name, c->trace_type);
codegen_startfun(c, trace_fn, false);
LLVMSetFunctionCallConv(trace_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(trace_fn, 0);
LLVMValueRef arg = LLVMGetParam(trace_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, g->structure_ptr,
"object");
// If we don't ever trace anything, delete this function.
int extra = 0;
// Non-structs have a type descriptor.
if(g->underlying != TK_STRUCT)
extra++;
// Actors have a pad.
if(g->underlying == TK_ACTOR)
extra++;
bool need_trace = trace_fields(c, g, ctx, object, extra);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
if(!need_trace)
LLVMDeleteFunction(trace_fn);
return true;
}
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 bool genfun_fun(compile_t* c, reachable_type_t* t,
reachable_method_t* m)
{
assert(m->func != NULL);
AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, result, can_error,
body);
if(m->name == c->str__final)
{
t->final_fn = m->func;
LLVMSetFunctionCallConv(m->func, LLVMCCallConv);
}
codegen_startfun(c, m->func, m->di_file, m->di_method);
name_params(c, t, m, params, m->func);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
return false;
if(value != GEN_NOVALUE)
{
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(m->func));
LLVMTypeRef r_type = LLVMGetReturnType(f_type);
// If the result type is known to be a tuple, do the correct assignment
// cast even if the body type is not a tuple.
ast_t* body_type = ast_type(body);
if(ast_id(result) == TK_TUPLETYPE)
body_type = result;
LLVMValueRef ret = gen_assign_cast(c, r_type, value, body_type);
if(ret == NULL)
return false;
codegen_debugloc(c, ast_childlast(body));
LLVMBuildRet(c->builder, ret);
codegen_debugloc(c, NULL);
}
codegen_finishfun(c);
return true;
}
static LLVMValueRef genfun_new(compile_t* c, gentype_t* g, const char *name,
ast_t* typeargs)
{
ast_t* fun = get_fun(g, name, typeargs);
LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);
if(func == NULL)
{
ast_free_unattached(fun);
return NULL;
}
if(LLVMCountBasicBlocks(func) != 0)
{
ast_free_unattached(fun);
return func;
}
codegen_startfun(c, func, ast_debug(fun));
name_params(c, g->ast, ast_childidx(fun, 3), func);
genfun_dwarf(c, g, name, typeargs, fun);
if(!gen_field_init(c, g))
{
ast_free_unattached(fun);
return NULL;
}
ast_t* body = ast_childidx(fun, 6);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
{
ast_free_unattached(fun);
return NULL;
}
genfun_dwarf_return(c, body);
// Return 'this'.
LLVMBuildRet(c->builder, LLVMGetParam(func, 0));
codegen_finishfun(c);
ast_free_unattached(fun);
return func;
}
static LLVMValueRef genfun_fun(compile_t* c, gentype_t* g, const char *name,
ast_t* typeargs)
{
ast_t* fun = get_fun(g, name, typeargs);
LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);
if(func == NULL)
{
ast_free_unattached(fun);
return NULL;
}
if(LLVMCountBasicBlocks(func) != 0)
{
ast_free_unattached(fun);
return func;
}
codegen_startfun(c, func, ast_debug(fun));
name_params(c, g->ast, ast_childidx(fun, 3), func);
genfun_dwarf(c, g, name, typeargs, fun);
ast_t* body = ast_childidx(fun, 6);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
{
ast_free_unattached(fun);
return NULL;
} else if(value != GEN_NOVALUE) {
genfun_dwarf_return(c, body);
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef r_type = LLVMGetReturnType(f_type);
LLVMValueRef ret = gen_assign_cast(c, r_type, value, ast_type(body));
LLVMBuildRet(c->builder, ret);
}
codegen_finishfun(c);
ast_free_unattached(fun);
return func;
}
void genprim_array_trace(compile_t* c, reach_type_t* t)
{
codegen_startfun(c, t->trace_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->trace_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(t->trace_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->trace_fn, 1);
// Read the base pointer.
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->use_type, "");
LLVMValueRef pointer = field_value(c, object, 3);
// Trace the base pointer.
LLVMValueRef args[2];
args[0] = ctx;
args[1] = pointer;
gencall_runtime(c, "pony_trace", args, 2, "");
trace_array_elements(c, t, ctx, object, pointer);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
void genprim_array_serialise_trace(compile_t* c, reach_type_t* t)
{
// Generate the serialise_trace function.
t->serialise_trace_fn = codegen_addfun(c, genname_serialise_trace(t->name),
c->trace_type);
codegen_startfun(c, t->serialise_trace_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->serialise_trace_fn, LLVMCCallConv);
LLVMSetLinkage(t->serialise_trace_fn, LLVMExternalLinkage);
LLVMValueRef ctx = LLVMGetParam(t->serialise_trace_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->serialise_trace_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->use_type, "");
// Read the size.
LLVMValueRef size = field_value(c, object, 1);
// Calculate the size of the element type.
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);
// Reserve space for the array elements.
LLVMValueRef pointer = field_value(c, object, 3);
LLVMValueRef args[3];
args[0] = ctx;
args[1] = pointer;
args[2] = LLVMBuildMul(c->builder, size, l_size, "");
gencall_runtime(c, "pony_serialise_reserve", args, 3, "");
// Trace the array elements.
trace_array_elements(c, t, ctx, object, pointer);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
void gen_digestof_fun(compile_t* c, reach_type_t* t)
{
pony_assert(t->can_be_boxed);
reach_method_t* m = reach_method(t, TK_BOX, stringtab("__digestof"), NULL);
if(m == NULL)
return;
compile_type_t* c_t = (compile_type_t*)t->c_type;
compile_method_t* c_m = (compile_method_t*)m->c_method;
c_m->func_type = LLVMFunctionType(c->intptr, &c_t->structure_ptr, 1, false);
c_m->func = codegen_addfun(c, m->full_name, c_m->func_type, true);
codegen_startfun(c, c_m->func, NULL, NULL, NULL, false);
LLVMValueRef value = LLVMGetParam(codegen_fun(c), 0);
value = gen_unbox(c, t->ast_cap, value);
LLVMBuildRet(c->builder, gen_digestof_value(c, t->ast_cap, value));
codegen_finishfun(c);
}
static void make_deserialise(compile_t* c, reach_type_t* t)
{
// Generate the deserialise function.
t->deserialise_fn = codegen_addfun(c, genname_deserialise(t->name),
c->trace_type);
codegen_startfun(c, t->deserialise_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->deserialise_fn, LLVMCCallConv);
LLVMSetLinkage(t->deserialise_fn, LLVMExternalLinkage);
LLVMValueRef ctx = LLVMGetParam(t->deserialise_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->deserialise_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"");
// At this point, the serialised contents have been copied to the allocated
// object.
deserialise(c, t, ctx, object);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
static void make_cpuid(compile_t* c)
{
if(target_is_x86(c->opt->triple))
{
LLVMTypeRef elems[4] = {c->i32, c->i32, c->i32, c->i32};
LLVMTypeRef r_type = LLVMStructTypeInContext(c->context, elems, 4, false);
LLVMTypeRef f_type = LLVMFunctionType(r_type, &c->i32, 1, false);
LLVMValueRef fun = codegen_addfun(c, "internal.x86.cpuid", f_type);
LLVMSetFunctionCallConv(fun, LLVMCCallConv);
codegen_startfun(c, fun, NULL, NULL);
LLVMValueRef cpuid = LLVMConstInlineAsm(f_type,
"cpuid", "={ax},={bx},={cx},={dx},{ax}", false, false);
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
LLVMValueRef result = LLVMBuildCall(c->builder, cpuid, &zero, 1, "");
LLVMBuildRet(c->builder, result);
codegen_finishfun(c);
} else {
(void)c;
}
}
void gen_is_tuple_fun(compile_t* c, reach_type_t* t)
{
pony_assert(t->underlying == TK_TUPLETYPE);
reach_method_t* m = reach_method(t, TK_BOX, stringtab("__is"), NULL);
pony_assert(m != NULL);
LLVMTypeRef params[2];
params[0] = t->structure_ptr;
params[1] = t->structure_ptr;
m->func_type = LLVMFunctionType(c->i1, params, 2, false);
m->func = codegen_addfun(c, m->full_name, m->func_type);
codegen_startfun(c, m->func, NULL, NULL);
LLVMValueRef l_value = LLVMGetParam(codegen_fun(c), 0);
LLVMValueRef r_value = LLVMGetParam(codegen_fun(c), 1);
l_value = gen_unbox(c, t->ast_cap, l_value);
r_value = gen_unbox(c, t->ast_cap, r_value);
LLVMBuildRet(c->builder, tuple_is(c, t->ast_cap, t->ast_cap, l_value,
r_value));
codegen_finishfun(c);
}
static bool make_nominal(compile_t* c, ast_t* ast, gentype_t* g, bool prelim)
{
assert(ast_id(ast) == TK_NOMINAL);
ast_t* def = (ast_t*)ast_data(ast);
token_id id = ast_id(def);
// For traits, just return a raw object pointer.
switch(id)
{
case TK_INTERFACE:
case TK_TRAIT:
g->underlying = id;
g->use_type = c->object_ptr;
dwarf_trait(&c->dwarf, g);
return true;
default: {}
}
// If we already exist or we're preliminary, we're done.
if(setup_name(c, ast, g, prelim))
return true;
if(g->primitive == NULL)
{
// Not a primitive type. Generate all the fields and a trace function.
setup_type_fields(g);
// Forward declare debug symbols for this nominal, if needed.
// At this point, this can only be TK_STRUCT, TK_CLASS, TK_PRIMITIVE, or
// TK_ACTOR ast nodes. TK_TYPE has been translated to any of the former
// during reification.
dwarf_forward(&c->dwarf, g);
bool ok = make_struct(c, g);
if(!g->done)
ok = ok && make_trace(c, g) && make_components(c, g);
if(!ok)
{
free_fields(g);
return false;
}
// Finalise symbols for composite type.
if(!g->done)
dwarf_composite(&c->dwarf, g);
} else {
// Emit debug symbols for a basic type (U8, U16, U32...)
dwarf_basic(&c->dwarf, g);
// Create a box type.
make_box_type(c, g);
}
if(!g->done)
{
// Generate a dispatch function if necessary.
make_dispatch(c, g);
// Create a unique global instance if we need one.
make_global_instance(c, g);
// Generate all the methods.
if(!genfun_methods(c, g))
{
free_fields(g);
return false;
}
if(g->underlying != TK_STRUCT)
gendesc_init(c, g);
// Finish off the dispatch function.
if(g->underlying == TK_ACTOR)
{
codegen_startfun(c, g->dispatch_fn, false);
codegen_finishfun(c);
}
// Finish the dwarf frame.
dwarf_finish(&c->dwarf);
}
free_fields(g);
g->done = true;
return true;
}
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);
}
static void gen_main(compile_t* c, gentype_t* main_g, gentype_t* env_g)
{
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, false);
LLVMValueRef args[3];
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[1], "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 main_actor = create_main(c, main_g);
// Create an Env on the main actor's heap.
const char* env_name = "Env";
const char* env_create = genname_fun(env_name, "_create", NULL);
LLVMValueRef env_args[4];
env_args[0] = gencall_alloc(c, env_g);
env_args[1] = LLVMBuildZExt(c->builder, args[0], c->i64, "");
env_args[2] = args[1];
env_args[3] = args[2];
LLVMValueRef env = gencall_runtime(c, env_create, env_args, 4, "env");
LLVMSetInstructionCallConv(env, GEN_CALLCONV);
// Run primitive initialisers using the main actor's heap.
primitive_call(c, stringtab("_init"), env);
// 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 = genfun_vtable_index(c, main_g, stringtab("create"), NULL);
size_t msg_size = LLVMABISizeOfType(c->target_data, msg_type);
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, "");
// Set the message contents.
LLVMValueRef env_ptr = LLVMBuildStructGEP(c->builder, msg_ptr, 3, "");
LLVMBuildStore(c->builder, env, env_ptr);
// Trace the message.
gencall_runtime(c, "pony_gc_send", NULL, 0, "");
const char* env_trace = genname_trace(env_name);
args[0] = LLVMBuildBitCast(c->builder, env, c->object_ptr, "");
args[1] = LLVMGetNamedFunction(c->module, env_trace);
gencall_runtime(c, "pony_traceobject", args, 2, "");
gencall_runtime(c, "pony_send_done", NULL, 0, "");
// Send the message.
args[0] = main_actor;
args[1] = msg;
gencall_runtime(c, "pony_sendv", args, 2, "");
// 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.
LLVMValueRef final_actor = create_main(c, main_g);
primitive_call(c, stringtab("_final"), NULL);
args[0] = final_actor;
gencall_runtime(c, "pony_destroy", args, 1, "");
// Return the runtime exit code.
LLVMBuildRet(c->builder, rc);
codegen_finishfun(c);
// External linkage for main().
LLVMSetLinkage(func, LLVMExternalLinkage);
}
static bool make_trace(compile_t* c, reach_type_t* t)
{
if(t->trace_fn == NULL)
return true;
if(t->underlying == TK_CLASS)
{
// Special case the array trace function.
AST_GET_CHILDREN(t->ast, pkg, id);
const char* package = ast_name(pkg);
const char* name = ast_name(id);
if((package == c->str_builtin) && (name == c->str_Array))
{
genprim_array_trace(c, t);
return true;
}
}
// Generate the trace function.
codegen_startfun(c, t->trace_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->trace_fn, LLVMCCallConv);
LLVMSetLinkage(t->trace_fn, LLVMExternalLinkage);
LLVMValueRef ctx = LLVMGetParam(t->trace_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->trace_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"object");
int extra = 0;
// Non-structs have a type descriptor.
if(t->underlying != TK_STRUCT)
extra++;
// Actors have a pad.
if(t->underlying == TK_ACTOR)
extra++;
for(uint32_t i = 0; i < t->field_count; i++)
{
LLVMValueRef field = LLVMBuildStructGEP(c->builder, object, i + extra, "");
if(!t->fields[i].embed)
{
// Call the trace function indirectly depending on rcaps.
LLVMValueRef value = LLVMBuildLoad(c->builder, field, "");
gentrace(c, ctx, value, t->fields[i].ast);
} else {
// Call the trace function directly without marking the field.
LLVMValueRef trace_fn = t->fields[i].type->trace_fn;
if(trace_fn != NULL)
{
LLVMValueRef args[2];
args[0] = ctx;
args[1] = LLVMBuildBitCast(c->builder, field, c->object_ptr, "");
LLVMBuildCall(c->builder, trace_fn, args, 2, "");
}
}
}
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
return true;
}
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);
}
void genprim_string_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, and rewrite alloc to be size + 1.
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 = LLVMBuildAdd(c->builder, size,
LLVMConstInt(c->intptr, 1, false), "");
LLVMValueRef alloc_loc = field_loc(c, offset_addr, t->structure,
c->intptr, 2);
LLVMBuildStore(c->builder, alloc, alloc_loc);
// Write the pointer.
LLVMValueRef ptr = field_value(c, object, 3);
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);
// Serialise the string contents.
LLVMValueRef ptr_offset_addr = LLVMBuildAdd(c->builder,
LLVMBuildPtrToInt(c->builder, addr, c->intptr, ""), ptr_offset, "");
args[0] = LLVMBuildIntToPtr(c->builder, ptr_offset_addr, c->void_ptr, "");
args[1] = LLVMBuildBitCast(c->builder, field_value(c, object, 3),
c->void_ptr, "");
args[2] = alloc;
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, "");
}
LLVMBuildBr(c->builder, post_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
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);
}
void genprim_array_deserialise(compile_t* c, reach_type_t* t)
{
// Generate the deserisalise function.
t->deserialise_fn = codegen_addfun(c, genname_serialise(t->name),
c->trace_type);
codegen_startfun(c, t->deserialise_fn, NULL, NULL);
LLVMSetFunctionCallConv(t->deserialise_fn, LLVMCCallConv);
LLVMValueRef ctx = LLVMGetParam(t->deserialise_fn, 0);
LLVMValueRef arg = LLVMGetParam(t->deserialise_fn, 1);
LLVMValueRef object = LLVMBuildBitCast(c->builder, arg, t->structure_ptr,
"");
gendeserialise_typeid(c, t, object);
// Deserialise the array contents.
LLVMValueRef alloc = field_value(c, object, 2);
LLVMValueRef ptr_offset = field_value(c, object, 3);
ptr_offset = LLVMBuildPtrToInt(c->builder, ptr_offset, c->intptr, "");
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);
LLVMValueRef args[3];
args[0] = ctx;
args[1] = ptr_offset;
args[2] = LLVMBuildMul(c->builder, alloc, l_size, "");
LLVMValueRef ptr = gencall_runtime(c, "pony_deserialise_block", args, 3, "");
LLVMValueRef ptr_loc = LLVMBuildStructGEP(c->builder, object, 3, "");
LLVMBuildStore(c->builder, ptr, ptr_loc);
if((t_elem->underlying == TK_PRIMITIVE) && (t_elem->primitive != NULL))
{
// Do nothing. A memcpy is sufficient.
} else {
LLVMValueRef size = field_value(c, object, 1);
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");
LLVMBuildBr(c->builder, cond_block);
// While the index is less than the size, deserialise 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 deserialise it.
LLVMPositionBuilderAtEnd(c->builder, body_block);
LLVMValueRef elem_ptr = LLVMBuildGEP(c->builder, ptr, &phi, 1, "");
gendeserialise_element(c, t_elem, false, ctx, elem_ptr);
// 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);
}
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
}
