LLVMValueRef genfun_proto(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);
// Disable debugloc on calls to methods that have no debug info.
if(!ast_debug(fun))
dwarf_location(&c->dwarf, NULL);
switch(ast_id(fun))
{
case TK_NEW:
case TK_BE:
if(g->underlying == TK_ACTOR)
{
const char* fun_name = genname_fun(g->type_name, name, typeargs);
const char* be_name = genname_be(fun_name);
func = LLVMGetNamedFunction(c->module, be_name);
}
break;
default: {}
}
ast_free_unattached(fun);
return func;
}
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);
}
void codegen_finishfun(compile_t* c)
{
if(c->frame->restore_builder != NULL)
LLVMPositionBuilderAtEnd(c->builder, c->frame->restore_builder);
// Reset debug locations
dwarf_location(&c->dwarf, NULL);
pop_frame(c);
}
LLVMValueRef gencall_create(compile_t* c, gentype_t* g)
{
// Disable debug anchor
dwarf_location(&c->dwarf, NULL);
LLVMValueRef args[2];
args[0] = codegen_ctx(c);
args[1] = LLVMConstBitCast(g->desc, c->descriptor_ptr);
LLVMValueRef result = gencall_runtime(c, "pony_create", args, 2, "");
return LLVMBuildBitCast(c->builder, result, g->use_type, "");
}
LLVMValueRef gencall_runtime(compile_t* c, const char *name,
LLVMValueRef* args, int count, const char* ret)
{
// Disable debug anchor
dwarf_location(&c->dwarf, NULL);
LLVMValueRef func = LLVMGetNamedFunction(c->module, name);
if(func == NULL)
return NULL;
return LLVMBuildCall(c->builder, func, args, count, ret);
}
void gencall_throw(compile_t* c)
{
// Disable debug location for throw calls
dwarf_location(&c->dwarf, NULL);
LLVMValueRef func = LLVMGetNamedFunction(c->module, "pony_throw");
if(c->frame->invoke_target != NULL)
invoke_fun(c, func, NULL, 0, "", false);
else
LLVMBuildCall(c->builder, func, NULL, 0, "");
LLVMBuildUnreachable(c->builder);
}
LLVMValueRef gen_assign(compile_t* c, ast_t* ast)
{
// Must generate the right hand side before the left hand side. Left and
// right are swapped for type checking, so we fetch them in reverse order.
AST_GET_CHILDREN(ast, right, left);
LLVMValueRef r_value = gen_expr(c, right);
// Emit debug location of assignment expression
dwarf_location(&c->dwarf, ast);
if(r_value == NULL)
return NULL;
return assign_rvalue(c, left, ast_type(right), r_value);
}
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 = ponyint_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 codegen_startfun(compile_t* c, LLVMValueRef fun, bool has_source)
{
compile_frame_t* frame = push_frame(c);
frame->fun = fun;
frame->restore_builder = LLVMGetInsertBlock(c->builder);
frame->has_source = has_source;
frame->is_function = true;
c->dwarf.has_source = has_source;
// Reset debug locations
dwarf_location(&c->dwarf, NULL);
if(LLVMCountBasicBlocks(fun) == 0)
{
LLVMBasicBlockRef block = codegen_block(c, "entry");
LLVMPositionBuilderAtEnd(c->builder, block);
}
}
static bool gen_field_init(compile_t* c, gentype_t* g)
{
LLVMValueRef this_ptr = LLVMGetParam(codegen_fun(c), 0);
ast_t* def = (ast_t*)ast_data(g->ast);
ast_t* members = ast_childidx(def, 4);
ast_t* member = ast_child(members);
// Struct index of the current field.
int index = 1;
if(ast_id(def) == TK_ACTOR)
index++;
// Iterate through all fields.
while(member != NULL)
{
switch(ast_id(member))
{
case TK_FVAR:
case TK_FLET:
{
// Skip this field if it has no initialiser.
AST_GET_CHILDREN(member, id, type, body);
if(ast_id(body) != TK_NONE)
{
// Reify the initialiser.
ast_t* this_type = set_cap_and_ephemeral(g->ast, TK_REF, TK_NONE);
ast_t* var = lookup(NULL, NULL, this_type, ast_name(id));
ast_free_unattached(this_type);
assert(var != NULL);
body = ast_childidx(var, 2);
// Get the field pointer.
dwarf_location(&c->dwarf, body);
LLVMValueRef l_value = LLVMBuildStructGEP(c->builder, this_ptr,
index, "");
// Cast the initialiser to the field type.
LLVMValueRef r_value = gen_expr(c, body);
if(r_value == NULL)
return false;
LLVMTypeRef l_type = LLVMGetElementType(LLVMTypeOf(l_value));
LLVMValueRef cast_value = gen_assign_cast(c, l_type, r_value,
ast_type(body));
if(cast_value == NULL)
return false;
// Store the result.
LLVMBuildStore(c->builder, cast_value, l_value);
}
index++;
break;
}
default: {}
}
member = ast_sibling(member);
}
return true;
}
static void genfun_dwarf_return(compile_t* c, ast_t* body)
{
ast_t* last = ast_childlast(body);
dwarf_location(&c->dwarf, last);
}
LLVMValueRef gen_ffi(compile_t* c, ast_t* ast)
{
AST_GET_CHILDREN(ast, id, typeargs, args, named_args, can_err);
bool err = (ast_id(can_err) == TK_QUESTION);
// Get the function name, +1 to skip leading @
const char* f_name = ast_name(id) + 1;
// Generate the return type.
ast_t* type = ast_type(ast);
gentype_t g;
// Emit dwarf location of ffi call
dwarf_location(&c->dwarf, ast);
if(!gentype(c, type, &g))
return NULL;
// Get the function.
LLVMValueRef func = LLVMGetNamedFunction(c->module, f_name);
if(func == NULL)
{
// If we have no prototype, declare one.
ast_t* decl = (ast_t*)ast_data(ast);
if(decl != NULL)
{
// Define using the declared types.
AST_GET_CHILDREN(decl, decl_id, decl_ret, decl_params, decl_err);
err = (ast_id(decl_err) == TK_QUESTION);
func = declare_ffi(c, f_name, &g, decl_params, err);
} else if(!strncmp(f_name, "llvm.", 5)) {
// Intrinsic, so use the exact types we supply.
func = declare_ffi(c, f_name, &g, args, err);
} else {
// Make it varargs.
func = declare_ffi_vararg(c, f_name, &g, err);
}
}
// Generate the arguments.
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMValueRef);
LLVMValueRef* f_args = (LLVMValueRef*)ponyint_pool_alloc_size(buf_size);
LLVMTypeRef f_type = LLVMGetElementType(LLVMTypeOf(func));
LLVMTypeRef* f_params = NULL;
bool vararg = (LLVMIsFunctionVarArg(f_type) != 0);
if(!vararg)
{
f_params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetParamTypes(f_type, f_params);
}
ast_t* arg = ast_child(args);
for(int i = 0; i < count; i++)
{
f_args[i] = gen_expr(c, arg);
if(!vararg && (LLVMGetTypeKind(f_params[i]) == LLVMPointerTypeKind))
{
if(LLVMGetTypeKind(LLVMTypeOf(f_args[i])) == LLVMIntegerTypeKind)
f_args[i] = LLVMBuildIntToPtr(c->builder, f_args[i], f_params[i], "");
else
f_args[i] = LLVMBuildBitCast(c->builder, f_args[i], f_params[i], "");
}
if(f_args[i] == NULL)
{
ponyint_pool_free_size(buf_size, f_args);
return NULL;
}
arg = ast_sibling(arg);
}
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
LLVMValueRef result;
if(err && (c->frame->invoke_target != NULL))
result = invoke_fun(c, func, f_args, count, "", false);
else
result = LLVMBuildCall(c->builder, func, f_args, count, "");
ponyint_pool_free_size(buf_size, f_args);
if(!vararg)
ponyint_pool_free_size(buf_size, f_params);
// Special case a None return value, which is used for void functions.
if(is_none(type))
return g.instance;
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:
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;
}
LLVMValueRef gen_ffi(compile_t* c, ast_t* ast)
{
AST_GET_CHILDREN(ast, id, typeargs, args);
// Get the function name, +1 to skip leading @
const char* f_name = ast_name(id) + 1;
// Generate the return type.
ast_t* type = ast_type(ast);
gentype_t g;
// Emit dwarf location of ffi call
dwarf_location(&c->dwarf, ast);
if(!gentype(c, type, &g))
return NULL;
// Get the function.
LLVMValueRef func = LLVMGetNamedFunction(c->module, f_name);
if(func == NULL)
{
// If we have no prototype, declare one.
if(!strncmp(f_name, "llvm.", 5))
{
// Intrinsic, so use the exact types we supply.
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* f_params = (LLVMTypeRef*)pool_alloc_size(buf_size);
count = 0;
ast_t* arg = ast_child(args);
while(arg != NULL)
{
ast_t* p_type = ast_type(arg);
gentype_t param_g;
if(!gentype(c, p_type, ¶m_g))
return NULL;
f_params[count++] = param_g.use_type;
arg = ast_sibling(arg);
}
// We may have generated the function by generating a parameter type.
func = LLVMGetNamedFunction(c->module, f_name);
if(func == NULL)
{
LLVMTypeRef r_type;
if(g.underlying == TK_TUPLETYPE)
{
// Can't use the named type. Build an unnamed type with the same
// elements.
unsigned int count = LLVMCountStructElementTypes(g.use_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* e_types = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetStructElementTypes(g.use_type, e_types);
r_type = LLVMStructTypeInContext(c->context, e_types, count, false);
pool_free_size(buf_size, e_types);
} else {
r_type = g.use_type;
}
LLVMTypeRef f_type = LLVMFunctionType(r_type, f_params, count,
false);
func = LLVMAddFunction(c->module, f_name, f_type);
if(!ast_canerror(ast))
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
}
pool_free_size(buf_size, f_params);
} else {
// Make it varargs.
LLVMTypeRef f_type = LLVMFunctionType(g.use_type, NULL, 0, true);
func = LLVMAddFunction(c->module, f_name, f_type);
if(!ast_canerror(ast))
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
}
}
// Generate the arguments.
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMValueRef);
LLVMValueRef* f_args = (LLVMValueRef*)pool_alloc_size(buf_size);
ast_t* arg = ast_child(args);
for(int i = 0; i < count; i++)
{
f_args[i] = gen_expr(c, arg);
if(f_args[i] == NULL)
{
pool_free_size(buf_size, f_args);
return NULL;
}
arg = ast_sibling(arg);
}
// If we can error out and we have an invoke target, generate an invoke
// instead of a call.
LLVMValueRef result;
if(ast_canerror(ast) && (c->frame->invoke_target != NULL))
result = invoke_fun(c, func, f_args, count, "", false);
else
result = LLVMBuildCall(c->builder, func, f_args, count, "");
pool_free_size(buf_size, f_args);
// Special case a None return value, which is used for void functions.
if(is_none(type))
return g.instance;
return result;
}