X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fnto-procfs.c;h=5ff01560e0b1c683427d58963bb7418432bc2513;hb=6873858b7e464e114f9a877e216949ad8350b4cf;hp=323d614d48784ff06073c21c6270ea973e76d5bc;hpb=32d0add0a654c1204ab71dc8a55d9374538c4b33;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c index 323d614d48..5ff01560e0 100644 --- a/gdb/nto-procfs.c +++ b/gdb/nto-procfs.c @@ -1,7 +1,7 @@ /* Machine independent support for QNX Neutrino /proc (process file system) for GDB. Written by Colin Burgess at QNX Software Systems Limited. - Copyright (C) 2003-2015 Free Software Foundation, Inc. + Copyright (C) 2003-2018 Free Software Foundation, Inc. Contributed by QNX Software Systems Ltd. @@ -30,6 +30,8 @@ #include #include #include +#include + #include "gdbcore.h" #include "inferior.h" #include "target.h" @@ -40,6 +42,8 @@ #include "regcache.h" #include "solib.h" #include "inf-child.h" +#include "common/filestuff.h" +#include "common/scoped_fd.h" #define NULL_PID 0 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\ @@ -47,21 +51,23 @@ int ctl_fd; -static void (*ofunc) (); +static sighandler_t ofunc; static procfs_run run; static ptid_t do_attach (ptid_t ptid); static int procfs_can_use_hw_breakpoint (struct target_ops *self, - int, int, int); + enum bptype, int, int); static int procfs_insert_hw_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, + CORE_ADDR addr, int len, + enum target_hw_bp_type type, struct expression *cond); static int procfs_remove_hw_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, + CORE_ADDR addr, int len, + enum target_hw_bp_type type, struct expression *cond); static int procfs_stopped_by_watchpoint (struct target_ops *ops); @@ -70,7 +76,7 @@ static int procfs_stopped_by_watchpoint (struct target_ops *ops); referenced elsewhere. 'nto_procfs_node' is a flag used to say whether we are local, or we should get the current node descriptor for the remote QNX node. */ -static char nto_procfs_path[PATH_MAX] = { "/proc" }; +static char *nodestr; static unsigned nto_procfs_node = ND_LOCAL_NODE; /* Return the current QNX Node, or error out. This is a simple @@ -82,10 +88,11 @@ nto_node (void) { unsigned node; - if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0) + if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 + || nodestr == NULL) return ND_LOCAL_NODE; - node = netmgr_strtond (nto_procfs_path, 0); + node = netmgr_strtond (nodestr, 0); if (node == -1) error (_("Lost the QNX node. Debug session probably over.")); @@ -105,12 +112,11 @@ procfs_is_nto_target (bfd *abfd) static void procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) { - char *nodestr; char *endstr; char buffer[50]; - int fd, total_size; + int total_size; procfs_sysinfo *sysinfo; - struct cleanup *cleanups; + char nto_procfs_path[PATH_MAX]; /* Offer to kill previous inferiors before opening this target. */ target_preopen (from_tty); @@ -120,8 +126,11 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) /* Set the default node used for spawning to this one, and only override it if there is a valid arg. */ + xfree (nodestr); + nodestr = NULL; + nto_procfs_node = ND_LOCAL_NODE; - nodestr = arg ? xstrdup (arg) : arg; + nodestr = (arg != NULL) ? xstrdup (arg) : NULL; init_thread_list (); @@ -146,22 +155,19 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) *endstr = 0; } } - snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "", - "/proc"); - if (nodestr) - xfree (nodestr); + snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", + (nodestr != NULL) ? nodestr : "", "/proc"); - fd = open (nto_procfs_path, O_RDONLY); - if (fd == -1) + scoped_fd fd (open (nto_procfs_path, O_RDONLY)); + if (fd.get () == -1) { printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno, safe_strerror (errno)); error (_("Invalid procfs arg")); } - cleanups = make_cleanup_close (fd); sysinfo = (void *) buffer; - if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK) + if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK) { printf_filtered ("Error getting size: %d (%s)\n", errno, safe_strerror (errno)); @@ -171,7 +177,7 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) { total_size = sysinfo->total_size; sysinfo = alloca (total_size); - if (!sysinfo) + if (sysinfo == NULL) { printf_filtered ("Memory error: %d (%s)\n", errno, safe_strerror (errno)); @@ -179,7 +185,8 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) } else { - if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK) + if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0) + != EOK) { printf_filtered ("Error getting sysinfo: %d (%s)\n", errno, safe_strerror (errno)); @@ -194,7 +201,6 @@ procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty) } } } - do_cleanups (cleanups); inf_child_open_target (ops, arg, from_tty); printf_filtered ("Debugging using %s\n", nto_procfs_path); @@ -241,38 +247,24 @@ static void update_thread_private_data_name (struct thread_info *new_thread, const char *newname) { - int newnamelen; - struct private_thread_info *pti; + nto_thread_info *pti = get_nto_thread_info (new_thread); gdb_assert (newname != NULL); gdb_assert (new_thread != NULL); - newnamelen = strlen (newname); - if (!new_thread->private) - { - new_thread->private = xmalloc (offsetof (struct private_thread_info, - name) - + newnamelen + 1); - memcpy (new_thread->private->name, newname, newnamelen + 1); - } - else if (strcmp (newname, new_thread->private->name) != 0) + + if (pti) { - /* Reallocate if neccessary. */ - int oldnamelen = strlen (new_thread->private->name); - - if (oldnamelen < newnamelen) - new_thread->private = xrealloc (new_thread->private, - offsetof (struct private_thread_info, - name) - + newnamelen + 1); - memcpy (new_thread->private->name, newname, newnamelen + 1); + pti = new nto_thread_info; + new_thread->priv.reset (pti); } + + pti->name = newname; } static void update_thread_private_data (struct thread_info *new_thread, pthread_t tid, int state, int flags) { - struct private_thread_info *pti; procfs_info pidinfo; struct _thread_name *tn; procfs_threadctl tctl; @@ -299,7 +291,7 @@ update_thread_private_data (struct thread_info *new_thread, update_thread_private_data_name (new_thread, tn->name_buf); - pti = (struct private_thread_info *) new_thread->private; + nto_thread_info *pti = get_nto_thread_info (new_thread); pti->tid = tid; pti->state = state; pti->flags = flags; @@ -351,12 +343,12 @@ do_closedir_cleanup (void *dir) closedir (dir); } -void -procfs_pidlist (char *args, int from_tty) +static void +procfs_pidlist (const char *args, int from_tty) { DIR *dp = NULL; struct dirent *dirp = NULL; - char buf[512]; + char buf[PATH_MAX]; procfs_info *pidinfo = NULL; procfs_debuginfo *info = NULL; procfs_status *status = NULL; @@ -364,12 +356,16 @@ procfs_pidlist (char *args, int from_tty) pid_t pid; char name[512]; struct cleanup *cleanups; + char procfs_dir[PATH_MAX]; + + snprintf (procfs_dir, sizeof (procfs_dir), "%s%s", + (nodestr != NULL) ? nodestr : "", "/proc"); - dp = opendir (nto_procfs_path); + dp = opendir (procfs_dir); if (dp == NULL) { fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)", - nto_procfs_path, errno, safe_strerror (errno)); + procfs_dir, errno, safe_strerror (errno)); return; } @@ -380,9 +376,6 @@ procfs_pidlist (char *args, int from_tty) do { - int fd; - struct cleanup *inner_cleanup; - /* Get the right pid and procfs path for the pid. */ do { @@ -392,24 +385,24 @@ procfs_pidlist (char *args, int from_tty) do_cleanups (cleanups); return; } - snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name); + snprintf (buf, sizeof (buf), "%s%s/%s/as", + (nodestr != NULL) ? nodestr : "", + "/proc", dirp->d_name); pid = atoi (dirp->d_name); } while (pid == 0); /* Open the procfs path. */ - fd = open (buf, O_RDONLY); - if (fd == -1) + scoped_fd fd (open (buf, O_RDONLY)); + if (fd.get () == -1) { fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n", buf, errno, safe_strerror (errno)); - do_cleanups (cleanups); - return; + continue; } - inner_cleanup = make_cleanup_close (fd); pidinfo = (procfs_info *) buf; - if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK) + if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK) { fprintf_unfiltered (gdb_stderr, "devctl DCMD_PROC_INFO failed - %d (%s)\n", @@ -419,7 +412,8 @@ procfs_pidlist (char *args, int from_tty) num_threads = pidinfo->num_threads; info = (procfs_debuginfo *) buf; - if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK) + if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) + != EOK) strcpy (name, "unavailable"); else strcpy (name, info->path); @@ -428,14 +422,17 @@ procfs_pidlist (char *args, int from_tty) status = (procfs_status *) buf; for (status->tid = 1; status->tid <= num_threads; status->tid++) { - if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK - && status->tid != 0) - break; - if (status->tid != 0) - printf_filtered ("%s - %d/%d\n", name, pid, status->tid); + const int err + = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0); + printf_filtered ("%s - %d", name, pid); + if (err == EOK && status->tid != 0) + printf_filtered ("/%d\n", status->tid); + else + { + printf_filtered ("\n"); + break; + } } - - do_cleanups (inner_cleanup); } while (dirp != NULL); @@ -443,8 +440,8 @@ procfs_pidlist (char *args, int from_tty) return; } -void -procfs_meminfo (char *args, int from_tty) +static void +procfs_meminfo (const char *args, int from_tty) { procfs_mapinfo *mapinfos = NULL; static int num_mapinfos = 0; @@ -484,7 +481,7 @@ procfs_meminfo (char *args, int from_tty) return; } - mapinfos = xmalloc (num * sizeof (procfs_mapinfo)); + mapinfos = XNEWVEC (procfs_mapinfo, num); num_mapinfos = num; mapinfo_p = mapinfos; @@ -499,7 +496,7 @@ procfs_meminfo (char *args, int from_tty) return; } - num = min (num, num_mapinfos); + num = std::min (num, num_mapinfos); /* Run through the list of mapinfos, and store the data and text info so we can print it at the bottom of the loop. */ @@ -596,7 +593,35 @@ procfs_files_info (struct target_ops *ignore) printf_unfiltered ("\tUsing the running image of %s %s via %s.\n", inf->attach_flag ? "attached" : "child", - target_pid_to_str (inferior_ptid), nto_procfs_path); + target_pid_to_str (inferior_ptid), + (nodestr != NULL) ? nodestr : "local node"); +} + +/* Target to_pid_to_exec_file implementation. */ + +static char * +procfs_pid_to_exec_file (struct target_ops *ops, const int pid) +{ + int proc_fd; + static char proc_path[PATH_MAX]; + ssize_t rd; + + /* Read exe file name. */ + snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile", + (nodestr != NULL) ? nodestr : "", pid); + proc_fd = open (proc_path, O_RDONLY); + if (proc_fd == -1) + return NULL; + + rd = read (proc_fd, proc_path, sizeof (proc_path) - 1); + close (proc_fd); + if (rd <= 0) + { + proc_path[0] = '\0'; + return NULL; + } + proc_path[rd] = '\0'; + return proc_path; } /* Attach to process PID, then initialize for debugging it. */ @@ -650,8 +675,8 @@ do_attach (ptid_t ptid) struct sigevent event; char path[PATH_MAX]; - snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, - ptid_get_pid (ptid)); + snprintf (path, PATH_MAX - 1, "%s%s/%d/as", + (nodestr != NULL) ? nodestr : "", "/proc", ptid_get_pid (ptid)); ctl_fd = open (path, O_RDWR); if (ctl_fd == -1) error (_("Couldn't open proc file %s, error %d (%s)"), path, errno, @@ -678,34 +703,30 @@ do_attach (ptid_t ptid) static void interrupt_query (void) { - target_terminal_ours (); - if (query (_("Interrupted while waiting for the program.\n\ Give up (and stop debugging it)? "))) { - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); quit (); } - - target_terminal_inferior (); } /* The user typed ^C twice. */ static void -nto_interrupt_twice (int signo) +nto_handle_sigint_twice (int signo) { signal (signo, ofunc); interrupt_query (); - signal (signo, nto_interrupt_twice); + signal (signo, nto_handle_sigint_twice); } static void -nto_interrupt (int signo) +nto_handle_sigint (int signo) { /* If this doesn't work, try more severe steps. */ - signal (signo, nto_interrupt_twice); + signal (signo, nto_handle_sigint_twice); - target_stop (inferior_ptid); + target_interrupt (); } static ptid_t @@ -733,12 +754,15 @@ procfs_wait (struct target_ops *ops, devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); while (!(status.flags & _DEBUG_FLAG_ISTOP)) { - ofunc = (void (*)()) signal (SIGINT, nto_interrupt); + ofunc = signal (SIGINT, nto_handle_sigint); sigwaitinfo (&set, &info); signal (SIGINT, ofunc); devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); } + nto_inferior_data (NULL)->stopped_flags = status.flags; + nto_inferior_data (NULL)->stopped_pc = status.ip; + if (status.flags & _DEBUG_FLAG_SSTEP) { ourstatus->kind = TARGET_WAITKIND_STOPPED; @@ -824,7 +848,7 @@ procfs_fetch_registers (struct target_ops *ops, reg; int regsize; - procfs_set_thread (inferior_ptid); + procfs_set_thread (regcache_get_ptid (regcache)); if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK) nto_supply_gregset (regcache, (char *) ®.greg); if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size) @@ -869,9 +893,42 @@ procfs_xfer_partial (struct target_ops *ops, enum target_object object, { case TARGET_OBJECT_MEMORY: return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len); + case TARGET_OBJECT_AUXV: + if (readbuf != NULL) + { + int err; + CORE_ADDR initial_stack; + debug_process_t procinfo; + /* For 32-bit architecture, size of auxv_t is 8 bytes. */ + const unsigned int sizeof_auxv_t = sizeof (auxv_t); + const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t; + int tempread; + gdb_byte *const tempbuf = alloca (sizeof_tempbuf); + + if (tempbuf == NULL) + return TARGET_XFER_E_IO; + + err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo, + sizeof procinfo, 0); + if (err != EOK) + return TARGET_XFER_E_IO; + + initial_stack = procinfo.initial_stack; + + /* procfs is always 'self-hosted', no byte-order manipulation. */ + tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf, + sizeof_tempbuf, + sizeof (auxv_t)); + tempread = std::min (tempread, len) - offset; + memcpy (readbuf, tempbuf + offset, tempread); + *xfered_len = tempread; + return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF; + } + /* Fallthru */ default: return ops->beneath->to_xfer_partial (ops->beneath, object, annex, - readbuf, writebuf, offset, len); + readbuf, writebuf, offset, len, + xfered_len); } } @@ -880,25 +937,14 @@ procfs_xfer_partial (struct target_ops *ops, enum target_object object, on signals, etc. We'd better not have left any breakpoints in the program or it'll die when it hits one. */ static void -procfs_detach (struct target_ops *ops, const char *args, int from_tty) +procfs_detach (struct target_ops *ops, inferior *inf, int from_tty) { - int siggnal = 0; int pid; - if (from_tty) - { - char *exec_file = get_exec_file (0); - if (exec_file == 0) - exec_file = ""; - printf_unfiltered ("Detaching from program: %s %s\n", - exec_file, target_pid_to_str (inferior_ptid)); - gdb_flush (gdb_stdout); - } - if (args) - siggnal = atoi (args); + target_announce_detach (); if (siggnal) - SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0); + SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, 0, 0, 0); close (ctl_fd); ctl_fd = -1; @@ -934,7 +980,8 @@ procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, static int procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); } @@ -1092,8 +1139,9 @@ breakup_args (char *scratch, char **argv) } static void -procfs_create_inferior (struct target_ops *ops, char *exec_file, - char *allargs, char **env, int from_tty) +procfs_create_inferior (struct target_ops *ops, const char *exec_file, + const std::string &allargs, + char **env, int from_tty) { struct inheritance inherit; pid_t pid; @@ -1105,7 +1153,7 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, const char *inferior_io_terminal = get_inferior_io_terminal (); struct inferior *inf; - argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) * + argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) * sizeof (*argv)); argv[0] = get_exec_file (1); if (!argv[0]) @@ -1116,8 +1164,8 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, return; } - args = xstrdup (allargs); - breakup_args (args, exec_file ? &argv[1] : &argv[0]); + args = xstrdup (allargs.c_str ()); + breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]); argv = nto_parse_redirection (argv, &in, &out, &err); @@ -1213,7 +1261,7 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, } if (!target_is_pushed (ops)) push_target (ops); - target_terminal_init (); + target_terminal::init (); if (exec_bfd != NULL || (symfile_objfile != NULL && symfile_objfile->obfd != NULL)) @@ -1221,7 +1269,7 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file, } static void -procfs_stop (struct target_ops *self, ptid_t ptid) +procfs_interrupt (struct target_ops *self) { devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0); } @@ -1229,7 +1277,7 @@ procfs_stop (struct target_ops *self, ptid_t ptid) static void procfs_kill_inferior (struct target_ops *ops) { - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); } /* Fill buf with regset and return devctl cmd to do the setting. Return @@ -1265,7 +1313,7 @@ get_regset (int regset, char *buf, int bufsize, int *regsize) return dev_set; } -void +static void procfs_store_registers (struct target_ops *ops, struct regcache *regcache, int regno) { @@ -1279,10 +1327,11 @@ procfs_store_registers (struct target_ops *ops, unsigned off; int len, regset, regsize, dev_set, err; char *data; + ptid_t ptid = regcache_get_ptid (regcache); - if (ptid_equal (inferior_ptid, null_ptid)) + if (ptid_equal (ptid, null_ptid)) return; - procfs_set_thread (inferior_ptid); + procfs_set_thread (ptid); if (regno == -1) { @@ -1313,7 +1362,7 @@ procfs_store_registers (struct target_ops *ops, if (dev_set == -1) return; - len = nto_register_area (get_regcache_arch (regcache), + len = nto_register_area (regcache->arch (), regno, regset, &off); if (len < 1) @@ -1347,13 +1396,6 @@ procfs_pass_signals (struct target_ops *self, } } -static struct tidinfo * -procfs_thread_info (pid_t pid, short tid) -{ -/* NYI */ - return NULL; -} - static char * procfs_pid_to_str (struct target_ops *ops, ptid_t ptid) { @@ -1444,9 +1486,10 @@ init_procfs_targets (void) t->to_thread_alive = procfs_thread_alive; t->to_update_thread_list = procfs_update_thread_list; t->to_pid_to_str = procfs_pid_to_str; - t->to_stop = procfs_stop; + t->to_interrupt = procfs_interrupt; t->to_have_continuable_watchpoint = 1; t->to_extra_thread_info = nto_extra_thread_info; + t->to_pid_to_exec_file = procfs_pid_to_exec_file; nto_native_ops = t; @@ -1494,16 +1537,16 @@ _initialize_procfs (void) static int -procfs_hw_watchpoint (int addr, int len, int type) +procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type) { procfs_break brk; switch (type) { - case 1: /* Read. */ + case hw_read: brk.type = _DEBUG_BREAK_RD; break; - case 2: /* Read/Write. */ + case hw_access: brk.type = _DEBUG_BREAK_RW; break; default: /* Modify. */ @@ -1525,14 +1568,16 @@ procfs_hw_watchpoint (int addr, int len, int type) static int procfs_can_use_hw_breakpoint (struct target_ops *self, - int type, int cnt, int othertype) + enum bptype type, + int cnt, int othertype) { return 1; } static int procfs_remove_hw_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, + CORE_ADDR addr, int len, + enum target_hw_bp_type type, struct expression *cond) { return procfs_hw_watchpoint (addr, -1, type); @@ -1540,7 +1585,8 @@ procfs_remove_hw_watchpoint (struct target_ops *self, static int procfs_insert_hw_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, + CORE_ADDR addr, int len, + enum target_hw_bp_type type, struct expression *cond) { return procfs_hw_watchpoint (addr, len, type); @@ -1549,5 +1595,21 @@ procfs_insert_hw_watchpoint (struct target_ops *self, static int procfs_stopped_by_watchpoint (struct target_ops *ops) { - return 0; + /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are + stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode; + future gdb versions will likely run in 'non-stop' mode in which case + we will have to store/examine statuses per thread in question. + Until then, this will work fine. */ + + struct inferior *inf = current_inferior (); + struct nto_inferior_data *inf_data; + + gdb_assert (inf != NULL); + + inf_data = nto_inferior_data (inf); + + return inf_data->stopped_flags + & (_DEBUG_FLAG_TRACE_RD + | _DEBUG_FLAG_TRACE_WR + | _DEBUG_FLAG_TRACE_MODIFY); }