/* SPU target-dependent code for GDB, the GNU debugger.
- Copyright (C) 2006-2012 Free Software Foundation, Inc.
+ Copyright (C) 2006-2017 Free Software Foundation, Inc.
Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
Based on a port by Sid Manning <sid@us.ibm.com>.
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "gdbcore.h"
-#include "gdb_string.h"
-#include "gdb_assert.h"
#include "frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
#include "value.h"
#include "inferior.h"
#include "dis-asm.h"
+#include "disasm.h"
#include "objfiles.h"
#include "language.h"
#include "regcache.h"
#include "observer.h"
#include "infcall.h"
#include "dwarf2.h"
-#include "exceptions.h"
+#include "dwarf2-frame.h"
+#include "ax.h"
#include "spu-tdep.h"
-
+#include "location.h"
/* The list of available "set spu " and "show spu " commands. */
static struct cmd_list_element *setspucmdlist = NULL;
gdb_byte reg[32];
char annex[32];
ULONGEST id;
+ ULONGEST ul;
status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
if (status != REG_VALID)
target_read (¤t_target, TARGET_OBJECT_SPU, annex,
reg, 0, sizeof reg);
- store_unsigned_integer (buf, 4, byte_order, strtoulst (reg, NULL, 16));
+ ul = strtoulst ((char *) reg, NULL, 16);
+ store_unsigned_integer (buf, 4, byte_order, ul);
return REG_VALID;
}
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- gdb_byte reg[32];
+ char reg[32];
char annex[32];
ULONGEST id;
xsnprintf (reg, sizeof reg, "0x%s",
phex_nz (extract_unsigned_integer (buf, 4, byte_order), 4));
target_write (¤t_target, TARGET_OBJECT_SPU, annex,
- reg, 0, strlen (reg));
+ (gdb_byte *) reg, 0, strlen (reg));
}
static void
}
}
+static int
+spu_ax_pseudo_register_collect (struct gdbarch *gdbarch,
+ struct agent_expr *ax, int regnum)
+{
+ switch (regnum)
+ {
+ case SPU_SP_REGNUM:
+ ax_reg_mask (ax, SPU_RAW_SP_REGNUM);
+ return 0;
+
+ case SPU_FPSCR_REGNUM:
+ case SPU_SRR0_REGNUM:
+ case SPU_LSLR_REGNUM:
+ case SPU_DECR_REGNUM:
+ case SPU_DECR_STATUS_REGNUM:
+ return -1;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
+ }
+}
+
+static int
+spu_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
+ struct agent_expr *ax, int regnum)
+{
+ switch (regnum)
+ {
+ case SPU_SP_REGNUM:
+ ax_reg (ax, SPU_RAW_SP_REGNUM);
+ return 0;
+
+ case SPU_FPSCR_REGNUM:
+ case SPU_SRR0_REGNUM:
+ case SPU_LSLR_REGNUM:
+ case SPU_DECR_REGNUM:
+ case SPU_DECR_STATUS_REGNUM:
+ return -1;
+
+ default:
+ internal_error (__FILE__, __LINE__, _("invalid regnum"));
+ }
+}
+
+
/* Value conversion -- access scalar values at the preferred slot. */
static struct value *
-spu_value_from_register (struct type *type, int regnum,
- struct frame_info *frame)
+spu_value_from_register (struct gdbarch *gdbarch, struct type *type,
+ int regnum, struct frame_id frame_id)
{
- struct value *value = default_value_from_register (type, regnum, frame);
+ struct value *value = default_value_from_register (gdbarch, type,
+ regnum, frame_id);
+ LONGEST len = TYPE_LENGTH (type);
- if (regnum < SPU_NUM_GPRS && TYPE_LENGTH (type) < 16)
+ if (regnum < SPU_NUM_GPRS && len < 16)
{
- int preferred_slot = TYPE_LENGTH (type) < 4 ? 4 - TYPE_LENGTH (type) : 0;
+ int preferred_slot = len < 4 ? 4 - len : 0;
set_value_offset (value, preferred_slot);
}
return default_register_reggroup_p (gdbarch, regnum, group);
}
+/* DWARF-2 register numbers. */
+
+static int
+spu_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
+{
+ /* Use cooked instead of raw SP. */
+ return (reg == SPU_RAW_SP_REGNUM)? SPU_SP_REGNUM : reg;
+}
+
/* Address handling. */
}
}
-/* Return true if we are in the function's epilogue, i.e. after the
- instruction that destroyed the function's stack frame.
+/* Implement the stack_frame_destroyed_p gdbarch method.
1) scan forward from the point of execution:
a) If you find an instruction that modifies the stack pointer
limit for the size of an epilogue. */
static int
-spu_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+spu_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
gdb_byte buf[16];
if (*this_prologue_cache)
- return *this_prologue_cache;
+ return (struct spu_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct spu_unwind_cache);
*this_prologue_cache = info;
{
/* Keep interrupt enabled state unchanged. */
ULONGEST old_pc;
+
regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &old_pc);
regcache_cooked_write_unsigned (regcache, SPU_PC_REGNUM,
(SPUADDR_ADDR (pc) & -4) | (old_pc & 3));
static struct gdbarch *
spu2ppu_prev_arch (struct frame_info *this_frame, void **this_cache)
{
- struct spu2ppu_cache *cache = *this_cache;
+ struct spu2ppu_cache *cache = (struct spu2ppu_cache *) *this_cache;
return get_regcache_arch (cache->regcache);
}
spu2ppu_this_id (struct frame_info *this_frame,
void **this_cache, struct frame_id *this_id)
{
- struct spu2ppu_cache *cache = *this_cache;
+ struct spu2ppu_cache *cache = (struct spu2ppu_cache *) *this_cache;
*this_id = cache->frame_id;
}
spu2ppu_prev_register (struct frame_info *this_frame,
void **this_cache, int regnum)
{
- struct spu2ppu_cache *cache = *this_cache;
+ struct spu2ppu_cache *cache = (struct spu2ppu_cache *) *this_cache;
struct gdbarch *gdbarch = get_regcache_arch (cache->regcache);
gdb_byte *buf;
- buf = alloca (register_size (gdbarch, regnum));
+ buf = (gdb_byte *) alloca (register_size (gdbarch, regnum));
regcache_cooked_read (cache->regcache, regnum, buf);
return frame_unwind_got_bytes (this_frame, regnum, buf);
}
CORE_ADDR base, func, backchain;
gdb_byte buf[4];
- if (gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_spu)
+ if (gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_spu)
return 0;
base = get_frame_sp (this_frame);
else
{
struct regcache *regcache;
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+ regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
cache->regcache = regcache_dup (regcache);
*this_prologue_cache = cache;
return 1;
static void
spu2ppu_dealloc_cache (struct frame_info *self, void *this_cache)
{
- struct spu2ppu_cache *cache = this_cache;
+ struct spu2ppu_cache *cache = (struct spu2ppu_cache *) this_cache;
regcache_xfree (cache->regcache);
}
case TYPE_CODE_BOOL:
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
+ case TYPE_CODE_RVALUE_REF:
return TYPE_LENGTH (type) <= 16;
default:
/* Breakpoints. */
+constexpr gdb_byte spu_break_insn[] = { 0x00, 0x00, 0x3f, 0xff };
-static const gdb_byte *
-spu_breakpoint_from_pc (struct gdbarch *gdbarch,
- CORE_ADDR * pcptr, int *lenptr)
-{
- static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
-
- *lenptr = sizeof breakpoint;
- return breakpoint;
-}
+typedef BP_MANIPULATION (spu_break_insn) spu_breakpoint;
static int
spu_memory_remove_breakpoint (struct gdbarch *gdbarch,
/* Software single-stepping support. */
-static int
-spu_software_single_step (struct frame_info *frame)
+static VEC (CORE_ADDR) *
+spu_software_single_step (struct regcache *regcache)
{
- struct gdbarch *gdbarch = get_frame_arch (frame);
- struct address_space *aspace = get_frame_address_space (frame);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR pc, next_pc;
unsigned int insn;
int offset, reg;
gdb_byte buf[4];
ULONGEST lslr;
+ VEC (CORE_ADDR) *next_pcs = NULL;
- pc = get_frame_pc (frame);
+ pc = regcache_read_pc (regcache);
if (target_read_memory (pc, buf, 4))
- return 1;
+ throw_error (MEMORY_ERROR, _("Could not read instruction at %s."),
+ paddress (gdbarch, pc));
+
insn = extract_unsigned_integer (buf, 4, byte_order);
/* Get local store limit. */
- lslr = get_frame_register_unsigned (frame, SPU_LSLR_REGNUM);
+ lslr = regcache_raw_get_unsigned (regcache, SPU_LSLR_REGNUM);
if (!lslr)
lslr = (ULONGEST) -1;
else
next_pc = (SPUADDR_ADDR (pc) + 4) & lslr;
- insert_single_step_breakpoint (gdbarch,
- aspace, SPUADDR (SPUADDR_SPU (pc), next_pc));
+ VEC_safe_push (CORE_ADDR, next_pcs, SPUADDR (SPUADDR_SPU (pc), next_pc));
if (is_branch (insn, &offset, ®))
{
if (reg == SPU_PC_REGNUM)
target += SPUADDR_ADDR (pc);
else if (reg != -1)
- {
- int optim, unavail;
-
- if (get_frame_register_bytes (frame, reg, 0, 4, buf,
- &optim, &unavail))
- target += extract_unsigned_integer (buf, 4, byte_order) & -4;
- else
- {
- if (optim)
- error (_("Could not determine address of "
- "single-step breakpoint."));
- if (unavail)
- throw_error (NOT_AVAILABLE_ERROR,
- _("Could not determine address of "
- "single-step breakpoint."));
- }
- }
+ target += regcache_raw_get_unsigned (regcache, reg) & -4;
target = target & lslr;
if (target != next_pc)
- insert_single_step_breakpoint (gdbarch, aspace,
- SPUADDR (SPUADDR_SPU (pc), target));
+ VEC_safe_push (CORE_ADDR, next_pcs, SPUADDR (SPUADDR_SPU (pc),
+ target));
}
- return 1;
+ return next_pcs;
}
/* Disassembler. */
-struct spu_dis_asm_data
+struct spu_dis_asm_info : disassemble_info
{
- struct gdbarch *gdbarch;
int id;
};
static void
spu_dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
{
- struct spu_dis_asm_data *data = info->application_data;
- print_address (data->gdbarch, SPUADDR (data->id, addr), info->stream);
+ struct spu_dis_asm_info *data = (struct spu_dis_asm_info *) info;
+ gdb_disassembler *di
+ = static_cast<gdb_disassembler *>(info->application_data);
+
+ print_address (di->arch (), SPUADDR (data->id, addr),
+ (struct ui_file *) info->stream);
}
static int
/* The opcodes disassembler does 18-bit address arithmetic. Make
sure the SPU ID encoded in the high bits is added back when we
call print_address. */
- struct disassemble_info spu_info = *info;
- struct spu_dis_asm_data data;
- data.gdbarch = info->application_data;
- data.id = SPUADDR_SPU (memaddr);
+ struct spu_dis_asm_info spu_info;
- spu_info.application_data = &data;
+ memcpy (&spu_info, info, sizeof (*info));
+ spu_info.id = SPUADDR_SPU (memaddr);
spu_info.print_address_func = spu_dis_asm_print_address;
return print_insn_spu (memaddr, &spu_info);
}
{
enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
- struct minimal_symbol *ovly_table_msym, *ovly_buf_table_msym;
+ struct bound_minimal_symbol ovly_table_msym, ovly_buf_table_msym;
CORE_ADDR ovly_table_base, ovly_buf_table_base;
unsigned ovly_table_size, ovly_buf_table_size;
struct spu_overlay_table *tbl;
struct obj_section *osect;
- char *ovly_table;
+ gdb_byte *ovly_table;
int i;
- tbl = objfile_data (objfile, spu_overlay_data);
+ tbl = (struct spu_overlay_table *) objfile_data (objfile, spu_overlay_data);
if (tbl)
return tbl;
ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, objfile);
- if (!ovly_table_msym)
+ if (!ovly_table_msym.minsym)
return NULL;
ovly_buf_table_msym = lookup_minimal_symbol ("_ovly_buf_table",
NULL, objfile);
- if (!ovly_buf_table_msym)
+ if (!ovly_buf_table_msym.minsym)
return NULL;
- ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
- ovly_table_size = MSYMBOL_SIZE (ovly_table_msym);
+ ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym);
+ ovly_table_size = MSYMBOL_SIZE (ovly_table_msym.minsym);
- ovly_buf_table_base = SYMBOL_VALUE_ADDRESS (ovly_buf_table_msym);
- ovly_buf_table_size = MSYMBOL_SIZE (ovly_buf_table_msym);
+ ovly_buf_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_buf_table_msym);
+ ovly_buf_table_size = MSYMBOL_SIZE (ovly_buf_table_msym.minsym);
- ovly_table = xmalloc (ovly_table_size);
+ ovly_table = (gdb_byte *) xmalloc (ovly_table_size);
read_memory (ovly_table_base, ovly_table, ovly_table_size);
tbl = OBSTACK_CALLOC (&objfile->objfile_obstack,
static void
spu_catch_start (struct objfile *objfile)
{
- struct minimal_symbol *minsym;
- struct symtab *symtab;
+ struct bound_minimal_symbol minsym;
+ struct compunit_symtab *cust;
CORE_ADDR pc;
- char buf[32];
+ struct event_location *location;
+ struct cleanup *back_to;
/* Do this only if requested by "set spu stop-on-load on". */
if (!spu_stop_on_load_p)
/* There can be multiple symbols named "main". Search for the
"main" in *this* objfile. */
minsym = lookup_minimal_symbol ("main", NULL, objfile);
- if (!minsym)
+ if (!minsym.minsym)
return;
/* If we have debugging information, try to use it -- this
will allow us to properly skip the prologue. */
- pc = SYMBOL_VALUE_ADDRESS (minsym);
- symtab = find_pc_sect_symtab (pc, SYMBOL_OBJ_SECTION (minsym));
- if (symtab != NULL)
+ pc = BMSYMBOL_VALUE_ADDRESS (minsym);
+ cust
+ = find_pc_sect_compunit_symtab (pc, MSYMBOL_OBJ_SECTION (minsym.objfile,
+ minsym.minsym));
+ if (cust != NULL)
{
- struct blockvector *bv = BLOCKVECTOR (symtab);
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
struct symbol *sym;
struct symtab_and_line sal;
- sym = lookup_block_symbol (block, "main", VAR_DOMAIN);
+ sym = block_lookup_symbol (block, "main", VAR_DOMAIN);
if (sym)
{
fixup_symbol_section (sym, objfile);
/* Use a numerical address for the set_breakpoint command to avoid having
the breakpoint re-set incorrectly. */
- xsnprintf (buf, sizeof buf, "*%s", core_addr_to_string (pc));
- create_breakpoint (get_objfile_arch (objfile), buf /* arg */,
+ location = new_address_location (pc, NULL, 0);
+ back_to = make_cleanup_delete_event_location (location);
+ create_breakpoint (get_objfile_arch (objfile), location,
NULL /* cond_string */, -1 /* thread */,
NULL /* extra_string */,
0 /* parse_condition_and_thread */, 1 /* tempflag */,
AUTO_BOOLEAN_FALSE /* pending_break_support */,
&bkpt_breakpoint_ops /* ops */, 0 /* from_tty */,
1 /* enabled */, 0 /* internal */, 0);
+ do_cleanups (back_to);
}
static void
flush_ea_cache (void)
{
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
struct objfile *obj;
if (!has_stack_frames ())
/* Lookup inferior function __cache_flush. */
msymbol = lookup_minimal_symbol ("__cache_flush", NULL, obj);
- if (msymbol != NULL)
+ if (msymbol.minsym != NULL)
{
struct type *type;
CORE_ADDR addr;
type = objfile_type (obj)->builtin_void;
type = lookup_function_type (type);
type = lookup_pointer_type (type);
- addr = SYMBOL_VALUE_ADDRESS (msymbol);
+ addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
call_function_by_hand (value_from_pointer (type, addr), 0, NULL);
}
if (len <= 0)
error (_("Could not read event_status."));
buf[len] = '\0';
- event_status = strtoulst (buf, NULL, 16);
+ event_status = strtoulst ((char *) buf, NULL, 16);
xsnprintf (annex, sizeof annex, "%d/event_mask", id);
len = target_read (¤t_target, TARGET_OBJECT_SPU, annex,
if (len <= 0)
error (_("Could not read event_mask."));
buf[len] = '\0';
- event_mask = strtoulst (buf, NULL, 16);
+ event_mask = strtoulst ((char *) buf, NULL, 16);
chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoEvent");
- if (ui_out_is_mi_like_p (current_uiout))
+ if (current_uiout->is_mi_like_p ())
{
- ui_out_field_fmt (current_uiout, "event_status",
- "0x%s", phex_nz (event_status, 4));
- ui_out_field_fmt (current_uiout, "event_mask",
- "0x%s", phex_nz (event_mask, 4));
+ current_uiout->field_fmt ("event_status",
+ "0x%s", phex_nz (event_status, 4));
+ current_uiout->field_fmt ("event_mask",
+ "0x%s", phex_nz (event_mask, 4));
}
else
{
if (len <= 0)
error (_("Could not read signal1_type."));
buf[len] = '\0';
- signal1_type = strtoulst (buf, NULL, 16);
+ signal1_type = strtoulst ((char *) buf, NULL, 16);
xsnprintf (annex, sizeof annex, "%d/signal2", id);
len = target_read (¤t_target, TARGET_OBJECT_SPU, annex, buf, 0, 4);
if (len <= 0)
error (_("Could not read signal2_type."));
buf[len] = '\0';
- signal2_type = strtoulst (buf, NULL, 16);
+ signal2_type = strtoulst ((char *) buf, NULL, 16);
chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoSignal");
- if (ui_out_is_mi_like_p (current_uiout))
+ if (current_uiout->is_mi_like_p ())
{
- ui_out_field_int (current_uiout, "signal1_pending", signal1_pending);
- ui_out_field_fmt (current_uiout, "signal1", "0x%s", phex_nz (signal1, 4));
- ui_out_field_int (current_uiout, "signal1_type", signal1_type);
- ui_out_field_int (current_uiout, "signal2_pending", signal2_pending);
- ui_out_field_fmt (current_uiout, "signal2", "0x%s", phex_nz (signal2, 4));
- ui_out_field_int (current_uiout, "signal2_type", signal2_type);
+ current_uiout->field_int ("signal1_pending", signal1_pending);
+ current_uiout->field_fmt ("signal1", "0x%s", phex_nz (signal1, 4));
+ current_uiout->field_int ("signal1_type", signal1_type);
+ current_uiout->field_int ("signal2_pending", signal2_pending);
+ current_uiout->field_fmt ("signal2", "0x%s", phex_nz (signal2, 4));
+ current_uiout->field_int ("signal2_type", signal2_type);
}
else
{
chain = make_cleanup_ui_out_table_begin_end (current_uiout, 1, nr, "mbox");
- ui_out_table_header (current_uiout, 32, ui_left, field, msg);
- ui_out_table_body (current_uiout);
+ current_uiout->table_header (32, ui_left, field, msg);
+ current_uiout->table_body ();
for (i = 0; i < nr; i++)
{
ULONGEST val;
val_chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "mbox");
val = extract_unsigned_integer (buf + 4*i, 4, byte_order);
- ui_out_field_fmt (current_uiout, field, "0x%s", phex (val, 4));
+ current_uiout->field_fmt (field, "0x%s", phex (val, 4));
do_cleanups (val_chain);
- if (!ui_out_is_mi_like_p (current_uiout))
+ if (!current_uiout->is_mi_like_p ())
printf_filtered ("\n");
}
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
};
- int *seq = alloca (nr * sizeof (int));
+ int *seq = XALLOCAVEC (int, nr);
int done = 0;
struct cleanup *chain;
int i, j;
chain = make_cleanup_ui_out_table_begin_end (current_uiout, 10, nr,
"dma_cmd");
- ui_out_table_header (current_uiout, 7, ui_left, "opcode", "Opcode");
- ui_out_table_header (current_uiout, 3, ui_left, "tag", "Tag");
- ui_out_table_header (current_uiout, 3, ui_left, "tid", "TId");
- ui_out_table_header (current_uiout, 3, ui_left, "rid", "RId");
- ui_out_table_header (current_uiout, 18, ui_left, "ea", "EA");
- ui_out_table_header (current_uiout, 7, ui_left, "lsa", "LSA");
- ui_out_table_header (current_uiout, 7, ui_left, "size", "Size");
- ui_out_table_header (current_uiout, 7, ui_left, "lstaddr", "LstAddr");
- ui_out_table_header (current_uiout, 7, ui_left, "lstsize", "LstSize");
- ui_out_table_header (current_uiout, 1, ui_left, "error_p", "E");
+ current_uiout->table_header (7, ui_left, "opcode", "Opcode");
+ current_uiout->table_header (3, ui_left, "tag", "Tag");
+ current_uiout->table_header (3, ui_left, "tid", "TId");
+ current_uiout->table_header (3, ui_left, "rid", "RId");
+ current_uiout->table_header (18, ui_left, "ea", "EA");
+ current_uiout->table_header (7, ui_left, "lsa", "LSA");
+ current_uiout->table_header (7, ui_left, "size", "Size");
+ current_uiout->table_header (7, ui_left, "lstaddr", "LstAddr");
+ current_uiout->table_header (7, ui_left, "lstsize", "LstSize");
+ current_uiout->table_header (1, ui_left, "error_p", "E");
- ui_out_table_body (current_uiout);
+ current_uiout->table_body ();
for (i = 0; i < nr; i++)
{
int mfc_cmd_opcode, mfc_cmd_tag, rclass_id, tclass_id;
int list_lsa, list_size, mfc_lsa, mfc_size;
ULONGEST mfc_ea;
- int list_valid_p, noop_valid_p, qw_valid_p, ea_valid_p, cmd_error_p;
+ int list_valid_p, qw_valid_p, ea_valid_p, cmd_error_p;
/* Decode contents of MFC Command Queue Context Save/Restore Registers.
See "Cell Broadband Engine Registers V1.3", section 3.3.2.1. */
mfc_lsa = spu_mfc_get_bitfield (mfc_cq_dw2, 0, 13);
mfc_size = spu_mfc_get_bitfield (mfc_cq_dw2, 14, 24);
- noop_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 37, 37);
qw_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 38, 38);
ea_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 39, 39);
cmd_error_p = spu_mfc_get_bitfield (mfc_cq_dw2, 40, 40);
cmd_chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "cmd");
if (spu_mfc_opcode[mfc_cmd_opcode])
- ui_out_field_string (current_uiout, "opcode", spu_mfc_opcode[mfc_cmd_opcode]);
+ current_uiout->field_string ("opcode", spu_mfc_opcode[mfc_cmd_opcode]);
else
- ui_out_field_int (current_uiout, "opcode", mfc_cmd_opcode);
+ current_uiout->field_int ("opcode", mfc_cmd_opcode);
- ui_out_field_int (current_uiout, "tag", mfc_cmd_tag);
- ui_out_field_int (current_uiout, "tid", tclass_id);
- ui_out_field_int (current_uiout, "rid", rclass_id);
+ current_uiout->field_int ("tag", mfc_cmd_tag);
+ current_uiout->field_int ("tid", tclass_id);
+ current_uiout->field_int ("rid", rclass_id);
if (ea_valid_p)
- ui_out_field_fmt (current_uiout, "ea", "0x%s", phex (mfc_ea, 8));
+ current_uiout->field_fmt ("ea", "0x%s", phex (mfc_ea, 8));
else
- ui_out_field_skip (current_uiout, "ea");
+ current_uiout->field_skip ("ea");
- ui_out_field_fmt (current_uiout, "lsa", "0x%05x", mfc_lsa << 4);
+ current_uiout->field_fmt ("lsa", "0x%05x", mfc_lsa << 4);
if (qw_valid_p)
- ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size << 4);
+ current_uiout->field_fmt ("size", "0x%05x", mfc_size << 4);
else
- ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size);
+ current_uiout->field_fmt ("size", "0x%05x", mfc_size);
if (list_valid_p)
{
- ui_out_field_fmt (current_uiout, "lstaddr", "0x%05x", list_lsa << 3);
- ui_out_field_fmt (current_uiout, "lstsize", "0x%05x", list_size << 3);
+ current_uiout->field_fmt ("lstaddr", "0x%05x", list_lsa << 3);
+ current_uiout->field_fmt ("lstsize", "0x%05x", list_size << 3);
}
else
{
- ui_out_field_skip (current_uiout, "lstaddr");
- ui_out_field_skip (current_uiout, "lstsize");
+ current_uiout->field_skip ("lstaddr");
+ current_uiout->field_skip ("lstsize");
}
if (cmd_error_p)
- ui_out_field_string (current_uiout, "error_p", "*");
+ current_uiout->field_string ("error_p", "*");
else
- ui_out_field_skip (current_uiout, "error_p");
+ current_uiout->field_skip ("error_p");
do_cleanups (cmd_chain);
- if (!ui_out_is_mi_like_p (current_uiout))
+ if (!current_uiout->is_mi_like_p ())
printf_filtered ("\n");
}
chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoDMA");
- if (ui_out_is_mi_like_p (current_uiout))
+ if (current_uiout->is_mi_like_p ())
{
- ui_out_field_fmt (current_uiout, "dma_info_type", "0x%s",
- phex_nz (dma_info_type, 4));
- ui_out_field_fmt (current_uiout, "dma_info_mask", "0x%s",
- phex_nz (dma_info_mask, 4));
- ui_out_field_fmt (current_uiout, "dma_info_status", "0x%s",
- phex_nz (dma_info_status, 4));
- ui_out_field_fmt (current_uiout, "dma_info_stall_and_notify", "0x%s",
- phex_nz (dma_info_stall_and_notify, 4));
- ui_out_field_fmt (current_uiout, "dma_info_atomic_command_status", "0x%s",
- phex_nz (dma_info_atomic_command_status, 4));
+ current_uiout->field_fmt ("dma_info_type", "0x%s",
+ phex_nz (dma_info_type, 4));
+ current_uiout->field_fmt ("dma_info_mask", "0x%s",
+ phex_nz (dma_info_mask, 4));
+ current_uiout->field_fmt ("dma_info_status", "0x%s",
+ phex_nz (dma_info_status, 4));
+ current_uiout->field_fmt ("dma_info_stall_and_notify", "0x%s",
+ phex_nz (dma_info_stall_and_notify, 4));
+ current_uiout->field_fmt ("dma_info_atomic_command_status", "0x%s",
+ phex_nz (dma_info_atomic_command_status, 4));
}
else
{
chain = make_cleanup_ui_out_tuple_begin_end (current_uiout,
"SPUInfoProxyDMA");
- if (ui_out_is_mi_like_p (current_uiout))
+ if (current_uiout->is_mi_like_p ())
{
- ui_out_field_fmt (current_uiout, "proxydma_info_type", "0x%s",
- phex_nz (dma_info_type, 4));
- ui_out_field_fmt (current_uiout, "proxydma_info_mask", "0x%s",
- phex_nz (dma_info_mask, 4));
- ui_out_field_fmt (current_uiout, "proxydma_info_status", "0x%s",
- phex_nz (dma_info_status, 4));
+ current_uiout->field_fmt ("proxydma_info_type", "0x%s",
+ phex_nz (dma_info_type, 4));
+ current_uiout->field_fmt ("proxydma_info_mask", "0x%s",
+ phex_nz (dma_info_mask, 4));
+ current_uiout->field_fmt ("proxydma_info_status", "0x%s",
+ phex_nz (dma_info_status, 4));
}
else
{
{
printf_unfiltered (_("\"info spu\" must be followed by "
"the name of an SPU facility.\n"));
- help_list (infospucmdlist, "info spu ", -1, gdb_stdout);
+ help_list (infospucmdlist, "info spu ", all_commands, gdb_stdout);
}
This assumes the filename convention employed by solib-spu.c. */
else if (info.abfd)
{
- char *name = strrchr (info.abfd->filename, '@');
+ const char *name = strrchr (info.abfd->filename, '@');
if (name)
sscanf (name, "@0x%*x <%d>", &id);
}
}
/* None found, so create a new architecture. */
- tdep = XCALLOC (1, struct gdbarch_tdep);
+ tdep = XCNEW (struct gdbarch_tdep);
tdep->id = id;
gdbarch = gdbarch_alloc (&info, tdep);
set_gdbarch_pseudo_register_write (gdbarch, spu_pseudo_register_write);
set_gdbarch_value_from_register (gdbarch, spu_value_from_register);
set_gdbarch_register_reggroup_p (gdbarch, spu_register_reggroup_p);
+ set_gdbarch_dwarf2_reg_to_regnum (gdbarch, spu_dwarf_reg_to_regnum);
+ set_gdbarch_ax_pseudo_register_collect
+ (gdbarch, spu_ax_pseudo_register_collect);
+ set_gdbarch_ax_pseudo_register_push_stack
+ (gdbarch, spu_ax_pseudo_register_push_stack);
/* Data types. */
set_gdbarch_char_signed (gdbarch, 0);
/* Frame handling. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+ dwarf2_append_unwinders (gdbarch);
frame_unwind_append_unwinder (gdbarch, &spu_frame_unwind);
frame_base_set_default (gdbarch, &spu_frame_base);
set_gdbarch_unwind_pc (gdbarch, spu_unwind_pc);
set_gdbarch_virtual_frame_pointer (gdbarch, spu_virtual_frame_pointer);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_skip_prologue (gdbarch, spu_skip_prologue);
- set_gdbarch_in_function_epilogue_p (gdbarch, spu_in_function_epilogue_p);
+ set_gdbarch_stack_frame_destroyed_p (gdbarch, spu_stack_frame_destroyed_p);
/* Cell/B.E. cross-architecture unwinder support. */
frame_unwind_prepend_unwinder (gdbarch, &spu2ppu_unwind);
/* Breakpoints. */
set_gdbarch_decr_pc_after_break (gdbarch, 4);
- set_gdbarch_breakpoint_from_pc (gdbarch, spu_breakpoint_from_pc);
+ set_gdbarch_breakpoint_kind_from_pc (gdbarch, spu_breakpoint::kind_from_pc);
+ set_gdbarch_sw_breakpoint_from_kind (gdbarch, spu_breakpoint::bp_from_kind);
set_gdbarch_memory_remove_breakpoint (gdbarch, spu_memory_remove_breakpoint);
- set_gdbarch_cannot_step_breakpoint (gdbarch, 1);
set_gdbarch_software_single_step (gdbarch, spu_software_single_step);
set_gdbarch_get_longjmp_target (gdbarch, spu_get_longjmp_target);