static int stabilizing_threads;
static void unsuspend_all_lwps (struct lwp_info *except);
-static struct lwp_info *add_lwp (ptid_t ptid);
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);
return 0;
}
-/* Returns true if this target can support fast tracepoints. This
- does not mean that the in-process agent has been loaded in the
- inferior. */
-
-static int
-supports_fast_tracepoints (void)
-{
- return the_low_target.install_fast_tracepoint_jump_pad != NULL;
-}
-
/* True if LWP is stopped in its stepping range. */
static int
return elf_64_file_p (file, machine);
}
-static void
-delete_lwp (struct lwp_info *lwp)
+void
+linux_process_target::delete_lwp (lwp_info *lwp)
{
struct thread_info *thr = get_lwp_thread (lwp);
remove_thread (thr);
- if (the_low_target.delete_thread != NULL)
- the_low_target.delete_thread (lwp->arch_private);
- else
- gdb_assert (lwp->arch_private == NULL);
+ low_delete_thread (lwp->arch_private);
free (lwp);
}
-/* Add a process to the common process list, and set its private
- data. */
+void
+linux_process_target::low_delete_thread (arch_lwp_info *info)
+{
+ /* Default implementation should be overridden if architecture-specific
+ info is being used. */
+ gdb_assert (info == nullptr);
+}
-static struct process_info *
-linux_add_process (int pid, int attached)
+process_info *
+linux_process_target::add_linux_process (int pid, int attached)
{
struct process_info *proc;
proc = add_process (pid, attached);
proc->priv = XCNEW (struct process_info_private);
- if (the_low_target.new_process != NULL)
- proc->priv->arch_private = the_low_target.new_process ();
+ proc->priv->arch_private = low_new_process ();
return proc;
}
+arch_process_info *
+linux_process_target::low_new_process ()
+{
+ return nullptr;
+}
+
+void
+linux_process_target::low_delete_process (arch_process_info *info)
+{
+ /* Default implementation must be overridden if architecture-specific
+ info exists. */
+ gdb_assert (info == nullptr);
+}
+
+void
+linux_process_target::low_new_fork (process_info *parent, process_info *child)
+{
+ /* Nop. */
+}
+
void
linux_process_target::arch_setup_thread (thread_info *thread)
{
will be detached, since we will need the process object and the
breakpoints to remove any breakpoints from memory when we
detach, and the client side will access registers. */
- child_proc = linux_add_process (new_pid, 0);
+ child_proc = add_linux_process (new_pid, 0);
gdb_assert (child_proc != NULL);
child_lwp = add_lwp (ptid);
gdb_assert (child_lwp != NULL);
child_proc->tdesc = tdesc;
/* Clone arch-specific process data. */
- if (the_low_target.new_fork != NULL)
- the_low_target.new_fork (parent_proc, child_proc);
+ low_new_fork (parent_proc, child_proc);
/* Save fork info in the parent thread. */
if (event == PTRACE_EVENT_FORK)
current_thread = NULL;
/* Create a new process/lwp/thread. */
- proc = linux_add_process (event_pid, 0);
+ proc = add_linux_process (event_pid, 0);
event_lwp = add_lwp (event_ptid);
event_thr = get_lwp_thread (event_lwp);
gdb_assert (current_thread == event_thr);
return true;
}
-static struct lwp_info *
-add_lwp (ptid_t ptid)
+lwp_info *
+linux_process_target::add_lwp (ptid_t ptid)
{
struct lwp_info *lwp;
lwp->thread = add_thread (ptid, lwp);
- if (the_low_target.new_thread != NULL)
- the_low_target.new_thread (lwp);
+ low_new_thread (lwp);
return lwp;
}
+void
+linux_process_target::low_new_thread (lwp_info *info)
+{
+ /* Nop. */
+}
+
/* Callback to be used when calling fork_inferior, responsible for
actually initiating the tracing of the inferior. */
NULL, NULL, NULL, NULL);
}
- linux_add_process (pid, 0);
+ add_linux_process (pid, 0);
ptid = ptid_t (pid, pid, 0);
new_lwp = add_lwp (ptid);
}
}
-/* Attach to an inferior process. Returns 0 on success, ERRNO on
- error. */
-
int
-linux_attach_lwp (ptid_t ptid)
+linux_process_target::attach_lwp (ptid_t ptid)
{
struct lwp_info *new_lwp;
int lwpid = ptid.lwp ();
if (debug_threads)
debug_printf ("Found new lwp %d\n", lwpid);
- err = linux_attach_lwp (ptid);
+ err = the_linux_target->attach_lwp (ptid);
/* Be quiet if we simply raced with the thread exiting. EPERM
is returned if the thread's task still exists, and is marked
ptid_t ptid = ptid_t (pid, pid, 0);
int err;
- proc = linux_add_process (pid, 1);
+ proc = add_linux_process (pid, 1);
/* Attach to PID. We will check for other threads
soon. */
- err = linux_attach_lwp (ptid);
+ err = attach_lwp (ptid);
if (err != 0)
{
remove_process (proc);
}
}
-/* Detach from LWP. */
-
-static void
-linux_detach_one_lwp (struct lwp_info *lwp)
+void
+linux_process_target::detach_one_lwp (lwp_info *lwp)
{
struct thread_info *thread = get_lwp_thread (lwp);
int sig;
regcache_invalidate_thread (thread);
/* Finally, let it resume. */
- if (the_low_target.prepare_to_resume != NULL)
- the_low_target.prepare_to_resume (lwp);
+ low_prepare_to_resume (lwp);
}
catch (const gdb_exception_error &ex)
{
delete_lwp (lwp);
}
-/* Callback for for_each_thread. Detaches from non-leader threads of a
- given process. */
-
-static void
-linux_detach_lwp_callback (thread_info *thread)
-{
- /* We don't actually detach from the thread group leader just yet.
- If the thread group exits, we must reap the zombie clone lwps
- before we're able to reap the leader. */
- if (thread->id.pid () == thread->id.lwp ())
- return;
-
- lwp_info *lwp = get_thread_lwp (thread);
- linux_detach_one_lwp (lwp);
-}
-
int
linux_process_target::detach (process_info *process)
{
/* Detach from the clone lwps first. If the thread group exits just
while we're detaching, we must reap the clone lwps before we're
able to reap the leader. */
- for_each_thread (process->pid, linux_detach_lwp_callback);
+ for_each_thread (process->pid, [this] (thread_info *thread)
+ {
+ /* We don't actually detach from the thread group leader just yet.
+ If the thread group exits, we must reap the zombie clone lwps
+ before we're able to reap the leader. */
+ if (thread->id.pid () == thread->id.lwp ())
+ return;
+
+ lwp_info *lwp = get_thread_lwp (thread);
+ detach_one_lwp (lwp);
+ });
main_lwp = find_lwp_pid (ptid_t (process->pid));
- linux_detach_one_lwp (main_lwp);
+ detach_one_lwp (main_lwp);
mourn (process);
thread_db_mourn (process);
#endif
- for_each_thread (process->pid, [] (thread_info *thread)
+ for_each_thread (process->pid, [this] (thread_info *thread)
{
delete_lwp (get_thread_lwp (thread));
});
/* Freeing all private data. */
priv = process->priv;
- if (the_low_target.delete_process != NULL)
- the_low_target.delete_process (priv->arch_private);
- else
- gdb_assert (priv->arch_private == NULL);
+ low_delete_process (priv->arch_private);
free (priv);
process->priv = NULL;
return get_thread_lwp (thread);
}
-/* Detect zombie thread group leaders, and "exit" them. We can't reap
- their exits until all other threads in the group have exited. */
-
-static void
-check_zombie_leaders (void)
+void
+linux_process_target::check_zombie_leaders ()
{
- for_each_process ([] (process_info *proc) {
+ for_each_process ([this] (process_info *proc) {
pid_t leader_pid = pid_of (proc);
struct lwp_info *leader_lp;
return 0;
}
-/* Convenience wrapper. Returns information about LWP's fast tracepoint
- collection status. */
-
-static fast_tpoint_collect_result
-linux_fast_tracepoint_collecting (struct lwp_info *lwp,
- struct fast_tpoint_collect_status *status)
+fast_tpoint_collect_result
+linux_process_target::linux_fast_tracepoint_collecting
+ (lwp_info *lwp, fast_tpoint_collect_status *status)
{
CORE_ADDR thread_area;
struct thread_info *thread = get_lwp_thread (lwp);
- if (the_low_target.get_thread_area == NULL)
- return fast_tpoint_collect_result::not_collecting;
-
/* Get the thread area address. This is used to recognize which
thread is which when tracing with the in-process agent library.
We don't read anything from the address, and treat it as opaque;
it's the address itself that we assume is unique per-thread. */
- if ((*the_low_target.get_thread_area) (lwpid_of (thread), &thread_area) == -1)
+ if (low_get_thread_area (lwpid_of (thread), &thread_area) == -1)
return fast_tpoint_collect_result::not_collecting;
return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
}
+int
+linux_process_target::low_get_thread_area (int lwpid, CORE_ADDR *addrp)
+{
+ return -1;
+}
+
bool
linux_process_target::maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat)
{
});
}
-static bool stuck_in_jump_pad_callback (thread_info *thread);
static bool lwp_running (thread_info *thread);
/* Stabilize threads (move out of jump pads).
void
linux_process_target::stabilize_threads ()
{
- thread_info *thread_stuck = find_thread (stuck_in_jump_pad_callback);
+ thread_info *thread_stuck = find_thread ([this] (thread_info *thread)
+ {
+ return stuck_in_jump_pad (thread);
+ });
if (thread_stuck != NULL)
{
if (debug_threads)
{
- thread_stuck = find_thread (stuck_in_jump_pad_callback);
+ thread_stuck = find_thread ([this] (thread_info *thread)
+ {
+ return stuck_in_jump_pad (thread);
+ });
if (thread_stuck != NULL)
debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
return null_ptid;
}
-/* Convenience function that is called when the kernel reports an exit
- event. This decides whether to report the event to GDB as a
- process exit event, a thread exit event, or to suppress the
- event. */
-
-static ptid_t
-filter_exit_event (struct lwp_info *event_child,
- struct target_waitstatus *ourstatus)
+ptid_t
+linux_process_target::filter_exit_event (lwp_info *event_child,
+ target_waitstatus *ourstatus)
{
client_state &cs = get_client_state ();
struct thread_info *thread = get_lwp_thread (event_child);
}
}
-/* Returns true if THREAD is stopped in a jump pad, and we can't
- move it out, because we need to report the stop event to GDB. For
- example, if the user puts a breakpoint in the jump pad, it's
- because she wants to debug it. */
-
-static bool
-stuck_in_jump_pad_callback (thread_info *thread)
+bool
+linux_process_target::stuck_in_jump_pad (thread_info *thread)
{
struct lwp_info *lwp = get_thread_lwp (thread);
lwpid_of (thread), step ? "step" : "continue", signal,
lwp->stop_expected ? "expected" : "not expected");
- if (the_low_target.prepare_to_resume != NULL)
- the_low_target.prepare_to_resume (lwp);
+ low_prepare_to_resume (lwp);
regcache_invalidate_thread (thread);
errno = 0;
lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
}
+void
+linux_process_target::low_prepare_to_resume (lwp_info *lwp)
+{
+ /* Nop. */
+}
+
/* Called when we try to resume a stopped LWP and that errors out. If
the LWP is no longer in ptrace-stopped state (meaning it's zombie,
or about to become), discard the error, clear any pending status
}
}
- if (the_low_target.supply_ptrace_register)
- the_low_target.supply_ptrace_register (regcache, regno, buf);
- else
- supply_register (regcache, regno, buf);
+ low_supply_ptrace_register (regcache, regno, buf);
}
void
buf = (char *) alloca (size);
memset (buf, 0, size);
- if (the_low_target.collect_ptrace_register)
- the_low_target.collect_ptrace_register (regcache, regno, buf);
- else
- collect_register (regcache, regno, buf);
+ low_collect_ptrace_register (regcache, regno, buf);
pid = lwpid_of (current_thread);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
}
#endif /* HAVE_LINUX_USRREGS */
+void
+linux_process_target::low_collect_ptrace_register (regcache *regcache,
+ int regno, char *buf)
+{
+ collect_register (regcache, regno, buf);
+}
+
+void
+linux_process_target::low_supply_ptrace_register (regcache *regcache,
+ int regno, const char *buf)
+{
+ supply_register (regcache, regno, buf);
+}
+
void
linux_process_target::usr_fetch_inferior_registers (const regs_info *regs_info,
regcache *regcache,
return linux_common_xfer_osdata (annex, readbuf, offset, len);
}
-/* Convert a native/host siginfo object, into/from the siginfo in the
- layout of the inferiors' architecture. */
-
-static void
-siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
+void
+linux_process_target::siginfo_fixup (siginfo_t *siginfo,
+ gdb_byte *inf_siginfo, int direction)
{
- int done = 0;
-
- if (the_low_target.siginfo_fixup != NULL)
- done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
+ bool done = low_siginfo_fixup (siginfo, inf_siginfo, direction);
/* If there was no callback, or the callback didn't do anything,
then just do a straight memcpy. */
}
}
+bool
+linux_process_target::low_siginfo_fixup (siginfo_t *native, gdb_byte *inf,
+ int direction)
+{
+ return false;
+}
+
bool
linux_process_target::supports_qxfer_siginfo ()
{
{
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
}
#endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
-void
-linux_process_target::process_qsupported (char **features, int count)
-{
- if (the_low_target.process_qsupported != NULL)
- the_low_target.process_qsupported (features, count);
-}
-
bool
linux_process_target::supports_catch_syscall ()
{
return (*the_low_target.get_ipa_tdesc_idx) ();
}
-bool
-linux_process_target::supports_tracepoints ()
-{
- if (*the_low_target.supports_tracepoints == NULL)
- return false;
-
- return (*the_low_target.supports_tracepoints) ();
-}
-
CORE_ADDR
linux_process_target::read_pc (regcache *regcache)
{
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