2005-08-22 Richard Henderson * function.c (ARG_POINTER_CFA_OFFSET): Move ... * defaults.h (ARG_POINTER_CFA_OFFSET): ... here. (INCOMING_FRAME_SP_OFFSET): Moved from ... * dwarf2out.c (INCOMING_FRAME_SP_OFFSET): ... here. (struct cfa_loc): Change reg to unsigned int, rearrange for better packing. (lookup_cfa_1): Remove inline marker. (cfa_equal_p): Split out of ... (def_cfa_1): ... here. Use INVALID_REGNUM. (build_cfa_loc): Handle !cfa->indirect. (frame_pointer_cfa_offset): New. (dbx_reg_number): Assert register elimination performed; do leaf register remapping. (reg_loc_descriptor): Avoid calling dbx_reg_number when unused. (eliminate_reg_to_offset): New. (based_loc_descr): Remove can_use_fbreg argument. Use fbreg only for verifiably local stack frame addresses; re-base to CFA. (mem_loc_descriptor): Remove can_use_fbreg argument. (concat_loc_descriptor, loc_descriptor): Likewise. (containing_function_has_frame_base): Remove. (rtl_for_decl_location): Don't do register elimination or leaf register remapping here. (secname_for_decl): Split out from .. (add_location_or_const_value_attribute): ... here. (convert_cfa_to_loc_list): New. (compute_frame_pointer_to_cfa_displacement): New. (gen_subprogram_die): Use them. * tree.h (frame_base_decl): Remove. * var-tracking.c (frame_base_decl, frame_stack_adjust): Remove. (prologue_stack_adjust): Remove. (vt_stack_adjustments): Use INCOMING_FRAME_SP_OFFSET. (adjust_stack_reference): Re-base memories to arg_pointer_rtx. (set_frame_base_location): Remove. (compute_bb_dataflow, emit_notes_in_bb): Don't call it. (dump_attrs_list, dump_dataflow_set): Use string concatenation. (vt_add_function_parameters): Don't eliminate_regs. (vt_initialize): Don't create frame_base_decl. --- gcc/defaults.h.orig 2005-11-17 23:01:55.000000000 -0200 +++ gcc/defaults.h 2005-11-17 23:07:55.000000000 -0200 @@ -715,4 +715,15 @@ #define EXIT_IGNORE_STACK 0 #endif +/* On most machines, the CFA coincides with the first incoming parm. */ +#ifndef ARG_POINTER_CFA_OFFSET +#define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL) +#endif + +/* The offset from the incoming value of %sp to the top of the stack frame + for the current function. */ +#ifndef INCOMING_FRAME_SP_OFFSET +#define INCOMING_FRAME_SP_OFFSET 0 +#endif + #endif /* ! GCC_DEFAULTS_H */ --- gcc/dwarf2out.c.orig 2005-11-17 23:07:20.000000000 -0200 +++ gcc/dwarf2out.c 2005-11-17 23:07:55.000000000 -0200 @@ -228,9 +228,9 @@ dw_cfi_node; of this structure. */ typedef struct cfa_loc GTY(()) { - unsigned long reg; HOST_WIDE_INT offset; HOST_WIDE_INT base_offset; + unsigned int reg; int indirect; /* 1 if CFA is accessed via a dereference. */ } dw_cfa_location; @@ -418,12 +418,6 @@ static void def_cfa_1 (const char *, dw_ #ifndef DWARF_FRAME_REGNUM #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) #endif - -/* The offset from the incoming value of %sp to the top of the stack frame - for the current function. */ -#ifndef INCOMING_FRAME_SP_OFFSET -#define INCOMING_FRAME_SP_OFFSET 0 -#endif /* Hook used by __throw. */ @@ -651,7 +645,7 @@ add_fde_cfi (const char *label, dw_cfi_r /* Subroutine of lookup_cfa. */ -static inline void +static void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) { switch (cfi->dw_cfi_opc) @@ -681,7 +675,7 @@ lookup_cfa (dw_cfa_location *loc) { dw_cfi_ref cfi; - loc->reg = (unsigned long) -1; + loc->reg = INVALID_REGNUM; loc->offset = 0; loc->indirect = 0; loc->base_offset = 0; @@ -725,6 +719,18 @@ dwarf2out_def_cfa (const char *label, un def_cfa_1 (label, &loc); } +/* Determine if two dw_cfa_location structures define the same data. */ + +static bool +cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2) +{ + return (loc1->reg == loc2->reg + && loc1->offset == loc2->offset + && loc1->indirect == loc2->indirect + && (loc1->indirect == 0 + || loc1->base_offset == loc2->base_offset)); +} + /* This routine does the actual work. The CFA is now calculated from the dw_cfa_location structure. */ @@ -744,9 +750,7 @@ def_cfa_1 (const char *label, dw_cfa_loc lookup_cfa (&old_cfa); /* If nothing changed, no need to issue any call frame instructions. */ - if (loc.reg == old_cfa.reg && loc.offset == old_cfa.offset - && loc.indirect == old_cfa.indirect - && (loc.indirect == 0 || loc.base_offset == old_cfa.base_offset)) + if (cfa_equal_p (&loc, &old_cfa)) return; cfi = new_cfi (); @@ -761,7 +765,8 @@ def_cfa_1 (const char *label, dw_cfa_loc } #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ - else if (loc.offset == old_cfa.offset && old_cfa.reg != (unsigned long) -1 + else if (loc.offset == old_cfa.offset + && old_cfa.reg != INVALID_REGNUM && !loc.indirect) { /* Construct a "DW_CFA_def_cfa_register " instruction, @@ -3098,28 +3103,40 @@ build_cfa_loc (dw_cfa_location *cfa) { struct dw_loc_descr_struct *head, *tmp; - if (cfa->indirect == 0) - abort (); - - if (cfa->base_offset) + if (cfa->indirect) { - if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); + if (cfa->base_offset) + { + if (cfa->reg <= 31) + head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); + else + head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); + } + else if (cfa->reg <= 31) + head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); else - head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); + head = new_loc_descr (DW_OP_regx, cfa->reg, 0); + + head->dw_loc_oprnd1.val_class = dw_val_class_const; + tmp = new_loc_descr (DW_OP_deref, 0, 0); + add_loc_descr (&head, tmp); + if (cfa->offset != 0) + { + tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0); + add_loc_descr (&head, tmp); + } } - else if (cfa->reg <= 31) - head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); else - head = new_loc_descr (DW_OP_regx, cfa->reg, 0); - - head->dw_loc_oprnd1.val_class = dw_val_class_const; - tmp = new_loc_descr (DW_OP_deref, 0, 0); - add_loc_descr (&head, tmp); - if (cfa->offset != 0) { - tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0); - add_loc_descr (&head, tmp); + if (cfa->offset == 0) + if (cfa->reg <= 31) + head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); + else + head = new_loc_descr (DW_OP_regx, cfa->reg, 0); + else if (cfa->reg <= 31) + head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->offset, 0); + else + head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->offset); } return head; @@ -3607,6 +3624,10 @@ static GTY(()) int label_num; #ifdef DWARF2_DEBUGGING_INFO +/* Offset from the "steady-state frame pointer" to the CFA, + within the current function. */ +static HOST_WIDE_INT frame_pointer_cfa_offset; + /* Forward declarations for functions defined in this file. */ static int is_pseudo_reg (rtx); @@ -3752,11 +3773,11 @@ static dw_loc_descr_ref reg_loc_descript static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); -static dw_loc_descr_ref based_loc_descr (unsigned, HOST_WIDE_INT, bool); +static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT); static int is_based_loc (rtx); -static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode, bool); -static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx, bool); -static dw_loc_descr_ref loc_descriptor (rtx, bool); +static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); +static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); +static dw_loc_descr_ref loc_descriptor (rtx); static dw_loc_descr_ref loc_descriptor_from_tree (tree, int); static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); static tree field_type (tree); @@ -8171,9 +8192,20 @@ dbx_reg_number (rtx rtl) { unsigned regno = REGNO (rtl); + if (! (HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM + || rtl != arg_pointer_rtx)) + abort (); + if (! (HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM + || rtl != frame_pointer_rtx)) + abort (); + if (regno >= FIRST_PSEUDO_REGISTER) abort (); +#ifdef LEAF_REG_REMAP + regno = LEAF_REG_REMAP (regno); +#endif + return DBX_REGISTER_NUMBER (regno); } @@ -8203,20 +8235,17 @@ add_loc_descr_op_piece (dw_loc_descr_ref static dw_loc_descr_ref reg_loc_descriptor (rtx rtl) { - unsigned reg; rtx regs; if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) return 0; - reg = dbx_reg_number (rtl); regs = (*targetm.dwarf_register_span) (rtl); - if (HARD_REGNO_NREGS (REGNO (rtl), GET_MODE (rtl)) > 1 - || regs) + if (HARD_REGNO_NREGS(REGNO (rtl), GET_MODE (rtl)) > 1 || regs) return multiple_reg_loc_descriptor (rtl, regs); else - return one_reg_loc_descriptor (reg); + return one_reg_loc_descriptor (dbx_reg_number (rtl)); } /* Return a location descriptor that designates a machine register for @@ -8321,25 +8350,54 @@ int_loc_descriptor (HOST_WIDE_INT i) return new_loc_descr (op, i, 0); } +/* Return an offset from an eliminable register to the post-prologue + frame pointer. */ + +static HOST_WIDE_INT +eliminate_reg_to_offset (rtx reg) +{ + HOST_WIDE_INT offset = 0; + + reg = eliminate_regs (reg, VOIDmode, NULL_RTX); + if (GET_CODE (reg) == PLUS) + { + offset = INTVAL (XEXP (reg, 1)); + reg = XEXP (reg, 0); + } + if (! (reg == (frame_pointer_needed ? hard_frame_pointer_rtx + : stack_pointer_rtx))) + abort (); + + return offset; +} + /* Return a location descriptor that designates a base+offset location. */ static dw_loc_descr_ref -based_loc_descr (unsigned int reg, HOST_WIDE_INT offset, bool can_use_fbreg) +based_loc_descr (rtx reg, HOST_WIDE_INT offset) { dw_loc_descr_ref loc_result; - /* For the "frame base", we use the frame pointer or stack pointer - registers, since the RTL for local variables is relative to one of - them. */ - unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed - ? HARD_FRAME_POINTER_REGNUM - : STACK_POINTER_REGNUM); - - if (reg == fp_reg && can_use_fbreg) - loc_result = new_loc_descr (DW_OP_fbreg, offset, 0); - else if (reg <= 31) - loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0); + + /* We only use "frame base" when we're sure we're talking about the + post-prologue local stack frame. We do this by *not* running + register elimination until this point, and recognizing the special + argument pointer and soft frame pointer rtx's. */ + if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) + { + offset += eliminate_reg_to_offset (reg); + offset += frame_pointer_cfa_offset; + + loc_result = new_loc_descr (DW_OP_fbreg, offset, 0); + } else - loc_result = new_loc_descr (DW_OP_bregx, reg, offset); + { + unsigned int regno = dbx_reg_number (reg); + + if (regno <= 31) + loc_result = new_loc_descr (DW_OP_breg0 + regno, offset, 0); + else + loc_result = new_loc_descr (DW_OP_bregx, regno, offset); + } return loc_result; } @@ -8368,15 +8426,13 @@ is_based_loc (rtx rtl) MODE is the mode of the memory reference, needed to handle some autoincrement addressing modes. - CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the location - list for RTL. We can't use it when we are emitting location list for - virtual variable frame_base_decl (i.e. a location list for DW_AT_frame_base) - which describes how frame base changes when !frame_pointer_needed. + CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the + location list for RTL. Return 0 if we can't represent the location. */ static dw_loc_descr_ref -mem_loc_descriptor (rtx rtl, enum machine_mode mode, bool can_use_fbreg) +mem_loc_descriptor (rtx rtl, enum machine_mode mode) { dw_loc_descr_ref mem_loc_result = NULL; @@ -8422,13 +8478,11 @@ mem_loc_descriptor (rtx rtl, enum machin memory) so DWARF consumers need to be aware of the subtle distinction between OP_REG and OP_BASEREG. */ if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) - mem_loc_result = based_loc_descr (dbx_reg_number (rtl), 0, - can_use_fbreg); + mem_loc_result = based_loc_descr (rtl, 0); break; case MEM: - mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl), - can_use_fbreg); + mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); if (mem_loc_result != 0) add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); break; @@ -8494,13 +8548,11 @@ mem_loc_descriptor (rtx rtl, enum machin case PLUS: plus: if (is_based_loc (rtl)) - mem_loc_result = based_loc_descr (dbx_reg_number (XEXP (rtl, 0)), - INTVAL (XEXP (rtl, 1)), - can_use_fbreg); + mem_loc_result = based_loc_descr (XEXP (rtl, 0), + INTVAL (XEXP (rtl, 1))); else { - mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, - can_use_fbreg); + mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); if (mem_loc_result == 0) break; @@ -8512,8 +8564,7 @@ mem_loc_descriptor (rtx rtl, enum machin else { add_loc_descr (&mem_loc_result, - mem_loc_descriptor (XEXP (rtl, 1), mode, - can_use_fbreg)); + mem_loc_descriptor (XEXP (rtl, 1), mode)); add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0)); } @@ -8524,10 +8575,8 @@ mem_loc_descriptor (rtx rtl, enum machin { /* If a pseudo-reg is optimized away, it is possible for it to be replaced with a MEM containing a multiply. */ - dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, - can_use_fbreg); - dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, - can_use_fbreg); + dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); + dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); if (op0 == 0 || op1 == 0) break; @@ -8546,8 +8595,7 @@ mem_loc_descriptor (rtx rtl, enum machin /* If this is a MEM, return its address. Otherwise, we can't represent this. */ if (GET_CODE (XEXP (rtl, 0)) == MEM) - return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode, - can_use_fbreg); + return mem_loc_descriptor (XEXP (XEXP (rtl, 0), 0), mode); else return 0; @@ -8562,11 +8610,11 @@ mem_loc_descriptor (rtx rtl, enum machin This is typically a complex variable. */ static dw_loc_descr_ref -concat_loc_descriptor (rtx x0, rtx x1, bool can_use_fbreg) +concat_loc_descriptor (rtx x0, rtx x1) { dw_loc_descr_ref cc_loc_result = NULL; - dw_loc_descr_ref x0_ref = loc_descriptor (x0, can_use_fbreg); - dw_loc_descr_ref x1_ref = loc_descriptor (x1, can_use_fbreg); + dw_loc_descr_ref x0_ref = loc_descriptor (x0); + dw_loc_descr_ref x1_ref = loc_descriptor (x1); if (x0_ref == 0 || x1_ref == 0) return 0; @@ -8580,29 +8628,6 @@ concat_loc_descriptor (rtx x0, rtx x1, b return cc_loc_result; } -/* Return true if DECL's containing function has a frame base attribute. - Return false otherwise. */ - -static bool -containing_function_has_frame_base (tree decl) -{ - tree declcontext = decl_function_context (decl); - dw_die_ref context; - dw_attr_ref attr; - - if (!declcontext) - return false; - - context = lookup_decl_die (declcontext); - if (!context) - return false; - - for (attr = context->die_attr; attr; attr = attr->dw_attr_next) - if (attr->dw_attr == DW_AT_frame_base) - return true; - return false; -} - /* Output a proper Dwarf location descriptor for a variable or parameter which is either allocated in a register or in a memory location. For a register, we just generate an OP_REG and the register number. For a @@ -8612,7 +8637,7 @@ containing_function_has_frame_base (tree If we don't know how to describe it, return 0. */ static dw_loc_descr_ref -loc_descriptor (rtx rtl, bool can_use_fbreg) +loc_descriptor (rtx rtl) { dw_loc_descr_ref loc_result = NULL; @@ -8633,20 +8658,18 @@ loc_descriptor (rtx rtl, bool can_use_fb break; case MEM: - loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl), - can_use_fbreg); + loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); break; case CONCAT: - loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1), - can_use_fbreg); + loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); break; case VAR_LOCATION: /* Single part. */ if (GET_CODE (XEXP (rtl, 1)) != PARALLEL) { - loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), can_use_fbreg); + loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0)); } /* Multiple parts. */ else @@ -8657,16 +8680,14 @@ loc_descriptor (rtx rtl, bool can_use_fb int i; /* Create the first one, so we have something to add to. */ - loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0), - can_use_fbreg); + loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); for (i = 1; i < num_elem; i++) { dw_loc_descr_ref temp; - temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0), - can_use_fbreg); + temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); add_loc_descr (&loc_result, temp); mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); @@ -8789,7 +8810,6 @@ loc_descriptor_from_tree (tree loc, int else { enum machine_mode mode = GET_MODE (rtl); - bool can_use_fb = containing_function_has_frame_base (loc); if (GET_CODE (rtl) == MEM) { @@ -8797,7 +8817,7 @@ loc_descriptor_from_tree (tree loc, int rtl = XEXP (rtl, 0); } - ret = mem_loc_descriptor (rtl, mode, can_use_fb); + ret = mem_loc_descriptor (rtl, mode); } } break; @@ -8872,18 +8892,16 @@ loc_descriptor_from_tree (tree loc, int /* Get an RTL for this, if something has been emitted. */ rtx rtl = lookup_constant_def (loc); enum machine_mode mode; - bool can_use_fb; if (GET_CODE (rtl) != MEM) return 0; - can_use_fb = containing_function_has_frame_base (loc); mode = GET_MODE (rtl); rtl = XEXP (rtl, 0); rtl = (*targetm.delegitimize_address) (rtl); indirect_p = 1; - ret = mem_loc_descriptor (rtl, mode, can_use_fb); + ret = mem_loc_descriptor (rtl, mode); break; } @@ -9743,19 +9761,10 @@ rtl_for_decl_location (tree decl) } } - if (rtl != NULL_RTX) - { - rtl = eliminate_regs (rtl, 0, NULL_RTX); -#ifdef LEAF_REG_REMAP - if (current_function_uses_only_leaf_regs) - leaf_renumber_regs_insn (rtl); -#endif - } - /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, and will have been substituted directly into all expressions that use it. C does not have such a concept, but C++ and other languages do. */ - else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) + if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) { /* If a variable is initialized with a string constant without embedded zeros, build CONST_STRING. */ @@ -9803,6 +9812,34 @@ rtl_for_decl_location (tree decl) return rtl; } +/* We need to figure out what section we should use as the base for the + address ranges where a given location is valid. + 1. If this particular DECL has a section associated with it, use that. + 2. If this function has a section associated with it, use that. + 3. Otherwise, use the text section. + XXX: If you split a variable across multiple sections, we won't notice. */ + +static const char * +secname_for_decl (tree decl) +{ + const char *secname; + + if (DECL_SECTION_NAME (decl)) + { + tree sectree = DECL_SECTION_NAME (decl); + secname = TREE_STRING_POINTER (sectree); + } + else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) + { + tree sectree = DECL_SECTION_NAME (current_function_decl); + secname = TREE_STRING_POINTER (sectree); + } + else + secname = text_section_label; + + return secname; +} + /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value data attribute for a variable or a parameter. We generate the DW_AT_const_value attribute only in those cases where the given variable @@ -9834,36 +9871,11 @@ add_location_or_const_value_attribute (d differ. */ if (loc_list && loc_list->first != loc_list->last) { - const char *secname; - const char *endname; + const char *secname, *endname; dw_loc_list_ref list; rtx varloc; struct var_loc_node *node; - /* We need to figure out what section we should use as the base - for the address ranges where a given location is valid. - 1. If this particular DECL has a section associated with it, - use that. - 2. If this function has a section associated with it, use - that. - 3. Otherwise, use the text section. - XXX: If you split a variable across multiple sections, this - won't notice. */ - - if (DECL_SECTION_NAME (decl)) - { - tree sectree = DECL_SECTION_NAME (decl); - secname = TREE_STRING_POINTER (sectree); - } - else if (current_function_decl - && DECL_SECTION_NAME (current_function_decl)) - { - tree sectree = DECL_SECTION_NAME (current_function_decl); - secname = TREE_STRING_POINTER (sectree); - } - else - secname = text_section_label; - /* Now that we know what section we are using for a base, actually construct the list of locations. The first location information is what is passed to the @@ -9877,7 +9889,9 @@ add_location_or_const_value_attribute (d node = loc_list->first; varloc = NOTE_VAR_LOCATION (node->var_loc_note); - list = new_loc_list (loc_descriptor (varloc, attr != DW_AT_frame_base), + secname = secname_for_decl (decl); + + list = new_loc_list (loc_descriptor (varloc), node->label, node->next->label, secname, 1); node = node->next; @@ -9888,8 +9902,7 @@ add_location_or_const_value_attribute (d NODE->NEXT->LABEL. */ varloc = NOTE_VAR_LOCATION (node->var_loc_note); add_loc_descr_to_loc_list (&list, - loc_descriptor (varloc, - attr != DW_AT_frame_base), + loc_descriptor (varloc), node->label, node->next->label, secname); } @@ -9909,8 +9922,7 @@ add_location_or_const_value_attribute (d endname = ggc_strdup (label_id); } add_loc_descr_to_loc_list (&list, - loc_descriptor (varloc, - attr != DW_AT_frame_base), + loc_descriptor (varloc), node->label, endname, secname); } @@ -9964,7 +9976,7 @@ add_location_or_const_value_attribute (d case REG: case SUBREG: case CONCAT: - descr = loc_descriptor (rtl, true); + descr = loc_descriptor (rtl); } add_AT_location_description (die, attr, descr); break; @@ -9977,14 +9989,14 @@ add_location_or_const_value_attribute (d int i; /* Create the first one, so we have something to add to. */ - descr = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0), true); + descr = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); add_loc_descr_op_piece (&descr, GET_MODE_SIZE (mode)); for (i = 1; i < num_elem; i++) { dw_loc_descr_ref temp; - temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0), true); + temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); add_loc_descr (&descr, temp); mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); add_loc_descr_op_piece (&descr, GET_MODE_SIZE (mode)); @@ -10030,6 +10042,98 @@ tree_add_const_value_attribute (dw_die_r } } +/* Convert the CFI instructions for the current function into a location + list. This is used for DW_AT_frame_base when we targeting a dwarf2 + consumer that does not support the dwarf3 DW_OP_call_frame_cfa. */ + +static dw_loc_list_ref +convert_cfa_to_loc_list (void) +{ + dw_fde_ref fde; + dw_loc_list_ref list, *list_tail; + dw_cfi_ref cfi; + dw_cfa_location last_cfa, next_cfa; + const char *start_label, *last_label, *section; + + fde = &fde_table[fde_table_in_use - 1]; + + section = secname_for_decl (current_function_decl); + list_tail = &list; + list = NULL; + + next_cfa.reg = INVALID_REGNUM; + next_cfa.offset = 0; + next_cfa.indirect = 0; + next_cfa.base_offset = 0; + + start_label = fde->dw_fde_begin; + + /* ??? Bald assumption that the CIE opcode list does not contain + advance opcodes. */ + for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) + lookup_cfa_1 (cfi, &next_cfa); + + last_cfa = next_cfa; + last_label = start_label; + + for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) + switch (cfi->dw_cfi_opc) + { + case DW_CFA_advance_loc1: + case DW_CFA_advance_loc2: + case DW_CFA_advance_loc4: + if (!cfa_equal_p (&last_cfa, &next_cfa)) + { + *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label, + last_label, section, list == NULL); + + list_tail = &(*list_tail)->dw_loc_next; + last_cfa = next_cfa; + start_label = last_label; + } + last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; + break; + + case DW_CFA_advance_loc: + /* The encoding is complex enough that we should never emit this. */ + case DW_CFA_remember_state: + case DW_CFA_restore_state: + /* We don't handle these two in this function. It would be possible + if it were to be required. */ + abort (); + + default: + lookup_cfa_1 (cfi, &next_cfa); + break; + } + + if (!cfa_equal_p (&last_cfa, &next_cfa)) + { + *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label, + last_label, section, list == NULL); + list_tail = &(*list_tail)->dw_loc_next; + start_label = last_label; + } + *list_tail = new_loc_list (build_cfa_loc (&next_cfa), start_label, + fde->dw_fde_end, section, list == NULL); + + return list; +} + +/* Compute a displacement from the "steady-state frame pointer" to + the CFA, and store it in frame_pointer_cfa_offset. */ + +static void +compute_frame_pointer_to_cfa_displacement (void) +{ + HOST_WIDE_INT offset; + + offset = eliminate_reg_to_offset (arg_pointer_rtx); + offset += ARG_POINTER_CFA_OFFSET (current_function_decl); + + frame_pointer_cfa_offset = -offset; +} + /* Generate a DW_AT_name attribute given some string value to be included as the value of the attribute. */ @@ -10128,7 +10232,7 @@ add_bound_info (dw_die_ref subrange_die, add_AT_flag (decl_die, DW_AT_artificial, 1); add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); add_AT_location_description (decl_die, DW_AT_location, - loc_descriptor (loc, true)); + loc_descriptor (loc)); add_AT_die_ref (subrange_die, bound_attr, decl_die); } @@ -11114,7 +11218,6 @@ gen_subprogram_die (tree decl, dw_die_re char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; tree origin = decl_ultimate_origin (decl); dw_die_ref subr_die; - rtx fp_reg; tree fn_arg_types; tree outer_scope; dw_die_ref old_die = lookup_decl_die (decl); @@ -11277,20 +11380,32 @@ gen_subprogram_die (tree decl, dw_die_re add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); #endif - /* Define the "frame base" location for this routine. We use the - frame pointer or stack pointer registers, since the RTL for local - variables is relative to one of them. */ - if (frame_base_decl && lookup_decl_loc (frame_base_decl) != NULL) - { - add_location_or_const_value_attribute (subr_die, frame_base_decl, - DW_AT_frame_base); - } - else - { - fp_reg - = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx; - add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg)); - } + /* We define the "frame base" as the function's CFA. This is more + convenient for several reasons: (1) It's stable across the prologue + and epilogue, which makes it better than just a frame pointer, + (2) With dwarf3, there exists a one-byte encoding that allows us + to reference the .debug_frame data by proxy, but failing that, + (3) We can at least reuse the code inspection and interpretation + code that determines the CFA position at various points in the + function. */ + /* ??? Use some command-line or configury switch to enable the use + of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf + consumers that understand it; fall back to "pure" dwarf2 and + convert the CFA data into a location list. */ + { + dw_loc_list_ref list = convert_cfa_to_loc_list (); + if (list->dw_loc_next) + add_AT_loc_list (subr_die, DW_AT_frame_base, list); + else + add_AT_loc (subr_die, DW_AT_frame_base, list->expr); + } + + /* Compute a displacement from the "steady-state frame pointer" to + the CFA. The former is what all stack slots and argument slots + will reference in the rtl; the later is what we've told the + debugger about. We'll need to adjust all frame_base references + by this displacement. */ + compute_frame_pointer_to_cfa_displacement (); #if 0 /* ??? This fails for nested inline functions, because context_display --- gcc/function.c.orig 2005-11-17 23:01:55.000000000 -0200 +++ gcc/function.c 2005-11-17 23:07:55.000000000 -0200 @@ -2824,12 +2824,6 @@ #endif #endif -/* On most machines, the CFA coincides with the first incoming parm. */ - -#ifndef ARG_POINTER_CFA_OFFSET -#define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL) -#endif - /* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had its address taken. DECL is the decl or SAVE_EXPR for the object stored in the register, for later use if we do need to force --- gcc/tree.h.orig 2005-11-17 23:06:26.000000000 -0200 +++ gcc/tree.h 2005-11-17 23:07:55.000000000 -0200 @@ -2065,7 +2065,6 @@ #define NULL_TREE (tree) NULL -extern GTY(()) tree frame_base_decl; extern tree decl_assembler_name (tree); /* Compute the number of bytes occupied by 'node'. This routine only --- gcc/var-tracking.c.orig 2005-11-17 23:01:55.000000000 -0200 +++ gcc/var-tracking.c 2005-11-17 23:07:55.000000000 -0200 @@ -266,19 +266,12 @@ /* Shall notes be emitted? */ static bool emit_notes; -/* Fake variable for stack pointer. */ -tree frame_base_decl; - -/* Stack adjust caused by function prologue. */ -static HOST_WIDE_INT frame_stack_adjust; - /* Local function prototypes. */ static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *, HOST_WIDE_INT *); static void insn_stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *, HOST_WIDE_INT *); static void bb_stack_adjust_offset (basic_block); -static HOST_WIDE_INT prologue_stack_adjust (void); static bool vt_stack_adjustments (void); static rtx adjust_stack_reference (rtx, HOST_WIDE_INT); static hashval_t variable_htab_hash (const void *); @@ -333,7 +326,6 @@ static void dump_dataflow_sets (void); static void variable_was_changed (variable, htab_t); -static void set_frame_base_location (dataflow_set *, rtx); static void set_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT); static void delete_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT); static int emit_note_insn_var_location (void **, void *); @@ -489,38 +481,6 @@ VTI (bb)->out.stack_adjust = offset; } -/* Compute stack adjustment caused by function prologue. */ - -static HOST_WIDE_INT -prologue_stack_adjust (void) -{ - HOST_WIDE_INT offset = 0; - basic_block bb = ENTRY_BLOCK_PTR->next_bb; - rtx insn; - rtx end; - - if (!BB_END (bb)) - return 0; - - end = NEXT_INSN (BB_END (bb)); - for (insn = BB_HEAD (bb); insn != end; insn = NEXT_INSN (insn)) - { - if (GET_CODE (insn) == NOTE - && NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) - break; - - if (INSN_P (insn)) - { - HOST_WIDE_INT tmp; - - insn_stack_adjust_offset_pre_post (insn, &tmp, &tmp); - offset += tmp; - } - } - - return offset; -} - /* Compute stack adjustments for all blocks by traversing DFS tree. Return true when the adjustments on all incoming edges are consistent. Heavily borrowed from flow_depth_first_order_compute. */ @@ -533,7 +493,7 @@ /* Initialize entry block. */ VTI (ENTRY_BLOCK_PTR)->visited = true; - VTI (ENTRY_BLOCK_PTR)->out.stack_adjust = frame_stack_adjust; + VTI (ENTRY_BLOCK_PTR)->out.stack_adjust = INCOMING_FRAME_SP_OFFSET; /* Allocate stack for back-tracking up CFG. */ stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge)); @@ -587,27 +547,23 @@ return true; } -/* Adjust stack reference MEM by ADJUSTMENT bytes and return the new rtx. */ +/* Adjust stack reference MEM by ADJUSTMENT bytes and make it relative + to the argument pointer. Return the new rtx. */ static rtx adjust_stack_reference (rtx mem, HOST_WIDE_INT adjustment) { - rtx adjusted_mem; - rtx tmp; + rtx addr, cfa, tmp; - if (adjustment == 0) - return mem; + adjustment -= ARG_POINTER_CFA_OFFSET (current_function_decl); + cfa = plus_constant (arg_pointer_rtx, adjustment); - adjusted_mem = copy_rtx (mem); - XEXP (adjusted_mem, 0) = replace_rtx (XEXP (adjusted_mem, 0), - stack_pointer_rtx, - gen_rtx_PLUS (Pmode, stack_pointer_rtx, - GEN_INT (adjustment))); - tmp = simplify_rtx (XEXP (adjusted_mem, 0)); + addr = replace_rtx (copy_rtx (XEXP (mem, 0)), stack_pointer_rtx, cfa); + tmp = simplify_rtx (addr); if (tmp) - XEXP (adjusted_mem, 0) = tmp; + addr = tmp; - return adjusted_mem; + return replace_equiv_address_nv (mem, addr); } /* The hash function for variable_htab, computes the hash value @@ -1657,14 +1613,7 @@ break; case MO_ADJUST: - { - rtx base; - - out->stack_adjust += VTI (bb)->mos[i].u.adjust; - base = gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, - out->stack_adjust)); - set_frame_base_location (out, base); - } + out->stack_adjust += VTI (bb)->mos[i].u.adjust; break; } } @@ -1786,8 +1735,7 @@ for (; list; list = list->next) { print_mem_expr (rtl_dump_file, list->decl); - fprintf (rtl_dump_file, "+"); - fprintf (rtl_dump_file, HOST_WIDE_INT_PRINT_DEC, list->offset); + fprintf (rtl_dump_file, "+" HOST_WIDE_INT_PRINT_DEC, list->offset); } fprintf (rtl_dump_file, "\n"); } @@ -1837,9 +1785,8 @@ { int i; - fprintf (rtl_dump_file, "Stack adjustment: "); - fprintf (rtl_dump_file, HOST_WIDE_INT_PRINT_DEC, set->stack_adjust); - fprintf (rtl_dump_file, "\n"); + fprintf (rtl_dump_file, "Stack adjustment: " HOST_WIDE_INT_PRINT_DEC "\n", + set->stack_adjust); for (i = 1; i < FIRST_PSEUDO_REGISTER; i++) { if (set->regs[i]) @@ -1921,37 +1868,6 @@ } } -/* Set the location of frame_base_decl to LOC in dataflow set SET. This - function expects that frame_base_decl has already one location for offset 0 - in the variable table. */ - -static void -set_frame_base_location (dataflow_set *set, rtx loc) -{ - variable var; - - var = htab_find_with_hash (set->vars, frame_base_decl, - VARIABLE_HASH_VAL (frame_base_decl)); -#ifdef ENABLE_CHECKING - if (!var) - abort (); - if (var->n_var_parts != 1) - abort (); - if (var->var_part[0].offset != 0) - abort (); - if (!var->var_part[0].loc_chain) - abort (); -#endif - - /* If frame_base_decl is shared unshare it first. */ - if (var->refcount > 1) - var = unshare_variable (set, var); - - var->var_part[0].loc_chain->loc = loc; - var->var_part[0].cur_loc = loc; - variable_was_changed (var, set->vars); -} - /* Set the part of variable's location in the dataflow set SET. The variable part is specified by variable's declaration DECL and offset OFFSET and the part's location by LOC. */ @@ -2482,15 +2398,7 @@ break; case MO_ADJUST: - { - rtx base; - - set.stack_adjust += VTI (bb)->mos[i].u.adjust; - base = gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, - set.stack_adjust)); - set_frame_base_location (&set, base); - emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN); - } + set.stack_adjust += VTI (bb)->mos[i].u.adjust; break; } } @@ -2600,7 +2508,6 @@ abort (); #endif - incoming = eliminate_regs (incoming, 0, NULL_RTX); out = &VTI (ENTRY_BLOCK_PTR)->out; if (GET_CODE (incoming) == REG) @@ -2614,9 +2521,7 @@ set_variable_part (out, incoming, parm, offset); } else if (GET_CODE (incoming) == MEM) - { - set_variable_part (out, incoming, parm, offset); - } + set_variable_part (out, incoming, parm, offset); } } @@ -2761,28 +2666,6 @@ changed_variables = htab_create (10, variable_htab_hash, variable_htab_eq, NULL); vt_add_function_parameters (); - - if (!frame_pointer_needed) - { - rtx base; - - /* Create fake variable for tracking stack pointer changes. */ - frame_base_decl = make_node (VAR_DECL); - DECL_NAME (frame_base_decl) = get_identifier ("___frame_base_decl"); - TREE_TYPE (frame_base_decl) = char_type_node; - DECL_ARTIFICIAL (frame_base_decl) = 1; - DECL_IGNORED_P (frame_base_decl) = 1; - - /* Set its initial "location". */ - frame_stack_adjust = -prologue_stack_adjust (); - base = gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, - frame_stack_adjust)); - set_variable_part (&VTI (ENTRY_BLOCK_PTR)->out, base, frame_base_decl, 0); - } - else - { - frame_base_decl = NULL; - } } /* Free the data structures needed for variable tracking. */