/* Interface GDB to the GNU Hurd.
- Copyright (C) 1992-2018 Free Software Foundation, Inc.
+ Copyright (C) 1992-2019 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/* Include this first, to pick up the <mach.h> 'thread_info' diversion. */
+#include "gnu-nat.h"
+
/* Mach/Hurd headers are not yet ready for C++ compilation. */
extern "C"
{
#include "value.h"
#include "language.h"
#include "target.h"
-#include "gdb_wait.h"
+#include "common/gdb_wait.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "gdbthread.h"
#include "gdb_obstack.h"
#include "tid-parse.h"
+#include "nat/fork-inferior.h"
-#include "gnu-nat.h"
#include "inf-child.h"
/* MIG stubs are not yet ready for C++ compilation. */
last = thread;
proc_debug (thread, "new thread: %lu", threads[i]);
- ptid = ptid_build (inf->pid, thread->tid, 0);
+ ptid = ptid_t (inf->pid, thread->tid, 0);
/* Tell GDB's generic thread code. */
- if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+ if (inferior_ptid == ptid_t (inf->pid))
/* This is the first time we're hearing about thread
ids, after a fork-child. */
thread_change_ptid (inferior_ptid, ptid);
waiting_inf = inf;
- inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
+ inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid).c_str ());
rewait:
if (proc_wait_pid != inf->pid && !inf->no_wait)
thread = inf->wait.thread;
if (thread)
- ptid = ptid_build (inf->pid, thread->tid, 0);
- else if (ptid_equal (ptid, minus_one_ptid))
+ ptid = ptid_t (inf->pid, thread->tid, 0);
+ else if (ptid == minus_one_ptid)
thread = inf_tid_to_thread (inf, -1);
else
- thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
+ thread = inf_tid_to_thread (inf, ptid.lwp ());
if (!thread || thread->port == MACH_PORT_NULL)
{
/* TID is dead; try and find a new thread. */
if (inf_update_procs (inf) && inf->threads)
- ptid = ptid_build (inf->pid, inf->threads->tid, 0); /* The first
+ ptid = ptid_t (inf->pid, inf->threads->tid, 0); /* The first
available
thread. */
else
}
if (thread
- && !ptid_equal (ptid, minus_one_ptid)
+ && ptid != minus_one_ptid
&& status->kind != TARGET_WAITKIND_SPURIOUS
&& inf->pause_sc == 0 && thread->pause_sc == 0)
/* If something actually happened to THREAD, make sure we
inf_update_suspends (inf);
}
- inf_debug (inf, "returning ptid = %s, status = %s (%d)",
- target_pid_to_str (ptid),
- status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
- : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
- : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
- : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
- : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
- : "?",
- status->value.integer);
+ inf_debug (inf, "returning ptid = %s, %s",
+ target_pid_to_str (ptid).c_str (),
+ target_waitstatus_to_string (status).c_str ());
return ptid;
}
mach_port_t oldmsgport)
ILL_RPC (S_proc_getmsgport_reply,
mach_port_t reply_port, kern_return_t return_code,
- mach_port_t msgports)
+ mach_port_t msgports, mach_msg_type_name_t msgportsPoly)
ILL_RPC (S_proc_pid2task_reply,
mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
ILL_RPC (S_proc_task2pid_reply,
mach_port_t reply_port, kern_return_t return_code, pid_t pid)
ILL_RPC (S_proc_task2proc_reply,
- mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_port_t proc, mach_msg_type_name_t procPoly)
ILL_RPC (S_proc_proc2task_reply,
mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
ILL_RPC (S_proc_pid2proc_reply,
- mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
+ mach_port_t reply_port, kern_return_t return_code,
+ mach_port_t proc, mach_msg_type_name_t procPoly)
ILL_RPC (S_proc_getprocinfo_reply,
mach_port_t reply_port, kern_return_t return_code,
int flags, procinfo_t procinfo, mach_msg_type_number_t procinfoCnt,
struct inf *inf = gnu_current_inf;
inf_debug (inf, "ptid = %s, step = %d, sig = %d",
- target_pid_to_str (ptid), step, sig);
+ target_pid_to_str (ptid).c_str (), step, sig);
inf_validate_procinfo (inf);
inf_update_procs (inf);
/* A specific PTID means `step only this process id'. */
- resume_all = ptid_equal (ptid, minus_one_ptid);
+ resume_all = ptid == minus_one_ptid;
if (resume_all)
/* Allow all threads to run, except perhaps single-stepping one. */
{
inf_debug (inf, "running all threads; tid = %d",
- ptid_get_pid (inferior_ptid));
+ inferior_ptid.pid ());
ptid = inferior_ptid; /* What to step. */
inf_set_threads_resume_sc (inf, 0, 1);
}
else
/* Just allow a single thread to run. */
{
- struct proc *thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
+ struct proc *thread = inf_tid_to_thread (inf, ptid.lwp ());
if (!thread)
error (_("Can't run single thread id %s: no such thread!"),
- target_pid_to_str (ptid));
- inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
+ inf_debug (inf, "running one thread: %s",
+ target_pid_to_str (ptid).c_str ());
inf_set_threads_resume_sc (inf, thread, 0);
}
if (step)
{
- step_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
+ step_thread = inf_tid_to_thread (inf, ptid.lwp ());
if (!step_thread)
warning (_("Can't step thread id %s: no such thread."),
- target_pid_to_str (ptid));
+ target_pid_to_str (ptid).c_str ());
else
- inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
+ inf_debug (inf, "stepping thread: %s",
+ target_pid_to_str (ptid).c_str ());
}
if (step_thread != inf->step_thread)
inf_set_step_thread (inf, step_thread);
/* We have something that executes now. We'll be running through
the shell at this point (if startup-with-shell is true), but the
pid shouldn't change. */
- add_thread_silent (pid_to_ptid (pid));
+ add_thread_silent (ptid_t (pid));
/* Attach to the now stopped child, which is actually a shell... */
inf_debug (inf, "attaching to child: %d", pid);
/* We now have thread info. */
thread_change_ptid (inferior_ptid,
- ptid_build (inf->pid, inf_pick_first_thread (), 0));
+ ptid_t (inf->pid, inf_pick_first_thread (), 0));
gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
exec_file, pid);
else
printf_unfiltered ("Attaching to pid %d\n", pid);
-
- gdb_flush (gdb_stdout);
}
inf_debug (inf, "attaching to pid: %d", pid);
inf_update_procs (inf);
- inferior_ptid = ptid_build (pid, inf_pick_first_thread (), 0);
+ inferior_ptid = ptid_t (pid, inf_pick_first_thread (), 0);
/* We have to initialize the terminal settings now, since the code
below might try to restore them. */
exec_file, gnu_current_inf->pid);
else
printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
- gdb_flush (gdb_stdout);
}
pid = gnu_current_inf->pid;
inf_detach (gnu_current_inf);
inferior_ptid = null_ptid;
- detach_inferior (pid);
+ detach_inferior (find_inferior_pid (pid));
- inf_child_maybe_unpush_target (ops);
+ maybe_unpush_target ();
}
\f
{
inf_update_procs (gnu_current_inf);
return !!inf_tid_to_thread (gnu_current_inf,
- ptid_get_lwp (ptid));
+ ptid.lwp ());
}
\f
mach_msg_type_number_t copy_count;
int deallocate = 0;
- char *errstr = "Bug in gnu_write_inferior";
+ const char *errstr = "Bug in gnu_write_inferior";
struct vm_region_list *region_element;
struct vm_region_list *region_head = NULL;
return tid_str;
}
-const char *
+std::string
gnu_nat_target::pid_to_str (ptid_t ptid)
{
struct inf *inf = gnu_current_inf;
- int tid = ptid_get_lwp (ptid);
+ int tid = ptid.lwp ();
struct proc *thread = inf_tid_to_thread (inf, tid);
if (thread)
return proc_string (thread);
else
- {
- static char tid_str[80];
-
- xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
- return tid_str;
- }
+ return string_printf ("bogus thread id %d", tid);
}
\f
}
static int
-parse_int_arg (const char *args, char *cmd_prefix)
+parse_int_arg (const char *args, const char *cmd_prefix)
{
if (args)
{
}
static int
-_parse_bool_arg (const char *args, char *t_val, char *f_val, char *cmd_prefix)
+_parse_bool_arg (const char *args, const char *t_val, const char *f_val,
+ const char *cmd_prefix)
{
if (!args || strcmp (args, t_val) == 0)
return 1;
_parse_bool_arg (args, "on", "off", cmd_prefix)
static void
-check_empty (const char *args, char *cmd_prefix)
+check_empty (const char *args, const char *cmd_prefix)
{
if (args)
error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
{
struct inf *inf = cur_inf ();
struct proc *thread = inf_tid_to_thread (inf,
- ptid_get_lwp (inferior_ptid));
+ inferior_ptid.lwp ());
if (!thread)
error (_("No current thread."));
return thread;
else
{
struct thread_info *tp = parse_thread_id (args, NULL);
- inf->signal_thread = inf_tid_to_thread (inf, ptid_get_lwp (tp->ptid));
+ inf->signal_thread = inf_tid_to_thread (inf, tp->ptid.lwp ());
}
}
thread_basic_info_data_t _info;
thread_basic_info_t info = &_info;
mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
- kern_return_t err =
- thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
+ kern_return_t err
+ = mach_thread_info (thread->port, THREAD_BASIC_INFO,
+ (int *) &info, &info_len);
if (err)
error (("%s."), safe_strerror (err));
thread->sc = info->suspend_count;