@@ -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)
/* 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;
@@ -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.
@@ -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;
Sometimes we compare cfa.reg with REGNO, and sometimes with something that has been passed through DWARF_FRAME_REGNUM. This leads to all sorts of confusion. I think that ideally we'd leave dw_cfa_location.reg in the GCC regno space, because that's convenient for the majority of the code that interprets rtl and turns it into CFIs. However, we have no inverse of DWARF_FRAME_REGNUM, which means that lookup_cfa_1 cannot read CFI data in dwarf2 regno space and produce an output in GCC regno space. Therefore, I've audited all uses of dw_cfa_location.reg to ensure that all references are in dwarf2 regno space. It would have been nice to be able to use C++ classes to be able to do this checking in perpetuity, but the equivalent struct wrapping in C would have made the source to ugly. Tested on x86_64-linux. Committed. r~ * 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.