ir_entity *create_compilerlib_entity(ident *id, ir_type *mt)
{
ir_entity *entity = pmap_get(ir_entity, irp->compilerlib_entities, id);
if (entity != NULL)
return entity;
/* let frontend mangle the name */
ident *ld_name = compilerlib_mangler(id, mt);
/* search for an existing entity */
ir_type *glob = get_glob_type();
for (size_t i = 0, n_members = get_compound_n_members(glob);
i < n_members; ++i) {
ir_entity *member = get_compound_member(glob, i);
if (get_entity_ld_ident(member) == ld_name) {
entity = member;
goto found;
}
}
entity = new_entity(glob, id, mt);
set_entity_ld_ident(entity, ld_name);
set_entity_visibility(entity, ir_visibility_external);
found:
pmap_insert(irp->compilerlib_entities, id, entity);
return entity;
}
int tr_verify(void)
{
bool fine = true;
type_walk(check_tore, NULL, &fine);
for (ir_segment_t s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
ir_type const *const segment = get_segment_type(s);
for (size_t e = 0; e < get_compound_n_members(segment); ++e) {
ir_entity const *const entity = get_compound_member(segment, e);
ident *const ld_ident = get_entity_ld_ident(entity);
if (ld_ident == NULL &&
get_entity_visibility(entity) != ir_visibility_private) {
report_error("public segment member %+F has no name",
entity);
fine = false;
continue;
}
if (segment->flags & tf_info)
fine &= verify_info_member(segment, entity);
}
}
ir_type const *const thread_locals
= get_segment_type(IR_SEGMENT_THREAD_LOCAL);
for (size_t i = 0, n = get_compound_n_members(thread_locals); i < n; ++i) {
const ir_entity *entity = get_compound_member(thread_locals, i);
/* this is odd and should not be allowed I think */
if (is_method_entity(entity)) {
report_error("method %+F in thread local segment", entity);
fine = false;
}
if (get_entity_linkage(entity) & IR_LINKAGE_CONSTANT) {
report_error("entity %+F in thread local segment is constant",
entity);
fine = false;
}
}
return fine;
}
static bool check_compound_type(const ir_type *tp)
{
bool fine = true;
bool is_class = is_Class_type(tp);
for (size_t i = 0, n = get_compound_n_members(tp); i < n; ++i) {
ir_entity *member = get_compound_member(tp, i);
if (member == NULL) {
report_error("%+F has a NULL member\n", tp);
fine = false;
continue;
}
ir_type *owner = get_entity_owner(member);
if (owner != tp) {
report_error("member %+F of %+F has owner %+F\n", member, tp, owner);
fine = false;
}
if (is_class) {
fine &= check_class_member(tp, member);
}
}
return fine;
}
void jit_compile_execute_main(void)
{
unsigned const alignment = 16;
unsigned const align_mask = ~(alignment-1);
optimize_lower_ir_prog();
/* This is somewhat ad-hoc testing code for the jit, it is limited and
* will not handle all firm programs. */
const struct {
char const *name;
void const *func;
} external_functions[] = {
{ "atoi", (void const*)(intptr_t)atoi },
{ "free", (void const*)(intptr_t)free },
{ "getchar", (void const*)(intptr_t)getchar },
{ "malloc", (void const*)(intptr_t)malloc },
{ "printf", (void const*)(intptr_t)printf },
{ "puts", (void const*)(intptr_t)puts },
{ "rand", (void const*)(intptr_t)rand },
{ "realloc", (void const*)(intptr_t)realloc },
};
ir_jit_segment_t *const segment = be_new_jit_segment();
ir_entity ** funcents = NEW_ARR_F(ir_entity*, 0);
ir_jit_function_t ** functions = NEW_ARR_F(ir_jit_function_t*, 0);
ir_entity *main_entity = NULL;
size_t code_size = 0;
ir_type *const global_type = get_glob_type();
for (size_t i = 0, n = get_compound_n_members(global_type); i < n; ++i) {
ir_entity *const entity = get_compound_member(global_type, i);
char const *const ld_name = get_entity_ld_name(entity);
if (is_method_entity(entity)
&& !(get_entity_linkage(entity) & IR_LINKAGE_NO_CODEGEN)) {
ir_graph *const irg = get_entity_irg(entity);
if (irg != NULL) {
ir_jit_function_t *const func = be_jit_compile(segment, irg);
if (func == NULL)
panic("Could not jit compile '%s'", ld_name);
unsigned const misalign = alignment - (code_size%alignment);
code_size += (misalign != alignment ? misalign : 0);
ARR_APP1(ir_jit_function_t*, functions, func);
ARR_APP1(ir_entity*, funcents, entity);
code_size += be_get_function_size(func);
if (streq(ld_name, "main") || streq(ld_name, "_main"))
main_entity = entity;
continue;
}
}
/* See if its one of our well-known functions */
for (unsigned f = 0; f < ARRAY_SIZE(external_functions); ++f) {
char const *const name = external_functions[f].name;
void const *const func = external_functions[f].func;
if (streq(ld_name, name)
|| (ld_name[0] == '_' && streq(&ld_name[1], name))) {
be_jit_set_entity_addr(entity, func);
break;
}
}
}
if (main_entity == NULL)
panic("Could not find main() function");
/* Allocate executable memory */
char *const memory = mmap(0, code_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (memory == NULL)
panic("Could not mmap memory");
/* Determine final function addresses */
size_t const n_functions = ARR_LEN(functions);
assert(ARR_LEN(funcents) == n_functions);
unsigned offset = 0;
for (size_t i = 0; i < n_functions; ++i) {
offset = (offset + alignment - 1) & align_mask;
char *const dest = memory + offset;
ir_entity *const entity = funcents[i];
be_jit_set_entity_addr(entity, dest);
offset += be_get_function_size(functions[i]);
}
assert(offset == code_size);
/* Emit and resolve */
for (size_t i = 0; i < n_functions; ++i) {
ir_entity *const entity = funcents[i];
char *const dest
= memory + ((char const*)be_jit_get_entity_addr(entity) - memory);
be_emit_function(dest, functions[i]);
}
be_destroy_jit_segment(segment);
if (mprotect(memory, code_size, PROT_EXEC) != 0)
panic("Couldn't make memory executable");
typedef int (*mainfunc)(int argc, char **argv);
mainfunc main_ptr = (mainfunc)(intptr_t)be_jit_get_entity_addr(main_entity);
int res = main_ptr(0, NULL);
fprintf(stderr, "Exit code: %d\n", res);
munmap(memory, code_size);
}
static bool check_initializer(const ir_initializer_t *initializer,
const ir_type *type,
const ir_entity *context)
{
bool fine = true;
switch (get_initializer_kind(initializer)) {
case IR_INITIALIZER_NULL:
return fine;
case IR_INITIALIZER_TARVAL: {
ir_tarval *tv = get_initializer_tarval_value(initializer);
if (get_type_mode(type) != get_tarval_mode(tv)) {
report_error("tarval initializer for entity %+F has wrong mode: %+F vs %+F", context, get_type_mode(type), get_tarval_mode(tv));
fine = false;
}
return fine;
}
case IR_INITIALIZER_CONST: {
ir_node *value = get_initializer_const_value(initializer);
if (get_type_mode(type) != get_irn_mode(value)) {
report_error("const initializer for entity %+F has wrong mode: %+F vs %+F", context, get_type_mode(type), get_irn_mode(value));
fine = false;
}
if (!constant_on_correct_irg(value)) {
report_error("initializer const value %+F for entity %+F not on const-code irg", value, context);
fine = false;
}
return fine;
}
case IR_INITIALIZER_COMPOUND: {
size_t n_entries = get_initializer_compound_n_entries(initializer);
if (is_Array_type(type)) {
ir_type *element_type = get_array_element_type(type);
/* TODO: check array bounds? */
for (size_t i = 0; i < n_entries; ++i) {
const ir_initializer_t *sub_initializer
= get_initializer_compound_value(initializer, i);
check_initializer(sub_initializer, element_type, context);
}
} else if (is_compound_type(type)) {
size_t n_members = get_compound_n_members(type);
if (n_entries > n_members) {
report_error("too many values in compound initializer of %+F",
context);
fine = false;
}
for (size_t i = 0; i < n_entries; ++i) {
if (i >= n_members)
break;
ir_entity *member = get_compound_member(type, i);
ir_type *member_type = get_entity_type(member);
const ir_initializer_t *sub_initializer
= get_initializer_compound_value(initializer, i);
check_initializer(sub_initializer, member_type, context);
}
} else {
report_error("compound initiailizer for non-array/compound type in entity %+F",
context);
fine = false;
}
return fine;
}
}
report_error("invalid initializer for entity %+F", context);
return false;
}
int tr_verify(void)
{
bool fine = true;
ir_type *constructors;
ir_type *destructors;
ir_type *thread_locals;
type_walk(check_tore, NULL, &fine);
for (ir_segment_t s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
const ir_type *type = get_segment_type(s);
for (size_t e = 0; e < get_compound_n_members(type); ++e) {
ir_entity *entity = get_compound_member(type, e);
if (get_entity_ld_ident(entity) == NULL &&
get_entity_visibility(entity) != ir_visibility_private) {
report_error("public segment member %+F has no name",
entity);
fine = false;
}
}
}
constructors = get_segment_type(IR_SEGMENT_CONSTRUCTORS);
for (size_t i = 0, n = get_compound_n_members(constructors); i < n; ++i) {
const ir_entity *entity = get_compound_member(constructors, i);
if ((get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER) == 0) {
report_error("entity %+F in constructors without LINKAGE_HIDDEN_USER",
entity);
fine = false;
}
/* Mach-O doesn't like labels in this section */
if (get_entity_ld_name(entity)[0] != '\0') {
report_error("entity %+F in constructors must not have an ld_name",
entity);
fine = false;
}
}
destructors = get_segment_type(IR_SEGMENT_DESTRUCTORS);
for (size_t i = 0, n = get_compound_n_members(destructors); i < n; ++i) {
const ir_entity *entity = get_compound_member(destructors, i);
if ((get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER) == 0) {
report_error("entity %+F in destructors without LINKAGE_HIDDEN_USER",
entity);
fine = false;
}
/* Mach-O doesn't like labels in this section */
if (get_entity_ld_name(entity)[0] != '\0') {
report_error("entity %+F in destructors must not have an ld_name",
entity);
fine = false;
}
}
thread_locals = get_segment_type(IR_SEGMENT_THREAD_LOCAL);
for (size_t i = 0, n = get_compound_n_members(thread_locals); i < n; ++i) {
const ir_entity *entity = get_compound_member(thread_locals, i);
/* this is odd and should not be allowed I think */
if (is_method_entity(entity)) {
report_error("method %+F in thread local segment");
fine = false;
}
if (get_entity_linkage(entity) & IR_LINKAGE_CONSTANT) {
report_error("entity %+F in thread local segment is constant");
fine = false;
}
}
return fine;
}
