X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Frecord-btrace.c;h=65d6a254ff06c0c0b83ae5f115e65e11194a080e;hb=e3ec872f8012377e50f0c9c888d2bc3163a356b2;hp=0f01aceb93c7206fff1d7da353d3dc4b416fc360;hpb=10b2ded43caa3298cded1df8b620caaaee3f9209;p=external%2Fbinutils.git diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 0f01ace..65d6a25 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -1,6 +1,6 @@ /* Branch trace support for GDB, the GNU debugger. - Copyright (C) 2013-2018 Free Software Foundation, Inc. + Copyright (C) 2013-2019 Free Software Foundation, Inc. Contributed by Intel Corp. @@ -38,8 +38,10 @@ #include "infrun.h" #include "event-loop.h" #include "inf-loop.h" -#include "vec.h" +#include "gdbsupport/vec.h" +#include "inferior.h" #include +#include "gdbarch.h" static const target_info record_btrace_target_info = { "record-btrace", @@ -52,12 +54,11 @@ static const target_info record_btrace_target_info = { class record_btrace_target final : public target_ops { public: - record_btrace_target () - { to_stratum = record_stratum; } - const target_info &info () const override { return record_btrace_target_info; } + strata stratum () const override { return record_stratum; } + void close () override; void async (int) override; @@ -143,7 +144,7 @@ static record_btrace_target record_btrace_ops; /* Token associated with a new-thread observer enabling branch tracing for the new thread. */ -static const gdb::observers::token record_btrace_thread_observer_token; +static const gdb::observers::token record_btrace_thread_observer_token {}; /* Memory access types used in set/show record btrace replay-memory-access. */ static const char replay_memory_access_read_only[] = "read-only"; @@ -244,14 +245,13 @@ record_btrace_get_cpu (void) static struct thread_info * require_btrace_thread (void) { - struct thread_info *tp; - DEBUG ("require"); - tp = find_thread_ptid (inferior_ptid); - if (tp == NULL) + if (inferior_ptid == null_ptid) error (_("No thread.")); + thread_info *tp = inferior_thread (); + validate_registers_access (); btrace_fetch (tp, record_btrace_get_cpu ()); @@ -283,15 +283,14 @@ require_btrace (void) static void record_btrace_enable_warn (struct thread_info *tp) { - TRY + try { btrace_enable (tp, &record_btrace_conf); } - CATCH (error, RETURN_MASK_ERROR) + catch (const gdb_exception_error &error) { - warning ("%s", error.message); + warning ("%s", error.what ()); } - END_CATCH } /* Enable automatic tracing of new threads. */ @@ -379,7 +378,6 @@ record_btrace_target_open (const char *args, int from_tty) /* If we fail to enable btrace for one thread, disable it for the threads for which it was successfully enabled. */ scoped_btrace_disable btrace_disable; - struct thread_info *tp; DEBUG ("open"); @@ -388,7 +386,7 @@ record_btrace_target_open (const char *args, int from_tty) if (!target_has_execution) error (_("The program is not being run.")); - ALL_NON_EXITED_THREADS (tp) + for (thread_info *tp : all_non_exited_threads ()) if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num)) { btrace_enable (tp, &record_btrace_conf); @@ -406,13 +404,11 @@ record_btrace_target_open (const char *args, int from_tty) void record_btrace_target::stop_recording () { - struct thread_info *tp; - DEBUG ("stop recording"); record_btrace_auto_disable (); - ALL_NON_EXITED_THREADS (tp) + for (thread_info *tp : all_non_exited_threads ()) if (tp->btrace.target != NULL) btrace_disable (tp); } @@ -423,7 +419,7 @@ void record_btrace_target::disconnect (const char *args, int from_tty) { - struct target_ops *beneath = this->beneath; + struct target_ops *beneath = this->beneath (); /* Do not stop recording, just clean up GDB side. */ unpush_target (this); @@ -437,8 +433,6 @@ record_btrace_target::disconnect (const char *args, void record_btrace_target::close () { - struct thread_info *tp; - if (record_btrace_async_inferior_event_handler != NULL) delete_async_event_handler (&record_btrace_async_inferior_event_handler); @@ -448,7 +442,7 @@ record_btrace_target::close () /* We should have already stopped recording. Tear down btrace in case we have not. */ - ALL_NON_EXITED_THREADS (tp) + for (thread_info *tp : all_non_exited_threads ()) btrace_teardown (tp); } @@ -462,7 +456,7 @@ record_btrace_target::async (int enable) else clear_async_event_handler (record_btrace_async_inferior_event_handler); - this->beneath->async (enable); + this->beneath ()->async (enable); } /* Adjusts the size and returns a human readable size suffix. */ @@ -602,7 +596,8 @@ record_btrace_target::info_record () printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) " "for thread %s (%s).\n"), insns, calls, gaps, - print_thread_id (tp), target_pid_to_str (tp->ptid)); + print_thread_id (tp), + target_pid_to_str (tp->ptid).c_str ()); if (btrace_is_replaying (tp)) printf_unfiltered (_("Replay in progress. At instruction %u.\n"), @@ -622,21 +617,13 @@ btrace_ui_out_decode_error (struct ui_out *uiout, int errcode, if (!(format == BTRACE_FORMAT_PT && errcode > 0)) { uiout->text (_("decode error (")); - uiout->field_int ("errcode", errcode); + uiout->field_signed ("errcode", errcode); uiout->text (_("): ")); } uiout->text (errstr); uiout->text (_("]\n")); } -/* Print an unsigned int. */ - -static void -ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val) -{ - uiout->field_fmt (fld, "%u", val); -} - /* A range of source lines. */ struct btrace_line_range @@ -791,7 +778,7 @@ btrace_insn_history (struct ui_out *uiout, gdb::optional src_and_asm_tuple; gdb::optional asm_list; - gdb_pretty_print_disassembler disasm (gdbarch); + gdb_pretty_print_disassembler disasm (gdbarch, uiout); for (btrace_insn_iterator it = *begin; btrace_insn_cmp (&it, end) != 0; btrace_insn_next (&it, 1)) @@ -854,7 +841,7 @@ btrace_insn_history (struct ui_out *uiout, if ((insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) != 0) dinsn.is_speculative = 1; - disasm.pretty_print_insn (uiout, &dinsn, flags); + disasm.pretty_print_insn (&dinsn, flags); } } } @@ -1038,9 +1025,9 @@ btrace_call_history_insn_range (struct ui_out *uiout, begin = bfun->insn_offset; end = begin + size - 1; - ui_out_field_uint (uiout, "insn begin", begin); + uiout->field_unsigned ("insn begin", begin); uiout->text (","); - ui_out_field_uint (uiout, "insn end", end); + uiout->field_unsigned ("insn end", end); } /* Compute the lowest and highest source line for the instructions in BFUN @@ -1096,20 +1083,21 @@ btrace_call_history_src_line (struct ui_out *uiout, return; uiout->field_string ("file", - symtab_to_filename_for_display (symbol_symtab (sym))); + symtab_to_filename_for_display (symbol_symtab (sym)), + ui_out_style_kind::FILE); btrace_compute_src_line_range (bfun, &begin, &end); if (end < begin) return; uiout->text (":"); - uiout->field_int ("min line", begin); + uiout->field_signed ("min line", begin); if (end == begin) return; uiout->text (","); - uiout->field_int ("max line", end); + uiout->field_signed ("max line", end); } /* Get the name of a branch trace function. */ @@ -1160,7 +1148,7 @@ btrace_call_history (struct ui_out *uiout, msym = bfun->msym; /* Print the function index. */ - ui_out_field_uint (uiout, "index", bfun->number); + uiout->field_unsigned ("index", bfun->number); uiout->text ("\t"); /* Indicate gaps in the trace. */ @@ -1187,11 +1175,14 @@ btrace_call_history (struct ui_out *uiout, } if (sym != NULL) - uiout->field_string ("function", SYMBOL_PRINT_NAME (sym)); + uiout->field_string ("function", SYMBOL_PRINT_NAME (sym), + ui_out_style_kind::FUNCTION); else if (msym != NULL) - uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym)); + uiout->field_string ("function", MSYMBOL_PRINT_NAME (msym), + ui_out_style_kind::FUNCTION); else if (!uiout->is_mi_like_p ()) - uiout->field_string ("function", "??"); + uiout->field_string ("function", "??", + ui_out_style_kind::FUNCTION); if ((flags & RECORD_PRINT_INSN_RANGE) != 0) { @@ -1398,10 +1389,8 @@ record_btrace_target::record_method (ptid_t ptid) bool record_btrace_target::record_is_replaying (ptid_t ptid) { - struct thread_info *tp; - - ALL_NON_EXITED_THREADS (tp) - if (ptid_match (tp->ptid, ptid) && btrace_is_replaying (tp)) + for (thread_info *tp : all_non_exited_threads (ptid)) + if (btrace_is_replaying (tp)) return true; return false; @@ -1463,8 +1452,8 @@ record_btrace_target::xfer_partial (enum target_object object, } /* Forward the request. */ - return this->beneath->xfer_partial (object, annex, readbuf, writebuf, - offset, len, xfered_len); + return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf, + offset, len, xfered_len); } /* The insert_breakpoint method of target record-btrace. */ @@ -1482,16 +1471,15 @@ record_btrace_target::insert_breakpoint (struct gdbarch *gdbarch, replay_memory_access = replay_memory_access_read_write; ret = 0; - TRY + try { - ret = this->beneath->insert_breakpoint (gdbarch, bp_tgt); + ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { replay_memory_access = old; - throw_exception (except); + throw; } - END_CATCH replay_memory_access = old; return ret; @@ -1513,16 +1501,15 @@ record_btrace_target::remove_breakpoint (struct gdbarch *gdbarch, replay_memory_access = replay_memory_access_read_write; ret = 0; - TRY + try { - ret = this->beneath->remove_breakpoint (gdbarch, bp_tgt, reason); + ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { replay_memory_access = old; - throw_exception (except); + throw; } - END_CATCH replay_memory_access = old; return ret; @@ -1536,7 +1523,7 @@ record_btrace_target::fetch_registers (struct regcache *regcache, int regno) struct btrace_insn_iterator *replay; struct thread_info *tp; - tp = find_thread_ptid (regcache_get_ptid (regcache)); + tp = find_thread_ptid (regcache->ptid ()); gdb_assert (tp != NULL); replay = tp->btrace.replay; @@ -1558,10 +1545,10 @@ record_btrace_target::fetch_registers (struct regcache *regcache, int regno) insn = btrace_insn_get (replay); gdb_assert (insn != NULL); - regcache_raw_supply (regcache, regno, &insn->pc); + regcache->raw_supply (regno, &insn->pc); } else - this->beneath->fetch_registers (regcache, regno); + this->beneath ()->fetch_registers (regcache, regno); } /* The store_registers method of target record-btrace. */ @@ -1569,15 +1556,13 @@ record_btrace_target::fetch_registers (struct regcache *regcache, int regno) void record_btrace_target::store_registers (struct regcache *regcache, int regno) { - struct target_ops *t; - if (!record_btrace_generating_corefile - && record_is_replaying (regcache_get_ptid (regcache))) + && record_is_replaying (regcache->ptid ())) error (_("Cannot write registers while replaying.")); gdb_assert (may_write_registers != 0); - this->beneath->store_registers (regcache, regno); + this->beneath ()->store_registers (regcache, regno); } /* The prepare_to_store method of target record-btrace. */ @@ -1586,10 +1571,10 @@ void record_btrace_target::prepare_to_store (struct regcache *regcache) { if (!record_btrace_generating_corefile - && record_is_replaying (regcache_get_ptid (regcache))) + && record_is_replaying (regcache->ptid ())) return; - this->beneath->prepare_to_store (regcache); + this->beneath ()->prepare_to_store (regcache); } /* The branch trace frame cache. */ @@ -1778,8 +1763,7 @@ record_btrace_frame_sniffer (const struct frame_unwind *self, struct frame_info *next; /* THIS_FRAME does not contain a reference to its thread. */ - tp = find_thread_ptid (inferior_ptid); - gdb_assert (tp != NULL); + tp = inferior_thread (); bfun = NULL; next = get_next_frame (this_frame); @@ -1845,7 +1829,7 @@ record_btrace_tailcall_frame_sniffer (const struct frame_unwind *self, if ((callee->flags & BFUN_UP_LINKS_TO_TAILCALL) == 0) return 0; - tinfo = find_thread_ptid (inferior_ptid); + tinfo = inferior_thread (); if (btrace_find_call_by_number (&it, &tinfo->btrace, callee->up) == 0) return 0; @@ -1956,7 +1940,8 @@ record_btrace_resume_thread (struct thread_info *tp, struct btrace_thread_info *btinfo; DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag)); + target_pid_to_str (tp->ptid).c_str (), flag, + btrace_thread_flag_to_str (flag)); btinfo = &tp->btrace; @@ -1970,16 +1955,17 @@ record_btrace_resume_thread (struct thread_info *tp, /* Get the current frame for TP. */ -static struct frame_info * -get_thread_current_frame (struct thread_info *tp) +static struct frame_id +get_thread_current_frame_id (struct thread_info *tp) { - struct frame_info *frame; - ptid_t old_inferior_ptid; + struct frame_id id; int executing; - /* Set INFERIOR_PTID, which is implicitly used by get_current_frame. */ - old_inferior_ptid = inferior_ptid; - inferior_ptid = tp->ptid; + /* Set current thread, which is implicitly used by + get_current_frame. */ + scoped_restore_current_thread restore_thread; + + switch_to_thread (tp); /* Clear the executing flag to allow changes to the current frame. We are not actually running, yet. We just started a reverse execution @@ -1988,33 +1974,26 @@ get_thread_current_frame (struct thread_info *tp) For the former, EXECUTING is true and we're in wait, about to move the thread. Since we need to recompute the stack, we temporarily set EXECUTING to flase. */ - executing = is_executing (inferior_ptid); - set_executing (inferior_ptid, 0); + executing = tp->executing; + set_executing (inferior_ptid, false); - frame = NULL; - TRY + id = null_frame_id; + try { - frame = get_current_frame (); + id = get_frame_id (get_current_frame ()); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { /* Restore the previous execution state. */ set_executing (inferior_ptid, executing); - /* Restore the previous inferior_ptid. */ - inferior_ptid = old_inferior_ptid; - - throw_exception (except); + throw; } - END_CATCH /* Restore the previous execution state. */ set_executing (inferior_ptid, executing); - /* Restore the previous inferior_ptid. */ - inferior_ptid = old_inferior_ptid; - - return frame; + return id; } /* Start replaying a thread. */ @@ -2037,15 +2016,13 @@ record_btrace_start_replaying (struct thread_info *tp) Since frames are computed differently when we're replaying, we need to recompute those stored frames and fix them up so we can still detect subroutines after we started replaying. */ - TRY + try { - struct frame_info *frame; struct frame_id frame_id; int upd_step_frame_id, upd_step_stack_frame_id; /* The current frame without replaying - computed via normal unwind. */ - frame = get_thread_current_frame (tp); - frame_id = get_frame_id (frame); + frame_id = get_thread_current_frame_id (tp); /* Check if we need to update any stepping-related frame id's. */ upd_step_frame_id = frame_id_eq (frame_id, @@ -2073,11 +2050,10 @@ record_btrace_start_replaying (struct thread_info *tp) btinfo->replay = replay; /* Make sure we're not using any stale registers. */ - registers_changed_ptid (tp->ptid); + registers_changed_thread (tp); /* The current frame with replaying - computed via btrace unwind. */ - frame = get_thread_current_frame (tp); - frame_id = get_frame_id (frame); + frame_id = get_thread_current_frame_id (tp); /* Replace stepping related frames where necessary. */ if (upd_step_frame_id) @@ -2085,16 +2061,15 @@ record_btrace_start_replaying (struct thread_info *tp) if (upd_step_stack_frame_id) tp->control.step_stack_frame_id = frame_id; } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { xfree (btinfo->replay); btinfo->replay = NULL; - registers_changed_ptid (tp->ptid); + registers_changed_thread (tp); - throw_exception (except); + throw; } - END_CATCH return replay; } @@ -2112,7 +2087,7 @@ record_btrace_stop_replaying (struct thread_info *tp) btinfo->replay = NULL; /* Make sure we're not leaving any stale registers. */ - registers_changed_ptid (tp->ptid); + registers_changed_thread (tp); } /* Stop replaying TP if it is at the end of its execution history. */ @@ -2140,10 +2115,9 @@ record_btrace_stop_replaying_at_end (struct thread_info *tp) void record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) { - struct thread_info *tp; enum btrace_thread_flag flag, cflag; - DEBUG ("resume %s: %s%s", target_pid_to_str (ptid), + DEBUG ("resume %s: %s%s", target_pid_to_str (ptid).c_str (), ::execution_direction == EXEC_REVERSE ? "reverse-" : "", step ? "step" : "cont"); @@ -2161,7 +2135,7 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) if ((::execution_direction != EXEC_REVERSE) && !record_is_replaying (minus_one_ptid)) { - this->beneath->resume (ptid, step, signal); + this->beneath ()->resume (ptid, step, signal); return; } @@ -2183,22 +2157,20 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) For all-stop targets, we only step INFERIOR_PTID and continue others. */ if (!target_is_non_stop_p ()) { - gdb_assert (ptid_match (inferior_ptid, ptid)); + gdb_assert (inferior_ptid.matches (ptid)); - ALL_NON_EXITED_THREADS (tp) - if (ptid_match (tp->ptid, ptid)) - { - if (ptid_match (tp->ptid, inferior_ptid)) - record_btrace_resume_thread (tp, flag); - else - record_btrace_resume_thread (tp, cflag); - } + for (thread_info *tp : all_non_exited_threads (ptid)) + { + if (tp->ptid.matches (inferior_ptid)) + record_btrace_resume_thread (tp, flag); + else + record_btrace_resume_thread (tp, cflag); + } } else { - ALL_NON_EXITED_THREADS (tp) - if (ptid_match (tp->ptid, ptid)) - record_btrace_resume_thread (tp, flag); + for (thread_info *tp : all_non_exited_threads (ptid)) + record_btrace_resume_thread (tp, flag); } /* Async support. */ @@ -2216,7 +2188,7 @@ record_btrace_target::commit_resume () { if ((::execution_direction != EXEC_REVERSE) && !record_is_replaying (minus_one_ptid)) - beneath->commit_resume (); + beneath ()->commit_resume (); } /* Cancel resuming TP. */ @@ -2232,7 +2204,7 @@ record_btrace_cancel_resume (struct thread_info *tp) DEBUG ("cancel resume thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid), flags, + target_pid_to_str (tp->ptid).c_str (), flags, btrace_thread_flag_to_str (flags)); tp->btrace.flags &= ~(BTHR_MOVE | BTHR_STOP); @@ -2334,7 +2306,6 @@ record_btrace_replay_at_breakpoint (struct thread_info *tp) struct btrace_insn_iterator *replay; struct btrace_thread_info *btinfo; const struct btrace_insn *insn; - struct inferior *inf; btinfo = &tp->btrace; replay = btinfo->replay; @@ -2346,11 +2317,7 @@ record_btrace_replay_at_breakpoint (struct thread_info *tp) if (insn == NULL) return 0; - inf = find_inferior_ptid (tp->ptid); - if (inf == NULL) - return 0; - - return record_check_stopped_by_breakpoint (inf->aspace, insn->pc, + return record_check_stopped_by_breakpoint (tp->inf->aspace, insn->pc, &btinfo->stop_reason); } @@ -2465,7 +2432,7 @@ record_btrace_step_thread (struct thread_info *tp) btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP); DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp), - target_pid_to_str (tp->ptid), flags, + target_pid_to_str (tp->ptid).c_str (), flags, btrace_thread_flag_to_str (flags)); /* We can't step without an execution history. */ @@ -2550,32 +2517,25 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, std::vector moving; std::vector no_history; - DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid), options); + DEBUG ("wait %s (0x%x)", target_pid_to_str (ptid).c_str (), options); /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) && !record_is_replaying (minus_one_ptid)) { - return this->beneath->wait (ptid, status, options); + return this->beneath ()->wait (ptid, status, options); } /* Keep a work list of moving threads. */ - { - thread_info *tp; - - ALL_NON_EXITED_THREADS (tp) - { - if (ptid_match (tp->ptid, ptid) - && ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)) - moving.push_back (tp); - } - } + for (thread_info *tp : all_non_exited_threads (ptid)) + if ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0) + moving.push_back (tp); if (moving.empty ()) { *status = btrace_step_no_resumed (); - DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid), + DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid).c_str (), target_waitstatus_to_string (status).c_str ()); return null_ptid; @@ -2650,9 +2610,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, /* Stop all other threads. */ if (!target_is_non_stop_p ()) { - thread_info *tp; - - ALL_NON_EXITED_THREADS (tp) + for (thread_info *tp : all_non_exited_threads ()) record_btrace_cancel_resume (tp); } @@ -2664,11 +2622,11 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, record_btrace_clear_histories (&eventing->btrace); /* We moved the replay position but did not update registers. */ - registers_changed_ptid (eventing->ptid); + registers_changed_thread (eventing); DEBUG ("wait ended by thread %s (%s): %s", print_thread_id (eventing), - target_pid_to_str (eventing->ptid), + target_pid_to_str (eventing->ptid).c_str (), target_waitstatus_to_string (status).c_str ()); return eventing->ptid; @@ -2679,24 +2637,21 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, void record_btrace_target::stop (ptid_t ptid) { - DEBUG ("stop %s", target_pid_to_str (ptid)); + DEBUG ("stop %s", target_pid_to_str (ptid).c_str ()); /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) && !record_is_replaying (minus_one_ptid)) { - this->beneath->stop (ptid); + this->beneath ()->stop (ptid); } else { - struct thread_info *tp; - - ALL_NON_EXITED_THREADS (tp) - if (ptid_match (tp->ptid, ptid)) - { - tp->btrace.flags &= ~BTHR_MOVE; - tp->btrace.flags |= BTHR_STOP; - } + for (thread_info *tp : all_non_exited_threads (ptid)) + { + tp->btrace.flags &= ~BTHR_MOVE; + tp->btrace.flags |= BTHR_STOP; + } } } @@ -2720,7 +2675,7 @@ record_btrace_target::stopped_by_sw_breakpoint () return tp->btrace.stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT; } - return this->beneath->stopped_by_sw_breakpoint (); + return this->beneath ()->stopped_by_sw_breakpoint (); } /* The supports_stopped_by_sw_breakpoint method of target @@ -2732,7 +2687,7 @@ record_btrace_target::supports_stopped_by_sw_breakpoint () if (record_is_replaying (minus_one_ptid)) return true; - return this->beneath->supports_stopped_by_sw_breakpoint (); + return this->beneath ()->supports_stopped_by_sw_breakpoint (); } /* The stopped_by_sw_breakpoint method of target record-btrace. */ @@ -2747,7 +2702,7 @@ record_btrace_target::stopped_by_hw_breakpoint () return tp->btrace.stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT; } - return this->beneath->stopped_by_hw_breakpoint (); + return this->beneath ()->stopped_by_hw_breakpoint (); } /* The supports_stopped_by_hw_breakpoint method of target @@ -2759,7 +2714,7 @@ record_btrace_target::supports_stopped_by_hw_breakpoint () if (record_is_replaying (minus_one_ptid)) return true; - return this->beneath->supports_stopped_by_hw_breakpoint (); + return this->beneath ()->supports_stopped_by_hw_breakpoint (); } /* The update_thread_list method of target record-btrace. */ @@ -2772,7 +2727,7 @@ record_btrace_target::update_thread_list () return; /* Forward the request. */ - this->beneath->update_thread_list (); + this->beneath ()->update_thread_list (); } /* The thread_alive method of target record-btrace. */ @@ -2782,10 +2737,10 @@ record_btrace_target::thread_alive (ptid_t ptid) { /* We don't add or remove threads during replay. */ if (record_is_replaying (minus_one_ptid)) - return find_thread_ptid (ptid) != NULL; + return true; /* Forward the request. */ - return this->beneath->thread_alive (ptid); + return this->beneath ()->thread_alive (ptid); } /* Set the replay branch trace instruction iterator. If IT is NULL, replay @@ -2809,13 +2764,14 @@ record_btrace_set_replay (struct thread_info *tp, return; *btinfo->replay = *it; - registers_changed_ptid (tp->ptid); + registers_changed_thread (tp); } /* Start anew from the new replay position. */ record_btrace_clear_histories (btinfo); - stop_pc = regcache_read_pc (get_current_regcache ()); + inferior_thread ()->suspend.stop_pc + = regcache_read_pc (get_current_regcache ()); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); } @@ -2888,9 +2844,7 @@ record_btrace_target::goto_record (ULONGEST insn) void record_btrace_target::record_stop_replaying () { - struct thread_info *tp; - - ALL_NON_EXITED_THREADS (tp) + for (thread_info *tp : all_non_exited_threads ()) record_btrace_stop_replaying (tp); } @@ -2928,16 +2882,15 @@ cmd_record_btrace_bts_start (const char *args, int from_tty) record_btrace_conf.format = BTRACE_FORMAT_BTS; - TRY + try { execute_command ("target record-btrace", from_tty); } - CATCH (exception, RETURN_MASK_ALL) + catch (const gdb_exception &exception) { record_btrace_conf.format = BTRACE_FORMAT_NONE; - throw_exception (exception); + throw; } - END_CATCH } /* Start recording in Intel Processor Trace format. */ @@ -2950,16 +2903,15 @@ cmd_record_btrace_pt_start (const char *args, int from_tty) record_btrace_conf.format = BTRACE_FORMAT_PT; - TRY + try { execute_command ("target record-btrace", from_tty); } - CATCH (exception, RETURN_MASK_ALL) + catch (const gdb_exception &exception) { record_btrace_conf.format = BTRACE_FORMAT_NONE; - throw_exception (exception); + throw; } - END_CATCH } /* Alias for "target record". */ @@ -2972,26 +2924,24 @@ cmd_record_btrace_start (const char *args, int from_tty) record_btrace_conf.format = BTRACE_FORMAT_PT; - TRY + try { execute_command ("target record-btrace", from_tty); } - CATCH (exception, RETURN_MASK_ALL) + catch (const gdb_exception &exception) { record_btrace_conf.format = BTRACE_FORMAT_BTS; - TRY + try { execute_command ("target record-btrace", from_tty); } - CATCH (exception, RETURN_MASK_ALL) + catch (const gdb_exception &ex) { record_btrace_conf.format = BTRACE_FORMAT_NONE; - throw_exception (exception); + throw; } - END_CATCH } - END_CATCH } /* The "set record btrace" command. */ @@ -3094,8 +3044,6 @@ cmd_set_record_btrace_cpu (const char *args, int from_tty) static void cmd_show_record_btrace_cpu (const char *args, int from_tty) { - const char *cpu; - if (args != nullptr && *args != 0) error (_("Trailing junk: '%s'."), args); @@ -3215,11 +3163,11 @@ This format may not be available on all processors."), add_alias_cmd ("pt", "btrace pt", class_obscure, 1, &record_cmdlist); add_prefix_cmd ("btrace", class_support, cmd_set_record_btrace, - _("Set record options"), &set_record_btrace_cmdlist, + _("Set record options."), &set_record_btrace_cmdlist, "set record btrace ", 0, &set_record_cmdlist); add_prefix_cmd ("btrace", class_support, cmd_show_record_btrace, - _("Show record options"), &show_record_btrace_cmdlist, + _("Show record options."), &show_record_btrace_cmdlist, "show record btrace ", 0, &show_record_cmdlist); add_setshow_enum_cmd ("replay-memory-access", no_class, @@ -3248,7 +3196,7 @@ When GDB does not support that cpu, this option can be used to enable\n\ workarounds for a similar cpu that GDB supports.\n\n\ When set to \"none\", errata workarounds are disabled."), &set_record_btrace_cpu_cmdlist, - _("set record btrace cpu "), 1, + "set record btrace cpu ", 1, &set_record_btrace_cmdlist); add_cmd ("auto", class_support, cmd_set_record_btrace_cpu_auto, _("\ @@ -3264,12 +3212,12 @@ Show the cpu to be used for trace decode."), &show_record_btrace_cmdlist); add_prefix_cmd ("bts", class_support, cmd_set_record_btrace_bts, - _("Set record btrace bts options"), + _("Set record btrace bts options."), &set_record_btrace_bts_cmdlist, "set record btrace bts ", 0, &set_record_btrace_cmdlist); add_prefix_cmd ("bts", class_support, cmd_show_record_btrace_bts, - _("Show record btrace bts options"), + _("Show record btrace bts options."), &show_record_btrace_bts_cmdlist, "show record btrace bts ", 0, &show_record_btrace_cmdlist); @@ -3288,12 +3236,12 @@ The trace buffer size may not be changed while recording."), NULL, &show_record_btrace_bts_cmdlist); add_prefix_cmd ("pt", class_support, cmd_set_record_btrace_pt, - _("Set record btrace pt options"), + _("Set record btrace pt options."), &set_record_btrace_pt_cmdlist, "set record btrace pt ", 0, &set_record_btrace_cmdlist); add_prefix_cmd ("pt", class_support, cmd_show_record_btrace_pt, - _("Show record btrace pt options"), + _("Show record btrace pt options."), &show_record_btrace_pt_cmdlist, "show record btrace pt ", 0, &show_record_btrace_cmdlist);