MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gdb: convert arc to new-style debug macros

Browse Source 
Add the standard arc_debug_printf, but also arc_linux_debug_printf,
arc_linux_nat_debug_printf and arc_newlib_debug_printf to match the
prefixes currently used in the debug messages.

gdb/ChangeLog:

	* arc-tdep.h (arc_debug_printf): New.
	* arc-tdep.c: Use arc_debug_printf.
	* arc-linux-nat.c (arc_linux_nat_debug_printf): Add and use.
	* arc-linux-tdep.c (arc_linux_debug_printf): Add and use.
	* arc-newlib-tdep.c (arc_newlib_debug_printf): Add and use.

Change-Id: I5d937566ed7a1925f7982e8809802c8f0560d8c6
This commit is contained in:
Simon Marchi 2021-01-13 14:32:39 -05:00
parent fb0f5031bb
commit d8d1feb424
6 changed files with 98 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gdb/ChangeLog
View File

@ -1,3 +1,11 @@
2021-01-13 Simon Marchi <simon.marchi@polymtl.ca>
* arc-tdep.h (arc_debug_printf): New.
* arc-tdep.c: Use arc_debug_printf.
* arc-linux-nat.c (arc_linux_nat_debug_printf): Add and use.
* arc-linux-tdep.c (arc_linux_debug_printf): Add and use.
* arc-newlib-tdep.c (arc_newlib_debug_printf): Add and use.
2021-01-13 Simon Marchi <simon.marchi@polymtl.ca> 2021-01-13 Simon Marchi <simon.marchi@polymtl.ca>
* arc-tdep.h (arc_debug): Change type to bool. * arc-tdep.h (arc_debug): Change type to bool.

16
gdb/arc-linux-nat.c
View File

@ -46,6 +46,11 @@
/* Defines ps_err_e, struct ps_prochandle. */ /* Defines ps_err_e, struct ps_prochandle. */
#include "gdb_proc_service.h" #include "gdb_proc_service.h"
/* Print an "arc-linux-nat" debug statement. */
#define arc_linux_nat_debug_printf(fmt, ...) \
debug_prefixed_printf_cond (arc_debug, "arc-linux-nat", fmt, ##__VA_ARGS__)
/* Linux starting with 4.12 supports NT_ARC_V2 note type, which adds R30, /* Linux starting with 4.12 supports NT_ARC_V2 note type, which adds R30,
R58 and R59 registers, which are specific to ARC HS and aren't R58 and R59 registers, which are specific to ARC HS and aren't
available in ARC 700. */ available in ARC 700. */
@ -219,9 +224,7 @@ void
fill_fpregset (const struct regcache *regcache, fill_fpregset (const struct regcache *regcache,
gdb_fpregset_t *fpregsetp, int regnum) gdb_fpregset_t *fpregsetp, int regnum)
{ {
if (arc_debug) arc_linux_nat_debug_printf ("called");
debug_printf ("arc-linux-nat: fill_fpregset called.");
return;
} }
/* ARC doesn't have separate FP registers. This function is exported /* ARC doesn't have separate FP registers. This function is exported
@ -230,9 +233,7 @@ fill_fpregset (const struct regcache *regcache,
void void
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{ {
if (arc_debug) arc_linux_nat_debug_printf ("called");
debug_printf ("arc-linux-nat: supply_fpregset called.");
return;
} }
/* Implement the "read_description" method of linux_nat_target. */ /* Implement the "read_description" method of linux_nat_target. */
@ -295,8 +296,7 @@ ps_err_e
ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx, ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx,
void **base) void **base)
{ {
if (arc_debug) arc_linux_nat_debug_printf ("called");
debug_printf ("arc-linux-nat: ps_get_thread_area called");
if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0) if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
return PS_ERR; return PS_ERR;

43
gdb/arc-linux-tdep.c
View File

@ -31,6 +31,11 @@
#include "arc-tdep.h" #include "arc-tdep.h"
#include "arch/arc.h" #include "arch/arc.h"
/* Print an "arc-linux" debug statement. */
#define arc_linux_debug_printf(fmt, ...) \
debug_prefixed_printf_cond (arc_debug, "arc-linux", fmt, ##__VA_ARGS__)
#define REGOFF(offset) (offset * ARC_REGISTER_SIZE) #define REGOFF(offset) (offset * ARC_REGISTER_SIZE)
/* arc_linux_sc_reg_offsets[i] is the offset of register i in the `struct /* arc_linux_sc_reg_offsets[i] is the offset of register i in the `struct
@ -158,11 +163,7 @@ arc_linux_is_sigtramp (struct frame_info *this_frame)
struct gdbarch *gdbarch = get_frame_arch (this_frame); struct gdbarch *gdbarch = get_frame_arch (this_frame);
CORE_ADDR pc = get_frame_pc (this_frame); CORE_ADDR pc = get_frame_pc (this_frame);
if (arc_debug) arc_linux_debug_printf ("pc=%s", paddress(gdbarch, pc));
{
debug_printf ("arc-linux: arc_linux_is_sigtramp, pc=%s\n",
paddress(gdbarch, pc));
}
static const gdb_byte insns_be_hs[] = { static const gdb_byte insns_be_hs[] = {
0x20, 0x8a, 0x12, 0xc2, /* mov r8,nr_rt_sigreturn */ 0x20, 0x8a, 0x12, 0xc2, /* mov r8,nr_rt_sigreturn */
@ -383,15 +384,12 @@ arc_linux_software_single_step (struct regcache *regcache)
regcache_cooked_read_unsigned (regcache, ARC_LP_COUNT_REGNUM, regcache_cooked_read_unsigned (regcache, ARC_LP_COUNT_REGNUM,
&lp_count); &lp_count);
if (arc_debug) arc_linux_debug_printf ("lp_start = %s, lp_end = %s, "
{ "lp_count = %s, next_pc = %s",
debug_printf ("arc-linux: lp_start = %s, lp_end = %s, " paddress (gdbarch, lp_start),
"lp_count = %s, next_pc = %s\n", paddress (gdbarch, lp_end),
paddress (gdbarch, lp_start), pulongest (lp_count),
paddress (gdbarch, lp_end), paddress (gdbarch, next_pc));
pulongest (lp_count),
paddress (gdbarch, next_pc));
}
if (next_pc == lp_end && lp_count > 1) if (next_pc == lp_end && lp_count > 1)
{ {
@ -436,17 +434,13 @@ arc_linux_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
if (resolver.minsym != nullptr) if (resolver.minsym != nullptr)
{ {
CORE_ADDR res_addr = BMSYMBOL_VALUE_ADDRESS (resolver); CORE_ADDR res_addr = BMSYMBOL_VALUE_ADDRESS (resolver);
debug_printf ("arc-linux: skip_solib_resolver (): " arc_linux_debug_printf ("pc = %s, resolver at %s",
"pc = %s, resolver at %s\n", print_core_address (gdbarch, pc),
print_core_address (gdbarch, pc), print_core_address (gdbarch, res_addr));
print_core_address (gdbarch, res_addr));
} }
else else
{ arc_linux_debug_printf ("pc = %s, no resolver found",
debug_printf ("arc-linux: skip_solib_resolver (): " print_core_address (gdbarch, pc));
"pc = %s, no resolver found\n",
print_core_address (gdbarch, pc));
}
} }
if (resolver.minsym != nullptr && BMSYMBOL_VALUE_ADDRESS (resolver) == pc) if (resolver.minsym != nullptr && BMSYMBOL_VALUE_ADDRESS (resolver) == pc)
@ -625,8 +619,7 @@ arc_linux_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (arc_debug) arc_linux_debug_printf ("GNU/Linux OS/ABI initialization.");
debug_printf ("arc-linux: GNU/Linux OS/ABI initialization.\n");
/* Fill in target-dependent info in ARC-private structure. */ /* Fill in target-dependent info in ARC-private structure. */
tdep->is_sigtramp = arc_linux_is_sigtramp; tdep->is_sigtramp = arc_linux_is_sigtramp;

11
gdb/arc-newlib-tdep.c
View File

@ -24,13 +24,17 @@
#include "arc-tdep.h" #include "arc-tdep.h"
#include "osabi.h" #include "osabi.h"
/* Print an "arc-newlib" debug statement. */
#define arc_newlib_debug_printf(fmt, ...) \
debug_prefixed_printf_cond (arc_debug, "arc-newlib", fmt, ##__VA_ARGS__)
/* Implement the 'init_osabi' method of struct gdb_osabi_handler. */ /* Implement the 'init_osabi' method of struct gdb_osabi_handler. */
static void static void
arc_newlib_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch) arc_newlib_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
{ {
if (arc_debug) arc_newlib_debug_printf ("Initialization.");
debug_printf ("arc-newlib: Initialization.\n");
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
@ -44,8 +48,7 @@ arc_newlib_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
static enum gdb_osabi static enum gdb_osabi
arc_newlib_osabi_sniffer (bfd *abfd) arc_newlib_osabi_sniffer (bfd *abfd)
{ {
if (arc_debug) arc_newlib_debug_printf ("OS/ABI sniffer.");
debug_printf ("arc-newlib: OS/ABI sniffer.\n");
/* crt0.S in libgloss for ARC defines .ivt section for interrupt handlers. /* crt0.S in libgloss for ARC defines .ivt section for interrupt handlers.
If this section is not present then this is likely not a newlib - could be If this section is not present then this is likely not a newlib - could be

135
gdb/arc-tdep.c
View File

@ -601,9 +601,8 @@ arc_write_pc (struct regcache *regcache, CORE_ADDR new_pc)
{ {
struct gdbarch *gdbarch = regcache->arch (); struct gdbarch *gdbarch = regcache->arch ();
if (arc_debug) arc_debug_printf ("Writing PC, new value=%s",
debug_printf ("arc: Writing PC, new value=%s\n", paddress (gdbarch, new_pc));
paddress (gdbarch, new_pc));
regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch),
new_pc); new_pc);
@ -614,13 +613,10 @@ arc_write_pc (struct regcache *regcache, CORE_ADDR new_pc)
if ((status32 & ARC_STATUS32_DE_MASK) != 0) if ((status32 & ARC_STATUS32_DE_MASK) != 0)
{ {
if (arc_debug) arc_debug_printf ("Changing PC while in delay slot. Will "
{
debug_printf ("arc: Changing PC while in delay slot. Will "
"reset STATUS32.DE bit to zero. Value of STATUS32 " "reset STATUS32.DE bit to zero. Value of STATUS32 "
"register is 0x%s\n", "register is 0x%s",
phex (status32, ARC_REGISTER_SIZE)); phex (status32, ARC_REGISTER_SIZE));
}
/* Reset bit and write to the cache. */ /* Reset bit and write to the cache. */
status32 &= ~0x40; status32 &= ~0x40;
@ -734,8 +730,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
function_call_return_method return_method, function_call_return_method return_method,
CORE_ADDR struct_addr) CORE_ADDR struct_addr)
{ {
if (arc_debug) arc_debug_printf ("nargs = %d", nargs);
debug_printf ("arc: push_dummy_call (nargs = %d)\n", nargs);
int arg_reg = ARC_FIRST_ARG_REGNUM; int arg_reg = ARC_FIRST_ARG_REGNUM;
@ -751,9 +746,8 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* Pass the return address in the first argument register. */ /* Pass the return address in the first argument register. */
regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr); regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
if (arc_debug) arc_debug_printf ("struct return address %s passed in R%d",
debug_printf ("arc: struct return address %s passed in R%d", print_core_address (gdbarch, struct_addr), arg_reg);
print_core_address (gdbarch, struct_addr), arg_reg);
arg_reg++; arg_reg++;
} }
@ -771,8 +765,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
total_space += space; total_space += space;
if (arc_debug) arc_debug_printf ("arg %d: %u bytes -> %u", i, len, space);
debug_printf ("arc: arg %d: %u bytes -> %u\n", i, len, space);
} }
/* Allocate a buffer to hold a memory image of the arguments. */ /* Allocate a buffer to hold a memory image of the arguments. */
@ -786,9 +779,8 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
unsigned int space = align_up (len, 4); unsigned int space = align_up (len, 4);
memcpy (data, value_contents (args[i]), (size_t) len); memcpy (data, value_contents (args[i]), (size_t) len);
if (arc_debug) arc_debug_printf ("copying arg %d, val 0x%08x, len %d to mem",
debug_printf ("arc: copying arg %d, val 0x%08x, len %d to mem\n", i, *((int *) value_contents (args[i])), len);
i, *((int *) value_contents (args[i])), len);
data += space; data += space;
} }
@ -797,9 +789,8 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
data = memory_image; data = memory_image;
while (arg_reg <= ARC_LAST_ARG_REGNUM) while (arg_reg <= ARC_LAST_ARG_REGNUM)
{ {
if (arc_debug) arc_debug_printf ("passing 0x%02x%02x%02x%02x in register R%d",
debug_printf ("arc: passing 0x%02x%02x%02x%02x in register R%d\n", data[0], data[1], data[2], data[3], arg_reg);
data[0], data[1], data[2], data[3], arg_reg);
/* Note we don't use write_unsigned here, since that would convert /* Note we don't use write_unsigned here, since that would convert
the byte order, but we are already in the correct byte order. */ the byte order, but we are already in the correct byte order. */
@ -819,8 +810,7 @@ arc_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
operation). */ operation). */
if (total_space > 0) if (total_space > 0)
{ {
if (arc_debug) arc_debug_printf ("passing %d bytes on stack\n", total_space);
debug_printf ("arc: passing %d bytes on stack\n", total_space);
sp -= total_space; sp -= total_space;
write_memory (sp, data, (int) total_space); write_memory (sp, data, (int) total_space);
@ -916,8 +906,7 @@ arc_extract_return_value (struct gdbarch *gdbarch, struct type *type,
{ {
unsigned int len = TYPE_LENGTH (type); unsigned int len = TYPE_LENGTH (type);
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: extract_return_value\n");
if (len <= ARC_REGISTER_SIZE) if (len <= ARC_REGISTER_SIZE)
{ {
@ -928,8 +917,7 @@ arc_extract_return_value (struct gdbarch *gdbarch, struct type *type,
store_unsigned_integer (valbuf, (int) len, store_unsigned_integer (valbuf, (int) len,
gdbarch_byte_order (gdbarch), val); gdbarch_byte_order (gdbarch), val);
if (arc_debug) arc_debug_printf ("returning 0x%s", phex (val, ARC_REGISTER_SIZE));
debug_printf ("arc: returning 0x%s\n", phex (val, ARC_REGISTER_SIZE));
} }
else if (len <= ARC_REGISTER_SIZE * 2) else if (len <= ARC_REGISTER_SIZE * 2)
{ {
@ -945,10 +933,9 @@ arc_extract_return_value (struct gdbarch *gdbarch, struct type *type,
(int) len - ARC_REGISTER_SIZE, (int) len - ARC_REGISTER_SIZE,
gdbarch_byte_order (gdbarch), high); gdbarch_byte_order (gdbarch), high);
if (arc_debug) arc_debug_printf ("returning 0x%s%s",
debug_printf ("arc: returning 0x%s%s\n", phex (high, ARC_REGISTER_SIZE),
phex (high, ARC_REGISTER_SIZE), phex (low, ARC_REGISTER_SIZE));
phex (low, ARC_REGISTER_SIZE));
} }
else else
error (_("arc: extract_return_value: type length %u too large"), len); error (_("arc: extract_return_value: type length %u too large"), len);
@ -970,8 +957,7 @@ arc_store_return_value (struct gdbarch *gdbarch, struct type *type,
{ {
unsigned int len = TYPE_LENGTH (type); unsigned int len = TYPE_LENGTH (type);
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: store_return_value\n");
if (len <= ARC_REGISTER_SIZE) if (len <= ARC_REGISTER_SIZE)
{ {
@ -982,8 +968,7 @@ arc_store_return_value (struct gdbarch *gdbarch, struct type *type,
gdbarch_byte_order (gdbarch)); gdbarch_byte_order (gdbarch));
regcache_cooked_write_unsigned (regcache, ARC_R0_REGNUM, val); regcache_cooked_write_unsigned (regcache, ARC_R0_REGNUM, val);
if (arc_debug) arc_debug_printf ("storing 0x%s", phex (val, ARC_REGISTER_SIZE));
debug_printf ("arc: storing 0x%s\n", phex (val, ARC_REGISTER_SIZE));
} }
else if (len <= ARC_REGISTER_SIZE * 2) else if (len <= ARC_REGISTER_SIZE * 2)
{ {
@ -999,10 +984,9 @@ arc_store_return_value (struct gdbarch *gdbarch, struct type *type,
regcache_cooked_write_unsigned (regcache, ARC_R0_REGNUM, low); regcache_cooked_write_unsigned (regcache, ARC_R0_REGNUM, low);
regcache_cooked_write_unsigned (regcache, ARC_R1_REGNUM, high); regcache_cooked_write_unsigned (regcache, ARC_R1_REGNUM, high);
if (arc_debug) arc_debug_printf ("storing 0x%s%s",
debug_printf ("arc: storing 0x%s%s\n", phex (high, ARC_REGISTER_SIZE),
phex (high, ARC_REGISTER_SIZE), phex (low, ARC_REGISTER_SIZE));
phex (low, ARC_REGISTER_SIZE));
} }
else else
error (_("arc_store_return_value: type length too large.")); error (_("arc_store_return_value: type length too large."));
@ -1013,8 +997,7 @@ arc_store_return_value (struct gdbarch *gdbarch, struct type *type,
static int static int
arc_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) arc_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: get_longjmp_target\n");
struct gdbarch *gdbarch = get_frame_arch (frame); struct gdbarch *gdbarch = get_frame_arch (frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
@ -1046,10 +1029,9 @@ arc_return_value (struct gdbarch *gdbarch, struct value *function,
|| valtype->code () == TYPE_CODE_UNION || valtype->code () == TYPE_CODE_UNION
|| TYPE_LENGTH (valtype) > 2 * ARC_REGISTER_SIZE); || TYPE_LENGTH (valtype) > 2 * ARC_REGISTER_SIZE);
if (arc_debug) arc_debug_printf ("readbuf = %s, writebuf = %s",
debug_printf ("arc: return_value (readbuf = %s, writebuf = %s)\n", host_address_to_string (readbuf),
host_address_to_string (readbuf), host_address_to_string (writebuf));
host_address_to_string (writebuf));
if (writebuf != NULL) if (writebuf != NULL)
{ {
@ -1400,10 +1382,9 @@ static CORE_ADDR
arc_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR entrypoint, arc_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR entrypoint,
const CORE_ADDR limit_pc, struct arc_frame_cache *cache) const CORE_ADDR limit_pc, struct arc_frame_cache *cache)
{ {
if (arc_debug) arc_debug_printf ("entrypoint=%s, limit_pc=%s",
debug_printf ("arc: analyze_prologue (entrypoint=%s, limit_pc=%s)\n", paddress (gdbarch, entrypoint),
paddress (gdbarch, entrypoint), paddress (gdbarch, limit_pc));
paddress (gdbarch, limit_pc));
/* Prologue values. Only core registers can be stored. */ /* Prologue values. Only core registers can be stored. */
pv_t regs[ARC_LAST_CORE_REGNUM + 1]; pv_t regs[ARC_LAST_CORE_REGNUM + 1];
@ -1429,9 +1410,8 @@ arc_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR entrypoint,
if (!arc_is_in_prologue (gdbarch, insn, regs, &stack)) if (!arc_is_in_prologue (gdbarch, insn, regs, &stack))
{ {
/* Found an instruction that is not in the prologue. */ /* Found an instruction that is not in the prologue. */
if (arc_debug) arc_debug_printf ("End of prologue reached at address %s",
debug_printf ("arc: End of prologue reached at address %s\n", paddress (gdbarch, insn.address));
paddress (gdbarch, insn.address));
break; break;
} }
@ -1492,8 +1472,7 @@ const static int MAX_PROLOGUE_LENGTH
static CORE_ADDR static CORE_ADDR
arc_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) arc_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: skip_prologue\n");
CORE_ADDR func_addr; CORE_ADDR func_addr;
const char *func_name; const char *func_name;
@ -1665,19 +1644,19 @@ static void
arc_print_frame_cache (struct gdbarch *gdbarch, const char *message, arc_print_frame_cache (struct gdbarch *gdbarch, const char *message,
struct arc_frame_cache *cache, int addresses_known) struct arc_frame_cache *cache, int addresses_known)
{ {
debug_printf ("arc: frame_info %s\n", message); arc_debug_printf ("frame_info %s", message);
debug_printf ("arc: prev_sp = %s\n", paddress (gdbarch, cache->prev_sp)); arc_debug_printf ("prev_sp = %s", paddress (gdbarch, cache->prev_sp));
debug_printf ("arc: frame_base_reg = %i\n", cache->frame_base_reg); arc_debug_printf ("frame_base_reg = %i", cache->frame_base_reg);
debug_printf ("arc: frame_base_offset = %s\n", arc_debug_printf ("frame_base_offset = %s",
plongest (cache->frame_base_offset)); plongest (cache->frame_base_offset));
for (int i = 0; i <= ARC_BLINK_REGNUM; i++) for (int i = 0; i <= ARC_BLINK_REGNUM; i++)
{ {
if (trad_frame_addr_p (cache->saved_regs, i)) if (trad_frame_addr_p (cache->saved_regs, i))
debug_printf ("arc: saved register %s at %s %s\n", arc_debug_printf ("saved register %s at %s %s",
gdbarch_register_name (gdbarch, i), gdbarch_register_name (gdbarch, i),
(addresses_known) ? "address" : "offset", (addresses_known) ? "address" : "offset",
paddress (gdbarch, cache->saved_regs[i].addr ())); paddress (gdbarch, cache->saved_regs[i].addr ()));
} }
} }
@ -1686,8 +1665,7 @@ arc_print_frame_cache (struct gdbarch *gdbarch, const char *message,
static struct arc_frame_cache * static struct arc_frame_cache *
arc_make_frame_cache (struct frame_info *this_frame) arc_make_frame_cache (struct frame_info *this_frame)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: frame_cache\n");
struct gdbarch *gdbarch = get_frame_arch (this_frame); struct gdbarch *gdbarch = get_frame_arch (this_frame);
@ -1755,8 +1733,7 @@ static void
arc_frame_this_id (struct frame_info *this_frame, void **this_cache, arc_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id) struct frame_id *this_id)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: frame_this_id\n");
struct gdbarch *gdbarch = get_frame_arch (this_frame); struct gdbarch *gdbarch = get_frame_arch (this_frame);
@ -1851,8 +1828,7 @@ arc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
static struct arc_frame_cache * static struct arc_frame_cache *
arc_make_sigtramp_frame_cache (struct frame_info *this_frame) arc_make_sigtramp_frame_cache (struct frame_info *this_frame)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: sigtramp_frame_cache\n");
struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame)); struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
@ -1891,8 +1867,7 @@ static void
arc_sigtramp_frame_this_id (struct frame_info *this_frame, arc_sigtramp_frame_this_id (struct frame_info *this_frame,
void **this_cache, struct frame_id *this_id) void **this_cache, struct frame_id *this_id)
{ {
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: sigtramp_frame_this_id\n");
if (*this_cache == NULL) if (*this_cache == NULL)
*this_cache = arc_make_sigtramp_frame_cache (this_frame); *this_cache = arc_make_sigtramp_frame_cache (this_frame);
@ -1911,8 +1886,7 @@ static struct value *
arc_sigtramp_frame_prev_register (struct frame_info *this_frame, arc_sigtramp_frame_prev_register (struct frame_info *this_frame,
void **this_cache, int regnum) void **this_cache, int regnum)
{ {
if (arc_debug) arc_debug_printf ("regnum = %d", regnum);
debug_printf ("arc: sigtramp_frame_prev_register (regnum = %d)\n", regnum);
/* Make sure we've initialized the cache. */ /* Make sure we've initialized the cache. */
if (*this_cache == NULL) if (*this_cache == NULL)
@ -1932,8 +1906,7 @@ arc_sigtramp_frame_sniffer (const struct frame_unwind *self,
{ {
struct gdbarch_tdep *tdep; struct gdbarch_tdep *tdep;
if (arc_debug) arc_debug_printf ("called");
debug_printf ("arc: sigtramp_frame_sniffer\n");
tdep = gdbarch_tdep (get_frame_arch (this_frame)); tdep = gdbarch_tdep (get_frame_arch (this_frame));
@ -2193,8 +2166,7 @@ arc_tdesc_init (struct gdbarch_info info, const struct target_desc **tdesc,
tdesc_arch_data_up *tdesc_data) tdesc_arch_data_up *tdesc_data)
{ {
const struct target_desc *tdesc_loc = info.target_desc; const struct target_desc *tdesc_loc = info.target_desc;
if (arc_debug) arc_debug_printf ("Target description initialization.");
debug_printf ("arc: Target description initialization.\n");
/* If target doesn't provide a description, use the default ones. */ /* If target doesn't provide a description, use the default ones. */
if (!tdesc_has_registers (tdesc_loc)) if (!tdesc_has_registers (tdesc_loc))
@ -2206,8 +2178,7 @@ arc_tdesc_init (struct gdbarch_info info, const struct target_desc **tdesc,
} }
gdb_assert (tdesc_loc != nullptr); gdb_assert (tdesc_loc != nullptr);
if (arc_debug) arc_debug_printf ("Have got a target description");
debug_printf ("arc: Have got a target description\n");
const struct tdesc_feature *feature_core const struct tdesc_feature *feature_core
= tdesc_find_feature (tdesc_loc, ARC_CORE_FEATURE_NAME); = tdesc_find_feature (tdesc_loc, ARC_CORE_FEATURE_NAME);
@ -2253,8 +2224,7 @@ arc_tdesc_init (struct gdbarch_info info, const struct target_desc **tdesc,
if (!valid_p) if (!valid_p)
{ {
if (arc_debug) arc_debug_printf ("Target description is not valid");
debug_printf ("arc: Target description is not valid\n");
return false; return false;
} }
@ -2300,8 +2270,7 @@ arc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
const struct target_desc *tdesc; const struct target_desc *tdesc;
tdesc_arch_data_up tdesc_data; tdesc_arch_data_up tdesc_data;
if (arc_debug) arc_debug_printf ("Architecture initialization.");
debug_printf ("arc: Architecture initialization.\n");
if (!arc_tdesc_init (info, &tdesc, &tdesc_data)) if (!arc_tdesc_init (info, &tdesc, &tdesc_data))
return nullptr; return nullptr;

5
gdb/arc-tdep.h
View File

@ -114,6 +114,11 @@ enum arc_regnum
extern bool arc_debug; extern bool arc_debug;
/* Print an "arc" debug statement. */
#define arc_debug_printf(fmt, ...) \
debug_prefixed_printf_cond (arc_debug, "arc", fmt, ##__VA_ARGS__)
/* Target-dependent information. */ /* Target-dependent information. */
struct gdbarch_tdep struct gdbarch_tdep