static void unsuspend_all_lwps (struct lwp_info *except);
static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
static int lwp_is_marked_dead (struct lwp_info *lwp);
-static int finish_step_over (struct lwp_info *lwp);
static int kill_lwp (unsigned long lwpid, int signo);
static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
static int linux_low_ptrace_options (int attached);
being stepped. */
ptid_t step_over_bkpt;
-/* True if the low target can hardware single-step. */
-
-static int
-can_hardware_single_step (void)
-{
- if (the_low_target.supports_hardware_single_step != NULL)
- return the_low_target.supports_hardware_single_step ();
- else
- return 0;
-}
-
bool
linux_process_target::low_supports_breakpoints ()
{
return pc;
}
-/* This function should only be called if LWP got a SYSCALL_SIGTRAP.
- Fill *SYSNO with the syscall nr trapped. */
-
-static void
-get_syscall_trapinfo (struct lwp_info *lwp, int *sysno)
+void
+linux_process_target::get_syscall_trapinfo (lwp_info *lwp, int *sysno)
{
struct thread_info *saved_thread;
struct regcache *regcache;
- if (the_low_target.get_syscall_trapinfo == NULL)
- {
- /* If we cannot get the syscall trapinfo, report an unknown
- system call number. */
- *sysno = UNKNOWN_SYSCALL;
- return;
- }
-
saved_thread = current_thread;
current_thread = get_lwp_thread (lwp);
regcache = get_thread_regcache (current_thread, 1);
- (*the_low_target.get_syscall_trapinfo) (regcache, sysno);
+ low_get_syscall_trapinfo (regcache, sysno);
if (debug_threads)
debug_printf ("get_syscall_trapinfo sysno %d\n", *sysno);
current_thread = saved_thread;
}
+void
+linux_process_target::low_get_syscall_trapinfo (regcache *regcache, int *sysno)
+{
+ /* By default, report an unknown system call number. */
+ *sysno = UNKNOWN_SYSCALL;
+}
+
bool
linux_process_target::save_stop_reason (lwp_info *lwp)
{
{
maybe_disable_address_space_randomization restore_personality
(cs.disable_randomization);
- std::string str_program_args = stringify_argv (program_args);
+ std::string str_program_args = construct_inferior_arguments (program_args);
pid = fork_inferior (program,
str_program_args.c_str (),
return child;
}
-/* Return true if THREAD is doing hardware single step. */
-
-static int
-maybe_hw_step (struct thread_info *thread)
+bool
+linux_process_target::maybe_hw_step (thread_info *thread)
{
- if (can_hardware_single_step ())
- return 1;
+ if (supports_hardware_single_step ())
+ return true;
else
{
/* GDBserver must insert single-step breakpoint for software
single step. */
gdb_assert (has_single_step_breakpoints (thread));
- return 0;
+ return false;
}
}
return !proc->syscalls_to_catch.empty ();
}
-/* Returns 1 if GDB is interested in the event_child syscall.
- Only to be called when stopped reason is SYSCALL_SIGTRAP. */
-
-static int
-gdb_catch_this_syscall_p (struct lwp_info *event_child)
+bool
+linux_process_target::gdb_catch_this_syscall (lwp_info *event_child)
{
int sysno;
struct thread_info *thread = get_lwp_thread (event_child);
struct process_info *proc = get_thread_process (thread);
if (proc->syscalls_to_catch.empty ())
- return 0;
+ return false;
if (proc->syscalls_to_catch[0] == ANY_SYSCALL)
- return 1;
+ return true;
get_syscall_trapinfo (event_child, &sysno);
for (int iter : proc->syscalls_to_catch)
if (iter == sysno)
- return 1;
+ return true;
- return 0;
+ return false;
}
ptid_t
/* Check if GDB is interested in this syscall. */
if (WIFSTOPPED (w)
&& WSTOPSIG (w) == SYSCALL_SIGTRAP
- && !gdb_catch_this_syscall_p (event_child))
+ && !gdb_catch_this_syscall (event_child))
{
if (debug_threads)
{
{
int step = 0;
- if (can_hardware_single_step ())
+ if (supports_hardware_single_step ())
{
step = 1;
}
debug_printf (" pending reinsert at 0x%s\n",
paddress (lwp->bp_reinsert));
- if (can_hardware_single_step ())
+ if (supports_hardware_single_step ())
{
if (fast_tp_collecting == fast_tpoint_collect_result::not_collecting)
{
" single-stepping\n",
lwpid_of (thread));
- if (can_hardware_single_step ())
+ if (supports_hardware_single_step ())
step = 1;
else
{
step_over_bkpt = thread->id;
}
-/* Finish a step-over. Reinsert the breakpoint we had uninserted in
- start_step_over, if still there, and delete any single-step
- breakpoints we've set, on non hardware single-step targets. */
-
-static int
-finish_step_over (struct lwp_info *lwp)
+bool
+linux_process_target::finish_step_over (lwp_info *lwp)
{
if (lwp->bp_reinsert != 0)
{
and later not being able to explain it, because we were
stepping over a breakpoint, and we hold all threads but
LWP stopped while doing that. */
- if (!can_hardware_single_step ())
+ if (!supports_hardware_single_step ())
{
gdb_assert (has_single_step_breakpoints (current_thread));
delete_single_step_breakpoints (current_thread);
step_over_bkpt = null_ptid;
current_thread = saved_thread;
- return 1;
+ return true;
}
else
- return 0;
+ return false;
}
void
bool
linux_process_target::supports_hardware_single_step ()
{
- return can_hardware_single_step ();
+ return true;
}
bool
{
if (supports_software_single_step ())
return true;
- if (*the_low_target.supports_range_stepping == NULL)
- return false;
- return (*the_low_target.supports_range_stepping) ();
+ return low_supports_range_stepping ();
+}
+
+bool
+linux_process_target::low_supports_range_stepping ()
+{
+ return false;
}
bool
bool
linux_process_target::supports_catch_syscall ()
{
- return (the_low_target.get_syscall_trapinfo != NULL
+ return (low_supports_catch_syscall ()
&& linux_supports_tracesysgood ());
}
-int
-linux_process_target::get_ipa_tdesc_idx ()
+bool
+linux_process_target::low_supports_catch_syscall ()
{
- if (the_low_target.get_ipa_tdesc_idx == NULL)
- return 0;
-
- return (*the_low_target.get_ipa_tdesc_idx) ();
+ return false;
}
CORE_ADDR
target_unpause_all (true);
}
-bool
-linux_process_target::supports_fast_tracepoints ()
-{
- return the_low_target.install_fast_tracepoint_jump_pad != nullptr;
-}
-
-int
-linux_process_target::install_fast_tracepoint_jump_pad
- (CORE_ADDR tpoint, CORE_ADDR tpaddr, CORE_ADDR collector,
- CORE_ADDR lockaddr, ULONGEST orig_size, CORE_ADDR *jump_entry,
- CORE_ADDR *trampoline, ULONGEST *trampoline_size,
- unsigned char *jjump_pad_insn, ULONGEST *jjump_pad_insn_size,
- CORE_ADDR *adjusted_insn_addr, CORE_ADDR *adjusted_insn_addr_end,
- char *err)
-{
- return (*the_low_target.install_fast_tracepoint_jump_pad)
- (tpoint, tpaddr, collector, lockaddr, orig_size,
- jump_entry, trampoline, trampoline_size,
- jjump_pad_insn, jjump_pad_insn_size,
- adjusted_insn_addr, adjusted_insn_addr_end,
- err);
-}
-
-emit_ops *
-linux_process_target::emit_ops ()
-{
- if (the_low_target.emit_ops != NULL)
- return (*the_low_target.emit_ops) ();
- else
- return NULL;
-}
-
-int
-linux_process_target::get_min_fast_tracepoint_insn_len ()
-{
- return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
-}
-
/* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
static int
projects / deliverable / binutils-gdb.git / blobdiff