static LLVMValueRef
translateRecordExpr(SymbolTable *TyTable, SymbolTable *ValTable, ASTNode *Node) {
PtrVector *V = &(Node->Child);
ASTNode *FieldNode = (ASTNode*) ptrVectorGet(V, 0);
Type *ThisType = createType(IdTy, Node->Value);
LLVMTypeRef RecordType = getLLVMTypeFromType(TyTable, ThisType);
LLVMValueRef RecordVal = LLVMBuildMalloc(Builder, RecordType, "");
unsigned FieldNumber = LLVMCountStructElementTypes(RecordType),
I;
for (I = 0; I < FieldNumber; ++I) {
LLVMValueRef ElemIdx[] = { getSConstInt(0), getSConstInt(I) };
LLVMValueRef ElemI = LLVMBuildInBoundsGEP(Builder, RecordVal, ElemIdx, 2, "");
LLVMValueRef FieldPtr = translateExpr(TyTable, ValTable, ptrVectorGet(&(FieldNode->Child), I));
LLVMValueRef ValueFrom = NULL;
switch (LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(FieldPtr)))) {
case LLVMIntegerTypeKind:
case LLVMFloatTypeKind: ValueFrom = LLVMBuildLoad(Builder, FieldPtr, ""); break;
case LLVMPointerTypeKind: ValueFrom = toDynamicMemory(FieldPtr); break;
default: ValueFrom = FieldPtr;
}
LLVMBuildStore(Builder, ValueFrom, ElemI);
}
return RecordVal;
}
LLVMValueRef gen_tuple(compile_t* c, ast_t* ast)
{
ast_t* child = ast_child(ast);
if(ast_sibling(child) == NULL)
return gen_expr(c, child);
deferred_reification_t* reify = c->frame->reify;
ast_t* type = deferred_reify(reify, ast_type(ast), c->opt);
// If we contain '_', we have no usable value.
if(contains_dontcare(type))
{
ast_free_unattached(type);
return GEN_NOTNEEDED;
}
reach_type_t* t = reach_type(c->reach, type);
compile_type_t* c_t = (compile_type_t*)t->c_type;
int count = LLVMCountStructElementTypes(c_t->primitive);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* elements = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetStructElementTypes(c_t->primitive, elements);
LLVMValueRef tuple = LLVMGetUndef(c_t->primitive);
int i = 0;
while(child != NULL)
{
LLVMValueRef value = gen_expr(c, child);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, elements);
return NULL;
}
// We'll have an undefined element if one of our source elements is a
// variable declaration. This is ok, since the tuple value will never be
// used.
if(value == GEN_NOVALUE || value == GEN_NOTNEEDED)
{
ponyint_pool_free_size(buf_size, elements);
return value;
}
ast_t* child_type = deferred_reify(reify, ast_type(child), c->opt);
value = gen_assign_cast(c, elements[i], value, child_type);
ast_free_unattached(child_type);
tuple = LLVMBuildInsertValue(c->builder, tuple, value, i++, "");
child = ast_sibling(child);
}
ponyint_pool_free_size(buf_size, elements);
return tuple;
}
static LLVMValueRef gen_digestof_value(compile_t* c, LLVMValueRef value)
{
LLVMTypeRef type = LLVMTypeOf(value);
switch(LLVMGetTypeKind(type))
{
case LLVMFloatTypeKind:
value = LLVMBuildBitCast(c->builder, value, c->i32, "");
return LLVMBuildZExt(c->builder, value, c->i64, "");
case LLVMDoubleTypeKind:
return LLVMBuildBitCast(c->builder, value, c->i64, "");
case LLVMIntegerTypeKind:
{
uint32_t width = LLVMGetIntTypeWidth(type);
if(width < 64)
{
value = LLVMBuildZExt(c->builder, value, c->i64, "");
} else if(width == 128) {
LLVMValueRef shift = LLVMConstInt(c->i128, 64, false);
LLVMValueRef high = LLVMBuildLShr(c->builder, value, shift, "");
high = LLVMBuildTrunc(c->builder, high, c->i64, "");
value = LLVMBuildTrunc(c->builder, value, c->i64, "");
value = LLVMBuildXor(c->builder, value, high, "");
}
return value;
}
case LLVMStructTypeKind:
{
uint32_t count = LLVMCountStructElementTypes(type);
LLVMValueRef result = LLVMConstInt(c->i64, 0, false);
for(uint32_t i = 0; i < count; i++)
{
LLVMValueRef elem = LLVMBuildExtractValue(c->builder, value, i, "");
elem = gen_digestof_value(c, elem);
result = LLVMBuildXor(c->builder, result, elem, "");
}
return result;
}
case LLVMPointerTypeKind:
return LLVMBuildPtrToInt(c->builder, value, c->i64, "");
default: {}
}
assert(0);
return NULL;
}
static LLVMTypeRef ffi_return_type(compile_t* c, reach_type_t* t,
bool intrinsic)
{
compile_type_t* c_t = (compile_type_t*)t->c_type;
if(t->underlying == TK_TUPLETYPE)
{
pony_assert(intrinsic);
// Can't use the named type. Build an unnamed type with the same elements.
unsigned int count = LLVMCountStructElementTypes(c_t->use_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* e_types = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetStructElementTypes(c_t->use_type, e_types);
ast_t* child = ast_child(t->ast);
size_t i = 0;
while(child != NULL)
{
// A Bool in an intrinsic tuple return type is an i1.
if(is_bool(child))
e_types[i] = c->i1;
child = ast_sibling(child);
i++;
}
LLVMTypeRef r_type = LLVMStructTypeInContext(c->context, e_types, count,
false);
ponyint_pool_free_size(buf_size, e_types);
return r_type;
} else if(is_none(t->ast_cap)) {
return c->void_type;
} else {
return c_t->use_type;
}
}
static LLVMValueRef assign_to_tuple(compile_t* c, LLVMTypeRef l_type,
LLVMValueRef r_value, ast_t* type)
{
// Cast each component.
assert(ast_id(type) == TK_TUPLETYPE);
int count = LLVMCountStructElementTypes(l_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* elements = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetStructElementTypes(l_type, elements);
LLVMValueRef result = LLVMGetUndef(l_type);
ast_t* type_child = ast_child(type);
int i = 0;
while(type_child != NULL)
{
LLVMValueRef r_child = LLVMBuildExtractValue(c->builder, r_value, i, "");
LLVMValueRef cast_value = gen_assign_cast(c, elements[i], r_child,
type_child);
if(cast_value == NULL)
{
pool_free_size(buf_size, elements);
return NULL;
}
result = LLVMBuildInsertValue(c->builder, result, cast_value, i, "");
type_child = ast_sibling(type_child);
i++;
}
pool_free_size(buf_size, elements);
return result;
}
static LLVMValueRef gen_digestof_value(compile_t* c, ast_t* type,
LLVMValueRef value)
{
LLVMTypeRef impl_type = LLVMTypeOf(value);
switch(LLVMGetTypeKind(impl_type))
{
case LLVMFloatTypeKind:
value = LLVMBuildBitCast(c->builder, value, c->i32, "");
return LLVMBuildZExt(c->builder, value, c->intptr, "");
case LLVMDoubleTypeKind:
value = LLVMBuildBitCast(c->builder, value, c->i64, "");
return gen_digestof_int64(c, value);
case LLVMIntegerTypeKind:
{
uint32_t width = LLVMGetIntTypeWidth(impl_type);
if(width < 64)
{
return LLVMBuildZExt(c->builder, value, c->intptr, "");
} else if(width == 64) {
return gen_digestof_int64(c, value);
} else if(width == 128) {
LLVMValueRef shift = LLVMConstInt(c->i128, 64, false);
LLVMValueRef high = LLVMBuildLShr(c->builder, value, shift, "");
high = LLVMBuildTrunc(c->builder, high, c->i64, "");
value = LLVMBuildTrunc(c->builder, value, c->i64, "");
high = gen_digestof_int64(c, high);
value = gen_digestof_int64(c, value);
return LLVMBuildXor(c->builder, value, high, "");
}
break;
}
case LLVMStructTypeKind:
{
uint32_t count = LLVMCountStructElementTypes(impl_type);
LLVMValueRef result = LLVMConstInt(c->intptr, 0, false);
ast_t* child = ast_child(type);
for(uint32_t i = 0; i < count; i++)
{
LLVMValueRef elem = LLVMBuildExtractValue(c->builder, value, i, "");
elem = gen_digestof_value(c, child, elem);
result = LLVMBuildXor(c->builder, result, elem, "");
child = ast_sibling(child);
}
pony_assert(child == NULL);
return result;
}
case LLVMPointerTypeKind:
if(!is_known(type))
{
reach_type_t* t = reach_type(c->reach, type);
int sub_kind = subtype_kind(t);
if((sub_kind & SUBTYPE_KIND_BOXED) != 0)
return gen_digestof_box(c, t, value, sub_kind);
}
return LLVMBuildPtrToInt(c->builder, value, c->intptr, "");
default: {}
}
pony_assert(0);
return NULL;
}
LLVMValueRef encode_packed_struct_inline(
struct llvm_ctx *ctx,
LLVMValueRef first_mr_word,
LLVMValueRef bit_offset,
IDL_tree ctyp,
LLVMValueRef src_base)
{
const struct packed_format *fmt = packed_format_of(ctyp);
assert(fmt != NULL);
/* for sub-word items, bit_offset is required. for word and larger ones it
* is forbidden.
*/
assert(bit_offset == NULL || (fmt->num_bits < BITS_PER_WORD
&& fmt->num_words == 1));
assert(bit_offset != NULL || fmt->num_bits >= BITS_PER_WORD);
char **names = NULL;
T s_type = llvm_struct_type(ctx, &names, ctyp);
int names_len = 0;
while(names[names_len] != NULL) names_len++;
assert(names_len == fmt->num_items);
assert(LLVMCountStructElementTypes(s_type) == names_len);
T types[MAX(names_len, 1)];
LLVMGetStructElementTypes(s_type, types);
V wordval = CONST_WORD(0);
int cur_word = 0, wordval_fill = 0;
for(int i=0; i<fmt->num_items; i++) {
assert(wordval_fill <= BITS_PER_WORD);
const struct packed_item *pi = fmt->items[i];
assert(bit_offset == NULL || pi->word == 0);
int field_ix = strv_lookup(names, pi->name);
if(field_ix < 0) {
fprintf(stderr, "%s: not the way to go.\n", __func__);
abort();
}
V start_mr = NULL;
if(bit_offset == NULL) {
start_mr = LLVMBuildAdd(ctx->builder, first_mr_word,
CONST_INT(pi->word), "word.ix");
}
/* flush previous word? */
if(wordval_fill > 0 && cur_word != pi->word) {
assert(bit_offset == NULL);
V mr_ix = LLVMBuildAdd(ctx->builder, first_mr_word,
CONST_INT(cur_word), tmp_f(ctx->pr, "flush.w%d.ix", cur_word));
LLVMBuildStore(ctx->builder, wordval, UTCB_ADDR_VAL(ctx, mr_ix,
tmp_f(ctx->pr, "flush.w%d.addr", cur_word)));
wordval = CONST_WORD(0);
wordval_fill = 0;
cur_word = pi->word;
}
V valptr = LLVMBuildStructGEP(ctx->builder, src_base, field_ix,
tmp_f(ctx->pr, "%s.start.ptr", pi->name));
if(pi->dim > 1) {
/* array types. TODO */
fprintf(stderr, "%s: struct-member arrays not implemented\n",
__func__);
abort();
} else if(IDL_NODE_TYPE(pi->type) == IDLN_TYPE_STRUCT) {
if(pi->len < BITS_PER_WORD) {
wordval = encode_packed_struct(ctx, wordval,
CONST_INT(pi->bit), pi->type, valptr);
wordval_fill = (wordval_fill + pi->len) % BITS_PER_WORD;
} else {
encode_packed_struct(ctx, start_mr, NULL, pi->type, valptr);
}
} else if(IDL_NODE_TYPE(pi->type) == IDLN_TYPE_UNION) {
fprintf(stderr, "%s: union-member types not implemented\n",
__func__);
abort();
} else if(IS_LONGLONG_TYPE(pi->type)) {
assert(bit_offset == NULL);
assert(pi->bit == 0 && wordval_fill == 0);
V val = LLVMBuildLoad(ctx->builder, valptr, "longlong.fld");
build_write_ipc_parameter(ctx, start_mr, pi->type, &val);
} else if(is_value_type(pi->type)) {
/* word-size and smaller items. */
V val = LLVMBuildLoad(ctx->builder, valptr,
tmp_f(ctx->pr, "fld.%s.val", pi->name));
val = LLVMBuildZExtOrBitCast(ctx->builder, val, ctx->wordt,
tmp_f(ctx->pr, "fld.%s.word", pi->name));
V bitoffs = CONST_INT(pi->bit);
V shifted = LLVMBuildShl(ctx->builder, val, bitoffs,
tmp_f(ctx->pr, "fld.%s.shifted", pi->name));
wordval = LLVMBuildOr(ctx->builder, shifted, wordval,
tmp_f(ctx->pr, "word%d.%s.merged", cur_word, pi->name));
wordval_fill += pi->len;
} else if(IS_MAPGRANT_TYPE(pi->type)) {
assert(bit_offset == NULL);
assert(pi->bit == 0 && wordval_fill == 0);
build_write_ipc_parameter(ctx, start_mr, pi->type, &valptr);
} else {
NOTDEFINED(pi->type);
}
}
if(bit_offset == NULL && wordval_fill > 0) {
/* flush final partial word if the last item was sub-word */
V mr_ix = LLVMBuildAdd(ctx->builder, first_mr_word,
CONST_INT(cur_word), tmp_f(ctx->pr, "flush.w%d.ix", cur_word));
LLVMBuildStore(ctx->builder, wordval, UTCB_ADDR_VAL(ctx, mr_ix,
tmp_f(ctx->pr, "flush.w%d.addr", cur_word)));
wordval = NULL;
} else if(bit_offset != NULL) {
/* shift and merge */
wordval = LLVMBuildOr(ctx->builder, first_mr_word,
LLVMBuildShl(ctx->builder, wordval, bit_offset, "short.shifted"),
"rv.merged");
}
g_strfreev(names);
return wordval;
}
void decode_packed_struct_inline(
struct llvm_ctx *ctx,
LLVMValueRef dst,
IDL_tree ctyp,
LLVMValueRef first_mr,
LLVMValueRef bit_offset)
{
const struct packed_format *fmt = packed_format_of(ctyp);
assert(fmt != NULL);
char **names = NULL;
T s_type = llvm_struct_type(ctx, &names, ctyp);
int names_len = 0;
while(names[names_len] != NULL) names_len++;
assert(names_len == fmt->num_items);
assert(LLVMCountStructElementTypes(s_type) == names_len);
T types[MAX(names_len, 1)];
LLVMGetStructElementTypes(s_type, types);
int cur_word = 0;
V wordval = NULL;
for(int i=0; i<fmt->num_items; i++) {
const struct packed_item *pi = fmt->items[i];
int field_ix = strv_lookup(names, pi->name);
if(field_ix < 0) {
fprintf(stderr, "%s: not the way to go.\n", __func__);
abort();
}
V start_mr = LLVMBuildAdd(ctx->builder, first_mr,
CONST_INT(pi->word), tmp_f(ctx->pr, "%s.start.mr", pi->name));
V dstptr = LLVMBuildStructGEP(ctx->builder, dst, field_ix,
tmp_f(ctx->pr, "%s.start.ptr", pi->name));
if(pi->dim > 1) {
/* array types. TODO */
fprintf(stderr, "%s: struct-member arrays not implemented\n",
__func__);
abort();
} else if(IDL_NODE_TYPE(pi->type) == IDLN_TYPE_STRUCT) {
decode_packed_struct(ctx, &dstptr, pi->type, start_mr,
CONST_INT(pi->bit));
} else if(IDL_NODE_TYPE(pi->type) == IDLN_TYPE_UNION) {
fprintf(stderr, "%s: union-member types not implemented\n",
__func__);
abort();
} else if(IS_LONGLONG_TYPE(pi->type)) {
/* long long on a 32-bit architecture. can be #ifdef'd out for
* 64-bit targets, where it'd be just a value type.
*/
V dtmp = NULL;
build_read_ipc_parameter(ctx, &dtmp, pi->type,
start_mr);
LLVMBuildStore(ctx->builder, dtmp, dstptr);
} else if(is_value_type(pi->type)) {
/* word-size and smaller items. */
if(cur_word != pi->word || wordval == NULL) {
cur_word = pi->word;
V old_wv = wordval;
wordval = build_ipc_input_val_ix(ctx, start_mr,
tmp_f(ctx->pr, "st.word%d", pi->word));
if(old_wv == NULL) {
/* shift it down, since we start at an offset. */
wordval = LLVMBuildLShr(ctx->builder, wordval,
bit_offset, "st.bitoffs.shifted");
}
}
V subval = LLVMBuildLShr(ctx->builder, wordval,
CONST_INT(pi->bit),
tmp_f(ctx->pr, "st.word%d.shr%d", pi->word, pi->bit));
if(pi->len < BITS_PER_WORD) {
subval = LLVMBuildAnd(ctx->builder, subval,
CONST_WORD((1 << pi->len) - 1),
tmp_f(ctx->pr, "st.word%d.s%d.m%d", pi->word, pi->bit,
pi->len));
}
subval = LLVMBuildTruncOrBitCast(ctx->builder, subval,
types[field_ix], "st.val.cast");
LLVMBuildStore(ctx->builder, subval, dstptr);
} else if(IS_MAPGRANT_TYPE(pi->type)) {
/* two words, like peas in a pod */
assert(pi->bit == 0);
build_read_ipc_parameter(ctx, &dstptr, pi->type, start_mr);
} else {
NOTDEFINED(pi->type);
}
}
g_strfreev(names);
}
static LLVMValueRef declare_ffi(compile_t* c, const char* f_name,
reach_type_t* t, ast_t* args, bool err, bool intrinsic)
{
ast_t* last_arg = ast_childlast(args);
if((last_arg != NULL) && (ast_id(last_arg) == TK_ELLIPSIS))
return declare_ffi_vararg(c, f_name, t, err);
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* f_params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
count = 0;
ast_t* arg = ast_child(args);
while(arg != NULL)
{
ast_t* p_type = ast_type(arg);
if(p_type == NULL)
p_type = ast_childidx(arg, 1);
reach_type_t* pt = reach_type(c->reach, p_type);
pony_assert(pt != NULL);
// An intrinsic that takes a Bool should be i1, not ibool.
if(intrinsic && is_bool(pt->ast))
f_params[count++] = c->i1;
else
f_params[count++] = pt->use_type;
arg = ast_sibling(arg);
}
LLVMTypeRef r_type;
if(t->underlying == TK_TUPLETYPE)
{
// Can't use the named type. Build an unnamed type with the same
// elements.
unsigned int count = LLVMCountStructElementTypes(t->use_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* e_types = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetStructElementTypes(t->use_type, e_types);
if(intrinsic)
{
ast_t* child = ast_child(t->ast);
size_t i = 0;
while(child != NULL)
{
// A Bool in an intrinsic tuple return type is an i1, not an ibool.
if(is_bool(child))
e_types[i] = c->i1;
child = ast_sibling(child);
i++;
}
}
r_type = LLVMStructTypeInContext(c->context, e_types, count, false);
ponyint_pool_free_size(buf_size, e_types);
} else {
// An intrinsic that returns a Bool returns an i1, not an ibool.
if(intrinsic && is_bool(t->ast))
r_type = c->i1;
else
r_type = t->use_type;
}
LLVMTypeRef f_type = LLVMFunctionType(r_type, f_params, count, false);
LLVMValueRef func = LLVMAddFunction(c->module, f_name, f_type);
if(!err)
{
#if PONY_LLVM >= 309
LLVM_DECLARE_ATTRIBUTEREF(nounwind_attr, nounwind, 0);
LLVMAddAttributeAtIndex(func, LLVMAttributeFunctionIndex, nounwind_attr);
#else
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
#endif
}
ponyint_pool_free_size(buf_size, f_params);
return func;
}
static LLVMValueRef declare_ffi(compile_t* c, const char* f_name,
gentype_t* g, ast_t* args, bool err)
{
ast_t* last_arg = ast_childlast(args);
if((last_arg != NULL) && (ast_id(last_arg) == TK_ELLIPSIS))
return declare_ffi_vararg(c, f_name, g, err);
int count = (int)ast_childcount(args);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* f_params = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
count = 0;
ast_t* arg = ast_child(args);
while(arg != NULL)
{
ast_t* p_type = ast_type(arg);
if(p_type == NULL)
p_type = ast_childidx(arg, 1);
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.
LLVMValueRef 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*)ponyint_pool_alloc_size(buf_size);
LLVMGetStructElementTypes(g->use_type, e_types);
r_type = LLVMStructTypeInContext(c->context, e_types, count, false);
ponyint_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(!err)
LLVMAddFunctionAttr(func, LLVMNoUnwindAttribute);
}
ponyint_pool_free_size(buf_size, f_params);
return func;
}
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;
}