/* Native-dependent code for FreeBSD.
- Copyright (C) 2002-2017 Free Software Foundation, Inc.
+ Copyright (C) 2002-2018 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "byte-vector.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include <sys/ptrace.h>
#include <sys/signal.h>
#include <sys/sysctl.h>
-#ifdef HAVE_KINFO_GETVMMAP
#include <sys/user.h>
+#if defined(HAVE_KINFO_GETFILE) || defined(HAVE_KINFO_GETVMMAP)
#include <libutil.h>
#endif
+#if !defined(HAVE_KINFO_GETVMMAP)
+#include "filestuff.h"
+#endif
#include "elf-bfd.h"
#include "fbsd-nat.h"
+#include "fbsd-tdep.h"
+
+#include <list>
/* Return the name of a file that can be opened to get the symbols for
the child process identified by PID. */
mib[3] = pid;
buflen = sizeof buf;
if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
- return buf;
+ /* The kern.proc.pathname.<pid> sysctl returns a length of zero
+ for processes without an associated executable such as kernel
+ processes. */
+ return buflen == 0 ? NULL : buf;
#endif
xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
find_memory_region_ftype func, void *obfd)
{
pid_t pid = ptid_get_pid (inferior_ptid);
- struct kinfo_vmentry *vmentl, *kve;
+ struct kinfo_vmentry *kve;
uint64_t size;
- struct cleanup *cleanup;
int i, nitems;
- vmentl = kinfo_getvmmap (pid, &nitems);
+ gdb::unique_xmalloc_ptr<struct kinfo_vmentry>
+ vmentl (kinfo_getvmmap (pid, &nitems));
if (vmentl == NULL)
perror_with_name (_("Couldn't fetch VM map entries."));
- cleanup = make_cleanup (free, vmentl);
- for (i = 0; i < nitems; i++)
+ for (i = 0, kve = vmentl.get (); i < nitems; i++, kve++)
{
- kve = &vmentl[i];
-
/* Skip unreadable segments and those where MAP_NOCORE has been set. */
if (!(kve->kve_protection & KVME_PROT_READ)
|| kve->kve_flags & KVME_FLAG_NOCOREDUMP)
kve->kve_protection & KVME_PROT_WRITE,
kve->kve_protection & KVME_PROT_EXEC, 1, obfd);
}
- do_cleanups (cleanup);
return 0;
}
#else
find_memory_region_ftype func, void *obfd)
{
pid_t pid = ptid_get_pid (inferior_ptid);
- char *mapfilename;
- FILE *mapfile;
unsigned long start, end, size;
char protection[4];
int read, write, exec;
- struct cleanup *cleanup;
- mapfilename = xstrprintf ("/proc/%ld/map", (long) pid);
- cleanup = make_cleanup (xfree, mapfilename);
- mapfile = fopen (mapfilename, "r");
+ std::string mapfilename = string_printf ("/proc/%ld/map", (long) pid);
+ gdb_file_up mapfile (fopen (mapfilename.c_str (), "r"));
if (mapfile == NULL)
- error (_("Couldn't open %s."), mapfilename);
- make_cleanup_fclose (mapfile);
+ error (_("Couldn't open %s."), mapfilename.c_str ());
if (info_verbose)
fprintf_filtered (gdb_stdout,
- "Reading memory regions from %s\n", mapfilename);
+ "Reading memory regions from %s\n", mapfilename.c_str ());
/* Now iterate until end-of-file. */
- while (fbsd_read_mapping (mapfile, &start, &end, &protection[0]))
+ while (fbsd_read_mapping (mapfile.get (), &start, &end, &protection[0]))
{
size = end - start;
func (start, size, read, write, exec, 1, obfd);
}
- do_cleanups (cleanup);
return 0;
}
#endif
+/* Fetch the command line for a running process. */
+
+static gdb::unique_xmalloc_ptr<char>
+fbsd_fetch_cmdline (pid_t pid)
+{
+ size_t len;
+ int mib[4];
+
+ len = 0;
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_ARGS;
+ mib[3] = pid;
+ if (sysctl (mib, 4, NULL, &len, NULL, 0) == -1)
+ return nullptr;
+
+ if (len == 0)
+ return nullptr;
+
+ gdb::unique_xmalloc_ptr<char> cmdline ((char *) xmalloc (len));
+ if (sysctl (mib, 4, cmdline.get (), &len, NULL, 0) == -1)
+ return nullptr;
+
+ return cmdline;
+}
+
+/* Fetch the external variant of the kernel's internal process
+ structure for the process PID into KP. */
+
+static bool
+fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
+{
+ size_t len;
+ int mib[4];
+
+ len = sizeof *kp;
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PID;
+ mib[3] = pid;
+ return (sysctl (mib, 4, kp, &len, NULL, 0) == 0);
+}
+
+/* Implement the "to_info_proc target_ops" method. */
+
+static void
+fbsd_info_proc (struct target_ops *ops, const char *args,
+ enum info_proc_what what)
+{
+#ifdef HAVE_KINFO_GETFILE
+ gdb::unique_xmalloc_ptr<struct kinfo_file> fdtbl;
+ int nfd = 0;
+#endif
+ struct kinfo_proc kp;
+ char *tmp;
+ pid_t pid;
+ bool do_cmdline = false;
+ bool do_cwd = false;
+ bool do_exe = false;
+#ifdef HAVE_KINFO_GETVMMAP
+ bool do_mappings = false;
+#endif
+ bool do_status = false;
+
+ switch (what)
+ {
+ case IP_MINIMAL:
+ do_cmdline = true;
+ do_cwd = true;
+ do_exe = true;
+ break;
+#ifdef HAVE_KINFO_GETVMMAP
+ case IP_MAPPINGS:
+ do_mappings = true;
+ break;
+#endif
+ case IP_STATUS:
+ case IP_STAT:
+ do_status = true;
+ break;
+ case IP_CMDLINE:
+ do_cmdline = true;
+ break;
+ case IP_EXE:
+ do_exe = true;
+ break;
+ case IP_CWD:
+ do_cwd = true;
+ break;
+ case IP_ALL:
+ do_cmdline = true;
+ do_cwd = true;
+ do_exe = true;
+#ifdef HAVE_KINFO_GETVMMAP
+ do_mappings = true;
+#endif
+ do_status = true;
+ break;
+ default:
+ error (_("Not supported on this target."));
+ }
+
+ gdb_argv built_argv (args);
+ if (built_argv.count () == 0)
+ {
+ pid = ptid_get_pid (inferior_ptid);
+ if (pid == 0)
+ error (_("No current process: you must name one."));
+ }
+ else if (built_argv.count () == 1 && isdigit (built_argv[0][0]))
+ pid = strtol (built_argv[0], NULL, 10);
+ else
+ error (_("Invalid arguments."));
+
+ printf_filtered (_("process %d\n"), pid);
+#ifdef HAVE_KINFO_GETFILE
+ if (do_cwd || do_exe)
+ fdtbl.reset (kinfo_getfile (pid, &nfd));
+#endif
+
+ if (do_cmdline)
+ {
+ gdb::unique_xmalloc_ptr<char> cmdline = fbsd_fetch_cmdline (pid);
+ if (cmdline != nullptr)
+ printf_filtered ("cmdline = '%s'\n", cmdline.get ());
+ else
+ warning (_("unable to fetch command line"));
+ }
+ if (do_cwd)
+ {
+ const char *cwd = NULL;
+#ifdef HAVE_KINFO_GETFILE
+ struct kinfo_file *kf = fdtbl.get ();
+ for (int i = 0; i < nfd; i++, kf++)
+ {
+ if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_CWD)
+ {
+ cwd = kf->kf_path;
+ break;
+ }
+ }
+#endif
+ if (cwd != NULL)
+ printf_filtered ("cwd = '%s'\n", cwd);
+ else
+ warning (_("unable to fetch current working directory"));
+ }
+ if (do_exe)
+ {
+ const char *exe = NULL;
+#ifdef HAVE_KINFO_GETFILE
+ struct kinfo_file *kf = fdtbl.get ();
+ for (int i = 0; i < nfd; i++, kf++)
+ {
+ if (kf->kf_type == KF_TYPE_VNODE && kf->kf_fd == KF_FD_TYPE_TEXT)
+ {
+ exe = kf->kf_path;
+ break;
+ }
+ }
+#endif
+ if (exe == NULL)
+ exe = fbsd_pid_to_exec_file (ops, pid);
+ if (exe != NULL)
+ printf_filtered ("exe = '%s'\n", exe);
+ else
+ warning (_("unable to fetch executable path name"));
+ }
+#ifdef HAVE_KINFO_GETVMMAP
+ if (do_mappings)
+ {
+ int nvment;
+ gdb::unique_xmalloc_ptr<struct kinfo_vmentry>
+ vmentl (kinfo_getvmmap (pid, &nvment));
+
+ if (vmentl != nullptr)
+ {
+ printf_filtered (_("Mapped address spaces:\n\n"));
+#ifdef __LP64__
+ printf_filtered (" %18s %18s %10s %10s %9s %s\n",
+ "Start Addr",
+ " End Addr",
+ " Size", " Offset", "Flags ", "File");
+#else
+ printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
+ "Start Addr",
+ " End Addr",
+ " Size", " Offset", "Flags ", "File");
+#endif
+
+ struct kinfo_vmentry *kve = vmentl.get ();
+ for (int i = 0; i < nvment; i++, kve++)
+ {
+ ULONGEST start, end;
+
+ start = kve->kve_start;
+ end = kve->kve_end;
+#ifdef __LP64__
+ printf_filtered (" %18s %18s %10s %10s %9s %s\n",
+ hex_string (start),
+ hex_string (end),
+ hex_string (end - start),
+ hex_string (kve->kve_offset),
+ fbsd_vm_map_entry_flags (kve->kve_flags,
+ kve->kve_protection),
+ kve->kve_path);
+#else
+ printf_filtered ("\t%10s %10s %10s %10s %9s %s\n",
+ hex_string (start),
+ hex_string (end),
+ hex_string (end - start),
+ hex_string (kve->kve_offset),
+ fbsd_vm_map_entry_flags (kve->kve_flags,
+ kve->kve_protection),
+ kve->kve_path);
+#endif
+ }
+ }
+ else
+ warning (_("unable to fetch virtual memory map"));
+ }
+#endif
+ if (do_status)
+ {
+ if (!fbsd_fetch_kinfo_proc (pid, &kp))
+ warning (_("Failed to fetch process information"));
+ else
+ {
+ const char *state;
+ int pgtok;
+
+ printf_filtered ("Name: %s\n", kp.ki_comm);
+ switch (kp.ki_stat)
+ {
+ case SIDL:
+ state = "I (idle)";
+ break;
+ case SRUN:
+ state = "R (running)";
+ break;
+ case SSTOP:
+ state = "T (stopped)";
+ break;
+ case SZOMB:
+ state = "Z (zombie)";
+ break;
+ case SSLEEP:
+ state = "S (sleeping)";
+ break;
+ case SWAIT:
+ state = "W (interrupt wait)";
+ break;
+ case SLOCK:
+ state = "L (blocked on lock)";
+ break;
+ default:
+ state = "? (unknown)";
+ break;
+ }
+ printf_filtered ("State: %s\n", state);
+ printf_filtered ("Parent process: %d\n", kp.ki_ppid);
+ printf_filtered ("Process group: %d\n", kp.ki_pgid);
+ printf_filtered ("Session id: %d\n", kp.ki_sid);
+ printf_filtered ("TTY: %ju\n", (uintmax_t) kp.ki_tdev);
+ printf_filtered ("TTY owner process group: %d\n", kp.ki_tpgid);
+ printf_filtered ("User IDs (real, effective, saved): %d %d %d\n",
+ kp.ki_ruid, kp.ki_uid, kp.ki_svuid);
+ printf_filtered ("Group IDs (real, effective, saved): %d %d %d\n",
+ kp.ki_rgid, kp.ki_groups[0], kp.ki_svgid);
+ printf_filtered ("Groups: ");
+ for (int i = 0; i < kp.ki_ngroups; i++)
+ printf_filtered ("%d ", kp.ki_groups[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Minor faults (no memory page): %ld\n",
+ kp.ki_rusage.ru_minflt);
+ printf_filtered ("Minor faults, children: %ld\n",
+ kp.ki_rusage_ch.ru_minflt);
+ printf_filtered ("Major faults (memory page faults): %ld\n",
+ kp.ki_rusage.ru_majflt);
+ printf_filtered ("Major faults, children: %ld\n",
+ kp.ki_rusage_ch.ru_majflt);
+ printf_filtered ("utime: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage.ru_utime.tv_sec,
+ kp.ki_rusage.ru_utime.tv_usec);
+ printf_filtered ("stime: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage.ru_stime.tv_sec,
+ kp.ki_rusage.ru_stime.tv_usec);
+ printf_filtered ("utime, children: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage_ch.ru_utime.tv_sec,
+ kp.ki_rusage_ch.ru_utime.tv_usec);
+ printf_filtered ("stime, children: %jd.%06ld\n",
+ (intmax_t) kp.ki_rusage_ch.ru_stime.tv_sec,
+ kp.ki_rusage_ch.ru_stime.tv_usec);
+ printf_filtered ("'nice' value: %d\n", kp.ki_nice);
+ printf_filtered ("Start time: %jd.%06ld\n", kp.ki_start.tv_sec,
+ kp.ki_start.tv_usec);
+ pgtok = getpagesize () / 1024;
+ printf_filtered ("Virtual memory size: %ju kB\n",
+ (uintmax_t) kp.ki_size / 1024);
+ printf_filtered ("Data size: %ju kB\n",
+ (uintmax_t) kp.ki_dsize * pgtok);
+ printf_filtered ("Stack size: %ju kB\n",
+ (uintmax_t) kp.ki_ssize * pgtok);
+ printf_filtered ("Text size: %ju kB\n",
+ (uintmax_t) kp.ki_tsize * pgtok);
+ printf_filtered ("Resident set size: %ju kB\n",
+ (uintmax_t) kp.ki_rssize * pgtok);
+ printf_filtered ("Maximum RSS: %ju kB\n",
+ (uintmax_t) kp.ki_rusage.ru_maxrss);
+ printf_filtered ("Pending Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_siglist.__bits[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Ignored Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_sigignore.__bits[i]);
+ printf_filtered ("\n");
+ printf_filtered ("Caught Signals: ");
+ for (int i = 0; i < _SIG_WORDS; i++)
+ printf_filtered ("%08x ", kp.ki_sigcatch.__bits[i]);
+ printf_filtered ("\n");
+ }
+ }
+}
+
#ifdef KERN_PROC_AUXV
static enum target_xfer_status (*super_xfer_partial) (struct target_ops *ops,
enum target_object object,
struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
/* Is the inferior 32-bit? If so, use the 32-bit siginfo size. */
- if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
+ if (gdbarch_long_bit (gdbarch) == 32)
return sizeof (struct siginfo32);
#endif
return sizeof (siginfo_t);
struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
/* Is the inferior 32-bit? If not, nothing to do. */
- if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 32)
+ if (gdbarch_long_bit (gdbarch) != 32)
return;
struct siginfo32 si32;
32-bits of the pointer value. */
#if _BYTE_ORDER == _BIG_ENDIAN
if (si->si_value.sival_int == 0)
- si32->si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
+ si32.si_value.sival_ptr = (uintptr_t) si->si_value.sival_ptr;
else
si32.si_value.sival_int = si->si_value.sival_int;
#else
#endif
case TARGET_OBJECT_AUXV:
{
- struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
- unsigned char *buf;
+ gdb::byte_vector buf_storage;
+ gdb_byte *buf;
size_t buflen;
int mib[4];
else
{
buflen = offset + len;
- buf = XCNEWVEC (unsigned char, buflen);
- cleanup = make_cleanup (xfree, buf);
+ buf_storage.resize (buflen);
+ buf = buf_storage.data ();
}
if (sysctl (mib, 4, buf, &buflen, NULL, 0) == 0)
{
else
buflen = 0;
}
- do_cleanups (cleanup);
*xfered_len = buflen;
return (buflen == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
}
- do_cleanups (cleanup);
return TARGET_XFER_E_IO;
}
default:
fprintf_filtered (file, _("Debugging of FreeBSD lwp module is %s.\n"), value);
}
-#if defined(TDP_RFPPWAIT) || defined(HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME)
-/* Fetch the external variant of the kernel's internal process
- structure for the process PID into KP. */
-
-static void
-fbsd_fetch_kinfo_proc (pid_t pid, struct kinfo_proc *kp)
-{
- size_t len;
- int mib[4];
-
- len = sizeof *kp;
- mib[0] = CTL_KERN;
- mib[1] = KERN_PROC;
- mib[2] = KERN_PROC_PID;
- mib[3] = pid;
- if (sysctl (mib, 4, kp, &len, NULL, 0) == -1)
- perror_with_name (("sysctl"));
-}
-#endif
-
/*
FreeBSD's first thread support was via a "reentrant" version of libc
(libc_r) that first shipped in 2.2.7. This library multiplexed all
/* Note that ptrace_lwpinfo returns the process command in pl_tdname
if a name has not been set explicitly. Return a NULL name in
that case. */
- fbsd_fetch_kinfo_proc (pid, &kp);
+ if (!fbsd_fetch_kinfo_proc (pid, &kp))
+ perror_with_name (_("Failed to fetch process information"));
if (ptrace (PT_LWPINFO, lwp, (caddr_t) &pl, sizeof pl) == -1)
perror_with_name (("ptrace"));
if (strcmp (kp.ki_comm, pl.pl_tdname) == 0)
static void
fbsd_add_threads (pid_t pid)
{
- struct cleanup *cleanup;
- lwpid_t *lwps;
int i, nlwps;
gdb_assert (!in_thread_list (pid_to_ptid (pid)));
if (nlwps == -1)
perror_with_name (("ptrace"));
- lwps = XCNEWVEC (lwpid_t, nlwps);
- cleanup = make_cleanup (xfree, lwps);
+ gdb::unique_xmalloc_ptr<lwpid_t[]> lwps (XCNEWVEC (lwpid_t, nlwps));
- nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps, nlwps);
+ nlwps = ptrace (PT_GETLWPLIST, pid, (caddr_t) lwps.get (), nlwps);
if (nlwps == -1)
perror_with_name (("ptrace"));
add_thread (ptid);
}
}
- do_cleanups (cleanup);
}
/* Implement the "to_update_thread_list" target_ops method. */
sake. FreeBSD versions newer than 9.1 contain both fixes.
*/
-struct fbsd_fork_info
-{
- struct fbsd_fork_info *next;
- ptid_t ptid;
-};
-
-static struct fbsd_fork_info *fbsd_pending_children;
+static std::list<ptid_t> fbsd_pending_children;
/* Record a new child process event that is reported before the
corresponding fork event in the parent. */
static void
fbsd_remember_child (ptid_t pid)
{
- struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
-
- info->ptid = pid;
- info->next = fbsd_pending_children;
- fbsd_pending_children = info;
+ fbsd_pending_children.push_front (pid);
}
/* Check for a previously-recorded new child process event for PID.
static ptid_t
fbsd_is_child_pending (pid_t pid)
{
- struct fbsd_fork_info *info, *prev;
- ptid_t ptid;
-
- prev = NULL;
- for (info = fbsd_pending_children; info; prev = info, info = info->next)
- {
- if (ptid_get_pid (info->ptid) == pid)
- {
- if (prev == NULL)
- fbsd_pending_children = info->next;
- else
- prev->next = info->next;
- ptid = info->ptid;
- xfree (info);
- return ptid;
- }
- }
+ for (auto it = fbsd_pending_children.begin ();
+ it != fbsd_pending_children.end (); it++)
+ if (it->pid () == pid)
+ {
+ ptid_t ptid = *it;
+ fbsd_pending_children.erase (it);
+ return ptid;
+ }
return null_ptid;
}
#ifndef PTRACE_VFORK
-static struct fbsd_fork_info *fbsd_pending_vfork_done;
+static std::forward_list<ptid_t> fbsd_pending_vfork_done;
/* Record a pending vfork done event. */
static void
fbsd_add_vfork_done (ptid_t pid)
{
- struct fbsd_fork_info *info = XCNEW (struct fbsd_fork_info);
-
- info->ptid = pid;
- info->next = fbsd_pending_vfork_done;
- fbsd_pending_vfork_done = info;
+ fbsd_pending_vfork_done.push_front (pid);
}
/* Check for a pending vfork done event for a specific PID. */
static int
fbsd_is_vfork_done_pending (pid_t pid)
{
- struct fbsd_fork_info *info;
-
- for (info = fbsd_pending_vfork_done; info != NULL; info = info->next)
- {
- if (ptid_get_pid (info->ptid) == pid)
- return 1;
- }
+ for (auto it = fbsd_pending_vfork_done.begin ();
+ it != fbsd_pending_vfork_done.end (); it++)
+ if (it->pid () == pid)
+ return 1;
return 0;
}
static ptid_t
fbsd_next_vfork_done (void)
{
- struct fbsd_fork_info *info;
- ptid_t ptid;
-
- if (fbsd_pending_vfork_done != NULL)
+ if (!fbsd_pending_vfork_done.empty ())
{
- info = fbsd_pending_vfork_done;
- fbsd_pending_vfork_done = info->next;
- ptid = info->ptid;
- xfree (info);
+ ptid_t ptid = fbsd_pending_vfork_done.front ();
+ fbsd_pending_vfork_done.pop_front ();
return ptid;
}
return null_ptid;
#ifndef PTRACE_VFORK
/* For vfork, the child process will have the P_PPWAIT
flag set. */
- fbsd_fetch_kinfo_proc (child, &kp);
- if (kp.ki_flag & P_PPWAIT)
- ourstatus->kind = TARGET_WAITKIND_VFORKED;
+ if (fbsd_fetch_kinfo_proc (child, &kp))
+ {
+ if (kp.ki_flag & P_PPWAIT)
+ ourstatus->kind = TARGET_WAITKIND_VFORKED;
+ }
+ else
+ warning (_("Failed to fetch process information"));
#endif
ourstatus->value.related_pid = child_ptid;
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
static int
-fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, int needed,
- int any_count, int table_size, int *table)
+fbsd_set_syscall_catchpoint (struct target_ops *self, int pid, bool needed,
+ int any_count,
+ gdb::array_view<const int> syscall_counts)
{
/* Ignore the arguments. inf-ptrace.c will use PT_SYSCALL which
{
t->to_pid_to_exec_file = fbsd_pid_to_exec_file;
t->to_find_memory_regions = fbsd_find_memory_regions;
+ t->to_info_proc = fbsd_info_proc;
#ifdef KERN_PROC_AUXV
super_xfer_partial = t->to_xfer_partial;
t->to_xfer_partial = fbsd_xfer_partial;
add_target (t);
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_fbsd_nat;
-
void
_initialize_fbsd_nat (void)
{