X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbegnuas.c;h=a2d36cb88a0a6b6d2ff935648ebfff6bfc610a2a;hb=4afdd22d55e88960e79760b6193253534ce298f1;hp=65e4e35c35415ea15dfa11f640373858e807e17d;hpb=cae489f4820198cafe19f3c4eb4a759ddebb56e3;p=libfirm diff --git a/ir/be/begnuas.c b/ir/be/begnuas.c index 65e4e35c3..a2d36cb88 100644 --- a/ir/be/begnuas.c +++ b/ir/be/begnuas.c @@ -24,9 +24,7 @@ * @date 04.11.2005 * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include "begnuas.h" @@ -68,7 +66,11 @@ static const char *get_section_name(be_gas_section_t section) { ".section\t.rodata", ".section\t.bss", ".section\t.tbss,\"awT\",@nobits", - ".section\t.ctors,\"aw\",@progbits" + ".section\t.ctors,\"aw\",@progbits", + ".section\t.dtors,\"aw\",@progbits", + NULL, /* no cstring section */ + NULL, + NULL }, { /* GAS_FLAVOUR_MINGW */ ".section\t.text", @@ -76,7 +78,11 @@ static const char *get_section_name(be_gas_section_t section) { ".section .rdata,\"dr\"", ".section\t.bss", ".section\t.tbss,\"awT\",@nobits", - ".section\t.ctors,\"aw\",@progbits" + ".section\t.ctors,\"aw\",@progbits", + ".section\t.dtors,\"aw\",@progbits", + NULL, + NULL, + NULL }, { /* GAS_FLAVOUR_YASM */ ".section\t.text", @@ -84,15 +90,23 @@ static const char *get_section_name(be_gas_section_t section) { ".section\t.rodata", ".section\t.bss", ".section\t.tbss,\"awT\",@nobits", - ".section\t.ctors,\"aw\",@progbits" + ".section\t.ctors,\"aw\",@progbits", + ".section\t.dtors,\"aw\",@progbits", + NULL, + NULL, + NULL }, { /* GAS_FLAVOUR_MACH_O */ ".text", ".data", ".const", ".data", - NULL, /* TLS is not supported on Mach-O */ - NULL /* constructors aren't marked with sections in Mach-O */ + NULL, /* TLS is not supported on Mach-O */ + ".mod_init_func", + NULL, /* TODO: how is this called? */ + ".cstring", + ".section\t__IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5", + ".section\t__IMPORT,__pointers,non_lazy_symbol_pointers" } }; @@ -102,7 +116,7 @@ static const char *get_section_name(be_gas_section_t section) { } void be_gas_emit_switch_section(be_gas_section_t section) { - if(current_section == section) + if (current_section == section) return; be_emit_char('\t'); @@ -115,6 +129,8 @@ void be_gas_emit_switch_section(be_gas_section_t section) { void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment) { const char *name = get_entity_ld_name(entity); + const char *fill_byte = ""; + unsigned maximum_skip; be_gas_emit_switch_section(GAS_SECTION_TEXT); @@ -125,17 +141,17 @@ void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment) be_emit_char('\n'); be_emit_write_line(); - const char *fill_byte = ""; /* gcc fills space between function with 0x90, no idea if this is needed */ - if(be_gas_flavour == GAS_FLAVOUR_MACH_O) { + if (be_gas_flavour == GAS_FLAVOUR_MACH_O) { fill_byte = "0x90"; } - unsigned maximum_skip = (1 << alignment) - 1; - be_emit_cstring("\t.p2align "); - be_emit_irprintf("%u,%s,%u\n", alignment, fill_byte, maximum_skip); - be_emit_write_line(); - + if (alignment > 0) { + maximum_skip = (1 << alignment) - 1; + be_emit_cstring("\t.p2align "); + be_emit_irprintf("%u,%s,%u\n", alignment, fill_byte, maximum_skip); + be_emit_write_line(); + } if (get_entity_visibility(entity) == visibility_external_visible) { be_emit_cstring(".globl "); be_emit_string(name); @@ -153,7 +169,11 @@ void be_gas_emit_function_prolog(ir_entity *entity, unsigned alignment) case GAS_FLAVOUR_MINGW: be_emit_cstring("\t.def\t"); be_emit_string(name); - be_emit_cstring(";\t.scl\t2;\t.type\t32;\t.endef\n"); + if (get_entity_visibility(entity) == visibility_external_visible) { + be_emit_cstring(";\t.scl\t2;\t.type\t32;\t.endef\n"); + } else { + be_emit_cstring(";\t.scl\t3;\t.type\t32;\t.endef\n"); + } be_emit_write_line(); break; case GAS_FLAVOUR_MACH_O: @@ -191,9 +211,8 @@ void be_gas_emit_function_epilog(ir_entity *entity) * and even there NOT needed. So we might change it in the future. */ typedef struct _be_gas_decl_env { - const be_main_env_t *main_env; /**< The main backend environment, used for it's debug handle. */ - int dump_tls; - waitq *worklist; /**< A worklist we use to place not yet handled entities on. */ + be_gas_section_t section; + waitq *worklist; /**< A worklist we use to place not yet handled entities on. */ } be_gas_decl_env_t; /************************************************************************/ @@ -209,59 +228,76 @@ static void dump_arith_tarval(tarval *tv, int bytes) switch (bytes) { case 1: be_emit_irprintf("0x%02x", get_tarval_sub_bits(tv, 0)); - break; + return; case 2: be_emit_irprintf("0x%02x%02x", get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0)); - break; + return; case 4: be_emit_irprintf("0x%02x%02x%02x%02x", get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0)); - break; + return; case 8: be_emit_irprintf("0x%02x%02x%02x%02x%02x%02x%02x%02x", get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6), get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4), get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0)); - break; + return; - case 10: case 12: - break; + /* Beware: Mixed endian output! One little endian number emitted as + * three longs. Each long initializer is written in big endian. */ + be_emit_irprintf( + "\t.long\t0x%02x%02x%02x%02x\n" + "\t.long\t0x%02x%02x%02x%02x\n" + "\t.long\t0x%02x%02x%02x%02x", + get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), + get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0), + get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6), + get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4), + get_tarval_sub_bits(tv, 11), get_tarval_sub_bits(tv, 10), + get_tarval_sub_bits(tv, 9), get_tarval_sub_bits(tv, 8) + ); + return; case 16: - be_emit_irprintf("0x%02x%02x%02x%02x%02x%02x%02x%02x" - "%02x%02x%02x%02x%02x%02x%02x%02x", + be_emit_irprintf( + "\t.long\t0x%02x%02x%02x%02x0x%02x%02x%02x%02x0x%02x%02x%02x%02x0x%02x%02x%02x%02x", get_tarval_sub_bits(tv, 15), get_tarval_sub_bits(tv, 16), get_tarval_sub_bits(tv, 13), get_tarval_sub_bits(tv, 12), get_tarval_sub_bits(tv, 11), get_tarval_sub_bits(tv, 10), - get_tarval_sub_bits(tv, 9), get_tarval_sub_bits(tv, 8), - get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6), - get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4), - get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), - get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0)); - break; - - - default: - fprintf(stderr, "Try to dump an tarval with %d bytes\n", bytes); - assert(0); + get_tarval_sub_bits(tv, 9), get_tarval_sub_bits(tv, 8), + get_tarval_sub_bits(tv, 7), get_tarval_sub_bits(tv, 6), + get_tarval_sub_bits(tv, 5), get_tarval_sub_bits(tv, 4), + get_tarval_sub_bits(tv, 3), get_tarval_sub_bits(tv, 2), + get_tarval_sub_bits(tv, 1), get_tarval_sub_bits(tv, 0) + ); + return; } + + panic("Can't dump a tarval with %d bytes", bytes); } /** * Return the label prefix for labeled blocks. */ -const char *be_gas_label_prefix(void) { +const char *be_gas_block_label_prefix(void) { return ".LG"; } +/** + * Return the label prefix for labeled instructions. + */ +const char *be_gas_insn_label_prefix(void) { + return ".LE"; +} + /** * Dump a label. */ static void dump_label(ir_label_t label) { - be_emit_irprintf("%s%ld", be_gas_label_prefix(), label); + be_emit_irprintf("%s%lu", be_gas_block_label_prefix(), label); } /** @@ -356,7 +392,7 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init) case symconst_addr_ent: ent = get_SymConst_entity(init); - if(!is_entity_backend_marked(ent)) { + if (!is_entity_backend_marked(ent)) { waitq_put(env->worklist, ent); set_entity_backend_marked(ent, 1); } @@ -366,7 +402,7 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init) case symconst_ofs_ent: ent = get_SymConst_entity(init); #if 0 /* not needed, is it? */ - if(!is_entity_backend_marked(ent)) { + if (!is_entity_backend_marked(ent)) { waitq_put(env->worklist, ent); set_entity_backend_marked(ent, 1); } @@ -397,26 +433,35 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *init) } return; - case iro_Add: - do_dump_atomic_init(env, get_Add_left(init)); - be_emit_cstring(" + "); - do_dump_atomic_init(env, get_Add_right(init)); - return; + case iro_Add: + if (!mode_is_int(mode) && !mode_is_reference(mode)) { + panic("Constant must be int or pointer for '+' to work"); + } + do_dump_atomic_init(env, get_Add_left(init)); + be_emit_cstring(" + "); + do_dump_atomic_init(env, get_Add_right(init)); + return; - case iro_Sub: - do_dump_atomic_init(env, get_Sub_left(init)); - be_emit_cstring(" - "); - do_dump_atomic_init(env, get_Sub_right(init)); - return; + case iro_Sub: + if (!mode_is_int(mode) && !mode_is_reference(mode)) { + panic("Constant must be int or pointer for '-' to work"); + } + do_dump_atomic_init(env, get_Sub_left(init)); + be_emit_cstring(" - "); + do_dump_atomic_init(env, get_Sub_right(init)); + return; - case iro_Mul: - do_dump_atomic_init(env, get_Mul_left(init)); - be_emit_cstring(" * "); - do_dump_atomic_init(env, get_Mul_right(init)); - return; + case iro_Mul: + if (!mode_is_int(mode) && !mode_is_reference(mode)) { + panic("Constant must be int or pointer for '*' to work"); + } + do_dump_atomic_init(env, get_Mul_left(init)); + be_emit_cstring(" * "); + do_dump_atomic_init(env, get_Mul_right(init)); + return; - default: - assert(0 && "dump_atomic_init(): unknown IR-node"); + default: + panic("dump_atomic_init(): unsupported IR-node %+F", init); } } @@ -453,7 +498,7 @@ static void dump_size_type(size_t size) { break; default: - panic("Try to dump a type with %u bytes\n", (unsigned) size); + panic("Try to dump a type with %u bytes", (unsigned)size); } } @@ -481,41 +526,41 @@ static void dump_atomic_init(be_gas_decl_env_t *env, ir_node *init) static int initializer_is_string_const(const ir_initializer_t *initializer) { size_t i, len; + int found_printable = 0; - if(initializer->kind != IR_INITIALIZER_COMPOUND) + if (initializer->kind != IR_INITIALIZER_COMPOUND) return 0; len = initializer->compound.n_initializers; if (len < 1) return 0; - for(i = 0; i < len; ++i) { + for (i = 0; i < len; ++i) { int c; tarval *tv; ir_mode *mode; ir_initializer_t *sub_initializer = initializer->compound.initializers[i]; - if(sub_initializer->kind != IR_INITIALIZER_TARVAL) + if (sub_initializer->kind != IR_INITIALIZER_TARVAL) return 0; tv = sub_initializer->tarval.value; mode = get_tarval_mode(tv); - if (!mode_is_int(mode) - || get_mode_size_bits(mode) != get_mode_size_bits(mode_Bs)) + if (!mode_is_int(mode) || get_mode_size_bits(mode) != 8) return 0; c = get_tarval_long(tv); - if (i < len - 1) { - if (!isgraph(c) && !isspace(c)) - return 0; - } else { - if (c != 0) - return 0; - } + if (isgraph(c) || isspace(c)) + found_printable = 1; + else if (c != 0) + return 0; + + if (i == len - 1 && c != '\0') + return 0; } - return 1; + return found_printable; } /** @@ -528,6 +573,7 @@ static int ent_is_string_const(ir_entity *ent) ir_type *type, *element_type; ir_mode *mode; int i, c, n; + int found_printable = 0; type = get_entity_type(ent); @@ -544,11 +590,10 @@ static int ent_is_string_const(ir_entity *ent) /* and the mode of the element type is an int of * the same size as the byte mode */ mode = get_type_mode(element_type); - if (!mode_is_int(mode) - || get_mode_size_bits(mode) != get_mode_size_bits(mode_Bs)) + if (!mode_is_int(mode) || get_mode_size_bits(mode) != 8) return 0; - if(ent->has_initializer) { + if (ent->has_initializer) { /* TODO */ return 0; } else { @@ -561,14 +606,18 @@ static int ent_is_string_const(ir_entity *ent) c = (int) get_tarval_long(get_Const_tarval(irn)); - if((i < n - 1 && !(isgraph(c) || isspace(c))) - || (i == n - 1 && c != '\0')) + if (isgraph(c) || isspace(c)) + found_printable = 1; + else if (c != 0) + return 0; + + if (i == n - 1 && c != '\0') return 0; } } /* then we can emit it as a string constant */ - return 1; + return found_printable; } /** @@ -580,23 +629,21 @@ static int ent_is_string_const(ir_entity *ent) static void dump_string_cst(ir_entity *ent) { int i, len; + int output_len; ir_type *type; int type_size; int remaining_space; - be_gas_section_t last_section = current_section; - len = get_compound_ent_n_values(ent); + len = get_compound_ent_n_values(ent); + output_len = len; if (be_gas_flavour == GAS_FLAVOUR_MACH_O) { - if (get_entity_variability(ent) == variability_constant) { - be_gas_emit_switch_section(GAS_SECTION_CSTRING); - } be_emit_cstring("\t.ascii \""); } else { be_emit_cstring("\t.string \""); - len -= 1; + output_len -= 1; } - for (i = 0; i < len; ++i) { + for (i = 0; i < output_len; ++i) { ir_node *irn; int c; @@ -624,11 +671,8 @@ static void dump_string_cst(ir_entity *ent) type_size = get_type_size_bytes(type); remaining_space = type_size - len; assert(remaining_space >= 0); - if(remaining_space > 0) { - be_emit_irprintf("\t.skip\t%d\n", remaining_space); - } - if(be_gas_flavour == GAS_FLAVOUR_MACH_O) { - be_gas_emit_switch_section(last_section); + if (remaining_space > 0) { + be_emit_irprintf("\t.space\t%d\n", remaining_space); } } @@ -637,14 +681,14 @@ static void dump_string_initializer(const ir_initializer_t *initializer) size_t i, len; len = initializer->compound.n_initializers; - if(be_gas_flavour == GAS_FLAVOUR_MACH_O) { + if (be_gas_flavour == GAS_FLAVOUR_MACH_O) { + be_emit_cstring("\t.ascii \""); + } else { be_emit_cstring("\t.string \""); len -= 1; - } else { - be_emit_cstring("\t.ascii \""); } - for(i = 0; i < len; ++i) { + for (i = 0; i < len; ++i) { const ir_initializer_t *sub_initializer = get_initializer_compound_value(initializer, i); @@ -694,7 +738,7 @@ static int is_type_variable_size(ir_type *type) static size_t get_initializer_size(const ir_initializer_t *initializer, ir_type *type) { - switch(get_initializer_kind(initializer)) { + switch (get_initializer_kind(initializer)) { case IR_INITIALIZER_TARVAL: { assert(get_tarval_mode(get_initializer_tarval_value(initializer)) == get_type_mode(type)); return get_type_size_bytes(type); @@ -703,14 +747,14 @@ static size_t get_initializer_size(const ir_initializer_t *initializer, case IR_INITIALIZER_NULL: return get_type_size_bytes(type); case IR_INITIALIZER_COMPOUND: { - if(!is_type_variable_size(type)) { + if (!is_type_variable_size(type)) { return get_type_size_bytes(type); } else { unsigned n_entries = get_initializer_compound_n_entries(initializer); unsigned i; unsigned initializer_size = get_type_size_bytes(type); - for(i = 0; i < n_entries; ++i) { + for (i = 0; i < n_entries; ++i) { ir_entity *entity = get_compound_member(type, i); ir_type *type = get_entity_type(entity); @@ -720,7 +764,7 @@ static size_t get_initializer_size(const ir_initializer_t *initializer, unsigned offset = get_entity_offset(entity); unsigned size = get_initializer_size(sub_initializer, type); - if(offset + size > initializer_size) { + if (offset + size > initializer_size) { initializer_size = offset + size; } } @@ -747,7 +791,7 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits, int value_len; int j; - switch(get_initializer_kind(initializer)) { + switch (get_initializer_kind(initializer)) { case IR_INITIALIZER_NULL: return; case IR_INITIALIZER_TARVAL: @@ -755,7 +799,7 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits, break; case IR_INITIALIZER_CONST: { ir_node *node = get_initializer_const_value(initializer); - if(!is_Const(node)) { + if (!is_Const(node)) { panic("bitfield initializer not a Const node"); } tv = get_Const_tarval(node); @@ -765,8 +809,9 @@ static void dump_bitfield(normal_or_bitfield *vals, size_t offset_bits, panic("bitfield initializer is compound"); } if (tv == NULL) { - panic("Couldn't get numeric value for bitfield initializer\n"); + panic("Couldn't get numeric value for bitfield initializer"); } + tv = tarval_convert_to(tv, get_type_mode(type)); /* normalize offset */ vals += offset_bits >> 3; @@ -793,7 +838,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals, { assert((size_t) (vals - glob_vals) < max_vals); - switch(get_initializer_kind(initializer)) { + switch (get_initializer_kind(initializer)) { case IR_INITIALIZER_NULL: return; case IR_INITIALIZER_TARVAL: { @@ -803,7 +848,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals, vals->kind = TARVAL; vals->v.tarval = get_initializer_tarval_value(initializer); assert(get_type_mode(type) == get_tarval_mode(vals->v.tarval)); - for(i = 1; i < get_type_size_bytes(type); ++i) { + for (i = 1; i < get_type_size_bytes(type); ++i) { vals[i].kind = NORMAL; vals[i].v.value = NULL; } @@ -815,7 +860,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals, assert(vals->kind != BITFIELD); vals->kind = NORMAL; vals->v.value = get_initializer_const_value(initializer); - for(i = 1; i < get_type_size_bytes(type); ++i) { + for (i = 1; i < get_type_size_bytes(type); ++i) { vals[i].kind = NORMAL; vals[i].v.value = NULL; } @@ -825,16 +870,16 @@ static void dump_ir_initializer(normal_or_bitfield *vals, size_t i = 0; size_t n = get_initializer_compound_n_entries(initializer); - if(is_Array_type(type)) { + if (is_Array_type(type)) { ir_type *element_type = get_array_element_type(type); size_t skip = get_type_size_bytes(element_type); size_t alignment = get_type_alignment_bytes(element_type); size_t misalign = skip % alignment; - if(misalign != 0) { + if (misalign != 0) { skip += alignment - misalign; } - for(i = 0; i < n; ++i) { + for (i = 0; i < n; ++i) { ir_initializer_t *sub_initializer = get_initializer_compound_value(initializer, i); @@ -846,7 +891,7 @@ static void dump_ir_initializer(normal_or_bitfield *vals, size_t n_members, i; assert(is_compound_type(type)); n_members = get_compound_n_members(type); - for(i = 0; i < n_members; ++i) { + for (i = 0; i < n_members; ++i) { ir_entity *member = get_compound_member(type, i); size_t offset = get_entity_offset(member); ir_type *subtype = get_entity_type(member); @@ -857,12 +902,12 @@ static void dump_ir_initializer(normal_or_bitfield *vals, sub_initializer = get_initializer_compound_value(initializer, i); - if(mode != NULL) { + if (mode != NULL) { size_t offset_bits = get_entity_offset_bits_remainder(member); size_t value_len = get_mode_size_bits(mode); - if(offset_bits != 0 || + if (offset_bits != 0 || (value_len != 8 && value_len != 16 && value_len != 32 && value_len != 64)) { dump_bitfield(&vals[offset], offset_bits, @@ -889,7 +934,7 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) size_t size; size_t k; - if(initializer_is_string_const(initializer)) { + if (initializer_is_string_const(initializer)) { dump_string_initializer(initializer); return; } @@ -904,7 +949,7 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) * In the worst case, every initializer allocates one byte. * Moreover, initializer might be big, do not allocate on stack. */ - vals = xcalloc(size, sizeof(vals[0])); + vals = XMALLOCNZ(normal_or_bitfield, size); #ifndef NDEBUG glob_vals = vals; @@ -915,21 +960,22 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) /* now write values sorted */ for (k = 0; k < size; ) { - int space = 0, skip = 0; + int space = 0; + int elem_size = 1; if (vals[k].kind == NORMAL) { - if(vals[k].v.value != NULL) { + if (vals[k].v.value != NULL) { dump_atomic_init(env, vals[k].v.value); - skip = get_mode_size_bytes(get_irn_mode(vals[k].v.value)) - 1; + elem_size = get_mode_size_bytes(get_irn_mode(vals[k].v.value)); } else { - space = 1; + elem_size = 0; } - } else if(vals[k].kind == TARVAL) { + } else if (vals[k].kind == TARVAL) { tarval *tv = vals[k].v.tarval; size_t size = get_mode_size_bytes(get_tarval_mode(tv)); assert(tv != NULL); - skip = size - 1; + elem_size = size; dump_size_type(size); dump_arith_tarval(tv, size); be_emit_char('\n'); @@ -940,17 +986,15 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) be_emit_write_line(); } - ++k; + k += elem_size; while (k < size && vals[k].kind == NORMAL && vals[k].v.value == NULL) { ++space; ++k; } - space -= skip; - assert(space >= 0); /* a gap */ if (space > 0) { - be_emit_irprintf("\t.skip\t%d\n", space); + be_emit_irprintf("\t.space\t%d\n", space); be_emit_write_line(); } } @@ -966,7 +1010,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent) int i, j, n; unsigned k, last_ofs; - if(ent->has_initializer) { + if (ent->has_initializer) { dump_initializer(env, ent); return; } @@ -994,7 +1038,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent) * In the worst case, every initializer allocates one byte. * Moreover, initializer might be big, do not allocate on stack. */ - vals = xcalloc(last_ofs, sizeof(vals[0])); + vals = XMALLOCNZ(normal_or_bitfield, last_ofs); /* collect the values and store them at the offsets */ for (i = 0; i < n; ++i) { @@ -1010,7 +1054,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent) tarval *tv = get_atomic_init_tv(value); unsigned char curr_bits, last_bits = 0; if (tv == NULL) { - panic("Couldn't get numeric value for bitfield initializer '%s'\n", + panic("Couldn't get numeric value for bitfield initializer '%s'", get_entity_ld_name(ent)); } /* normalize offset */ @@ -1042,7 +1086,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent) for (k = 0; k < last_ofs; ) { int space = 0, skip = 0; if (vals[k].kind == NORMAL) { - if(vals[k].v.value != NULL) { + if (vals[k].v.value != NULL) { dump_atomic_init(env, vals[k].v.value); skip = get_mode_size_bytes(get_irn_mode(vals[k].v.value)) - 1; } else { @@ -1063,7 +1107,7 @@ static void dump_compound_init(be_gas_decl_env_t *env, ir_entity *ent) /* a gap */ if (space > 0) { - be_emit_irprintf("\t.skip\t%d\n", space); + be_emit_irprintf("\t.space\t%d\n", space); be_emit_write_line(); } } @@ -1075,7 +1119,7 @@ static void emit_align(unsigned alignment) if (!is_po2(alignment)) panic("alignment not a power of 2"); - be_emit_irprintf(".p2align\t%u\n", log2_floor(alignment)); + be_emit_irprintf("\t.p2align\t%u\n", log2_floor(alignment)); be_emit_write_line(); } @@ -1084,49 +1128,40 @@ static void emit_align(unsigned alignment) * * @param env the gas output environment * @param ent the entity to be dumped - * @param emit_commons if non-zero, emit commons (non-local uninitialized entities) */ -static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons) +static void dump_global(be_gas_decl_env_t *env, ir_entity *ent) { ir_type *type = get_entity_type(ent); ident *ld_ident = get_entity_ld_ident(ent); unsigned align = get_type_alignment_bytes(type); int emit_as_common = 0; - be_gas_section_t section; - ir_variability variability; - ir_visibility visibility; - - if (is_Method_type(type)) { - if (be_gas_flavour != GAS_FLAVOUR_MACH_O - && get_method_img_section(ent) == section_constructors) { - be_gas_emit_switch_section(GAS_SECTION_CTOR); - emit_align(align); - dump_size_type(align); - be_emit_ident(ld_ident); - be_emit_char('\n'); - be_emit_write_line(); - } + be_gas_section_t section = env->section; + ir_variability variability = get_entity_variability(ent); + ir_visibility visibility = get_entity_visibility(ent); + if (is_Method_type(type) && section != GAS_SECTION_PIC_TRAMPOLINES) { return; } - variability = get_entity_variability(ent); - visibility = get_entity_visibility(ent); - section = GAS_SECTION_DATA; - if (env->dump_tls) { - section = GAS_SECTION_TLS; + if (section != (be_gas_section_t) -1) { emit_as_common = 0; } else if (variability == variability_constant) { /* a constant entity, put it on the rdata */ section = GAS_SECTION_RODATA; + if (be_gas_flavour == GAS_FLAVOUR_MACH_O + && ent_is_string_const(ent)) { + section = GAS_SECTION_CSTRING; + } } else if (variability == variability_uninitialized) { /* uninitialized entity put it in bss segment */ section = GAS_SECTION_COMMON; - if (emit_commons && visibility != visibility_local) + if (visibility != visibility_local) emit_as_common = 1; + } else { + section = GAS_SECTION_DATA; } - if(!emit_as_common) { + if (!emit_as_common) { be_gas_emit_switch_section(section); } @@ -1138,7 +1173,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons be_emit_ident(ld_ident); be_emit_char('\n'); be_emit_write_line(); - } else if(visibility == visibility_external_allocated) { + } else if (visibility == visibility_external_allocated) { be_emit_cstring(".globl\t"); be_emit_ident(ld_ident); be_emit_char('\n'); @@ -1147,10 +1182,20 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons return; } /* alignment */ - if (align > 1 && !emit_as_common) { + if (align > 1 && !emit_as_common && section != GAS_SECTION_PIC_TRAMPOLINES + && section != GAS_SECTION_PIC_SYMBOLS) { emit_align(align); } + if (visibility != visibility_external_allocated && !emit_as_common + && be_gas_flavour == GAS_FLAVOUR_ELF) { + be_emit_cstring("\t.type\t"); + be_emit_ident(ld_ident); + be_emit_cstring(", @object\n\t.size\t"); + be_emit_ident(ld_ident); + be_emit_irprintf(", %u\n", get_type_size_bytes(type)); + } + if (!emit_as_common) { be_emit_ident(ld_ident); be_emit_cstring(":\n"); @@ -1173,8 +1218,26 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons be_emit_write_line(); break; } + } else if (section == GAS_SECTION_PIC_TRAMPOLINES + || section == GAS_SECTION_PIC_SYMBOLS) { + if (be_gas_flavour == GAS_FLAVOUR_MACH_O) { + be_emit_cstring("\t.indirect_symbol "); + be_emit_ident(get_entity_ident(ent)); + be_emit_char('\n'); + be_emit_write_line(); + if (section == GAS_SECTION_PIC_TRAMPOLINES) { + be_emit_cstring("\thlt ; hlt ; hlt ; hlt ; hlt\n"); + be_emit_write_line(); + } else { + assert(section == GAS_SECTION_PIC_SYMBOLS); + be_emit_cstring("\t.long 0\n"); + be_emit_write_line(); + } + } else { + panic("PIC trampolines not yet supported in this gas mode"); + } } else { - be_emit_irprintf("\t.zero %u\n", get_type_size_bytes(type)); + be_emit_irprintf("\t.space %u\n", get_type_size_bytes(type)); be_emit_write_line(); } } else { @@ -1196,7 +1259,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons dump_compound_init(env, ent); break; default: - assert(0); + panic("Unimplemented type kind in dump_global()"); } } } @@ -1207,12 +1270,11 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent, int emit_commons * * @param gt a global like type, either the global or the TLS one * @param env an environment - * @param emit_commons if non-zero, emit commons (non-local uninitialized entities) * @param only_emit_marked if non-zero, external allocated entities that do not have * its visited flag set are ignored */ static void be_gas_dump_globals(ir_type *gt, be_gas_decl_env_t *env, - int emit_commons, int only_emit_marked) + int only_emit_marked) { int i, n = get_compound_n_members(gt); waitq *worklist = new_waitq(); @@ -1239,7 +1301,7 @@ static void be_gas_dump_globals(ir_type *gt, be_gas_decl_env_t *env, while (!waitq_empty(worklist)) { ir_entity *ent = waitq_get(worklist); - dump_global(env, ent, emit_commons); + dump_global(env, ent); } del_waitq(worklist); @@ -1255,13 +1317,29 @@ void be_gas_emit_decls(const be_main_env_t *main_env, be_gas_decl_env_t env; memset(&env, 0, sizeof(env)); - env.main_env = main_env; - /* dump global type */ - be_gas_dump_globals(get_glob_type(), &env, 1, only_emit_marked_entities); - - /* dump the Thread Local Storage */ - env.dump_tls = 1; - be_gas_dump_globals(get_tls_type(), &env, 0, only_emit_marked_entities); - env.dump_tls = 0; + env.section = (be_gas_section_t) -1; + be_gas_dump_globals(get_glob_type(), &env, only_emit_marked_entities); + env.section = GAS_SECTION_TLS; + be_gas_dump_globals(get_tls_type(), &env, only_emit_marked_entities); + env.section = GAS_SECTION_CONSTRUCTORS; + be_gas_dump_globals(get_segment_type(IR_SEGMENT_CONSTRUCTORS), &env, + only_emit_marked_entities); + env.section = GAS_SECTION_DESTRUCTORS; + be_gas_dump_globals(get_segment_type(IR_SEGMENT_DESTRUCTORS), &env, + only_emit_marked_entities); + + env.section = GAS_SECTION_PIC_SYMBOLS; + be_gas_dump_globals(main_env->pic_symbols_type, &env, + only_emit_marked_entities); + + if (get_compound_n_members(main_env->pic_trampolines_type) > 0) { + env.section = GAS_SECTION_PIC_TRAMPOLINES; + be_gas_dump_globals(main_env->pic_trampolines_type, &env, + only_emit_marked_entities); + if (be_gas_flavour == GAS_FLAVOUR_MACH_O) { + be_emit_cstring("\t.subsections_via_symbols\n"); + be_emit_write_line(); + } + } }