We're going to need the same enum as enum lwp_stop_reason in more
targets, so this promotes it to common code.
gdb/gdbserver/ChangeLog:
2015-03-04 Pedro Alves <palves@redhat.com>
enum lwp_stop_reason -> enum target_stop_reason
* linux-low.c (check_stopped_by_breakpoint): Adjust.
(thread_still_has_status_pending_p, check_stopped_by_watchpoint)
(linux_wait_1, stuck_in_jump_pad_callback)
(move_out_of_jump_pad_callback, linux_resume_one_lwp)
(linux_stopped_by_watchpoint):
* linux-low.h (enum lwp_stop_reason): Delete.
(struct lwp_info) <stop_reason>: Now an enum target_stop_reason.
* linux-x86-low.c (x86_linux_prepare_to_resume): Adjust.
gdb/ChangeLog:
2015-03-04 Pedro Alves <palves@redhat.com>
enum lwp_stop_reason -> enum target_stop_reason
* linux-nat.c (linux_resume_one_lwp, check_stopped_by_watchpoint)
(linux_nat_stopped_by_watchpoint, status_callback)
(linux_nat_wait_1): Adjust.
* linux-nat.h (enum lwp_stop_reason): Delete.
(struct lwp_info) <stop_reason>: Now an enum target_stop_reason.
* x86-linux-nat.c (x86_linux_prepare_to_resume): Adjust.
* target/waitstatus.h (enum target_stop_reason): New.
+2015-03-04 Pedro Alves <palves@redhat.com>
+
+ enum lwp_stop_reason -> enum target_stop_reason
+ * linux-nat.c (linux_resume_one_lwp, check_stopped_by_watchpoint)
+ (linux_nat_stopped_by_watchpoint, status_callback)
+ (linux_nat_wait_1): Adjust.
+ * linux-nat.h (enum lwp_stop_reason): Delete.
+ (struct lwp_info) <stop_reason>: Now an enum target_stop_reason.
+ * x86-linux-nat.c (x86_linux_prepare_to_resume): Adjust.
+ * target/waitstatus.h (enum target_stop_reason): New.
+
2015-03-04 Pedro Alves <palves@redhat.com>
* breakpoint.c (need_moribund_for_location_type): New function.
+2015-03-04 Pedro Alves <palves@redhat.com>
+
+ enum lwp_stop_reason -> enum target_stop_reason
+ * linux-low.c (check_stopped_by_breakpoint): Adjust.
+ (thread_still_has_status_pending_p, check_stopped_by_watchpoint)
+ (linux_wait_1, stuck_in_jump_pad_callback)
+ (move_out_of_jump_pad_callback, linux_resume_one_lwp)
+ (linux_stopped_by_watchpoint):
+ * linux-low.h (enum lwp_stop_reason): Delete.
+ (struct lwp_info) <stop_reason>: Now an enum target_stop_reason.
+ * linux-x86-low.c (x86_linux_prepare_to_resume): Adjust.
+
2015-03-04 Yao Qi <yao.qi@linaro.org>
* Makefile.in (SFILES): Add linux-aarch64-low.c.
}
lwp->stop_pc = sw_breakpoint_pc;
- lwp->stop_reason = LWP_STOPPED_BY_SW_BREAKPOINT;
+ lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
current_thread = saved_thread;
return 1;
}
}
lwp->stop_pc = pc;
- lwp->stop_reason = LWP_STOPPED_BY_HW_BREAKPOINT;
+ lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
current_thread = saved_thread;
return 1;
}
return 0;
if (thread->last_resume_kind != resume_stop
- && (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT
- || lp->stop_reason == LWP_STOPPED_BY_HW_BREAKPOINT))
+ && (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
{
struct thread_info *saved_thread;
CORE_ADDR pc;
lwpid_of (thread));
discard = 1;
}
- else if (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT
+ else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
&& !(*the_low_target.breakpoint_at) (pc))
{
if (debug_threads)
lwpid_of (thread));
discard = 1;
}
- else if (lp->stop_reason == LWP_STOPPED_BY_HW_BREAKPOINT
+ else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
&& !hardware_breakpoint_inserted_here (pc))
{
if (debug_threads)
if (the_low_target.stopped_by_watchpoint ())
{
- child->stop_reason = LWP_STOPPED_BY_WATCHPOINT;
+ child->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
if (the_low_target.stopped_data_address != NULL)
child->stopped_data_address
current_thread = saved_thread;
}
- return child->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
+ return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
/* Do low-level handling of the event, and check if we should go on
Advance the PC manually past the breakpoint, otherwise the
program would keep trapping the permanent breakpoint forever. */
if (!ptid_equal (step_over_bkpt, null_ptid)
- && event_child->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT)
+ && event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
{
unsigned int increment_pc = the_low_target.breakpoint_len;
(*the_low_target.set_pc) (regcache, event_child->stop_pc);
if (!(*the_low_target.breakpoint_at) (event_child->stop_pc))
- event_child->stop_reason = LWP_STOPPED_BY_NO_REASON;
+ event_child->stop_reason = TARGET_STOPPED_BY_NO_REASON;
}
}
report_to_gdb = (!maybe_internal_trap
|| (current_thread->last_resume_kind == resume_step
&& !in_step_range)
- || event_child->stop_reason == LWP_STOPPED_BY_WATCHPOINT
+ || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
|| (!step_over_finished && !in_step_range
&& !bp_explains_trap && !trace_event)
|| (gdb_breakpoint_here (event_child->stop_pc)
else if (!lwp_in_step_range (event_child))
debug_printf ("Out of step range, reporting event.\n");
}
- if (event_child->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
+ if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
debug_printf ("Stopped by watchpoint.\n");
else if (gdb_breakpoint_here (event_child->stop_pc))
debug_printf ("Stopped by GDB breakpoint.\n");
/* Now that we've selected our final event LWP, un-adjust its PC if
it was a software breakpoint. */
- if (event_child->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT)
+ if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
{
int decr_pc = the_low_target.decr_pc_after_break;
return (supports_fast_tracepoints ()
&& agent_loaded_p ()
&& (gdb_breakpoint_here (lwp->stop_pc)
- || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT
+ || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
|| thread->last_resume_kind == resume_step)
&& linux_fast_tracepoint_collecting (lwp, NULL));
}
/* Allow debugging the jump pad, gdb_collect, etc. */
if (!gdb_breakpoint_here (lwp->stop_pc)
- && lwp->stop_reason != LWP_STOPPED_BY_WATCHPOINT
+ && lwp->stop_reason != TARGET_STOPPED_BY_WATCHPOINT
&& thread->last_resume_kind != resume_step
&& maybe_move_out_of_jump_pad (lwp, wstat))
{
regcache_invalidate_thread (thread);
errno = 0;
lwp->stopped = 0;
- lwp->stop_reason = LWP_STOPPED_BY_NO_REASON;
+ lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
lwp->stepping = step;
ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (thread),
(PTRACE_TYPE_ARG3) 0,
{
struct lwp_info *lwp = get_thread_lwp (current_thread);
- return lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
+ return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
static CORE_ADDR
/* Included for ptrace type definitions. */
#include "nat/linux-ptrace.h"
+#include "target/waitstatus.h" /* For enum target_stop_reason. */
#define PTRACE_XFER_TYPE long
#define get_thread_lwp(thr) ((struct lwp_info *) (inferior_target_data (thr)))
#define get_lwp_thread(lwp) ((lwp)->thread)
-/* Reasons an LWP last stopped. */
-
-enum lwp_stop_reason
-{
- /* Either not stopped, or stopped for a reason that doesn't require
- special tracking. */
- LWP_STOPPED_BY_NO_REASON,
-
- /* Stopped by a software breakpoint. */
- LWP_STOPPED_BY_SW_BREAKPOINT,
-
- /* Stopped by a hardware breakpoint. */
- LWP_STOPPED_BY_HW_BREAKPOINT,
-
- /* Stopped by a watchpoint. */
- LWP_STOPPED_BY_WATCHPOINT
-};
-
/* This struct is recorded in the target_data field of struct thread_info.
On linux ``all_threads'' is keyed by the LWP ID, which we use as the
/* The reason the LWP last stopped, if we need to track it
(breakpoint, watchpoint, etc.) */
- enum lwp_stop_reason stop_reason;
+ enum target_stop_reason stop_reason;
/* On architectures where it is possible to know the data address of
a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
lwp->arch_private->debug_registers_changed = 0;
}
- if (clear_status || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
+ if (clear_status || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
x86_linux_dr_set (ptid, DR_STATUS, 0);
}
\f
if (linux_nat_prepare_to_resume != NULL)
linux_nat_prepare_to_resume (lp);
linux_ops->to_resume (linux_ops, lp->ptid, step, signo);
- lp->stop_reason = LWP_STOPPED_BY_NO_REASON;
+ lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
lp->stopped = 0;
registers_changed_ptid (lp->ptid);
}
if (linux_ops->to_stopped_by_watchpoint (linux_ops))
{
- lp->stop_reason = LWP_STOPPED_BY_WATCHPOINT;
+ lp->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
if (linux_ops->to_stopped_data_address != NULL)
lp->stopped_data_address_p =
do_cleanups (old_chain);
- return lp->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
+ return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
/* Called when the LWP stopped for a trap that could be explained by a
static void
save_sigtrap (struct lwp_info *lp)
{
- gdb_assert (lp->stop_reason == LWP_STOPPED_BY_NO_REASON);
+ gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
gdb_assert (lp->status != 0);
if (check_stopped_by_watchpoint (lp))
gdb_assert (lp != NULL);
- return lp->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
+ return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
}
static int
if (!lp->resumed)
return 0;
- if (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT
- || lp->stop_reason == LWP_STOPPED_BY_HW_BREAKPOINT)
+ if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
+ || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
{
struct regcache *regcache = get_thread_regcache (lp->ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
regcache_write_pc (regcache, sw_bp_pc);
lp->stop_pc = sw_bp_pc;
- lp->stop_reason = LWP_STOPPED_BY_SW_BREAKPOINT;
+ lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
return 1;
}
target_pid_to_str (lp->ptid));
lp->stop_pc = pc;
- lp->stop_reason = LWP_STOPPED_BY_HW_BREAKPOINT;
+ lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
return 1;
}
/* Now that we've selected our final event LWP, un-adjust its PC if
it was a software breakpoint. */
- if (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT)
+ if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
{
struct regcache *regcache = get_thread_regcache (lp->ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct arch_lwp_info;
-/* Reasons an LWP last stopped. */
-
-enum lwp_stop_reason
-{
- /* Either not stopped, or stopped for a reason that doesn't require
- special tracking. */
- LWP_STOPPED_BY_NO_REASON,
-
- /* Stopped by a software breakpoint. */
- LWP_STOPPED_BY_SW_BREAKPOINT,
-
- /* Stopped by a hardware breakpoint. */
- LWP_STOPPED_BY_HW_BREAKPOINT,
-
- /* Stopped by a watchpoint. */
- LWP_STOPPED_BY_WATCHPOINT
-};
-
/* Structure describing an LWP. This is public only for the purposes
of ALL_LWPS; target-specific code should generally not access it
directly. */
/* The reason the LWP last stopped, if we need to track it
(breakpoint, watchpoint, etc.) */
- enum lwp_stop_reason stop_reason;
+ enum target_stop_reason stop_reason;
/* On architectures where it is possible to know the data address of
a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and
} value;
};
+/* Extended reasons that can explain why a target/thread stopped for a
+ trap signal. */
+
+enum target_stop_reason
+{
+ /* Either not stopped, or stopped for a reason that doesn't require
+ special tracking. */
+ TARGET_STOPPED_BY_NO_REASON,
+
+ /* Stopped by a software breakpoint. */
+ TARGET_STOPPED_BY_SW_BREAKPOINT,
+
+ /* Stopped by a hardware breakpoint. */
+ TARGET_STOPPED_BY_HW_BREAKPOINT,
+
+ /* Stopped by a watchpoint. */
+ TARGET_STOPPED_BY_WATCHPOINT
+};
+
/* Prototypes */
/* Return a pretty printed form of target_waitstatus.
lwp->arch_private->debug_registers_changed = 0;
}
- if (clear_status || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
+ if (clear_status || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
}
projects / thirdparty / binutils-gdb.git / commitdiff
