OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
This commit is contained in:
Richard Henderson 2011-07-11 12:30:56 -07:00 committed by Richard Henderson
parent 5fb8060d5b
commit 7263c6d715
4 changed files with 108 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
gcc/ChangeLog
View File

@ -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.

154
gcc/dwarf2cfi.c
View File

@ -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;

4
gcc/dwarf2out.c
View File

@ -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.

10
gcc/dwarf2out.h
View File

@ -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;