#include "event-loop.h"
#include "inf-loop.h"
#include "vec.h"
+#include "inferior.h"
#include <algorithm>
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;
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 ());
/* 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");
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);
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);
}
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);
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);
/* 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);
}
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. */
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;
}
/* 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. */
ret = 0;
TRY
{
- ret = this->beneath->insert_breakpoint (gdbarch, bp_tgt);
+ ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
}
CATCH (except, RETURN_MASK_ALL)
{
ret = 0;
TRY
{
- ret = this->beneath->remove_breakpoint (gdbarch, bp_tgt, reason);
+ ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt, reason);
}
CATCH (except, RETURN_MASK_ALL)
{
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;
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. */
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. */
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. */
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);
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;
/* 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
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;
+ id = null_frame_id;
TRY
{
- frame = get_current_frame ();
+ id = get_frame_id (get_current_frame ());
}
CATCH (except, RETURN_MASK_ALL)
{
/* Restore the previous execution state. */
set_executing (inferior_ptid, executing);
- /* Restore the previous inferior_ptid. */
- inferior_ptid = old_inferior_ptid;
-
throw_exception (except);
}
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. */
subroutines after we started replaying. */
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,
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)
xfree (btinfo->replay);
btinfo->replay = NULL;
- registers_changed_ptid (tp->ptid);
+ registers_changed_thread (tp);
throw_exception (except);
}
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. */
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),
if ((::execution_direction != EXEC_REVERSE)
&& !record_is_replaying (minus_one_ptid))
{
- this->beneath->resume (ptid, step, signal);
+ this->beneath ()->resume (ptid, step, signal);
return;
}
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. */
{
if ((::execution_direction != EXEC_REVERSE)
&& !record_is_replaying (minus_one_ptid))
- beneath->commit_resume ();
+ beneath ()->commit_resume ();
}
/* Cancel resuming 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;
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);
}
return status;
}
-/* A vector of threads. */
-
-typedef struct thread_info * tp_t;
-DEF_VEC_P (tp_t);
-
/* Announce further events if necessary. */
static void
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 ())
{
/* 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);
}
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),
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;
+ }
}
}
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
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. */
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
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. */
return;
/* Forward the request. */
- this->beneath->update_thread_list ();
+ this->beneath ()->update_thread_list ();
}
/* The thread_alive method of target record-btrace. */
{
/* 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
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);
}
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);
}
{
execute_command ("target record-btrace", from_tty);
}
- CATCH (exception, RETURN_MASK_ALL)
+ CATCH (ex, RETURN_MASK_ALL)
{
record_btrace_conf.format = BTRACE_FORMAT_NONE;
- throw_exception (exception);
+ throw_exception (ex);
}
END_CATCH
}
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);
add_prefix_cmd ("cpu", class_support, cmd_set_record_btrace_cpu,
_("\
Set the cpu to be used for trace decode.\n\n\
-The format is \"<vendor>:<identifier>\" or \"none\" or \"auto\" (default).\n\
-For vendor \"intel\" the format is \"<family>/<model>[/<stepping>]\".\n\n\
+The format is \"VENDOR:IDENTIFIER\" or \"none\" or \"auto\" (default).\n\
+For vendor \"intel\" the format is \"FAMILY/MODEL[/STEPPING]\".\n\n\
When decoding branch trace, enable errata workarounds for the specified cpu.\n\
The default is \"auto\", which uses the cpu on which the trace was recorded.\n\
When GDB does not support that cpu, this option can be used to enable\n\
projects / deliverable / binutils-gdb.git / blobdiff