X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fspu-tdep.c;h=17dae90741f8943d276e9d7bec99f6f0f112204f;hb=0bef263a74645a064f08c157639736645df7e4f9;hp=b3f50a1e9c1804471030aff819a8dd5765838eaa;hpb=13def385c0d3121354e8616a93d3ad55815e4859;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c index b3f50a1e9c..17dae90741 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, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 2006-2012 Free Software Foundation, Inc. Contributed by Ulrich Weigand . Based on a port by Sid Manning . @@ -43,7 +43,8 @@ #include "block.h" #include "observer.h" #include "infcall.h" - +#include "dwarf2.h" +#include "exceptions.h" #include "spu-tdep.h" @@ -175,67 +176,72 @@ spu_register_type (struct gdbarch *gdbarch, int reg_nr) return builtin_type (gdbarch)->builtin_uint32; default: - internal_error (__FILE__, __LINE__, "invalid regnum"); + internal_error (__FILE__, __LINE__, _("invalid regnum")); } } /* 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; - 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)); + 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")); @@ -353,7 +359,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 @@ -449,7 +455,7 @@ enum op_a = 0x0c0, op_ai = 0x1c, - op_selb = 0x4, + op_selb = 0x8, op_br = 0x64, op_bra = 0x60, @@ -813,7 +819,7 @@ spu_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, } else { - /* ??? We don't really know ... */ + /* ??? We don't really know ... */ *reg = SPU_SP_REGNUM; *offset = 0; } @@ -1006,7 +1012,8 @@ spu_frame_unwind_cache (struct frame_info *this_frame, { /* Assume the link register is saved into its slot. */ if (backchain + 16 <= lslr) - info->saved_regs[SPU_LR_REGNUM].addr = SPUADDR (id, backchain + 16); + info->saved_regs[SPU_LR_REGNUM].addr = SPUADDR (id, + backchain + 16); /* Frame bases. */ info->frame_base = SPUADDR (id, backchain); @@ -1074,6 +1081,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, @@ -1228,6 +1236,7 @@ spu2ppu_dealloc_cache (struct frame_info *self, void *this_cache) static const struct frame_unwind spu2ppu_unwind = { ARCH_FRAME, + default_frame_unwind_stop_reason, spu2ppu_this_id, spu2ppu_prev_register, NULL, @@ -1446,6 +1455,21 @@ spu_return_value (struct gdbarch *gdbarch, struct type *func_type, gdb_byte *out, const gdb_byte *in) { 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; @@ -1457,11 +1481,14 @@ 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: - error ("Cannot set function return value."); + error (_("Cannot set function return value.")); break; } } @@ -1470,11 +1497,14 @@ 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: - error ("Function return value unknown."); + error (_("Function return value unknown.")); break; } } @@ -1486,7 +1516,8 @@ spu_return_value (struct gdbarch *gdbarch, struct type *func_type, /* Breakpoints. */ static const gdb_byte * -spu_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr) +spu_breakpoint_from_pc (struct gdbarch *gdbarch, + CORE_ADDR * pcptr, int *lenptr) { static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff }; @@ -1494,6 +1525,39 @@ spu_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr) return breakpoint; } +static int +spu_memory_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + /* We work around a problem in combined Cell/B.E. debugging here. Consider + that in a combined application, we have some breakpoints inserted in SPU + code, and now the application forks (on the PPU side). GDB common code + will assume that the fork system call copied all breakpoints into the new + process' address space, and that all those copies now need to be removed + (see breakpoint.c:detach_breakpoints). + + While this is certainly true for PPU side breakpoints, it is not true + for SPU side breakpoints. fork will clone the SPU context file + descriptors, so that all the existing SPU contexts are in accessible + in the new process. However, the contents of the SPU contexts themselves + are *not* cloned. Therefore the effect of detach_breakpoints is to + remove SPU breakpoints from the *original* SPU context's local store + -- this is not the correct behaviour. + + The workaround is to check whether the PID we are asked to remove this + breakpoint from (i.e. ptid_get_pid (inferior_ptid)) is different from the + PID of the current inferior (i.e. current_inferior ()->pid). This is only + true in the context of detach_breakpoints. If so, we simply do nothing. + [ Note that for the fork child process, it does not matter if breakpoints + remain inserted, because those SPU contexts are not runnable anyway -- + the Linux kernel allows only the original process to invoke spu_run. */ + + if (ptid_get_pid (inferior_ptid) != current_inferior ()->pid) + return 0; + + return default_memory_remove_breakpoint (gdbarch, bp_tgt); +} + /* Software single-stepping support. */ @@ -1539,8 +1603,21 @@ 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) + 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; @@ -1563,9 +1640,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; @@ -1594,8 +1675,9 @@ spu_dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) static int 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. */ + /* 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; @@ -1629,11 +1711,12 @@ gdb_print_insn_spu (bfd_vma memaddr, struct disassemble_info *info) _ovly_table should never change. - Both tables are aligned to a 16-byte boundary, the symbols _ovly_table - and _ovly_buf_table are of type STT_OBJECT and their size set to the size - of the respective array. buf in _ovly_table is an index into _ovly_buf_table. + Both tables are aligned to a 16-byte boundary, the symbols + _ovly_table and _ovly_buf_table are of type STT_OBJECT and their + size set to the size of the respective array. buf in _ovly_table is + an index into _ovly_buf_table. - mapped is an index into _ovly_table. Both the mapped and buf indices start + mapped is an index into _ovly_table. Both the mapped and buf indices start from one to reference the first entry in their respective tables. */ /* Using the per-objfile private data mechanism, we store for each @@ -1676,7 +1759,8 @@ spu_get_overlay_table (struct objfile *objfile) if (!ovly_table_msym) return NULL; - ovly_buf_table_msym = lookup_minimal_symbol ("_ovly_buf_table", NULL, objfile); + ovly_buf_table_msym = lookup_minimal_symbol ("_ovly_buf_table", + NULL, objfile); if (!ovly_buf_table_msym) return NULL; @@ -1859,10 +1943,11 @@ spu_catch_start (struct objfile *objfile) create_breakpoint (get_objfile_arch (objfile), buf /* arg */, NULL /* cond_string */, -1 /* thread */, 0 /* parse_condition_and_thread */, 1 /* tempflag */, - 0 /* hardwareflag */, 0 /* traceflag */, + bp_breakpoint /* type_wanted */, 0 /* ignore_count */, AUTO_BOOLEAN_FALSE /* pending_break_support */, - NULL /* ops */, 0 /* from_tty */, 1 /* enabled */); + &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */, + 1 /* enabled */, 0 /* internal */); } @@ -1968,13 +2053,13 @@ info_spu_event_command (char *args, int from_tty) buf[len] = '\0'; event_mask = strtoulst (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 @@ -2045,16 +2130,16 @@ info_spu_signal_command (char *args, int from_tty) buf[len] = '\0'; signal2_type = strtoulst (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 { @@ -2092,21 +2177,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"); } @@ -2130,7 +2215,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 (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,20 +2333,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++) { @@ -2302,47 +2388,47 @@ 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 (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"); } @@ -2388,19 +2474,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 @@ -2460,15 +2546,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 @@ -2497,7 +2584,8 @@ info_spu_proxydma_command (char *args, int from_tty) static void info_spu_command (char *args, int from_tty) { - printf_unfiltered (_("\"info spu\" must be followed by the name of an SPU facility.\n")); + printf_unfiltered (_("\"info spu\" must be followed by " + "the name of an SPU facility.\n")); help_list (infospucmdlist, "info spu ", -1, gdb_stdout); } @@ -2638,6 +2726,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Breakpoints. */ 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);