/* SPU target-dependent code for GDB, the GNU debugger.
- Copyright (C) 2006-2012 Free Software Foundation, Inc.
+ Copyright (C) 2006-2013 Free Software Foundation, Inc.
Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
Based on a port by Sid Manning <sid@us.ibm.com>.
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
CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
bfd_byte buf[4];
unsigned int insn;
- int rt, ra, rb, rc, immed;
+ int rt, ra, rb, immed;
/* Find the search limits based on function boundaries and hard limit.
We assume the epilogue can be up to 64 instructions long. */
{
/* 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));
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;
struct value *arg = args[i];
struct type *type = check_typedef (value_type (arg));
const gdb_byte *contents = value_contents (arg);
- int len = TYPE_LENGTH (type);
- int n_regs = align_up (len, 16) / 16;
+ int n_regs = align_up (TYPE_LENGTH (type), 16) / 16;
/* If the argument doesn't wholly fit into registers, it and
all subsequent arguments go to the stack. */
/* Function return value access. */
static enum return_value_convention
-spu_return_value (struct gdbarch *gdbarch, struct type *func_type,
+spu_return_value (struct gdbarch *gdbarch, struct value *function,
struct type *type, struct regcache *regcache,
gdb_byte *out, const gdb_byte *in)
{
+ struct type *func_type = function ? value_type (function) : NULL;
enum return_value_convention rvc;
int opencl_vector = 0;
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);
/* 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));
+ symtab = find_pc_sect_symtab (pc, SYMBOL_OBJ_SECTION (objfile, minsym));
if (symtab != NULL)
{
struct blockvector *bv = BLOCKVECTOR (symtab);
gdb_byte buf[100];
char annex[32];
LONGEST len;
- int rc, id;
+ int id;
if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
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");
char annex[32];
gdb_byte buf[100];
LONGEST len;
- int rc, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
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");
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
ULONGEST mfc_cq_dw1;
ULONGEST mfc_cq_dw2;
int mfc_cmd_opcode, mfc_cmd_tag, rclass_id, tclass_id;
- int lsa, size, list_lsa, list_size, mfc_lsa, mfc_size;
+ 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;
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
char annex[32];
gdb_byte buf[1024];
LONGEST len;
- int i, id;
+ int id;
if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
error (_("\"info spu\" is only supported on the SPU architecture."));
projects / deliverable / binutils-gdb.git / blobdiff