2005-08-22  Richard Henderson  <rth@redhat.com>

	* 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 <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)

+{