void gendesc_table(compile_t* c)
{
uint32_t len = c->reach->next_type_id;
size_t size = len * sizeof(LLVMValueRef);
LLVMValueRef* args = (LLVMValueRef*)ponyint_pool_alloc_size(size);
reach_type_t* t;
size_t i = HASHMAP_BEGIN;
while((t = reach_types_next(&c->reach->types, &i)) != NULL)
{
LLVMValueRef desc;
if(t->desc != NULL)
desc = LLVMBuildBitCast(c->builder, t->desc, c->descriptor_ptr, "");
else
desc = LLVMConstNull(c->descriptor_ptr);
args[t->type_id] = desc;
}
LLVMTypeRef type = LLVMArrayType(c->descriptor_ptr, len);
LLVMValueRef table = LLVMAddGlobal(c->module, type, "__DescTable");
LLVMValueRef value = LLVMConstArray(c->descriptor_ptr, args, len);
LLVMSetInitializer(table, value);
LLVMSetGlobalConstant(table, true);
LLVMValueRef table_size = LLVMAddGlobal(c->module, c->intptr,
"__DescTableSize");
LLVMSetInitializer(table_size, LLVMConstInt(c->intptr, len, false));
LLVMSetGlobalConstant(table_size, true);
ponyint_pool_free_size(size, args);
}
static LLVMValueRef make_trait_list(compile_t* c, reach_type_t* t,
uint32_t* final_count)
{
// The list is an array of integers.
uint32_t* tid;
size_t tid_size;
uint32_t count = trait_count(t, &tid, &tid_size);
// If we have no traits, return a null pointer to a list.
if(count == 0)
return LLVMConstNull(LLVMPointerType(LLVMArrayType(c->i32, 0), 0));
// Create a constant array of trait identifiers.
size_t list_size = count * sizeof(LLVMValueRef);
LLVMValueRef* list = (LLVMValueRef*)ponyint_pool_alloc_size(list_size);
for(uint32_t i = 0; i < count; i++)
list[i] = LLVMConstInt(c->i32, tid[i], false);
LLVMValueRef trait_array = LLVMConstArray(c->i32, list, count);
// Create a global to hold the array.
const char* name = genname_traitlist(t->name);
LLVMTypeRef list_type = LLVMArrayType(c->i32, count);
LLVMValueRef global = LLVMAddGlobal(c->module, list_type, name);
LLVMSetGlobalConstant(global, true);
LLVMSetLinkage(global, LLVMPrivateLinkage);
LLVMSetInitializer(global, trait_array);
ponyint_pool_free_size(tid_size, tid);
ponyint_pool_free_size(list_size, list);
*final_count = count;
return global;
}
static LLVMValueRef
translateStringLit(ASTNode *Node) {
int Length = strlen(Node->Value);
LLVMValueRef GlobVar = LLVMAddGlobal(Module, LLVMArrayType(LLVMInt8Type(), Length+1), "global.var");
LLVMSetInitializer(GlobVar, LLVMConstString(Node->Value, Length, 0));
LLVMValueRef LocalVar = LLVMBuildAlloca(Builder, LLVMArrayType(LLVMInt8Type(), Length+1), "local.string.");
LLVMValueRef LocalI8 = LLVMBuildBitCast(Builder, LocalVar, LLVMPointerType(LLVMInt8Type(), 0), "");
copyMemory(LocalI8, GlobVar, getSConstInt(Length+1));
return wrapValue(LocalI8);
}
LLVMTypeRef gendesc_type(compile_t* c, gentype_t* g)
{
const char* desc_name;
uint32_t traits = 0;
uint32_t fields = 0;
uint32_t vtable_size = 0;
if(g != NULL)
{
// TODO: wrong trait count
desc_name = g->desc_name;
traits = trait_count(c, g, NULL, NULL);
if(g->underlying == TK_TUPLETYPE)
{
fields = g->field_count;
} else {
vtable_size = genfun_vtable_size(c, g);
}
} else {
desc_name = genname_descriptor(NULL);
}
LLVMTypeRef type = LLVMGetTypeByName(c->module, desc_name);
if(type == NULL)
{
type = LLVMStructCreateNamed(c->context, desc_name);
} else if(!LLVMIsOpaqueStruct(type)) {
return type;
}
LLVMTypeRef params[DESC_LENGTH];
params[DESC_ID] = c->i32;
params[DESC_SIZE] = c->i32;
params[DESC_TRAIT_COUNT] = c->i32;
params[DESC_FIELD_COUNT] = c->i32;
params[DESC_FIELD_OFFSET] = c->i32;
params[DESC_TRACE] = c->trace_fn;
params[DESC_SERIALISE] = c->trace_fn;
params[DESC_DESERIALISE] = c->trace_fn;
params[DESC_DISPATCH] = c->dispatch_fn;
params[DESC_FINALISE] = c->final_fn;
params[DESC_EVENT_NOTIFY] = c->i32;
params[DESC_TRAITS] = LLVMPointerType(LLVMArrayType(c->i32, traits), 0);
params[DESC_FIELDS] = LLVMPointerType(
LLVMArrayType(c->field_descriptor, fields), 0);
params[DESC_VTABLE] = LLVMArrayType(c->void_ptr, vtable_size);
LLVMStructSetBody(type, params, DESC_LENGTH, false);
return type;
}
void gendesc_type(compile_t* c, reach_type_t* t)
{
switch(t->underlying)
{
case TK_TUPLETYPE:
case TK_PRIMITIVE:
case TK_STRUCT:
case TK_CLASS:
case TK_ACTOR:
break;
default:
return;
}
const char* desc_name = genname_descriptor(t->name);
uint32_t traits = trait_count(t, NULL, NULL);
uint32_t fields = 0;
uint32_t vtable_size = 0;
if(t->underlying == TK_TUPLETYPE)
fields = t->field_count;
else
vtable_size = t->vtable_size;
t->desc_type = LLVMStructCreateNamed(c->context, desc_name);
LLVMTypeRef params[DESC_LENGTH];
params[DESC_ID] = c->i32;
params[DESC_SIZE] = c->i32;
params[DESC_TRAIT_COUNT] = c->i32;
params[DESC_FIELD_COUNT] = c->i32;
params[DESC_FIELD_OFFSET] = c->i32;
params[DESC_INSTANCE] = c->object_ptr;
params[DESC_TRACE] = c->trace_fn;
params[DESC_SERIALISE_TRACE] = c->trace_fn;
params[DESC_SERIALISE] = c->serialise_fn;
params[DESC_DESERIALISE] = c->trace_fn;
params[DESC_DISPATCH] = c->dispatch_fn;
params[DESC_FINALISE] = c->final_fn;
params[DESC_EVENT_NOTIFY] = c->i32;
params[DESC_TRAITS] = LLVMPointerType(LLVMArrayType(c->i32, traits), 0);
params[DESC_FIELDS] = LLVMPointerType(
LLVMArrayType(c->field_descriptor, fields), 0);
params[DESC_VTABLE] = LLVMArrayType(c->void_ptr, vtable_size);
LLVMStructSetBody(t->desc_type, params, DESC_LENGTH, false);
t->desc = LLVMAddGlobal(c->module, t->desc_type, desc_name);
LLVMSetGlobalConstant(t->desc, true);
LLVMSetLinkage(t->desc, LLVMPrivateLinkage);
}
static LLVMValueRef make_trait_list(compile_t* c, gentype_t* g)
{
// The list is an array of integers.
uint32_t count = trait_count(c, g);
// If we have no traits, return a null pointer to a list.
if(count == 0)
return LLVMConstNull(LLVMPointerType(LLVMArrayType(c->i32, 0), 0));
// Sort the trait identifiers.
size_t tid_size = count * sizeof(uint32_t);
uint32_t* tid = (uint32_t*)pool_alloc_size(tid_size);
reachable_type_t* t = reach_type(c->reachable, g->type_name);
assert(t != NULL);
size_t i = HASHMAP_BEGIN;
size_t index = 0;
reachable_type_t* provide;
while((provide = reachable_type_cache_next(&t->subtypes, &i)) != NULL)
tid[index++] = provide->type_id;
qsort(tid, index, sizeof(uint32_t), cmp_uint32);
index = unique_uint32(tid, index);
// Create a constant array of trait identifiers.
size_t list_size = index * sizeof(LLVMValueRef);
LLVMValueRef* list = (LLVMValueRef*)pool_alloc_size(list_size);
for(i = 0; i < index; i++)
list[i] = LLVMConstInt(c->i32, tid[i], false);
count = (uint32_t)index;
LLVMValueRef trait_array = LLVMConstArray(c->i32, list, count);
// Create a global to hold the array.
const char* name = genname_traitlist(g->type_name);
LLVMTypeRef type = LLVMArrayType(c->i32, count);
LLVMValueRef global = LLVMAddGlobal(c->module, type, name);
LLVMSetGlobalConstant(global, true);
LLVMSetLinkage(global, LLVMInternalLinkage);
LLVMSetInitializer(global, trait_array);
pool_free_size(tid_size, tid);
pool_free_size(list_size, list);
return global;
}
/* TODO: cache outputs by the struct type's repo id, like in
* packed_format_of()
*/
LLVMTypeRef llvm_struct_type(
struct llvm_ctx *ctx,
char ***names_p,
IDL_tree type)
{
assert(IDL_NODE_TYPE(type) == IDLN_TYPE_STRUCT);
GArray *types = g_array_new(FALSE, FALSE, sizeof(T));
GPtrArray *names = names_p != NULL ? g_ptr_array_new() : NULL;
struct member_item *members = expand_member_list(
IDL_TYPE_STRUCT(type).member_list);
for(int i=0; members[i].type != NULL; i++) {
IDL_tree mtype = members[i].type;
T mt = llvm_rigid_type(ctx, mtype);
if(members[i].dim == 0) {
g_array_append_val(types, mt);
} else {
T ary = LLVMArrayType(mt, members[i].dim);
g_array_append_val(types, ary);
}
if(names_p != NULL) {
g_ptr_array_add(names, g_strdup(members[i].name));
}
}
g_free(members);
if(names_p != NULL) {
char **namev = g_new(char *, names->len + 1);
for(int i=0; i<names->len; i++) namev[i] = names->pdata[i];
namev[names->len] = NULL;
g_ptr_array_free(names, TRUE);
(*names_p) = namev;
}
void type_define_array_size(struct type *r, size_t n_elems) {
assert(r);
assert(r->u.n_elems == TYPE_ARRAY_NO_N_ELEMS);
r->u.n_elems = n_elems;
r->val = TYPE_ARRAY;
r->llvm_type = LLVMArrayType(r->next->llvm_type, n_elems);
}
struct type *type_new_array_no_size(struct type *to) {
assert(to);
struct type *r = malloc(sizeof *r);
r->val = TYPE_ARRAY;
r->u.n_elems = TYPE_ARRAY_NO_N_ELEMS;
r->next = to;
r->llvm_type = LLVMArrayType(to->llvm_type, 0);
return r;
}
struct type *type_new_array(struct type *to, size_t n_elems) {
assert(to);
struct type *r = malloc(sizeof *r);
r->val = TYPE_ARRAY;
r->next = to;
r->u.n_elems = n_elems;
r->llvm_type = LLVMArrayType(to->llvm_type, n_elems);
return r;
}
static LLVMValueRef make_field_list(compile_t* c, gentype_t* g)
{
// The list is an array of field descriptors.
int count;
if(g->underlying == TK_TUPLETYPE)
count = g->field_count;
else
count = 0;
LLVMTypeRef type = LLVMArrayType(c->field_descriptor, count);
// If we aren't a tuple, return a null pointer to a list.
if(count == 0)
return LLVMConstNull(LLVMPointerType(type, 0));
// Create a constant array of field descriptors.
size_t buf_size = count *sizeof(LLVMValueRef);
LLVMValueRef* list = (LLVMValueRef*)pool_alloc_size(buf_size);
for(int i = 0; i < count; i++)
{
gentype_t fg;
if(!gentype(c, g->fields[i], &fg))
return NULL;
LLVMValueRef fdesc[2];
fdesc[0] = LLVMConstInt(c->i32,
LLVMOffsetOfElement(c->target_data, g->primitive, i), false);
if(fg.desc != NULL)
{
// We are a concrete type.
fdesc[1] = LLVMConstBitCast(fg.desc, c->descriptor_ptr);
} else {
// We aren't a concrete type.
fdesc[1] = LLVMConstNull(c->descriptor_ptr);
}
list[i] = LLVMConstStructInContext(c->context, fdesc, 2, false);
}
LLVMValueRef field_array = LLVMConstArray(c->field_descriptor, list, count);
// Create a global to hold the array.
const char* name = genname_fieldlist(g->type_name);
LLVMValueRef global = LLVMAddGlobal(c->module, type, name);
LLVMSetGlobalConstant(global, true);
LLVMSetLinkage(global, LLVMInternalLinkage);
LLVMSetInitializer(global, field_array);
pool_free_size(buf_size, list);
return global;
}
LLVMValueRef
lp_build_const_string_variable(LLVMModuleRef module,
LLVMContextRef context,
const char *str, int len)
{
LLVMValueRef string = LLVMAddGlobal(module, LLVMArrayType(LLVMInt8TypeInContext(context), len + 1), "");
LLVMSetGlobalConstant(string, TRUE);
LLVMSetLinkage(string, LLVMInternalLinkage);
LLVMSetInitializer(string, LLVMConstStringInContext(context, str, len + 1, TRUE));
return string;
}
void gendesc_basetype(compile_t* c, LLVMTypeRef desc_type)
{
LLVMTypeRef params[DESC_LENGTH];
params[DESC_ID] = c->i32;
params[DESC_SIZE] = c->i32;
params[DESC_TRAIT_COUNT] = c->i32;
params[DESC_FIELD_COUNT] = c->i32;
params[DESC_FIELD_OFFSET] = c->i32;
params[DESC_TRACE] = c->trace_fn;
params[DESC_SERIALISE] = c->trace_fn;
params[DESC_DESERIALISE] = c->trace_fn;
params[DESC_DISPATCH] = c->dispatch_fn;
params[DESC_FINALISE] = c->final_fn;
params[DESC_EVENT_NOTIFY] = c->i32;
params[DESC_TRAITS] = LLVMPointerType(LLVMArrayType(c->i32, 0), 0);
params[DESC_FIELDS] = LLVMPointerType(
LLVMArrayType(c->field_descriptor, 0), 0);
params[DESC_VTABLE] = LLVMArrayType(c->void_ptr, 0);
LLVMStructSetBody(desc_type, params, DESC_LENGTH, false);
}
static LLVMValueRef llvm_load_const_buffer(
struct lp_build_tgsi_context * bld_base,
LLVMValueRef OffsetValue,
unsigned ConstantAddressSpace)
{
LLVMValueRef offset[2] = {
LLVMConstInt(LLVMInt64TypeInContext(bld_base->base.gallivm->context), 0, false),
OffsetValue
};
LLVMTypeRef const_ptr_type = LLVMPointerType(LLVMArrayType(LLVMVectorType(bld_base->base.elem_type, 4), 1024),
ConstantAddressSpace);
LLVMValueRef const_ptr = LLVMBuildIntToPtr(bld_base->base.gallivm->builder, lp_build_const_int32(bld_base->base.gallivm, 0), const_ptr_type, "");
LLVMValueRef ptr = LLVMBuildGEP(bld_base->base.gallivm->builder, const_ptr, offset, 2, "");
return LLVMBuildLoad(bld_base->base.gallivm->builder, ptr, "");
}
static LLVMValueRef make_trait_list(compile_t* c, gentype_t* g)
{
// The list is an array of integers.
uint32_t count = trait_count(c, g);
LLVMTypeRef type = LLVMArrayType(c->i32, count);
// If we have no traits, return a null pointer to a list.
if(count == 0)
return LLVMConstNull(LLVMPointerType(type, 0));
// Create a constant array of trait identifiers.
size_t buf_size = count *sizeof(LLVMValueRef);
LLVMValueRef* list = (LLVMValueRef*)pool_alloc_size(buf_size);
reachable_type_t* t = reach_type(c->reachable, g->type_name);
assert(t != NULL);
size_t i = HASHMAP_BEGIN;
size_t index = 0;
reachable_type_t* provide;
while((provide = reachable_type_cache_next(&t->subtypes, &i)) != NULL)
list[index++] = make_type_id(c, provide->name);
LLVMValueRef trait_array = LLVMConstArray(c->i32, list, count);
// Create a global to hold the array.
const char* name = genname_traitlist(g->type_name);
LLVMValueRef global = LLVMAddGlobal(c->module, type, name);
LLVMSetGlobalConstant(global, true);
LLVMSetLinkage(global, LLVMInternalLinkage);
LLVMSetInitializer(global, trait_array);
pool_free_size(buf_size, list);
return global;
}
LLVMTypeRef ett_llvm_type(EagleComplexType *type)
{
switch(type->type)
{
case ETVoid:
return LLVMVoidTypeInContext(utl_get_current_context());
case ETFloat:
return LLVMFloatTypeInContext(utl_get_current_context());
case ETDouble:
return LLVMDoubleTypeInContext(utl_get_current_context());
case ETInt1:
return LLVMInt1TypeInContext(utl_get_current_context());
case ETGeneric: // In practice this doesn't matter
case ETAny:
case ETInt8:
case ETUInt8:
return LLVMInt8TypeInContext(utl_get_current_context());
case ETInt16:
case ETUInt16:
return LLVMInt16TypeInContext(utl_get_current_context());
case ETInt32:
case ETUInt32:
return LLVMInt32TypeInContext(utl_get_current_context());
case ETInt64:
case ETUInt64:
return LLVMInt64TypeInContext(utl_get_current_context());
case ETCString:
return LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
case ETEnum:
return LLVMInt64TypeInContext(utl_get_current_context());
case ETGenerator:
{
if(generator_type)
return generator_type;
LLVMTypeRef ptmp[2];
ptmp[0] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
ptmp[1] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
generator_type = LLVMStructCreateNamed(utl_get_current_context(), "__egl_gen_strct");
LLVMStructSetBody(generator_type, ptmp, 2, 0);
return generator_type;
}
case ETClass:
case ETStruct:
{
EagleStructType *st = (EagleStructType *)type;
LLVMTypeRef loaded = LLVMGetTypeByName(the_module, st->name);
if(loaded)
return loaded;
return NULL;
// LLVMTypeRef ty = LLVMStructTypeInContext(utl_get_current_context(),
}
case ETInterface:
{
return LLVMInt8TypeInContext(utl_get_current_context());
}
case ETPointer:
{
EaglePointerType *pt = (EaglePointerType *)type;
if(pt->counted || pt->weak)
{
LLVMTypeRef ptmp[2];
ptmp[0] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
ptmp[1] = LLVMInt1TypeInContext(utl_get_current_context());
LLVMTypeRef tys[6];
tys[0] = LLVMInt64TypeInContext(utl_get_current_context());
tys[1] = LLVMInt16TypeInContext(utl_get_current_context());
tys[2] = LLVMInt16TypeInContext(utl_get_current_context());
tys[3] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
tys[4] = LLVMPointerType(LLVMFunctionType(LLVMVoidTypeInContext(utl_get_current_context()), ptmp, 2, 0), 0);
tys[5] = ett_llvm_type(pt->to);
return LLVMPointerType(ty_get_counted(LLVMStructTypeInContext(utl_get_current_context(), tys, 6, 0)), 0);
}
return LLVMPointerType(ett_llvm_type(((EaglePointerType *)type)->to), 0);
}
case ETArray:
{
EagleArrayType *at = (EagleArrayType *)type;
if(at->ct < 0)
return LLVMPointerType(ett_llvm_type(at->of), 0);
else
return LLVMArrayType(ett_llvm_type(at->of), at->ct);
}
case ETFunction:
{
EagleFunctionType *ft = (EagleFunctionType *)type;
if(ET_IS_CLOSURE(type))
{
LLVMTypeRef tys[2];
tys[0] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
tys[1] = LLVMPointerType(LLVMInt8TypeInContext(utl_get_current_context()), 0);
return LLVMStructTypeInContext(utl_get_current_context(), tys, 2, 0);
}
LLVMTypeRef *tys = malloc(sizeof(LLVMTypeRef) * ft->pct);
int i;
for(i = 0; i < ft->pct; i++)
tys[i] = ett_llvm_type(ft->params[i]);
LLVMTypeRef out = LLVMFunctionType(ett_llvm_type(ft->retType), tys, ft->pct, 0);
free(tys);
return out;
}
default:
return NULL;
}
}
static void
lp_jit_create_types(struct lp_fragment_shader_variant *lp)
{
struct gallivm_state *gallivm = lp->gallivm;
LLVMContextRef lc = gallivm->context;
LLVMTypeRef viewport_type, texture_type, sampler_type;
/* struct lp_jit_viewport */
{
LLVMTypeRef elem_types[LP_JIT_VIEWPORT_NUM_FIELDS];
elem_types[LP_JIT_VIEWPORT_MIN_DEPTH] =
elem_types[LP_JIT_VIEWPORT_MAX_DEPTH] = LLVMFloatTypeInContext(lc);
viewport_type = LLVMStructTypeInContext(lc, elem_types,
Elements(elem_types), 0);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport, min_depth,
gallivm->target, viewport_type,
LP_JIT_VIEWPORT_MIN_DEPTH);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_viewport, max_depth,
gallivm->target, viewport_type,
LP_JIT_VIEWPORT_MAX_DEPTH);
LP_CHECK_STRUCT_SIZE(struct lp_jit_viewport,
gallivm->target, viewport_type);
}
/* struct lp_jit_texture */
{
LLVMTypeRef elem_types[LP_JIT_TEXTURE_NUM_FIELDS];
elem_types[LP_JIT_TEXTURE_WIDTH] =
elem_types[LP_JIT_TEXTURE_HEIGHT] =
elem_types[LP_JIT_TEXTURE_DEPTH] =
elem_types[LP_JIT_TEXTURE_FIRST_LEVEL] =
elem_types[LP_JIT_TEXTURE_LAST_LEVEL] = LLVMInt32TypeInContext(lc);
elem_types[LP_JIT_TEXTURE_BASE] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
elem_types[LP_JIT_TEXTURE_ROW_STRIDE] =
elem_types[LP_JIT_TEXTURE_IMG_STRIDE] =
elem_types[LP_JIT_TEXTURE_MIP_OFFSETS] =
LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TEXTURE_LEVELS);
texture_type = LLVMStructTypeInContext(lc, elem_types,
Elements(elem_types), 0);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width,
gallivm->target, texture_type,
LP_JIT_TEXTURE_WIDTH);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, height,
gallivm->target, texture_type,
LP_JIT_TEXTURE_HEIGHT);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, depth,
gallivm->target, texture_type,
LP_JIT_TEXTURE_DEPTH);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, first_level,
gallivm->target, texture_type,
LP_JIT_TEXTURE_FIRST_LEVEL);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, last_level,
gallivm->target, texture_type,
LP_JIT_TEXTURE_LAST_LEVEL);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, base,
gallivm->target, texture_type,
LP_JIT_TEXTURE_BASE);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, row_stride,
gallivm->target, texture_type,
LP_JIT_TEXTURE_ROW_STRIDE);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, img_stride,
gallivm->target, texture_type,
LP_JIT_TEXTURE_IMG_STRIDE);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, mip_offsets,
gallivm->target, texture_type,
LP_JIT_TEXTURE_MIP_OFFSETS);
LP_CHECK_STRUCT_SIZE(struct lp_jit_texture,
gallivm->target, texture_type);
}
/* struct lp_jit_sampler */
{
LLVMTypeRef elem_types[LP_JIT_SAMPLER_NUM_FIELDS];
elem_types[LP_JIT_SAMPLER_MIN_LOD] =
elem_types[LP_JIT_SAMPLER_MAX_LOD] =
elem_types[LP_JIT_SAMPLER_LOD_BIAS] = LLVMFloatTypeInContext(lc);
elem_types[LP_JIT_SAMPLER_BORDER_COLOR] =
LLVMArrayType(LLVMFloatTypeInContext(lc), 4);
sampler_type = LLVMStructTypeInContext(lc, elem_types,
Elements(elem_types), 0);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, min_lod,
gallivm->target, sampler_type,
LP_JIT_SAMPLER_MIN_LOD);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, max_lod,
gallivm->target, sampler_type,
LP_JIT_SAMPLER_MAX_LOD);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, lod_bias,
gallivm->target, sampler_type,
LP_JIT_SAMPLER_LOD_BIAS);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_sampler, border_color,
gallivm->target, sampler_type,
LP_JIT_SAMPLER_BORDER_COLOR);
LP_CHECK_STRUCT_SIZE(struct lp_jit_sampler,
gallivm->target, sampler_type);
}
/* struct lp_jit_context */
{
LLVMTypeRef elem_types[LP_JIT_CTX_COUNT];
LLVMTypeRef context_type;
elem_types[LP_JIT_CTX_CONSTANTS] =
LLVMArrayType(LLVMPointerType(LLVMFloatTypeInContext(lc), 0), LP_MAX_TGSI_CONST_BUFFERS);
elem_types[LP_JIT_CTX_NUM_CONSTANTS] =
LLVMArrayType(LLVMInt32TypeInContext(lc), LP_MAX_TGSI_CONST_BUFFERS);
elem_types[LP_JIT_CTX_ALPHA_REF] = LLVMFloatTypeInContext(lc);
elem_types[LP_JIT_CTX_STENCIL_REF_FRONT] =
elem_types[LP_JIT_CTX_STENCIL_REF_BACK] = LLVMInt32TypeInContext(lc);
elem_types[LP_JIT_CTX_U8_BLEND_COLOR] = LLVMPointerType(LLVMInt8TypeInContext(lc), 0);
elem_types[LP_JIT_CTX_F_BLEND_COLOR] = LLVMPointerType(LLVMFloatTypeInContext(lc), 0);
elem_types[LP_JIT_CTX_VIEWPORTS] = LLVMPointerType(viewport_type, 0);
elem_types[LP_JIT_CTX_TEXTURES] = LLVMArrayType(texture_type,
PIPE_MAX_SHADER_SAMPLER_VIEWS);
elem_types[LP_JIT_CTX_SAMPLERS] = LLVMArrayType(sampler_type,
PIPE_MAX_SAMPLERS);
context_type = LLVMStructTypeInContext(lc, elem_types,
Elements(elem_types), 0);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, constants,
gallivm->target, context_type,
LP_JIT_CTX_CONSTANTS);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, num_constants,
gallivm->target, context_type,
LP_JIT_CTX_NUM_CONSTANTS);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, alpha_ref_value,
gallivm->target, context_type,
LP_JIT_CTX_ALPHA_REF);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_front,
gallivm->target, context_type,
LP_JIT_CTX_STENCIL_REF_FRONT);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, stencil_ref_back,
gallivm->target, context_type,
LP_JIT_CTX_STENCIL_REF_BACK);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, u8_blend_color,
gallivm->target, context_type,
LP_JIT_CTX_U8_BLEND_COLOR);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, f_blend_color,
gallivm->target, context_type,
LP_JIT_CTX_F_BLEND_COLOR);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, viewports,
gallivm->target, context_type,
LP_JIT_CTX_VIEWPORTS);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, textures,
gallivm->target, context_type,
LP_JIT_CTX_TEXTURES);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, samplers,
gallivm->target, context_type,
LP_JIT_CTX_SAMPLERS);
LP_CHECK_STRUCT_SIZE(struct lp_jit_context,
gallivm->target, context_type);
lp->jit_context_ptr_type = LLVMPointerType(context_type, 0);
}
/* struct lp_jit_thread_data */
{
LLVMTypeRef elem_types[LP_JIT_THREAD_DATA_COUNT];
LLVMTypeRef thread_data_type;
elem_types[LP_JIT_THREAD_DATA_COUNTER] = LLVMInt64TypeInContext(lc);
elem_types[LP_JIT_THREAD_DATA_RASTER_STATE_VIEWPORT_INDEX] =
LLVMInt32TypeInContext(lc);
thread_data_type = LLVMStructTypeInContext(lc, elem_types,
Elements(elem_types), 0);
lp->jit_thread_data_ptr_type = LLVMPointerType(thread_data_type, 0);
}
if (gallivm_debug & GALLIVM_DEBUG_IR) {
LLVMDumpModule(gallivm->module);
}
}
while(count < len)
{
t = reach_types_next(&c->reach->types, &i);
pony_assert(t != NULL);
if(t->is_trait || (t->underlying == TK_STRUCT))
continue;
uint32_t type_id = t->type_id;
if((type_id % 4) == 0)
{
size_t type_size = (size_t)LLVMABISizeOfType(c->target_data, t->use_type);
args[type_id >> 2] = LLVMConstInt(c->i32, type_size, false);
count++;
}
}
LLVMTypeRef type = LLVMArrayType(c->i32, len);
LLVMValueRef table = LLVMAddGlobal(c->module, type, "__NumSizeTable");
LLVMValueRef value = LLVMConstArray(c->i32, args, len);
LLVMSetInitializer(table, value);
LLVMSetGlobalConstant(table, true);
LLVMSetAlignment(table, 4);
LLVMSetLinkage(table, LLVMPrivateLinkage);
ponyint_pool_free_size(size, args);
return table;
}
static void init_runtime(compile_t* c)
{
c->str_builtin = stringtab("$0");
c->str_Bool = stringtab("Bool");
c->str_I8 = stringtab("I8");
c->str_I16 = stringtab("I16");
c->str_I32 = stringtab("I32");
c->str_I64 = stringtab("I64");
c->str_I128 = stringtab("I128");
c->str_ILong = stringtab("ILong");
c->str_ISize = stringtab("ISize");
c->str_U8 = stringtab("U8");
c->str_U16 = stringtab("U16");
c->str_U32 = stringtab("U32");
c->str_U64 = stringtab("U64");
c->str_U128 = stringtab("U128");
c->str_ULong = stringtab("ULong");
c->str_USize = stringtab("USize");
c->str_F32 = stringtab("F32");
c->str_F64 = stringtab("F64");
c->str_Pointer = stringtab("Pointer");
c->str_Maybe = stringtab("MaybePointer");
c->str_DoNotOptimise = stringtab("DoNotOptimise");
c->str_Array = stringtab("Array");
c->str_String = stringtab("String");
c->str_Platform = stringtab("Platform");
c->str_Main = stringtab("Main");
c->str_Env = stringtab("Env");
c->str_add = stringtab("add");
c->str_sub = stringtab("sub");
c->str_mul = stringtab("mul");
c->str_div = stringtab("div");
c->str_mod = stringtab("mod");
c->str_neg = stringtab("neg");
c->str_and = stringtab("op_and");
c->str_or = stringtab("op_or");
c->str_xor = stringtab("op_xor");
c->str_not = stringtab("op_not");
c->str_shl = stringtab("shl");
c->str_shr = stringtab("shr");
c->str_eq = stringtab("eq");
c->str_ne = stringtab("ne");
c->str_lt = stringtab("lt");
c->str_le = stringtab("le");
c->str_ge = stringtab("ge");
c->str_gt = stringtab("gt");
c->str_this = stringtab("this");
c->str_create = stringtab("create");
c->str__create = stringtab("_create");
c->str__init = stringtab("_init");
c->str__final = stringtab("_final");
c->str__event_notify = stringtab("_event_notify");
LLVMTypeRef type;
LLVMTypeRef params[5];
LLVMValueRef value;
c->void_type = LLVMVoidTypeInContext(c->context);
c->ibool = LLVMInt8TypeInContext(c->context);
c->i1 = LLVMInt1TypeInContext(c->context);
c->i8 = LLVMInt8TypeInContext(c->context);
c->i16 = LLVMInt16TypeInContext(c->context);
c->i32 = LLVMInt32TypeInContext(c->context);
c->i64 = LLVMInt64TypeInContext(c->context);
c->i128 = LLVMIntTypeInContext(c->context, 128);
c->f32 = LLVMFloatTypeInContext(c->context);
c->f64 = LLVMDoubleTypeInContext(c->context);
c->intptr = LLVMIntPtrTypeInContext(c->context, c->target_data);
// i8*
c->void_ptr = LLVMPointerType(c->i8, 0);
// forward declare object
c->object_type = LLVMStructCreateNamed(c->context, "__object");
c->object_ptr = LLVMPointerType(c->object_type, 0);
// padding required in an actor between the descriptor and fields
c->actor_pad = LLVMArrayType(c->i8, PONY_ACTOR_PAD_SIZE);
// message
params[0] = c->i32; // size
params[1] = c->i32; // id
c->msg_type = LLVMStructCreateNamed(c->context, "__message");
c->msg_ptr = LLVMPointerType(c->msg_type, 0);
LLVMStructSetBody(c->msg_type, params, 2, false);
// trace
// void (*)(i8*, __object*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
c->trace_type = LLVMFunctionType(c->void_type, params, 2, false);
c->trace_fn = LLVMPointerType(c->trace_type, 0);
// serialise
// void (*)(i8*, __object*, i8*, intptr, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->void_ptr;
params[3] = c->intptr;
params[4] = c->i32;
c->serialise_type = LLVMFunctionType(c->void_type, params, 5, false);
c->serialise_fn = LLVMPointerType(c->serialise_type, 0);
// dispatch
// void (*)(i8*, __object*, $message*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->msg_ptr;
c->dispatch_type = LLVMFunctionType(c->void_type, params, 3, false);
c->dispatch_fn = LLVMPointerType(c->dispatch_type, 0);
// void (*)(__object*)
params[0] = c->object_ptr;
c->final_fn = LLVMPointerType(
LLVMFunctionType(c->void_type, params, 1, false), 0);
// descriptor, opaque version
// We need this in order to build our own structure.
const char* desc_name = genname_descriptor(NULL);
c->descriptor_type = LLVMStructCreateNamed(c->context, desc_name);
c->descriptor_ptr = LLVMPointerType(c->descriptor_type, 0);
// field descriptor
// Also needed to build a descriptor structure.
params[0] = c->i32;
params[1] = c->descriptor_ptr;
c->field_descriptor = LLVMStructTypeInContext(c->context, params, 2, false);
// descriptor, filled in
gendesc_basetype(c, c->descriptor_type);
// define object
params[0] = c->descriptor_ptr;
LLVMStructSetBody(c->object_type, params, 1, false);
// $i8* pony_ctx()
type = LLVMFunctionType(c->void_ptr, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_ctx", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMAddFunctionAttr(value, LLVMReadNoneAttribute);
// __object* pony_create(i8*, __Desc*)
params[0] = c->void_ptr;
params[1] = c->descriptor_ptr;
type = LLVMFunctionType(c->object_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_create", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, PONY_ACTOR_PAD_SIZE);
// void ponyint_destroy(__object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "ponyint_destroy", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_sendv(i8*, __object*, $message*);
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->msg_ptr;
type = LLVMFunctionType(c->void_type, params, 3, false);
value = LLVMAddFunction(c->module, "pony_sendv", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* pony_alloc(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
#if PONY_LLVM >= 307
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_small(i8*, i32)
params[0] = c->void_ptr;
params[1] = c->i32;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_small", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MIN);
// i8* pony_alloc_large(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_large", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MAX + 1);
// i8* pony_realloc(i8*, i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_realloc", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
#if PONY_LLVM >= 307
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_final(i8*, intptr, c->final_fn)
params[0] = c->void_ptr;
params[1] = c->intptr;
params[2] = c->final_fn;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_alloc_final", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
#if PONY_LLVM >= 307
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// $message* pony_alloc_msg(i32, i32)
params[0] = c->i32;
params[1] = c->i32;
type = LLVMFunctionType(c->msg_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_msg", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// void pony_trace(i8*, i8*)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_trace", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* pony_traceobject(i8*, __object*, __Desc*, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->descriptor_ptr;
params[3] = c->i32;
type = LLVMFunctionType(c->void_ptr, params, 4, false);
value = LLVMAddFunction(c->module, "pony_traceknown", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* pony_traceunknown(i8*, __object*, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->i32;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_traceunknown", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_gc_send(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_gc_send", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_gc_recv(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_gc_recv", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_send_done(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_send_done", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_recv_done(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_recv_done", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_serialise_reserve(i8*, i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_type, params, 3, false);
value = LLVMAddFunction(c->module, "pony_serialise_reserve", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// intptr pony_serialise_offset(i8*, i8*)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
type = LLVMFunctionType(c->intptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_serialise_offset", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* pony_deserialise_offset(i8*, __desc*, intptr)
params[0] = c->void_ptr;
params[1] = c->descriptor_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_deserialise_offset", type);
// i8* pony_deserialise_block(i8*, intptr, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_deserialise_block", type);
// i32 pony_init(i32, i8**)
params[0] = c->i32;
params[1] = LLVMPointerType(c->void_ptr, 0);
type = LLVMFunctionType(c->i32, params, 2, false);
value = LLVMAddFunction(c->module, "pony_init", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_become(i8*, __object*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_become", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i32 pony_start(i32)
params[0] = c->i32;
type = LLVMFunctionType(c->i32, params, 1, false);
value = LLVMAddFunction(c->module, "pony_start", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_throw()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
LLVMAddFunction(c->module, "pony_throw", type);
// i32 pony_personality_v0(...)
type = LLVMFunctionType(c->i32, NULL, 0, true);
c->personality = LLVMAddFunction(c->module, "pony_personality_v0", type);
// void llvm.memcpy.*(i8*, i8*, i32/64, i32, i1)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[3] = c->i32;
params[4] = c->i1;
if(target_is_ilp32(c->opt->triple))
{
params[2] = c->i32;
type = LLVMFunctionType(c->void_type, params, 5, false);
value = LLVMAddFunction(c->module, "llvm.memcpy.p0i8.p0i8.i32", type);
} else {
params[2] = c->i64;
type = LLVMFunctionType(c->void_type, params, 5, false);
value = LLVMAddFunction(c->module, "llvm.memcpy.p0i8.p0i8.i64", type);
}
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void llvm.memmove.*(i8*, i8*, i32/64, i32, i1)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[3] = c->i32;
params[4] = c->i1;
if(target_is_ilp32(c->opt->triple))
{
params[2] = c->i32;
type = LLVMFunctionType(c->void_type, params, 5, false);
value = LLVMAddFunction(c->module, "llvm.memmove.p0i8.p0i8.i32", type);
} else {
params[2] = c->i64;
type = LLVMFunctionType(c->void_type, params, 5, false);
value = LLVMAddFunction(c->module, "llvm.memmove.p0i8.p0i8.i64", type);
}
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
}
static void init_runtime(compile_t* c)
{
c->str_builtin = stringtab("$0");
c->str_Bool = stringtab("Bool");
c->str_I8 = stringtab("I8");
c->str_I16 = stringtab("I16");
c->str_I32 = stringtab("I32");
c->str_I64 = stringtab("I64");
c->str_I128 = stringtab("I128");
c->str_ILong = stringtab("ILong");
c->str_ISize = stringtab("ISize");
c->str_U8 = stringtab("U8");
c->str_U16 = stringtab("U16");
c->str_U32 = stringtab("U32");
c->str_U64 = stringtab("U64");
c->str_U128 = stringtab("U128");
c->str_ULong = stringtab("ULong");
c->str_USize = stringtab("USize");
c->str_F32 = stringtab("F32");
c->str_F64 = stringtab("F64");
c->str_Pointer = stringtab("Pointer");
c->str_Maybe = stringtab("MaybePointer");
c->str_DoNotOptimise = stringtab("DoNotOptimise");
c->str_Array = stringtab("Array");
c->str_String = stringtab("String");
c->str_Platform = stringtab("Platform");
c->str_Main = stringtab("Main");
c->str_Env = stringtab("Env");
c->str_add = stringtab("add");
c->str_sub = stringtab("sub");
c->str_mul = stringtab("mul");
c->str_div = stringtab("div");
c->str_mod = stringtab("mod");
c->str_neg = stringtab("neg");
c->str_add_unsafe = stringtab("add_unsafe");
c->str_sub_unsafe = stringtab("sub_unsafe");
c->str_mul_unsafe = stringtab("mul_unsafe");
c->str_div_unsafe = stringtab("div_unsafe");
c->str_mod_unsafe = stringtab("mod_unsafe");
c->str_neg_unsafe = stringtab("neg_unsafe");
c->str_and = stringtab("op_and");
c->str_or = stringtab("op_or");
c->str_xor = stringtab("op_xor");
c->str_not = stringtab("op_not");
c->str_shl = stringtab("shl");
c->str_shr = stringtab("shr");
c->str_shl_unsafe = stringtab("shl_unsafe");
c->str_shr_unsafe = stringtab("shr_unsafe");
c->str_eq = stringtab("eq");
c->str_ne = stringtab("ne");
c->str_lt = stringtab("lt");
c->str_le = stringtab("le");
c->str_ge = stringtab("ge");
c->str_gt = stringtab("gt");
c->str_eq_unsafe = stringtab("eq_unsafe");
c->str_ne_unsafe = stringtab("ne_unsafe");
c->str_lt_unsafe = stringtab("lt_unsafe");
c->str_le_unsafe = stringtab("le_unsafe");
c->str_ge_unsafe = stringtab("ge_unsafe");
c->str_gt_unsafe = stringtab("gt_unsafe");
c->str_this = stringtab("this");
c->str_create = stringtab("create");
c->str__create = stringtab("_create");
c->str__init = stringtab("_init");
c->str__final = stringtab("_final");
c->str__event_notify = stringtab("_event_notify");
c->str__serialise_space = stringtab("_serialise_space");
c->str__serialise = stringtab("_serialise");
c->str__deserialise = stringtab("_deserialise");
LLVMTypeRef type;
LLVMTypeRef params[5];
LLVMValueRef value;
c->void_type = LLVMVoidTypeInContext(c->context);
c->i1 = LLVMInt1TypeInContext(c->context);
c->i8 = LLVMInt8TypeInContext(c->context);
c->i16 = LLVMInt16TypeInContext(c->context);
c->i32 = LLVMInt32TypeInContext(c->context);
c->i64 = LLVMInt64TypeInContext(c->context);
c->i128 = LLVMIntTypeInContext(c->context, 128);
c->f32 = LLVMFloatTypeInContext(c->context);
c->f64 = LLVMDoubleTypeInContext(c->context);
c->intptr = LLVMIntPtrTypeInContext(c->context, c->target_data);
// i8*
c->void_ptr = LLVMPointerType(c->i8, 0);
// forward declare object
c->object_type = LLVMStructCreateNamed(c->context, "__object");
c->object_ptr = LLVMPointerType(c->object_type, 0);
// padding required in an actor between the descriptor and fields
c->actor_pad = LLVMArrayType(c->i8, PONY_ACTOR_PAD_SIZE);
// message
params[0] = c->i32; // size
params[1] = c->i32; // id
c->msg_type = LLVMStructCreateNamed(c->context, "__message");
c->msg_ptr = LLVMPointerType(c->msg_type, 0);
LLVMStructSetBody(c->msg_type, params, 2, false);
// trace
// void (*)(i8*, __object*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
c->trace_type = LLVMFunctionType(c->void_type, params, 2, false);
c->trace_fn = LLVMPointerType(c->trace_type, 0);
// serialise
// void (*)(i8*, __object*, i8*, intptr, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->void_ptr;
params[3] = c->intptr;
params[4] = c->i32;
c->serialise_type = LLVMFunctionType(c->void_type, params, 5, false);
c->serialise_fn = LLVMPointerType(c->serialise_type, 0);
// serialise_space
// i64 (__object*)
params[0] = c->object_ptr;
c->custom_serialise_space_fn = LLVMPointerType(
LLVMFunctionType(c->i64, params, 1, false), 0);
// custom_deserialise
// void (*)(__object*, void*)
params[0] = c->object_ptr;
params[1] = c->void_ptr;
c->custom_deserialise_fn = LLVMPointerType(
LLVMFunctionType(c->void_type, params, 2, false), 0);
// dispatch
// void (*)(i8*, __object*, $message*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->msg_ptr;
c->dispatch_type = LLVMFunctionType(c->void_type, params, 3, false);
c->dispatch_fn = LLVMPointerType(c->dispatch_type, 0);
// void (*)(__object*)
params[0] = c->object_ptr;
c->final_fn = LLVMPointerType(
LLVMFunctionType(c->void_type, params, 1, false), 0);
// descriptor, opaque version
// We need this in order to build our own structure.
const char* desc_name = genname_descriptor(NULL);
c->descriptor_type = LLVMStructCreateNamed(c->context, desc_name);
c->descriptor_ptr = LLVMPointerType(c->descriptor_type, 0);
// field descriptor
// Also needed to build a descriptor structure.
params[0] = c->i32;
params[1] = c->descriptor_ptr;
c->field_descriptor = LLVMStructTypeInContext(c->context, params, 2, false);
// descriptor, filled in
gendesc_basetype(c, c->descriptor_type);
// define object
params[0] = c->descriptor_ptr;
LLVMStructSetBody(c->object_type, params, 1, false);
#if PONY_LLVM >= 309
LLVM_DECLARE_ATTRIBUTEREF(nounwind_attr, nounwind, 0);
LLVM_DECLARE_ATTRIBUTEREF(readnone_attr, readnone, 0);
LLVM_DECLARE_ATTRIBUTEREF(readonly_attr, readonly, 0);
LLVM_DECLARE_ATTRIBUTEREF(inacc_or_arg_mem_attr,
inaccessiblemem_or_argmemonly, 0);
LLVM_DECLARE_ATTRIBUTEREF(noalias_attr, noalias, 0);
LLVM_DECLARE_ATTRIBUTEREF(noreturn_attr, noreturn, 0);
LLVM_DECLARE_ATTRIBUTEREF(deref_actor_attr, dereferenceable,
PONY_ACTOR_PAD_SIZE + (target_is_ilp32(c->opt->triple) ? 4 : 8));
LLVM_DECLARE_ATTRIBUTEREF(align_pool_attr, align, ponyint_pool_size(0));
LLVM_DECLARE_ATTRIBUTEREF(align_heap_attr, align, HEAP_MIN);
LLVM_DECLARE_ATTRIBUTEREF(deref_or_null_alloc_attr, dereferenceable_or_null,
HEAP_MIN);
LLVM_DECLARE_ATTRIBUTEREF(deref_alloc_small_attr, dereferenceable, HEAP_MIN);
LLVM_DECLARE_ATTRIBUTEREF(deref_alloc_large_attr, dereferenceable,
HEAP_MAX << 1);
#endif
// i8* pony_ctx()
type = LLVMFunctionType(c->void_ptr, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_ctx", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, readnone_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMAddFunctionAttr(value, LLVMReadNoneAttribute);
#endif
// __object* pony_create(i8*, __Desc*)
params[0] = c->void_ptr;
params[1] = c->descriptor_ptr;
type = LLVMFunctionType(c->object_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_create", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, deref_actor_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_pool_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, PONY_ACTOR_PAD_SIZE +
(target_is_ilp32(c->opt->triple) ? 4 : 8));
#endif
// void ponyint_destroy(__object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "ponyint_destroy", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// void pony_sendv(i8*, __object*, $message*, $message*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->msg_ptr;
params[3] = c->msg_ptr;
type = LLVMFunctionType(c->void_type, params, 4, false);
value = LLVMAddFunction(c->module, "pony_sendv", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// void pony_sendv_single(i8*, __object*, $message*, $message*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->msg_ptr;
params[3] = c->msg_ptr;
type = LLVMFunctionType(c->void_type, params, 4, false);
value = LLVMAddFunction(c->module, "pony_sendv_single", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// i8* pony_alloc(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_or_null_alloc_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_small(i8*, i32)
params[0] = c->void_ptr;
params[1] = c->i32;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_small", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_alloc_small_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_large(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_large", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_alloc_large_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MAX << 1);
#endif
// i8* pony_realloc(i8*, i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_realloc", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_or_null_alloc_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_final(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_final", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_or_null_alloc_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceableOrNull(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_small_final(i8*, i32)
params[0] = c->void_ptr;
params[1] = c->i32;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_small_final", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_alloc_small_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MIN);
#endif
// i8* pony_alloc_large_final(i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_large_final", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex,
deref_alloc_large_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_heap_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
LLVMSetDereferenceable(value, 0, HEAP_MAX << 1);
#endif
// $message* pony_alloc_msg(i32, i32)
params[0] = c->i32;
params[1] = c->i32;
type = LLVMFunctionType(c->msg_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_msg", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, align_pool_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
#endif
// void pony_trace(i8*, i8*)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_trace", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, 2, readnone_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
value = LLVMGetParam(value, 1);
LLVMAddAttribute(value, LLVMReadNoneAttribute);
#endif
// void pony_traceknown(i8*, __object*, __Desc*, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->descriptor_ptr;
params[3] = c->i32;
type = LLVMFunctionType(c->void_type, params, 4, false);
value = LLVMAddFunction(c->module, "pony_traceknown", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, 2, readonly_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
value = LLVMGetParam(value, 1);
LLVMAddAttribute(value, LLVMReadOnlyAttribute);
#endif
// void pony_traceunknown(i8*, __object*, i32)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
params[2] = c->i32;
type = LLVMFunctionType(c->void_type, params, 3, false);
value = LLVMAddFunction(c->module, "pony_traceunknown", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, 2, readonly_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
value = LLVMGetParam(value, 1);
LLVMAddAttribute(value, LLVMReadOnlyAttribute);
#endif
// void pony_gc_send(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_gc_send", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// void pony_gc_recv(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_gc_recv", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// void pony_send_done(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_send_done", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
#endif
// void pony_recv_done(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_recv_done", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
#endif
// void pony_serialise_reserve(i8*, i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_type, params, 3, false);
value = LLVMAddFunction(c->module, "pony_serialise_reserve", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, 2, readnone_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
value = LLVMGetParam(value, 1);
LLVMAddAttribute(value, LLVMReadNoneAttribute);
#endif
// intptr pony_serialise_offset(i8*, i8*)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
type = LLVMFunctionType(c->intptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_serialise_offset", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, 2, readonly_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
value = LLVMGetParam(value, 1);
LLVMAddAttribute(value, LLVMReadOnlyAttribute);
#endif
// i8* pony_deserialise_offset(i8*, __desc*, intptr)
params[0] = c->void_ptr;
params[1] = c->descriptor_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_deserialise_offset", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#elif PONY_LLVM == 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
#endif
// i8* pony_deserialise_block(i8*, intptr, intptr)
params[0] = c->void_ptr;
params[1] = c->intptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->void_ptr, params, 3, false);
value = LLVMAddFunction(c->module, "pony_deserialise_block", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeReturnIndex, noalias_attr);
#else
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
LLVMSetReturnNoAlias(value);
#endif
// i32 pony_init(i32, i8**)
params[0] = c->i32;
params[1] = LLVMPointerType(c->void_ptr, 0);
type = LLVMFunctionType(c->i32, params, 2, false);
value = LLVMAddFunction(c->module, "pony_init", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// void pony_become(i8*, __object*)
params[0] = c->void_ptr;
params[1] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_become", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// i32 pony_start(i32, i32)
params[0] = c->i32;
params[1] = c->i32;
type = LLVMFunctionType(c->i32, params, 2, false);
value = LLVMAddFunction(c->module, "pony_start", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex,
inacc_or_arg_mem_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
# if PONY_LLVM >= 308
LLVMSetInaccessibleMemOrArgMemOnly(value);
# endif
#endif
// i32 pony_get_exitcode()
type = LLVMFunctionType(c->i32, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_get_exitcode", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, readonly_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMAddFunctionAttr(value, LLVMReadOnlyAttribute);
#endif
// void pony_throw()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_throw", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, noreturn_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoReturnAttribute);
#endif
// i32 pony_personality_v0(...)
type = LLVMFunctionType(c->i32, NULL, 0, true);
c->personality = LLVMAddFunction(c->module, "pony_personality_v0", type);
// i32 memcmp(i8*, i8*, intptr)
params[0] = c->void_ptr;
params[1] = c->void_ptr;
params[2] = c->intptr;
type = LLVMFunctionType(c->i32, params, 3, false);
value = LLVMAddFunction(c->module, "memcmp", type);
#if PONY_LLVM >= 309
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, nounwind_attr);
LLVMAddAttributeAtIndex(value, LLVMAttributeFunctionIndex, readonly_attr);
LLVMAddAttributeAtIndex(value, 1, readonly_attr);
LLVMAddAttributeAtIndex(value, 2, readonly_attr);
#else
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMAddFunctionAttr(value, LLVMReadOnlyAttribute);
LLVMValueRef param = LLVMGetParam(value, 0);
LLVMAddAttribute(param, LLVMReadOnlyAttribute);
param = LLVMGetParam(value, 1);
LLVMAddAttribute(param, LLVMReadOnlyAttribute);
#endif
}
static void init_runtime(compile_t* c)
{
c->str_1 = stringtab("$1");
c->str_Bool = stringtab("Bool");
c->str_I8 = stringtab("I8");
c->str_I16 = stringtab("I16");
c->str_I32 = stringtab("I32");
c->str_I64 = stringtab("I64");
c->str_I128 = stringtab("I128");
c->str_U8 = stringtab("U8");
c->str_U16 = stringtab("U16");
c->str_U32 = stringtab("U32");
c->str_U64 = stringtab("U64");
c->str_U128 = stringtab("U128");
c->str_F32 = stringtab("F32");
c->str_F64 = stringtab("F64");
c->str_Pointer = stringtab("Pointer");
c->str_Array = stringtab("Array");
c->str_Platform = stringtab("Platform");
c->str_add = stringtab("add");
c->str_sub = stringtab("sub");
c->str_mul = stringtab("mul");
c->str_div = stringtab("div");
c->str_mod = stringtab("mod");
c->str_neg = stringtab("neg");
c->str_and = stringtab("op_and");
c->str_or = stringtab("op_or");
c->str_xor = stringtab("op_xor");
c->str_not = stringtab("op_not");
c->str_shl = stringtab("shl");
c->str_shr = stringtab("shr");
c->str_eq = stringtab("eq");
c->str_ne = stringtab("ne");
c->str_lt = stringtab("lt");
c->str_le = stringtab("le");
c->str_ge = stringtab("ge");
c->str_gt = stringtab("gt");
LLVMTypeRef type;
LLVMTypeRef params[4];
LLVMValueRef value;
c->void_type = LLVMVoidTypeInContext(c->context);
c->i1 = LLVMInt1TypeInContext(c->context);
c->i8 = LLVMInt8TypeInContext(c->context);
c->i16 = LLVMInt16TypeInContext(c->context);
c->i32 = LLVMInt32TypeInContext(c->context);
c->i64 = LLVMInt64TypeInContext(c->context);
c->i128 = LLVMIntTypeInContext(c->context, 128);
c->f32 = LLVMFloatTypeInContext(c->context);
c->f64 = LLVMDoubleTypeInContext(c->context);
c->intptr = LLVMIntPtrTypeInContext(c->context, c->target_data);
// i8*
c->void_ptr = LLVMPointerType(c->i8, 0);
// forward declare object
c->object_type = LLVMStructCreateNamed(c->context, "$object");
c->object_ptr = LLVMPointerType(c->object_type, 0);
// padding required in an actor between the descriptor and fields
c->actor_pad = LLVMArrayType(c->i8, PONY_ACTOR_PAD_SIZE);
// message
params[0] = c->i32; // size
params[1] = c->i32; // id
c->msg_type = LLVMStructCreateNamed(c->context, "$message");
c->msg_ptr = LLVMPointerType(c->msg_type, 0);
LLVMStructSetBody(c->msg_type, params, 2, false);
// trace
// void (*)($object*)
params[0] = c->object_ptr;
c->trace_type = LLVMFunctionType(c->void_type, params, 1, false);
c->trace_fn = LLVMPointerType(c->trace_type, 0);
// dispatch
// void (*)($object*, $message*)
params[0] = c->object_ptr;
params[1] = c->msg_ptr;
c->dispatch_type = LLVMFunctionType(c->void_type, params, 2, false);
c->dispatch_fn = LLVMPointerType(c->dispatch_type, 0);
// void (*)($object*)
params[0] = c->object_ptr;
c->final_fn = LLVMPointerType(
LLVMFunctionType(c->void_type, params, 1, false), 0);
// descriptor, opaque version
// We need this in order to build our own structure.
const char* desc_name = genname_descriptor(NULL);
c->descriptor_type = LLVMStructCreateNamed(c->context, desc_name);
c->descriptor_ptr = LLVMPointerType(c->descriptor_type, 0);
// field descriptor
// Also needed to build a descriptor structure.
params[0] = c->i32;
params[1] = c->descriptor_ptr;
c->field_descriptor = LLVMStructTypeInContext(c->context, params, 2, false);
// descriptor, filled in
c->descriptor_type = gendesc_type(c, NULL);
// define object
params[0] = c->descriptor_ptr;
LLVMStructSetBody(c->object_type, params, 1, false);
// $object* pony_create($desc*)
params[0] = c->descriptor_ptr;
type = LLVMFunctionType(c->object_ptr, params, 1, false);
value = LLVMAddFunction(c->module, "pony_create", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// void pony_destroy($object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_destroy", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
//LLVMSetReturnNoAlias(value);
// void pony_sendv($object*, $message*);
params[0] = c->object_ptr;
params[1] = c->msg_ptr;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_sendv", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* pony_alloc(i64)
params[0] = c->i64;
type = LLVMFunctionType(c->void_ptr, params, 1, false);
value = LLVMAddFunction(c->module, "pony_alloc", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// i8* pony_realloc(i8*, i64)
params[0] = c->void_ptr;
params[1] = c->i64;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_realloc", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// i8* pony_alloc_final(i64, c->final_fn)
params[0] = c->i64;
params[1] = c->final_fn;
type = LLVMFunctionType(c->void_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_final", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// $message* pony_alloc_msg(i32, i32)
params[0] = c->i32;
params[1] = c->i32;
type = LLVMFunctionType(c->msg_ptr, params, 2, false);
value = LLVMAddFunction(c->module, "pony_alloc_msg", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
LLVMSetReturnNoAlias(value);
// void pony_trace(i8*)
params[0] = c->void_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_trace", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_traceactor($object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_traceactor", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_traceobject($object*, trace_fn)
params[0] = c->object_ptr;
params[1] = c->trace_fn;
type = LLVMFunctionType(c->void_type, params, 2, false);
value = LLVMAddFunction(c->module, "pony_traceobject", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_traceunknown($object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_traceunknown", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_trace_tag_or_actor($object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_trace_tag_or_actor", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_gc_send()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_gc_send", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_gc_recv()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_gc_recv", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_send_done()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_send_done", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_recv_done()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
value = LLVMAddFunction(c->module, "pony_recv_done", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i32 pony_init(i32, i8**)
params[0] = c->i32;
params[1] = LLVMPointerType(c->void_ptr, 0);
type = LLVMFunctionType(c->i32, params, 2, false);
value = LLVMAddFunction(c->module, "pony_init", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_become($object*)
params[0] = c->object_ptr;
type = LLVMFunctionType(c->void_type, params, 1, false);
value = LLVMAddFunction(c->module, "pony_become", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i32 pony_start(i32)
params[0] = c->i32;
type = LLVMFunctionType(c->i32, params, 1, false);
value = LLVMAddFunction(c->module, "pony_start", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// void pony_throw()
type = LLVMFunctionType(c->void_type, NULL, 0, false);
LLVMAddFunction(c->module, "pony_throw", type);
// i32 pony_personality_v0(...)
type = LLVMFunctionType(c->i32, NULL, 0, true);
c->personality = LLVMAddFunction(c->module, "pony_personality_v0", type);
// i8* memcpy(...)
type = LLVMFunctionType(c->void_ptr, NULL, 0, true);
value = LLVMAddFunction(c->module, "memcpy", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
// i8* memmove(...)
type = LLVMFunctionType(c->void_ptr, NULL, 0, true);
value = LLVMAddFunction(c->module, "memmove", type);
LLVMAddFunctionAttr(value, LLVMNoUnwindAttribute);
}