Merge GDB 7.5.1

gdb/procfs.c

 /* Machine independent support for SVR4 /proc (process file system) for GDB.
 
    Copyright (C) 1999-2003, 2006-2012 Free Software Foundation, Inc.
 
    Written by Michael Snyder at Cygnus Solutions.
    Based on work by Fred Fish, Stu Grossman, Geoff Noer, and others.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 94 matching lines @@
 /* Prototypes for supply_gregset etc.  */
 #include "gregset.h"
 
 /* =================== TARGET_OPS "MODULE" =================== */
 
 /* This module defines the GDB target vector and its methods.  */
 
 static void procfs_attach (struct target_ops *, char *, int);
 static void procfs_detach (struct target_ops *, char *, int);
 static void procfs_resume (struct target_ops *,
-                           ptid_t, int, enum target_signal);
+                           ptid_t, int, enum gdb_signal);
 static void procfs_stop (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_pass_signals (int, unsigned char *);
 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 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 LONGEST 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);
 
 static int procfs_thread_alive (struct target_ops *ops, ptid_t);
 
-void procfs_find_new_threads (struct target_ops *ops);
-char *procfs_pid_to_str (struct target_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 int proc_find_memory_regions (int (*) (CORE_ADDR,
                                               unsigned long,
                                               int, int, int,
                                               void *),
                                      void *);
 
 static char * procfs_make_note_section (bfd *, int *);
 
 static int procfs_can_use_hw_breakpoint (int, int, int);
 
+static void procfs_info_proc (struct target_ops *, char *,
+                              enum info_proc_what);
+
 #if defined (PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
 /* When GDB is built as 64-bit application on Solaris, the auxv data
    is presented in 64-bit format.  We need to provide a custom parser
    to handle that.  */
 static int
 procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                    gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
   gdb_byte *ptr = *readptr;
@@ skipping 40 matching lines @@
   t->to_files_info = procfs_files_info;
   t->to_stop = procfs_stop;
 
   t->to_find_new_threads = procfs_find_new_threads;
   t->to_thread_alive = procfs_thread_alive;
   t->to_pid_to_str = procfs_pid_to_str;
 
   t->to_has_thread_control = tc_schedlock;
   t->to_find_memory_regions = proc_find_memory_regions;
   t->to_make_corefile_notes = procfs_make_note_section;
+  t->to_info_proc = procfs_info_proc;
 
 #if defined(PR_MODEL_NATIVE) && (PR_MODEL_NATIVE == PR_MODEL_LP64)
   t->to_auxv_parse = procfs_auxv_parse;
 #endif
 
   t->to_magic = OPS_MAGIC;
 
   return t;
 }
 
@@ skipping 31 matching lines @@
 #ifdef HAVE_PR_SIGACTION64_T
 typedef pr_sigaction64_t gdb_sigaction_t;
 #else
 typedef struct sigaction gdb_sigaction_t;
 #endif
 
 /* siginfo */
 #ifdef HAVE_PR_SIGINFO64_T
 typedef pr_siginfo64_t gdb_siginfo_t;
 #else
-typedef struct siginfo gdb_siginfo_t;
+typedef siginfo_t gdb_siginfo_t;
 #endif
 
 /* On mips-irix, praddset and prdelset are defined in such a way that
    they return a value, which causes GCC to emit a -Wunused error
    because the returned value is not used.  Prevent this warning
    by casting the return value to void.  On sparc-solaris, this issue
    does not exist because the definition of these macros already include
    that cast to void.  */
 #define gdb_praddset(sp, flag) ((void) praddset (sp, flag))
 #define gdb_prdelset(sp, flag) ((void) prdelset (sp, flag))
@@ skipping 732 matching lines @@
 /* This "module" is the interface layer between the /proc system API
    and the gdb target vector functions.  This layer consists of access
    functions that encapsulate each of the basic operations that we
    need to use from the /proc API.
 
    The main motivation for this layer is to hide the fact that there
    are two very different implementations of the /proc API.  Rather
    than have a bunch of #ifdefs all thru the gdb target vector
    functions, we do our best to hide them all in here.  */
 
-int proc_get_status (procinfo * pi);
-long proc_flags (procinfo * pi);
-int proc_why (procinfo * pi);
-int proc_what (procinfo * pi);
-int proc_set_run_on_last_close (procinfo * pi);
-int proc_unset_run_on_last_close (procinfo * pi);
-int proc_set_inherit_on_fork (procinfo * pi);
-int proc_unset_inherit_on_fork (procinfo * pi);
-int proc_set_async (procinfo * pi);
-int proc_unset_async (procinfo * pi);
-int proc_stop_process (procinfo * pi);
-int proc_trace_signal (procinfo * pi, int signo);
-int proc_ignore_signal (procinfo * pi, int signo);
-int proc_clear_current_fault (procinfo * pi);
-int proc_set_current_signal (procinfo * pi, int signo);
-int proc_clear_current_signal (procinfo * pi);
-int proc_set_gregs (procinfo * pi);
-int proc_set_fpregs (procinfo * pi);
-int proc_wait_for_stop (procinfo * pi);
-int proc_run_process (procinfo * pi, int step, int signo);
-int proc_kill (procinfo * pi, int signo);
-int proc_parent_pid (procinfo * pi);
-int proc_get_nthreads (procinfo * pi);
-int proc_get_current_thread (procinfo * pi);
-int proc_set_held_signals (procinfo * pi, gdb_sigset_t * sighold);
-int proc_set_traced_sysexit (procinfo * pi, sysset_t * sysset);
-int proc_set_traced_sysentry (procinfo * pi, sysset_t * sysset);
-int proc_set_traced_faults (procinfo * pi, fltset_t * fltset);
-int proc_set_traced_signals (procinfo * pi, gdb_sigset_t * sigset);
+static long proc_flags (procinfo * pi);
+static int proc_why (procinfo * pi);
+static int proc_what (procinfo * pi);
+static int proc_set_current_signal (procinfo * pi, int signo);
+static int proc_get_current_thread (procinfo * pi);
+static int proc_iterate_over_threads
+  (procinfo * pi,
+   int (*func) (procinfo *, procinfo *, void *),
+   void *ptr);
 
-int proc_update_threads (procinfo * pi);
-int proc_iterate_over_threads (procinfo * pi,
-                               int (*func) (procinfo *, procinfo *, void *),
-                               void *ptr);
-
-gdb_gregset_t *proc_get_gregs (procinfo * pi);
-gdb_fpregset_t *proc_get_fpregs (procinfo * pi);
-sysset_t *proc_get_traced_sysexit (procinfo * pi, sysset_t * save);
-sysset_t *proc_get_traced_sysentry (procinfo * pi, sysset_t * save);
-fltset_t *proc_get_traced_faults (procinfo * pi, fltset_t * save);
-gdb_sigset_t *proc_get_traced_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigset_t *proc_get_held_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigset_t *proc_get_pending_signals (procinfo * pi, gdb_sigset_t * save);
-gdb_sigaction_t *proc_get_signal_actions (procinfo * pi,
-                                          gdb_sigaction_t *save);
-
-void proc_warn (procinfo * pi, char *func, int line);
-void proc_error (procinfo * pi, char *func, int line);
-
-void
+static void
 proc_warn (procinfo *pi, char *func, int line)
 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   print_sys_errmsg (errmsg, errno);
 }
 
-void
+static void
 proc_error (procinfo *pi, char *func, int line)
 {
   sprintf (errmsg, "procfs: %s line %d, %s", func, line, pi->pathname);
   perror_with_name (errmsg);
 }
 
 /* Updates the status struct in the procinfo.  There is a 'valid'
    flag, to let other functions know when this function needs to be
    called (so the status is only read when it is needed).  The status
    file descriptor is also only opened when it is needed.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_get_status (procinfo *pi)
 {
   /* Status file descriptor is opened "lazily".  */
   if (pi->status_fd == 0 &&
       open_procinfo_files (pi, FD_STATUS) == 0)
     {
       pi->status_valid = 0;
       return 0;
     }
 
@@ skipping 73 matching lines @@
 #ifdef NEW_PROC_API
   /* In the read/write multiple-fd model, the status struct includes
      the fp regs too, so mark them valid too.  */
   pi->fpregs_valid = pi->status_valid;
 #endif
   return pi->status_valid;      /* True if success, false if failure.  */
 }
 
 /* Returns the process flags (pr_flags field).  */
 
-long
+static long
 proc_flags (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0; /* FIXME: not a good failure value (but what is?)  */
 
 #ifdef NEW_PROC_API
 # ifdef UNIXWARE
   /* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
      pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
      The two sets of flags don't overlap.  */
   return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
 # else
   return pi->prstatus.pr_lwp.pr_flags;
 # endif
 #else
   return pi->prstatus.pr_flags;
 #endif
 }
 
 /* Returns the pr_why field (why the process stopped).  */
 
-int
+static int
 proc_why (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0; /* FIXME: not a good failure value (but what is?)  */
 
 #ifdef NEW_PROC_API
   return pi->prstatus.pr_lwp.pr_why;
 #else
   return pi->prstatus.pr_why;
 #endif
 }
 
 /* Returns the pr_what field (details of why the process stopped).  */
 
-int
+static int
 proc_what (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0; /* FIXME: not a good failure value (but what is?)  */
 
 #ifdef NEW_PROC_API
   return pi->prstatus.pr_lwp.pr_what;
 #else
   return pi->prstatus.pr_what;
@@ skipping 22 matching lines @@
             (gdb_byte *) &pi->prstatus.pr_info.si_addr);
 #endif
   return 1;
 }
 
 #ifndef PIOCSSPCACT     /* The following is not supported on OSF.  */
 
 /* Returns the pr_nsysarg field (number of args to the current
    syscall).  */
 
-int
+static int
 proc_nsysarg (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0;
 
 #ifdef NEW_PROC_API
   return pi->prstatus.pr_lwp.pr_nsysarg;
 #else
   return pi->prstatus.pr_nsysarg;
 #endif
 }
 
 /* Returns the pr_sysarg field (pointer to the arguments of current
    syscall).  */
 
-long *
+static long *
 proc_sysargs (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return NULL;
 
 #ifdef NEW_PROC_API
   return (long *) &pi->prstatus.pr_lwp.pr_sysarg;
 #else
   return (long *) &pi->prstatus.pr_sysarg;
 #endif
 }
-
-/* Returns the pr_syscall field (id of current syscall if we are in
-   one).  */
-
-int
-proc_syscall (procinfo *pi)
-{
-  if (!pi->status_valid)
-    if (!proc_get_status (pi))
-      return 0;
-
-#ifdef NEW_PROC_API
-  return pi->prstatus.pr_lwp.pr_syscall;
-#else
-  return pi->prstatus.pr_syscall;
-#endif
-}
 #endif /* PIOCSSPCACT */
 
+#ifdef PROCFS_DONT_PIOCSSIG_CURSIG
 /* Returns the pr_cursig field (current signal).  */
 
-long
+static long
 proc_cursig (struct procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0; /* FIXME: not a good failure value (but what is?)  */
 
 #ifdef NEW_PROC_API
   return pi->prstatus.pr_lwp.pr_cursig;
 #else
   return pi->prstatus.pr_cursig;
 #endif
 }
+#endif /* PROCFS_DONT_PIOCSSIG_CURSIG */
 
 /* === I appologize for the messiness of this function.
    === This is an area where the different versions of
    === /proc are more inconsistent than usual.
 
    Set or reset any of the following process flags:
       PR_FORK   -- forked child will inherit trace flags
       PR_RLC    -- traced process runs when last /proc file closed.
       PR_KLC    -- traced process is killed when last /proc file closed.
       PR_ASYNC  -- LWP's get to run/stop independently.
@@ skipping 114 matching lines @@
              "<unknown flag>",
              mode == FLAG_RESET ? "off" : "on");
 
   return win;
 }
 
 /* Set the run_on_last_close flag.  Process with all threads will
    become runnable when debugger closes all /proc fds.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_run_on_last_close (procinfo *pi)
 {
   return proc_modify_flag (pi, PR_RLC, FLAG_SET);
 }
 
 /* Reset the run_on_last_close flag.  The process will NOT become
    runnable when debugger closes its file handles.  Returns non-zero
    for success, zero for failure.  */
 
-int
+static int
 proc_unset_run_on_last_close (procinfo *pi)
 {
   return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
 }
 
-#ifdef PR_KLC
-/* Set the kill_on_last_close flag.  Process with all threads will be
-   killed when debugger closes all /proc fds (or debugger exits or
-   dies).  Returns non-zero for success, zero for failure.  */
-
-int
-proc_set_kill_on_last_close (procinfo *pi)
-{
-  return proc_modify_flag (pi, PR_KLC, FLAG_SET);
-}
-
-/* Reset the kill_on_last_close flag.  Process will NOT be killed when
-   debugger closes its file handles (or exits or dies).  Returns
-   non-zero for success, zero for failure.  */
-
-int
-proc_unset_kill_on_last_close (procinfo *pi)
-{
-  return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
-}
-#endif /* PR_KLC */
-
-/* Set inherit_on_fork flag.  If the process forks a child while we
-   are registered for events in the parent, then we will also recieve
-   events from the child.  Returns non-zero for success, zero for
-   failure.  */
-
-int
-proc_set_inherit_on_fork (procinfo *pi)
-{
-  return proc_modify_flag (pi, PR_FORK, FLAG_SET);
-}
-
 /* Reset inherit_on_fork flag.  If the process forks a child while we
    are registered for events in the parent, then we will NOT recieve
    events from the child.  Returns non-zero for success, zero for
    failure.  */
 
-int
+static int
 proc_unset_inherit_on_fork (procinfo *pi)
 {
   return proc_modify_flag (pi, PR_FORK, FLAG_RESET);
 }
 
 #ifdef PR_ASYNC
 /* Set PR_ASYNC flag.  If one LWP stops because of a debug event
    (signal etc.), the remaining LWPs will continue to run.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_async (procinfo *pi)
 {
   return proc_modify_flag (pi, PR_ASYNC, FLAG_SET);
 }
 
 /* Reset PR_ASYNC flag.  If one LWP stops because of a debug event
    (signal etc.), then all other LWPs will stop as well.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_unset_async (procinfo *pi)
 {
   return proc_modify_flag (pi, PR_ASYNC, FLAG_RESET);
 }
 #endif /* PR_ASYNC */
 
 /* Request the process/LWP to stop.  Does not wait.  Returns non-zero
    for success, zero for failure.  */
 
-int
+static int
 proc_stop_process (procinfo *pi)
 {
   int win;
 
   /* We might conceivably apply this operation to an LWP, and the
      LWP's ctl file descriptor might not be open.  */
 
   if (pi->ctl_fd == 0 &&
       open_procinfo_files (pi, FD_CTL) == 0)
     return 0;
@@ skipping 16 matching lines @@
         }
 #endif
     }
 
   return win;
 }
 
 /* Wait for the process or LWP to stop (block until it does).  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_wait_for_stop (procinfo *pi)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 35 matching lines @@
      - (ioctl): set held   signal set
      - (ioctl): set traced fault  set
      - (ioctl): set start pc (vaddr)
 
    Always clears the current fault.  PI is the process or LWP to
    operate on.  If STEP is true, set the process or LWP to trap after
    one instruction.  If SIGNO is zero, clear the current signal if
    any; if non-zero, set the current signal to this one.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_run_process (procinfo *pi, int step, int signo)
 {
   int win;
   int runflags;
 
   /* We will probably have to apply this operation to individual
      threads, so make sure the control file descriptor is open.  */
 
   if (pi->ctl_fd == 0 &&
       open_procinfo_files (pi, FD_CTL) == 0)
@@ skipping 26 matching lines @@
     win = (ioctl (pi->ctl_fd, PIOCRUN, &prrun) >= 0);
   }
 #endif
 
   return win;
 }
 
 /* Register to trace signals in the process or LWP.  Returns non-zero
    for success, zero for failure.  */
 
-int
+static int
 proc_set_traced_signals (procinfo *pi, gdb_sigset_t *sigset)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 19 matching lines @@
   pi->status_valid = 0;
 
   if (!win)
     warning (_("procfs: set_traced_signals failed"));
   return win;
 }
 
 /* Register to trace hardware faults in the process or LWP.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_traced_faults (procinfo *pi, fltset_t *fltset)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 17 matching lines @@
 #endif
   /* The above operation renders the procinfo's cached pstatus obsolete.  */
   pi->status_valid = 0;
 
   return win;
 }
 
 /* Register to trace entry to system calls in the process or LWP.
    Returns non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_traced_sysentry (procinfo *pi, sysset_t *sysset)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 24 matching lines @@
   /* The above operation renders the procinfo's cached pstatus
      obsolete.  */
   pi->status_valid = 0;
 
   return win;
 }
 
 /* Register to trace exit from system calls in the process or LWP.
    Returns non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_traced_sysexit (procinfo *pi, sysset_t *sysset)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 24 matching lines @@
   /* The above operation renders the procinfo's cached pstatus
      obsolete.  */
   pi->status_valid = 0;
 
   return win;
 }
 
 /* Specify the set of blocked / held signals in the process or LWP.
    Returns non-zero for success, zero for failure.  */
 
-int
+static int
 proc_set_held_signals (procinfo *pi, gdb_sigset_t *sighold)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 14 matching lines @@
 #else
   win = (ioctl (pi->ctl_fd, PIOCSHOLD, sighold) >= 0);
 #endif
   /* The above operation renders the procinfo's cached pstatus
      obsolete.  */
   pi->status_valid = 0;
 
   return win;
 }
 
-/* Returns the set of signals that are pending in the process or LWP.
-   Will also copy the sigset if SAVE is non-zero.  */
-
-gdb_sigset_t *
-proc_get_pending_signals (procinfo *pi, gdb_sigset_t *save)
-{
-  gdb_sigset_t *ret = NULL;
-
-  /* We should never have to apply this operation to any procinfo
-     except the one for the main process.  If that ever changes for
-     any reason, then take out the following clause and replace it
-     with one that makes sure the ctl_fd is open.  */
-
-  if (pi->tid != 0)
-    pi = find_procinfo_or_die (pi->pid, 0);
-
-  if (!pi->status_valid)
-    if (!proc_get_status (pi))
-      return NULL;
-
-#ifdef NEW_PROC_API
-  ret = &pi->prstatus.pr_lwp.pr_lwppend;
-#else
-  ret = &pi->prstatus.pr_sigpend;
-#endif
-  if (save && ret)
-    memcpy (save, ret, sizeof (gdb_sigset_t));
-
-  return ret;
-}
-
-/* Returns the set of signal actions.  Will also copy the sigactionset
-   if SAVE is non-zero.  */
-
-gdb_sigaction_t *
-proc_get_signal_actions (procinfo *pi, gdb_sigaction_t *save)
-{
-  gdb_sigaction_t *ret = NULL;
-
-  /* We should never have to apply this operation to any procinfo
-     except the one for the main process.  If that ever changes for
-     any reason, then take out the following clause and replace it
-     with one that makes sure the ctl_fd is open.  */
-
-  if (pi->tid != 0)
-    pi = find_procinfo_or_die (pi->pid, 0);
-
-  if (!pi->status_valid)
-    if (!proc_get_status (pi))
-      return NULL;
-
-#ifdef NEW_PROC_API
-  ret = &pi->prstatus.pr_lwp.pr_action;
-#else
-  ret = &pi->prstatus.pr_action;
-#endif
-  if (save && ret)
-    memcpy (save, ret, sizeof (gdb_sigaction_t));
-
-  return ret;
-}
-
 /* Returns the set of signals that are held / blocked.  Will also copy
    the sigset if SAVE is non-zero.  */
 
-gdb_sigset_t *
+static gdb_sigset_t *
 proc_get_held_signals (procinfo *pi, gdb_sigset_t *save)
 {
   gdb_sigset_t *ret = NULL;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 19 matching lines @@
 #endif /* NEW_PROC_API */
   if (save && ret)
     memcpy (save, ret, sizeof (gdb_sigset_t));
 
   return ret;
 }
 
 /* Returns the set of signals that are traced / debugged.  Will also
    copy the sigset if SAVE is non-zero.  */
 
-gdb_sigset_t *
+static gdb_sigset_t *
 proc_get_traced_signals (procinfo *pi, gdb_sigset_t *save)
 {
   gdb_sigset_t *ret = NULL;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 12 matching lines @@
     if (ioctl (pi->ctl_fd, PIOCGTRACE, &sigtrace) >= 0)
       ret = &sigtrace;
   }
 #endif
   if (save && ret)
     memcpy (save, ret, sizeof (gdb_sigset_t));
 
   return ret;
 }
 
-/* Add SIGNO to the set of signals that are traced.  Returns non-zero
-   for success, zero for failure.  */
-
-int
-proc_trace_signal (procinfo *pi, int signo)
-{
-  gdb_sigset_t temp;
-
-  /* We should never have to apply this operation to any procinfo
-     except the one for the main process.  If that ever changes for
-     any reason, then take out the following clause and replace it
-     with one that makes sure the ctl_fd is open.  */
-
-  if (pi->tid != 0)
-    pi = find_procinfo_or_die (pi->pid, 0);
-
-  if (pi)
-    {
-      if (proc_get_traced_signals (pi, &temp))
-        {
-          gdb_praddset (&temp, signo);
-          return proc_set_traced_signals (pi, &temp);
-        }
-    }
-
-  return 0;     /* failure */
-}
-
-/* Remove SIGNO from the set of signals that are traced.  Returns
-   non-zero for success, zero for failure.  */
-
-int
-proc_ignore_signal (procinfo *pi, int signo)
-{
-  gdb_sigset_t temp;
-
-  /* We should never have to apply this operation to any procinfo
-     except the one for the main process.  If that ever changes for
-     any reason, then take out the following clause and replace it
-     with one that makes sure the ctl_fd is open.  */
-
-  if (pi->tid != 0)
-    pi = find_procinfo_or_die (pi->pid, 0);
-
-  if (pi)
-    {
-      if (proc_get_traced_signals (pi, &temp))
-        {
-          gdb_prdelset (&temp, signo);
-          return proc_set_traced_signals (pi, &temp);
-        }
-    }
-
-  return 0;     /* failure */
-}
-
 /* Returns the set of hardware faults that are traced /debugged.  Will
    also copy the faultset if SAVE is non-zero.  */
 
-fltset_t *
+static fltset_t *
 proc_get_traced_faults (procinfo *pi, fltset_t *save)
 {
   fltset_t *ret = NULL;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 15 matching lines @@
 #endif
   if (save && ret)
     memcpy (save, ret, sizeof (fltset_t));
 
   return ret;
 }
 
 /* Returns the set of syscalls that are traced /debugged on entry.
    Will also copy the syscall set if SAVE is non-zero.  */
 
-sysset_t *
+static sysset_t *
 proc_get_traced_sysentry (procinfo *pi, sysset_t *save)
 {
   sysset_t *ret = NULL;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 46 matching lines @@
 #endif /* NEW_PROC_API */
   if (save && ret)
     memcpy (save, ret, sysset_t_size (pi));
 
   return ret;
 }
 
 /* Returns the set of syscalls that are traced /debugged on exit.
    Will also copy the syscall set if SAVE is non-zero.  */
 
-sysset_t *
+static sysset_t *
 proc_get_traced_sysexit (procinfo *pi, sysset_t *save)
 {
   sysset_t * ret = NULL;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 47 matching lines @@
   if (save && ret)
     memcpy (save, ret, sysset_t_size (pi));
 
   return ret;
 }
 
 /* The current fault (if any) is cleared; the associated signal will
    not be sent to the process or LWP when it resumes.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_clear_current_fault (procinfo *pi)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 13 matching lines @@
 }
 
 /* Set the "current signal" that will be delivered next to the
    process.  NOTE: semantics are different from those of KILL.  This
    signal will be delivered to the process or LWP immediately when it
    is resumed (even if the signal is held/blocked); it will NOT
    immediately cause another event of interest, and will NOT first
    trap back to the debugger.  Returns non-zero for success, zero for
    failure.  */
 
-int
+static int
 proc_set_current_signal (procinfo *pi, int signo)
 {
   int win;
   struct {
     procfs_ctl_t cmd;
     /* Use char array to avoid alignment issues.  */
     char sinfo[sizeof (gdb_siginfo_t)];
   } arg;
   gdb_siginfo_t mysinfo;
   ptid_t wait_ptid;
@@ skipping 14 matching lines @@
      bug.  */
   if (signo > 0 &&
       signo == proc_cursig (pi))
     return 1;           /* I assume this is a success?  */
 #endif
 
   /* The pointer is just a type alias.  */
   get_last_target_status (&wait_ptid, &wait_status);
   if (ptid_equal (wait_ptid, inferior_ptid)
       && wait_status.kind == TARGET_WAITKIND_STOPPED
-      && wait_status.value.sig == target_signal_from_host (signo)
+      && wait_status.value.sig == gdb_signal_from_host (signo)
       && proc_get_status (pi)
 #ifdef NEW_PROC_API
       && pi->prstatus.pr_lwp.pr_info.si_signo == signo
 #else
       && pi->prstatus.pr_info.si_signo == signo
 #endif
       )
     /* Use the siginfo associated with the signal being
        redelivered.  */
 #ifdef NEW_PROC_API
@@ skipping 17 matching lines @@
   win = (ioctl (pi->ctl_fd, PIOCSSIG, (void *) &arg.sinfo) >= 0);
 #endif
 
   return win;
 }
 
 /* The current signal (if any) is cleared, and is not sent to the
    process or LWP when it resumes.  Returns non-zero for success, zero
    for failure.  */
 
-int
+static int
 proc_clear_current_signal (procinfo *pi)
 {
   int win;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
@@ skipping 22 matching lines @@
 #else
   win = (ioctl (pi->ctl_fd, PIOCSSIG, 0) >= 0);
 #endif
 
   return win;
 }
 
 /* Return the general-purpose registers for the process or LWP
    corresponding to PI.  Upon failure, return NULL.  */
 
-gdb_gregset_t *
+static gdb_gregset_t *
 proc_get_gregs (procinfo *pi)
 {
   if (!pi->status_valid || !pi->gregs_valid)
     if (!proc_get_status (pi))
       return NULL;
 
   /* OK, sorry about the ifdef's.  There's three cases instead of two,
      because in this case Unixware and Solaris/RW differ.  */
 
 #ifdef NEW_PROC_API
 # ifdef UNIXWARE                /* FIXME:  Should be autoconfigured.  */
   return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.gregs;
 # else
   return &pi->prstatus.pr_lwp.pr_reg;
 # endif
 #else
   return &pi->prstatus.pr_reg;
 #endif
 }
 
 /* Return the general-purpose registers for the process or LWP
    corresponding to PI.  Upon failure, return NULL.  */
 
-gdb_fpregset_t *
+static gdb_fpregset_t *
 proc_get_fpregs (procinfo *pi)
 {
 #ifdef NEW_PROC_API
   if (!pi->status_valid || !pi->fpregs_valid)
     if (!proc_get_status (pi))
       return NULL;
 
 # ifdef UNIXWARE                /* FIXME:  Should be autoconfigured.  */
   return &pi->prstatus.pr_lwp.pr_context.uc_mcontext.fpregs;
 # else
@@ skipping 52 matching lines @@
 # endif
         }
     }
 #endif /* NEW_PROC_API */
 }
 
 /* Write the general-purpose registers back to the process or LWP
    corresponding to PI.  Return non-zero for success, zero for
    failure.  */
 
-int
+static int
 proc_set_gregs (procinfo *pi)
 {
   gdb_gregset_t *gregs;
   int win;
 
   gregs = proc_get_gregs (pi);
   if (gregs == NULL)
     return 0;                   /* proc_get_regs has already warned.  */
 
   if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
@@ skipping 19 matching lines @@
 
   /* Policy: writing the registers invalidates our cache.  */
   pi->gregs_valid = 0;
   return win;
 }
 
 /* Write the floating-pointer registers back to the process or LWP
    corresponding to PI.  Return non-zero for success, zero for
    failure.  */
 
-int
+static int
 proc_set_fpregs (procinfo *pi)
 {
   gdb_fpregset_t *fpregs;
   int win;
 
   fpregs = proc_get_fpregs (pi);
   if (fpregs == NULL)
     return 0;                   /* proc_get_fpregs has already warned.  */
 
   if (pi->ctl_fd == 0 && open_procinfo_files (pi, FD_CTL) == 0)
@@ skipping 37 matching lines @@
     }
 
   /* Policy: writing the registers invalidates our cache.  */
   pi->fpregs_valid = 0;
   return win;
 }
 
 /* Send a signal to the proc or lwp with the semantics of "kill()".
    Returns non-zero for success, zero for failure.  */
 
-int
+static int
 proc_kill (procinfo *pi, int signo)
 {
   int win;
 
   /* We might conceivably apply this operation to an LWP, and the
      LWP's ctl file descriptor might not be open.  */
 
   if (pi->ctl_fd == 0 &&
       open_procinfo_files (pi, FD_CTL) == 0)
     {
@@ skipping 13 matching lines @@
       win = (ioctl (pi->ctl_fd, PIOCKILL, &signo) >= 0);
 #endif
   }
 
   return win;
 }
 
 /* Find the pid of the process that started this one.  Returns the
    parent process pid, or zero.  */
 
-int
+static int
 proc_parent_pid (procinfo *pi)
 {
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
   if (pi->tid != 0)
     pi = find_procinfo_or_die (pi->pid, 0);
 
@@ skipping 15 matching lines @@
   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
   void *ptr;
 
   gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
   gdbarch_address_to_pointer (target_gdbarch, ptr_type,
                               (gdb_byte *) &ptr, addr);
   return ptr;
 }
 #endif
 
-int
+static int
 proc_set_watchpoint (procinfo *pi, CORE_ADDR addr, int len, int wflags)
 {
 #if !defined (PCWATCH) && !defined (PIOCSWATCH)
   /* If neither or these is defined, we can't support watchpoints.
      This just avoids possibly failing to compile the below on such
      systems.  */
   return 0;
 #else
 /* Horrible hack!  Detect Solaris 2.5, because this doesn't work on 2.5.  */
 #if defined (PIOCOPENLWP) || defined (UNIXWARE) /* Solaris 2.5: bail out.  */
@@ skipping 149 matching lines @@
 
 /* =================== Thread "MODULE" =================== */
 
 /* NOTE: you'll see more ifdefs and duplication of functions here,
    since there is a different way to do threads on every OS.  */
 
 /* Returns the number of threads for the process.  */
 
 #if defined (PIOCNTHR) && defined (PIOCTLIST)
 /* OSF version */
-int
+static int
 proc_get_nthreads (procinfo *pi)
 {
   int nthreads = 0;
 
   if (ioctl (pi->ctl_fd, PIOCNTHR, &nthreads) < 0)
     proc_warn (pi, "procfs: PIOCNTHR failed", __LINE__);
 
   return nthreads;
 }
 
 #else
 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
 /* Solaris and Unixware version */
-int
+static int
 proc_get_nthreads (procinfo *pi)
 {
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0;
 
   /* NEW_PROC_API: only works for the process procinfo, because the
      LWP procinfos do not get prstatus filled in.  */
 #ifdef NEW_PROC_API
   if (pi->tid != 0)     /* Find the parent process procinfo.  */
     pi = find_procinfo_or_die (pi->pid, 0);
 #endif
   return pi->prstatus.pr_nlwp;
 }
 
 #else
 /* Default version */
-int
+static int
 proc_get_nthreads (procinfo *pi)
 {
   return 0;
 }
 #endif
 #endif
 
 /* LWP version.
 
    Return the ID of the thread that had an event of interest.
    (ie. the one that hit a breakpoint or other traced event).  All
    other things being equal, this should be the ID of a thread that is
    currently executing.  */
 
 #if defined (SYS_lwpcreate) || defined (SYS_lwp_create) /* FIXME: multiple */
 /* Solaris and Unixware version */
-int
+static int
 proc_get_current_thread (procinfo *pi)
 {
   /* Note: this should be applied to the root procinfo for the
      process, not to the procinfo for an LWP.  If applied to the
      procinfo for an LWP, it will simply return that LWP's ID.  In
      that case, find the parent process procinfo.  */
 
   if (pi->tid != 0)
     pi = find_procinfo_or_die (pi->pid, 0);
 
   if (!pi->status_valid)
     if (!proc_get_status (pi))
       return 0;
 
 #ifdef NEW_PROC_API
   return pi->prstatus.pr_lwp.pr_lwpid;
 #else
   return pi->prstatus.pr_who;
 #endif
 }
 
 #else
 #if defined (PIOCNTHR) && defined (PIOCTLIST)
 /* OSF version */
-int
+static int
 proc_get_current_thread (procinfo *pi)
 {
 #if 0   /* FIXME: not ready for prime time?  */
   return pi->prstatus.pr_tid;
 #else
   return 0;
 #endif
 }
 
 #else
 /* Default version */
-int
+static int
 proc_get_current_thread (procinfo *pi)
 {
   return 0;
 }
 
 #endif
 #endif
 
 /* Discover the IDs of all the threads within the process, and create
    a procinfo for each of them (chained to the parent).  This
    unfortunately requires a different method on every OS.  Returns
    non-zero for success, zero for failure.  */
 
-int
+static int
 proc_delete_dead_threads (procinfo *parent, procinfo *thread, void *ignore)
 {
   if (thread && parent) /* sanity */
     {
       thread->status_valid = 0;
       if (!proc_get_status (thread))
         destroy_one_procinfo (&parent->thread_list, thread);
     }
   return 0;     /* keep iterating */
 }
 
 #if defined (PIOCLSTATUS)
 /* Solaris 2.5 (ioctl) version */
-int
+static int
 proc_update_threads (procinfo *pi)
 {
   gdb_prstatus_t *prstatus;
   struct cleanup *old_chain = NULL;
   procinfo *thread;
   int nlwp, i;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
@@ skipping 28 matching lines @@
 }
 #else
 #ifdef NEW_PROC_API
 /* Unixware and Solaris 6 (and later) version.  */
 static void
 do_closedir_cleanup (void *dir)
 {
   closedir (dir);
 }
 
-int
+static int
 proc_update_threads (procinfo *pi)
 {
   char pathname[MAX_PROC_NAME_SIZE + 16];
   struct dirent *direntry;
   struct cleanup *old_chain = NULL;
   procinfo *thread;
   DIR *dirp;
   int lwpid;
 
   /* We should never have to apply this operation to any procinfo
@@ skipping 27 matching lines @@
         if ((thread = create_procinfo (pi->pid, lwpid)) == NULL)
           proc_error (pi, "update_threads, create_procinfo", __LINE__);
       }
   pi->threads_valid = 1;
   do_cleanups (old_chain);
   return 1;
 }
 #else
 #ifdef PIOCTLIST
 /* OSF version */
-int
+static int
 proc_update_threads (procinfo *pi)
 {
   int nthreads, i;
   tid_t *threads;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
      with one that makes sure the ctl_fd is open.  */
 
@@ skipping 15 matching lines @@
     {
       if (!find_procinfo (pi->pid, threads[i]))
         if (!create_procinfo  (pi->pid, threads[i]))
           proc_error (pi, "update_threads, create_procinfo", __LINE__);
     }
   pi->threads_valid = 1;
   return 1;
 }
 #else
 /* Default version */
-int
+static int
 proc_update_threads (procinfo *pi)
 {
   return 0;
 }
 #endif  /* OSF PIOCTLIST */
 #endif  /* NEW_PROC_API   */
 #endif  /* SOL 2.5 PIOCLSTATUS */
 
 /* Given a pointer to a function, call that function once for each lwp
    in the procinfo list, until the function returns non-zero, in which
    event return the value returned by the function.
 
    Note: this function does NOT call update_threads.  If you want to
    discover new threads first, you must call that function explicitly.
    This function just makes a quick pass over the currently-known
    procinfos.
 
    PI is the parent process procinfo.  FUNC is the per-thread
    function.  PTR is an opaque parameter for function.  Returns the
    first non-zero return value from the callee, or zero.  */
 
-int
+static int
 proc_iterate_over_threads (procinfo *pi,
                            int (*func) (procinfo *, procinfo *, void *),
                            void *ptr)
 {
   procinfo *thread, *next;
   int retval = 0;
 
   /* We should never have to apply this operation to any procinfo
      except the one for the main process.  If that ever changes for
      any reason, then take out the following clause and replace it
@@ skipping 858 matching lines @@
                     if (status)
                       {
                         /* How to exit gracefully, returning "unknown
                            event".  */
                         status->kind = TARGET_WAITKIND_SPURIOUS;
                         return inferior_ptid;
                       }
                     else
                       {
                         /* How to keep going without returning to wfi: */
-                        target_resume (ptid, 0, TARGET_SIGNAL_0);
+                        target_resume (ptid, 0, GDB_SIGNAL_0);
                         goto wait_again;
                       }
                   }
                 break;
               case PR_SYSEXIT:
                 if (syscall_is_exec (pi, what))
                   {
                     /* Hopefully this is our own "fork-child" execing
                        the real child.  Hoax this event into a trap, and
                        GDB will see the child about to execute its start
                        address.  */
                     wstat = (SIGTRAP << 8) | 0177;
                   }
 #ifdef SYS_syssgi
                 else if (what == SYS_syssgi)
                   {
                     /* see if we can break on dbx_link().  If yes, then
                        we no longer need the SYS_syssgi notifications.  */
                     if (insert_dbx_link_breakpoint (pi))
                       proc_trace_syscalls_1 (pi, SYS_syssgi, PR_SYSEXIT,
                                              FLAG_RESET, 0);
 
                     /* 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, TARGET_SIGNAL_0);
+                    target_resume (ptid, 0, GDB_SIGNAL_0);
                     goto wait_again;
                   }
 #endif
                 else if (syscall_is_lwp_create (pi, what))
                   {
                     /* This syscall is somewhat like fork/exec.  We
                        will get the event twice: once for the parent
                        LWP, and once for the child.  We should already
                        know about the parent LWP, but the child will
                        be new to us.  So, whenever we get this event,
@@ skipping 349 matching lines @@
 
    If STEP is true, then arrange for the child to stop again after
    executing a single instruction.  If SIGNO is zero, then cancel any
    pending signal; if non-zero, then arrange for the indicated signal
    to be delivered to the child when it runs.  If PID is -1, then
    allow any child thread to run; if non-zero, then allow only the
    indicated thread to run.  (not implemented yet).  */
 
 static void
 procfs_resume (struct target_ops *ops,
-               ptid_t ptid, int step, enum target_signal signo)
+               ptid_t ptid, int step, enum gdb_signal signo)
 {
   procinfo *pi, *thread;
   int native_signo;
 
   /* 2.1:
      prrun.prflags |= PRSVADDR;
      prrun.pr_vaddr = $PC;         set resume address
      prrun.prflags |= PRSTRACE;    trace signals in pr_trace (all)
      prrun.prflags |= PRSFAULT;    trace faults in pr_fault (all but PAGE)
      prrun.prflags |= PRCFAULT;    clear current fault.
 
      PRSTRACE and PRSFAULT can be done by other means
         (proc_trace_signals, proc_trace_faults)
      PRSVADDR is unnecessary.
      PRCFAULT may be replaced by a PIOCCFAULT call (proc_clear_current_fault)
      This basically leaves PRSTEP and PRCSIG.
      PRCSIG is like PIOCSSIG (proc_clear_current_signal).
      So basically PR_STEP is the sole argument that must be passed
      to proc_run_process (for use in the prrun struct by ioctl).  */
 
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
 
   /* First cut: ignore pid argument.  */
   errno = 0;
 
   /* Convert signal to host numbering.  */
   if (signo == 0 ||
-      (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
+      (signo == GDB_SIGNAL_STOP && pi->ignore_next_sigstop))
     native_signo = 0;
   else
-    native_signo = target_signal_to_host (signo);
+    native_signo = gdb_signal_to_host (signo);
 
   pi->ignore_next_sigstop = 0;
 
   /* Running the process voids all cached registers and status.  */
   /* Void the threads' caches first.  */
   proc_iterate_over_threads (pi, invalidate_cache, NULL);
   /* Void the process procinfo's caches.  */
   invalidate_cache (NULL, pi, NULL);
 
   if (PIDGET (ptid) != -1)
@@ skipping 38 matching lines @@
 procfs_pass_signals (int numsigs, unsigned char *pass_signals)
 {
   gdb_sigset_t signals;
   procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
   int signo;
 
   prfillset (&signals);
 
   for (signo = 0; signo < NSIG; signo++)
     {
-      int target_signo = target_signal_from_host (signo);
+      int target_signo = gdb_signal_from_host (signo);
       if (target_signo < numsigs && pass_signals[target_signo])
         gdb_prdelset (&signals, signo);
     }
 
   if (!proc_set_traced_signals (pi, &signals))
     proc_error (pi, "pass_signals", __LINE__);
 }
 
 /* Print status information about the child process.  */
 
@@ skipping 463 matching lines @@
 
   if (!in_thread_list (gdb_threadid) || is_exited (gdb_threadid))
     add_thread (gdb_threadid);
 
   return 0;
 }
 
 /* Query all the threads that the target knows about, and give them
    back to GDB to add to its list.  */
 
-void
+static void
 procfs_find_new_threads (struct target_ops *ops)
 {
   procinfo *pi;
 
   /* Find procinfo for main process.  */
   pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
   proc_update_threads (pi);
   proc_iterate_over_threads (pi, procfs_notice_thread, NULL);
 }
 
@@ skipping 21 matching lines @@
       return 0;
     }
   /* I couldn't have got its status if it weren't alive, so it's
      alive.  */
   return 1;
 }
 
 /* Convert PTID to a string.  Returns the string in a static
    buffer.  */
 
-char *
+static char *
 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[80];
 
   if (TIDGET (ptid) == 0)
     sprintf (buf, "process %d", PIDGET (ptid));
   else
     sprintf (buf, "LWP %ld", TIDGET (ptid));
 
   return buf;
 }
 
 /* Insert a watchpoint.  */
 
-int
+static int
 procfs_set_watchpoint (ptid_t ptid, CORE_ADDR addr, int len, int rwflag,
                        int after)
 {
 #ifndef UNIXWARE
 #ifndef AIX5
   int       pflags = 0;
   procinfo *pi;
 
   pi = find_procinfo_or_die (PIDGET (ptid) == -1 ?
                              PIDGET (inferior_ptid) : PIDGET (ptid), 0);
@@ skipping 354 matching lines @@
                      "    Offset",
                      "Flags");
 
   iterate_over_mappings (pi, NULL, NULL, info_mappings_callback);
   printf_filtered ("\n");
 }
 
 /* Implement the "info proc" command.  */
 
 static void
-info_proc_cmd (char *args, int from_tty)
+procfs_info_proc (struct target_ops *ops, char *args,
+                  enum info_proc_what what)
 {
   struct cleanup *old_chain;
   procinfo *process  = NULL;
   procinfo *thread   = NULL;
   char    **argv     = NULL;
   char     *tmp      = NULL;
   int       pid      = 0;
   int       tid      = 0;
   int       mappings = 0;
 
+  switch (what)
+    {
+    case IP_MINIMAL:
+      break;
+
+    case IP_MAPPINGS:
+    case IP_ALL:
+      mappings = 1;
+      break;
+
+    default:
+      error (_("Not supported on this target."));
+    }
+
   old_chain = make_cleanup (null_cleanup, 0);
   if (args)
     {
       argv = gdb_buildargv (args);
       make_cleanup_freeargv (argv);
     }
   while (argv != NULL && *argv != NULL)
     {
       if (isdigit (argv[0][0]))
         {
           pid = strtoul (argv[0], &tmp, 10);
           if (*tmp == '/')
             tid = strtoul (++tmp, NULL, 10);
         }
       else if (argv[0][0] == '/')
         {
           tid = strtoul (argv[0] + 1, NULL, 10);
         }
-      else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
-        {
-          mappings = 1;
-        }
-      else
-        {
-          /* [...] */
-        }
       argv++;
     }
   if (pid == 0)
     pid = PIDGET (inferior_ptid);
   if (pid == 0)
     error (_("No current process: you must name one."));
   else
     {
       /* Have pid, will travel.
          First see if it's a process we're already debugging.  */
@@ skipping 115 matching lines @@
   proc_trace_syscalls (args, from_tty, PR_SYSENTRY, FLAG_RESET);
 }
 
 static void
 proc_untrace_sysexit_cmd (char *args, int from_tty)
 {
   proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
 }
 
 
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern void _initialize_procfs (void);
+
 void
 _initialize_procfs (void)
 {
   observer_attach_inferior_created (procfs_inferior_created);
 
-  add_info ("proc", info_proc_cmd, _("\
-Show /proc process information about any running process.\n\
-Specify process id, or use the program being debugged by default.\n\
-Specify keyword 'mappings' for detailed info on memory mappings."));
   add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
            _("Give a trace of entries into the syscall."));
   add_com ("proc-trace-exit", no_class, proc_trace_sysexit_cmd,
            _("Give a trace of exits from the syscall."));
   add_com ("proc-untrace-entry", no_class, proc_untrace_sysentry_cmd,
            _("Cancel a trace of entries into the syscall."));
   add_com ("proc-untrace-exit", no_class, proc_untrace_sysexit_cmd,
            _("Cancel a trace of exits from the syscall."));
 }
 
@@ skipping 15 matching lines @@
   return pid_to_ptid (procinfo_list ? procinfo_list->pid : -1);
 }
 
 /* ===================  GCORE .NOTE "MODULE" =================== */
 #if defined (UNIXWARE) || defined (PIOCOPENLWP) || defined (PCAGENT)
 /* gcore only implemented on solaris and unixware (so far) */
 
 static char *
 procfs_do_thread_registers (bfd *obfd, ptid_t ptid,
                             char *note_data, int *note_size,
-                            enum target_signal stop_signal)
+                            enum gdb_signal stop_signal)
 {
   struct regcache *regcache = get_thread_regcache (ptid);
   gdb_gregset_t gregs;
   gdb_fpregset_t fpregs;
   unsigned long merged_pid;
   struct cleanup *old_chain;
 
   merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid);
 
   /* This part is the old method for fetching registers.
@@ skipping 30 matching lines @@
 
   do_cleanups (old_chain);
 
   return note_data;
 }
 
 struct procfs_corefile_thread_data {
   bfd *obfd;
   char *note_data;
   int *note_size;
-  enum target_signal stop_signal;
+  enum gdb_signal stop_signal;
 };
 
 static int
 procfs_corefile_thread_callback (procinfo *pi, procinfo *thread, void *data)
 {
   struct procfs_corefile_thread_data *args = data;
 
   if (pi != NULL)
     {
       ptid_t ptid = MERGEPID (pi->pid, thread->tid);
 
       args->note_data = procfs_do_thread_registers (args->obfd, ptid,
                                                     args->note_data,
                                                     args->note_size,
                                                     args->stop_signal);
     }
   return 0;
 }
 
 static int
 find_signalled_thread (struct thread_info *info, void *data)
 {
-  if (info->suspend.stop_signal != TARGET_SIGNAL_0
+  if (info->suspend.stop_signal != GDB_SIGNAL_0
       && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
     return 1;
 
   return 0;
 }
 
-static enum target_signal
+static enum gdb_signal
 find_stop_signal (void)
 {
   struct thread_info *info =
     iterate_over_threads (find_signalled_thread, NULL);
 
   if (info)
     return info->suspend.stop_signal;
   else
-    return TARGET_SIGNAL_0;
+    return GDB_SIGNAL_0;
 }
 
 static char *
 procfs_make_note_section (bfd *obfd, int *note_size)
 {
   struct cleanup *old_chain;
   gdb_gregset_t gregs;
   gdb_fpregset_t fpregs;
   char fname[16] = {'\0'};
   char psargs[80] = {'\0'};
   procinfo *pi = find_procinfo_or_die (PIDGET (inferior_ptid), 0);
   char *note_data = NULL;
   char *inf_args;
   struct procfs_corefile_thread_data thread_args;
   gdb_byte *auxv;
   int auxv_len;
-  enum target_signal stop_signal;
+  enum gdb_signal stop_signal;
 
   if (get_exec_file (0))
     {
       strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
-      strncpy (psargs, get_exec_file (0),
-               sizeof (psargs));
+      fname[sizeof (fname) - 1] = 0;
+      strncpy (psargs, get_exec_file (0), sizeof (psargs));
+      psargs[sizeof (psargs) - 1] = 0;
 
       inf_args = get_inferior_args ();
       if (inf_args && *inf_args &&
           strlen (inf_args) < ((int) sizeof (psargs) - (int) strlen (psargs)))
         {
           strncat (psargs, " ",
                    sizeof (psargs) - strlen (psargs));
           strncat (psargs, inf_args,
                    sizeof (psargs) - strlen (psargs));
         }
@@ skipping 39 matching lines @@
 }
 #else /* !(Solaris or Unixware) */
 static char *
 procfs_make_note_section (bfd *obfd, int *note_size)
 {
   error (_("gcore not implemented for this host."));
   return NULL;  /* lint */
 }
 #endif /* Solaris or Unixware */
 /* ===================  END GCORE .NOTE "MODULE" =================== */