Automatic date update in version.in

[deliverable/binutils-gdb.git] / gdb / procfs.c

diff --git a/gdb/procfs.c b/gdb/procfs.c
index 4ee0fa88cf2c28c179fab6ca5d1e857d289d553d..adb2e84632694692940e03243ed83d88381fd473 100644 (file)
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -1,6 +1,6 @@
 /* Machine independent support for SVR4 /proc (process file system) for GDB.
 
 /* Machine independent support for SVR4 /proc (process file system) for GDB.
 

-   Copyright (C) 1999-2013 Free Software Foundation, Inc.
+   Copyright (C) 1999-2017 Free Software Foundation, Inc.

 
    Written by Michael Snyder at Cygnus Solutions.
    Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
 
    Written by Michael Snyder at Cygnus Solutions.
    Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.


@@ -22,6 +22,7 @@
 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"

+#include "infrun.h"

 #include "target.h"
 #include "gdbcore.h"
 #include "elf-bfd.h"           /* for elfcore_write_* */
 #include "target.h"
 #include "gdbcore.h"
 #include "elf-bfd.h"           /* for elfcore_write_* */


@@ -29,6 +30,7 @@
 #include "gdbthread.h"
 #include "regcache.h"
 #include "inf-child.h"
 #include "gdbthread.h"
 #include "regcache.h"
 #include "inf-child.h"

+#include "filestuff.h"

 
 #if defined (NEW_PROC_API)
 #define _STRUCTURED_PROC 1     /* Should be done by configure script.  */
 
 #if defined (NEW_PROC_API)
 #define _STRUCTURED_PROC 1     /* Should be done by configure script.  */


@@ -41,13 +43,10 @@
 #ifdef HAVE_SYS_SYSCALL_H
 #include <sys/syscall.h>
 #endif
 #ifdef HAVE_SYS_SYSCALL_H
 #include <sys/syscall.h>
 #endif

-#include <sys/errno.h>

 #include "gdb_wait.h"
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_bfd.h"
 #include "gdb_wait.h"
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_bfd.h"

-#include <string.h>
-#include "gdb_assert.h"

 #include "inflow.h"
 #include "auxv.h"
 #include "procfs.h"
 #include "inflow.h"
 #include "auxv.h"
 #include "procfs.h"


@@ -109,40 +108,45 @@
 
 /* This module defines the GDB target vector and its methods.  */
 
 
 /* This module defines the GDB target vector and its methods.  */
 

-static void procfs_attach (struct target_ops *, char *, int);
+static void procfs_attach (struct target_ops *, const char *, int);

 static void procfs_detach (struct target_ops *, const char *, int);
 static void procfs_resume (struct target_ops *,
                           ptid_t, int, enum gdb_signal);
 static void procfs_detach (struct target_ops *, const char *, int);
 static void procfs_resume (struct target_ops *,
                           ptid_t, int, enum gdb_signal);

-static void procfs_stop (ptid_t);
+static void procfs_interrupt (struct target_ops *self, ptid_t);

 static void procfs_files_info (struct target_ops *);
 static void procfs_fetch_registers (struct target_ops *,
                                    struct regcache *, int);
 static void procfs_store_registers (struct target_ops *,
                                    struct regcache *, int);
 static void procfs_files_info (struct target_ops *);
 static void procfs_fetch_registers (struct target_ops *,
                                    struct regcache *, int);
 static void procfs_store_registers (struct target_ops *,
                                    struct regcache *, int);

-static void procfs_pass_signals (int, unsigned char *);
+static void procfs_pass_signals (struct target_ops *self,
+                                int, unsigned char *);

 static void procfs_kill_inferior (struct target_ops *ops);
 static void procfs_mourn_inferior (struct target_ops *ops);
 static void procfs_kill_inferior (struct target_ops *ops);
 static void procfs_mourn_inferior (struct target_ops *ops);

-static void procfs_create_inferior (struct target_ops *, char *,
-                                   char *, char **, int);
+static void procfs_create_inferior (struct target_ops *, const char *,
+                                   const std::string &, char **, int);

 static ptid_t procfs_wait (struct target_ops *,
                           ptid_t, struct target_waitstatus *, int);
 static ptid_t procfs_wait (struct target_ops *,
                           ptid_t, struct target_waitstatus *, int);

-static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
-                              struct mem_attrib *attrib,
-                              struct target_ops *);
+static enum target_xfer_status procfs_xfer_memory (gdb_byte *,
+                                                  const gdb_byte *,
+                                                  ULONGEST, ULONGEST,
+                                                  ULONGEST *);

 static target_xfer_partial_ftype procfs_xfer_partial;
 
 static int procfs_thread_alive (struct target_ops *ops, ptid_t);
 
 static target_xfer_partial_ftype procfs_xfer_partial;
 
 static int procfs_thread_alive (struct target_ops *ops, ptid_t);
 

-static void procfs_find_new_threads (struct target_ops *ops);
-static char *procfs_pid_to_str (struct target_ops *, ptid_t);
+static void procfs_update_thread_list (struct target_ops *ops);
+static const char *procfs_pid_to_str (struct target_ops *, ptid_t);

 
 

-static int proc_find_memory_regions (find_memory_region_ftype, void *);
+static int proc_find_memory_regions (struct target_ops *self,
+                                    find_memory_region_ftype, void *);

 
 

-static char * procfs_make_note_section (bfd *, int *);
+static char * procfs_make_note_section (struct target_ops *self,
+                                       bfd *, int *);

 
 

-static int procfs_can_use_hw_breakpoint (int, int, int);
+static int procfs_can_use_hw_breakpoint (struct target_ops *self,
+                                        enum bptype, int, int);

 
 

-static void procfs_info_proc (struct target_ops *, char *,
+static void procfs_info_proc (struct target_ops *, const char *,

                              enum info_proc_what);
 
 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
                              enum info_proc_what);
 
 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)


@@ -179,10 +183,6 @@ procfs_target (void)
 {
   struct target_ops *t = inf_child_target ();
 
 {
   struct target_ops *t = inf_child_target ();
 

-  t->to_shortname = "procfs";
-  t->to_longname = "Unix /proc child process";
-  t->to_doc =
-    "Unix /proc child process (started by the \"run\" command).";

   t->to_create_inferior = procfs_create_inferior;
   t->to_kill = procfs_kill_inferior;
   t->to_mourn_inferior = procfs_mourn_inferior;
   t->to_create_inferior = procfs_create_inferior;
   t->to_kill = procfs_kill_inferior;
   t->to_mourn_inferior = procfs_mourn_inferior;


@@ -193,12 +193,11 @@ procfs_target (void)
   t->to_fetch_registers = procfs_fetch_registers;
   t->to_store_registers = procfs_store_registers;
   t->to_xfer_partial = procfs_xfer_partial;
   t->to_fetch_registers = procfs_fetch_registers;
   t->to_store_registers = procfs_store_registers;
   t->to_xfer_partial = procfs_xfer_partial;

-  t->deprecated_xfer_memory = procfs_xfer_memory;

   t->to_pass_signals = procfs_pass_signals;
   t->to_files_info = procfs_files_info;
   t->to_pass_signals = procfs_pass_signals;
   t->to_files_info = procfs_files_info;

-  t->to_stop = procfs_stop;
+  t->to_interrupt = procfs_interrupt;

 
 

-  t->to_find_new_threads = procfs_find_new_threads;
+  t->to_update_thread_list = procfs_update_thread_list;

   t->to_thread_alive = procfs_thread_alive;
   t->to_pid_to_str = procfs_pid_to_str;
 
   t->to_thread_alive = procfs_thread_alive;
   t->to_pid_to_str = procfs_pid_to_str;
 


@@ -422,7 +421,7 @@ static procinfo *find_procinfo (int pid, int tid);
 static procinfo *create_procinfo (int pid, int tid);
 static void destroy_procinfo (procinfo * p);
 static void do_destroy_procinfo_cleanup (void *);
 static procinfo *create_procinfo (int pid, int tid);
 static void destroy_procinfo (procinfo * p);
 static void do_destroy_procinfo_cleanup (void *);

-static void dead_procinfo (procinfo * p, char *msg, int killp);
+static void dead_procinfo (procinfo * p, const char *msg, int killp);

 static int open_procinfo_files (procinfo * p, int which);
 static void close_procinfo_files (procinfo * p);
 static int sysset_t_size (procinfo *p);
 static int open_procinfo_files (procinfo * p, int which);
 static void close_procinfo_files (procinfo * p);
 static int sysset_t_size (procinfo *p);


@@ -430,7 +429,7 @@ static sysset_t *sysset_t_alloc (procinfo * pi);
 #ifdef DYNAMIC_SYSCALLS
 static void load_syscalls (procinfo *pi);
 static void free_syscalls (procinfo *pi);
 #ifdef DYNAMIC_SYSCALLS
 static void load_syscalls (procinfo *pi);
 static void free_syscalls (procinfo *pi);

-static int find_syscall (procinfo *pi, char *name);
+static int find_syscall (procinfo *pi, const char *name);

 #endif /* DYNAMIC_SYSCALLS */
 
 static int iterate_over_mappings
 #endif /* DYNAMIC_SYSCALLS */
 
 static int iterate_over_mappings


@@ -691,7 +690,7 @@ create_procinfo (int pid, int tid)
                                                   create it if it
                                                   doesn't exist yet?  */
 
                                                   create it if it
                                                   doesn't exist yet?  */
 

-  pi = (procinfo *) xmalloc (sizeof (procinfo));
+  pi = XNEW (procinfo);

   memset (pi, 0, sizeof (procinfo));
   pi->pid = pid;
   pi->tid = tid;
   memset (pi, 0, sizeof (procinfo));
   pi->pid = pid;
   pi->tid = tid;


@@ -792,7 +791,7 @@ destroy_procinfo (procinfo *pi)
 static void
 do_destroy_procinfo_cleanup (void *pi)
 {
 static void
 do_destroy_procinfo_cleanup (void *pi)
 {

-  destroy_procinfo (pi);
+  destroy_procinfo ((procinfo *) pi);

 }
 
 enum { NOKILL, KILL };
 }
 
 enum { NOKILL, KILL };


@@ -802,7 +801,7 @@ enum { NOKILL, KILL };
    destroys the data structure.  */
 
 static void
    destroys the data structure.  */
 
 static void

-dead_procinfo (procinfo *pi, char *msg, int kill_p)
+dead_procinfo (procinfo *pi, const char *msg, int kill_p)

 {
   char procfile[80];
 
 {
   char procfile[80];
 


@@ -846,7 +845,7 @@ sysset_t_alloc (procinfo * pi)
   sysset_t *ret;
   int size = sysset_t_size (pi);
 
   sysset_t *ret;
   int size = sysset_t_size (pi);
 

-  ret = xmalloc (size);
+  ret = (sysset_t *) xmalloc (size);

 #ifdef DYNAMIC_SYSCALLS
   ret->pr_size = ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
                  / (8 * sizeof (uint64_t)));
 #ifdef DYNAMIC_SYSCALLS
   ret->pr_size = ((pi->num_syscalls + (8 * sizeof (uint64_t) - 1))
                  / (8 * sizeof (uint64_t)));


@@ -919,7 +918,7 @@ load_syscalls (procinfo *pi)
       maxcall = syscalls[i].pr_number;
 
   pi->num_syscalls = maxcall+1;
       maxcall = syscalls[i].pr_number;
 
   pi->num_syscalls = maxcall+1;

-  pi->syscall_names = xmalloc (pi->num_syscalls * sizeof (char *));
+  pi->syscall_names = XNEWVEC (char *, pi->num_syscalls);

 
   for (i = 0; i < pi->num_syscalls; i++)
     pi->syscall_names[i] = NULL;
 
   for (i = 0; i < pi->num_syscalls; i++)
     pi->syscall_names[i] = NULL;


@@ -983,7 +982,7 @@ free_syscalls (procinfo *pi)
    If no match is found, return -1.  */
 
 static int
    If no match is found, return -1.  */
 
 static int

-find_syscall (procinfo *pi, char *name)
+find_syscall (procinfo *pi, const char *name)

 {
   int i;
 
 {
   int i;
 


@@ -1021,14 +1020,14 @@ static int proc_iterate_over_threads
    void *ptr);
 
 static void
    void *ptr);
 
 static void

-proc_warn (procinfo *pi, char *func, int line)
+proc_warn (procinfo *pi, const char *func, int line)

 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   print_sys_errmsg (errmsg, errno);
 }
 
 static void
 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   print_sys_errmsg (errmsg, errno);
 }
 
 static void

-proc_error (procinfo *pi, char *func, int line)
+proc_error (procinfo *pi, const char *func, int line)

 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   perror_with_name (errmsg);
 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   perror_with_name (errmsg);


@@ -1676,7 +1675,7 @@ proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
                  - sizeof (sysset_t)
                  + sysset_t_size (pi);
 
                  - sizeof (sysset_t)
                  + sysset_t_size (pi);
 

-    argp = xmalloc (argp_size);
+    argp = (struct gdb_proc_ctl_pcsentry *) xmalloc (argp_size);

 
     argp->cmd = PCSENTRY;
     memcpy (&argp->sysset, sysset, sysset_t_size (pi));
 
     argp->cmd = PCSENTRY;
     memcpy (&argp->sysset, sysset, sysset_t_size (pi));


@@ -1721,7 +1720,7 @@ proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
                  - sizeof (sysset_t)
                  + sysset_t_size (pi);
 
                  - sizeof (sysset_t)
                  + sysset_t_size (pi);
 

-    argp = xmalloc (argp_size);
+    argp = (struct gdb_proc_ctl_pcsexit *) xmalloc (argp_size);

 
     argp->cmd = PCSEXIT;
     memcpy (&argp->sysset, sysset, sysset_t_size (pi));
 
     argp->cmd = PCSEXIT;
     memcpy (&argp->sysset, sysset, sysset_t_size (pi));


@@ -2491,7 +2490,7 @@ proc_get_LDT_entry (procinfo *pi, int key)
   /* Allocate space for one LDT entry.
      This alloc must persist, because we return a pointer to it.  */
   if (ldt_entry == NULL)
   /* Allocate space for one LDT entry.
      This alloc must persist, because we return a pointer to it.  */
   if (ldt_entry == NULL)

-    ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
+    ldt_entry = XNEW (struct ssd);

 
   /* Open the file descriptor for the LDT table.  */
   sprintf (pathname, "/proc/%d/ldt", pi->pid);
 
   /* Open the file descriptor for the LDT table.  */
   sprintf (pathname, "/proc/%d/ldt", pi->pid);


@@ -2513,9 +2512,13 @@ proc_get_LDT_entry (procinfo *pi, int key)
        break;  /* end of table */
       /* If key matches, return this entry.  */
       if (ldt_entry->sel == key)
        break;  /* end of table */
       /* If key matches, return this entry.  */
       if (ldt_entry->sel == key)

-       return ldt_entry;
+       {
+         do_cleanups (old_chain);
+         return ldt_entry;
+       }

     }
   /* Loop ended, match not found.  */
     }
   /* Loop ended, match not found.  */

+  do_cleanups (old_chain);

   return NULL;
 #else
   int nldt, i;
   return NULL;
 #else
   int nldt, i;


@@ -2732,7 +2735,7 @@ proc_update_threads (procinfo *pi)
   if ((nlwp = proc_get_nthreads (pi)) <= 1)
     return 1;  /* Process is not multi-threaded; nothing to do.  */
 
   if ((nlwp = proc_get_nthreads (pi)) <= 1)
     return 1;  /* Process is not multi-threaded; nothing to do.  */
 

-  prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1));
+  prstatus = XNEWVEC (gdb_prstatus_t, nlwp + 1);

 
   old_chain = make_cleanup (xfree, prstatus);
   if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
 
   old_chain = make_cleanup (xfree, prstatus);
   if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)


@@ -2757,7 +2760,7 @@ proc_update_threads (procinfo *pi)
 static void
 do_closedir_cleanup (void *dir)
 {
 static void
 do_closedir_cleanup (void *dir)
 {

-  closedir (dir);
+  closedir ((DIR *) dir);

 }
 
 static int
 }
 
 static int


@@ -2826,7 +2829,7 @@ proc_update_threads (procinfo *pi)
   if (nthreads < 2)
     return 0;          /* Nothing to do for 1 or fewer threads.  */
 
   if (nthreads < 2)
     return 0;          /* Nothing to do for 1 or fewer threads.  */
 

-  threads = xmalloc (nthreads * sizeof (tid_t));
+  threads = XNEWVEC (tid_t, nthreads);

 
   if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
     proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
 
   if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
     proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);


@@ -2904,13 +2907,6 @@ static void do_detach (int signo);
 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
                                   int entry_or_exit, int mode, int from_tty);
 
 static void proc_trace_syscalls_1 (procinfo *pi, int syscallnum,
                                   int entry_or_exit, int mode, int from_tty);
 

-/* On mips-irix, we need to insert a breakpoint at __dbx_link during
-   the startup phase.  The following two variables are used to record
-   the address of the breakpoint, and the code that was replaced by
-   a breakpoint.  */
-static int dbx_link_bpt_addr = 0;
-static void *dbx_link_bpt;
-

 /* Sets up the inferior to be debugged.  Registers to trace signals,
    hardware faults, and syscalls.  Note: does not set RLC flag: caller
    may want to customize that.  Returns zero for success (note!
 /* Sets up the inferior to be debugged.  Registers to trace signals,
    hardware faults, and syscalls.  Note: does not set RLC flag: caller
    may want to customize that.  Returns zero for success (note!


@@ -2926,16 +2922,9 @@ procfs_debug_inferior (procinfo *pi)
   sysset_t *traced_syscall_exits;
   int status;
 
   sysset_t *traced_syscall_exits;
   int status;
 

-#ifdef PROCFS_DONT_TRACE_FAULTS
-  /* On some systems (OSF), we don't trace hardware faults.
-     Apparently it's enough that we catch them as signals.
-     Wonder why we don't just do that in general?  */
-  premptyset (&traced_faults);         /* don't trace faults.  */
-#else

   /* Register to trace hardware faults in the child.  */
   prfillset (&traced_faults);          /* trace all faults...  */
   gdb_prdelset  (&traced_faults, FLTPAGE);     /* except page fault.  */
   /* Register to trace hardware faults in the child.  */
   prfillset (&traced_faults);          /* trace all faults...  */
   gdb_prdelset  (&traced_faults, FLTPAGE);     /* except page fault.  */

-#endif

   if (!proc_set_traced_faults  (pi, &traced_faults))
     return __LINE__;
 
   if (!proc_set_traced_faults  (pi, &traced_faults))
     return __LINE__;
 


@@ -3038,7 +3027,7 @@ procfs_debug_inferior (procinfo *pi)
 }
 
 static void
 }
 
 static void

-procfs_attach (struct target_ops *ops, char *args, int from_tty)
+procfs_attach (struct target_ops *ops, const char *args, int from_tty)

 {
   char *exec_file;
   int   pid;
 {
   char *exec_file;
   int   pid;


@@ -3062,7 +3051,8 @@ procfs_attach (struct target_ops *ops, char *args, int from_tty)
       fflush (stdout);
     }
   inferior_ptid = do_attach (pid_to_ptid (pid));
       fflush (stdout);
     }
   inferior_ptid = do_attach (pid_to_ptid (pid));

-  push_target (ops);
+  if (!target_is_pushed (ops))
+    push_target (ops);

 }
 
 static void
 }
 
 static void


@@ -3076,7 +3066,7 @@ procfs_detach (struct target_ops *ops, const char *args, int from_tty)
 
   if (from_tty)
     {
 
   if (from_tty)
     {

-      char *exec_file;
+      const char *exec_file;

 
       exec_file = get_exec_file (0);
       if (exec_file == NULL)
 
       exec_file = get_exec_file (0);
       if (exec_file == NULL)


@@ -3091,7 +3081,7 @@ procfs_detach (struct target_ops *ops, const char *args, int from_tty)
 
   inferior_ptid = null_ptid;
   detach_inferior (pid);
 
   inferior_ptid = null_ptid;
   detach_inferior (pid);

-  unpush_target (ops);
+  inf_child_maybe_unpush_target (ops);

 }
 
 static ptid_t
 }
 
 static ptid_t


@@ -3229,15 +3219,16 @@ procfs_fetch_registers (struct target_ops *ops,
 {
   gdb_gregset_t *gregs;
   procinfo *pi;
 {
   gdb_gregset_t *gregs;
   procinfo *pi;

-  int pid = ptid_get_pid (inferior_ptid);
-  int tid = ptid_get_lwp (inferior_ptid);
+  ptid_t ptid = regcache_get_ptid (regcache);
+  int pid = ptid_get_pid (ptid);
+  int tid = ptid_get_lwp (ptid);

   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   pi = find_procinfo_or_die (pid, tid);
 
   if (pi == NULL)
     error (_("procfs: fetch_registers failed to find procinfo for %s"),
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   pi = find_procinfo_or_die (pid, tid);
 
   if (pi == NULL)
     error (_("procfs: fetch_registers failed to find procinfo for %s"),

-          target_pid_to_str (inferior_ptid));
+          target_pid_to_str (ptid));

 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)
 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)


@@ -3278,15 +3269,16 @@ procfs_store_registers (struct target_ops *ops,
 {
   gdb_gregset_t *gregs;
   procinfo *pi;
 {
   gdb_gregset_t *gregs;
   procinfo *pi;

-  int pid = ptid_get_pid (inferior_ptid);
-  int tid = ptid_get_lwp (inferior_ptid);
+  ptid_t ptid = regcache_get_ptid (regcache);
+  int pid = ptid_get_pid (ptid);
+  int tid = ptid_get_lwp (ptid);

   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   pi = find_procinfo_or_die (pid, tid);
 
   if (pi == NULL)
     error (_("procfs: store_registers: failed to find procinfo for %s"),
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   pi = find_procinfo_or_die (pid, tid);
 
   if (pi == NULL)
     error (_("procfs: store_registers: failed to find procinfo for %s"),

-          target_pid_to_str (inferior_ptid));
+          target_pid_to_str (ptid));

 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)
 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)


@@ -3381,23 +3373,6 @@ syscall_is_lwp_create (procinfo *pi, int scall)
   return 0;
 }
 
   return 0;
 }
 

-/* Remove the breakpoint that we inserted in __dbx_link().
-   Does nothing if the breakpoint hasn't been inserted or has already
-   been removed.  */
-
-static void
-remove_dbx_link_breakpoint (void)
-{
-  if (dbx_link_bpt_addr == 0)
-    return;
-
-  if (deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt) != 0)
-    warning (_("Unable to remove __dbx_link breakpoint."));
-
-  dbx_link_bpt_addr = 0;
-  dbx_link_bpt = NULL;
-}
-

 #ifdef SYS_syssgi
 /* Return the address of the __dbx_link() function in the file
    refernced by ABFD by scanning its symbol table.  Return 0 if
 #ifdef SYS_syssgi
 /* Return the address of the __dbx_link() function in the file
    refernced by ABFD by scanning its symbol table.  Return 0 if


@@ -3440,43 +3415,40 @@ dbx_link_addr (bfd *abfd)
 static int
 insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
 {
 static int
 insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
 {

-  bfd *abfd;

   long storage_needed;
   CORE_ADDR sym_addr;
 
   long storage_needed;
   CORE_ADDR sym_addr;
 

-  abfd = gdb_bfd_fdopenr ("unamed", 0, fd);
+  gdb_bfd_ref_ptr abfd (gdb_bfd_fdopenr ("unamed", 0, fd));

   if (abfd == NULL)
     {
       warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
       return 0;
     }
 
   if (abfd == NULL)
     {
       warning (_("Failed to create a bfd: %s."), bfd_errmsg (bfd_get_error ()));
       return 0;
     }
 

-  if (!bfd_check_format (abfd, bfd_object))
+  if (!bfd_check_format (abfd.get (), bfd_object))

     {
       /* Not the correct format, so we can not possibly find the dbx_link
         symbol in it.  */
     {
       /* Not the correct format, so we can not possibly find the dbx_link
         symbol in it.  */

-      gdb_bfd_unref (abfd);

       return 0;
     }
 
       return 0;
     }
 

-  sym_addr = dbx_link_addr (abfd);
+  sym_addr = dbx_link_addr (abfd.get ());

   if (sym_addr != 0)
     {
   if (sym_addr != 0)
     {

+      struct breakpoint *dbx_link_bpt;
+

       /* Insert the breakpoint.  */
       /* Insert the breakpoint.  */

-      dbx_link_bpt_addr = sym_addr;
-      dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch (), NULL,
-                                                      sym_addr);
+      dbx_link_bpt
+       = create_and_insert_solib_event_breakpoint (target_gdbarch (),
+                                                   sym_addr);

       if (dbx_link_bpt == NULL)
        {
          warning (_("Failed to insert dbx_link breakpoint."));
       if (dbx_link_bpt == NULL)
        {
          warning (_("Failed to insert dbx_link breakpoint."));

-         gdb_bfd_unref (abfd);

          return 0;
        }
          return 0;
        }

-      gdb_bfd_unref (abfd);

       return 1;
     }
 
       return 1;
     }
 

-  gdb_bfd_unref (abfd);

   return 0;
 }
 
   return 0;
 }
 


@@ -3745,7 +3717,7 @@ wait_again:
                    else
                      {
                        /* How to keep going without returning to wfi: */
                    else
                      {
                        /* How to keep going without returning to wfi: */

-                       target_resume (ptid, 0, GDB_SIGNAL_0);
+                       target_continue_no_signal (ptid);

                        goto wait_again;
                      }
                  }
                        goto wait_again;
                      }
                  }


@@ -3771,7 +3743,7 @@ wait_again:
                    /* This is an internal event and should be transparent
                       to wfi, so resume the execution and wait again.  See
                       comment in procfs_init_inferior() for more details.  */
                    /* This is an internal event and should be transparent
                       to wfi, so resume the execution and wait again.  See
                       comment in procfs_init_inferior() for more details.  */

-                   target_resume (ptid, 0, GDB_SIGNAL_0);
+                   target_continue_no_signal (ptid);

                    goto wait_again;
                  }
 #endif
                    goto wait_again;
                  }
 #endif


@@ -3865,7 +3837,7 @@ wait_again:
                      add_thread (temp_ptid);
 
                    status->kind = TARGET_WAITKIND_STOPPED;
                      add_thread (temp_ptid);
 
                    status->kind = TARGET_WAITKIND_STOPPED;

-                   status->value.sig = 0;
+                   status->value.sig = GDB_SIGNAL_0;

                    return retval;
                  }
 #endif
                    return retval;
                  }
 #endif


@@ -3895,14 +3867,6 @@ wait_again:
 #if (FLTTRACE != FLTBPT)       /* Avoid "duplicate case" error.  */
                case FLTTRACE:
 #endif
 #if (FLTTRACE != FLTBPT)       /* Avoid "duplicate case" error.  */
                case FLTTRACE:
 #endif

-                 /* If we hit our __dbx_link() internal breakpoint,
-                    then remove it.  See comments in procfs_init_inferior()
-                    for more details.  */
-                 if (dbx_link_bpt_addr != 0
-                     && dbx_link_bpt_addr
-                        == regcache_read_pc (get_current_regcache ()))
-                   remove_dbx_link_breakpoint ();
-

                  wstat = (SIGTRAP << 8) | 0177;
                  break;
                case FLTSTACK:
                  wstat = (SIGTRAP << 8) | 0177;
                  break;
                case FLTSTACK:


@@ -3973,53 +3937,39 @@ wait_again:
 /* Perform a partial transfer to/from the specified object.  For
    memory transfers, fall back to the old memory xfer functions.  */
 
 /* Perform a partial transfer to/from the specified object.  For
    memory transfers, fall back to the old memory xfer functions.  */
 

-static LONGEST
+static enum target_xfer_status

 procfs_xfer_partial (struct target_ops *ops, enum target_object object,
                     const char *annex, gdb_byte *readbuf,
 procfs_xfer_partial (struct target_ops *ops, enum target_object object,
                     const char *annex, gdb_byte *readbuf,

-                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+                    const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+                    ULONGEST *xfered_len)

 {
   switch (object)
     {
     case TARGET_OBJECT_MEMORY:
 {
   switch (object)
     {
     case TARGET_OBJECT_MEMORY:

-      if (readbuf)
-       return (*ops->deprecated_xfer_memory) (offset, readbuf,
-                                              len, 0/*read*/, NULL, ops);
-      if (writebuf)
-       return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
-                                              len, 1/*write*/, NULL, ops);
-      return -1;
+      return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);

 
 #ifdef NEW_PROC_API
     case TARGET_OBJECT_AUXV:
       return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
 
 #ifdef NEW_PROC_API
     case TARGET_OBJECT_AUXV:
       return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,

-                              offset, len);
+                              offset, len, xfered_len);

 #endif
 
     default:
 #endif
 
     default:

-      if (ops->beneath != NULL)
-       return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
-                                             readbuf, writebuf, offset, len);
-      return -1;
+      return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
+                                           readbuf, writebuf, offset, len,
+                                           xfered_len);

     }
 }
 
     }
 }
 

+/* Helper for procfs_xfer_partial that handles memory transfers.
+   Arguments are like target_xfer_partial.  */

 
 

-/* Transfer LEN bytes between GDB address MYADDR and target address
-   MEMADDR.  If DOWRITE is non-zero, transfer them to the target,
-   otherwise transfer them from the target.  TARGET is unused.
-
-   The return value is 0 if an error occurred or no bytes were
-   transferred.  Otherwise, it will be a positive value which
-   indicates the number of bytes transferred between gdb and the
-   target.  (Note that the interface also makes provisions for
-   negative values, but this capability isn't implemented here.)  */
-
-static int
-procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
-                   struct mem_attrib *attrib, struct target_ops *target)
+static enum target_xfer_status
+procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
+                   ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)

 {
   procinfo *pi;
 {
   procinfo *pi;

-  int nbytes = 0;
+  int nbytes;

 
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
 
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);


@@ -4027,31 +3977,26 @@ procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
       open_procinfo_files (pi, FD_AS) == 0)
     {
       proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);
       open_procinfo_files (pi, FD_AS) == 0)
     {
       proc_warn (pi, "xfer_memory, open_proc_files", __LINE__);

-      return 0;
+      return TARGET_XFER_E_IO;

     }
 
     }
 

-  if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
+  if (lseek (pi->as_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
+    return TARGET_XFER_E_IO;
+
+  if (writebuf != NULL)

     {
     {

-      if (dowrite)
-       {
-#ifdef NEW_PROC_API
-         PROCFS_NOTE ("write memory:\n");
-#else
-         PROCFS_NOTE ("write memory:\n");
-#endif
-         nbytes = write (pi->as_fd, myaddr, len);
-       }
-      else
-       {
-         PROCFS_NOTE ("read  memory:\n");
-         nbytes = read (pi->as_fd, myaddr, len);
-       }
-      if (nbytes < 0)
-       {
-         nbytes = 0;
-       }
+      PROCFS_NOTE ("write memory:\n");
+      nbytes = write (pi->as_fd, writebuf, len);

     }
     }

-  return nbytes;
+  else
+    {
+      PROCFS_NOTE ("read  memory:\n");
+      nbytes = read (pi->as_fd, readbuf, len);
+    }
+  if (nbytes <= 0)
+    return TARGET_XFER_E_IO;
+  *xfered_len = nbytes;
+  return TARGET_XFER_OK;

 }
 
 /* Called by target_resume before making child runnable.  Mark cached
 }
 
 /* Called by target_resume before making child runnable.  Mark cached


@@ -4224,7 +4169,8 @@ procfs_resume (struct target_ops *ops,
 /* Set up to trace signals in the child process.  */
 
 static void
 /* Set up to trace signals in the child process.  */
 
 static void

-procfs_pass_signals (int numsigs, unsigned char *pass_signals)
+procfs_pass_signals (struct target_ops *self,
+                    int numsigs, unsigned char *pass_signals)

 {
   gdb_sigset_t signals;
   procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
 {
   gdb_sigset_t signals;
   procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);


@@ -4260,7 +4206,7 @@ procfs_files_info (struct target_ops *ignore)
    kill(SIGINT) to the child's process group.  */
 
 static void
    kill(SIGINT) to the child's process group.  */
 
 static void

-procfs_stop (ptid_t ptid)
+procfs_interrupt (struct target_ops *self, ptid_t ptid)

 {
   kill (-inferior_process_group (), SIGINT);
 }
 {
   kill (-inferior_process_group (), SIGINT);
 }


@@ -4276,16 +4222,6 @@ unconditionally_kill_inferior (procinfo *pi)
   int parent_pid;
 
   parent_pid = proc_parent_pid (pi);
   int parent_pid;
 
   parent_pid = proc_parent_pid (pi);

-#ifdef PROCFS_NEED_CLEAR_CURSIG_FOR_KILL
-  /* FIXME: use access functions.  */
-  /* Alpha OSF/1-3.x procfs needs a clear of the current signal
-     before the PIOCKILL, otherwise it might generate a corrupted core
-     file for the inferior.  */
-  if (ioctl (pi->ctl_fd, PIOCSSIG, NULL) < 0)
-    {
-      printf_filtered ("unconditionally_kill: SSIG failed!\n");
-    }
-#endif

 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
   /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
      to kill the inferior, otherwise it might remain stopped with a
 #ifdef PROCFS_NEED_PIOCSSIG_FOR_KILL
   /* Alpha OSF/1-2.x procfs needs a PIOCSSIG call with a SIGKILL signal
      to kill the inferior, otherwise it might remain stopped with a


@@ -4338,7 +4274,7 @@ procfs_kill_inferior (struct target_ops *ops)
 
       if (pi)
        unconditionally_kill_inferior (pi);
 
       if (pi)
        unconditionally_kill_inferior (pi);

-      target_mourn_inferior ();
+      target_mourn_inferior (inferior_ptid);

     }
 }
 
     }
 }
 


@@ -4356,16 +4292,10 @@ procfs_mourn_inferior (struct target_ops *ops)
       if (pi)
        destroy_procinfo (pi);
     }
       if (pi)
        destroy_procinfo (pi);
     }

-  unpush_target (ops);
-
-  if (dbx_link_bpt != NULL)
-    {
-      deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt);
-      dbx_link_bpt_addr = 0;
-      dbx_link_bpt = NULL;
-    }

 
   generic_mourn_inferior ();
 
   generic_mourn_inferior ();

+
+  inf_child_maybe_unpush_target (ops);

 }
 
 /* When GDB forks to create a runnable inferior process, this function
 }
 
 /* When GDB forks to create a runnable inferior process, this function


@@ -4383,7 +4313,8 @@ procfs_init_inferior (struct target_ops *ops, int pid)
 
   /* This routine called on the parent side (GDB side)
      after GDB forks the inferior.  */
 
   /* This routine called on the parent side (GDB side)
      after GDB forks the inferior.  */

-  push_target (ops);
+  if (!target_is_pushed (ops))
+    push_target (ops);

 
   if ((pi = create_procinfo (pid, 0)) == NULL)
     perror (_("procfs: out of memory in 'init_inferior'"));
 
   if ((pi = create_procinfo (pid, 0)) == NULL)
     perror (_("procfs: out of memory in 'init_inferior'"));


@@ -4595,8 +4526,8 @@ procfs_set_exec_trap (void)
    inf-ptrace?  */
 
 static void
    inf-ptrace?  */
 
 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)

 {
   char *shell_file = getenv ("SHELL");
   char *tryname;
 {
   char *shell_file = getenv ("SHELL");
   char *tryname;


@@ -4626,18 +4557,18 @@ procfs_create_inferior (struct target_ops *ops, char *exec_file,
         if the caller is the superuser; failing to use it loses if
         there are ACLs or some such.  */
 
         if the caller is the superuser; failing to use it loses if
         there are ACLs or some such.  */
 

-      char *p;
-      char *p1;
+      const char *p;
+      const char *p1;

       /* FIXME-maybe: might want "set path" command so user can change what
         path is used from within GDB.  */
       /* FIXME-maybe: might want "set path" command so user can change what
         path is used from within GDB.  */

-      char *path = getenv ("PATH");
+      const char *path = getenv ("PATH");

       int len;
       struct stat statbuf;
 
       if (path == NULL)
        path = "/bin:/usr/bin";
 
       int len;
       struct stat statbuf;
 
       if (path == NULL)
        path = "/bin:/usr/bin";
 

-      tryname = alloca (strlen (path) + strlen (shell_file) + 2);
+      tryname = (char *) alloca (strlen (path) + strlen (shell_file) + 2);

       for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
        {
          p1 = strchr (p, ':');
       for (p = path; p != NULL; p = p1 ? p1 + 1: NULL)
        {
          p1 = strchr (p, ':');


@@ -4700,7 +4631,7 @@ procfs_inferior_created (struct target_ops *ops, int from_tty)
 #endif
 }
 
 #endif
 }
 

-/* Callback for find_new_threads.  Calls "add_thread".  */
+/* Callback for update_thread_list.  Calls "add_thread".  */

 
 static int
 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)
 
 static int
 procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)


@@ -4717,10 +4648,12 @@ procfs_notice_thread (procinfo *pi, procinfo *thread, void *ptr)
    back to GDB to add to its list.  */
 
 static void
    back to GDB to add to its list.  */
 
 static void

-procfs_find_new_threads (struct target_ops *ops)
+procfs_update_thread_list (struct target_ops *ops)

 {
   procinfo *pi;
 
 {
   procinfo *pi;
 

+  prune_threads ();
+

   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
   proc_update_threads (pi);
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
   proc_update_threads (pi);


@@ -4758,7 +4691,7 @@ procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
 /* Convert PTID to a string.  Returns the string in a static
    buffer.  */
 
 /* Convert PTID to a string.  Returns the string in a static
    buffer.  */
 

-static char *
+static const char *

 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[80];
 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[80];


@@ -4832,7 +4765,9 @@ procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
    target_can_use_hardware_watchpoint.  */
 
 static int
    target_can_use_hardware_watchpoint.  */
 
 static int

-procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
+procfs_can_use_hw_breakpoint (struct target_ops *self,
+                             enum bptype type,
+                             int cnt, int othertype)

 {
   /* Due to the way that proc_set_watchpoint() is implemented, host
      and target pointers must be of the same size.  If they are not,
 {
   /* Due to the way that proc_set_watchpoint() is implemented, host
      and target pointers must be of the same size.  If they are not,


@@ -4856,7 +4791,7 @@ procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
    fault, else returns zero.  */
 
 static int
    fault, else returns zero.  */
 
 static int

-procfs_stopped_by_watchpoint (void)
+procfs_stopped_by_watchpoint (struct target_ops *ops)

 {
   procinfo *pi;
 
 {
   procinfo *pi;
 


@@ -4895,7 +4830,9 @@ procfs_stopped_data_address (struct target_ops *targ, CORE_ADDR *addr)
 }
 
 static int
 }
 
 static int

-procfs_insert_watchpoint (CORE_ADDR addr, int len, int type,
+procfs_insert_watchpoint (struct target_ops *self,
+                         CORE_ADDR addr, int len,
+                         enum target_hw_bp_type type,

                          struct expression *cond)
 {
   if (!target_have_steppable_watchpoint
                          struct expression *cond)
 {
   if (!target_have_steppable_watchpoint


@@ -4917,14 +4854,17 @@ procfs_insert_watchpoint (CORE_ADDR addr, int len, int type,
 }
 
 static int
 }
 
 static int

-procfs_remove_watchpoint (CORE_ADDR addr, int len, int type,
+procfs_remove_watchpoint (struct target_ops *self,
+                         CORE_ADDR addr, int len,
+                         enum target_hw_bp_type type,

                          struct expression *cond)
 {
   return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0);
 }
 
 static int
                          struct expression *cond)
 {
   return procfs_set_watchpoint (inferior_ptid, addr, 0, 0, 0);
 }
 
 static int

-procfs_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+procfs_region_ok_for_hw_watchpoint (struct target_ops *self,
+                                   CORE_ADDR addr, int len)

 {
   /* The man page for proc(4) on Solaris 2.6 and up says that the
      system can support "thousands" of hardware watchpoints, but gives
 {
   /* The man page for proc(4) on Solaris 2.6 and up says that the
      system can support "thousands" of hardware watchpoints, but gives


@@ -5049,7 +4989,8 @@ find_memory_regions_callback (struct prmap *map,
    the callback.  */
 
 static int
    the callback.  */
 
 static int

-proc_find_memory_regions (find_memory_region_ftype func, void *data)
+proc_find_memory_regions (struct target_ops *self,
+                         find_memory_region_ftype func, void *data)

 {
   procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
 
 {
   procinfo *pi = find_procinfo_or_die (ptid_get_pid (inferior_ptid), 0);
 


@@ -5148,7 +5089,7 @@ info_proc_mappings (procinfo *pi, int summary)
 /* Implement the "info proc" command.  */
 
 static void
 /* Implement the "info proc" command.  */
 
 static void

-procfs_info_proc (struct target_ops *ops, char *args,
+procfs_info_proc (struct target_ops *ops, const char *args,

                  enum info_proc_what what)
 {
   struct cleanup *old_chain;
                  enum info_proc_what what)
 {
   struct cleanup *old_chain;


@@ -5383,7 +5324,7 @@ procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
   /* This part is the old method for fetching registers.
      It should be replaced by the newer one using regsets
      once it is implemented in this platform:
   /* This part is the old method for fetching registers.
      It should be replaced by the newer one using regsets
      once it is implemented in this platform:

-     gdbarch_regset_from_core_section() and regset->collect_regset().  */
+     gdbarch_iterate_over_regset_sections().  */

 
   old_chain = save_inferior_ptid ();
   inferior_ptid = ptid;
 
   old_chain = save_inferior_ptid ();
   inferior_ptid = ptid;


@@ -5427,7 +5368,8 @@ struct procfs_corefile_thread_data {
 static int
 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
 {
 static int
 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
 {

-  struct procfs_corefile_thread_data *args = data;
+  struct procfs_corefile_thread_data *args
+    = (struct procfs_corefile_thread_data *) data;

 
   if (pi != NULL)
     {
 
   if (pi != NULL)
     {


@@ -5464,7 +5406,7 @@ find_stop_signal (void)
 }
 
 static char *
 }
 
 static char *

-procfs_make_note_section (bfd *obfd, int *note_size)
+procfs_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)

 {
   struct cleanup *old_chain;
   gdb_gregset_t gregs;
 {
   struct cleanup *old_chain;
   gdb_gregset_t gregs;


@@ -5518,9 +5460,6 @@ procfs_make_note_section (bfd *obfd, int *note_size)
   thread_args.stop_signal = stop_signal;
   proc_iterate_over_threads (pi, procfs_corefile_thread_callback,
                             &thread_args);
   thread_args.stop_signal = stop_signal;
   proc_iterate_over_threads (pi, procfs_corefile_thread_callback,
                             &thread_args);

-
-  /* There should be always at least one thread.  */
-  gdb_assert (thread_args.note_data != note_data);

   note_data = thread_args.note_data;
 
   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,
   note_data = thread_args.note_data;
 
   auxv_len = target_read_alloc (&current_target, TARGET_OBJECT_AUXV,


@@ -5532,12 +5471,11 @@ procfs_make_note_section (bfd *obfd, int *note_size)
       xfree (auxv);
     }
 
       xfree (auxv);
     }
 

-  make_cleanup (xfree, note_data);

   return note_data;
 }
 #else /* !Solaris */
 static char *
   return note_data;
 }
 #else /* !Solaris */
 static char *

-procfs_make_note_section (bfd *obfd, int *note_size)
+procfs_make_note_section (struct target_ops *self, bfd *obfd, int *note_size)

 {
   error (_("gcore not implemented for this host."));
   return NULL; /* lint */
 {
   error (_("gcore not implemented for this host."));
   return NULL; /* lint */