X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fspu-tdep.c;h=f2f4f6564793a047dc0fafff304bc1097625ee0e;hb=24b9144d4ba83d37751786b08b48ad62fb7aef26;hp=a7c2bf02daa6760970ba52c3649946266b2e623f;hpb=f5ea389ac78ccd7c426a93f43e6117dad9ce0878;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index a7c2bf02da..f2f4f65647 100644 --- a/gdb/spu-tdep.c +++ b/gdb/spu-tdep.c @@ -1,5 +1,5 @@ /* SPU target-dependent code for GDB, the GNU debugger. - Copyright (C) 2006-2016 Free Software Foundation, Inc. + Copyright (C) 2006-2018 Free Software Foundation, Inc. Contributed by Ulrich Weigand . Based on a port by Sid Manning . @@ -33,11 +33,11 @@ #include "value.h" #include "inferior.h" #include "dis-asm.h" +#include "disasm.h" #include "objfiles.h" #include "language.h" #include "regcache.h" #include "reggroups.h" -#include "floatformat.h" #include "block.h" #include "observer.h" #include "infcall.h" @@ -113,7 +113,7 @@ static struct cmd_list_element *infospucmdlist = NULL; static const char * spu_register_name (struct gdbarch *gdbarch, int reg_nr) { - static char *register_names[] = + static const char *register_names[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", @@ -185,7 +185,7 @@ 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); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum register_status status; gdb_byte reg[32]; @@ -193,7 +193,7 @@ spu_pseudo_register_read_spu (struct regcache *regcache, const char *regname, ULONGEST id; ULONGEST ul; - status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + status = regcache->raw_read (SPU_ID_REGNUM, &id); if (status != REG_VALID) return status; xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname); @@ -218,14 +218,14 @@ spu_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, switch (regnum) { case SPU_SP_REGNUM: - status = regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg); + status = regcache->raw_read (SPU_RAW_SP_REGNUM, reg); if (status != REG_VALID) return status; memcpy (buf, reg, 4); return status; case SPU_FPSCR_REGNUM: - status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id); + status = regcache->raw_read (SPU_ID_REGNUM, &id); if (status != REG_VALID) return status; xsnprintf (annex, sizeof annex, "%d/fpcr", (int) id); @@ -253,7 +253,7 @@ static void spu_pseudo_register_write_spu (struct regcache *regcache, const char *regname, const gdb_byte *buf) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); char reg[32]; char annex[32]; @@ -1178,7 +1178,7 @@ spu_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) static CORE_ADDR spu_read_pc (struct regcache *regcache) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ()); ULONGEST pc; regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &pc); /* Mask off interrupt enable bit. */ @@ -1209,7 +1209,7 @@ static struct gdbarch * spu2ppu_prev_arch (struct frame_info *this_frame, void **this_cache) { struct spu2ppu_cache *cache = (struct spu2ppu_cache *) *this_cache; - return get_regcache_arch (cache->regcache); + return cache->regcache->arch (); } static void @@ -1225,7 +1225,7 @@ spu2ppu_prev_register (struct frame_info *this_frame, void **this_cache, int regnum) { struct spu2ppu_cache *cache = (struct spu2ppu_cache *) *this_cache; - struct gdbarch *gdbarch = get_regcache_arch (cache->regcache); + struct gdbarch *gdbarch = cache->regcache->arch (); gdb_byte *buf; buf = (gdb_byte *) alloca (register_size (gdbarch, regnum)); @@ -1266,7 +1266,7 @@ spu2ppu_sniffer (const struct frame_unwind *self, if (fi) { - cache->regcache = frame_save_as_regcache (fi); + cache->regcache = frame_save_as_regcache (fi).release (); *this_prologue_cache = cache; return 1; } @@ -1287,7 +1287,7 @@ static void spu2ppu_dealloc_cache (struct frame_info *self, void *this_cache) { struct spu2ppu_cache *cache = (struct spu2ppu_cache *) this_cache; - regcache_xfree (cache->regcache); + delete cache->regcache; } static const struct frame_unwind spu2ppu_unwind = { @@ -1338,6 +1338,7 @@ spu_scalar_value_p (struct type *type) case TYPE_CODE_BOOL: case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: return TYPE_LENGTH (type) <= 16; default: @@ -1610,17 +1611,17 @@ spu_memory_remove_breakpoint (struct gdbarch *gdbarch, /* Software single-stepping support. */ -static VEC (CORE_ADDR) * +static std::vector spu_software_single_step (struct regcache *regcache) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); 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; + std::vector next_pcs; pc = regcache_read_pc (regcache); @@ -1631,8 +1632,8 @@ spu_software_single_step (struct regcache *regcache) insn = extract_unsigned_integer (buf, 4, byte_order); /* Get local store limit. */ - lslr = regcache_raw_get_unsigned (regcache, SPU_LSLR_REGNUM); - if (!lslr) + if ((regcache_cooked_read_unsigned (regcache, SPU_LSLR_REGNUM, &lslr) + != REG_VALID) || !lslr) lslr = (ULONGEST) -1; /* Next sequential instruction is at PC + 4, except if the current @@ -1643,7 +1644,7 @@ spu_software_single_step (struct regcache *regcache) else next_pc = (SPUADDR_ADDR (pc) + 4) & lslr; - VEC_safe_push (CORE_ADDR, next_pcs, SPUADDR (SPUADDR_SPU (pc), next_pc)); + next_pcs.push_back (SPUADDR (SPUADDR_SPU (pc), next_pc)); if (is_branch (insn, &offset, ®)) { @@ -1652,12 +1653,14 @@ spu_software_single_step (struct regcache *regcache) if (reg == SPU_PC_REGNUM) target += SPUADDR_ADDR (pc); else if (reg != -1) - target += regcache_raw_get_unsigned (regcache, reg) & -4; + { + regcache_raw_read_part (regcache, reg, 0, 4, buf); + target += extract_unsigned_integer (buf, 4, byte_order) & -4; + } target = target & lslr; if (target != next_pc) - VEC_safe_push (CORE_ADDR, next_pcs, SPUADDR (SPUADDR_SPU (pc), - target)); + next_pcs.push_back (SPUADDR (SPUADDR_SPU (pc), target)); } return next_pcs; @@ -1693,18 +1696,19 @@ spu_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) /* 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 - = (struct spu_dis_asm_data *) info->application_data; - print_address (data->gdbarch, SPUADDR (data->id, addr), + struct spu_dis_asm_info *data = (struct spu_dis_asm_info *) info; + gdb_disassembler *di + = static_cast(info->application_data); + + print_address (di->arch (), SPUADDR (data->id, addr), (struct ui_file *) info->stream); } @@ -1714,14 +1718,12 @@ gdb_print_insn_spu (bfd_vma memaddr, struct disassemble_info *info) /* 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 = (struct 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); + return default_print_insn (memaddr, &spu_info); } @@ -1913,7 +1915,6 @@ spu_overlay_new_objfile (struct objfile *objfile) /* Now go and fiddle with all the LMAs. */ ALL_OBJFILE_OSECTIONS (objfile, osect) { - bfd *obfd = objfile->obfd; asection *bsect = osect->the_bfd_section; int ndx = osect - objfile->sections; @@ -1933,8 +1934,6 @@ spu_catch_start (struct objfile *objfile) struct bound_minimal_symbol minsym; struct compunit_symtab *cust; CORE_ADDR pc; - 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) @@ -1967,7 +1966,9 @@ spu_catch_start (struct objfile *objfile) struct symbol *sym; struct symtab_and_line sal; - sym = block_lookup_symbol (block, "main", VAR_DOMAIN); + sym = block_lookup_symbol (block, "main", + symbol_name_match_type::SEARCH_NAME, + VAR_DOMAIN); if (sym) { fixup_symbol_section (sym, objfile); @@ -1978,9 +1979,8 @@ spu_catch_start (struct objfile *objfile) /* Use a numerical address for the set_breakpoint command to avoid having the breakpoint re-set incorrectly. */ - location = new_address_location (pc, NULL, 0); - back_to = make_cleanup_delete_event_location (location); - create_breakpoint (get_objfile_arch (objfile), location, + event_location_up location = new_address_location (pc, NULL, 0); + create_breakpoint (get_objfile_arch (objfile), location.get (), NULL /* cond_string */, -1 /* thread */, NULL /* extra_string */, 0 /* parse_condition_and_thread */, 1 /* tempflag */, @@ -1989,7 +1989,6 @@ spu_catch_start (struct objfile *objfile) AUTO_BOOLEAN_FALSE /* pending_break_support */, &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */, 1 /* enabled */, 0 /* internal */, 0); - do_cleanups (back_to); } @@ -2040,7 +2039,7 @@ flush_ea_cache (void) type = lookup_pointer_type (type); addr = BMSYMBOL_VALUE_ADDRESS (msymbol); - call_function_by_hand (value_from_pointer (type, addr), 0, NULL); + call_function_by_hand (value_from_pointer (type, addr), NULL, 0, NULL); } } @@ -2063,12 +2062,11 @@ spu_attach_normal_stop (struct bpstats *bs, int print_frame) /* "info spu" commands. */ static void -info_spu_event_command (char *args, int from_tty) +info_spu_event_command (const char *args, int from_tty) { struct frame_info *frame = get_selected_frame (NULL); ULONGEST event_status = 0; ULONGEST event_mask = 0; - struct cleanup *chain; gdb_byte buf[100]; char annex[32]; LONGEST len; @@ -2095,26 +2093,24 @@ info_spu_event_command (char *args, int from_tty) buf[len] = '\0'; event_mask = strtoulst ((char *) buf, NULL, 16); - chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoEvent"); + ui_out_emit_tuple tuple_emitter (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 { printf_filtered (_("Event Status 0x%s\n"), phex (event_status, 4)); printf_filtered (_("Event Mask 0x%s\n"), phex (event_mask, 4)); } - - do_cleanups (chain); } static void -info_spu_signal_command (char *args, int from_tty) +info_spu_signal_command (const char *args, int from_tty) { struct frame_info *frame = get_selected_frame (NULL); struct gdbarch *gdbarch = get_frame_arch (frame); @@ -2125,7 +2121,6 @@ info_spu_signal_command (char *args, int from_tty) ULONGEST signal2 = 0; ULONGEST signal2_type = 0; int signal2_pending = 0; - struct cleanup *chain; char annex[32]; gdb_byte buf[100]; LONGEST len; @@ -2172,16 +2167,16 @@ info_spu_signal_command (char *args, int from_tty) buf[len] = '\0'; signal2_type = strtoulst ((char *) buf, NULL, 16); - chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoSignal"); + ui_out_emit_tuple tuple_emitter (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 { @@ -2205,48 +2200,42 @@ info_spu_signal_command (char *args, int from_tty) else printf_filtered (_("(Type Overwrite)\n")); } - - do_cleanups (chain); } static void info_spu_mailbox_list (gdb_byte *buf, int nr, enum bfd_endian byte_order, const char *field, const char *msg) { - struct cleanup *chain; int i; if (nr <= 0) return; - chain = make_cleanup_ui_out_table_begin_end (current_uiout, 1, nr, "mbox"); + ui_out_emit_table table_emitter (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++) { - struct cleanup *val_chain; - 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)); - do_cleanups (val_chain); - - if (!ui_out_is_mi_like_p (current_uiout)) + { + ULONGEST val; + ui_out_emit_tuple tuple_emitter (current_uiout, "mbox"); + val = extract_unsigned_integer (buf + 4*i, 4, byte_order); + current_uiout->field_fmt (field, "0x%s", phex (val, 4)); + } + + if (!current_uiout->is_mi_like_p ()) printf_filtered ("\n"); } - - do_cleanups (chain); } static void -info_spu_mailbox_command (char *args, int from_tty) +info_spu_mailbox_command (const char *args, int from_tty) { struct frame_info *frame = get_selected_frame (NULL); struct gdbarch *gdbarch = get_frame_arch (frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - struct cleanup *chain; char annex[32]; gdb_byte buf[1024]; LONGEST len; @@ -2257,7 +2246,7 @@ info_spu_mailbox_command (char *args, int from_tty) id = get_frame_register_unsigned (frame, SPU_ID_REGNUM); - chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoMailbox"); + ui_out_emit_tuple tuple_emitter (current_uiout, "SPUInfoMailbox"); xsnprintf (annex, sizeof annex, "%d/mbox_info", id); len = target_read (¤t_target, TARGET_OBJECT_SPU, annex, @@ -2285,8 +2274,6 @@ info_spu_mailbox_command (char *args, int from_tty) info_spu_mailbox_list (buf, len / 4, byte_order, "wbox", "SPU Inbound Mailbox"); - - do_cleanups (chain); } static ULONGEST @@ -2299,7 +2286,7 @@ spu_mfc_get_bitfield (ULONGEST word, int first, int last) static void info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) { - static char *spu_mfc_opcode[256] = + static const char *spu_mfc_opcode[256] = { /* 00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, @@ -2337,7 +2324,6 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) int *seq = XALLOCAVEC (int, nr); int done = 0; - struct cleanup *chain; int i, j; @@ -2375,25 +2361,23 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) nr = i; - chain = make_cleanup_ui_out_table_begin_end (current_uiout, 10, nr, - "dma_cmd"); + ui_out_emit_table table_emitter (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++) { - struct cleanup *cmd_chain; ULONGEST mfc_cq_dw0; ULONGEST mfc_cq_dw1; ULONGEST mfc_cq_dw2; @@ -2429,55 +2413,53 @@ info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order) 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"); + { + ui_out_emit_tuple tuple_emitter (current_uiout, "cmd"); - if (spu_mfc_opcode[mfc_cmd_opcode]) - ui_out_field_string (current_uiout, "opcode", spu_mfc_opcode[mfc_cmd_opcode]); - else - ui_out_field_int (current_uiout, "opcode", mfc_cmd_opcode); + if (spu_mfc_opcode[mfc_cmd_opcode]) + current_uiout->field_string ("opcode", spu_mfc_opcode[mfc_cmd_opcode]); + else + 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)); - else - ui_out_field_skip (current_uiout, "ea"); + if (ea_valid_p) + current_uiout->field_fmt ("ea", "0x%s", phex (mfc_ea, 8)); + else + current_uiout->field_skip ("ea"); - ui_out_field_fmt (current_uiout, "lsa", "0x%05x", mfc_lsa << 4); - if (qw_valid_p) - ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size << 4); - else - ui_out_field_fmt (current_uiout, "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); - } - else - { - ui_out_field_skip (current_uiout, "lstaddr"); - ui_out_field_skip (current_uiout, "lstsize"); - } + current_uiout->field_fmt ("lsa", "0x%05x", mfc_lsa << 4); + if (qw_valid_p) + current_uiout->field_fmt ("size", "0x%05x", mfc_size << 4); + else + current_uiout->field_fmt ("size", "0x%05x", mfc_size); - if (cmd_error_p) - ui_out_field_string (current_uiout, "error_p", "*"); - else - ui_out_field_skip (current_uiout, "error_p"); + if (list_valid_p) + { + current_uiout->field_fmt ("lstaddr", "0x%05x", list_lsa << 3); + current_uiout->field_fmt ("lstsize", "0x%05x", list_size << 3); + } + else + { + current_uiout->field_skip ("lstaddr"); + current_uiout->field_skip ("lstsize"); + } - do_cleanups (cmd_chain); + if (cmd_error_p) + current_uiout->field_string ("error_p", "*"); + else + current_uiout->field_skip ("error_p"); + } - if (!ui_out_is_mi_like_p (current_uiout)) + if (!current_uiout->is_mi_like_p ()) printf_filtered ("\n"); } - - do_cleanups (chain); } static void -info_spu_dma_command (char *args, int from_tty) +info_spu_dma_command (const char *args, int from_tty) { struct frame_info *frame = get_selected_frame (NULL); struct gdbarch *gdbarch = get_frame_arch (frame); @@ -2487,7 +2469,6 @@ info_spu_dma_command (char *args, int from_tty) ULONGEST dma_info_status; ULONGEST dma_info_stall_and_notify; ULONGEST dma_info_atomic_command_status; - struct cleanup *chain; char annex[32]; gdb_byte buf[1024]; LONGEST len; @@ -2515,20 +2496,20 @@ 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 (current_uiout, "SPUInfoDMA"); + ui_out_emit_tuple tuple_emitter (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 { @@ -2554,11 +2535,10 @@ info_spu_dma_command (char *args, int from_tty) } info_spu_dma_cmdlist (buf + 40, 16, byte_order); - do_cleanups (chain); } static void -info_spu_proxydma_command (char *args, int from_tty) +info_spu_proxydma_command (const char *args, int from_tty) { struct frame_info *frame = get_selected_frame (NULL); struct gdbarch *gdbarch = get_frame_arch (frame); @@ -2566,7 +2546,6 @@ info_spu_proxydma_command (char *args, int from_tty) ULONGEST dma_info_type; ULONGEST dma_info_mask; ULONGEST dma_info_status; - struct cleanup *chain; char annex[32]; gdb_byte buf[1024]; LONGEST len; @@ -2587,17 +2566,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 (current_uiout, - "SPUInfoProxyDMA"); + ui_out_emit_tuple tuple_emitter (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 { @@ -2619,11 +2597,10 @@ info_spu_proxydma_command (char *args, int from_tty) } info_spu_dma_cmdlist (buf + 24, 8, byte_order); - do_cleanups (chain); } static void -info_spu_command (char *args, int from_tty) +info_spu_command (const char *args, int from_tty) { printf_unfiltered (_("\"info spu\" must be followed by " "the name of an SPU facility.\n")); @@ -2634,13 +2611,13 @@ info_spu_command (char *args, int from_tty) /* Root of all "set spu "/"show spu " commands. */ static void -show_spu_command (char *args, int from_tty) +show_spu_command (const char *args, int from_tty) { help_list (showspucmdlist, "show spu ", all_commands, gdb_stdout); } static void -set_spu_command (char *args, int from_tty) +set_spu_command (const char *args, int from_tty) { help_list (setspucmdlist, "set spu ", all_commands, gdb_stdout); } @@ -2672,8 +2649,8 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) int id = -1; /* Which spufs ID was requested as address space? */ - if (info.tdep_info) - id = *(int *)info.tdep_info; + if (info.id) + id = *info.id; /* For objfile architectures of SPU solibs, decode the ID from the name. This assumes the filename convention employed by solib-spu.c. */ else if (info.abfd) @@ -2745,6 +2722,9 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_address_class_name_to_type_flags (gdbarch, spu_address_class_name_to_type_flags); + /* We need to support more than "addr_bit" significant address bits + in order to support SPUADDR_ADDR encoded values. */ + set_gdbarch_significant_addr_bit (gdbarch, 64); /* Inferior function calls. */ set_gdbarch_call_dummy_location (gdbarch, ON_STACK); @@ -2784,9 +2764,6 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return gdbarch; } -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_spu_tdep; - void _initialize_spu_tdep (void) {