} Elf64_auxv_t;
#endif
-/* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
- representation of the thread ID.
-
- ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
- the same as the LWP ID.
-
- ``all_processes'' is keyed by the "overall process ID", which
- GNU/Linux calls tgid, "thread group ID". */
-
-struct inferior_list all_lwps;
-
/* A list of all unknown processes which receive stop signals. Some
other process will presumably claim each of these as forked
children momentarily. */
delete_lwp (struct lwp_info *lwp)
{
remove_thread (get_lwp_thread (lwp));
- remove_inferior (&all_lwps, &lwp->entry);
free (lwp->arch_private);
free (lwp);
}
handle_extended_wait (struct lwp_info *event_child, int wstat)
{
int event = wstat >> 16;
+ struct thread_info *event_thr = get_lwp_thread (event_child);
struct lwp_info *new_lwp;
if (event == PTRACE_EVENT_CLONE)
unsigned long new_pid;
int ret, status;
- ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), (PTRACE_TYPE_ARG3) 0,
+ ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0,
&new_pid);
/* If we haven't already seen the new PID stop, wait for it now. */
warning ("wait returned unexpected status 0x%x", status);
}
- ptid = ptid_build (pid_of (event_child), new_pid, 0);
+ ptid = ptid_build (pid_of (event_thr), new_pid, 0);
new_lwp = add_lwp (ptid);
/* Either we're going to immediately resume the new thread
lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
memset (lwp, 0, sizeof (*lwp));
- lwp->entry.id = ptid;
-
if (the_low_target.new_thread != NULL)
lwp->arch_private = the_low_target.new_thread ();
- add_inferior_to_list (&all_lwps, &lwp->entry);
lwp->thread = add_thread (ptid, lwp);
return lwp;
/* Note that extracting the pid from the current inferior is
safe, since we're always called in the context of the same
process as this new thread. */
- int pid = pid_of (get_thread_lwp (current_inferior));
+ int pid = pid_of (current_inferior);
ptid = ptid_build (pid, lwpid, 0);
}
static void
linux_kill_one_lwp (struct lwp_info *lwp)
{
- int pid = lwpid_of (lwp);
+ struct thread_info *thr = get_lwp_thread (lwp);
+ int pid = lwpid_of (thr);
/* PTRACE_KILL is unreliable. After stepping into a signal handler,
there is no signal context, and ptrace(PTRACE_KILL) (or
kill (pid, SIGKILL);
if (debug_threads)
debug_printf ("LKL: kill (SIGKILL) %s, 0, 0 (%s)\n",
- target_pid_to_str (ptid_of (lwp)),
+ target_pid_to_str (ptid_of (thr)),
errno ? strerror (errno) : "OK");
errno = 0;
ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
if (debug_threads)
debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
- target_pid_to_str (ptid_of (lwp)),
+ target_pid_to_str (ptid_of (thr)),
errno ? strerror (errno) : "OK");
}
the children get a chance to be reaped, it will remain a zombie
forever. */
- if (lwpid_of (lwp) == pid)
+ if (lwpid_of (thread) == pid)
{
if (debug_threads)
debug_printf ("lkop: is last of process %s\n",
linux_kill_one_lwp (lwp);
/* Make sure it died. The loop is most likely unnecessary. */
- pid = linux_wait_for_event (lwp->entry.id, &wstat, __WALL);
+ pid = linux_wait_for_event (thread->entry.id, &wstat, __WALL);
} while (pid > 0 && WIFSTOPPED (wstat));
return 0;
if (lwp == NULL)
{
if (debug_threads)
- debug_printf ("lk_1: cannot find lwp %ld, for pid: %d\n",
- lwpid_of (lwp), pid);
+ debug_printf ("lk_1: cannot find lwp for pid: %d\n",
+ pid);
}
else
{
+ struct thread_info *thr = get_lwp_thread (lwp);
+
if (debug_threads)
debug_printf ("lk_1: killing lwp %ld, for pid: %d\n",
- lwpid_of (lwp), pid);
+ lwpid_of (thr), pid);
do
{
linux_kill_one_lwp (lwp);
/* Make sure it died. The loop is most likely unnecessary. */
- lwpid = linux_wait_for_event (lwp->entry.id, &wstat, __WALL);
+ lwpid = linux_wait_for_event (thr->entry.id, &wstat, __WALL);
} while (lwpid > 0 && WIFSTOPPED (wstat));
}
{
if (debug_threads)
debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
- target_pid_to_str (ptid_of (lp)));
+ target_pid_to_str (ptid_of (thread)));
return 0;
}
if (debug_threads)
debug_printf ("GPS: lwp %s had stopped with extended "
"status: no pending signal\n",
- target_pid_to_str (ptid_of (lp)));
+ target_pid_to_str (ptid_of (thread)));
return 0;
}
{
if (debug_threads)
debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
- target_pid_to_str (ptid_of (lp)),
+ target_pid_to_str (ptid_of (thread)),
gdb_signal_to_string (signo));
return 0;
}
debug_printf ("GPS: lwp %s had signal %s, "
"but we don't know if we should pass it. "
"Default to not.\n",
- target_pid_to_str (ptid_of (lp)),
+ target_pid_to_str (ptid_of (thread)),
gdb_signal_to_string (signo));
return 0;
}
{
if (debug_threads)
debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
- target_pid_to_str (ptid_of (lp)),
+ target_pid_to_str (ptid_of (thread)),
gdb_signal_to_string (signo));
return WSTOPSIG (status);
{
if (debug_threads)
debug_printf ("Sending SIGCONT to %s\n",
- target_pid_to_str (ptid_of (lwp)));
+ target_pid_to_str (ptid_of (thread)));
- kill_lwp (lwpid_of (lwp), SIGCONT);
+ kill_lwp (lwpid_of (thread), SIGCONT);
lwp->stop_expected = 0;
}
/* Flush any pending changes to the process's registers. */
- regcache_invalidate_thread (get_lwp_thread (lwp));
+ regcache_invalidate_thread (thread);
/* Pass on any pending signal for this thread. */
sig = get_detach_signal (thread);
/* Finally, let it resume. */
if (the_low_target.prepare_to_resume != NULL)
the_low_target.prepare_to_resume (lwp);
- if (ptrace (PTRACE_DETACH, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+ if (ptrace (PTRACE_DETACH, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
(PTRACE_TYPE_ARG4) (long) sig) < 0)
error (_("Can't detach %s: %s"),
- target_pid_to_str (ptid_of (lwp)),
+ target_pid_to_str (ptid_of (thread)),
strerror (errno));
delete_lwp (lwp);
static int
delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
struct process_info *process = proc;
- if (pid_of (lwp) == pid_of (process))
+ if (pid_of (thread) == pid_of (process))
delete_lwp (lwp);
return 0;
thread_db_mourn (process);
#endif
- find_inferior (&all_lwps, delete_lwp_callback, process);
+ find_inferior (&all_threads, delete_lwp_callback, process);
/* Freeing all private data. */
priv = process->private;
static int
status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
ptid_t ptid = * (ptid_t *) arg;
- struct thread_info *thread;
/* Check if we're only interested in events from a specific process
or its lwps. */
if (!ptid_equal (minus_one_ptid, ptid)
- && ptid_get_pid (ptid) != ptid_get_pid (lwp->entry.id))
+ && ptid_get_pid (ptid) != ptid_get_pid (thread->entry.id))
return 0;
- thread = get_lwp_thread (lwp);
-
/* If we got a `vCont;t', but we haven't reported a stop yet, do
report any status pending the LWP may have. */
if (thread->last_resume_kind == resume_stop
struct lwp_info *
find_lwp_pid (ptid_t ptid)
{
- return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
+ struct inferior_list_entry *thread
+ = find_inferior (&all_threads, same_lwp, &ptid);
+
+ if (thread == NULL)
+ return NULL;
+
+ return get_thread_lwp ((struct thread_info *) thread);
}
static struct lwp_info *
{
int ret;
int to_wait_for = -1;
- struct lwp_info *child = NULL;
+ struct lwp_info *child;
+ struct thread_info *thread;
if (debug_threads)
debug_printf ("linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
debug_printf ("Got an event from %d (%x)\n", ret, *wstatp);
child = find_lwp_pid (pid_to_ptid (ret));
+ if (child != NULL)
+ thread = get_lwp_thread (child);
+ else
+ thread = NULL;
/* If we didn't find a process, one of two things presumably happened:
- A process we started and then detached from has exited. Ignore it.
needs to happen after we have attached to the inferior and it
is stopped for the first time, but before we access any
inferior registers. */
- proc = find_process_pid (pid_of (child));
+ proc = find_process_pid (pid_of (thread));
if (proc->private->new_inferior)
{
struct thread_info *saved_inferior;
saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (child);
+ current_inferior = thread;
the_low_target.arch_setup ();
struct 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 0;
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 (lwp), &thread_area) == -1)
+ if ((*the_low_target.get_thread_area) (lwpid_of (thread), &thread_area) == -1)
return 0;
return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad.\n",
- lwpid_of (lwp));
+ lwpid_of (current_inferior));
r = linux_fast_tracepoint_collecting (lwp, &status);
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of "
"the jump pad...it does\n",
- lwpid_of (lwp));
+ lwpid_of (current_inferior));
current_inferior = saved_inferior;
return 1;
|| WSTOPSIG (*wstat) == SIGFPE
|| WSTOPSIG (*wstat) == SIGBUS
|| WSTOPSIG (*wstat) == SIGSEGV)
- && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp),
+ && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior),
(PTRACE_TYPE_ARG3) 0, &info) == 0
/* Final check just to make sure we don't clobber
the siginfo of non-kernel-sent signals. */
&& (uintptr_t) info.si_addr == lwp->stop_pc)
{
info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
- ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp),
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (current_inferior),
(PTRACE_TYPE_ARG3) 0, &info);
}
- regcache = get_thread_regcache (get_lwp_thread (lwp), 1);
+ regcache = get_thread_regcache (current_inferior, 1);
(*the_low_target.set_pc) (regcache, status.tpoint_addr);
lwp->stop_pc = status.tpoint_addr;
if (debug_threads)
debug_printf ("Checking whether LWP %ld needs to move out of the "
"jump pad...no\n",
- lwpid_of (lwp));
+ lwpid_of (current_inferior));
current_inferior = saved_inferior;
return 0;
enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
{
struct pending_signals *p_sig;
+ struct thread_info *thread = get_lwp_thread (lwp);
if (debug_threads)
debug_printf ("Deferring signal %d for LWP %ld.\n",
- WSTOPSIG (*wstat), lwpid_of (lwp));
+ WSTOPSIG (*wstat), lwpid_of (thread));
if (debug_threads)
{
debug_printf ("Not requeuing already queued non-RT signal %d"
" for LWP %ld\n",
sig->signal,
- lwpid_of (lwp));
+ lwpid_of (thread));
return;
}
}
p_sig->prev = lwp->pending_signals_to_report;
p_sig->signal = WSTOPSIG (*wstat);
memset (&p_sig->info, 0, sizeof (siginfo_t));
- ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+ ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
&p_sig->info);
lwp->pending_signals_to_report = p_sig;
static int
dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
{
+ struct thread_info *thread = get_lwp_thread (lwp);
+
if (lwp->pending_signals_to_report != NULL)
{
struct pending_signals **p_sig;
*wstat = W_STOPCODE ((*p_sig)->signal);
if ((*p_sig)->info.si_signo != 0)
- ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
&(*p_sig)->info);
free (*p_sig);
*p_sig = NULL;
if (debug_threads)
debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
- WSTOPSIG (*wstat), lwpid_of (lwp));
+ WSTOPSIG (*wstat), lwpid_of (thread));
if (debug_threads)
{
{
if (debug_threads)
debug_printf ("CB: Push back breakpoint for %s\n",
- target_pid_to_str (ptid_of (lwp)));
+ target_pid_to_str (ptid_of (current_inferior)));
/* Back up the PC if necessary. */
if (the_low_target.decr_pc_after_break)
if (debug_threads)
debug_printf ("CB: No breakpoint found at %s for [%s]\n",
paddress (lwp->stop_pc),
- target_pid_to_str (ptid_of (lwp)));
+ target_pid_to_str (ptid_of (current_inferior)));
}
current_inferior = saved_inferior;
static int
linux_wait_for_event (ptid_t ptid, int *wstat, int options)
{
+ struct thread_info *event_thread;
struct lwp_info *event_child, *requested_child;
ptid_t wait_ptid;
+ /* N.B. event_thread points to the thread_info struct that contains
+ event_child. Keep them in sync. */
+ event_thread = NULL;
event_child = NULL;
requested_child = NULL;
if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
{
- event_child = (struct lwp_info *)
- find_inferior (&all_lwps, status_pending_p_callback, &ptid);
- if (debug_threads && event_child)
- debug_printf ("Got a pending child %ld\n", lwpid_of (event_child));
+ event_thread = (struct thread_info *)
+ find_inferior (&all_threads, status_pending_p_callback, &ptid);
+ if (event_thread != NULL)
+ event_child = get_thread_lwp (event_thread);
+ if (debug_threads && event_thread)
+ debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread));
}
else
{
fatal ("requesting an event out of a suspended child?");
if (requested_child->status_pending_p)
- event_child = requested_child;
+ {
+ event_child = requested_child;
+ event_thread = get_lwp_thread (event_child);
+ }
}
if (event_child != NULL)
{
if (debug_threads)
debug_printf ("Got an event from pending child %ld (%04x)\n",
- lwpid_of (event_child), event_child->status_pending);
+ lwpid_of (event_thread), event_child->status_pending);
*wstat = event_child->status_pending;
event_child->status_pending_p = 0;
event_child->status_pending = 0;
- current_inferior = get_lwp_thread (event_child);
- return lwpid_of (event_child);
+ current_inferior = event_thread;
+ return lwpid_of (event_thread);
}
if (ptid_is_pid (ptid))
if (event_child == NULL)
error ("event from unknown child");
+ event_thread = get_lwp_thread (event_child);
if (ptid_is_pid (ptid)
- && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child)))
+ && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_thread)))
{
if (! WIFSTOPPED (*wstat))
mark_lwp_dead (event_child, *wstat);
continue;
}
- current_inferior = get_lwp_thread (event_child);
+ current_inferior = event_thread;
/* Check for thread exit. */
if (! WIFSTOPPED (*wstat))
{
if (debug_threads)
- debug_printf ("LWP %ld exiting\n", lwpid_of (event_child));
+ debug_printf ("LWP %ld exiting\n", lwpid_of (event_thread));
/* If the last thread is exiting, just return. */
if (last_thread_of_process_p (current_inferior))
{
if (debug_threads)
debug_printf ("LWP %ld is last lwp of process\n",
- lwpid_of (event_child));
- return lwpid_of (event_child);
+ lwpid_of (event_thread));
+ return lwpid_of (event_thread);
}
if (!non_stop)
current_inferior = get_first_thread ();
if (debug_threads)
debug_printf ("Current inferior is now %ld\n",
- lwpid_of (get_thread_lwp (current_inferior)));
+ lwpid_of (current_inferior));
}
else
{
well, it did something. */
if (requested_child != NULL)
{
- int lwpid = lwpid_of (event_child);
+ int lwpid = lwpid_of (event_thread);
/* Cancel the step-over operation --- the thread that
started it is gone. */
if (event_child->must_set_ptrace_flags)
{
- linux_enable_event_reporting (lwpid_of (event_child));
+ linux_enable_event_reporting (lwpid_of (event_thread));
event_child->must_set_ptrace_flags = 0;
}
}
}
- return lwpid_of (event_child);
+ return lwpid_of (event_thread);
}
/* NOTREACHED */
static int
count_events_callback (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
int *count = data;
gdb_assert (count != NULL);
static int
select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
&& thread->last_resume_kind == resume_step
static int
select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
int *selector = data;
gdb_assert (selector != NULL);
static int
cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lp = get_thread_lwp (thread);
struct lwp_info *event_lp = data;
/* Leave the LWP that has been elected to receive a SIGTRAP alone. */
static void
linux_cancel_breakpoints (void)
{
- find_inferior (&all_lwps, cancel_breakpoints_callback, NULL);
+ find_inferior (&all_threads, cancel_breakpoints_callback, NULL);
}
/* Select one LWP out of those that have events pending. */
{
int num_events = 0;
int random_selector;
- struct lwp_info *event_lp;
+ struct thread_info *event_thread;
/* Give preference to any LWP that is being single-stepped. */
- event_lp
- = (struct lwp_info *) find_inferior (&all_lwps,
- select_singlestep_lwp_callback, NULL);
- if (event_lp != NULL)
+ event_thread
+ = (struct thread_info *) find_inferior (&all_threads,
+ select_singlestep_lwp_callback,
+ NULL);
+ if (event_thread != NULL)
{
if (debug_threads)
debug_printf ("SEL: Select single-step %s\n",
- target_pid_to_str (ptid_of (event_lp)));
+ target_pid_to_str (ptid_of (event_thread)));
}
else
{
which have had SIGTRAP events. */
/* First see how many SIGTRAP events we have. */
- find_inferior (&all_lwps, count_events_callback, &num_events);
+ find_inferior (&all_threads, count_events_callback, &num_events);
/* Now randomly pick a LWP out of those that have had a SIGTRAP. */
random_selector = (int)
debug_printf ("SEL: Found %d SIGTRAP events, selecting #%d\n",
num_events, random_selector);
- event_lp = (struct lwp_info *) find_inferior (&all_lwps,
- select_event_lwp_callback,
- &random_selector);
+ event_thread
+ = (struct thread_info *) find_inferior (&all_threads,
+ select_event_lwp_callback,
+ &random_selector);
}
- if (event_lp != NULL)
+ if (event_thread != NULL)
{
+ struct lwp_info *event_lp = get_thread_lwp (event_thread);
+
/* Switch the event LWP. */
*orig_lp = event_lp;
}
static int
unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
/* Ignore EXCEPT. */
if (lwp == except)
static void
unsuspend_all_lwps (struct lwp_info *except)
{
- find_inferior (&all_lwps, unsuspend_one_lwp, except);
+ find_inferior (&all_threads, unsuspend_one_lwp, except);
}
static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
linux_stabilize_threads (void)
{
struct thread_info *save_inferior;
- struct lwp_info *lwp_stuck;
+ struct thread_info *thread_stuck;
- lwp_stuck
- = (struct lwp_info *) find_inferior (&all_lwps,
- stuck_in_jump_pad_callback, NULL);
- if (lwp_stuck != NULL)
+ thread_stuck
+ = (struct thread_info *) find_inferior (&all_threads,
+ stuck_in_jump_pad_callback,
+ NULL);
+ if (thread_stuck != NULL)
{
if (debug_threads)
debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
- lwpid_of (lwp_stuck));
+ lwpid_of (thread_stuck));
return;
}
stabilizing_threads = 1;
/* Kick 'em all. */
- for_each_inferior (&all_lwps, move_out_of_jump_pad_callback);
+ for_each_inferior (&all_threads, move_out_of_jump_pad_callback);
/* Loop until all are stopped out of the jump pads. */
- while (find_inferior (&all_lwps, lwp_running, NULL) != NULL)
+ while (find_inferior (&all_threads, lwp_running, NULL) != NULL)
{
struct target_waitstatus ourstatus;
struct lwp_info *lwp;
}
}
- find_inferior (&all_lwps, unsuspend_one_lwp, NULL);
+ find_inferior (&all_threads, unsuspend_one_lwp, NULL);
stabilizing_threads = 0;
if (debug_threads)
{
- lwp_stuck
- = (struct lwp_info *) find_inferior (&all_lwps,
- stuck_in_jump_pad_callback, NULL);
- if (lwp_stuck != NULL)
+ thread_stuck
+ = (struct thread_info *) find_inferior (&all_threads,
+ stuck_in_jump_pad_callback,
+ NULL);
+ if (thread_stuck != NULL)
debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
- lwpid_of (lwp_stuck));
+ lwpid_of (thread_stuck));
}
}
{
debug_printf ("linux_wait_1 ret = %s, exited with "
"retcode %d\n",
- target_pid_to_str (ptid_of (event_child)),
+ target_pid_to_str (ptid_of (current_inferior)),
WEXITSTATUS (w));
debug_exit ();
}
{
debug_printf ("linux_wait_1 ret = %s, terminated with "
"signal %d\n",
- target_pid_to_str (ptid_of (event_child)),
+ target_pid_to_str (ptid_of (current_inferior)),
WTERMSIG (w));
debug_exit ();
}
}
- return ptid_of (event_child);
+ return ptid_of (current_inferior);
}
}
else
if (debug_threads)
debug_printf ("Got signal %d for LWP %ld. Check if we need "
"to defer or adjust it.\n",
- WSTOPSIG (w), lwpid_of (event_child));
+ WSTOPSIG (w), lwpid_of (current_inferior));
/* Allow debugging the jump pad itself. */
if (current_inferior->last_resume_kind != resume_step
if (debug_threads)
debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
- WSTOPSIG (w), lwpid_of (event_child));
+ WSTOPSIG (w), lwpid_of (current_inferior));
linux_resume_one_lwp (event_child, 0, 0, NULL);
goto retry;
if (debug_threads)
debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
"Check if we're already there.\n",
- lwpid_of (event_child),
+ lwpid_of (current_inferior),
event_child->collecting_fast_tracepoint);
trace_event = 1;
{
debug_printf ("linux_wait_1 ret = %s, stopped "
"while stabilizing threads\n",
- target_pid_to_str (ptid_of (event_child)));
+ target_pid_to_str (ptid_of (current_inferior)));
debug_exit ();
}
- return ptid_of (event_child);
+ return ptid_of (current_inferior);
}
}
}
if (debug_threads)
debug_printf ("Ignored signal %d for LWP %ld.\n",
- WSTOPSIG (w), lwpid_of (event_child));
+ WSTOPSIG (w), lwpid_of (current_inferior));
- if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child),
+ if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior),
(PTRACE_TYPE_ARG3) 0, &info) == 0)
info_p = &info;
else
if (the_low_target.set_pc != NULL)
{
struct regcache *regcache
- = get_thread_regcache (get_lwp_thread (event_child), 1);
+ = get_thread_regcache (current_inferior, 1);
(*the_low_target.set_pc) (regcache, event_child->stop_pc);
}
breakpoints in other LWPs that have hit a GDB breakpoint.
See the comment in cancel_breakpoints_callback to find out
why. */
- find_inferior (&all_lwps, cancel_breakpoints_callback, event_child);
+ find_inferior (&all_threads, cancel_breakpoints_callback, event_child);
/* If we were going a step-over, all other threads but the stepping one
had been paused in start_step_over, with their suspend counts
if (debug_threads)
{
debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
- target_pid_to_str (ptid_of (event_child)),
+ target_pid_to_str (ptid_of (current_inferior)),
ourstatus->kind, ourstatus->value.sig);
debug_exit ();
}
- return ptid_of (event_child);
+ return ptid_of (current_inferior);
}
/* Get rid of any pending event in the pipe. */
{
int pid;
- pid = lwpid_of (lwp);
+ pid = lwpid_of (get_lwp_thread (lwp));
/* If we already have a pending stop signal for this process, don't
send another. */
static int
send_sigstop_callback (struct inferior_list_entry *entry, void *except)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
/* Ignore EXCEPT. */
if (lwp == except)
suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
void *except)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
/* Ignore EXCEPT. */
if (lwp == except)
static void
wait_for_sigstop (struct inferior_list_entry *entry)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
struct thread_info *saved_inferior;
int wstat;
ptid_t saved_tid;
{
if (debug_threads)
debug_printf ("wait_for_sigstop: LWP %ld already stopped\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return;
}
else
saved_tid = null_ptid; /* avoid bogus unused warning */
- ptid = lwp->entry.id;
+ ptid = thread->entry.id;
if (debug_threads)
debug_printf ("wait_for_sigstop: pulling one event\n");
{
if (debug_threads)
debug_printf ("LWP %ld stopped with signal %d\n",
- lwpid_of (lwp), WSTOPSIG (wstat));
+ lwpid_of (thread), WSTOPSIG (wstat));
if (WSTOPSIG (wstat) != SIGSTOP)
{
if (debug_threads)
debug_printf ("LWP %ld stopped with non-sigstop status %06x\n",
- lwpid_of (lwp), wstat);
+ lwpid_of (thread), wstat);
lwp->status_pending_p = 1;
lwp->status_pending = wstat;
static int
stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lwp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
gdb_assert (lwp->suspended == 0);
gdb_assert (lwp->stopped);
static void
move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
- struct thread_info *thread = get_lwp_thread (lwp);
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
int *wstat;
gdb_assert (lwp->suspended == 0);
{
if (debug_threads)
debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
if (wstat)
{
if (debug_threads)
debug_printf ("Signal %d for LWP %ld deferred "
"(in jump pad)\n",
- WSTOPSIG (*wstat), lwpid_of (lwp));
+ WSTOPSIG (*wstat), lwpid_of (thread));
}
linux_resume_one_lwp (lwp, 0, 0, NULL);
static int
lwp_running (struct inferior_list_entry *entry, void *data)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
if (lwp->dead)
return 0;
debug_printf ("stop_all_lwps (%s, except=%s)\n",
suspend ? "stop-and-suspend" : "stop",
except != NULL
- ? target_pid_to_str (ptid_of (except))
+ ? target_pid_to_str (ptid_of (get_lwp_thread (except)))
: "none");
}
: STOPPING_THREADS);
if (suspend)
- find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except);
+ find_inferior (&all_threads, suspend_and_send_sigstop_callback, except);
else
- find_inferior (&all_lwps, send_sigstop_callback, except);
- for_each_inferior (&all_lwps, wait_for_sigstop);
+ find_inferior (&all_threads, send_sigstop_callback, except);
+ for_each_inferior (&all_threads, wait_for_sigstop);
stopping_threads = NOT_STOPPING_THREADS;
if (debug_threads)
linux_resume_one_lwp (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
{
+ struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_inferior;
int fast_tp_collecting;
{
/* Collecting 'while-stepping' actions doesn't make sense
anymore. */
- release_while_stepping_state_list (get_lwp_thread (lwp));
+ release_while_stepping_state_list (thread);
}
/* If we have pending signals or status, and a new signal, enqueue the
if (debug_threads)
debug_printf ("Not resuming lwp %ld (%s, signal %d, stop %s);"
" has pending status\n",
- lwpid_of (lwp), step ? "step" : "continue", signal,
+ lwpid_of (thread), step ? "step" : "continue", signal,
lwp->stop_expected ? "expected" : "not expected");
return;
}
saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (lwp);
+ current_inferior = thread;
if (debug_threads)
debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
- lwpid_of (lwp), step ? "step" : "continue", signal,
+ lwpid_of (thread), step ? "step" : "continue", signal,
lwp->stop_expected ? "expected" : "not expected");
/* This bit needs some thinking about. If we get a signal that
if (debug_threads)
debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
" (exit-jump-pad-bkpt)\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
/* Postpone any pending signal. It was enqueued above. */
signal = 0;
if (debug_threads)
debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
" single-stepping\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
if (can_hardware_single_step ())
step = 1;
address, continue, and carry on catching this while-stepping
action only when that breakpoint is hit. A future
enhancement. */
- if (get_lwp_thread (lwp)->while_stepping != NULL
+ if (thread->while_stepping != NULL
&& can_hardware_single_step ())
{
if (debug_threads)
debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
step = 1;
}
signal = (*p_sig)->signal;
if ((*p_sig)->info.si_signo != 0)
- ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+ ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
&(*p_sig)->info);
free (*p_sig);
if (the_low_target.prepare_to_resume != NULL)
the_low_target.prepare_to_resume (lwp);
- regcache_invalidate_thread (get_lwp_thread (lwp));
+ regcache_invalidate_thread (thread);
errno = 0;
lwp->stopped = 0;
lwp->stopped_by_watchpoint = 0;
lwp->stepping = step;
- ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp),
+ ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (thread),
(PTRACE_TYPE_ARG3) 0,
/* Coerce to a uintptr_t first to avoid potential gcc warning
of coercing an 8 byte integer to a 4 byte pointer. */
static int
linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
{
- struct lwp_info *lwp;
- struct thread_info *thread;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
int ndx;
struct thread_resume_array *r;
- thread = (struct thread_info *) entry;
- lwp = get_thread_lwp (thread);
r = arg;
for (ndx = 0; ndx < r->n; ndx++)
|| ptid_equal (ptid, entry->id)
/* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
of PID'. */
- || (ptid_get_pid (ptid) == pid_of (lwp)
+ || (ptid_get_pid (ptid) == pid_of (thread)
&& (ptid_is_pid (ptid)
|| ptid_get_lwp (ptid) == -1)))
{
== TARGET_WAITKIND_STOPPED)
? "stopped"
: "stopping",
- lwpid_of (lwp));
+ lwpid_of (thread));
continue;
}
if (debug_threads)
debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
"leaving status pending.\n",
- WSTOPSIG (lwp->status_pending), lwpid_of (lwp));
+ WSTOPSIG (lwp->status_pending),
+ lwpid_of (thread));
}
return 0;
static int
resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
/* LWPs which will not be resumed are not interesting, because
we might not wait for them next time through linux_wait. */
static int
need_step_over_p (struct inferior_list_entry *entry, void *dummy)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
- struct thread_info *thread;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
struct thread_info *saved_inferior;
CORE_ADDR pc;
{
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
- thread = get_lwp_thread (lwp);
-
if (thread->last_resume_kind == resume_stop)
{
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
" stopped\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
{
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
if (!lwp->need_step_over)
{
if (debug_threads)
- debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (lwp));
+ debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (thread));
}
if (lwp->status_pending_p)
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
" status.\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
"Old stop_pc was 0x%s, PC is now 0x%s\n",
- lwpid_of (lwp), paddress (lwp->stop_pc), paddress (pc));
+ lwpid_of (thread),
+ paddress (lwp->stop_pc), paddress (pc));
lwp->need_step_over = 0;
return 0;
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? yes, but found"
" GDB breakpoint at 0x%s; skipping step over\n",
- lwpid_of (lwp), paddress (pc));
+ lwpid_of (thread), paddress (pc));
current_inferior = saved_inferior;
return 0;
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? yes, "
"found breakpoint at 0x%s\n",
- lwpid_of (lwp), paddress (pc));
+ lwpid_of (thread), paddress (pc));
/* We've found an lwp that needs stepping over --- return 1 so
that find_inferior stops looking. */
if (debug_threads)
debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
" at 0x%s\n",
- lwpid_of (lwp), paddress (pc));
+ lwpid_of (thread), paddress (pc));
return 0;
}
static int
start_step_over (struct lwp_info *lwp)
{
+ struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_inferior;
CORE_ADDR pc;
int step;
if (debug_threads)
debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
stop_all_lwps (1, lwp);
gdb_assert (lwp->suspended == 0);
pc = get_pc (lwp);
saved_inferior = current_inferior;
- current_inferior = get_lwp_thread (lwp);
+ current_inferior = thread;
lwp->bp_reinsert = pc;
uninsert_breakpoints_at (pc);
linux_resume_one_lwp (lwp, step, 0, NULL);
/* Require next event from this LWP. */
- step_over_bkpt = lwp->entry.id;
+ step_over_bkpt = thread->entry.id;
return 1;
}
static int
linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
{
- struct lwp_info *lwp;
- struct thread_info *thread;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
int step;
int leave_all_stopped = * (int *) arg;
int leave_pending;
- thread = (struct thread_info *) entry;
- lwp = get_thread_lwp (thread);
-
if (lwp->resume == NULL)
return 0;
if (lwp->resume->kind == resume_stop)
{
if (debug_threads)
- debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (lwp));
+ debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread));
if (!lwp->stopped)
{
if (debug_threads)
- debug_printf ("stopping LWP %ld\n", lwpid_of (lwp));
+ debug_printf ("stopping LWP %ld\n", lwpid_of (thread));
/* Stop the thread, and wait for the event asynchronously,
through the event loop. */
{
if (debug_threads)
debug_printf ("already stopped LWP %ld\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
/* The LWP may have been stopped in an internal event that
was not meant to be notified back to GDB (e.g., gdbserver
if (!leave_pending)
{
if (debug_threads)
- debug_printf ("resuming LWP %ld\n", lwpid_of (lwp));
+ debug_printf ("resuming LWP %ld\n", lwpid_of (thread));
step = (lwp->resume->kind == resume_step);
linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
else
{
if (debug_threads)
- debug_printf ("leaving LWP %ld stopped\n", lwpid_of (lwp));
+ debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread));
/* If we have a new signal, enqueue the signal. */
if (lwp->resume->sig != 0)
PTRACE_SETSIGINFO. */
if (WIFSTOPPED (lwp->last_status)
&& WSTOPSIG (lwp->last_status) == lwp->resume->sig)
- ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+ ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
&p_sig->info);
lwp->pending_signals = p_sig;
linux_resume (struct thread_resume *resume_info, size_t n)
{
struct thread_resume_array array = { resume_info, n };
- struct lwp_info *need_step_over = NULL;
+ struct thread_info *need_step_over = NULL;
int any_pending;
int leave_all_stopped;
before considering to start a step-over (in all-stop). */
any_pending = 0;
if (!non_stop)
- find_inferior (&all_lwps, resume_status_pending_p, &any_pending);
+ find_inferior (&all_threads, resume_status_pending_p, &any_pending);
/* If there is a thread which would otherwise be resumed, which is
stopped at a breakpoint that needs stepping over, then don't
queued. */
if (!any_pending && supports_breakpoints ())
need_step_over
- = (struct lwp_info *) find_inferior (&all_lwps,
- need_step_over_p, NULL);
+ = (struct thread_info *) find_inferior (&all_threads,
+ need_step_over_p, NULL);
leave_all_stopped = (need_step_over != NULL || any_pending);
find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
if (need_step_over)
- start_step_over (need_step_over);
+ start_step_over (get_thread_lwp (need_step_over));
if (debug_threads)
{
static int
proceed_one_lwp (struct inferior_list_entry *entry, void *except)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
- struct thread_info *thread;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
int step;
if (lwp == except)
return 0;
if (debug_threads)
- debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (lwp));
+ debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread));
if (!lwp->stopped)
{
if (debug_threads)
- debug_printf (" LWP %ld already running\n", lwpid_of (lwp));
+ debug_printf (" LWP %ld already running\n", lwpid_of (thread));
return 0;
}
- thread = get_lwp_thread (lwp);
-
if (thread->last_resume_kind == resume_stop
&& thread->last_status.kind != TARGET_WAITKIND_IGNORE)
{
if (debug_threads)
debug_printf (" client wants LWP to remain %ld stopped\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
{
if (debug_threads)
debug_printf (" LWP %ld has pending status, leaving stopped\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
return 0;
}
if (lwp->suspended)
{
if (debug_threads)
- debug_printf (" LWP %ld is suspended\n", lwpid_of (lwp));
+ debug_printf (" LWP %ld is suspended\n", lwpid_of (thread));
return 0;
}
if (debug_threads)
debug_printf ("Client wants LWP %ld to stop. "
"Making sure it has a SIGSTOP pending\n",
- lwpid_of (lwp));
+ lwpid_of (thread));
send_sigstop (lwp);
}
static int
unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
{
- struct lwp_info *lwp = (struct lwp_info *) entry;
+ struct thread_info *thread = (struct thread_info *) entry;
+ struct lwp_info *lwp = get_thread_lwp (thread);
if (lwp == except)
return 0;
static void
proceed_all_lwps (void)
{
- struct lwp_info *need_step_over;
+ struct thread_info *need_step_over;
/* If there is a thread which would otherwise be resumed, which is
stopped at a breakpoint that needs stepping over, then don't
if (supports_breakpoints ())
{
need_step_over
- = (struct lwp_info *) find_inferior (&all_lwps,
- need_step_over_p, NULL);
+ = (struct thread_info *) find_inferior (&all_threads,
+ need_step_over_p, NULL);
if (need_step_over != NULL)
{
"thread %ld needing a step-over\n",
lwpid_of (need_step_over));
- start_step_over (need_step_over);
+ start_step_over (get_thread_lwp (need_step_over));
return;
}
}
if (debug_threads)
debug_printf ("Proceeding, no step-over needed\n");
- find_inferior (&all_lwps, proceed_one_lwp, NULL);
+ find_inferior (&all_threads, proceed_one_lwp, NULL);
}
/* Stopped LWPs that the client wanted to be running, that don't have
debug_enter ();
if (except)
debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
- lwpid_of (except));
+ lwpid_of (get_lwp_thread (except)));
else
debug_printf ("unstopping all lwps\n");
}
if (unsuspend)
- find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
+ find_inferior (&all_threads, unsuspend_and_proceed_one_lwp, except);
else
- find_inferior (&all_lwps, proceed_one_lwp, except);
+ find_inferior (&all_threads, proceed_one_lwp, except);
if (debug_threads)
{
regset = regsets_info->regsets;
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
while (regset->size >= 0)
{
void *buf, *data;
regset = regsets_info->regsets;
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
while (regset->size >= 0)
{
void *buf, *data;
& -sizeof (PTRACE_XFER_TYPE));
buf = alloca (size);
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
else
collect_register (regcache, regno, buf);
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
{
errno = 0;
static int
linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
- int pid = lwpid_of (get_thread_lwp (current_inferior));
+ int pid = lwpid_of (current_inferior);
register PTRACE_XFER_TYPE *buffer;
register CORE_ADDR addr;
register int count;
register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
alloca (count * sizeof (PTRACE_XFER_TYPE));
- int pid = lwpid_of (get_thread_lwp (current_inferior));
+ int pid = lwpid_of (current_inferior);
if (len == 0)
{
if (!ptid_equal (cont_thread, null_ptid)
&& !ptid_equal (cont_thread, minus_one_ptid))
{
- struct lwp_info *lwp;
int lwpid;
- lwp = get_thread_lwp (current_inferior);
- lwpid = lwpid_of (lwp);
+ lwpid = lwpid_of (current_inferior);
kill_lwp (lwpid, SIGINT);
}
else
{
char filename[PATH_MAX];
int fd, n;
- int pid = lwpid_of (get_thread_lwp (current_inferior));
+ int pid = lwpid_of (current_inferior);
xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
if (current_inferior == NULL)
return -1;
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
if (debug_threads)
debug_printf ("%s siginfo for lwp %d.\n",
unsigned const char *writebuf,
CORE_ADDR offset, int len)
{
- long pid = lwpid_of (get_thread_lwp (current_inferior));
+ long pid = lwpid_of (current_inferior);
char buf[128];
int fd = 0;
int ret = 0;
if (readbuf == NULL)
return -1;
- pid = lwpid_of (get_thread_lwp (current_inferior));
+ pid = lwpid_of (current_inferior);
xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
is_elf64 = elf_64_file_p (filename, &machine);
lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
projects / binutils-gdb.git / commitdiff