/* Machine independent support for QNX Neutrino /proc (process file system)
for GDB. Written by Colin Burgess at QNX Software Systems Limited.
- Copyright (C) 2003-2018 Free Software Foundation, Inc.
+ Copyright (C) 2003-2022 Free Software Foundation, Inc.
Contributed by QNX Software Systems Ltd.
#include "regcache.h"
#include "solib.h"
#include "inf-child.h"
-#include "common/filestuff.h"
-#include "common/scoped_fd.h"
+#include "gdbsupport/filestuff.h"
+#include "gdbsupport/scoped_fd.h"
#define NULL_PID 0
#define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
void resume (ptid_t, int, enum gdb_signal) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
void fetch_registers (struct regcache *, int) override;
void store_registers (struct regcache *, int) override;
void mourn_inferior () override;
- void pass_signals (int, unsigned char *) override;
+ void pass_signals (gdb::array_view<const unsigned char>) override;
bool thread_alive (ptid_t ptid) override;
void update_thread_list () override;
- const char *pid_to_str (ptid_t) override;
+ std::string pid_to_str (ptid_t) override;
void interrupt () override;
prune_threads ();
- pid = inferior_ptid.pid ();
+ pid = current_inferior ()->pid;
status.tid = 1;
(e.g. thread exited). */
continue;
ptid = ptid_t (pid, 0, tid);
- new_thread = find_thread_ptid (ptid);
+ new_thread = find_thread_ptid (this, ptid);
if (!new_thread)
new_thread = add_thread (ptid);
update_thread_private_data (new_thread, tid, status.state, 0);
if (strcmp (map.info.path, printme.name))
continue;
- /* Lower debug_vaddr is always text, if nessessary, swap. */
+ /* Lower debug_vaddr is always text, if necessary, swap. */
if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
{
memcpy (&(printme.data), &(printme.text),
{
struct inferior *inf = current_inferior ();
- printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
- inf->attach_flag ? "attached" : "child",
- target_pid_to_str (inferior_ptid),
- (nodestr != NULL) ? nodestr : "local node");
+ printf_filtered ("\tUsing the running image of %s %s via %s.\n",
+ inf->attach_flag ? "attached" : "child",
+ target_pid_to_str (inferior_ptid).c_str (),
+ (nodestr != NULL) ? nodestr : "local node");
}
/* Target to_pid_to_exec_file implementation. */
void
nto_procfs_target::attach (const char *args, int from_tty)
{
- char *exec_file;
int pid;
struct inferior *inf;
if (pid == getpid ())
error (_("Attaching GDB to itself is not a good idea..."));
- if (from_tty)
- {
- exec_file = (char *) get_exec_file (0);
-
- if (exec_file)
- printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
- target_pid_to_str (ptid_t (pid)));
- else
- printf_unfiltered ("Attaching to %s\n",
- target_pid_to_str (ptid_t (pid)));
+ target_announce_attach (from_tty, pid);
- gdb_flush (gdb_stdout);
- }
- inferior_ptid = do_attach (ptid_t (pid));
+ ptid_t ptid = do_attach (ptid_t (pid));
inf = current_inferior ();
inferior_appeared (inf, pid);
inf->attach_flag = 1;
- if (!target_is_pushed (ops))
- push_target (ops);
+ if (!inf->target_is_pushed (ops))
+ inf->push_target (ops);
+
+ update_thread_list ();
- procfs_update_thread_list (ops);
+ switch_to_thread (find_thread_ptid (this, ptid));
}
void
nto_procfs_target::post_attach (pid_t pid)
{
- if (exec_bfd)
+ if (current_program_space->exec_bfd ())
solib_create_inferior_hook (0);
}
sptid_t
nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
- int options)
+ target_wait_flags options)
{
sigset_t set;
siginfo_t info;
procfs_status status;
static int exit_signo = 0; /* To track signals that cause termination. */
- ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+ ourstatus->set_spurious ();
if (inferior_ptid == null_ptid)
{
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = GDB_SIGNAL_0;
+ ourstatus->set_stopped (GDB_SIGNAL_0);
exit_signo = 0;
return null_ptid;
}
nto_inferior_data (NULL)->stopped_pc = status.ip;
if (status.flags & _DEBUG_FLAG_SSTEP)
- {
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = GDB_SIGNAL_TRAP;
- }
+ ourstatus->set_stopped (GDB_SIGNAL_TRAP);
/* Was it a breakpoint? */
else if (status.flags & _DEBUG_FLAG_TRACE)
- {
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = GDB_SIGNAL_TRAP;
- }
+ ourstatus->set_stopped (GDB_SIGNAL_TRAP);
else if (status.flags & _DEBUG_FLAG_ISTOP)
{
switch (status.why)
{
case _DEBUG_WHY_SIGNALLED:
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig =
- gdb_signal_from_host (status.info.si_signo);
+ ourstatus->set_stopped (gdb_signal_from_host (status.info.si_signo));
exit_signo = 0;
break;
case _DEBUG_WHY_FAULTED:
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
if (status.info.si_signo == SIGTRAP)
{
- ourstatus->value.sig = 0;
+ ourstatus->set_stopped (0);
exit_signo = 0;
}
else
{
- ourstatus->value.sig =
- gdb_signal_from_host (status.info.si_signo);
- exit_signo = ourstatus->value.sig;
+ ourstatus->set_stopped
+ (gdb_signal_from_host (status.info.si_signo));
+ exit_signo = ourstatus->sig ();
}
break;
if (exit_signo)
{
/* Abnormal death. */
- ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
- ourstatus->value.sig = exit_signo;
+ ourstatus->set_signalled (exit_signo);
}
else
{
/* Normal death. */
- ourstatus->kind = TARGET_WAITKIND_EXITED;
- ourstatus->value.integer = WEXITSTATUS (waitval);
+ ourstatus->set_exited (WEXITSTATUS (waitval));
}
exit_signo = 0;
break;
case _DEBUG_WHY_REQUESTED:
/* We are assuming a requested stop is due to a SIGINT. */
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
- ourstatus->value.sig = GDB_SIGNAL_INT;
+ ourstatus->set_stopped (GDB_SIGNAL_INT);
exit_signo = 0;
break;
}
return TARGET_XFER_E_IO;
err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
- sizeof procinfo, 0);
+ sizeof procinfo, 0);
if (err != EOK)
return TARGET_XFER_E_IO;
void
nto_procfs_target::detach (inferior *inf, int from_tty)
{
- int pid;
-
target_announce_detach ();
if (siggnal)
- SignalKill (nto_node (), inferior_ptid.pid (), 0, 0, 0, 0);
+ SignalKill (nto_node (), inf->pid, 0, 0, 0, 0);
close (ctl_fd);
ctl_fd = -1;
- pid = inferior_ptid.pid ();
- inferior_ptid = null_ptid;
- detach_inferior (pid);
+ switch_to_no_thread ();
+ detach_inferior (inf->pid);
init_thread_list ();
inf_child_maybe_unpush_target (ops);
}
SignalKill (nto_node (), inferior_ptid.pid (), 0, SIGKILL, 0, 0);
close (ctl_fd);
}
- inferior_ptid = null_ptid;
+ switch_to_no_thread ();
init_thread_list ();
inf_child_mourn_inferior (ops);
}
the string "a b c d", and as output it would fill in argv with
the four arguments "a", "b", "c", "d". The only additional
functionality is simple quoting. The gdb command:
- run a "b c d" f
+ run a "b c d" f
will fill in argv with the three args "a", "b c d", "e". */
static void
breakup_args (char *scratch, char **argv)
const char *in = "", *out = "", *err = "";
int fd, fds[3];
sigset_t set;
- const char *inferior_io_terminal = get_inferior_io_terminal ();
struct inferior *inf;
argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
sizeof (*argv));
- argv[0] = get_exec_file (1);
+ argv[0] = const_cast<char *> (get_exec_file (1));
if (!argv[0])
{
if (exec_file)
/* If the user specified I/O via gdb's --tty= arg, use it, but only
if the i/o is not also being specified via redirection. */
- if (inferior_io_terminal)
+ const char *inferior_tty = current_inferior ()->tty ();
+ if (inferior_tty != nullptr)
{
if (!in[0])
- in = inferior_io_terminal;
+ in = inferior_tty;
if (!out[0])
- out = inferior_io_terminal;
+ out = inferior_tty;
if (!err[0])
- err = inferior_io_terminal;
+ err = inferior_tty;
}
if (in[0])
if (fds[2] != STDERR_FILENO)
close (fds[2]);
- inferior_ptid = do_attach (ptid_t (pid));
- procfs_update_thread_list (ops);
+ ptid_t ptid = do_attach (ptid_t (pid));
+ update_thread_list ();
+ switch_to_thread (find_thread_ptid (this, ptid));
inf = current_inferior ();
inferior_appeared (inf, pid);
{
/* FIXME: expected warning? */
/* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
- errn, strerror(errn) ); */
+ errn, safe_strerror(errn) ); */
}
- if (!target_is_pushed (ops))
- push_target (ops);
+ if (!inf->target_is_pushed (ops))
+ inf->push_target (ops);
target_terminal::init ();
- if (exec_bfd != NULL
- || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
+ if (current_program_space->exec_bfd () != NULL
+ || (current_program_space->symfile_object_file != NULL
+ && current_program_space->symfile_object_file->obfd != NULL))
solib_create_inferior_hook (0);
}
/* Set list of signals to be handled in the target. */
void
-nto_procfs_target::pass_signals (int numsigs, unsigned char *pass_signals)
+nto_procfs_target::pass_signals
+ (gdb::array_view<const unsigned char> pass_signals)
{
int signo;
for (signo = 1; signo < NSIG; signo++)
{
int target_signo = gdb_signal_from_host (signo);
- if (target_signo < numsigs && pass_signals[target_signo])
- sigdelset (&run.trace, signo);
+ if (target_signo < pass_signals.size () && pass_signals[target_signo])
+ sigdelset (&run.trace, signo);
}
}
-char *
+std::string
nto_procfs_target::pid_to_str (ptid_t ptid)
{
- static char buf[1024];
- int pid, tid, n;
+ int pid, tid;
struct tidinfo *tip;
pid = ptid.pid ();
tid = ptid.tid ();
- n = snprintf (buf, 1023, "process %d", pid);
-
#if 0 /* NYI */
tip = procfs_thread_info (pid, tid);
if (tip != NULL)
snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
#endif
- return buf;
+ return string_printf ("process %d", pid);
}
/* to_can_run implementation for "target procfs". Note this really
#define OSTYPE_NTO 1
+void _initialize_procfs ();
void
-_initialize_procfs (void)
+_initialize_procfs ()
{
sigset_t set;
projects / binutils-gdb.git / blobdiff