X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbegnuas.c;h=a2d36cb88a0a6b6d2ff935648ebfff6bfc610a2a;hb=4afdd22d55e88960e79760b6193253534ce298f1;hp=531e8684917550817f5894072af84e1492a4a90b;hpb=812b05b22c1c41e0f57c65b80feadecc439d8f32;p=libfirm diff --git a/ir/be/begnuas.c b/ir/be/begnuas.c index 531e86849..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" @@ -118,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'); @@ -213,7 +211,6 @@ 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. */ be_gas_section_t section; waitq *worklist; /**< A worklist we use to place not yet handled entities on. */ } be_gas_decl_env_t; @@ -249,31 +246,37 @@ static void dump_arith_tarval(tarval *tv, int bytes) return; case 12: - be_emit_irprintf("0x%02x%02x%02x%02x%02x%02x%02x%02x" - "%02x%02x%02x%02x", 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)); + /* 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)); + 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\n", bytes); + panic("Can't dump a tarval with %d bytes", bytes); } /** @@ -389,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); } @@ -399,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); } @@ -430,35 +433,35 @@ static void do_dump_atomic_init(be_gas_decl_env_t *env, ir_node *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: - 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: - 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; + 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; - default: - assert(0 && "dump_atomic_init(): unknown IR-node"); + 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: + 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: + panic("dump_atomic_init(): unsupported IR-node %+F", init); } } @@ -495,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); } } @@ -525,33 +528,32 @@ 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 (isgraph(c) || isspace(c)) found_printable = 1; - else if(c != 0) + else if (c != 0) return 0; if (i == len - 1 && c != '\0') @@ -588,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 { @@ -607,7 +608,7 @@ static int ent_is_string_const(ir_entity *ent) if (isgraph(c) || isspace(c)) found_printable = 1; - else if(c != 0) + else if (c != 0) return 0; if (i == n - 1 && c != '\0') @@ -628,19 +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; - 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) { 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; @@ -668,8 +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 (remaining_space > 0) { + be_emit_irprintf("\t.space\t%d\n", remaining_space); } } @@ -678,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; } - for(i = 0; i < len; ++i) { + for (i = 0; i < len; ++i) { const ir_initializer_t *sub_initializer = get_initializer_compound_value(initializer, i); @@ -735,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); @@ -744,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); @@ -761,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; } } @@ -788,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: @@ -796,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); @@ -806,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; @@ -834,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: { @@ -844,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; } @@ -856,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; } @@ -866,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); @@ -887,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); @@ -898,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, @@ -930,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; } @@ -945,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; @@ -959,13 +963,13 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) 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); elem_size = get_mode_size_bytes(get_irn_mode(vals[k].v.value)); } else { 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)); @@ -990,7 +994,7 @@ static void dump_initializer(be_gas_decl_env_t *env, ir_entity *entity) /* 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(); } } @@ -1006,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; } @@ -1034,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) { @@ -1050,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 */ @@ -1082,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 { @@ -1103,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(); } } @@ -1157,7 +1161,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent) section = GAS_SECTION_DATA; } - if(!emit_as_common) { + if (!emit_as_common) { be_gas_emit_switch_section(section); } @@ -1169,7 +1173,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent) 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'); @@ -1214,14 +1218,21 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent) be_emit_write_line(); break; } - } else if (section == GAS_SECTION_PIC_TRAMPOLINES) { + } 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(); - be_emit_cstring("\thlt ; hlt ; hlt ; hlt ; hlt\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"); } @@ -1248,7 +1259,7 @@ static void dump_global(be_gas_decl_env_t *env, ir_entity *ent) dump_compound_init(env, ent); break; default: - assert(0); + panic("Unimplemented type kind in dump_global()"); } } } @@ -1306,8 +1317,6 @@ 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 */ env.section = (be_gas_section_t) -1; be_gas_dump_globals(get_glob_type(), &env, only_emit_marked_entities);