X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbestabs.c;h=55a5ef8dc365c39a2d76836b80e6db7291485a30;hb=3bb47464dc990c9def630a208a12da1bdd035bbb;hp=a5918840f6482500ddf6739b19a462ef28017f18;hpb=ea75e9d38674b468f602a0699fb64b9c01254797;p=libfirm diff --git a/ir/be/bestabs.c b/ir/be/bestabs.c index a5918840f..55a5ef8dc 100644 --- a/ir/be/bestabs.c +++ b/ir/be/bestabs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -143,7 +143,7 @@ static unsigned get_type_number(stabs_handle *h, ir_type *tp) num = h->next_type_nr++; pmap_insert(h->type_map, tp, INT_TO_PTR(num)); } else { - num = PTR_TO_INT(entry->value); + num = (unsigned)PTR_TO_INT(entry->value); } return num; } /* get_type_number */ @@ -173,10 +173,10 @@ typedef struct walker_env { /* a type is not ready: put it on the wait queue */ #define SET_TYPE_NOT_READY(wq, tp) \ - do { \ - set_type_link(tp, (void *)1); \ - waitq_put(wq, tp); \ - } while (0) + do { \ + set_type_link(tp, (void *)1); \ + waitq_put(wq, tp); \ + } while (0) /* a the is ready */ #define SET_TYPE_READY(tp) set_type_link(tp, NULL) @@ -202,7 +202,7 @@ static const tarval_mode_info dec_output = { /** * emit a tarval as decimal */ -static void be_emit_tv_as_decimal(tarval *tv) +static void be_emit_tv_as_decimal(ir_tarval *tv) { ir_mode *mode = get_tarval_mode(tv); const tarval_mode_info *old = get_tarval_mode_output_option(mode); @@ -214,8 +214,14 @@ static void be_emit_tv_as_decimal(tarval *tv) static void emit_type_name(const ir_type *type) { + char *c; char buf[256]; ir_print_type(buf, sizeof(buf), type); + /* replace special chars to be on the safe side */ + for (c = buf; *c != '\0'; ++c) { + if (*c == '\n' || *c == '"' || *c == '\\') + *c = '?'; + } be_emit_string(buf); } @@ -238,10 +244,12 @@ static void gen_primitive_type(stabs_handle *h, ir_type *tp) return; } /* if */ - if (0 && get_mode_size_bits(mode) & 7) { +#if 0 + if (get_mode_size_bits(mode) & 7) { /* this is a bitfield type, ignore it */ return; } /* if */ +#endif type_num = get_type_number(h, tp); @@ -330,18 +338,18 @@ static void gen_pointer_type(wenv_t *env, ir_type *tp) static void print_array_type(stabs_handle *h, ir_type *tp, int local) { ir_type *etp = get_array_element_type(tp); - int i, n = get_array_n_dimensions(tp); + size_t i, n = get_array_n_dimensions(tp); unsigned type_num = local ? h->next_type_nr++ : get_type_number(h, tp); - int *perm; + size_t *perm; be_emit_irprintf("%u=a", type_num); - NEW_ARR_A(int, perm, n); + perm = ALLOCAN(size_t, n); for (i = 0; i < n; ++i) { perm[i] = get_array_order(tp, i); } for (i = 0; i < n; ++i) { - int dim = perm[i]; + size_t dim = perm[i]; if (is_Const(get_array_lower_bound(tp, dim)) && is_Const(get_array_upper_bound(tp, dim))) { long min = get_array_lower_bound_int(tp, dim); @@ -420,19 +428,20 @@ static void gen_struct_union_type(wenv_t *env, ir_type *tp) ofs = get_entity_offset(ent); if (is_Struct_type(mtp) && get_type_mode(mtp) != NULL) { /* this structure is a bitfield, skip */ - int i, n; + int m; + int n_members = get_struct_n_members(mtp); - for (i = 0, n = get_struct_n_members(mtp); i < n; ++i) { - ir_entity *ent = get_struct_member(mtp, i); - ir_type *tp = get_entity_type(ent); + for (m = 0; m < n_members; ++m) { + ir_entity *member = get_struct_member(mtp, m); + ir_type *member_tp = get_entity_type(member); int bofs; - type_num = get_type_number(h, tp); - size = get_type_size_bytes(tp) * 8; - bofs = (ofs + get_entity_offset(ent)) * 8 + get_entity_offset_bits_remainder(ent); + type_num = get_type_number(h, member_tp); + size = get_type_size_bytes(member_tp) * 8; + bofs = (ofs + get_entity_offset(member)) * 8 + get_entity_offset_bits_remainder(member); /* name:type, bit offset from the start of the struct', number of bits in the element. */ - be_emit_irprintf("%s:%u,%d,%u;", get_entity_name(ent), type_num, bofs, size); + be_emit_irprintf("%s:%u,%d,%u;", get_entity_name(member), type_num, bofs, size); } } else { /* no bitfield */ @@ -502,7 +511,7 @@ static void gen_method_type(wenv_t *env, ir_type *tp) */ static void walk_type(type_or_ent tore, void *ctx) { - wenv_t *env = ctx; + wenv_t *env = (wenv_t*)ctx; ir_type *tp; if (is_type(tore.typ)) { @@ -562,10 +571,9 @@ static void walk_type(type_or_ent tore, void *ctx) static void finish_types(wenv_t *env) { waitq *wq = env->wq; - ir_type *tp; while (! waitq_empty(wq)) { - tp = waitq_get(wq); + ir_type *tp = (ir_type*)waitq_get(wq); if (IS_TYPE_READY(tp)) continue; @@ -609,9 +617,14 @@ static void gen_types(stabs_handle *h) env.h = h; env.wq = new_waitq(); + + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_LINK); type_walk(NULL, walk_type, &env); + irp_free_resources(irp, IRP_RESOURCE_TYPE_LINK); + finish_types(&env); del_waitq(env.wq); + } /* gen_types */ @@ -620,27 +633,30 @@ static void gen_types(stabs_handle *h) /** * start a new source object (compilation unit) */ -static void stabs_so(dbg_handle *handle, const char *filename) +static void stabs_unit_begin(dbg_handle *handle, const char *filename) { stabs_handle *h = (stabs_handle *)handle; + + /* needed for the debug support */ + be_gas_emit_switch_section(GAS_SECTION_TEXT); + be_emit_irprintf("%stext0:\n", be_gas_get_private_prefix()); + be_emit_write_line(); + h->main_file = h->curr_file = filename; be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,%stext0\n", filename, N_SO, be_gas_get_private_prefix()); be_emit_write_line(); -} /* stabs_so */ +} -/** - * Main Program - */ -static void stabs_main_program(dbg_handle *handle) +static void stabs_unit_end(dbg_handle *handle) { ir_graph *irg = get_irp_main_irg(); - (void) handle; if (irg) { - be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,0\n", get_entity_name(get_irg_entity(irg)), N_MAIN); - be_emit_write_line(); + ir_entity *entity = get_irg_entity(irg); + be_emit_irprintf("\t.stabs\t\"%s\",%d,0,0,0\n", + get_entity_ld_name(entity), N_MAIN); } -} /* stabs_main_program */ +} static void stabs_set_dbg_info(dbg_handle *h, dbg_info *dbgi) { @@ -677,20 +693,22 @@ static void stabs_set_dbg_info(dbg_handle *h, dbg_info *dbgi) /** * dump the stabs for a method begin */ -static void stabs_method_begin(dbg_handle *handle, const ir_entity *ent, const be_stack_layout_t *layout) +static void stabs_method_begin(dbg_handle *handle, const ir_entity *ent) { stabs_handle *h = (stabs_handle *)handle; + ir_graph *irg = get_entity_irg(ent); ir_type *mtp, *rtp; unsigned type_num; int i, n, between_size; + be_stack_layout_t *layout = be_get_irg_stack_layout(irg); h->cur_ent = ent; h->layout = layout; /* create the method entry */ mtp = get_entity_type(ent); - if (is_lowered_type(mtp)) - mtp = get_associated_type(mtp); + while (is_lowered_type(mtp)) + mtp = get_higher_type(mtp); if (get_method_n_ress(mtp) > 0) rtp = get_method_res_type(mtp, 0); else @@ -707,19 +725,18 @@ static void stabs_method_begin(dbg_handle *handle, const ir_entity *ent, const b /* create parameter entries */ between_size = get_type_size_bytes(layout->between_type); for (i = 0, n = get_method_n_params(mtp); i < n; ++i) { - ir_type *ptp = get_method_param_type(mtp, i); - const char *name = get_method_param_name(mtp, i); - unsigned type_num = get_type_number(h, ptp); - char buf[16]; - int ofs = 0; - ir_entity *stack_ent; - - if (! name) { - snprintf(buf, sizeof(buf), "arg%d", i); - name = buf; - } + ir_type *ptp = get_method_param_type(mtp, i); + const char *name = NULL; + char buf[16]; + int ofs = 0; + ir_entity *stack_ent; + + if (! name) { + snprintf(buf, sizeof(buf), "arg%d", i); + name = buf; + } /* check if this parameter has a stack entity. If it has, it - it transmitted on the stack, else in a register */ + * it transmitted on the stack, else in a register */ stack_ent = layout->param_map[i]; if (stack_ent) { ofs = get_entity_offset(stack_ent) + between_size; @@ -758,24 +775,24 @@ static void stabs_method_end(dbg_handle *handle) /* create entries for automatic variables on the stack */ frame_size = get_type_size_bytes(layout->frame_type); for (i = 0, n = get_compound_n_members(layout->frame_type); i < n; ++i) { - ir_entity *ent = get_compound_member(layout->frame_type, i); + ir_entity *member = get_compound_member(layout->frame_type, i); ir_type *tp; int ofs; unsigned type_num; /* ignore spill slots and other helper objects */ - if (is_entity_compiler_generated(ent)) + if (is_entity_compiler_generated(member)) continue; - tp = get_entity_type(ent); + tp = get_entity_type(member); /* should not happen in backend but ... */ if (is_Method_type(tp)) continue; type_num = get_type_number(h, tp); - ofs = -frame_size + get_entity_offset(ent); + ofs = -frame_size + get_entity_offset(member); be_emit_irprintf("\t.stabs\t\"%s:%u\",%d,0,0,%d\n", - get_entity_name(ent), type_num, N_LSYM, ofs); + get_entity_name(member), type_num, N_LSYM, ofs); be_emit_write_line(); } /* we need a lexical block here */ @@ -821,11 +838,11 @@ static void stabs_variable(dbg_handle *handle, const ir_entity *ent) if (linkage & IR_LINKAGE_CONSTANT) kind = N_ROSYM; snprintf(buf, sizeof(buf), "\t.stabs\t\"%s:S%u\",%d,0,0,%s\n", - get_entity_name(ent), tp_num, kind, get_entity_ld_name(ent)); + get_entity_name(ent), tp_num, kind, get_entity_ld_name(ent)); } else { /* a global variable */ snprintf(buf, sizeof(buf), "\t.stabs\t\"%s:G%u\",%d,0,0,0\n", - get_entity_name(ent), tp_num, N_GSYM); + get_entity_name(ent), tp_num, (int)N_GSYM); } buf[sizeof(buf) - 1] = '\0'; @@ -845,8 +862,8 @@ static void stabs_close(dbg_handle *handle) /** The stabs operations. */ static const debug_ops stabs_ops = { stabs_close, - stabs_so, - stabs_main_program, + stabs_unit_begin, + stabs_unit_end, stabs_method_begin, stabs_method_end, stabs_types, @@ -865,7 +882,7 @@ static dbg_handle *be_stabs_open(void) return &h->base; } -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_stabs); +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_stabs) void be_init_stabs(void) { be_register_dbgout_module("stabs", be_stabs_open);