In general:
There is no unique numbering for the x86 architecture. It's parameterized
- by DWARF_FRAME_REGNUM, which is DBX_REGISTER_NUMBER except for Windows, and
+ by DWARF_FRAME_REGNUM, which is DEBUGGER_REGNO except for Windows, and
the latter depends on the platform.
*/
rtx aarch64_gen_stepped_int_parallel (unsigned int, int, int);
bool aarch64_stepped_int_parallel_p (rtx, int);
rtx aarch64_tls_get_addr (void);
-unsigned aarch64_dbx_register_number (unsigned);
+unsigned aarch64_debugger_regno (unsigned);
unsigned aarch64_trampoline_size (void);
void aarch64_asm_output_labelref (FILE *, const char *);
void aarch64_cpu_cpp_builtins (cpp_reader *);
/* Provide a mapping from gcc register numbers to dwarf register numbers. */
unsigned
-aarch64_dbx_register_number (unsigned regno)
+aarch64_debugger_regno (unsigned regno)
{
if (GP_REGNUM_P (regno))
return AARCH64_DWARF_R0 + regno - R0_REGNUM;
#define DWARF_FRAME_REGISTERS (DWARF_ALT_FRAME_RETURN_COLUMN + 1)
-#define DBX_REGISTER_NUMBER(REGNO) aarch64_dbx_register_number (REGNO)
+#define DEBUGGER_REGNO(REGNO) aarch64_debugger_regno (REGNO)
/* Provide a definition of DWARF_FRAME_REGNUM here so that fallback unwinders
can use DWARF_ALT_FRAME_RETURN_COLUMN defined below. This is just the same
as the default definition in dwarf2out.cc. */
#undef DWARF_FRAME_REGNUM
-#define DWARF_FRAME_REGNUM(REGNO) DBX_REGISTER_NUMBER (REGNO)
+#define DWARF_FRAME_REGNUM(REGNO) DEBUGGER_REGNO (REGNO)
#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LR_REGNUM)
can use DWARF_ALT_FRAME_RETURN_COLUMN defined below. This is just the same
as the default definition in dwarf2out.cc. */
#undef DWARF_FRAME_REGNUM
-#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
+#define DWARF_FRAME_REGNUM(REG) DEBUGGER_REGNO (REG)
/* Before the prologue, RA lives in $26. */
#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, 26)
Because mlo / mhi form a 64 bit value, we use different gcc internal
register numbers to make them form a register pair as the gcc internals
know it. mmid gets number 57, if still available, and mlo / mhi get
- number 58 and 59, depending on endianness. We use DBX_REGISTER_NUMBER
+ number 58 and 59, depending on endianness. We use DEBUGGER_REGNO
to map this back. */
char rname56[5] = "r56";
char rname57[5] = "r57";
#undef PREFERRED_DEBUGGING_TYPE
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
-/* How to renumber registers for dbx and gdb. */
-#define DBX_REGISTER_NUMBER(REGNO) \
+/* How to renumber registers for gdb. */
+#define DEBUGGER_REGNO(REGNO) \
((TARGET_MULMAC_32BY16_SET && (REGNO) >= 56 && (REGNO) <= 57) \
? ((REGNO) ^ !TARGET_BIG_ENDIAN) \
: (TARGET_MUL64_SET && (REGNO) >= 57 && (REGNO) <= 58) \
unsigned int);
extern HOST_WIDE_INT thumb_compute_initial_elimination_offset (unsigned int,
unsigned int);
-extern unsigned int arm_dbx_register_number (unsigned int);
+extern unsigned int arm_debugger_regno (unsigned int);
extern void arm_output_fn_unwind (FILE *, bool);
extern rtx arm_expand_builtin (tree exp, rtx target, rtx subtarget
/* Map internal gcc register numbers to DWARF2 register numbers. */
unsigned int
-arm_dbx_register_number (unsigned int regno)
+arm_debugger_regno (unsigned int regno)
{
if (regno < 16)
return regno;
/* VFP (VFP3) adds 32 (64) + 1 VFPCC. */
#define FIRST_PSEUDO_REGISTER 107
-#define DBX_REGISTER_NUMBER(REGNO) arm_dbx_register_number (REGNO)
+#define DEBUGGER_REGNO(REGNO) arm_debugger_regno (REGNO)
/* Value should be nonzero if functions must have frame pointers.
Zero means the frame pointer need not be set up (and parms may be accessed
/* This works for GAS and some other assemblers. */
#define SET_ASM_OP ".set "
-/* DBX register number for a given compiler register number */
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+/* Debugger register number for a given compiler register number */
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#define SIZE_ASM_OP "\t.size\t"
static unit_req_table unit_reqs;
\f
/* Register map for debugging. */
-unsigned const dbx_register_map[FIRST_PSEUDO_REGISTER] =
+unsigned const debugger_register_map[FIRST_PSEUDO_REGISTER] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* A0 - A15. */
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, /* A16 - A32. */
"B24", "B25", "B26", "B27", "B28", "B29", "B30", "B31", \
"FP", "ARGP", "ILC" }
-#define DBX_REGISTER_NUMBER(N) (dbx_register_map[(N)])
+#define DEBUGGER_REGNO(N) (debugger_register_map[(N)])
-extern unsigned const dbx_register_map[FIRST_PSEUDO_REGISTER];
+extern unsigned const debugger_register_map[FIRST_PSEUDO_REGISTER];
#define FINAL_PRESCAN_INSN c6x_final_prescan_insn
an inverse mapping from dwarf register to gcc register. There is one
need in dwarf2out.cc:expand_builtin_init_dwarf_reg_sizes. Right now, I
don't see that we need exact correspondence between DWARF *frame*
- registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */
+ registers and DEBUGGER_REGNO, so map them onto GCC registers. */
#define DWARF_FRAME_REGNUM(REG) (REG)
/* Node: Stack Checking */
/* Node: All Debuggers */
-#define DBX_REGISTER_NUMBER(REGNO) \
+#define DEBUGGER_REGNO(REGNO) \
((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : \
(REGNO) == CRIS_MOF_REGNUM ? CRIS_CANONICAL_MOF_REGNUM : \
(REGNO) == CRIS_CC0_REGNUM ? CRIS_CANONICAL_CC0_REGNUM : \
/* Arrays that map GCC register numbers to debugger register numbers,
'-1' means that is INVALID_REGNUM.
TODO: which rules according to here ? */
-const int csky_dbx_regno[FIRST_PSEUDO_REGISTER] =
+const int csky_debugger_regno[FIRST_PSEUDO_REGISTER] =
{
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
is different from that used in other debug info sections.
Given a GCC hard register number,
this macro should return the .eh_frame register number.*/
-#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
+#define DWARF_FRAME_REGNUM(REG) DEBUGGER_REGNO (REG)
/* If INCOMING_RETURN_ADDR_RTX is defined & the RTL is REG,
define DWARF_FRAME_RETURN_COLUMN to DWARF_FRAME_REGNUM. */
/* Use r0 and r1 to pass exception handling information. */
#define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? N : INVALID_REGNUM)
-/* How to renumber registers for dbx and gdb. */
-extern const int csky_dbx_regno[];
-#define DBX_REGISTER_NUMBER(REGNO) ((unsigned int) csky_dbx_regno[REGNO])
+/* How to renumber registers for gdb. */
+extern const int csky_debugger_regno[];
+#define DEBUGGER_REGNO(REGNO) ((unsigned int) csky_debugger_regno[REGNO])
/******************************************************************
\f
/* Macros Affecting all Debug Formats. */
-/* A C expression that returns the DBX register number for the compiler
+/* A C expression that returns the debugger register number for the compiler
register number REGNO. In simple cases, the value of this expression may be
REGNO itself. But sometimes there are some registers that the compiler
- knows about and DBX does not, or vice versa. In such cases, some register
- may need to have one number in the compiler and another for DBX.
+ knows about and debugger does not, or vice versa. In such cases, some register
+ may need to have one number in the compiler and another for debugger.
If two registers have consecutive numbers inside GCC, and they can be
used as a pair to hold a multiword value, then they *must* have consecutive
- numbers after renumbering with `DBX_REGISTER_NUMBER'. Otherwise, debuggers
+ numbers after renumbering with `DEBUGGER_REGNO'. Otherwise, debuggers
will be unable to access such a pair, because they expect register pairs to
be consecutive in their own numbering scheme.
- If you find yourself defining `DBX_REGISTER_NUMBER' in way that does not
+ If you find yourself defining `DEBUGGER_REGNO' in way that does not
preserve register pairs, then what you must do instead is redefine the
actual register numbering scheme.
This declaration is required. */
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#undef PREFERRED_DEBUGGING_TYPE
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
#define DWARF2_DEBUGGING_INFO 1
#define DWARF2_ASM_LINE_DEBUG_INFO 1
#define EH_FRAME_THROUGH_COLLECT2 1
-#define DBX_REGISTER_NUMBER(REGNO) gcn_dwarf_register_number (REGNO)
+#define DEBUGGER_REGNO(REGNO) gcn_dwarf_register_number (REGNO)
gcc_unreachable ();
}
-/* Implement DBX_REGISTER_NUMBER macro.
+/* Implement DEBUGGER_REGNO macro.
Return the DWARF register number that corresponds to the GCC internal
REGNO. */
#define ASM_LONG "\t.long\t"
#define ASM_QUAD "\t.quad\t" /* Should not be used for 32bit compilation. */
-/* This was suggested, but it shouldn't be right for DBX output. -- RMS
+/* This was suggested, but it shouldn't be right for debugger output. -- RMS
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) */
\f
#endif
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] \
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] \
: (dwarf_debuginfo_p () \
- ? svr4_dbx_register_map[n] : dbx_register_map[n]))
+ ? svr4_debugger_register_map[n] : debugger_register_map[n]))
/* Map gcc register number to DWARF 2 CFA column number. For 32 bit
- target, always use the svr4_dbx_register_map for DWARF .eh_frame
+ target, always use the svr4_debugger_register_map for DWARF .eh_frame
even if we don't use DWARF .debug_frame. */
#undef DWARF_FRAME_REGNUM
#define DWARF_FRAME_REGNUM(n) \
- (TARGET_64BIT ? dbx64_register_map[(n)] \
- : svr4_dbx_register_map[(n)])
+ (TARGET_64BIT ? debugger64_register_map[(n)] \
+ : svr4_debugger_register_map[(n)])
/* The 64-bit MS_ABI changes the set of call-used registers. */
#undef DWARF_FRAME_REGISTERS
/* Darwin uses the standard DWARF register numbers but the default
register numbers for STABS. Fortunately for 64-bit code the
default and the standard are the same. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] \
- : dwarf_debuginfo_p () ? svr4_dbx_register_map[n] \
- : dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] \
+ : dwarf_debuginfo_p () ? svr4_debugger_register_map[n] \
+ : debugger_register_map[n])
/* Unfortunately, the 32-bit EH information also doesn't use the standard
DWARF register numbers. */
#undef PTRDIFF_TYPE
#define PTRDIFF_TYPE "int"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) svr4_dbx_register_map[n]
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) svr4_debugger_register_map[n]
/* Default to pcc-struct-return. */
#define DEFAULT_PCC_STRUCT_RETURN 1
#undef ASM_APP_OFF
#define ASM_APP_OFF "#NO_APP\n"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
#undef NO_PROFILE_COUNTERS
#define NO_PROFILE_COUNTERS 1
#undef ASM_APP_OFF
#define ASM_APP_OFF "#NO_APP\n"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
#undef NO_PROFILE_COUNTERS
#define NO_PROFILE_COUNTERS 1
* Next is the question of whether to uses underscores. RMS didn't
* like this idea at first, but since it is now obvious that we
* need this separate tm file for use with gas, at least to get
- * dbx debugging info, I think we should also switch to underscores.
+ * debugging info, I think we should also switch to underscores.
* We can keep i386v for real att style output, and the few
* people who want both form will have to compile twice.
*/
#undef ASM_COMMENT_START
#define ASM_COMMENT_START "#"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
/* Output assembler code to FILE to call the profiler.
To the best of my knowledge, no GNU userspace libc has required the label
/* The "default" register map used in 32bit mode. */
-int const dbx_register_map[FIRST_PSEUDO_REGISTER] =
+int const debugger_register_map[FIRST_PSEUDO_REGISTER] =
{
/* general regs */
0, 2, 1, 3, 6, 7, 4, 5,
/* The "default" register map used in 64bit mode. */
-int const dbx64_register_map[FIRST_PSEUDO_REGISTER] =
+int const debugger64_register_map[FIRST_PSEUDO_REGISTER] =
{
/* general regs */
0, 1, 2, 3, 4, 5, 6, 7,
17 for %st(6) (gcc regno = 14)
18 for %st(7) (gcc regno = 15)
*/
-int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER] =
+int const svr4_debugger_register_map[FIRST_PSEUDO_REGISTER] =
{
/* general regs */
0, 2, 1, 3, 6, 7, 5, 4,
{ "zmm28", XMM28_REG }, { "zmm29", XMM29_REG }, { "zmm30", XMM30_REG }, { "zmm31", XMM31_REG } \
}
-/* How to renumber registers for dbx and gdb. */
+/* How to renumber registers for gdb. */
-#define DBX_REGISTER_NUMBER(N) \
- (TARGET_64BIT ? dbx64_register_map[(N)] : dbx_register_map[(N)])
+#define DEBUGGER_REGNO(N) \
+ (TARGET_64BIT ? debugger64_register_map[(N)] : debugger_register_map[(N)])
-extern int const dbx_register_map[FIRST_PSEUDO_REGISTER];
-extern int const dbx64_register_map[FIRST_PSEUDO_REGISTER];
-extern int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER];
+extern int const debugger_register_map[FIRST_PSEUDO_REGISTER];
+extern int const debugger64_register_map[FIRST_PSEUDO_REGISTER];
+extern int const svr4_debugger_register_map[FIRST_PSEUDO_REGISTER];
/* Before the prologue, RA is at 0(%esp). */
#define INCOMING_RETURN_ADDR_RTX \
%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}}\
crtbegin.o%s"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
#define LOCAL_LABEL_PREFIX "."
#undef ASM_COMMENT_START
#define ASM_COMMENT_START "#"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
#undef ASM_SPEC
#define ASM_SPEC "--32 -march=iamcu"
/* LynxOS's GDB counts the floating point registers from 16. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] \
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] \
: (n) == 0 ? 0 \
: (n) == 1 ? 2 \
: (n) == 2 ? 1 \
#undef ASM_COMMENT_START
#define ASM_COMMENT_START "#"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) svr4_dbx_register_map[n]
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) svr4_debugger_register_map[n]
/* Output assembler code to FILE to call the profiler. */
#define TARGET_POSIX_IO
-#undef DBX_REGISTER_NUMBER
+#undef DEBUGGER_REGNO
} \
while (0)
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
/* This must agree with <machine/_types.h>. */
#undef SIZE_TYPE
#undef X86_FILE_START_VERSION_DIRECTIVE
#define X86_FILE_START_VERSION_DIRECTIVE true
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) svr4_dbx_register_map[n]
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) svr4_debugger_register_map[n]
/* A C statement (sans semicolon) to output to the stdio stream
FILE the assembler definition of uninitialized global DECL named
#endif
-/* Provide our target specific DBX_REGISTER_NUMBER. VxWorks relies on
+/* Provide our target specific DEBUGGER_REGNO. VxWorks relies on
the SVR4 numbering. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
/* CPU macro definitions, ordered to account for VxWorks 7 not
supporting CPUs older than PENTIUM4 since SR0650. */
#undef ASM_COMMENT_START
#define ASM_COMMENT_START "#"
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(n) \
- (TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(n) \
+ (TARGET_64BIT ? debugger64_register_map[n] : svr4_debugger_register_map[n])
/* Output assembler code to FILE to call the profiler. */
#define NO_PROFILE_COUNTERS 1
extern int ia64_eh_uses (int);
extern void emit_safe_across_calls (void);
extern void ia64_init_builtins (void);
-extern int ia64_dbx_register_number (int);
+extern int ia64_debugger_regno (int);
extern rtx ia64_return_addr_rtx (HOST_WIDE_INT, rtx);
extern void ia64_split_return_addr_rtx (rtx);
if (mask && TARGET_GNU_AS)
fprintf (file, "\t.prologue %d, %d\n", mask,
- ia64_dbx_register_number (grsave));
+ ia64_debugger_regno (grsave));
else
fputs ("\t.prologue\n", file);
}
int
-ia64_dbx_register_number (int regno)
+ia64_debugger_regno (int regno)
{
/* In ia64_expand_prologue we quite literally renamed the frame pointer
from its home at loc79 to something inside the register frame. We
if (unwind)
fprintf (out_file, "\t.vframe r%d\n",
- ia64_dbx_register_number (REGNO (dest)));
+ ia64_debugger_regno (REGNO (dest)));
}
else
gcc_unreachable ();
/* Saving return address pointer. */
if (unwind)
fprintf (out_file, "\t.save rp, r%d\n",
- ia64_dbx_register_number (dest_regno));
+ ia64_debugger_regno (dest_regno));
return;
}
gcc_assert (dest_regno == current_frame_info.r[reg_save_pr]);
if (unwind)
fprintf (out_file, "\t.save pr, r%d\n",
- ia64_dbx_register_number (dest_regno));
+ ia64_debugger_regno (dest_regno));
break;
case AR_UNAT_REGNUM:
gcc_assert (dest_regno == current_frame_info.r[reg_save_ar_unat]);
if (unwind)
fprintf (out_file, "\t.save ar.unat, r%d\n",
- ia64_dbx_register_number (dest_regno));
+ ia64_debugger_regno (dest_regno));
break;
case AR_LC_REGNUM:
gcc_assert (dest_regno == current_frame_info.r[reg_save_ar_lc]);
if (unwind)
fprintf (out_file, "\t.save ar.lc, r%d\n",
- ia64_dbx_register_number (dest_regno));
+ ia64_debugger_regno (dest_regno));
break;
default:
{
if (unwind)
fprintf (out_file, "\t.save ar.pfs, r%d\n",
- ia64_dbx_register_number (dest_regno));
+ ia64_debugger_regno (dest_regno));
}
else
{
/* Macros Affecting all Debug Formats. */
/* This is handled in sysv4.h. */
-
-\f
-/* Specific Options for DBX Output. */
-
-\f
-/* Open ended Hooks for DBX Output. */
-
-/* Likewise. */
-
-\f
-/* File names in DBX format. */
-
-/* Likewise. */
-
\f
/* Macros for Dwarf Output. */
#undef FINI_SECTION_ASM_OP
#define FINI_SECTION_ASM_OP "\t.section\t.fini,\"ax\",\"progbits\""
-#define DBX_REGISTER_NUMBER(REGNO) \
- ia64_dbx_register_number(REGNO)
+#define DEBUGGER_REGNO(REGNO) \
+ ia64_debugger_regno(REGNO)
#undef SIZE_TYPE
#define SIZE_TYPE "long unsigned int"
/* Debugging. */
/*-------------*/
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#define DEFAULT_GDB_EXTENSIONS 1
/* Registers That Address the Stack Frame */
-/* Implements DWARF_FRAME_REGNUM and DBX_REGISTER_NUMBER. Note that
+/* Implements DWARF_FRAME_REGNUM and DEBUGGER_REGNO. Note that
the original spec called for dwarf numbers to vary with register
width as well, for example, r0l, r0, and r2r0 would each have
different dwarf numbers. GCC doesn't support this, and we don't do
#define DWARF_FRAME_REGISTERS 20
#define DWARF_FRAME_REGNUM(N) m32c_dwarf_frame_regnum (N)
-#define DBX_REGISTER_NUMBER(N) m32c_dwarf_frame_regnum (N)
+#define DEBUGGER_REGNO(N) m32c_dwarf_frame_regnum (N)
#undef ASM_PREFERRED_EH_DATA_FORMAT
/* This is the same as the default in practice, except that by making
#define TARGET_ASM_FILE_END file_end_indicate_exec_stack
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#undef SIZE_TYPE
#define SIZE_TYPE "unsigned int"
/* On the Sun-3, the floating point registers have numbers
18 to 25, not 16 to 23 as they do in the compiler. */
-#define DBX_REGISTER_NUMBER(REGNO) ((REGNO) < 16 ? (REGNO) : (REGNO) + 2)
+#define DEBUGGER_REGNO(REGNO) ((REGNO) < 16 ? (REGNO) : (REGNO) + 2)
/* Before the prologue, RA is at 0(%sp). */
#define INCOMING_RETURN_ADDR_RTX \
UNITS_PER_WORD)) \
: gen_rtx_MEM (Pmode, plus_constant (Pmode, FRAME, UNITS_PER_WORD)))
-/* We must not use the DBX register numbers for the DWARF 2 CFA column
+/* We must not use the debugger register numbers for the DWARF 2 CFA column
numbers because that maps to numbers beyond FIRST_PSEUDO_REGISTER.
Instead use the identity mapping. */
#define DWARF_FRAME_REGNUM(REG) \
SVR4 debugger in the m68k/SVR4 reference port, where d0-d7
are 0-7, a0-a8 are 8-15, and fp0-fp7 are 16-23. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#if 0
/* SVR4 m68k assembler is bitching on the `comm i,1,1' which askes for
#define M68K_STATIC_CHAIN_REG_NAME REGISTER_PREFIX "a1"
-/* Now to renumber registers for dbx and gdb.
+/* Now to renumber registers for gdb.
We use the Sun-3 convention, which is:
floating point registers have numbers 18 to 25, not
16 to 23 as they do in the compiler. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(REGNO) ((REGNO) < 16 ? (REGNO) : (REGNO) + 2)
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(REGNO) ((REGNO) < 16 ? (REGNO) : (REGNO) + 2)
/* 1 if N is a possible register number for a function value. For
char microblaze_print_operand_punct[256];
/* Map GCC register number to debugger register number. */
-int microblaze_dbx_regno[FIRST_PSEUDO_REGISTER];
+int microblaze_debugger_regno[FIRST_PSEUDO_REGISTER];
/* Map hard register number to register class. */
enum reg_class microblaze_regno_to_class[] =
Ignore the special purpose register numbers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- microblaze_dbx_regno[i] = -1;
+ microblaze_debugger_regno[i] = -1;
- start = GP_DBX_FIRST - GP_REG_FIRST;
+ start = GP_DEBUGGER_FIRST - GP_REG_FIRST;
for (i = GP_REG_FIRST; i <= GP_REG_LAST; i++)
- microblaze_dbx_regno[i] = i + start;
+ microblaze_debugger_regno[i] = i + start;
/* Set up array giving whether a given register can hold a given mode. */
extern int microblaze_section_threshold;
/* Map register # to debug register # */
-extern int microblaze_dbx_regno[];
+extern int microblaze_debugger_regno[];
extern int microblaze_no_unsafe_delay;
extern int microblaze_has_clz;
/* Debug stuff. */
-/* How to renumber registers for dbx and gdb. */
-#define DBX_REGISTER_NUMBER(REGNO) microblaze_dbx_regno[(REGNO)]
+/* How to renumber registers for gdb. */
+#define DEBUGGER_REGNO(REGNO) microblaze_debugger_regno[(REGNO)]
/* Generate DWARF exception handling info. */
#define DWARF2_UNWIND_INFO 1
#define GP_REG_FIRST 0
#define GP_REG_LAST 31
#define GP_REG_NUM (GP_REG_LAST - GP_REG_FIRST + 1)
-#define GP_DBX_FIRST 0
+#define GP_DEBUGGER_FIRST 0
#define ST_REG 32
#define AP_REG_NUM 33
#undef SUBTARGET_OVERRIDE_OPTIONS
#define SUBTARGET_OVERRIDE_OPTIONS VXWORKS_OVERRIDE_OPTIONS
-#undef DBX_REGISTER_NUMBER
+#undef DEBUGGER_REGNO
extern void mmix_output_register_setting (FILE *, int, int64_t, int);
extern int mmix_opposite_regno (int, int);
extern int mmix_local_regno (int);
-extern unsigned mmix_dbx_register_number (unsigned);
+extern unsigned mmix_debugger_regno (unsigned);
extern int mmix_use_simple_return (void);
extern void mmix_make_decl_one_only (tree);
extern int mmix_data_alignment (tree, int);
fprintf (stream, "\tLOC @+(%d-@)&%d\n", 1 << power, (1 << power) - 1);
}
-/* DBX_REGISTER_NUMBER. */
+/* DEBUGGER_REGNO. */
unsigned
-mmix_dbx_register_number (unsigned regno)
+mmix_debugger_regno (unsigned regno)
{
/* Adjust the register number to the one it will be output as, dammit.
It'd be nice if we could check the assumption that we're filling a
/* We need to renumber registers to get the number of the return address
register in the range 0..255. It is also space-saving if registers
mentioned in the call-frame information (which uses this function by
- defaulting DWARF_FRAME_REGNUM to DBX_REGISTER_NUMBER) are numbered
+ defaulting DWARF_FRAME_REGNUM to DEBUGGER_REGNO) are numbered
0 .. 63. So map 224 .. 256+15 -> 0 .. 47 and 0 .. 223 -> 48..223+48. */
return regno >= 224 ? (regno - 224) : (regno + 48);
}
/* Node: All Debuggers */
-#define DBX_REGISTER_NUMBER(REGNO) \
- mmix_dbx_register_number (REGNO)
-
-
-/* Node: DBX Options */
-/* (empty) */
-/* Node: DBX Hooks */
-/* (empty) */
-/* Node: File Names and DBX */
-/* (empty) */
-
+#define DEBUGGER_REGNO(REGNO) \
+ mmix_debugger_regno (REGNO)
/* Node: DWARF */
#define DWARF2_DEBUGGING_INFO 1
/* Controlling Debugging Information Format. */
-extern unsigned int nds32_dbx_register_number (unsigned int);
+extern unsigned int nds32_debugger_regno (unsigned int);
/* ------------------------------------------------------------------------ */
/* Map internal gcc register numbers to DWARF2 register numbers. */
unsigned int
-nds32_dbx_register_number (unsigned int regno)
+nds32_debugger_regno (unsigned int regno)
{
/* The nds32 port in GDB maintains a mapping between dwarf register
number and displayed register name. For backward compatibility to
/* -- Macros Affecting All Debugging Formats. */
-/* -- Specific Options for DBX Output. */
-
-/* -- Open-Ended Hooks for DBX Format. */
-
-/* -- File Names in DBX Format. */
-
/* -- Macros for DWARF Output. */
/* -- Macros for VMS Debug Format. */
This is used to unwind the stack to an exception handler's call frame. */
#define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, 2)
-#define DBX_REGISTER_NUMBER(REGNO) nds32_dbx_register_number (REGNO)
+#define DEBUGGER_REGNO(REGNO) nds32_debugger_regno (REGNO)
#define STACK_POINTER_REGNUM SP_REGNUM
#undef ASM_APP_OFF
#define ASM_APP_OFF "\t// #NO_APP \n"
-#define DBX_REGISTER_NUMBER(N) N
+#define DEBUGGER_REGNO(N) N
#define TEXT_SECTION_ASM_OP ""
#define DATA_SECTION_ASM_OP ""
: (X) < 24 ? ((X) - 16) * 2 + 17 \
: ((X) - 24) * 2 + 16)
-#define DBX_REGISTER_NUMBER(X) GCC_TO_HW_REGNO(X)
+#define DEBUGGER_REGNO(X) GCC_TO_HW_REGNO(X)
#define REGISTER_NAMES { \
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
|| (GET_MODE_SIZE (MODE) == 8 * UNITS_PER_WORD \
&& ((REGNO) & 7) == 3 && (REGNO) <= 19)))
-/* How to renumber registers for dbx and gdb.
+/* How to renumber registers for gdb.
Registers 0 - 31 remain unchanged.
Register 88 is mapped to 32. */
-#define DBX_REGISTER_NUMBER(REGNO) \
+#define DEBUGGER_REGNO(REGNO) \
((REGNO) <= 31 ? (REGNO) : \
((REGNO) <= 87 ? (REGNO) + 40 : 32))
-/* We must not use the DBX register numbers for the DWARF 2 CFA column
+/* We must not use the debugger register numbers for the DWARF 2 CFA column
numbers because that maps to numbers beyond FIRST_PSEUDO_REGISTER.
Instead use the identity mapping. */
#define DWARF_FRAME_REGNUM(REG) REG
|| (GET_MODE_SIZE (MODE) == 4 * UNITS_PER_WORD \
&& ((REGNO) & 3) == 3 && (REGNO) <= 23)))
-/* How to renumber registers for dbx and gdb.
+/* How to renumber registers for gdb.
Registers 0 - 31 remain unchanged.
Registers 32 - 59 are mapped to 72, 74, 76 ...
Register 60 is mapped to 32. */
-#define DBX_REGISTER_NUMBER(REGNO) \
+#define DEBUGGER_REGNO(REGNO) \
((REGNO) <= 31 ? (REGNO) : ((REGNO) < 60 ? (REGNO - 32) * 2 + 72 : 32))
-/* We must not use the DBX register numbers for the DWARF 2 CFA column
+/* We must not use the debugger register numbers for the DWARF 2 CFA column
numbers because that maps to numbers beyond FIRST_PSEUDO_REGISTER.
Instead use the identity mapping. */
#define DWARF_FRAME_REGNUM(REG) REG
extern alias_set_type get_TOC_alias_set (void);
extern void rs6000_emit_prologue (void);
extern void rs6000_emit_load_toc_table (int);
-extern unsigned int rs6000_dbx_register_number (unsigned int, unsigned int);
+extern unsigned int rs6000_debugger_regno (unsigned int, unsigned int);
extern void rs6000_emit_epilogue (enum epilogue_type);
extern void rs6000_expand_split_stack_prologue (void);
extern void rs6000_split_stack_space_check (rtx, rtx);
2 -- DWARF .eh_frame section */
unsigned int
-rs6000_dbx_register_number (unsigned int regno, unsigned int format)
+rs6000_debugger_regno (unsigned int regno, unsigned int format)
{
/* On some platforms, we use the standard DWARF register
numbering for .debug_info and .debug_frame. */
#define FIRST_PSEUDO_REGISTER 111
/* Use standard DWARF numbering for DWARF debugging information. */
-#define DBX_REGISTER_NUMBER(REGNO) rs6000_dbx_register_number ((REGNO), 0)
+#define DEBUGGER_REGNO(REGNO) rs6000_debugger_regno ((REGNO), 0)
/* Use gcc hard register numbering for eh_frame. */
#define DWARF_FRAME_REGNUM(REGNO) (REGNO)
collected using DWARF_FRAME_REGNUM to those that should be output in
.debug_frame and .eh_frame. */
#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) \
- rs6000_dbx_register_number ((REGNO), (FOR_EH) ? 2 : 1)
+ rs6000_debugger_regno ((REGNO), (FOR_EH) ? 2 : 1)
/* 1 for registers that have pervasive standard uses
and are not available for the register allocator.
/* Define the dwarf register mapping.
v16-v31 -> 68-83
rX -> X otherwise */
-#define DBX_REGISTER_NUMBER(regno) \
+#define DEBUGGER_REGNO(regno) \
(((regno) >= 38 && (regno) <= 53) ? (regno) + 30 : (regno))
/* Frame registers. */
#define LINK_EMUL_PREFIX "sh%{ml:l}elf"
#endif
-#define DBX_REGISTER_NUMBER(REGNO) SH_DBX_REGISTER_NUMBER (REGNO)
+#define DEBUGGER_REGNO(REGNO) SH_DEBUGGER_REGNO (REGNO)
#undef ASM_GENERATE_INTERNAL_LABEL
#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \
in MD_FALLBACK_FRAME_STATE_FOR and its content will be read with
_Unwind_GetGR which uses dwarf_reg_size_table to get the size of
the register. So the entry of dwarf_reg_size_table corresponding to
- this slot must be set. To do this, we redefine DBX_REGISTER_NUMBER
+ this slot must be set. To do this, we redefine DEBUGGER_REGNO
so as to return itself for 16. */
-#undef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(REGNO) \
- (((REGNO) == 16) ? 16 : SH_DBX_REGISTER_NUMBER (REGNO))
+#undef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(REGNO) \
+ (((REGNO) == 16) ? 16 : SH_DEBUGGER_REGNO (REGNO))
/* Install the __sync libcalls. */
#undef TARGET_INIT_LIBFUNCS
fprintf ((file), "\tmov.l\t@r15+,r%d\n", (v)); \
}
-/* DBX register number for a given compiler register number. */
+/* Debugger register number for a given compiler register number. */
/* GDB has FPUL at 23 and FP0 at 25, so we must add one to all FP registers
to match gdb. */
/* expand_builtin_init_dwarf_reg_sizes uses this to test if a
register exists, so we should return -1 for invalid register numbers. */
-#define DBX_REGISTER_NUMBER(REGNO) SH_DBX_REGISTER_NUMBER (REGNO)
+#define DEBUGGER_REGNO(REGNO) SH_DEBUGGER_REGNO (REGNO)
-#define SH_DBX_REGISTER_NUMBER(REGNO) \
+#define SH_DEBUGGER_REGNO(REGNO) \
(IN_RANGE ((REGNO), \
(unsigned HOST_WIDE_INT) FIRST_GENERAL_REG, \
FIRST_GENERAL_REG + 15U) \
This describes how to specify debugging information.
mda is known to GDB, but not to GCC. */
-#define DBX_REGISTER_NUMBER(REGNO) \
+#define DEBUGGER_REGNO(REGNO) \
((REGNO) > MDB_REGNUM ? (REGNO) + 1 : (REGNO))
/* `DEBUGGER_AUTO_OFFSET (X)'
automatic variable having address X (an RTL expression). The
default computation assumes that X is based on the frame-pointer
and gives the offset from the frame-pointer. This is required for
- targets that produce debugging output for DBX and allow the frame-pointer
+ targets that produce debugging output for debugger and allow the frame-pointer
to be eliminated when the `-g' options is used. */
#define DEBUGGER_AUTO_OFFSET(X) \
(GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
/* Do not force "-fpic" for this target. */
#define XTENSA_ALWAYS_PIC 0
-#undef DBX_REGISTER_NUMBER
+#undef DEBUGGER_REGNO
/* Search for headers in $tooldir/arch/include and for libraries and
startfiles in $tooldir/arch/lib. */
/* Always enable "-fpic" for Xtensa Linux. */
#define XTENSA_ALWAYS_PIC 1
-#undef DBX_REGISTER_NUMBER
+#undef DEBUGGER_REGNO
#undef TARGET_LIBC_HAS_FUNCTION
#define TARGET_LIBC_HAS_FUNCTION no_c99_libc_has_function
-#undef DBX_REGISTER_NUMBER
+#undef DEBUGGER_REGNO
#endif /* RTX_CODE */
extern void xtensa_setup_frame_addresses (void);
-extern int xtensa_dbx_register_number (int);
+extern int xtensa_debugger_regno (int);
extern long compute_frame_size (poly_int64);
extern bool xtensa_use_return_instruction_p (void);
extern void xtensa_expand_prologue (void);
/* Return the debugger register number to use for 'regno'. */
int
-xtensa_dbx_register_number (int regno)
+xtensa_debugger_regno (int regno)
{
int first = -1;
#define FIRST_PSEUDO_REGISTER 36
/* Return the stabs register number to use for REGNO. */
-#define DBX_REGISTER_NUMBER(REGNO) xtensa_dbx_register_number (REGNO)
+#define DEBUGGER_REGNO(REGNO) xtensa_debugger_regno (REGNO)
/* 1 for registers that have pervasive standard uses
and are not available for the register allocator. */
#endif
#endif
-/* How to renumber registers for dbx and gdb. If not defined, assume
+/* How to renumber registers for gdb. If not defined, assume
no renumbering is necessary. */
-#ifndef DBX_REGISTER_NUMBER
-#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
+#ifndef DEBUGGER_REGNO
+#define DEBUGGER_REGNO(REGNO) (REGNO)
#endif
/* The mapping from gcc register number to DWARF 2 CFA column number.
By default, we just provide columns for all registers. */
#ifndef DWARF_FRAME_REGNUM
-#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
+#define DWARF_FRAME_REGNUM(REG) DEBUGGER_REGNO (REG)
#endif
/* The mapping from dwarf CFA reg number to internal dwarf reg numbers. */
used in .eh_frame or .debug_frame is different from that used in other
debug info sections. Given a GCC hard register number, this macro
should return the .eh_frame register number. The default is
-@code{DBX_REGISTER_NUMBER (@var{regno})}.
+@code{DEBUGGER_REGISTER_NUMBER (@var{regno})}.
@end defmac
@c prevent bad page break with this line
These macros affect all debugging formats.
-@defmac DBX_REGISTER_NUMBER (@var{regno})
-A C expression that returns the DBX register number for the compiler
+@defmac DEBUGGER_REGISTER_NUMBER (@var{regno})
+A C expression that returns the debugger register number for the compiler
register number @var{regno}. In the default macro provided, the value
of this expression will be @var{regno} itself. But sometimes there are
-some registers that the compiler knows about and DBX does not, or vice
+some registers that the compiler knows about and debugger does not, or vice
versa. In such cases, some register may need to have one number in the
-compiler and another for DBX@.
+compiler and another for debugger@.
If two registers have consecutive numbers inside GCC, and they can be
used as a pair to hold a multiword value, then they @emph{must} have
-consecutive numbers after renumbering with @code{DBX_REGISTER_NUMBER}.
+consecutive numbers after renumbering with @code{DEBUGGER_REGISTER_NUMBER}.
Otherwise, debuggers will be unable to access such a pair, because they
expect register pairs to be consecutive in their own numbering scheme.
-If you find yourself defining @code{DBX_REGISTER_NUMBER} in way that
+If you find yourself defining @code{DEBUGGER_REGISTER_NUMBER} in way that
does not preserve register pairs, then what you must do instead is
redefine the actual register numbering scheme.
@end defmac
variable having address @var{x} (an RTL expression). The default
computation assumes that @var{x} is based on the frame-pointer and
gives the offset from the frame-pointer. This is required for targets
-that produce debugging output for DBX and allow the frame-pointer to be
+that produce debugging output for debugger and allow the frame-pointer to be
eliminated when the @option{-g} option is used.
@end defmac
@defmac DEFAULT_GDB_EXTENSIONS
Define this macro to control whether GCC should by default generate
-GDB's extended version of DBX debugging information (assuming DBX-format
-debugging information is enabled at all). If you don't define the
+GDB's extended version of debugging information. If you don't define the
macro, the default is 1: always generate the extended information
if there is any occasion to.
@end defmac
used in .eh_frame or .debug_frame is different from that used in other
debug info sections. Given a GCC hard register number, this macro
should return the .eh_frame register number. The default is
-@code{DBX_REGISTER_NUMBER (@var{regno})}.
+@code{DEBUGGER_REGISTER_NUMBER (@var{regno})}.
@end defmac
@c prevent bad page break with this line
These macros affect all debugging formats.
-@defmac DBX_REGISTER_NUMBER (@var{regno})
-A C expression that returns the DBX register number for the compiler
+@defmac DEBUGGER_REGISTER_NUMBER (@var{regno})
+A C expression that returns the debugger register number for the compiler
register number @var{regno}. In the default macro provided, the value
of this expression will be @var{regno} itself. But sometimes there are
-some registers that the compiler knows about and DBX does not, or vice
+some registers that the compiler knows about and debugger does not, or vice
versa. In such cases, some register may need to have one number in the
-compiler and another for DBX@.
+compiler and another for debugger@.
If two registers have consecutive numbers inside GCC, and they can be
used as a pair to hold a multiword value, then they @emph{must} have
-consecutive numbers after renumbering with @code{DBX_REGISTER_NUMBER}.
+consecutive numbers after renumbering with @code{DEBUGGER_REGISTER_NUMBER}.
Otherwise, debuggers will be unable to access such a pair, because they
expect register pairs to be consecutive in their own numbering scheme.
-If you find yourself defining @code{DBX_REGISTER_NUMBER} in way that
+If you find yourself defining @code{DEBUGGER_REGISTER_NUMBER} in way that
does not preserve register pairs, then what you must do instead is
redefine the actual register numbering scheme.
@end defmac
variable having address @var{x} (an RTL expression). The default
computation assumes that @var{x} is based on the frame-pointer and
gives the offset from the frame-pointer. This is required for targets
-that produce debugging output for DBX and allow the frame-pointer to be
+that produce debugging output for debugger and allow the frame-pointer to be
eliminated when the @option{-g} option is used.
@end defmac
@defmac DEFAULT_GDB_EXTENSIONS
Define this macro to control whether GCC should by default generate
-GDB's extended version of DBX debugging information (assuming DBX-format
-debugging information is enabled at all). If you don't define the
+GDB's extended version of debugging information. If you don't define the
macro, the default is 1: always generate the extended information
if there is any occasion to.
@end defmac
static dw_die_ref modified_type_die (tree, int, bool, dw_die_ref);
static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
-static unsigned int dbx_reg_number (const_rtx);
+static unsigned int debugger_reg_number (const_rtx);
static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
return die;
}
-/* Return the DBX register number described by a given RTL node. */
+/* Return the debugger register number described by a given RTL node. */
static unsigned int
-dbx_reg_number (const_rtx rtl)
+debugger_reg_number (const_rtx rtl)
{
unsigned regno = REGNO (rtl);
}
#endif
- regno = DBX_REGISTER_NUMBER (regno);
+ regno = DEBUGGER_REGNO (regno);
gcc_assert (regno != INVALID_REGNUM);
return regno;
}
return multiple_reg_loc_descriptor (rtl, regs, initialized);
else
{
- unsigned int dbx_regnum = dbx_reg_number (rtl);
- if (dbx_regnum == IGNORED_DWARF_REGNUM)
+ unsigned int debugger_regnum = debugger_reg_number (rtl);
+ if (debugger_regnum == IGNORED_DWARF_REGNUM)
return 0;
- return one_reg_loc_descriptor (dbx_regnum, initialized);
+ return one_reg_loc_descriptor (debugger_regnum, initialized);
}
}
}
#endif
- gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
+ gcc_assert ((unsigned) DEBUGGER_REGNO (reg) == debugger_reg_number (rtl));
nregs = REG_NREGS (rtl);
/* At present we only track constant-sized pieces. */
{
dw_loc_descr_ref t;
- t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
+ t = one_reg_loc_descriptor (DEBUGGER_REGNO (reg),
VAR_INIT_STATUS_INITIALIZED);
add_loc_descr (&loc_result, t);
add_loc_descr_op_piece (&loc_result, size);
{
dw_loc_descr_ref t;
- t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)),
+ t = one_reg_loc_descriptor (debugger_reg_number (XVECEXP (regs, 0, i)),
VAR_INIT_STATUS_INITIALIZED);
add_loc_descr (&loc_result, t);
add_loc_descr_op_piece (&loc_result, size);
))
{
dw_die_ref type_die;
- unsigned int dbx_regnum;
+ unsigned int debugger_regnum;
if (dwarf_strict && dwarf_version < 5)
break;
if (type_die == NULL)
break;
- dbx_regnum = dbx_reg_number (rtl);
- if (dbx_regnum == IGNORED_DWARF_REGNUM)
+ debugger_regnum = debugger_reg_number (rtl);
+ if (debugger_regnum == IGNORED_DWARF_REGNUM)
break;
mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_regval_type),
- dbx_regnum, 0);
+ debugger_regnum, 0);
mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
VOIDmode, VAR_INIT_STATUS_INITIALIZED);
else
{
- unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl));
- if (dbx_regnum == IGNORED_DWARF_REGNUM)
+ unsigned int debugger_regnum = debugger_reg_number (ENTRY_VALUE_EXP (rtl));
+ if (debugger_regnum == IGNORED_DWARF_REGNUM)
return NULL;
- op0 = one_reg_loc_descriptor (dbx_regnum,
+ op0 = one_reg_loc_descriptor (debugger_regnum,
VAR_INIT_STATUS_INITIALIZED);
}
}
#ifdef DWARF_FRAME_REGNUM
iwhich = DWARF_FRAME_REGNUM (iwhich);
#else
- iwhich = DBX_REGISTER_NUMBER (iwhich);
+ iwhich = DEBUGGER_REGNO (iwhich);
#endif
return GEN_INT (iwhich);
projects / thirdparty / gcc.git / commitdiff
