dwarf2cfi.c (DW_STACK_POINTER_REGNUM): New.

        * dwarf2cfi.c (DW_STACK_POINTER_REGNUM): New.
        (DW_FRAME_POINTER_REGNUM): New.
        (expand_builtin_init_dwarf_reg_sizes): Use unsigned for rnum.
        (def_cfa_1): Do not convert reg to DWARF_FRAME_REGNUM here.
        (dwf_regno): New.
        (dwarf2out_flush_queued_reg_saves, dwarf2out_frame_debug_def_cfa,
        dwarf2out_frame_debug_adjust_cfa, dwarf2out_frame_debug_cfa_register,
        dwarf2out_frame_debug_cfa_expression, dwarf2out_frame_debug_expr):
        Use it.
        * dwarf2out.c (based_loc_descr): Use dwarf_frame_regnum.
        * dwarf2out.h (dwarf_frame_regnum): New.
        (struct cfa_loc): Document the domain of the reg member.

From-SVN: r176178

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cb1fd65169c53e8453716660b9a523c940d68487..b523aadd9d5e4e735afb6e11e6d54701dd0807e3 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2011-07-11  Richard Henderson  <rth@redhat.com>
+
+       * dwarf2cfi.c (DW_STACK_POINTER_REGNUM): New.
+       (DW_FRAME_POINTER_REGNUM): New.
+       (expand_builtin_init_dwarf_reg_sizes): Use unsigned for rnum.
+       (def_cfa_1): Do not convert reg to DWARF_FRAME_REGNUM here.
+       (dwf_regno): New.
+       (dwarf2out_flush_queued_reg_saves, dwarf2out_frame_debug_def_cfa,
+       dwarf2out_frame_debug_adjust_cfa, dwarf2out_frame_debug_cfa_register,
+       dwarf2out_frame_debug_cfa_expression, dwarf2out_frame_debug_expr):
+       Use it.
+       * dwarf2out.c (based_loc_descr): Use dwarf_frame_regnum.
+       * dwarf2out.h (dwarf_frame_regnum): New.
+       (struct cfa_loc): Document the domain of the reg member.
+
 2011-07-11  Uros Bizjak  <ubizjak@gmail.com>
 
        * config/i386/i386.c (ix86_trampoline_init): Switch arms of if expr.

diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c
index 5b8420e8f85bb18b70808bc41a78f7cdc03d6e2a..1c76b3f71b93a56fc4c07e20cb732de8a4ff8857 100644 (file)
--- a/gcc/dwarf2cfi.c
+++ b/gcc/dwarf2cfi.c
@@ -57,6 +57,10 @@ along with GCC; see the file COPYING3.  If not see
 
 /* Maximum size (in bytes) of an artificially generated label.  */
 #define MAX_ARTIFICIAL_LABEL_BYTES     30
+
+/* Short-hand for commonly used register numbers.  */
+#define DW_STACK_POINTER_REGNUM  dwarf_frame_regnum (STACK_POINTER_REGNUM)
+#define DW_FRAME_POINTER_REGNUM  dwarf_frame_regnum (HARD_FRAME_POINTER_REGNUM)
 \f
 /* A vector of call frame insns for the CIE.  */
 cfi_vec cie_cfi_vec;
@@ -85,7 +89,7 @@ static void dwarf2out_frame_debug_restore_state (void);
 rtx
 expand_builtin_dwarf_sp_column (void)
 {
-  unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
+  unsigned int dwarf_regnum = DW_STACK_POINTER_REGNUM;
   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
 }
 
@@ -113,7 +117,7 @@ expand_builtin_init_dwarf_reg_sizes (tree address)
 
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     {
-      int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
+      unsigned int rnum = DWARF2_FRAME_REG_OUT (dwarf_frame_regnum (i), 1);
 
       if (rnum < DWARF_FRAME_REGISTERS)
        {
@@ -123,7 +127,7 @@ expand_builtin_init_dwarf_reg_sizes (tree address)
 
          if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
            save_mode = choose_hard_reg_mode (i, 1, true);
-         if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
+         if (dwarf_frame_regnum (i) == DWARF_FRAME_RETURN_COLUMN)
            {
              if (save_mode == VOIDmode)
                continue;
@@ -415,8 +419,6 @@ def_cfa_1 (dw_cfa_location *loc_p)
   if (cfa_store.reg == loc.reg && loc.indirect == 0)
     cfa_store.offset = loc.offset;
 
-  loc.reg = DWARF_FRAME_REGNUM (loc.reg);
-
   /* If nothing changed, no need to issue any call frame instructions.  */
   if (cfa_equal_p (&loc, &old_cfa))
     return;
@@ -810,10 +812,10 @@ dwarf2out_args_size (HOST_WIDE_INT size)
 static void
 dwarf2out_stack_adjust (HOST_WIDE_INT offset)
 {
-  if (cfa.reg == STACK_POINTER_REGNUM)
+  if (cfa.reg == DW_STACK_POINTER_REGNUM)
     cfa.offset += offset;
 
-  if (cfa_store.reg == STACK_POINTER_REGNUM)
+  if (cfa_store.reg == DW_STACK_POINTER_REGNUM)
     cfa_store.offset += offset;
 
   if (ACCUMULATE_OUTGOING_ARGS)
@@ -859,7 +861,7 @@ dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
 
   /* If only calls can throw, and we have a frame pointer,
      save up adjustments until we see the CALL_INSN.  */
-  if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
+  if (!flag_asynchronous_unwind_tables && cfa.reg != DW_STACK_POINTER_REGNUM)
     {
       if (CALL_P (insn) && !after_p)
        {
@@ -952,6 +954,16 @@ static GTY(()) VEC(reg_saved_in_data, gc) *regs_saved_in_regs;
 
 static GTY(()) reg_saved_in_data *cie_return_save;
 
+/* Short-hand inline for the very common D_F_R (REGNO (x)) operation.  */
+/* ??? This ought to go into dwarf2out.h alongside dwarf_frame_regnum,
+   except that dwarf2out.h is used in places where rtl is prohibited.  */
+
+static inline unsigned
+dwf_regno (const_rtx reg)
+{
+  return dwarf_frame_regnum (REGNO (reg));
+}
+
 /* Compare X and Y for equivalence.  The inputs may be REGs or PC_RTX.  */
 
 static bool
@@ -1031,9 +1043,9 @@ dwarf2out_flush_queued_reg_saves (void)
       if (q->reg == pc_rtx)
        reg = DWARF_FRAME_RETURN_COLUMN;
       else
-        reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
+        reg = dwf_regno (q->reg);
       if (q->saved_reg)
-       sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
+       sreg = dwf_regno (q->saved_reg);
       else
        sreg = INVALID_REGNUM;
       reg_save (reg, sreg, q->cfa_offset);
@@ -1106,12 +1118,12 @@ dwarf2out_frame_debug_def_cfa (rtx pat)
   switch (GET_CODE (pat))
     {
     case PLUS:
-      cfa.reg = REGNO (XEXP (pat, 0));
+      cfa.reg = dwf_regno (XEXP (pat, 0));
       cfa.offset = INTVAL (XEXP (pat, 1));
       break;
 
     case REG:
-      cfa.reg = REGNO (pat);
+      cfa.reg = dwf_regno (pat);
       break;
 
     case MEM:
@@ -1122,7 +1134,7 @@ dwarf2out_frame_debug_def_cfa (rtx pat)
          cfa.base_offset = INTVAL (XEXP (pat, 1));
          pat = XEXP (pat, 0);
        }
-      cfa.reg = REGNO (pat);
+      cfa.reg = dwf_regno (pat);
       break;
 
     default:
@@ -1147,7 +1159,7 @@ dwarf2out_frame_debug_adjust_cfa (rtx pat)
   switch (GET_CODE (src))
     {
     case PLUS:
-      gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
+      gcc_assert (dwf_regno (XEXP (src, 0)) == cfa.reg);
       cfa.offset -= INTVAL (XEXP (src, 1));
       break;
 
@@ -1158,7 +1170,7 @@ dwarf2out_frame_debug_adjust_cfa (rtx pat)
        gcc_unreachable ();
     }
 
-  cfa.reg = REGNO (dest);
+  cfa.reg = dwf_regno (dest);
   gcc_assert (cfa.indirect == 0);
 
   def_cfa_1 (&cfa);
@@ -1182,11 +1194,11 @@ dwarf2out_frame_debug_cfa_offset (rtx set)
   switch (GET_CODE (addr))
     {
     case REG:
-      gcc_assert (REGNO (addr) == cfa.reg);
+      gcc_assert (dwf_regno (addr) == cfa.reg);
       offset = -cfa.offset;
       break;
     case PLUS:
-      gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
+      gcc_assert (dwf_regno (XEXP (addr, 0)) == cfa.reg);
       offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
       break;
     default:
@@ -1201,7 +1213,7 @@ dwarf2out_frame_debug_cfa_offset (rtx set)
   else 
     {
       span = targetm.dwarf_register_span (src);
-      sregno = DWARF_FRAME_REGNUM (REGNO (src));
+      sregno = dwf_regno (src);
     }
 
   /* ??? We'd like to use queue_reg_save, but we need to come up with
@@ -1223,7 +1235,7 @@ dwarf2out_frame_debug_cfa_offset (rtx set)
        {
          rtx elem = XVECEXP (span, 0, par_index);
 
-         sregno = DWARF_FRAME_REGNUM (REGNO (src));
+         sregno = dwf_regno (src);
          reg_save (sregno, INVALID_REGNUM, span_offset);
          span_offset += GET_MODE_SIZE (GET_MODE (elem));
        }
@@ -1245,9 +1257,9 @@ dwarf2out_frame_debug_cfa_register (rtx set)
   if (src == pc_rtx)
     sregno = DWARF_FRAME_RETURN_COLUMN;
   else
-    sregno = DWARF_FRAME_REGNUM (REGNO (src));
+    sregno = dwf_regno (src);
 
-  dregno = DWARF_FRAME_REGNUM (REGNO (dest));
+  dregno = dwf_regno (dest);
 
   /* ??? We'd like to use queue_reg_save, but we need to come up with
      a different flushing heuristic for epilogues.  */
@@ -1272,7 +1284,7 @@ dwarf2out_frame_debug_cfa_expression (rtx set)
   gcc_assert (!span);
 
   cfi->dw_cfi_opc = DW_CFA_expression;
-  cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_REGNUM (REGNO (src));
+  cfi->dw_cfi_oprnd1.dw_cfi_reg_num = dwf_regno (src);
   cfi->dw_cfi_oprnd2.dw_cfi_loc
     = mem_loc_descriptor (XEXP (dest, 0), get_address_mode (dest),
                          GET_MODE (dest), VAR_INIT_STATUS_INITIALIZED);
@@ -1288,7 +1300,7 @@ static void
 dwarf2out_frame_debug_cfa_restore (rtx reg)
 {
   dw_cfi_ref cfi = new_cfi ();
-  unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
+  unsigned int regno = dwf_regno (reg);
 
   cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
@@ -1580,7 +1592,7 @@ dwarf2out_frame_debug_expr (rtx expr)
        {
          /* Setting FP from SP.  */
        case REG:
-         if (cfa.reg == (unsigned) REGNO (src))
+         if (cfa.reg == dwf_regno (src))
            {
              /* Rule 1 */
              /* Update the CFA rule wrt SP or FP.  Make sure src is
@@ -1590,7 +1602,7 @@ dwarf2out_frame_debug_expr (rtx expr)
                 ARM copies SP to a temporary register, and from there to
                 FP.  So we just rely on the backends to only set
                 RTX_FRAME_RELATED_P on appropriate insns.  */
-             cfa.reg = REGNO (dest);
+             cfa.reg = dwf_regno (dest);
              cfa_temp.reg = cfa.reg;
              cfa_temp.offset = cfa.offset;
            }
@@ -1599,8 +1611,7 @@ dwarf2out_frame_debug_expr (rtx expr)
              /* Saving a register in a register.  */
              gcc_assert (!fixed_regs [REGNO (dest)]
                          /* For the SPARC and its register window.  */
-                         || (DWARF_FRAME_REGNUM (REGNO (src))
-                             == DWARF_FRAME_RETURN_COLUMN));
+                         || (dwf_regno (src) == DWARF_FRAME_RETURN_COLUMN));
 
               /* After stack is aligned, we can only save SP in FP
                 if drap register is used.  In this case, we have
@@ -1611,7 +1622,7 @@ dwarf2out_frame_debug_expr (rtx expr)
                  && REGNO (src) == STACK_POINTER_REGNUM)
                gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
                            && fde->drap_reg != INVALID_REGNUM
-                           && cfa.reg != REGNO (src));
+                           && cfa.reg != dwf_regno (src));
              else
                queue_reg_save (src, dest, 0);
            }
@@ -1630,8 +1641,7 @@ dwarf2out_frame_debug_expr (rtx expr)
                  offset = INTVAL (XEXP (src, 1));
                  break;
                case REG:
-                 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
-                             == cfa_temp.reg);
+                 gcc_assert (dwf_regno (XEXP (src, 1)) == cfa_temp.reg);
                  offset = cfa_temp.offset;
                  break;
                default:
@@ -1641,8 +1651,8 @@ dwarf2out_frame_debug_expr (rtx expr)
              if (XEXP (src, 0) == hard_frame_pointer_rtx)
                {
                  /* Restoring SP from FP in the epilogue.  */
-                 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
-                 cfa.reg = STACK_POINTER_REGNUM;
+                 gcc_assert (cfa.reg == DW_FRAME_POINTER_REGNUM);
+                 cfa.reg = DW_STACK_POINTER_REGNUM;
                }
              else if (GET_CODE (src) == LO_SUM)
                /* Assume we've set the source reg of the LO_SUM from sp.  */
@@ -1652,9 +1662,9 @@ dwarf2out_frame_debug_expr (rtx expr)
 
              if (GET_CODE (src) != MINUS)
                offset = -offset;
-             if (cfa.reg == STACK_POINTER_REGNUM)
+             if (cfa.reg == DW_STACK_POINTER_REGNUM)
                cfa.offset += offset;
-             if (cfa_store.reg == STACK_POINTER_REGNUM)
+             if (cfa_store.reg == DW_STACK_POINTER_REGNUM)
                cfa_store.offset += offset;
            }
          else if (dest == hard_frame_pointer_rtx)
@@ -1665,13 +1675,13 @@ dwarf2out_frame_debug_expr (rtx expr)
              gcc_assert (frame_pointer_needed);
 
              gcc_assert (REG_P (XEXP (src, 0))
-                         && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
+                         && dwf_regno (XEXP (src, 0)) == cfa.reg
                          && CONST_INT_P (XEXP (src, 1)));
              offset = INTVAL (XEXP (src, 1));
              if (GET_CODE (src) != MINUS)
                offset = -offset;
              cfa.offset += offset;
-             cfa.reg = HARD_FRAME_POINTER_REGNUM;
+             cfa.reg = DW_FRAME_POINTER_REGNUM;
            }
          else
            {
@@ -1679,14 +1689,14 @@ dwarf2out_frame_debug_expr (rtx expr)
 
              /* Rule 4 */
              if (REG_P (XEXP (src, 0))
-                 && REGNO (XEXP (src, 0)) == cfa.reg
+                 && dwf_regno (XEXP (src, 0)) == cfa.reg
                  && CONST_INT_P (XEXP (src, 1)))
                {
                  /* Setting a temporary CFA register that will be copied
                     into the FP later on.  */
                  offset = - INTVAL (XEXP (src, 1));
                  cfa.offset += offset;
-                 cfa.reg = REGNO (dest);
+                 cfa.reg = dwf_regno (dest);
                  /* Or used to save regs to the stack.  */
                  cfa_temp.reg = cfa.reg;
                  cfa_temp.offset = cfa.offset;
@@ -1694,13 +1704,13 @@ dwarf2out_frame_debug_expr (rtx expr)
 
              /* Rule 5 */
              else if (REG_P (XEXP (src, 0))
-                      && REGNO (XEXP (src, 0)) == cfa_temp.reg
+                      && dwf_regno (XEXP (src, 0)) == cfa_temp.reg
                       && XEXP (src, 1) == stack_pointer_rtx)
                {
                  /* Setting a scratch register that we will use instead
                     of SP for saving registers to the stack.  */
-                 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
-                 cfa_store.reg = REGNO (dest);
+                 gcc_assert (cfa.reg == DW_STACK_POINTER_REGNUM);
+                 cfa_store.reg = dwf_regno (dest);
                  cfa_store.offset = cfa.offset - cfa_temp.offset;
                }
 
@@ -1708,7 +1718,7 @@ dwarf2out_frame_debug_expr (rtx expr)
              else if (GET_CODE (src) == LO_SUM
                       && CONST_INT_P (XEXP (src, 1)))
                {
-                 cfa_temp.reg = REGNO (dest);
+                 cfa_temp.reg = dwf_regno (dest);
                  cfa_temp.offset = INTVAL (XEXP (src, 1));
                }
              else
@@ -1718,18 +1728,17 @@ dwarf2out_frame_debug_expr (rtx expr)
 
          /* Rule 6 */
        case CONST_INT:
-         cfa_temp.reg = REGNO (dest);
+         cfa_temp.reg = dwf_regno (dest);
          cfa_temp.offset = INTVAL (src);
          break;
 
          /* Rule 7 */
        case IOR:
          gcc_assert (REG_P (XEXP (src, 0))
-                     && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
+                     && dwf_regno (XEXP (src, 0)) == cfa_temp.reg
                      && CONST_INT_P (XEXP (src, 1)));
 
-         if ((unsigned) REGNO (dest) != cfa_temp.reg)
-           cfa_temp.reg = REGNO (dest);
+         cfa_temp.reg = dwf_regno (dest);
          cfa_temp.offset |= INTVAL (XEXP (src, 1));
          break;
 
@@ -1757,13 +1766,13 @@ dwarf2out_frame_debug_expr (rtx expr)
                 Thus we must flush whatever we have queued first.  */
              dwarf2out_flush_queued_reg_saves ();
 
-              gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
+              gcc_assert (cfa_store.reg == dwf_regno (XEXP (src, 0)));
               fde->stack_realign = 1;
               fde->stack_realignment = INTVAL (XEXP (src, 1));
               cfa_store.offset = 0;
 
-             if (cfa.reg != STACK_POINTER_REGNUM
-                 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
+             if (cfa.reg != DW_STACK_POINTER_REGNUM
+                 && cfa.reg != DW_FRAME_POINTER_REGNUM)
                fde->drap_reg = cfa.reg;
             }
           return;
@@ -1791,10 +1800,10 @@ dwarf2out_frame_debug_expr (rtx expr)
          offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
 
          gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
-                     && cfa_store.reg == STACK_POINTER_REGNUM);
+                     && cfa_store.reg == DW_STACK_POINTER_REGNUM);
 
          cfa_store.offset += offset;
-         if (cfa.reg == STACK_POINTER_REGNUM)
+         if (cfa.reg == DW_STACK_POINTER_REGNUM)
            cfa.offset = cfa_store.offset;
 
          if (GET_CODE (XEXP (dest, 0)) == POST_MODIFY)
@@ -1813,7 +1822,7 @@ dwarf2out_frame_debug_expr (rtx expr)
 
          gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
                       == STACK_POINTER_REGNUM)
-                     && cfa_store.reg == STACK_POINTER_REGNUM);
+                     && cfa_store.reg == DW_STACK_POINTER_REGNUM);
 
          cfa_store.offset += offset;
 
@@ -1824,11 +1833,11 @@ dwarf2out_frame_debug_expr (rtx expr)
               && fde->stack_realign
               && src == hard_frame_pointer_rtx)
            {
-             gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
+             gcc_assert (cfa.reg != DW_FRAME_POINTER_REGNUM);
              cfa_store.offset = 0;
            }
 
-         if (cfa.reg == STACK_POINTER_REGNUM)
+         if (cfa.reg == DW_STACK_POINTER_REGNUM)
            cfa.offset = cfa_store.offset;
 
          if (GET_CODE (XEXP (dest, 0)) == POST_DEC)
@@ -1843,7 +1852,7 @@ dwarf2out_frame_debug_expr (rtx expr)
        case MINUS:
        case LO_SUM:
          {
-           int regno;
+           unsigned int regno;
 
            gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
                        && REG_P (XEXP (XEXP (dest, 0), 0)));
@@ -1851,15 +1860,15 @@ dwarf2out_frame_debug_expr (rtx expr)
            if (GET_CODE (XEXP (dest, 0)) == MINUS)
              offset = -offset;
 
-           regno = REGNO (XEXP (XEXP (dest, 0), 0));
+           regno = dwf_regno (XEXP (XEXP (dest, 0), 0));
 
-           if (cfa.reg == (unsigned) regno)
+           if (cfa.reg == regno)
              offset -= cfa.offset;
-           else if (cfa_store.reg == (unsigned) regno)
+           else if (cfa_store.reg == regno)
              offset -= cfa_store.offset;
            else
              {
-               gcc_assert (cfa_temp.reg == (unsigned) regno);
+               gcc_assert (cfa_temp.reg == regno);
                offset -= cfa_temp.offset;
              }
          }
@@ -1869,15 +1878,15 @@ dwarf2out_frame_debug_expr (rtx expr)
          /* Without an offset.  */
        case REG:
          {
-           int regno = REGNO (XEXP (dest, 0));
+           unsigned int regno = dwf_regno (XEXP (dest, 0));
 
-           if (cfa.reg == (unsigned) regno)
+           if (cfa.reg == regno)
              offset = -cfa.offset;
-           else if (cfa_store.reg == (unsigned) regno)
+           else if (cfa_store.reg == regno)
              offset = -cfa_store.offset;
            else
              {
-               gcc_assert (cfa_temp.reg == (unsigned) regno);
+               gcc_assert (cfa_temp.reg == regno);
                offset = -cfa_temp.offset;
              }
          }
@@ -1885,8 +1894,7 @@ dwarf2out_frame_debug_expr (rtx expr)
 
          /* Rule 14 */
        case POST_INC:
-         gcc_assert (cfa_temp.reg
-                     == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
+         gcc_assert (cfa_temp.reg == dwf_regno (XEXP (XEXP (dest, 0), 0)));
          offset = -cfa_temp.offset;
          cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
          break;
@@ -1904,7 +1912,7 @@ dwarf2out_frame_debug_expr (rtx expr)
       if (REG_P (src)
          && REGNO (src) != STACK_POINTER_REGNUM
          && REGNO (src) != HARD_FRAME_POINTER_REGNUM
-         && (unsigned) REGNO (src) == cfa.reg)
+         && dwf_regno (src) == cfa.reg)
        {
          /* We're storing the current CFA reg into the stack.  */
 
@@ -1919,14 +1927,14 @@ dwarf2out_frame_debug_expr (rtx expr)
               if (fde
                   && fde->stack_realign
                   && cfa.indirect == 0
-                  && cfa.reg != HARD_FRAME_POINTER_REGNUM)
+                  && cfa.reg != DW_FRAME_POINTER_REGNUM)
                 {
                  dw_cfa_location cfa_exp;
 
                  gcc_assert (fde->drap_reg == cfa.reg);
 
                  cfa_exp.indirect = 1;
-                 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
+                 cfa_exp.reg = DW_FRAME_POINTER_REGNUM;
                  cfa_exp.base_offset = offset;
                  cfa_exp.offset = 0;
 
@@ -1953,7 +1961,7 @@ dwarf2out_frame_debug_expr (rtx expr)
                x = XEXP (x, 0);
              gcc_assert (REG_P (x));
 
-             cfa.reg = REGNO (x);
+             cfa.reg = dwf_regno (x);
              cfa.base_offset = offset;
              cfa.indirect = 1;
              def_cfa_1 (&cfa);
@@ -2096,7 +2104,7 @@ dwarf2out_frame_debug (rtx insn, bool after_p)
              {
                gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
                if (REG_P (n))
-                 fde->vdrap_reg = REGNO (n);
+                 fde->vdrap_reg = dwf_regno (n);
              }
          }
        handled_one = true;
@@ -2418,7 +2426,7 @@ initial_return_save (rtx rtl)
     {
     case REG:
       /* RA is in a register.  */
-      reg = DWARF_FRAME_REGNUM (REGNO (rtl));
+      reg = dwf_regno (rtl);
       break;
 
     case MEM:
@@ -2486,7 +2494,7 @@ execute_dwarf2_frame (void)
 
       /* On entry, the Canonical Frame Address is at SP.  */
       memset(&loc, 0, sizeof (loc));
-      loc.reg = STACK_POINTER_REGNUM;
+      loc.reg = DW_STACK_POINTER_REGNUM;
       loc.offset = INCOMING_FRAME_SP_OFFSET;
       def_cfa_1 (&loc);
 
@@ -2526,7 +2534,7 @@ execute_dwarf2_frame (void)
   gcc_checking_assert (regs_saved_in_regs == NULL);
 
   memset (&cfa, 0, sizeof(cfa));
-  cfa.reg = STACK_POINTER_REGNUM;
+  cfa.reg = DW_STACK_POINTER_REGNUM;
   cfa.offset = INCOMING_FRAME_SP_OFFSET;
 
   old_cfa = cfa;

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index f9a1e70e58010af8e9199bebab9b3b289611bd19..835e4ecd88405133af7370959c17604d791a9791 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -10408,8 +10408,8 @@ based_loc_descr (rtx reg, HOST_WIDE_INT offset,
     }
   else if (!optimize
           && fde
-          && (fde->drap_reg == REGNO (reg)
-              || fde->vdrap_reg == REGNO (reg)))
+          && (fde->drap_reg == dwarf_frame_regnum (REGNO (reg))
+              || fde->vdrap_reg == dwarf_frame_regnum (REGNO (reg))))
     {
       /* Use cfa+offset to represent the location of arguments passed
         on the stack when drap is used to align stack.

diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h
index d41453baceabd86c1edf38aec4d9b0f6fd688aa6..912a100153acb1e20edecba4a45eb0fceac6f44d 100644 (file)
--- a/gcc/dwarf2out.h
+++ b/gcc/dwarf2out.h
@@ -121,6 +121,7 @@ dw_fde_node;
 typedef struct cfa_loc {
   HOST_WIDE_INT offset;
   HOST_WIDE_INT base_offset;
+  /* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space.  */
   unsigned int reg;
   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
@@ -261,6 +262,15 @@ extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
 extern void dwarf2out_vms_debug_main_pointer (void);
 #endif
 
+/* Unfortunately, DWARF_FRAME_REGNUM is not universally defined in such a
+   way as to force an unsigned return type.  Do that via inline wrapper.  */
+
+static inline unsigned
+dwarf_frame_regnum (unsigned regnum)
+{
+  return DWARF_FRAME_REGNUM (regnum);
+}
+  
 struct array_descr_info
 {
   int ndimensions;