X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fspu-tdep.c;h=f62e8e76b6c5b84f910a16cc9c0b01a7a56a1fb4;hb=d66ff635bec25bf940cc6d173a92f7796f18b310;hp=d42465986884defb5bddab2a739a6ff15f68679c;hpb=c378eb4eaae2baecb17b41ba928daf9dc74b1aab;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index d424659868..f62e8e76b6 100644 --- a/gdb/spu-tdep.c +++ b/gdb/spu-tdep.c @@ -1,6 +1,5 @@ /* SPU target-dependent code for GDB, the GNU debugger. - Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 2006-2016 Free Software Foundation, Inc. Contributed by Ulrich Weigand . Based on a port by Sid Manning . @@ -25,8 +24,6 @@ #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" @@ -44,9 +41,11 @@ #include "block.h" #include "observer.h" #include "infcall.h" - +#include "dwarf2.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; @@ -182,61 +181,68 @@ spu_register_type (struct gdbarch *gdbarch, int reg_nr) /* Pseudo registers for preferred slots - stack pointer. */ -static void +static enum register_status spu_pseudo_register_read_spu (struct regcache *regcache, const char *regname, gdb_byte *buf) { struct gdbarch *gdbarch = get_regcache_arch (regcache); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum register_status status; gdb_byte reg[32]; char annex[32]; ULONGEST id; + ULONGEST ul; - regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + if (status != REG_VALID) + return status; xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname); memset (reg, 0, sizeof reg); 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; } -static void +static enum register_status spu_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int regnum, gdb_byte *buf) { gdb_byte reg[16]; char annex[32]; ULONGEST id; + enum register_status status; switch (regnum) { case SPU_SP_REGNUM: - regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg); + status = regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg); + if (status != REG_VALID) + return status; memcpy (buf, reg, 4); - break; + return status; case SPU_FPSCR_REGNUM: - regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + if (status != REG_VALID) + return status; xsnprintf (annex, sizeof annex, "%d/fpcr", (int) id); target_read (¤t_target, TARGET_OBJECT_SPU, annex, buf, 0, 16); - break; + return status; case SPU_SRR0_REGNUM: - spu_pseudo_register_read_spu (regcache, "srr0", buf); - break; + return spu_pseudo_register_read_spu (regcache, "srr0", buf); case SPU_LSLR_REGNUM: - spu_pseudo_register_read_spu (regcache, "lslr", buf); - break; + return spu_pseudo_register_read_spu (regcache, "lslr", buf); case SPU_DECR_REGNUM: - spu_pseudo_register_read_spu (regcache, "decr", buf); - break; + return spu_pseudo_register_read_spu (regcache, "decr", buf); case SPU_DECR_STATUS_REGNUM: - spu_pseudo_register_read_spu (regcache, "decr_status", buf); - break; + return spu_pseudo_register_read_spu (regcache, "decr_status", buf); default: internal_error (__FILE__, __LINE__, _("invalid regnum")); @@ -249,7 +255,7 @@ spu_pseudo_register_write_spu (struct regcache *regcache, const char *regname, { 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; @@ -258,7 +264,7 @@ spu_pseudo_register_write_spu (struct regcache *regcache, const char *regname, 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 @@ -304,14 +310,60 @@ spu_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, } } +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); - int len = TYPE_LENGTH (type); + struct value *value = default_value_from_register (gdbarch, type, + regnum, frame_id); + LONGEST len = TYPE_LENGTH (type); if (regnum < SPU_NUM_GPRS && len < 16) { @@ -344,6 +396,15 @@ spu_register_reggroup_p (struct gdbarch *gdbarch, int regnum, 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. */ @@ -354,7 +415,7 @@ spu_gdbarch_id (struct gdbarch *gdbarch) int id = tdep->id; /* The objfile architecture of a standalone SPU executable does not - provide an SPU ID. Retrieve it from the the objfile's relocated + provide an SPU ID. Retrieve it from the objfile's relocated address range in this special case. */ if (id == -1 && symfile_objfile && symfile_objfile->obfd @@ -450,7 +511,7 @@ enum op_a = 0x0c0, op_ai = 0x1c, - op_selb = 0x4, + op_selb = 0x8, op_br = 0x64, op_bra = 0x60, @@ -820,8 +881,7 @@ spu_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, } } -/* 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 @@ -838,13 +898,13 @@ spu_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, 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; 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. */ @@ -940,7 +1000,7 @@ spu_frame_unwind_cache (struct frame_info *this_frame, 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; @@ -1076,6 +1136,7 @@ spu_frame_prev_register (struct frame_info *this_frame, static const struct frame_unwind spu_frame_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, spu_frame_this_id, spu_frame_prev_register, NULL, @@ -1129,6 +1190,7 @@ spu_write_pc (struct regcache *regcache, CORE_ADDR pc) { /* 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)); @@ -1146,7 +1208,7 @@ struct spu2ppu_cache 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); } @@ -1154,7 +1216,7 @@ static void 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; } @@ -1162,11 +1224,11 @@ static struct value * 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); } @@ -1180,7 +1242,7 @@ spu2ppu_sniffer (const struct frame_unwind *self, 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); @@ -1211,7 +1273,7 @@ spu2ppu_sniffer (const struct frame_unwind *self, 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; @@ -1224,12 +1286,13 @@ spu2ppu_sniffer (const struct frame_unwind *self, 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); } static const struct frame_unwind spu2ppu_unwind = { ARCH_FRAME, + default_frame_unwind_stop_reason, spu2ppu_this_id, spu2ppu_prev_register, NULL, @@ -1366,8 +1429,7 @@ spu_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 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. */ @@ -1443,11 +1505,27 @@ spu_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) /* 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; + + if (func_type) + { + func_type = check_typedef (func_type); + + if (TYPE_CODE (func_type) == TYPE_CODE_PTR) + func_type = check_typedef (TYPE_TARGET_TYPE (func_type)); + + if (TYPE_CODE (func_type) == TYPE_CODE_FUNC + && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GDB_IBM_OpenCL + && TYPE_CODE (type) == TYPE_CODE_ARRAY + && TYPE_VECTOR (type)) + opencl_vector = 1; + } if (TYPE_LENGTH (type) <= (SPU_ARGN_REGNUM - SPU_ARG1_REGNUM + 1) * 16) rvc = RETURN_VALUE_REGISTER_CONVENTION; @@ -1459,7 +1537,10 @@ spu_return_value (struct gdbarch *gdbarch, struct type *func_type, switch (rvc) { case RETURN_VALUE_REGISTER_CONVENTION: - spu_value_to_regcache (regcache, SPU_ARG1_REGNUM, type, in); + if (opencl_vector && TYPE_LENGTH (type) == 2) + regcache_cooked_write_part (regcache, SPU_ARG1_REGNUM, 2, 2, in); + else + spu_value_to_regcache (regcache, SPU_ARG1_REGNUM, type, in); break; case RETURN_VALUE_STRUCT_CONVENTION: @@ -1472,7 +1553,10 @@ spu_return_value (struct gdbarch *gdbarch, struct type *func_type, switch (rvc) { case RETURN_VALUE_REGISTER_CONVENTION: - spu_regcache_to_value (regcache, SPU_ARG1_REGNUM, type, out); + if (opencl_vector && TYPE_LENGTH (type) == 2) + regcache_cooked_read_part (regcache, SPU_ARG1_REGNUM, 2, 2, out); + else + spu_regcache_to_value (regcache, SPU_ARG1_REGNUM, type, out); break; case RETURN_VALUE_STRUCT_CONVENTION: @@ -1548,7 +1632,9 @@ spu_software_single_step (struct frame_info *frame) pc = get_frame_pc (frame); 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. */ @@ -1575,8 +1661,22 @@ spu_software_single_step (struct frame_info *frame) target += SPUADDR_ADDR (pc); else if (reg != -1) { - get_frame_register_bytes (frame, reg, 0, 4, buf); - target += extract_unsigned_integer (buf, 4, byte_order) & -4; + 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) + throw_error (OPTIMIZED_OUT_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 = target & lslr; @@ -1599,9 +1699,13 @@ spu_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[4]; CORE_ADDR jb_addr; + int optim, unavail; /* Jump buffer is pointed to by the argument register $r3. */ - get_frame_register_bytes (frame, SPU_ARG1_REGNUM, 0, 4, buf); + if (!get_frame_register_bytes (frame, SPU_ARG1_REGNUM, 0, 4, buf, + &optim, &unavail)) + return 0; + jb_addr = extract_unsigned_integer (buf, 4, byte_order); if (target_read_memory (SPUADDR (tdep->id, jb_addr), buf, 4)) return 0; @@ -1623,8 +1727,10 @@ struct spu_dis_asm_data 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_data *data + = (struct spu_dis_asm_data *) info->application_data; + print_address (data->gdbarch, SPUADDR (data->id, addr), + (struct ui_file *) info->stream); } static int @@ -1635,7 +1741,7 @@ gdb_print_insn_spu (bfd_vma memaddr, struct disassemble_info *info) call print_address. */ struct disassemble_info spu_info = *info; struct spu_dis_asm_data data; - data.gdbarch = info->application_data; + data.gdbarch = (struct gdbarch *) info->application_data; data.id = SPUADDR_SPU (memaddr); spu_info.application_data = &data; @@ -1698,34 +1804,34 @@ spu_get_overlay_table (struct objfile *objfile) { 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, @@ -1849,10 +1955,11 @@ spu_overlay_new_objfile (struct objfile *objfile) 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) @@ -1869,21 +1976,23 @@ spu_catch_start (struct objfile *objfile) /* 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); @@ -1894,15 +2003,18 @@ spu_catch_start (struct objfile *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 */, bp_breakpoint /* type_wanted */, 0 /* ignore_count */, AUTO_BOOLEAN_FALSE /* pending_break_support */, - NULL /* ops */, 0 /* from_tty */, 1 /* enabled */, - 0 /* internal */); + &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */, + 1 /* enabled */, 0 /* internal */, 0); + do_cleanups (back_to); } @@ -1931,7 +2043,7 @@ spu_objfile_from_frame (struct frame_info *frame) static void flush_ea_cache (void) { - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; struct objfile *obj; if (!has_stack_frames ()) @@ -1943,7 +2055,7 @@ flush_ea_cache (void) /* 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; @@ -1951,7 +2063,7 @@ flush_ea_cache (void) 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); } @@ -1985,7 +2097,7 @@ info_spu_event_command (char *args, int from_tty) 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.")); @@ -1998,7 +2110,7 @@ info_spu_event_command (char *args, int from_tty) 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, @@ -2006,15 +2118,15 @@ info_spu_event_command (char *args, int from_tty) 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 (uiout, "SPUInfoEvent"); + chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoEvent"); - if (ui_out_is_mi_like_p (uiout)) + if (ui_out_is_mi_like_p (current_uiout)) { - ui_out_field_fmt (uiout, "event_status", + ui_out_field_fmt (current_uiout, "event_status", "0x%s", phex_nz (event_status, 4)); - ui_out_field_fmt (uiout, "event_mask", + ui_out_field_fmt (current_uiout, "event_mask", "0x%s", phex_nz (event_mask, 4)); } else @@ -2042,7 +2154,7 @@ info_spu_signal_command (char *args, int from_tty) 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.")); @@ -2065,7 +2177,7 @@ info_spu_signal_command (char *args, int from_tty) 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); @@ -2083,18 +2195,18 @@ info_spu_signal_command (char *args, int from_tty) 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 (uiout, "SPUInfoSignal"); + chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoSignal"); - if (ui_out_is_mi_like_p (uiout)) + if (ui_out_is_mi_like_p (current_uiout)) { - ui_out_field_int (uiout, "signal1_pending", signal1_pending); - ui_out_field_fmt (uiout, "signal1", "0x%s", phex_nz (signal1, 4)); - ui_out_field_int (uiout, "signal1_type", signal1_type); - ui_out_field_int (uiout, "signal2_pending", signal2_pending); - ui_out_field_fmt (uiout, "signal2", "0x%s", phex_nz (signal2, 4)); - ui_out_field_int (uiout, "signal2_type", signal2_type); + 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); } else { @@ -2132,21 +2244,21 @@ info_spu_mailbox_list (gdb_byte *buf, int nr, enum bfd_endian byte_order, if (nr <= 0) return; - chain = make_cleanup_ui_out_table_begin_end (uiout, 1, nr, "mbox"); + chain = make_cleanup_ui_out_table_begin_end (current_uiout, 1, nr, "mbox"); - ui_out_table_header (uiout, 32, ui_left, field, msg); - ui_out_table_body (uiout); + ui_out_table_header (current_uiout, 32, ui_left, field, msg); + ui_out_table_body (current_uiout); for (i = 0; i < nr; i++) { struct cleanup *val_chain; ULONGEST val; - val_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "mbox"); + 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 (uiout, field, "0x%s", phex (val, 4)); + ui_out_field_fmt (current_uiout, field, "0x%s", phex (val, 4)); do_cleanups (val_chain); - if (!ui_out_is_mi_like_p (uiout)) + if (!ui_out_is_mi_like_p (current_uiout)) printf_filtered ("\n"); } @@ -2163,14 +2275,14 @@ info_spu_mailbox_command (char *args, int from_tty) 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.")); id = get_frame_register_unsigned (frame, SPU_ID_REGNUM); - chain = make_cleanup_ui_out_tuple_begin_end (uiout, "SPUInfoMailbox"); + chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoMailbox"); xsnprintf (annex, sizeof annex, "%d/mbox_info", id); len = target_read (¤t_target, TARGET_OBJECT_SPU, annex, @@ -2248,7 +2360,7 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) 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; @@ -2288,20 +2400,21 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) nr = i; - chain = make_cleanup_ui_out_table_begin_end (uiout, 10, nr, "dma_cmd"); + chain = make_cleanup_ui_out_table_begin_end (current_uiout, 10, nr, + "dma_cmd"); - ui_out_table_header (uiout, 7, ui_left, "opcode", "Opcode"); - ui_out_table_header (uiout, 3, ui_left, "tag", "Tag"); - ui_out_table_header (uiout, 3, ui_left, "tid", "TId"); - ui_out_table_header (uiout, 3, ui_left, "rid", "RId"); - ui_out_table_header (uiout, 18, ui_left, "ea", "EA"); - ui_out_table_header (uiout, 7, ui_left, "lsa", "LSA"); - ui_out_table_header (uiout, 7, ui_left, "size", "Size"); - ui_out_table_header (uiout, 7, ui_left, "lstaddr", "LstAddr"); - ui_out_table_header (uiout, 7, ui_left, "lstsize", "LstSize"); - ui_out_table_header (uiout, 1, ui_left, "error_p", "E"); + 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"); - ui_out_table_body (uiout); + ui_out_table_body (current_uiout); for (i = 0; i < nr; i++) { @@ -2310,9 +2423,9 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) 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; + 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. */ @@ -2337,52 +2450,51 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) 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 (uiout, "cmd"); + cmd_chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "cmd"); if (spu_mfc_opcode[mfc_cmd_opcode]) - ui_out_field_string (uiout, "opcode", spu_mfc_opcode[mfc_cmd_opcode]); + ui_out_field_string (current_uiout, "opcode", spu_mfc_opcode[mfc_cmd_opcode]); else - ui_out_field_int (uiout, "opcode", mfc_cmd_opcode); + ui_out_field_int (current_uiout, "opcode", mfc_cmd_opcode); - ui_out_field_int (uiout, "tag", mfc_cmd_tag); - ui_out_field_int (uiout, "tid", tclass_id); - ui_out_field_int (uiout, "rid", rclass_id); + 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); if (ea_valid_p) - ui_out_field_fmt (uiout, "ea", "0x%s", phex (mfc_ea, 8)); + ui_out_field_fmt (current_uiout, "ea", "0x%s", phex (mfc_ea, 8)); else - ui_out_field_skip (uiout, "ea"); + ui_out_field_skip (current_uiout, "ea"); - ui_out_field_fmt (uiout, "lsa", "0x%05x", mfc_lsa << 4); + ui_out_field_fmt (current_uiout, "lsa", "0x%05x", mfc_lsa << 4); if (qw_valid_p) - ui_out_field_fmt (uiout, "size", "0x%05x", mfc_size << 4); + ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size << 4); else - ui_out_field_fmt (uiout, "size", "0x%05x", mfc_size); + ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size); if (list_valid_p) { - ui_out_field_fmt (uiout, "lstaddr", "0x%05x", list_lsa << 3); - ui_out_field_fmt (uiout, "lstsize", "0x%05x", list_size << 3); + ui_out_field_fmt (current_uiout, "lstaddr", "0x%05x", list_lsa << 3); + ui_out_field_fmt (current_uiout, "lstsize", "0x%05x", list_size << 3); } else { - ui_out_field_skip (uiout, "lstaddr"); - ui_out_field_skip (uiout, "lstsize"); + ui_out_field_skip (current_uiout, "lstaddr"); + ui_out_field_skip (current_uiout, "lstsize"); } if (cmd_error_p) - ui_out_field_string (uiout, "error_p", "*"); + ui_out_field_string (current_uiout, "error_p", "*"); else - ui_out_field_skip (uiout, "error_p"); + ui_out_field_skip (current_uiout, "error_p"); do_cleanups (cmd_chain); - if (!ui_out_is_mi_like_p (uiout)) + if (!ui_out_is_mi_like_p (current_uiout)) printf_filtered ("\n"); } @@ -2404,7 +2516,7 @@ info_spu_dma_command (char *args, int from_tty) 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.")); @@ -2428,19 +2540,19 @@ info_spu_dma_command (char *args, int from_tty) dma_info_atomic_command_status = extract_unsigned_integer (buf + 32, 8, byte_order); - chain = make_cleanup_ui_out_tuple_begin_end (uiout, "SPUInfoDMA"); + chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoDMA"); - if (ui_out_is_mi_like_p (uiout)) + if (ui_out_is_mi_like_p (current_uiout)) { - ui_out_field_fmt (uiout, "dma_info_type", "0x%s", + ui_out_field_fmt (current_uiout, "dma_info_type", "0x%s", phex_nz (dma_info_type, 4)); - ui_out_field_fmt (uiout, "dma_info_mask", "0x%s", + ui_out_field_fmt (current_uiout, "dma_info_mask", "0x%s", phex_nz (dma_info_mask, 4)); - ui_out_field_fmt (uiout, "dma_info_status", "0x%s", + ui_out_field_fmt (current_uiout, "dma_info_status", "0x%s", phex_nz (dma_info_status, 4)); - ui_out_field_fmt (uiout, "dma_info_stall_and_notify", "0x%s", + 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 (uiout, "dma_info_atomic_command_status", "0x%s", + ui_out_field_fmt (current_uiout, "dma_info_atomic_command_status", "0x%s", phex_nz (dma_info_atomic_command_status, 4)); } else @@ -2483,7 +2595,7 @@ info_spu_proxydma_command (char *args, int from_tty) 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.")); @@ -2500,15 +2612,16 @@ info_spu_proxydma_command (char *args, int from_tty) dma_info_mask = extract_unsigned_integer (buf + 8, 8, byte_order); dma_info_status = extract_unsigned_integer (buf + 16, 8, byte_order); - chain = make_cleanup_ui_out_tuple_begin_end (uiout, "SPUInfoProxyDMA"); + chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, + "SPUInfoProxyDMA"); - if (ui_out_is_mi_like_p (uiout)) + if (ui_out_is_mi_like_p (current_uiout)) { - ui_out_field_fmt (uiout, "proxydma_info_type", "0x%s", + ui_out_field_fmt (current_uiout, "proxydma_info_type", "0x%s", phex_nz (dma_info_type, 4)); - ui_out_field_fmt (uiout, "proxydma_info_mask", "0x%s", + ui_out_field_fmt (current_uiout, "proxydma_info_mask", "0x%s", phex_nz (dma_info_mask, 4)); - ui_out_field_fmt (uiout, "proxydma_info_status", "0x%s", + ui_out_field_fmt (current_uiout, "proxydma_info_status", "0x%s", phex_nz (dma_info_status, 4)); } else @@ -2539,7 +2652,7 @@ info_spu_command (char *args, int from_tty) { 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); } @@ -2590,7 +2703,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); } @@ -2606,7 +2719,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) } /* 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); @@ -2626,6 +2739,11 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); @@ -2664,6 +2782,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* 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); @@ -2671,7 +2790,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); @@ -2680,7 +2799,6 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_decr_pc_after_break (gdbarch, 4); set_gdbarch_breakpoint_from_pc (gdbarch, spu_breakpoint_from_pc); 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);