28#include <sys/procfs.h>
29#include <sys/neutrino.h>
30#include <sys/syspage.h>
32#include <sys/netmgr.h>
45#include "gdbsupport/filestuff.h"
46#include "gdbsupport/scoped_fd.h"
49#define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
62 void open (
const char *arg,
int from_tty)
override;
64 void attach (
const char *,
int)
override = 0;
70 void resume (ptid_t,
int,
enum gdb_signal)
override;
80 const gdb_byte *writebuf,
81 ULONGEST offset, ULONGEST len,
82 ULONGEST *xfered_len)
override;
105 void kill ()
override;
108 char **,
int)
override;
112 void pass_signals (gdb::array_view<const unsigned char>)
override;
131 N_(
"QNX Neutrino local process"),
132 N_(
"QNX Neutrino local process (started by the \"run\" command).")
145 N_(
"QNX Neutrino local or remote process"),
146 N_(
"QNX Neutrino process. target procfs NODE")
175 return ND_LOCAL_NODE;
177 node = netmgr_strtond (
nodestr, 0);
179 error (_(
"Lost the QNX node. Debug session probably over."));
200 procfs_sysinfo *sysinfo;
201 char nto_procfs_path[PATH_MAX];
215 nodestr = (arg != NULL) ? xstrdup (arg) : NULL;
222 if (errno == ENOTSUP)
225 errno, safe_strerror (errno));
232 if (*(endstr - 1) ==
'/')
238 snprintf (nto_procfs_path, PATH_MAX - 1,
"%s%s",
241 scoped_fd fd (
open (nto_procfs_path, O_RDONLY));
244 gdb_printf (
"Error opening %s : %d (%s)\n", nto_procfs_path, errno,
245 safe_strerror (errno));
246 error (_(
"Invalid procfs arg"));
249 sysinfo = (
void *) buffer;
250 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo,
sizeof buffer, 0) != EOK)
252 gdb_printf (
"Error getting size: %d (%s)\n", errno,
253 safe_strerror (errno));
254 error (_(
"Devctl failed."));
258 total_size = sysinfo->total_size;
259 sysinfo = alloca (total_size);
263 safe_strerror (errno));
264 error (_(
"alloca failed."));
268 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0)
271 gdb_printf (
"Error getting sysinfo: %d (%s)\n", errno,
272 safe_strerror (errno));
273 error (_(
"Devctl failed."));
280 error (_(
"Invalid target CPU."));
285 inf_child_target::open (arg, from_tty);
286 gdb_printf (
"Debugging using %s\n", nto_procfs_path);
295 devctl (
ctl_fd, DCMD_PROC_CURTHREAD, &tid,
sizeof (tid), 0);
315 if ((
err = devctl (
ctl_fd, DCMD_PROC_TIDSTATUS,
324 return (
status.tid == tid) && (
status.state != STATE_DEAD);
333 gdb_assert (newname != NULL);
347 pthread_t tid,
int state,
int flags)
350 struct _thread_name *tn;
351 procfs_threadctl tctl;
353#if _NTO_VERSION > 630
356 if (devctl (
ctl_fd, DCMD_PROC_INFO, &pidinfo,
357 sizeof(pidinfo), 0) != EOK)
360 memset (&tctl, 0,
sizeof (tctl));
361 tctl.cmd = _NTO_TCTL_NAME;
362 tn = (
struct _thread_name *) (&tctl.data);
366 tn->name_buf_len =
sizeof (tctl.data) -
sizeof (*tn);
367 tn->new_name_len = -1;
368 if (devctl (
ctl_fd, DCMD_PROC_THREADCTL, &tctl,
sizeof (tctl), NULL) != EOK)
369 tn->name_buf[0] =
'\0';
371 tn->name_buf[_NTO_THREAD_NAME_MAX] =
'\0';
400 for (tid = 1;; ++tid)
411 ptid = ptid_t (
pid, 0, tid);
424 struct dirent *dirp = NULL;
426 procfs_info *pidinfo = NULL;
427 procfs_debuginfo *info = NULL;
428 procfs_status *
status = NULL;
429 pid_t num_threads = 0;
432 char procfs_dir[PATH_MAX];
434 snprintf (procfs_dir,
sizeof (procfs_dir),
"%s%s",
437 gdb_dir_up dp (opendir (procfs_dir));
441 procfs_dir, errno, safe_strerror (errno));
446 rewinddir (dp.get ());
453 dirp = readdir (dp.get ());
456 snprintf (buf,
sizeof (buf),
"%s%s/%s/as",
458 "/proc", dirp->d_name);
459 pid = atoi (dirp->d_name);
464 scoped_fd fd (open (buf, O_RDONLY));
468 buf, errno, safe_strerror (errno));
472 pidinfo = (procfs_info *) buf;
473 if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
476 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
477 errno, safe_strerror (errno));
480 num_threads = pidinfo->num_threads;
482 info = (procfs_debuginfo *) buf;
483 if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0)
485 strcpy (
name,
"unavailable");
487 strcpy (
name, info->path);
490 status = (procfs_status *) buf;
494 = devctl (fd.get (), DCMD_PROC_TIDSTATUS,
status, sizeof (buf), 0);
505 while (dirp != NULL);
511 procfs_mapinfo *mapinfos = NULL;
512 static int num_mapinfos = 0;
513 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
518 procfs_debuginfo info;
519 char buff[_POSIX_PATH_MAX];
527 unsigned debug_vaddr;
528 unsigned long long offset;
533 unsigned long long ino;
541 err = devctl (
ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
544 printf (
"failed devctl num mapinfos - %d (%s)\n",
err,
545 safe_strerror (
err));
549 mapinfos = XNEWVEC (procfs_mapinfo, num);
552 mapinfo_p = mapinfos;
555 err = devctl (
ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
556 *
sizeof (procfs_mapinfo), &num);
559 printf (
"failed devctl mapinfos - %d (%s)\n",
err, safe_strerror (
err));
564 num = std::min (num, num_mapinfos);
568 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
570 if (!(mapinfo_p->flags &
flags))
573 if (mapinfo_p->ino == 0)
576 map.info.vaddr = mapinfo_p->vaddr;
578 err = devctl (
ctl_fd, DCMD_PROC_MAPDEBUG, &map,
sizeof (map), 0);
582 memset (&printme, 0,
sizeof printme);
583 printme.dev = mapinfo_p->dev;
584 printme.ino = mapinfo_p->ino;
585 printme.text.addr = mapinfo_p->vaddr;
586 printme.text.size = mapinfo_p->size;
587 printme.text.flags = mapinfo_p->flags;
588 printme.text.offset = mapinfo_p->offset;
589 printme.text.debug_vaddr = map.info.vaddr;
590 strcpy (printme.name, map.info.path);
593 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
595 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
596 && mapinfo_p2->ino == mapinfo_p->ino
597 && mapinfo_p2->dev == mapinfo_p->dev)
599 map.info.vaddr = mapinfo_p2->vaddr;
601 devctl (
ctl_fd, DCMD_PROC_MAPDEBUG, &map,
sizeof (map), 0);
605 if (strcmp (map.info.path, printme.name))
609 if ((
int) map.info.vaddr < (
int) printme.text.debug_vaddr)
611 memcpy (&(printme.data), &(printme.text),
612 sizeof (printme.data));
613 printme.text.addr = mapinfo_p2->vaddr;
614 printme.text.size = mapinfo_p2->size;
615 printme.text.flags = mapinfo_p2->flags;
616 printme.text.offset = mapinfo_p2->offset;
617 printme.text.debug_vaddr = map.info.vaddr;
621 printme.data.addr = mapinfo_p2->vaddr;
622 printme.data.size = mapinfo_p2->size;
623 printme.data.flags = mapinfo_p2->flags;
624 printme.data.offset = mapinfo_p2->offset;
625 printme.data.debug_vaddr = map.info.vaddr;
633 gdb_printf (
"\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
635 gdb_printf (
"\t\tflags=%08x\n", printme.text.flags);
636 gdb_printf (
"\t\tdebug=%08x\n", printme.text.debug_vaddr);
637 gdb_printf (
"\t\toffset=%s\n", phex (printme.text.offset, 8));
638 if (printme.data.size)
640 gdb_printf (
"\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
642 gdb_printf (
"\t\tflags=%08x\n", printme.data.flags);
643 gdb_printf (
"\t\tdebug=%08x\n", printme.data.debug_vaddr);
644 gdb_printf (
"\t\toffset=%s\n", phex (printme.data.offset, 8));
647 gdb_printf (
"\tino=0x%x\n", (
unsigned int) printme.ino);
659 gdb_printf (
"\tUsing the running image of %s %s via %s.\n",
660 inf->attach_flag ?
"attached" :
"child",
671 static char proc_path[PATH_MAX];
675 snprintf (proc_path,
sizeof (proc_path),
"%s/proc/%d/exefile",
677 proc_fd =
open (proc_path, O_RDONLY);
681 rd =
read (proc_fd, proc_path,
sizeof (proc_path) - 1);
688 proc_path[rd] =
'\0';
701 if (
pid == getpid ())
702 error (_(
"Attaching GDB to itself is not a good idea..."));
709 inf->attach_flag =
true;
711 if (!
inf->target_is_pushed (ops))
712 inf->push_target (ops);
730 struct sigevent event;
733 snprintf (path, PATH_MAX - 1,
"%s%s/%d/as",
735 ctl_fd = open (path, O_RDWR);
737 error (_(
"Couldn't open proc file %s, error %d (%s)"), path, errno,
738 safe_strerror (errno));
740 error (_(
"Couldn't stop process"));
743 event.sigev_notify = SIGEV_SIGNAL_THREAD;
744 event.sigev_signo = SIGUSR1;
745 event.sigev_code = 0;
746 event.sigev_value.sival_ptr = NULL;
747 event.sigev_priority = -1;
748 devctl (
ctl_fd, DCMD_PROC_EVENT, &event,
sizeof (event), 0);
751 &&
status.flags & _DEBUG_FLAG_STOPPED)
752 SignalKill (
nto_node (), ptid.pid (), 0, SIGCONT, 0, 0);
754 return ptid_t (ptid.pid (), 0,
status.tid);
761 if (
query (_(
"Interrupted while waiting for the program.\n\
762Give up (and stop debugging it)? ")))
773 signal (signo,
ofunc);
789 target_wait_flags options)
794 static int exit_signo = 0;
806 sigaddset (&set, SIGUSR1);
809 while (!(
status.flags & _DEBUG_FLAG_ISTOP))
812 sigwaitinfo (&set, &
info);
813 signal (SIGINT,
ofunc);
820 if (
status.flags & _DEBUG_FLAG_SSTEP)
825 else if (
status.flags & _DEBUG_FLAG_ISTOP)
829 case _DEBUG_WHY_SIGNALLED:
833 case _DEBUG_WHY_FAULTED:
834 if (
status.info.si_signo == SIGTRAP)
842 (gdb_signal_from_host (
status.info.si_signo));
843 exit_signo = ourstatus->
sig ();
847 case _DEBUG_WHY_TERMINATED:
860 ourstatus->
set_exited (WEXITSTATUS (waitval));
866 case _DEBUG_WHY_REQUESTED:
887 procfs_altreg altreg;
893 if (devctl (
ctl_fd, DCMD_PROC_GETGREG, ®,
sizeof (reg), ®size) == EOK)
895 if (devctl (
ctl_fd, DCMD_PROC_GETFPREG, ®,
sizeof (reg), ®size)
898 if (devctl (
ctl_fd, DCMD_PROC_GETALTREG, ®,
sizeof (reg), ®size)
908 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
915 if (writebuf != NULL)
916 nbytes = write (
ctl_fd, writebuf, len);
921 *xfered_len = nbytes;
929 const char *annex, gdb_byte *readbuf,
930 const gdb_byte *writebuf, ULONGEST offset,
931 ULONGEST len, ULONGEST *xfered_len)
941 CORE_ADDR initial_stack;
944 const unsigned int sizeof_auxv_t =
sizeof (auxv_t);
945 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
947 gdb_byte *
const tempbuf = alloca (sizeof_tempbuf);
957 initial_stack =
procinfo.initial_stack;
963 tempread = std::min (tempread, len) - offset;
964 memcpy (readbuf,
tempbuf + offset, tempread);
965 *xfered_len = tempread;
971 readbuf, writebuf, offset, len,
994 inf_child_maybe_unpush_target (ops);
1005 errno = devctl (
ctl_fd, DCMD_PROC_BREAK, &brk,
sizeof (brk), 0);
1033 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1041 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1049 sigset_t *run_fault = (sigset_t *) (
void *) &
run.fault;
1057 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1059 run.flags |= _DEBUG_RUN_STEP;
1061 sigemptyset (run_fault);
1062 sigaddset (run_fault, FLTBPT);
1063 sigaddset (run_fault, FLTTRACE);
1064 sigaddset (run_fault, FLTILL);
1065 sigaddset (run_fault, FLTPRIV);
1066 sigaddset (run_fault, FLTBOUNDS);
1067 sigaddset (run_fault, FLTIOVF);
1068 sigaddset (run_fault, FLTIZDIV);
1069 sigaddset (run_fault, FLTFPE);
1071 sigaddset (run_fault, FLTPAGE);
1073 run.flags |= _DEBUG_RUN_ARM;
1075 signal_to_pass = gdb_signal_to_host (signo);
1080 signal_to_pass = gdb_signal_to_host (signo);
1081 if (
status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1083 if (signal_to_pass !=
status.info.si_signo)
1086 signal_to_pass, 0, 0);
1087 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1090 sigdelset (&
run.trace, signal_to_pass);
1094 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1096 errno = devctl (
ctl_fd, DCMD_PROC_RUN, &
run,
sizeof (
run), 0);
1099 perror (_(
"run error!\n"));
1114 inf_child_mourn_inferior (ops);
1128 char *pp, *cp = scratch;
1135 while (*cp ==
' ' || *cp ==
'\t' || *cp ==
'\n')
1146 quoting = strchr (cp,
'"') ? 1 : 0;
1154 cp = strchr (pp,
'"');
1155 if ((cp == NULL) || (!quoting))
1156 cp = strchr (pp,
' ');
1158 cp = strchr (pp,
'\t');
1160 cp = strchr (pp,
'\n');
1179 const std::string &allargs,
1180 char **env,
int from_tty)
1182 struct inheritance inherit;
1186 const char *in =
"", *out =
"", *
err =
"";
1191 argv =
xmalloc ((allargs.size () / (
unsigned) 2 + 2) *
1197 argv[0] = exec_file;
1202 args = xstrdup (allargs.c_str ());
1203 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1207 fds[0] = STDIN_FILENO;
1208 fds[1] = STDOUT_FILENO;
1209 fds[2] = STDERR_FILENO;
1214 if (inferior_tty !=
nullptr)
1226 fd =
open (in, O_RDONLY);
1234 fd =
open (out, O_WRONLY);
1250 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1253 sigaddset (&set, SIGUSR1);
1254 sigprocmask (SIG_UNBLOCK, &set, NULL);
1256 memset (&inherit, 0,
sizeof (inherit));
1261 inherit.flags |= SPAWN_SETND;
1262 inherit.flags &= ~SPAWN_EXEC;
1264 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1265 inherit.pgroup = SPAWN_NEWPGROUP;
1266 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1270 sigprocmask (SIG_BLOCK, &set, NULL);
1273 error (_(
"Error spawning %s: %d (%s)"), argv[0], errno,
1274 safe_strerror (errno));
1276 if (fds[0] != STDIN_FILENO)
1278 if (fds[1] != STDOUT_FILENO)
1280 if (fds[2] != STDERR_FILENO)
1289 inf->attach_flag =
false;
1291 flags = _DEBUG_FLAG_KLC;
1299 if (!
inf->target_is_pushed (ops))
1300 inf->push_target (ops);
1312 devctl (
ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1326 int dev_get, dev_set;
1330 dev_get = DCMD_PROC_GETGREG;
1331 dev_set = DCMD_PROC_SETGREG;
1335 dev_get = DCMD_PROC_GETFPREG;
1336 dev_set = DCMD_PROC_SETFPREG;
1340 dev_get = DCMD_PROC_GETALTREG;
1341 dev_set = DCMD_PROC_SETALTREG;
1348 if (devctl (
ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1361 procfs_altreg altreg;
1369 if (ptid == null_ptid)
1378 sizeof (reg), ®size);
1385 err = devctl (
ctl_fd, dev_set, ®, regsize, 0);
1388 "Warning unable to write regset %d: %s\n",
1389 regno, safe_strerror (
err));
1410 err = devctl (
ctl_fd, dev_set, ®, regsize, 0);
1413 "Warning unable to write regset %d: %s\n", regno,
1414 safe_strerror (
err));
1422 (gdb::array_view<const unsigned char> pass_signals)
1426 sigfillset (&
run.trace);
1428 for (signo = 1; signo < NSIG; signo++)
1430 int target_signo = gdb_signal_from_host (signo);
1432 sigdelset (&
run.trace, signo);
1440 struct tidinfo *tip;
1446 tip = procfs_thread_info (
pid, tid);
1448 snprintf (&buf[n], 1023,
" (state = 0x%02x)", tip->state);
1451 return string_printf (
"process %d",
pid);
1498 sigaddset (&set, SIGUSR1);
1499 sigprocmask (SIG_BLOCK, &set, NULL);
1502 sigfillset (&
run.trace);
1523 brk.type = _DEBUG_BREAK_RD;
1526 brk.type = _DEBUG_BREAK_RW;
1530 brk.type = _DEBUG_BREAK_RW;
1532 brk.type |= _DEBUG_BREAK_HW;
1536 errno = devctl (
ctl_fd, DCMD_PROC_BREAK, &brk,
sizeof (brk), 0);
1539 perror (_(
"Failed to set hardware watchpoint"));
1547 int cnt,
int othertype)
1553nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr,
int len,
1554 enum target_hw_bp_type
type,
1561nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr,
int len,
1562 enum target_hw_bp_type
type,
1580 gdb_assert (
inf != NULL);
1585 & (_DEBUG_FLAG_TRACE_RD
1586 | _DEBUG_FLAG_TRACE_WR
1587 | _DEBUG_FLAG_TRACE_MODIFY);
struct gdbarch * target_gdbarch(void)
static struct obstack tempbuf
const target_info & info() const override
const std::string & args() const
const std::string & tty()
const target_info & info() const override
thread_info * find_thread(ptid_t ptid)
void raw_collect(int regnum, void *buf) const override
private_thread_info_up priv
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
const char * get_exec_file(int err)
ssize_t read(int fd, void *buf, size_t count)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
void switch_to_thread(struct thread_info *thr)
void switch_to_no_thread()
void init_thread_list(void)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
void inf_child_open_target(const char *arg, int from_tty)
void inferior_appeared(struct inferior *inf, int pid)
void detach_inferior(inferior *inf)
struct inferior * current_inferior(void)
static void update_thread_private_data(struct thread_info *new_thread, pthread_t tid, int state, int flags)
static void update_thread_private_data_name(struct thread_info *new_thread, const char *newname)
void _initialize_procfs()
static void interrupt_query(void)
static int get_regset(int regset, char *buf, int bufsize, int *regsize)
static void procfs_set_thread(ptid_t ptid)
static void breakup_args(char *scratch, char **argv)
static void nto_handle_sigint_twice(int signo)
static nto_procfs_target_native nto_native_ops
static sighandler_t ofunc
static void procfs_pidlist(const char *args, int from_tty)
#define _DEBUG_FLAG_TRACE
static unsigned nto_procfs_node
static enum target_xfer_status procfs_xfer_memory(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
static void init_procfs_targets(void)
static enum gdb_osabi procfs_is_nto_target(bfd *abfd)
static nto_procfs_target_procfs nto_procfs_ops
static int procfs_breakpoint(CORE_ADDR addr, int type, int size)
static const target_info nto_native_target_info
static int procfs_hw_watchpoint(int addr, int len, enum target_hw_bp_type type)
static const target_info nto_procfs_target_info
static unsigned nto_node(void)
static void procfs_meminfo(const char *args, int from_tty)
static void nto_handle_sigint(int signo)
static ptid_t do_attach(ptid_t ptid)
LONGEST nto_read_auxv_from_initial_stack(CORE_ADDR initial_stack, gdb_byte *readbuf, LONGEST len, size_t sizeof_auxv_t)
void nto_init_solib_absolute_prefix(void)
char ** nto_parse_redirection(char *pargv[], const char **pin, const char **pout, const char **perr)
struct nto_inferior_data * nto_inferior_data(struct inferior *const inferior)
int nto_map_arch_to_cputype(const char *arch)
#define nto_supply_fpregset
#define nto_cpuinfo_flags
#define nto_register_area
#define nto_supply_gregset
static nto_thread_info * get_nto_thread_info(thread_info *thread)
#define nto_cpuinfo_valid
#define nto_supply_altregset
#define nto_is_nto_target
struct program_space * current_program_space
void solib_create_inferior_hook(int from_tty)
unsigned int stopped_flags
const target_info & info() const override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
void attach(const char *, int) override=0
void detach(inferior *, int) override
int can_use_hw_breakpoint(enum bptype, int, int) override
int insert_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
void update_thread_list() override
std::string pid_to_str(ptid_t) override
int remove_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
void mourn_inferior() override
void interrupt() override
int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
void store_registers(struct regcache *, int) override
int remove_breakpoint(struct gdbarch *, struct bp_target_info *, enum remove_bp_reason) override
void fetch_registers(struct regcache *, int) override
bool thread_alive(ptid_t ptid) override
const char * pid_to_exec_file(int pid) override
bool stopped_by_watchpoint() override
const char * extra_thread_info(struct thread_info *) override
void pass_signals(gdb::array_view< const unsigned char >) override
int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
void files_info() override
int insert_breakpoint(struct gdbarch *, struct bp_target_info *) override
void open(const char *arg, int from_tty) override
void resume(ptid_t, int, enum gdb_signal) override
void create_inferior(const char *, const std::string &, char **, int) override
struct objfile * symfile_object_file
target_ops * beneath() const
virtual enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
target_waitstatus & set_exited(int exit_status)
target_waitstatus & set_spurious()
target_waitstatus & set_signalled(gdb_signal sig)
target_waitstatus & set_stopped(gdb_signal sig)
void target_announce_detach(int from_tty)
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
void set_native_target(target_ops *target)
void target_announce_attach(int from_tty, int pid)
std::string target_pid_to_str(ptid_t ptid)
void target_preopen(int from_tty)
void target_mourn_inferior(ptid_t ptid)
static struct thread_info * new_thread(struct inferior *inf, ptid_t ptid)
int query(const char *ctlstr,...)
void gdb_printf(struct ui_file *stream, const char *format,...)
int parse_pid_to_attach(const char *args)