import gdb-2000-01-24 snapshot

14 files changed, 3311 insertions, 50 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index dd46c82..2d45b2a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,63 @@
+2000-01-24  Kevin Buettner  <kevinb@redhat.com>
+
+	* utils.c (get_field, put_field): Fix buffer underruns and
+	overruns.  Also, handle case where total_len is not evenly
+	divisible by 8.
+	(getfield): Make sure zeroing of unwanted bits occurs even
+	when bit field to extract does not straddle two or more
+	bytes.
+
+2000-01-23   Christopher Faylor  <cgf@cygnus.com>
+
+	* defs.h: Add gdb_thread_select declaration.
+
+2000-01-23  Kevin Buettner  <kevinb@redhat.com>
+
+	* linux-thread.c (_initialize_linuxthreads): Make sure that
+	linuxthreads_block_mask does not block SIGCHLD.
+
+2000-01-20  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* rdi-share/devsw.c (openLogFile): On cygwin, set the log mode to
+	text so that new lines work properly.
+
+2000-01-18  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* proc-utils.h: New file. Export functions from proc-*.c.
+
+	* proc_api.c: Rename to:
+	* proc-api.c: New file. Add include of proc-utils.h.
+
+	* proc_events.c: Rename to:
+	* proc-events.c: New file.
+
+	* proc_flags.c: Rename to:
+	* proc-flags.c: New file.
+
+	* proc_why.c: Rename to:
+	* proc-why.c: New file. Add include of proc-utils.h.
+
+	* procfs.c: Add includes of gdbthread.h, sys/wait.h, signal.h,
+ 	ctype.h, proc-utils.h.
+	(find_procinfo_or_die): Add braces to avoid ambiguous else clause.
+	(open_procinfo_files): Conditionalize local variable tmp, to avoid
+ 	compiler warnings.
+	(proc_iterate_over_mappings): Conditionalize local vars mapfd and
+ 	pathname.
+	(procfs_wait): Adjust format in some printf_filetered calls to
+ 	avoid compiler warnings.
+	(make_signal_thread_runnable): Ifdef 0. The calls to this function
+ 	are also ifdef'd 0 .
+	(procfs_resume): Add parentheses around '&&' operation.
+	(procfs_set_exec_trap): Remove unused variable.
+	(info_proc_cmd): Add braces to avoid ambiguous else clause.
+
+	* Makefile.in (procfs.o, proc-api.o, proc-events.o, proc-flags.o,
+ 	proc-why.o): Update dependencies.
+
+	* config/sparc/sun4sol2.mh (NATDEPFILES): Change proc_*.o files to
+	proc-*.o.
+
 2000-01-17  Jason Molenda  (jsm@bugshack.cygnus.com)
 
 	* configure.in (NEW_PROC_API): Fix Unixware-matching regexp.
@@ -32,6 +92,11 @@ Sun Jan 16 17:58:00 2000  David Taylor  <taylor@texas.cygnus.com>
 	* v850-tdep.c (v850_target_architecture_hook): Setup correct
  	machine id for disassembly.
 
+2000-01-13  Jim Blandy  <jimb@cygnus.com>
+
+	* i386-linux-nat.c (fill_gregset): Pass the correct arguments to
+	convert_to_regset, when regno indicates a specific register.
+
 Thu Jan 13 23:34:17 EST 2000  Nicholas Duffek <nsd@cygnus.com>
 
 	* uw-thread.c: Document libthread.so debugging interface.  Minor
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 8ce6044..68292d5 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -229,7 +229,7 @@ CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE) \
 ADD_FILES = $(REGEX) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 ADD_DEPS = $(REGEX1) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 
-VERSION = 20000117
+VERSION = 20000124
 DIST=gdb
 
 LINT=/usr/5bin/lint
@@ -1412,16 +1412,16 @@ printcmd.o: printcmd.c $(breakpoint_h) $(defs_h) $(expression_h) \
 # FIXME: Procfs.o gets -Wformat errors because things like pid_t don't
 # match output format strings.
 procfs.o: procfs.c $(command_h) $(defs_h) $(gdbcore_h) $(inferior_h) \
-	target.h gdb_string.h
+	target.h gdb_string.h gdbthread.h proc-utils.h
 	$(CC) -c $(INTERNAL_WARN_CFLAGS) $(NO_WERROR_CFLAGS) $<
 
-proc_api.o: proc_api.c $(defs_h) $(gdbcmd_h)
+proc-api.o: proc-api.c $(defs_h) $(gdbcmd_h) proc-utils.h
 
-proc_events.o: proc_events.c $(defs_h)
+proc-events.o: proc-events.c $(defs_h)
 
-proc_flags.o: proc_flags.c $(defs_h)
+proc-flags.o: proc-flags.c $(defs_h)
 
-proc_why.o: proc_why.c $(defs_h)
+proc-why.o: proc-why.c $(defs_h) proc-utils.h
 
 sol-thread.o: sol-thread.c $(defs_h) gdbthread.h target.h $(inferior_h) \
 	$(gdbcmd_h)
diff --git a/gdb/config/sparc/sun4sol2.mh b/gdb/config/sparc/sun4sol2.mh
index 1659c7a..b9ab28e 100644
--- a/gdb/config/sparc/sun4sol2.mh
+++ b/gdb/config/sparc/sun4sol2.mh
@@ -6,7 +6,7 @@ XM_CLIBS= -lsocket -lnsl
 
 NAT_FILE= nm-sun4sol2.h
 NATDEPFILES= corelow.o core-sol2.o solib.o fork-child.o procfs.o \
-	proc_api.o proc_events.o proc_flags.o proc_why.o
+	proc-api.o proc-events.o proc-flags.o proc-why.o
 
 # If you are compiling with Sun's compiler, add the -xs option to CC
 # (e.g. `make CC="cc -xs"').
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index 6eac3a4..95dee85 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -65,6 +65,7 @@ d30v-*-*)		gdb_target=d30v ;;
 h8300-*-*)		gdb_target=h8300 ;;
 h8500-*-*)		gdb_target=h8500 ;;
 
+
 fr30-*-elf*)		gdb_target=fr30 ;;
 
 
diff --git a/gdb/defs.h b/gdb/defs.h
index 3ae2b2d..ef4049d 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -1345,5 +1345,6 @@ enum gdb_rc gdb_breakpoint_query (/* struct {ui,gdb}_out *output, */ int bnum);
 enum gdb_rc gdb_breakpoint (char *address, char *condition,
 			    int hardwareflag, int tempflag,
 			    int thread, int ignore_count);
+enum gdb_rc gdb_thread_select (/* output object */ char *tidstr);
 
 #endif /* #ifndef DEFS_H */
diff --git a/gdb/linux-thread.c b/gdb/linux-thread.c
index df982a6..3e72ab4 100644
--- a/gdb/linux-thread.c
+++ b/gdb/linux-thread.c
@@ -1800,4 +1800,6 @@ _initialize_linuxthreads ()
   sigprocmask(SIG_BLOCK, 
 	      &linuxthreads_wait_mask, 
 	      &linuxthreads_block_mask);
+  /* Make sure that linuxthreads_block_mask is not blocking SIGCHLD */
+  sigdelset (&linuxthreads_block_mask, SIGCHLD);
 }
diff --git a/gdb/proc-api.c b/gdb/proc-api.c
new file mode 100644
index 0000000..a3629d7
--- /dev/null
+++ b/gdb/proc-api.c
@@ -0,0 +1,808 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   Copyright 1999 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
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, 
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/*
+ * Pretty-print trace of api calls to the /proc api
+ * (ioctl or read/write calls).
+ * 
+ */
+
+#include "defs.h"
+#include "gdbcmd.h"
+
+#if defined (NEW_PROC_API)
+#define _STRUCTURED_PROC 1
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/procfs.h>
+#include <sys/proc.h>	/* for struct proc */
+#include <sys/user.h>	/* for struct user */
+#include <fcntl.h>	/* for O_RDWR etc. */
+#include <sys/wait.h>
+
+#include "proc-utils.h"
+
+/*  Much of the information used in the /proc interface, particularly for
+    printing status information, is kept as tables of structures of the
+    following form.  These tables can be used to map numeric values to
+    their symbolic names and to a string that describes their specific use. */
+
+struct trans {
+  long value;                   /* The numeric value */
+  char *name;                   /* The equivalent symbolic value */
+  char *desc;                   /* Short description of value */
+};
+
+static int   procfs_trace    = 1;
+/*static int   info_verbose    = 1;*/	/* kludge */
+static FILE *procfs_file     = NULL;
+static char *procfs_filename = "procfs_trace";
+
+static void
+set_procfs_trace_cmd (args, from_tty, c)
+     char *args;
+     int from_tty;
+     struct cmd_list_element *c;
+{
+#if 0	/* not sure what I might actually need to do here, if anything */
+  if (procfs_file)
+    fflush (procfs_file);
+#endif
+}
+
+static void
+set_procfs_file_cmd (args, from_tty, c)
+     char *args;
+     int from_tty;
+     struct cmd_list_element *c;
+{
+  /* Just changed the filename for procfs tracing.
+     If a file was already open, close it.  */
+  if (procfs_file)
+    fclose (procfs_file);
+  procfs_file = NULL;
+}
+
+
+#ifndef NEW_PROC_API
+
+static struct trans ioctl_table[] = {
+#ifdef PIOCACINFO			/* irix */
+  { PIOCACINFO,    "PIOCACINFO",   "get process account info" },
+#endif
+  { PIOCACTION,    "PIOCACTION",   "get signal action structs" },
+#ifdef PIOCARGUMENTS			/* osf */
+  { PIOCARGUMENTS, "PIOCARGUMENTS", "command line args" },
+#endif
+#ifdef PIOCAUXV				/* solaris aux vectors */
+  { PIOCAUXV,      "PIOCAUXV",     "get aux vector" },
+  { PIOCNAUXV,     "PIOCNAUXV",    "get number of aux vector entries" },
+#endif /* AUXV */
+  { PIOCCFAULT,    "PIOCCFAULT",   "clear current fault" },
+  { PIOCCRED,      "PIOCCRED",     "get process credentials" },
+#ifdef PIOCENEVCTRS			/* irix event counters */
+  { PIOCENEVCTRS,    "PIOCENEVCTRS",    "acquire and start event counters" },
+  { PIOCGETEVCTRL,   "PIOCGETEVCTRL",   "get control info of event counters" },
+  { PIOCGETEVCTRS,   "PIOCGETEVCTRS",   "dump event counters" },
+  { PIOCGETPREVCTRS, "PIOCGETPREVCTRS", "dump event counters & prusage info" },
+  { PIOCRELEVCTRS,   "PIOCRELEVCTRS",   "release/stop event counters" },
+  { PIOCSETEVCTRL,   "PIOCSETEVCTRL",   "set control info of event counters" },
+  { PIOCGETPTIMER,   "PIOCGETPTIMER",   "get process timers" },
+#endif	/* irix event counters */
+  { PIOCGENTRY,    "PIOCGENTRY",   "get traced syscall entry set" },
+  { PIOCGETPR,     "PIOCGETPR",    "read struct proc" },
+  { PIOCGETU,      "PIOCGETU",     "read user area" },
+#if defined (PIOCGETUTK) && (defined(KERNEL) || defined(SHOW_UTT)) /* osf */
+  { PIOCGETUTK,  "PIOCGETUTK", "get the utask struct" },
+#endif
+  { PIOCGEXIT,     "PIOCGEXIT",    "get traced syscall exit  set" },
+  { PIOCGFAULT,    "PIOCGFAULT",   "get traced fault set" },
+#ifdef PIOCGFPCR			/* osf */
+  { PIOCGFPCR,     "PIOCGFPCR",    "get FP control register" },
+  { PIOCSFPCR,     "PIOCSFPCR",    "set FP conrtol register" },
+#endif
+  { PIOCGFPREG,    "PIOCGFPREG",   "get floating point registers" },
+  { PIOCGHOLD,     "PIOCGHOLD",    "get held signal set" },
+  { PIOCGREG,      "PIOCGREG",     "get general registers" },
+  { PIOCGROUPS,    "PIOCGROUPS",   "get supplementary groups" },
+#ifdef PIOCGSPCACT			/* osf */
+  { PIOCGSPCACT,   "PIOCGSPCACT",  "get special action" },
+  { PIOCSSPCACT,   "PIOCSSPCACT",  "set special action" },
+#endif
+  { PIOCGTRACE,    "PIOCGTRACE",   "get traced signal set" },
+#ifdef PIOCGWATCH			/* irix watchpoints */
+  { PIOCGWATCH,    "PIOCGWATCH",   "get watchpoint" },
+  { PIOCSWATCH,    "PIOCSWATCH",   "set watchpoint" },
+  { PIOCNWATCH,    "PIOCNWATCH",   "get number of watchpoints" },
+#endif	/* irix watchpoints */
+#ifdef PIOCGWIN				/* solaris sparc */
+  { PIOCGWIN,      "PIOCGWIN",     "get gwindows_t" },
+#endif
+#ifdef PIOCGXREG			/* solaris sparc extra regs */
+  { PIOCGXREGSIZE, "PIOCXREGSIZE", "get extra register state size" },
+  { PIOCGXREG,     "PIOCGXREG",    "get extra register state" },
+  { PIOCSXREG,     "PIOCSXREG",    "set extra register state" },
+#endif /* XREG */
+  { PIOCKILL,      "PIOCKILL",     "send signal" },
+#ifdef PIOCLDT				/* solaris i386 */
+  { PIOCLDT,       "PIOCLDT",      "get LDT" },
+  { PIOCNLDT,      "PIOCNLDT",     "get number of LDT entries" },
+#endif
+#ifdef PIOCLSTATUS			/* solaris and unixware */
+  { PIOCLSTATUS,   "PIOCLSTATUS",  "get status of all lwps" },
+  { PIOCLUSAGE,    "PIOCLUSAGE",   "get resource usage of all lwps" },
+  { PIOCOPENLWP,   "PIOCOPENLWP",  "get lwp file descriptor" },
+  { PIOCLWPIDS,    "PIOCLWPIDS",   "get lwp identifiers" },
+#endif /* LWP */
+  { PIOCMAP,       "PIOCMAP",      "get memory map information" },
+  { PIOCMAXSIG,    "PIOCMAXSIG",   "get max signal number" },
+  { PIOCNICE,      "PIOCNICE",     "set nice priority" },
+  { PIOCNMAP,      "PIOCNMAP",     "get number of memory mappings" },
+  { PIOCOPENM,     "PIOCOPENM",    "open mapped object for reading" },
+#ifdef PIOCOPENMOBS			/* osf */
+  { PIOCOPENMOBS,  "PIOCOPENMOBS", "open mapped object" },
+#endif
+#ifdef PIOCOPENPD	/* solaris */
+  { PIOCOPENPD,    "PIOCOPENPD",   "get page data file descriptor" },
+#endif
+  { PIOCPSINFO,    "PIOCPSINFO",   "get ps(1) information" },
+  { PIOCRESET,     "PIOCRESET",    "reset process flags" },
+  { PIOCRFORK,     "PIOCRFORK",    "reset inherit-on-fork flag" },
+  { PIOCRRLC,      "PIOCRRLC",     "reset run-on-last-close flag" },
+  { PIOCRUN,       "PIOCRUN",      "make process runnable" },
+#ifdef PIOCSAVECCNTRS			/* irix */
+  { PIOCSAVECCNTRS, "PIOCSAVECCNTRS", "parent gets child cntrs" },
+#endif
+  { PIOCSENTRY,    "PIOCSENTRY",   "set traced syscall entry set" },
+  { PIOCSET,       "PIOCSET",      "set process flags" },
+  { PIOCSEXIT,     "PIOCSEXIT",    "set traced syscall exit  set" },
+  { PIOCSFAULT,    "PIOCSFAULT",   "set traced fault set" },
+  { PIOCSFORK,     "PIOCSFORK",    "set inherit-on-fork flag" },
+  { PIOCSFPREG,    "PIOCSFPREG",   "set floating point registers" },
+  { PIOCSHOLD,     "PIOCSHOLD",    "set held signal set" },
+  { PIOCSREG,      "PIOCSREG",     "set general registers" },
+  { PIOCSRLC,      "PIOCSRLC",     "set run-on-last-close flag" },
+  { PIOCSSIG,      "PIOCSSIG",     "set current signal" },
+  { PIOCSTATUS,    "PIOCSTATUS",   "get process status" },
+  { PIOCSTOP,      "PIOCSTOP",     "post stop request" },
+  { PIOCSTRACE,    "PIOCSTRACE",   "set traced signal set" },
+  { PIOCUNKILL,    "PIOCUNKILL",   "delete a signal" },
+#ifdef PIOCUSAGE	/* solaris */
+  { PIOCUSAGE,     "PIOCUSAGE",    "get resource usage" },
+#endif
+  { PIOCWSTOP,     "PIOCWSTOP",    "wait for process to stop" },
+
+#ifdef PIOCNTHR				/* osf threads */
+  { PIOCNTHR,      "PIOCNTHR",     "get thread count" },
+  { PIOCRTINH,     "PIOCRTINH",    "reset inherit-on-thread-creation" },
+  { PIOCSTINH,     "PIOCSTINH",    "set   inherit-on-thread-creation" },
+  { PIOCTLIST,     "PIOCTLIST",    "get thread ids" },
+  { PIOCXPTH,      "PIOCXPTH",     "translate port to thread handle" },
+  { PIOCTRUN,      "PIOCTRUN",     "make thread runnable" },
+  { PIOCTSTATUS,   "PIOCTSTATUS",  "get thread status" },
+  { PIOCTSTOP,     "PIOCTSTOP",    "stop a thread" },
+  /* ... TGTRACE TSTRACE TSSIG TKILL TUNKILL TCFAULT TGFAULT TSFAULT
+     TGFPREG TSFPREG TGREG TSREG TACTION TTERM TABRUN TGENTRY TSENTRY
+     TGEXIT TSEXIT TSHOLD ... thread functions */
+#endif /* osf threads */
+  { -1,            NULL,           NULL }
+};
+
+int
+ioctl_with_trace (fd, opcode, ptr, file, line)
+     int  fd;
+     long opcode;
+     void *ptr;
+     char *file;
+     int  line;
+{
+  int i, ret, arg1;
+
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      for (i = 0; ioctl_table[i].name != NULL; i++)
+	if (ioctl_table[i].value == opcode)
+	  break;
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      switch (opcode) {
+      case PIOCSET:
+	arg1 = ptr ? *(long *) ptr : 0;
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCSET,   %s) %s\n", 
+		 arg1 == PR_FORK  ? "PR_FORK"  :
+		 arg1 == PR_RLC   ? "PR_RLC"   :
+#ifdef PR_ASYNC
+		 arg1 == PR_ASYNC ? "PR_ASYNC" :
+#endif
+		 "<unknown flag>",
+		 info_verbose ? ioctl_table[i].desc : "");
+	break;
+      case PIOCRESET:
+	arg1 = ptr ? *(long *) ptr : 0;
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCRESET, %s) %s\n", 
+		 arg1 == PR_FORK  ? "PR_FORK"  :
+		 arg1 == PR_RLC   ? "PR_RLC"   :
+#ifdef PR_ASYNC
+		 arg1 == PR_ASYNC ? "PR_ASYNC" :
+#endif
+		 "<unknown flag>",
+		 info_verbose ? ioctl_table[i].desc : "");
+	break;
+      case PIOCSTRACE:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCSTRACE) ");
+	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
+				     (sigset_t *) ptr, 0);
+	break;
+      case PIOCSFAULT:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (%s) ", 
+		 opcode == PIOCSFAULT ? "PIOCSFAULT" : "PIOCGFAULT");
+	proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
+				    (fltset_t *) ptr, 0);
+	break;
+      case PIOCSENTRY:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (%s) ", 
+		 opcode == PIOCSENTRY ? "PIOCSENTRY" : "PIOCGENTRY");
+	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
+				    (sysset_t *) ptr, 0);
+	break;
+      case PIOCSEXIT:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (%s) ", 
+		 opcode == PIOCSEXIT ? "PIOCSEXIT" : "PIOCGEXIT");
+	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
+				    (sysset_t *) ptr, 0);
+	break;
+      case PIOCSHOLD:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (%s) ", 
+		 opcode == PIOCSHOLD ? "PIOCSHOLD" : "PIOCGHOLD");
+	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
+				     (sigset_t *) ptr, 0);
+	break;
+      case PIOCSSIG:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCSSIG) ");
+	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
+				  ptr ? ((siginfo_t *) ptr)->si_signo : 0, 
+				  0);
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+      case PIOCRUN:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCRUN) ");
+	
+	arg1 = ptr ? *(long *) ptr : 0;
+	if (arg1 & PRCSIG)
+	  fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
+	if (arg1 & PRCFAULT)
+	  fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
+	if (arg1 & PRSTRACE)
+	  fprintf (procfs_file ? procfs_file : stdout, "setTrace ");
+	if (arg1 & PRSHOLD)
+	  fprintf (procfs_file ? procfs_file : stdout, "setHold ");
+	if (arg1 & PRSFAULT)
+	  fprintf (procfs_file ? procfs_file : stdout, "setFlt ");
+	if (arg1 & PRSVADDR)
+	  fprintf (procfs_file ? procfs_file : stdout, "setVaddr ");
+	if (arg1 & PRSTEP)
+	  fprintf (procfs_file ? procfs_file : stdout, "step ");
+	if (arg1 & PRSABORT)
+	  fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
+	if (arg1 & PRSTOP)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
+	  
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+      case PIOCKILL:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCKILL) ");
+	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
+				  ptr ? *(long *) ptr : 0, 0);
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+#ifdef PIOCSSPCACT
+      case PIOCSSPCACT:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "ioctl (PIOCSSPCACT) ");
+	arg1 = ptr ? *(long *) ptr : 0;
+	if (arg1 & PRFS_STOPFORK)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopFork ");
+	if (arg1 & PRFS_STOPEXEC)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopExec ");
+	if (arg1 & PRFS_STOPTERM)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopTerm ");
+	if (arg1 & PRFS_STOPTCR)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopThreadCreate ");
+	if (arg1 & PRFS_STOPTTERM)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopThreadTerm ");
+	if (arg1 & PRFS_KOLC)
+	  fprintf (procfs_file ? procfs_file : stdout, "killOnLastClose ");
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+#endif /* PIOCSSPCACT */
+      default:
+	if (ioctl_table[i].name)
+	  fprintf (procfs_file ? procfs_file : stdout, 
+		   "ioctl (%s) %s\n", 
+		   ioctl_table[i].name,
+		   info_verbose ? ioctl_table[i].desc : "");
+	else
+	  fprintf (procfs_file ? procfs_file : stdout, 
+		   "ioctl (<unknown %ld (0x%lx)) \n", opcode, opcode);
+	break;
+      }
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+  ret = ioctl (fd, opcode, ptr);
+  if (procfs_trace && ret < 0)
+    {
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "[ioctl (%s) FAILED!]\n",
+	       ioctl_table[i].name != NULL ? 
+	       ioctl_table[i].name : "<unknown>");
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+
+  return ret;
+}
+
+#else	/* NEW_PROC_API */
+
+static struct trans rw_table[] = {
+#ifdef PCAGENT			/* solaris */
+  { PCAGENT,  "PCAGENT",  "create agent lwp with regs from argument" },
+#endif
+  { PCCFAULT, "PCCFAULT", "clear current fault" },
+#ifdef PCCSIG			/* solaris */
+  { PCCSIG,   "PCCSIG",   "clear current signal" },
+#endif
+  { PCDSTOP,  "PCDSTOP",  "post stop request" },
+  { PCKILL,   "PCKILL",   "post a signal" },
+  { PCNICE,   "PCNICE",   "set nice priority" },
+#ifdef PCREAD			/* solaris */
+  { PCREAD,   "PCREAD",   "read from the address space" },
+  { PCWRITE,  "PCWRITE",  "write to the address space" },
+#endif
+#ifdef PCRESET			/* unixware */
+  { PCRESET,  "PCRESET",  "unset modes" },
+#endif
+  { PCRUN,    "PCRUN",    "make process/lwp runnable" },
+#ifdef PCSASRS			/* solaris 2.7 only */
+  { PCSASRS,  "PCSASRS",  "set ancillary state registers" },
+#endif
+#ifdef PCSCRED			/* solaris */
+  { PCSCRED,  "PCSCRED",  "set process credentials" },
+#endif
+  { PCSENTRY, "PCSENTRY", "set traced syscall entry set" },
+  { PCSET,    "PCSET",    "set modes" },
+  { PCSEXIT,  "PCSEXIT",  "set traced syscall exit  set" },
+  { PCSFAULT, "PCSFAULT", "set traced fault set" },
+  { PCSFPREG, "PCSFPREG", "set floating point registers" },
+  { PCSHOLD,  "PCSHOLD",  "set signal mask" },
+  { PCSREG,   "PCSREG",   "set general registers" },
+  { PCSSIG,   "PCSSIG",   "set current signal" },
+  { PCSTOP,   "PCSTOP",   "post stop request and wait" },
+  { PCSTRACE, "PCSTRACE", "set traced signal set" },
+#ifdef PCSVADDR			/* solaris */
+  { PCSVADDR, "PCSVADDR", "set pc virtual address" },
+#endif
+#ifdef PCSXREG			/* solaris sparc only */
+  { PCSXREG,  "PCSXREG",  "set extra registers" },
+#endif
+#ifdef PCTWSTOP			/* solaris */
+  { PCTWSTOP, "PCTWSTOP", "wait for stop, with timeout arg" },
+#endif
+  { PCUNKILL, "PCUNKILL", "delete a pending signal" },
+#ifdef PCUNSET			/* solaris */
+  { PCUNSET,  "PCUNSET",  "unset modes" },
+#endif
+#ifdef PCWATCH			/* solaris */
+  { PCWATCH,  "PCWATCH",  "set/unset watched memory area" },
+#endif
+  { PCWSTOP,  "PCWSTOP",  "wait for process/lwp to stop, no timeout" },
+  { 0,        NULL,      NULL }
+};
+
+static off_t lseek_offset;
+
+int
+write_with_trace (fd, arg, len, file, line)
+     int  fd;
+     long *arg;
+     size_t len;
+     char *file;
+     int  line;
+{
+  int  i;
+  long opcode = arg[0];
+  int ret;
+
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      for (i = 0; rw_table[i].name != NULL; i++)
+	if (rw_table[i].value == opcode)
+	  break;
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      switch (opcode) {
+      case PCSET:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSET,   %s) %s\n", 
+		 arg[1] == PR_FORK  ? "PR_FORK"  :
+		 arg[1] == PR_RLC   ? "PR_RLC"   :
+#ifdef PR_ASYNC
+		 arg[1] == PR_ASYNC ? "PR_ASYNC" :
+#endif
+		 "<unknown flag>",
+		 info_verbose ? rw_table[i].desc : "");
+	break;
+#ifdef PCUNSET
+      case PCUNSET:
+#endif
+#ifdef PCRESET
+      case PCRESET:
+#endif
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCRESET, %s) %s\n", 
+		 arg[1] == PR_FORK  ? "PR_FORK"  :
+		 arg[1] == PR_RLC   ? "PR_RLC"   :
+#ifdef PR_ASYNC
+		 arg[1] == PR_ASYNC ? "PR_ASYNC" :
+#endif
+		 "<unknown flag>",
+		 info_verbose ? rw_table[i].desc : "");
+	break;
+      case PCSTRACE:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSTRACE) ");
+	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
+				     (sigset_t *) &arg[1], 0);
+	break;
+      case PCSFAULT:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSFAULT) ");
+	proc_prettyfprint_faultset (procfs_file ? procfs_file : stdout,
+				    (fltset_t *) &arg[1], 0);
+	break;
+      case PCSENTRY:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSENTRY) ");
+	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
+				    (sysset_t *) &arg[1], 0);
+	break;
+      case PCSEXIT:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSEXIT) ");
+	proc_prettyfprint_syscalls (procfs_file ? procfs_file : stdout,
+				    (sysset_t *) &arg[1], 0);
+	break;
+      case PCSHOLD:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSHOLD) ");
+	proc_prettyfprint_signalset (procfs_file ? procfs_file : stdout,
+				     (sigset_t *) &arg[1], 0);
+	break;
+      case PCSSIG:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCSSIG) ");
+	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
+				  arg[1] ? ((siginfo_t *) &arg[1])->si_signo 
+				         : 0, 
+				  0);
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+      case PCRUN:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCRUN) ");
+	if (arg[1] & PRCSIG)
+	  fprintf (procfs_file ? procfs_file : stdout, "clearSig ");
+	if (arg[1] & PRCFAULT)
+	  fprintf (procfs_file ? procfs_file : stdout, "clearFlt ");
+	if (arg[1] & PRSTEP)
+	  fprintf (procfs_file ? procfs_file : stdout, "step ");
+	if (arg[1] & PRSABORT)
+	  fprintf (procfs_file ? procfs_file : stdout, "syscallAbort ");
+	if (arg[1] & PRSTOP)
+	  fprintf (procfs_file ? procfs_file : stdout, "stopReq ");
+	  
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+      case PCKILL:
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "write (PCKILL) ");
+	proc_prettyfprint_signal (procfs_file ? procfs_file : stdout,
+				  arg[1], 0);
+	fprintf (procfs_file ? procfs_file : stdout, "\n");
+	break;
+      default:
+	{
+	  static unsigned char break_insn[] = BREAKPOINT;
+
+	  if (len == sizeof (break_insn) &&
+	      memcmp (arg, &break_insn, len) == 0)
+	    fprintf (procfs_file ? procfs_file : stdout, 
+		     "write (<breakpoint at 0x%08x>) \n", lseek_offset);
+	  else if (rw_table[i].name)
+	    fprintf (procfs_file ? procfs_file : stdout, 
+		     "write (%s) %s\n", 
+		     rw_table[i].name, 
+		     info_verbose ? rw_table[i].desc : "");
+	  else
+	    {
+	      if (lseek_offset != -1)
+		fprintf (procfs_file ? procfs_file : stdout, 
+			 "write (<unknown>, %d bytes at 0x%08x) \n", 
+			 len, lseek_offset);
+	      else
+		fprintf (procfs_file ? procfs_file : stdout, 
+			 "write (<unknown>, %d bytes) \n", len);
+	    }
+	  break;
+	}
+      }
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+  ret = write (fd, arg, len);
+  if (procfs_trace && ret != len)
+    {
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "[write (%s) FAILED!\n",
+	       rw_table[i].name != NULL ? 
+	       rw_table[i].name : "<unknown>");
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+
+  lseek_offset = -1;
+  return ret;
+}
+
+off_t
+lseek_with_trace (fd, offset, whence, file, line)
+     int fd;
+     off_t offset;
+     int whence;
+     char *file;
+     int line;
+{
+  off_t ret;
+
+#if 0	/* don't need output, just need address */
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "lseek (0x%08x, %s) \n", offset, 
+	       whence == SEEK_SET ? "SEEK_SET" :
+	       whence == SEEK_CUR ? "SEEK_CUR" : 
+	       whence == SEEK_END ? "SEEK_END" :
+	       "<unknown whence>");
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+#endif
+  ret = lseek (fd, offset, whence);
+  lseek_offset = ret;
+  if (procfs_trace && ret == -1)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "[lseek (0x%08x) FAILED!\n", offset);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+
+  return ret;
+}
+
+#endif /* NEW_PROC_API */
+
+int
+open_with_trace (filename, mode, file, line)
+     char *filename;
+     int   mode;
+     char *file;
+     int   line;
+{
+  int ret = open (filename, mode);
+
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "%d = open (%s, ", ret, filename);
+      if (mode == O_RDONLY)
+	fprintf (procfs_file ? procfs_file : stdout, "O_RDONLY) %d\n", line);
+      else if (mode == O_WRONLY)
+	fprintf (procfs_file ? procfs_file : stdout, "O_WRONLY) %d\n", line);
+      else if (mode == O_RDWR)
+	fprintf (procfs_file ? procfs_file : stdout, "O_RDWR)   %d\n", line);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+
+  return ret;
+}
+
+int
+close_with_trace (fd, file, line)
+     int   fd;
+     char *file;
+     int   line;
+{
+  int ret = close (fd);
+
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "%d = close (%d)\n", ret, fd);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+
+  return ret;
+}
+
+int
+wait_with_trace (wstat, file, line)
+     int  *wstat;
+     char *file;
+     int   line;
+{
+  int ret, lstat = 0;
+
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "wait (line %d) ", line);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+  ret = wait (&lstat);
+  if (procfs_trace)
+    {
+      fprintf (procfs_file ? procfs_file : stdout, 
+	       "returned pid %d, status 0x%x\n", ret, lstat);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+  if (wstat)
+    *wstat = lstat;
+
+  return ret;
+}
+
+void
+procfs_note (msg, file, line)
+     char *msg;
+     char *file;
+     int   line;
+{
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (info_verbose)
+	fprintf (procfs_file ? procfs_file : stdout, 
+		 "%s:%d -- ", file, line);
+      fprintf (procfs_file ? procfs_file : stdout, msg);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+}
+
+void
+proc_prettyfprint_status (flags, why, what, thread)
+     long flags;
+     int  why;
+     int  what;
+     int  thread;
+{
+  if (procfs_trace)
+    {
+      if (procfs_file == NULL && procfs_filename != NULL)
+	procfs_file = fopen (procfs_filename, "a");
+
+      if (thread)
+	fprintf (procfs_file ? procfs_file : stdout,
+		 "Thread %d: ", thread);
+
+      proc_prettyfprint_flags (procfs_file ? procfs_file : stdout, 
+			       flags, 0);
+
+      if (flags & (PR_STOPPED | PR_ISTOP))
+	proc_prettyfprint_why (procfs_file ? procfs_file : stdout, 
+			       why, what, 0);
+      if (procfs_file)
+	fflush (procfs_file);
+    }
+}
+
+
+void
+_initialize_proc_api ()
+{
+  struct cmd_list_element *c;
+
+  c = add_set_cmd ("procfs-trace", no_class,
+		   var_boolean, (char *) &procfs_trace, 
+		   "Set tracing for /proc ioctl calls.\n", &setlist);
+
+  add_show_from_set (c, &showlist);
+  c->function.sfunc = set_procfs_trace_cmd;
+
+  c = add_set_cmd ("procfs-file", no_class, var_filename,
+		   (char *) &procfs_filename, 
+		   "Set filename for /proc tracefile.\n", &setlist);
+
+  add_show_from_set (c, &showlist);
+  c->function.sfunc = set_procfs_file_cmd;
+
+#ifdef TRACE_PROCFS
+  if (procfs_file == NULL && procfs_filename != NULL)
+    procfs_file = fopen (procfs_filename, "a");
+#endif
+}
diff --git a/gdb/proc-events.c b/gdb/proc-events.c
new file mode 100644
index 0000000..2a430d8
--- /dev/null
+++ b/gdb/proc-events.c
@@ -0,0 +1,1806 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   Copyright 1999 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
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, 
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/*
+ * Pretty-print "events of interest".
+ *
+ * This module includes pretty-print routines for:
+ *	faults  (hardware exceptions):
+ *	signals (software interrupts):
+ *	syscalls
+ *
+ * FIXME: At present, the syscall translation table must be initialized, 
+ * which is not true of the other translation tables.
+ */
+
+#include "defs.h"
+
+#if defined (NEW_PROC_API)
+#define _STRUCTURED_PROC 1
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/procfs.h>
+#include <sys/syscall.h>
+#include <sys/fault.h>
+
+/*  Much of the information used in the /proc interface, particularly for
+    printing status information, is kept as tables of structures of the
+    following form.  These tables can be used to map numeric values to
+    their symbolic names and to a string that describes their specific use. */
+
+struct trans {
+  int value;                    /* The numeric value */
+  char *name;                   /* The equivalent symbolic value */
+  char *desc;                   /* Short description of value */
+};
+
+/*
+ * pretty print syscalls
+ */
+
+/* Ugh -- Unixware and Solaris spell these differently! */
+
+#ifdef  SYS_lwpcreate
+#define SYS_lwp_create	SYS_lwpcreate
+#endif
+
+#ifdef  SYS_lwpexit
+#define SYS_lwp_exit SYS_lwpexit
+#endif
+
+#ifdef  SYS_lwpwait
+#define SYS_lwp_wait SYS_lwpwait
+#endif
+
+#ifdef  SYS_lwpself
+#define SYS_lwp_self SYS_lwpself
+#endif
+
+#ifdef  SYS_lwpinfo
+#define SYS_lwp_info SYS_lwpinfo
+#endif
+
+#ifdef  SYS_lwpprivate
+#define SYS_lwp_private SYS_lwpprivate
+#endif
+
+#ifdef  SYS_lwpkill
+#define SYS_lwp_kill SYS_lwpkill
+#endif
+
+#ifdef  SYS_lwpsuspend
+#define SYS_lwp_suspend SYS_lwpsuspend
+#endif
+
+#ifdef  SYS_lwpcontinue
+#define SYS_lwp_continue SYS_lwpcontinue
+#endif
+
+
+/* Syscall translation table. */
+
+#define MAX_SYSCALLS 262	/* pretty arbitrary */
+static char * syscall_table[MAX_SYSCALLS];
+
+void
+init_syscall_table (void)
+{
+#if defined (SYS_BSD_getime)
+  syscall_table[SYS_BSD_getime] = "BSD_getime";
+#endif
+#if defined (SYS_BSDgetpgrp)
+  syscall_table[SYS_BSDgetpgrp] = "BSDgetpgrp";
+#endif
+#if defined (SYS_BSDsetpgrp)
+  syscall_table[SYS_BSDsetpgrp] = "BSDsetpgrp";
+#endif
+#if defined (SYS_acancel)
+  syscall_table[SYS_acancel] = "acancel";
+#endif
+#if defined (SYS_accept)
+  syscall_table[SYS_accept] = "accept";
+#endif
+#if defined (SYS_access)
+  syscall_table[SYS_access] = "access";
+#endif
+#if defined (SYS_acct)
+  syscall_table[SYS_acct] = "acct";
+#endif
+#if defined (SYS_acl)
+  syscall_table[SYS_acl] = "acl";
+#endif
+#if defined (SYS_aclipc)
+  syscall_table[SYS_aclipc] = "aclipc";
+#endif
+#if defined (SYS_adjtime)
+  syscall_table[SYS_adjtime] = "adjtime";
+#endif
+#if defined (SYS_afs_syscall)
+  syscall_table[SYS_afs_syscall] = "afs_syscall";
+#endif
+#if defined (SYS_alarm)
+  syscall_table[SYS_alarm] = "alarm";
+#endif
+#if defined (SYS_alt_plock)
+  syscall_table[SYS_alt_plock] = "alt_plock";
+#endif
+#if defined (SYS_alt_sigpending)
+  syscall_table[SYS_alt_sigpending] = "alt_sigpending";
+#endif
+#if defined (SYS_async)
+  syscall_table[SYS_async] = "async";
+#endif
+#if defined (SYS_async_daemon)
+  syscall_table[SYS_async_daemon] = "async_daemon";
+#endif
+#if defined (SYS_audcntl)
+  syscall_table[SYS_audcntl] = "audcntl";
+#endif
+#if defined (SYS_audgen)
+  syscall_table[SYS_audgen] = "audgen";
+#endif
+#if defined (SYS_auditbuf)
+  syscall_table[SYS_auditbuf] = "auditbuf";
+#endif
+#if defined (SYS_auditctl)
+  syscall_table[SYS_auditctl] = "auditctl";
+#endif
+#if defined (SYS_auditdmp)
+  syscall_table[SYS_auditdmp] = "auditdmp";
+#endif
+#if defined (SYS_auditevt)
+  syscall_table[SYS_auditevt] = "auditevt";
+#endif
+#if defined (SYS_auditlog)
+  syscall_table[SYS_auditlog] = "auditlog";
+#endif
+#if defined (SYS_auditsys)
+  syscall_table[SYS_auditsys] = "auditsys";
+#endif
+#if defined (SYS_bind)
+  syscall_table[SYS_bind] = "bind";
+#endif
+#if defined (SYS_block)
+  syscall_table[SYS_block] = "block";
+#endif
+#if defined (SYS_brk)
+  syscall_table[SYS_brk] = "brk";
+#endif
+#if defined (SYS_cachectl)
+  syscall_table[SYS_cachectl] = "cachectl";
+#endif
+#if defined (SYS_cacheflush)
+  syscall_table[SYS_cacheflush] = "cacheflush";
+#endif
+#if defined (SYS_cancelblock)
+  syscall_table[SYS_cancelblock] = "cancelblock";
+#endif
+#if defined (SYS_cg_bind)
+  syscall_table[SYS_cg_bind] = "cg_bind";
+#endif
+#if defined (SYS_cg_current)
+  syscall_table[SYS_cg_current] = "cg_current";
+#endif
+#if defined (SYS_cg_ids)
+  syscall_table[SYS_cg_ids] = "cg_ids";
+#endif
+#if defined (SYS_cg_info)
+  syscall_table[SYS_cg_info] = "cg_info";
+#endif
+#if defined (SYS_cg_memloc)
+  syscall_table[SYS_cg_memloc] = "cg_memloc";
+#endif
+#if defined (SYS_cg_processors)
+  syscall_table[SYS_cg_processors] = "cg_processors";
+#endif
+#if defined (SYS_chdir)
+  syscall_table[SYS_chdir] = "chdir";
+#endif
+#if defined (SYS_chflags)
+  syscall_table[SYS_chflags] = "chflags";
+#endif
+#if defined (SYS_chmod)
+  syscall_table[SYS_chmod] = "chmod";
+#endif
+#if defined (SYS_chown)
+  syscall_table[SYS_chown] = "chown";
+#endif
+#if defined (SYS_chroot)
+  syscall_table[SYS_chroot] = "chroot";
+#endif
+#if defined (SYS_clocal)
+  syscall_table[SYS_clocal] = "clocal";
+#endif
+#if defined (SYS_clock_getres)
+  syscall_table[SYS_clock_getres] = "clock_getres";
+#endif
+#if defined (SYS_clock_gettime)
+  syscall_table[SYS_clock_gettime] = "clock_gettime";
+#endif
+#if defined (SYS_clock_settime)
+  syscall_table[SYS_clock_settime] = "clock_settime";
+#endif
+#if defined (SYS_close)
+  syscall_table[SYS_close] = "close";
+#endif
+#if defined (SYS_connect)
+  syscall_table[SYS_connect] = "connect";
+#endif
+#if defined (SYS_context)
+  syscall_table[SYS_context] = "context";
+#endif
+#if defined (SYS_creat)
+  syscall_table[SYS_creat] = "creat";
+#endif
+#if defined (SYS_creat64)
+  syscall_table[SYS_creat64] = "creat64";
+#endif
+#if defined (SYS_devstat)
+  syscall_table[SYS_devstat] = "devstat";
+#endif
+#if defined (SYS_dmi)
+  syscall_table[SYS_dmi] = "dmi";
+#endif
+#if defined (SYS_door)
+  syscall_table[SYS_door] = "door";
+#endif
+#if defined (SYS_dshmsys)
+  syscall_table[SYS_dshmsys] = "dshmsys";
+#endif
+#if defined (SYS_dup)
+  syscall_table[SYS_dup] = "dup";
+#endif
+#if defined (SYS_dup2)
+  syscall_table[SYS_dup2] = "dup2";
+#endif
+#if defined (SYS_evsys)
+  syscall_table[SYS_evsys] = "evsys";
+#endif
+#if defined (SYS_evtrapret)
+  syscall_table[SYS_evtrapret] = "evtrapret";
+#endif
+#if defined (SYS_exec)
+  syscall_table[SYS_exec] = "exec";
+#endif
+#if defined (SYS_exec_with_loader)
+  syscall_table[SYS_exec_with_loader] = "exec_with_loader";
+#endif
+#if defined (SYS_execv)
+  syscall_table[SYS_execv] = "execv";
+#endif
+#if defined (SYS_execve)
+  syscall_table[SYS_execve] = "execve";
+#endif
+#if defined (SYS_exit)
+  syscall_table[SYS_exit] = "exit";
+#endif
+#if defined (SYS_exportfs)
+  syscall_table[SYS_exportfs] = "exportfs";
+#endif
+#if defined (SYS_facl)
+  syscall_table[SYS_facl] = "facl";
+#endif
+#if defined (SYS_fchdir)
+  syscall_table[SYS_fchdir] = "fchdir";
+#endif
+#if defined (SYS_fchflags)
+  syscall_table[SYS_fchflags] = "fchflags";
+#endif
+#if defined (SYS_fchmod)
+  syscall_table[SYS_fchmod] = "fchmod";
+#endif
+#if defined (SYS_fchown)
+  syscall_table[SYS_fchown] = "fchown";
+#endif
+#if defined (SYS_fchroot)
+  syscall_table[SYS_fchroot] = "fchroot";
+#endif
+#if defined (SYS_fcntl)
+  syscall_table[SYS_fcntl] = "fcntl";
+#endif
+#if defined (SYS_fdatasync)
+  syscall_table[SYS_fdatasync] = "fdatasync";
+#endif
+#if defined (SYS_fdevstat)
+  syscall_table[SYS_fdevstat] = "fdevstat";
+#endif
+#if defined (SYS_fdsync)
+  syscall_table[SYS_fdsync] = "fdsync";
+#endif
+#if defined (SYS_filepriv)
+  syscall_table[SYS_filepriv] = "filepriv";
+#endif
+#if defined (SYS_flock)
+  syscall_table[SYS_flock] = "flock";
+#endif
+#if defined (SYS_flvlfile)
+  syscall_table[SYS_flvlfile] = "flvlfile";
+#endif
+#if defined (SYS_fork)
+  syscall_table[SYS_fork] = "fork";
+#endif
+#if defined (SYS_fork1)
+  syscall_table[SYS_fork1] = "fork1";
+#endif
+#if defined (SYS_forkall)
+  syscall_table[SYS_forkall] = "forkall";
+#endif
+#if defined (SYS_fpathconf)
+  syscall_table[SYS_fpathconf] = "fpathconf";
+#endif
+#if defined (SYS_fstat)
+  syscall_table[SYS_fstat] = "fstat";
+#endif
+#if defined (SYS_fstat64)
+  syscall_table[SYS_fstat64] = "fstat64";
+#endif
+#if defined (SYS_fstatfs)
+  syscall_table[SYS_fstatfs] = "fstatfs";
+#endif
+#if defined (SYS_fstatvfs)
+  syscall_table[SYS_fstatvfs] = "fstatvfs";
+#endif
+#if defined (SYS_fstatvfs64)
+  syscall_table[SYS_fstatvfs64] = "fstatvfs64";
+#endif
+#if defined (SYS_fsync)
+  syscall_table[SYS_fsync] = "fsync";
+#endif
+#if defined (SYS_ftruncate)
+  syscall_table[SYS_ftruncate] = "ftruncate";
+#endif
+#if defined (SYS_ftruncate64)
+  syscall_table[SYS_ftruncate64] = "ftruncate64";
+#endif
+#if defined (SYS_fuser)
+  syscall_table[SYS_fuser] = "fuser";
+#endif
+#if defined (SYS_fxstat)
+  syscall_table[SYS_fxstat] = "fxstat";
+#endif
+#if defined (SYS_get_sysinfo)
+  syscall_table[SYS_get_sysinfo] = "get_sysinfo";
+#endif
+#if defined (SYS_getaddressconf)
+  syscall_table[SYS_getaddressconf] = "getaddressconf";
+#endif
+#if defined (SYS_getcontext)
+  syscall_table[SYS_getcontext] = "getcontext";
+#endif
+#if defined (SYS_getdents)
+  syscall_table[SYS_getdents] = "getdents";
+#endif
+#if defined (SYS_getdents64)
+  syscall_table[SYS_getdents64] = "getdents64";
+#endif
+#if defined (SYS_getdirentries)
+  syscall_table[SYS_getdirentries] = "getdirentries";
+#endif
+#if defined (SYS_getdomainname)
+  syscall_table[SYS_getdomainname] = "getdomainname";
+#endif
+#if defined (SYS_getdtablesize)
+  syscall_table[SYS_getdtablesize] = "getdtablesize";
+#endif
+#if defined (SYS_getfh)
+  syscall_table[SYS_getfh] = "getfh";
+#endif
+#if defined (SYS_getfsstat)
+  syscall_table[SYS_getfsstat] = "getfsstat";
+#endif
+#if defined (SYS_getgid)
+  syscall_table[SYS_getgid] = "getgid";
+#endif
+#if defined (SYS_getgroups)
+  syscall_table[SYS_getgroups] = "getgroups";
+#endif
+#if defined (SYS_gethostid)
+  syscall_table[SYS_gethostid] = "gethostid";
+#endif
+#if defined (SYS_gethostname)
+  syscall_table[SYS_gethostname] = "gethostname";
+#endif
+#if defined (SYS_getitimer)
+  syscall_table[SYS_getitimer] = "getitimer";
+#endif
+#if defined (SYS_getksym)
+  syscall_table[SYS_getksym] = "getksym";
+#endif
+#if defined (SYS_getlogin)
+  syscall_table[SYS_getlogin] = "getlogin";
+#endif
+#if defined (SYS_getmnt)
+  syscall_table[SYS_getmnt] = "getmnt";
+#endif
+#if defined (SYS_getmsg)
+  syscall_table[SYS_getmsg] = "getmsg";
+#endif
+#if defined (SYS_getpagesize)
+  syscall_table[SYS_getpagesize] = "getpagesize";
+#endif
+#if defined (SYS_getpeername)
+  syscall_table[SYS_getpeername] = "getpeername";
+#endif
+#if defined (SYS_getpgid)
+  syscall_table[SYS_getpgid] = "getpgid";
+#endif
+#if defined (SYS_getpgrp)
+  syscall_table[SYS_getpgrp] = "getpgrp";
+#endif
+#if defined (SYS_getpid)
+  syscall_table[SYS_getpid] = "getpid";
+#endif
+#if defined (SYS_getpmsg)
+  syscall_table[SYS_getpmsg] = "getpmsg";
+#endif
+#if defined (SYS_getpriority)
+  syscall_table[SYS_getpriority] = "getpriority";
+#endif
+#if defined (SYS_getrlimit)
+  syscall_table[SYS_getrlimit] = "getrlimit";
+#endif
+#if defined (SYS_getrlimit64)
+  syscall_table[SYS_getrlimit64] = "getrlimit64";
+#endif
+#if defined (SYS_getrusage)
+  syscall_table[SYS_getrusage] = "getrusage";
+#endif
+#if defined (SYS_getsid)
+  syscall_table[SYS_getsid] = "getsid";
+#endif
+#if defined (SYS_getsockname)
+  syscall_table[SYS_getsockname] = "getsockname";
+#endif
+#if defined (SYS_getsockopt)
+  syscall_table[SYS_getsockopt] = "getsockopt";
+#endif
+#if defined (SYS_gettimeofday)
+  syscall_table[SYS_gettimeofday] = "gettimeofday";
+#endif
+#if defined (SYS_getuid)
+  syscall_table[SYS_getuid] = "getuid";
+#endif
+#if defined (SYS_gtty)
+  syscall_table[SYS_gtty] = "gtty";
+#endif
+#if defined (SYS_hrtsys)
+  syscall_table[SYS_hrtsys] = "hrtsys";
+#endif
+#if defined (SYS_inst_sync)
+  syscall_table[SYS_inst_sync] = "inst_sync";
+#endif
+#if defined (SYS_install_utrap)
+  syscall_table[SYS_install_utrap] = "install_utrap";
+#endif
+#if defined (SYS_invlpg)
+  syscall_table[SYS_invlpg] = "invlpg";
+#endif
+#if defined (SYS_ioctl)
+  syscall_table[SYS_ioctl] = "ioctl";
+#endif
+#if defined (SYS_kaio)
+  syscall_table[SYS_kaio] = "kaio";
+#endif
+#if defined (SYS_keyctl)
+  syscall_table[SYS_keyctl] = "keyctl";
+#endif
+#if defined (SYS_kill)
+  syscall_table[SYS_kill] = "kill";
+#endif
+#if defined (SYS_killpg)
+  syscall_table[SYS_killpg] = "killpg";
+#endif
+#if defined (SYS_kloadcall)
+  syscall_table[SYS_kloadcall] = "kloadcall";
+#endif
+#if defined (SYS_kmodcall)
+  syscall_table[SYS_kmodcall] = "kmodcall";
+#endif
+#if defined (SYS_ksigaction)
+  syscall_table[SYS_ksigaction] = "ksigaction";
+#endif
+#if defined (SYS_ksigprocmask)
+  syscall_table[SYS_ksigprocmask] = "ksigprocmask";
+#endif
+#if defined (SYS_ksigqueue)
+  syscall_table[SYS_ksigqueue] = "ksigqueue";
+#endif
+#if defined (SYS_lchown)
+  syscall_table[SYS_lchown] = "lchown";
+#endif
+#if defined (SYS_link)
+  syscall_table[SYS_link] = "link";
+#endif
+#if defined (SYS_listen)
+  syscall_table[SYS_listen] = "listen";
+#endif
+#if defined (SYS_llseek)
+  syscall_table[SYS_llseek] = "llseek";
+#endif
+#if defined (SYS_lseek)
+  syscall_table[SYS_lseek] = "lseek";
+#endif
+#if defined (SYS_lseek64)
+  syscall_table[SYS_lseek64] = "lseek64";
+#endif
+#if defined (SYS_lstat)
+  syscall_table[SYS_lstat] = "lstat";
+#endif
+#if defined (SYS_lstat64)
+  syscall_table[SYS_lstat64] = "lstat64";
+#endif
+#if defined (SYS_lvldom)
+  syscall_table[SYS_lvldom] = "lvldom";
+#endif
+#if defined (SYS_lvlequal)
+  syscall_table[SYS_lvlequal] = "lvlequal";
+#endif
+#if defined (SYS_lvlfile)
+  syscall_table[SYS_lvlfile] = "lvlfile";
+#endif
+#if defined (SYS_lvlipc)
+  syscall_table[SYS_lvlipc] = "lvlipc";
+#endif
+#if defined (SYS_lvlproc)
+  syscall_table[SYS_lvlproc] = "lvlproc";
+#endif
+#if defined (SYS_lvlvfs)
+  syscall_table[SYS_lvlvfs] = "lvlvfs";
+#endif
+#if defined (SYS_lwp_alarm)
+  syscall_table[SYS_lwp_alarm] = "lwp_alarm";
+#endif
+#if defined (SYS_lwp_cond_broadcast)
+  syscall_table[SYS_lwp_cond_broadcast] = "lwp_cond_broadcast";
+#endif
+#if defined (SYS_lwp_cond_signal)
+  syscall_table[SYS_lwp_cond_signal] = "lwp_cond_signal";
+#endif
+#if defined (SYS_lwp_cond_wait)
+  syscall_table[SYS_lwp_cond_wait] = "lwp_cond_wait";
+#endif
+#if defined (SYS_lwp_continue)
+  syscall_table[SYS_lwp_continue] = "lwp_continue";
+#endif
+#if defined (SYS_lwp_create)
+  syscall_table[SYS_lwp_create] = "lwp_create";
+#endif
+#if defined (SYS_lwp_exit)
+  syscall_table[SYS_lwp_exit] = "lwp_exit";
+#endif
+#if defined (SYS_lwp_getprivate)
+  syscall_table[SYS_lwp_getprivate] = "lwp_getprivate";
+#endif
+#if defined (SYS_lwp_info)
+  syscall_table[SYS_lwp_info] = "lwp_info";
+#endif
+#if defined (SYS_lwp_kill)
+  syscall_table[SYS_lwp_kill] = "lwp_kill";
+#endif
+#if defined (SYS_lwp_mutex_init)
+  syscall_table[SYS_lwp_mutex_init] = "lwp_mutex_init";
+#endif
+#if defined (SYS_lwp_mutex_lock)
+  syscall_table[SYS_lwp_mutex_lock] = "lwp_mutex_lock";
+#endif
+#if defined (SYS_lwp_mutex_trylock)
+  syscall_table[SYS_lwp_mutex_trylock] = "lwp_mutex_trylock";
+#endif
+#if defined (SYS_lwp_mutex_unlock)
+  syscall_table[SYS_lwp_mutex_unlock] = "lwp_mutex_unlock";
+#endif
+#if defined (SYS_lwp_private)
+  syscall_table[SYS_lwp_private] = "lwp_private";
+#endif
+#if defined (SYS_lwp_self)
+  syscall_table[SYS_lwp_self] = "lwp_self";
+#endif
+#if defined (SYS_lwp_sema_post)
+  syscall_table[SYS_lwp_sema_post] = "lwp_sema_post";
+#endif
+#if defined (SYS_lwp_sema_trywait)
+  syscall_table[SYS_lwp_sema_trywait] = "lwp_sema_trywait";
+#endif
+#if defined (SYS_lwp_sema_wait)
+  syscall_table[SYS_lwp_sema_wait] = "lwp_sema_wait";
+#endif
+#if defined (SYS_lwp_setprivate)
+  syscall_table[SYS_lwp_setprivate] = "lwp_setprivate";
+#endif
+#if defined (SYS_lwp_sigredirect)
+  syscall_table[SYS_lwp_sigredirect] = "lwp_sigredirect";
+#endif
+#if defined (SYS_lwp_suspend)
+  syscall_table[SYS_lwp_suspend] = "lwp_suspend";
+#endif
+#if defined (SYS_lwp_wait)
+  syscall_table[SYS_lwp_wait] = "lwp_wait";
+#endif
+#if defined (SYS_lxstat)
+  syscall_table[SYS_lxstat] = "lxstat";
+#endif
+#if defined (SYS_madvise)
+  syscall_table[SYS_madvise] = "madvise";
+#endif
+#if defined (SYS_memcntl)
+  syscall_table[SYS_memcntl] = "memcntl";
+#endif
+#if defined (SYS_mincore)
+  syscall_table[SYS_mincore] = "mincore";
+#endif
+#if defined (SYS_mincore)
+  syscall_table[SYS_mincore] = "mincore";
+#endif
+#if defined (SYS_mkdir)
+  syscall_table[SYS_mkdir] = "mkdir";
+#endif
+#if defined (SYS_mkmld)
+  syscall_table[SYS_mkmld] = "mkmld";
+#endif
+#if defined (SYS_mknod)
+  syscall_table[SYS_mknod] = "mknod";
+#endif
+#if defined (SYS_mldmode)
+  syscall_table[SYS_mldmode] = "mldmode";
+#endif
+#if defined (SYS_mmap)
+  syscall_table[SYS_mmap] = "mmap";
+#endif
+#if defined (SYS_mmap64)
+  syscall_table[SYS_mmap64] = "mmap64";
+#endif
+#if defined (SYS_modadm)
+  syscall_table[SYS_modadm] = "modadm";
+#endif
+#if defined (SYS_modctl)
+  syscall_table[SYS_modctl] = "modctl";
+#endif
+#if defined (SYS_modload)
+  syscall_table[SYS_modload] = "modload";
+#endif
+#if defined (SYS_modpath)
+  syscall_table[SYS_modpath] = "modpath";
+#endif
+#if defined (SYS_modstat)
+  syscall_table[SYS_modstat] = "modstat";
+#endif
+#if defined (SYS_moduload)
+  syscall_table[SYS_moduload] = "moduload";
+#endif
+#if defined (SYS_mount)
+  syscall_table[SYS_mount] = "mount";
+#endif
+#if defined (SYS_mprotect)
+  syscall_table[SYS_mprotect] = "mprotect";
+#endif
+#if defined (SYS_mremap)
+  syscall_table[SYS_mremap] = "mremap";
+#endif
+#if defined (SYS_msfs_syscall)
+  syscall_table[SYS_msfs_syscall] = "msfs_syscall";
+#endif
+#if defined (SYS_msgctl)
+  syscall_table[SYS_msgctl] = "msgctl";
+#endif
+#if defined (SYS_msgget)
+  syscall_table[SYS_msgget] = "msgget";
+#endif
+#if defined (SYS_msgrcv)
+  syscall_table[SYS_msgrcv] = "msgrcv";
+#endif
+#if defined (SYS_msgsnd)
+  syscall_table[SYS_msgsnd] = "msgsnd";
+#endif
+#if defined (SYS_msgsys)
+  syscall_table[SYS_msgsys] = "msgsys";
+#endif
+#if defined (SYS_msleep)
+  syscall_table[SYS_msleep] = "msleep";
+#endif
+#if defined (SYS_msync)
+  syscall_table[SYS_msync] = "msync";
+#endif
+#if defined (SYS_munmap)
+  syscall_table[SYS_munmap] = "munmap";
+#endif
+#if defined (SYS_mvalid)
+  syscall_table[SYS_mvalid] = "mvalid";
+#endif
+#if defined (SYS_mwakeup)
+  syscall_table[SYS_mwakeup] = "mwakeup";
+#endif
+#if defined (SYS_naccept)
+  syscall_table[SYS_naccept] = "naccept";
+#endif
+#if defined (SYS_nanosleep)
+  syscall_table[SYS_nanosleep] = "nanosleep";
+#endif
+#if defined (SYS_nfssvc)
+  syscall_table[SYS_nfssvc] = "nfssvc";
+#endif
+#if defined (SYS_nfssys)
+  syscall_table[SYS_nfssys] = "nfssys";
+#endif
+#if defined (SYS_ngetpeername)
+  syscall_table[SYS_ngetpeername] = "ngetpeername";
+#endif
+#if defined (SYS_ngetsockname)
+  syscall_table[SYS_ngetsockname] = "ngetsockname";
+#endif
+#if defined (SYS_nice)
+  syscall_table[SYS_nice] = "nice";
+#endif
+#if defined (SYS_nrecvfrom)
+  syscall_table[SYS_nrecvfrom] = "nrecvfrom";
+#endif
+#if defined (SYS_nrecvmsg)
+  syscall_table[SYS_nrecvmsg] = "nrecvmsg";
+#endif
+#if defined (SYS_nsendmsg)
+  syscall_table[SYS_nsendmsg] = "nsendmsg";
+#endif
+#if defined (SYS_ntp_adjtime)
+  syscall_table[SYS_ntp_adjtime] = "ntp_adjtime";
+#endif
+#if defined (SYS_ntp_gettime)
+  syscall_table[SYS_ntp_gettime] = "ntp_gettime";
+#endif
+#if defined (SYS_nuname)
+  syscall_table[SYS_nuname] = "nuname";
+#endif
+#if defined (SYS_obreak)
+  syscall_table[SYS_obreak] = "obreak";
+#endif
+#if defined (SYS_old_accept)
+  syscall_table[SYS_old_accept] = "old_accept";
+#endif
+#if defined (SYS_old_fstat)
+  syscall_table[SYS_old_fstat] = "old_fstat";
+#endif
+#if defined (SYS_old_getpeername)
+  syscall_table[SYS_old_getpeername] = "old_getpeername";
+#endif
+#if defined (SYS_old_getpgrp)
+  syscall_table[SYS_old_getpgrp] = "old_getpgrp";
+#endif
+#if defined (SYS_old_getsockname)
+  syscall_table[SYS_old_getsockname] = "old_getsockname";
+#endif
+#if defined (SYS_old_killpg)
+  syscall_table[SYS_old_killpg] = "old_killpg";
+#endif
+#if defined (SYS_old_lstat)
+  syscall_table[SYS_old_lstat] = "old_lstat";
+#endif
+#if defined (SYS_old_recv)
+  syscall_table[SYS_old_recv] = "old_recv";
+#endif
+#if defined (SYS_old_recvfrom)
+  syscall_table[SYS_old_recvfrom] = "old_recvfrom";
+#endif
+#if defined (SYS_old_recvmsg)
+  syscall_table[SYS_old_recvmsg] = "old_recvmsg";
+#endif
+#if defined (SYS_old_send)
+  syscall_table[SYS_old_send] = "old_send";
+#endif
+#if defined (SYS_old_sendmsg)
+  syscall_table[SYS_old_sendmsg] = "old_sendmsg";
+#endif
+#if defined (SYS_old_sigblock)
+  syscall_table[SYS_old_sigblock] = "old_sigblock";
+#endif
+#if defined (SYS_old_sigsetmask)
+  syscall_table[SYS_old_sigsetmask] = "old_sigsetmask";
+#endif
+#if defined (SYS_old_sigvec)
+  syscall_table[SYS_old_sigvec] = "old_sigvec";
+#endif
+#if defined (SYS_old_stat)
+  syscall_table[SYS_old_stat] = "old_stat";
+#endif
+#if defined (SYS_old_vhangup)
+  syscall_table[SYS_old_vhangup] = "old_vhangup";
+#endif
+#if defined (SYS_old_wait)
+  syscall_table[SYS_old_wait] = "old_wait";
+#endif
+#if defined (SYS_oldquota)
+  syscall_table[SYS_oldquota] = "oldquota";
+#endif
+#if defined (SYS_online)
+  syscall_table[SYS_online] = "online";
+#endif
+#if defined (SYS_open)
+  syscall_table[SYS_open] = "open";
+#endif
+#if defined (SYS_open64)
+  syscall_table[SYS_open64] = "open64";
+#endif
+#if defined (SYS_ovadvise)
+  syscall_table[SYS_ovadvise] = "ovadvise";
+#endif
+#if defined (SYS_p_online)
+  syscall_table[SYS_p_online] = "p_online";
+#endif
+#if defined (SYS_pagelock)
+  syscall_table[SYS_pagelock] = "pagelock";
+#endif
+#if defined (SYS_pathconf)
+  syscall_table[SYS_pathconf] = "pathconf";
+#endif
+#if defined (SYS_pause)
+  syscall_table[SYS_pause] = "pause";
+#endif
+#if defined (SYS_pgrpsys)
+  syscall_table[SYS_pgrpsys] = "pgrpsys";
+#endif
+#if defined (SYS_pid_block)
+  syscall_table[SYS_pid_block] = "pid_block";
+#endif
+#if defined (SYS_pid_unblock)
+  syscall_table[SYS_pid_unblock] = "pid_unblock";
+#endif
+#if defined (SYS_pipe)
+  syscall_table[SYS_pipe] = "pipe";
+#endif
+#if defined (SYS_plock)
+  syscall_table[SYS_plock] = "plock";
+#endif
+#if defined (SYS_poll)
+  syscall_table[SYS_poll] = "poll";
+#endif
+#if defined (SYS_prctl)
+  syscall_table[SYS_prctl] = "prctl";
+#endif
+#if defined (SYS_pread)
+  syscall_table[SYS_pread] = "pread";
+#endif
+#if defined (SYS_pread64)
+  syscall_table[SYS_pread64] = "pread64";
+#endif
+#if defined (SYS_pread64)
+  syscall_table[SYS_pread64] = "pread64";
+#endif
+#if defined (SYS_prepblock)
+  syscall_table[SYS_prepblock] = "prepblock";
+#endif
+#if defined (SYS_priocntl)
+  syscall_table[SYS_priocntl] = "priocntl";
+#endif
+#if defined (SYS_priocntllst)
+  syscall_table[SYS_priocntllst] = "priocntllst";
+#endif
+#if defined (SYS_priocntlset)
+  syscall_table[SYS_priocntlset] = "priocntlset";
+#endif
+#if defined (SYS_priocntlsys)
+  syscall_table[SYS_priocntlsys] = "priocntlsys";
+#endif
+#if defined (SYS_procblk)
+  syscall_table[SYS_procblk] = "procblk";
+#endif
+#if defined (SYS_processor_bind)
+  syscall_table[SYS_processor_bind] = "processor_bind";
+#endif
+#if defined (SYS_processor_exbind)
+  syscall_table[SYS_processor_exbind] = "processor_exbind";
+#endif
+#if defined (SYS_processor_info)
+  syscall_table[SYS_processor_info] = "processor_info";
+#endif
+#if defined (SYS_procpriv)
+  syscall_table[SYS_procpriv] = "procpriv";
+#endif
+#if defined (SYS_profil)
+  syscall_table[SYS_profil] = "profil";
+#endif
+#if defined (SYS_proplist_syscall)
+  syscall_table[SYS_proplist_syscall] = "proplist_syscall";
+#endif
+#if defined (SYS_pset)
+  syscall_table[SYS_pset] = "pset";
+#endif
+#if defined (SYS_ptrace)
+  syscall_table[SYS_ptrace] = "ptrace";
+#endif
+#if defined (SYS_putmsg)
+  syscall_table[SYS_putmsg] = "putmsg";
+#endif
+#if defined (SYS_putpmsg)
+  syscall_table[SYS_putpmsg] = "putpmsg";
+#endif
+#if defined (SYS_pwrite)
+  syscall_table[SYS_pwrite] = "pwrite";
+#endif
+#if defined (SYS_pwrite64)
+  syscall_table[SYS_pwrite64] = "pwrite64";
+#endif
+#if defined (SYS_quotactl)
+  syscall_table[SYS_quotactl] = "quotactl";
+#endif
+#if defined (SYS_rdblock)
+  syscall_table[SYS_rdblock] = "rdblock";
+#endif
+#if defined (SYS_read)
+  syscall_table[SYS_read] = "read";
+#endif
+#if defined (SYS_readlink)
+  syscall_table[SYS_readlink] = "readlink";
+#endif
+#if defined (SYS_readv)
+  syscall_table[SYS_readv] = "readv";
+#endif
+#if defined (SYS_reboot)
+  syscall_table[SYS_reboot] = "reboot";
+#endif
+#if defined (SYS_recv)
+  syscall_table[SYS_recv] = "recv";
+#endif
+#if defined (SYS_recvfrom)
+  syscall_table[SYS_recvfrom] = "recvfrom";
+#endif
+#if defined (SYS_recvmsg)
+  syscall_table[SYS_recvmsg] = "recvmsg";
+#endif
+#if defined (SYS_rename)
+  syscall_table[SYS_rename] = "rename";
+#endif
+#if defined (SYS_resolvepath)
+  syscall_table[SYS_resolvepath] = "resolvepath";
+#endif
+#if defined (SYS_revoke)
+  syscall_table[SYS_revoke] = "revoke";
+#endif
+#if defined (SYS_rfsys)
+  syscall_table[SYS_rfsys] = "rfsys";
+#endif
+#if defined (SYS_rmdir)
+  syscall_table[SYS_rmdir] = "rmdir";
+#endif
+#if defined (SYS_rpcsys)
+  syscall_table[SYS_rpcsys] = "rpcsys";
+#endif
+#if defined (SYS_sbrk)
+  syscall_table[SYS_sbrk] = "sbrk";
+#endif
+#if defined (SYS_schedctl)
+  syscall_table[SYS_schedctl] = "schedctl";
+#endif
+#if defined (SYS_secadvise)
+  syscall_table[SYS_secadvise] = "secadvise";
+#endif
+#if defined (SYS_secsys)
+  syscall_table[SYS_secsys] = "secsys";
+#endif
+#if defined (SYS_security)
+  syscall_table[SYS_security] = "security";
+#endif
+#if defined (SYS_select)
+  syscall_table[SYS_select] = "select";
+#endif
+#if defined (SYS_semctl)
+  syscall_table[SYS_semctl] = "semctl";
+#endif
+#if defined (SYS_semget)
+  syscall_table[SYS_semget] = "semget";
+#endif
+#if defined (SYS_semop)
+  syscall_table[SYS_semop] = "semop";
+#endif
+#if defined (SYS_semsys)
+  syscall_table[SYS_semsys] = "semsys";
+#endif
+#if defined (SYS_send)
+  syscall_table[SYS_send] = "send";
+#endif
+#if defined (SYS_sendmsg)
+  syscall_table[SYS_sendmsg] = "sendmsg";
+#endif
+#if defined (SYS_sendto)
+  syscall_table[SYS_sendto] = "sendto";
+#endif
+#if defined (SYS_set_program_attributes)
+  syscall_table[SYS_set_program_attributes] = "set_program_attributes";
+#endif
+#if defined (SYS_set_speculative)
+  syscall_table[SYS_set_speculative] = "set_speculative";
+#endif
+#if defined (SYS_set_sysinfo)
+  syscall_table[SYS_set_sysinfo] = "set_sysinfo";
+#endif
+#if defined (SYS_setcontext)
+  syscall_table[SYS_setcontext] = "setcontext";
+#endif
+#if defined (SYS_setdomainname)
+  syscall_table[SYS_setdomainname] = "setdomainname";
+#endif
+#if defined (SYS_setegid)
+  syscall_table[SYS_setegid] = "setegid";
+#endif
+#if defined (SYS_seteuid)
+  syscall_table[SYS_seteuid] = "seteuid";
+#endif
+#if defined (SYS_setgid)
+  syscall_table[SYS_setgid] = "setgid";
+#endif
+#if defined (SYS_setgroups)
+  syscall_table[SYS_setgroups] = "setgroups";
+#endif
+#if defined (SYS_sethostid)
+  syscall_table[SYS_sethostid] = "sethostid";
+#endif
+#if defined (SYS_sethostname)
+  syscall_table[SYS_sethostname] = "sethostname";
+#endif
+#if defined (SYS_setitimer)
+  syscall_table[SYS_setitimer] = "setitimer";
+#endif
+#if defined (SYS_setlogin)
+  syscall_table[SYS_setlogin] = "setlogin";
+#endif
+#if defined (SYS_setpgid)
+  syscall_table[SYS_setpgid] = "setpgid";
+#endif
+#if defined (SYS_setpgrp)
+  syscall_table[SYS_setpgrp] = "setpgrp";
+#endif
+#if defined (SYS_setpriority)
+  syscall_table[SYS_setpriority] = "setpriority";
+#endif
+#if defined (SYS_setregid)
+  syscall_table[SYS_setregid] = "setregid";
+#endif
+#if defined (SYS_setreuid)
+  syscall_table[SYS_setreuid] = "setreuid";
+#endif
+#if defined (SYS_setrlimit)
+  syscall_table[SYS_setrlimit] = "setrlimit";
+#endif
+#if defined (SYS_setrlimit64)
+  syscall_table[SYS_setrlimit64] = "setrlimit64";
+#endif
+#if defined (SYS_setsid)
+  syscall_table[SYS_setsid] = "setsid";
+#endif
+#if defined (SYS_setsockopt)
+  syscall_table[SYS_setsockopt] = "setsockopt";
+#endif
+#if defined (SYS_settimeofday)
+  syscall_table[SYS_settimeofday] = "settimeofday";
+#endif
+#if defined (SYS_setuid)
+  syscall_table[SYS_setuid] = "setuid";
+#endif
+#if defined (SYS_sgi)
+  syscall_table[SYS_sgi] = "sgi";
+#endif
+#if defined (SYS_sgifastpath)
+  syscall_table[SYS_sgifastpath] = "sgifastpath";
+#endif
+#if defined (SYS_sgikopt)
+  syscall_table[SYS_sgikopt] = "sgikopt";
+#endif
+#if defined (SYS_sginap)
+  syscall_table[SYS_sginap] = "sginap";
+#endif
+#if defined (SYS_shmat)
+  syscall_table[SYS_shmat] = "shmat";
+#endif
+#if defined (SYS_shmctl)
+  syscall_table[SYS_shmctl] = "shmctl";
+#endif
+#if defined (SYS_shmdt)
+  syscall_table[SYS_shmdt] = "shmdt";
+#endif
+#if defined (SYS_shmget)
+  syscall_table[SYS_shmget] = "shmget";
+#endif
+#if defined (SYS_shmsys)
+  syscall_table[SYS_shmsys] = "shmsys";
+#endif
+#if defined (SYS_shutdown)
+  syscall_table[SYS_shutdown] = "shutdown";
+#endif
+#if defined (SYS_sigaction)
+  syscall_table[SYS_sigaction] = "sigaction";
+#endif
+#if defined (SYS_sigaltstack)
+  syscall_table[SYS_sigaltstack] = "sigaltstack";
+#endif
+#if defined (SYS_sigaltstack)
+  syscall_table[SYS_sigaltstack] = "sigaltstack";
+#endif
+#if defined (SYS_sigblock)
+  syscall_table[SYS_sigblock] = "sigblock";
+#endif
+#if defined (SYS_signal)
+  syscall_table[SYS_signal] = "signal";
+#endif
+#if defined (SYS_signotify)
+  syscall_table[SYS_signotify] = "signotify";
+#endif
+#if defined (SYS_signotifywait)
+  syscall_table[SYS_signotifywait] = "signotifywait";
+#endif
+#if defined (SYS_sigpending)
+  syscall_table[SYS_sigpending] = "sigpending";
+#endif
+#if defined (SYS_sigpoll)
+  syscall_table[SYS_sigpoll] = "sigpoll";
+#endif
+#if defined (SYS_sigprocmask)
+  syscall_table[SYS_sigprocmask] = "sigprocmask";
+#endif
+#if defined (SYS_sigqueue)
+  syscall_table[SYS_sigqueue] = "sigqueue";
+#endif
+#if defined (SYS_sigreturn)
+  syscall_table[SYS_sigreturn] = "sigreturn";
+#endif
+#if defined (SYS_sigsendset)
+  syscall_table[SYS_sigsendset] = "sigsendset";
+#endif
+#if defined (SYS_sigsendsys)
+  syscall_table[SYS_sigsendsys] = "sigsendsys";
+#endif
+#if defined (SYS_sigsetmask)
+  syscall_table[SYS_sigsetmask] = "sigsetmask";
+#endif
+#if defined (SYS_sigstack)
+  syscall_table[SYS_sigstack] = "sigstack";
+#endif
+#if defined (SYS_sigsuspend)
+  syscall_table[SYS_sigsuspend] = "sigsuspend";
+#endif
+#if defined (SYS_sigvec)
+  syscall_table[SYS_sigvec] = "sigvec";
+#endif
+#if defined (SYS_sigwait)
+  syscall_table[SYS_sigwait] = "sigwait";
+#endif
+#if defined (SYS_sigwaitprim)
+  syscall_table[SYS_sigwaitprim] = "sigwaitprim";
+#endif
+#if defined (SYS_sleep)
+  syscall_table[SYS_sleep] = "sleep";
+#endif
+#if defined (SYS_so_socket)
+  syscall_table[SYS_so_socket] = "so_socket";
+#endif
+#if defined (SYS_so_socketpair)
+  syscall_table[SYS_so_socketpair] = "so_socketpair";
+#endif
+#if defined (SYS_sockconfig)
+  syscall_table[SYS_sockconfig] = "sockconfig";
+#endif
+#if defined (SYS_socket)
+  syscall_table[SYS_socket] = "socket";
+#endif
+#if defined (SYS_socketpair)
+  syscall_table[SYS_socketpair] = "socketpair";
+#endif
+#if defined (SYS_sproc)
+  syscall_table[SYS_sproc] = "sproc";
+#endif
+#if defined (SYS_sprocsp)
+  syscall_table[SYS_sprocsp] = "sprocsp";
+#endif
+#if defined (SYS_sstk)
+  syscall_table[SYS_sstk] = "sstk";
+#endif
+#if defined (SYS_stat)
+  syscall_table[SYS_stat] = "stat";
+#endif
+#if defined (SYS_stat64)
+  syscall_table[SYS_stat64] = "stat64";
+#endif
+#if defined (SYS_statfs)
+  syscall_table[SYS_statfs] = "statfs";
+#endif
+#if defined (SYS_statvfs)
+  syscall_table[SYS_statvfs] = "statvfs";
+#endif
+#if defined (SYS_statvfs64)
+  syscall_table[SYS_statvfs64] = "statvfs64";
+#endif
+#if defined (SYS_stime)
+  syscall_table[SYS_stime] = "stime";
+#endif
+#if defined (SYS_stty)
+  syscall_table[SYS_stty] = "stty";
+#endif
+#if defined (SYS_subsys_info)
+  syscall_table[SYS_subsys_info] = "subsys_info";
+#endif
+#if defined (SYS_swapctl)
+  syscall_table[SYS_swapctl] = "swapctl";
+#endif
+#if defined (SYS_swapon)
+  syscall_table[SYS_swapon] = "swapon";
+#endif
+#if defined (SYS_symlink)
+  syscall_table[SYS_symlink] = "symlink";
+#endif
+#if defined (SYS_sync)
+  syscall_table[SYS_sync] = "sync";
+#endif
+#if defined (SYS_sys3b)
+  syscall_table[SYS_sys3b] = "sys3b";
+#endif
+#if defined (SYS_syscall)
+  syscall_table[SYS_syscall] = "syscall";
+#endif
+#if defined (SYS_sysconfig)
+  syscall_table[SYS_sysconfig] = "sysconfig";
+#endif
+#if defined (SYS_sysfs)
+  syscall_table[SYS_sysfs] = "sysfs";
+#endif
+#if defined (SYS_sysi86)
+  syscall_table[SYS_sysi86] = "sysi86";
+#endif
+#if defined (SYS_sysinfo)
+  syscall_table[SYS_sysinfo] = "sysinfo";
+#endif
+#if defined (SYS_sysmips)
+  syscall_table[SYS_sysmips] = "sysmips";
+#endif
+#if defined (SYS_syssun)
+  syscall_table[SYS_syssun] = "syssun";
+#endif
+#if defined (SYS_systeminfo)
+  syscall_table[SYS_systeminfo] = "systeminfo";
+#endif
+#if defined (SYS_table)
+  syscall_table[SYS_table] = "table";
+#endif
+#if defined (SYS_time)
+  syscall_table[SYS_time] = "time";
+#endif
+#if defined (SYS_timedwait)
+  syscall_table[SYS_timedwait] = "timedwait";
+#endif
+#if defined (SYS_timer_create)
+  syscall_table[SYS_timer_create] = "timer_create";
+#endif
+#if defined (SYS_timer_delete)
+  syscall_table[SYS_timer_delete] = "timer_delete";
+#endif
+#if defined (SYS_timer_getoverrun)
+  syscall_table[SYS_timer_getoverrun] = "timer_getoverrun";
+#endif
+#if defined (SYS_timer_gettime)
+  syscall_table[SYS_timer_gettime] = "timer_gettime";
+#endif
+#if defined (SYS_timer_settime)
+  syscall_table[SYS_timer_settime] = "timer_settime";
+#endif
+#if defined (SYS_times)
+  syscall_table[SYS_times] = "times";
+#endif
+#if defined (SYS_truncate)
+  syscall_table[SYS_truncate] = "truncate";
+#endif
+#if defined (SYS_truncate64)
+  syscall_table[SYS_truncate64] = "truncate64";
+#endif
+#if defined (SYS_tsolsys)
+  syscall_table[SYS_tsolsys] = "tsolsys";
+#endif
+#if defined (SYS_uadmin)
+  syscall_table[SYS_uadmin] = "uadmin";
+#endif
+#if defined (SYS_ulimit)
+  syscall_table[SYS_ulimit] = "ulimit";
+#endif
+#if defined (SYS_umask)
+  syscall_table[SYS_umask] = "umask";
+#endif
+#if defined (SYS_umount)
+  syscall_table[SYS_umount] = "umount";
+#endif
+#if defined (SYS_uname)
+  syscall_table[SYS_uname] = "uname";
+#endif
+#if defined (SYS_unblock)
+  syscall_table[SYS_unblock] = "unblock";
+#endif
+#if defined (SYS_unlink)
+  syscall_table[SYS_unlink] = "unlink";
+#endif
+#if defined (SYS_unmount)
+  syscall_table[SYS_unmount] = "unmount";
+#endif
+#if defined (SYS_usleep_thread)
+  syscall_table[SYS_usleep_thread] = "usleep_thread";
+#endif
+#if defined (SYS_uswitch)
+  syscall_table[SYS_uswitch] = "uswitch";
+#endif
+#if defined (SYS_utc_adjtime)
+  syscall_table[SYS_utc_adjtime] = "utc_adjtime";
+#endif
+#if defined (SYS_utc_gettime)
+  syscall_table[SYS_utc_gettime] = "utc_gettime";
+#endif
+#if defined (SYS_utime)
+  syscall_table[SYS_utime] = "utime";
+#endif
+#if defined (SYS_utimes)
+  syscall_table[SYS_utimes] = "utimes";
+#endif
+#if defined (SYS_utssys)
+  syscall_table[SYS_utssys] = "utssys";
+#endif
+#if defined (SYS_vfork)
+  syscall_table[SYS_vfork] = "vfork";
+#endif
+#if defined (SYS_vhangup)
+  syscall_table[SYS_vhangup] = "vhangup";
+#endif
+#if defined (SYS_vtrace)
+  syscall_table[SYS_vtrace] = "vtrace";
+#endif
+#if defined (SYS_wait)
+  syscall_table[SYS_wait] = "wait";
+#endif
+#if defined (SYS_waitid)
+  syscall_table[SYS_waitid] = "waitid";
+#endif
+#if defined (SYS_waitsys)
+  syscall_table[SYS_waitsys] = "waitsys";
+#endif
+#if defined (SYS_write)
+  syscall_table[SYS_write] = "write";
+#endif
+#if defined (SYS_writev)
+  syscall_table[SYS_writev] = "writev";
+#endif
+#if defined (SYS_xenix)
+  syscall_table[SYS_xenix] = "xenix";
+#endif
+#if defined (SYS_xmknod)
+  syscall_table[SYS_xmknod] = "xmknod";
+#endif
+#if defined (SYS_xstat)
+  syscall_table[SYS_xstat] = "xstat";
+#endif
+#if defined (SYS_yield)
+  syscall_table[SYS_yield] = "yield";
+#endif
+};
+
+/*
+ * Prettyprint a single syscall by number.
+ */
+
+void
+proc_prettyfprint_syscall (file, num, verbose)
+     FILE *file;
+     int  num;
+     int  verbose;
+{
+  if (syscall_table[num])
+    fprintf (file, "SYS_%s ", syscall_table[num]);
+  else
+    fprintf (file, "<Unknown syscall %d> ", num);
+}
+
+void
+proc_prettyprint_syscall (num, verbose)
+     int num;
+     int verbose;
+{
+  proc_prettyfprint_syscall (stdout, num, verbose);
+}
+
+/*
+ * Prettyprint all of the syscalls in a sysset_t set.
+ */
+
+void
+proc_prettyfprint_syscalls (file, sysset, verbose)
+     FILE     *file;
+     sysset_t *sysset;
+     int      verbose;
+{
+  int i;
+
+  for (i = 0; i < MAX_SYSCALLS; i++)
+    if (prismember (sysset, i))
+      {
+	proc_prettyfprint_syscall (file, i, verbose);
+      }
+  fprintf (file, "\n");
+}
+
+void
+proc_prettyprint_syscalls (sysset, verbose)
+     sysset_t *sysset;
+     int      verbose;
+{
+  proc_prettyfprint_syscalls (stdout, sysset, verbose);
+}
+
+/* FIXME: add real-time signals */
+
+static struct trans signal_table[] = 
+{
+  { 0,      "<no signal>", "no signal" }, 
+#ifdef SIGHUP
+  { SIGHUP, "SIGHUP", "Hangup" },
+#endif
+#ifdef SIGINT
+  { SIGINT, "SIGINT", "Interrupt (rubout)" },
+#endif
+#ifdef SIGQUIT
+  { SIGQUIT, "SIGQUIT", "Quit (ASCII FS)" },
+#endif
+#ifdef SIGILL
+  { SIGILL, "SIGILL", "Illegal instruction" },	/* not reset when caught */
+#endif
+#ifdef SIGTRAP
+  { SIGTRAP, "SIGTRAP", "Trace trap" },		/* not reset when caught */
+#endif
+#ifdef SIGABRT
+  { SIGABRT, "SIGABRT", "used by abort()" },	/* replaces SIGIOT */
+#endif
+#ifdef SIGIOT
+  { SIGIOT, "SIGIOT", "IOT instruction" },
+#endif
+#ifdef SIGEMT
+  { SIGEMT, "SIGEMT", "EMT instruction" },
+#endif
+#ifdef SIGFPE
+  { SIGFPE, "SIGFPE", "Floating point exception" },
+#endif
+#ifdef SIGKILL
+  { SIGKILL, "SIGKILL", "Kill" },	/* Solaris: cannot be caught/ignored */
+#endif
+#ifdef SIGBUS
+  { SIGBUS, "SIGBUS", "Bus error" },
+#endif
+#ifdef SIGSEGV
+  { SIGSEGV, "SIGSEGV", "Segmentation violation" },
+#endif
+#ifdef SIGSYS
+  { SIGSYS, "SIGSYS", "Bad argument to system call" },
+#endif
+#ifdef SIGPIPE
+  { SIGPIPE, "SIGPIPE", "Write to pipe with no one to read it" },
+#endif
+#ifdef SIGALRM
+  { SIGALRM, "SIGALRM", "Alarm clock" },
+#endif
+#ifdef SIGTERM
+  { SIGTERM, "SIGTERM", "Software termination signal from kill" },
+#endif
+#ifdef SIGUSR1
+  { SIGUSR1, "SIGUSR1", "User defined signal 1" },
+#endif
+#ifdef SIGUSR2
+  { SIGUSR2, "SIGUSR2", "User defined signal 2" },
+#endif
+#ifdef SIGCHLD
+  { SIGCHLD, "SIGCHLD", "Child status changed" },	/* Posix version */
+#endif
+#ifdef SIGCLD
+  { SIGCLD, "SIGCLD", "Child status changed" },		/* Solaris version */
+#endif
+#ifdef SIGPWR
+  { SIGPWR, "SIGPWR", "Power-fail restart" },
+#endif
+#ifdef SIGWINCH
+  { SIGWINCH, "SIGWINCH", "Window size change" },
+#endif
+#ifdef SIGURG
+  { SIGURG, "SIGURG", "Urgent socket condition" },
+#endif
+#ifdef SIGPOLL
+  { SIGPOLL, "SIGPOLL", "Pollable event" },
+#endif
+#ifdef SIGIO
+  { SIGIO, "SIGIO", "Socket I/O possible" },	/* alias for SIGPOLL */
+#endif
+#ifdef SIGSTOP
+  { SIGSTOP, "SIGSTOP", "Stop, not from tty" },	/* cannot be caught or ignored */
+#endif
+#ifdef SIGTSTP
+  { SIGTSTP, "SIGTSTP", "User stop from tty" },
+#endif
+#ifdef SIGCONT
+  { SIGCONT, "SIGCONT", "Stopped process has been continued" },
+#endif
+#ifdef SIGTTIN
+  { SIGTTIN, "SIGTTIN", "Background tty read attempted" },
+#endif
+#ifdef SIGTTOU
+  { SIGTTOU, "SIGTTOU", "Background tty write attempted" },
+#endif
+#ifdef SIGVTALRM
+  { SIGVTALRM, "SIGVTALRM", "Virtual timer expired" },
+#endif
+#ifdef SIGPROF
+  { SIGPROF, "SIGPROF", "Profiling timer expired" },
+#endif
+#ifdef SIGXCPU
+  { SIGXCPU, "SIGXCPU", "Exceeded CPU limit" },
+#endif
+#ifdef SIGXFSZ
+  { SIGXFSZ, "SIGXFSZ", "Exceeded file size limit" },
+#endif
+#ifdef SIGWAITING
+  { SIGWAITING, "SIGWAITING", "Process's LWPs are blocked" },
+#endif
+#ifdef SIGLWP
+  { SIGLWP, "SIGLWP", "Used by thread library" },
+#endif
+#ifdef SIGFREEZE
+  { SIGFREEZE, "SIGFREEZE", "Used by CPR" },
+#endif
+#ifdef SIGTHAW
+  { SIGTHAW, "SIGTHAW", "Used by CPR" },
+#endif
+#ifdef SIGCANCEL
+  { SIGCANCEL, "SIGCANCEL", "Used by libthread" },
+#endif
+#ifdef SIGLOST
+  { SIGLOST, "SIGLOST", "Resource lost" },
+#endif
+#ifdef SIG32
+  { SIG32, "SIG32", "Reserved for kernel usage (Irix)" },
+#endif
+#ifdef SIGPTINTR
+  { SIGPTINTR, "SIGPTINTR", "Posix 1003.1b" },
+#endif
+#ifdef SIGTRESCHED
+  { SIGTRESCHED, "SIGTRESCHED", "Posix 1003.1b" },
+#endif
+#ifdef SIGINFO
+  { SIGINFO, "SIGINFO", "Information request" },
+#endif
+#ifdef SIGRESV
+  { SIGRESV, "SIGRESV", "Reserved by Digital for future use" },
+#endif
+#ifdef SIGAIO
+  { SIGAIO, "SIGAIO", "Asynchronous I/O signal" },
+#endif
+};
+
+/*
+ * Prettyprint a single signal by number.
+ * Accepts a signal number and finds it in the signal table, 
+ * then pretty-prints it. 
+ */
+
+void
+proc_prettyfprint_signal (file, signo, verbose)
+     FILE *file;
+     int  signo;
+     int verbose;
+{
+  int i;
+
+  for (i = 0; i < sizeof (signal_table) / sizeof (signal_table[0]); i++)
+    if (signo == signal_table[i].value)
+      {
+	fprintf (file, "%s", signal_table[i].name);
+	if (verbose)
+	  fprintf (file, ": %s\n", signal_table[i].desc);
+	else
+	  fprintf (file, " ");
+	return;
+      }
+  fprintf (file, "Unknown signal %d%c", signo, verbose ? '\n' : ' ');
+}
+
+void
+proc_prettyprint_signal (signo, verbose)
+     int signo;
+     int verbose;
+{
+  proc_prettyfprint_signal (stdout, signo, verbose);
+}
+
+/*
+ * Prettyprint all of the signals in a sigset_t set.
+ *
+ * This function loops over all signal numbers from 0 to NSIG, 
+ * uses them as indexes for prismember, and prints them pretty.
+ * 
+ * It does not loop over the signal table, as is done with the
+ * fault table, because the signal table may contain aliases.
+ * If it did, both aliases would be printed.
+ */
+
+void
+proc_prettyfprint_signalset (file, sigset, verbose)
+     FILE     *file;
+     sigset_t *sigset;
+     int      verbose;
+{
+  int i;
+
+  for (i = 0; i < NSIG; i++)
+    if (prismember (sigset, i))
+      proc_prettyfprint_signal (file, i, verbose);
+
+  if (!verbose)
+    fprintf (file, "\n");
+}
+
+void
+proc_prettyprint_signalset (sigset, verbose)
+     sigset_t *sigset;
+     int      verbose;
+{
+  proc_prettyfprint_signalset (stdout, sigset, verbose);
+}
+
+/*  Hardware fault translation table. */
+
+static struct trans fault_table[] =
+{
+#if defined (FLTILL)
+  { FLTILL, "FLTILL", "Illegal instruction" },
+#endif
+#if defined (FLTPRIV)
+  { FLTPRIV, "FLTPRIV", "Privileged instruction" },
+#endif
+#if defined (FLTBPT)
+  { FLTBPT, "FLTBPT", "Breakpoint trap" },
+#endif
+#if defined (FLTTRACE)
+  { FLTTRACE, "FLTTRACE", "Trace trap" },
+#endif
+#if defined (FLTACCESS)
+  { FLTACCESS, "FLTACCESS", "Memory access fault" },
+#endif
+#if defined (FLTBOUNDS)
+  { FLTBOUNDS, "FLTBOUNDS", "Memory bounds violation" },
+#endif
+#if defined (FLTIOVF)
+  { FLTIOVF, "FLTIOVF", "Integer overflow" },
+#endif
+#if defined (FLTIZDIV)
+  { FLTIZDIV, "FLTIZDIV", "Integer zero divide" },
+#endif
+#if defined (FLTFPE)
+  { FLTFPE, "FLTFPE", "Floating-point exception" },
+#endif
+#if defined (FLTSTACK)
+  { FLTSTACK, "FLTSTACK", "Unrecoverable stack fault" },
+#endif
+#if defined (FLTPAGE)
+  { FLTPAGE, "FLTPAGE", "Recoverable page fault" },
+#endif
+#if defined (FLTPCINVAL)
+  { FLTPCINVAL, "FLTPCINVAL", "Invalid PC exception" },
+#endif
+#if defined (FLTWATCH)
+  { FLTWATCH, "FLTWATCH", "User watchpoint" },
+#endif
+#if defined (FLTKWATCH)
+  { FLTKWATCH, "FLTKWATCH", "Kernel watchpoint" },
+#endif
+#if defined (FLTSCWATCH)
+  { FLTSCWATCH, "FLTSCWATCH", "Hit a store conditional on a watched page" },
+#endif
+};
+
+/*
+ * Work horse.  Accepts an index into the fault table, prints it pretty. 
+ */
+
+static void
+prettyfprint_faulttable_entry (file, i, verbose)
+     FILE *file;
+     int   i;
+     int   verbose;
+{
+  fprintf (file, "%s", fault_table[i].name);
+  if (verbose)
+    fprintf (file, ": %s\n", fault_table[i].desc);
+  else
+    fprintf (file, " ");
+}
+
+/* 
+ * Prettyprint a hardware fault by number.
+ */
+
+void
+proc_prettyfprint_fault (file, faultno, verbose)
+     FILE *file;
+     int  faultno;
+     int  verbose;
+{
+  int i;
+
+  for (i = 0; i < sizeof (fault_table) / sizeof (fault_table[0]); i++)
+    if (faultno == fault_table[i].value)
+      {
+	prettyfprint_faulttable_entry (file, i, verbose);
+	return;
+      }
+
+  fprintf (file, "Unknown hardware fault %d%c", 
+	   faultno, verbose ? '\n' : ' ');
+}
+
+void
+proc_prettyprint_fault (faultno, verbose)
+     int  faultno;
+     int  verbose;
+{
+  proc_prettyfprint_fault (stdout, faultno, verbose);
+}
+
+/*
+ * Prettyprint all the faults in a fltset_t set.
+ *
+ * This function loops thru the fault table, 
+ * using the value field as the index to prismember.
+ * The fault table had better not contain aliases, 
+ * for if it does they will both be printed.
+ */
+
+void
+proc_prettyfprint_faultset (file, fltset, verbose)
+     FILE     *file;
+     fltset_t *fltset;
+     int      verbose;
+{
+  int i;
+
+  for (i = 0; i < sizeof (fault_table) / sizeof (fault_table[0]); i++)
+    if (prismember (fltset, fault_table[i].value))
+      prettyfprint_faulttable_entry (file, i, verbose);
+
+  if (!verbose)
+    fprintf (file, "\n");
+}
+
+void
+proc_prettyprint_faultset (fltset, verbose)
+     fltset_t *fltset;
+     int      verbose;
+{
+  proc_prettyfprint_faultset (stdout, fltset, verbose);
+}
+
+/*
+ * Todo: actions, holds...
+ */
+
+void
+proc_prettyprint_actionset (struct sigaction *actions, int verbose)
+{
+}
+
+void
+_initialize_proc_events ()
+{
+  init_syscall_table ();
+}
diff --git a/gdb/proc-flags.c b/gdb/proc-flags.c
new file mode 100644
index 0000000..d2957be
--- /dev/null
+++ b/gdb/proc-flags.c
@@ -0,0 +1,296 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   Copyright 1999 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
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, 
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/*
+ * Pretty-print the prstatus flags.
+ * 
+ * Arguments: unsigned long flags, int verbose
+ *
+ */
+
+#include "defs.h"
+
+#if defined (NEW_PROC_API)
+#define _STRUCTURED_PROC 1
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/procfs.h>
+
+/*  Much of the information used in the /proc interface, particularly for
+    printing status information, is kept as tables of structures of the
+    following form.  These tables can be used to map numeric values to
+    their symbolic names and to a string that describes their specific use. */
+
+struct trans {
+  int value;                    /* The numeric value */
+  char *name;                   /* The equivalent symbolic value */
+  char *desc;                   /* Short description of value */
+};
+
+/* Translate bits in the pr_flags member of the prstatus structure,
+   into the names and desc information. */
+
+static struct trans pr_flag_table[] =
+{
+#if defined (PR_STOPPED)
+  /* Sol2.5: lwp is stopped
+   * Sol2.6: lwp is stopped
+   * Sol2.7: lwp is stopped
+   * IRIX6:  process is stopped
+   * OSF:    task/thread is stopped
+   * UW:     LWP is stopped
+   */
+  { PR_STOPPED, "PR_STOPPED", "Process (LWP) is stopped" },
+#endif
+#if defined (PR_ISTOP)
+  /* Sol2.5: lwp is stopped on an event of interest
+   * Sol2.6: lwp is stopped on an event of interest
+   * Sol2.7: lwp is stopped on an event of interest
+   * IRIX6:  process is stopped on event of interest
+   * OSF:    task/thread stopped on event of interest
+   * UW:     LWP stopped on an event of interest
+   */
+  { PR_ISTOP, "PR_ISTOP", "Stopped on an event of interest" },
+#endif
+#if defined (PR_DSTOP)
+  /* Sol2.5: lwp has a stop directive in effect
+   * Sol2.6: lwp has a stop directive in effect
+   * Sol2.7: lwp has a stop directive in effect
+   * IRIX6:  process has stop directive in effect
+   * OSF:    task/thread has stop directive in effect
+   * UW:     A stop directive is in effect
+   */
+  { PR_DSTOP, "PR_DSTOP", "A stop directive is in effect" },
+#endif
+#if defined (PR_STEP)
+  /* Sol2.5: lwp has a single-step directive in effect
+   * Sol2.6: lwp has a single-step directive in effect
+   * Sol2.7: lwp has a single-step directive in effect
+   * IRIX6:  process has single step pending
+   */
+  { PR_STEP, "PR_STEP", "A single step directive is in effect" },
+#endif
+#if defined (PR_ASLEEP)
+  /* Sol2.5: lwp is sleeping in a system call
+   * Sol2.6: lwp is sleeping in a system call
+   * Sol2.7: lwp is sleeping in a system call
+   * IRIX6:  process is in an interruptible sleep
+   * OSF:    task/thread is asleep within a system call
+   * UW:     LWP is sleep()ing in a system call
+   */
+  { PR_ASLEEP, "PR_ASLEEP", "Sleeping in an (interruptible) system call" },
+#endif
+#if defined (PR_PCINVAL)
+  /* Sol2.5: contents of pr_instr undefined
+   * Sol2.6: contents of pr_instr undefined
+   * Sol2.7: contents of pr_instr undefined
+   * IRIX6:  current pc is invalid
+   * OSF:    program counter contains invalid address
+   * UW:     %pc refers to an invalid virtual address
+   */
+  { PR_PCINVAL, "PR_PCINVAL", "PC (pr_instr) is invalid" },
+#endif
+#if defined (PR_ASLWP)
+  /* Sol2.5: this lwp is the aslwp
+   * Sol2.6: this lwp is the aslwp
+   * Sol2.7: this lwp is the aslwp
+   */
+  { PR_ASLWP, "PR_ASLWP", "This is the asynchronous signal LWP" },
+#endif
+#if defined (PR_AGENT)
+  /* Sol2.6: this lwp is the /proc agent lwp
+   * Sol2.7: this lwp is the /proc agent lwp
+   */
+  { PR_AGENT, "PR_AGENT", "This is the /proc agent LWP" },
+#endif
+#if defined (PR_ISSYS)
+  /* Sol2.5: system process
+   * Sol2.6: this is a system process
+   * Sol2.7: this is a system process
+   * IRIX6:  process is a system process
+   * OSF:    task/thread is a system task/thread
+   * UW:     System process
+   */
+  { PR_ISSYS, "PR_ISSYS", "Is a system process/thread" },
+#endif
+#if defined (PR_VFORKP)
+  /* Sol2.6: process is the parent of a vfork()d child
+   * Sol2.7: process is the parent of a vfork()d child
+   */
+  { PR_VFORKP, "PR_VFORKP", "Process is the parent of a vforked child" },
+#endif
+#ifdef PR_ORPHAN
+  /* Sol2.6: process's process group is orphaned
+   * Sol2.7: process's process group is orphaned
+   */
+  { PR_ORPHAN, "PR_ORPHAN", "Process's process group is orphaned" },
+#endif
+#if defined (PR_FORK)
+  /* Sol2.5: inherit-on-fork is in effect
+   * Sol2.6: inherit-on-fork is in effect
+   * Sol2.7: inherit-on-fork is in effect
+   * IRIX6:  process has inherit-on-fork flag set
+   * OSF:    task/thread has inherit-on-fork flag set
+   * UW:     inherit-on-fork is in effect
+   */
+  { PR_FORK, "PR_FORK", "Inherit-on-fork is in effect" },
+#endif
+#if defined (PR_RLC)
+  /* Sol2.5: run-on-last-close is in effect
+   * Sol2.6: run-on-last-close is in effect
+   * Sol2.7: run-on-last-close is in effect
+   * IRIX6:  process has run-on-last-close flag set
+   * OSF:    task/thread has run-on-last-close flag set
+   * UW:     Run-on-last-close is in effect
+   */
+  { PR_RLC, "PR_RLC", "Run-on-last-close is in effect" },
+#endif
+#if defined (PR_KLC)
+  /* Sol2.5: kill-on-last-close is in effect
+   * Sol2.6: kill-on-last-close is in effect
+   * Sol2.7: kill-on-last-close is in effect
+   * IRIX6:  process has kill-on-last-close flag set
+   * OSF:    kill-on-last-close, superceeds RLC
+   * UW:     kill-on-last-close is in effect
+   */
+  { PR_KLC, "PR_KLC", "Kill-on-last-close is in effect" },
+#endif
+#if defined (PR_ASYNC)
+  /* Sol2.5: asynchronous-stop is in effect
+   * Sol2.6: asynchronous-stop is in effect
+   * Sol2.7: asynchronous-stop is in effect
+   * OSF:    asynchronous stop mode is in effect
+   * UW:     asynchronous stop mode is in effect
+   */
+  { PR_ASYNC, "PR_ASYNC", "Asynchronous stop is in effect" },
+#endif
+#if defined (PR_MSACCT)
+  /* Sol2.5: micro-state usage accounting is in effect
+   * Sol2.6: micro-state usage accounting is in effect
+   * Sol2.7: micro-state usage accounting is in effect
+   */
+  { PR_MSACCT, "PR_MSACCT", "Microstate accounting enabled" },
+#endif
+#if defined (PR_BPTADJ)
+  /* Sol2.5: breakpoint trap pc adjustment is in effect
+   * Sol2.6: breakpoint trap pc adjustment is in effect
+   * Sol2.7: breakpoint trap pc adjustment is in effect
+   */
+  { PR_BPTADJ, "PR_BPTADJ", "Breakpoint PC adjustment in effect" },
+#endif
+#if defined (PR_PTRACE)
+  /* Note: different meanings on Solaris and Irix 6
+   * Sol2.5: obsolete, never set in SunOS5.0
+   * Sol2.6: ptrace-compatibility mode is in effect
+   * Sol2.7: ptrace-compatibility mode is in effect
+   * IRIX6:  process is traced with ptrace() too
+   * OSF:    task/thread is being traced by ptrace
+   * UW:     Process is being controlled by ptrace(2)
+   */
+  { PR_PTRACE, "PR_PTRACE", "Process is being controlled by ptrace" },
+#endif
+#if defined (PR_PCOMPAT)
+  /* Note: PCOMPAT on Sol2.5 means same thing as PTRACE on Sol2.6
+   * Sol2.5 (only): ptrace-compatibility mode is in effect
+   */
+  { PR_PCOMPAT, "PR_PCOMPAT", "Ptrace compatibility mode in effect" },
+#endif
+#ifdef PR_MSFORK
+  /* Sol2.6: micro-state accounting inherited on fork
+   * Sol2.7: micro-state accounting inherited on fork
+   */
+  { PR_MSFORK, "PR_PCOMPAT", "Micro-state accounting inherited on fork" },
+#endif
+
+#ifdef PR_ISKTHREAD
+  /* Irix6: process is a kernel thread */
+  { PR_ISKTHREAD, "PR_KTHREAD", "Process is a kernel thread" },
+#endif
+
+#ifdef PR_ABORT
+  /* OSF (only): abort the current stop condition */
+  { PR_ABORT, "PR_ABORT", "Abort the current stop condition" },
+#endif
+
+#ifdef PR_TRACING
+  /* OSF: task is traced */
+  { PR_TRACING, "PR_TRACING", "Task is traced" },
+#endif
+
+#ifdef PR_STOPFORK
+  /* OSF: stop child on fork */
+  { PR_STOPFORK, "PR_STOPFORK", "Stop child on fork" },
+#endif
+
+#ifdef PR_STOPEXEC
+  /* OSF: stop on exec */
+  { PR_STOPEXEC, "PR_STOPEXEC", "Stop on exec" },
+#endif
+
+#ifdef PR_STOPTERM
+  /* OSF: stop on task exit */
+  { PR_STOPTERM, "PR_STOPTERM", "Stop on task exit" },
+#endif
+
+#ifdef PR_STOPTCR
+  /* OSF: stop on thread creation */
+  { PR_STOPTCR, "PR_STOPTCR", "Stop on thread creation" },
+#endif
+
+#ifdef PR_STOPTTERM
+  /* OSF: stop on thread exit */
+  { PR_STOPTTERM, "PR_STOPTTERM", "Stop on thread exit" },
+#endif
+
+#ifdef PR_USCHED
+  /* OSF: user level scheduling is in effect */
+  { PR_USCHED, "PR_USCHED", "User level scheduling is in effect" },
+#endif
+};
+
+void
+proc_prettyfprint_flags (file, flags, verbose)
+     FILE         *file;
+     unsigned long flags;
+     int           verbose;
+{
+  int i;
+
+  for (i = 0; i < sizeof (pr_flag_table) / sizeof (pr_flag_table[0]); i++)
+    if (flags & pr_flag_table[i].value)
+      {
+	fprintf (file, "%s ", pr_flag_table[i].name);
+	if (verbose)
+	  fprintf (file, "%s\n", pr_flag_table[i].desc);
+      }
+  if (!verbose)
+    fprintf (file, "\n");
+}
+
+void
+proc_prettyprint_flags (flags, verbose)
+     unsigned long flags;
+     int           verbose;
+{
+  proc_prettyfprint_flags (stdout, flags, verbose);
+}
diff --git a/gdb/proc-utils.h b/gdb/proc-utils.h
new file mode 100644
index 0000000..cdab0c3
--- /dev/null
+++ b/gdb/proc-utils.h
@@ -0,0 +1,52 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   Copyright 1999 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, 
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+extern void 
+proc_prettyprint_why (unsigned long why, unsigned long what, int verbose);
+
+extern void proc_prettyprint_syscalls (sysset_t *sysset, int verbose);
+
+extern void proc_prettyprint_syscall (int num, int verbose);
+
+extern void proc_prettyprint_flags (unsigned long flags, int verbose);
+
+extern void
+proc_prettyfprint_signalset (FILE *file, sigset_t *sigset, int verbose);
+
+extern void
+proc_prettyfprint_faultset (FILE *file, fltset_t *fltset, int verbose);
+
+extern void
+proc_prettyfprint_syscall (FILE *file, int num, int verbose);
+
+extern void
+proc_prettyfprint_signal (FILE *file, int signo, int verbose);
+
+extern void
+proc_prettyfprint_flags (FILE *file, unsigned long flags, int verbose);
+
+extern void
+proc_prettyfprint_why (FILE *file, unsigned long why, unsigned long what, int verbose);
+
+extern void
+proc_prettyfprint_fault (FILE *file, int faultno, int verbose);
+
+extern void
+proc_prettyfprint_syscalls (FILE *file, sysset_t *sysset, int verbose);
diff --git a/gdb/proc-why.c b/gdb/proc-why.c
new file mode 100644
index 0000000..958eeb4
--- /dev/null
+++ b/gdb/proc-why.c
@@ -0,0 +1,181 @@
+/* Machine independent support for SVR4 /proc (process file system) for GDB.
+   Copyright 1999 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
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, 
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/*
+ * Pretty-print the pr_why value.
+ * 
+ * Arguments: unsigned long flags, int verbose
+ *
+ */
+
+#include "defs.h"
+
+#if defined(NEW_PROC_API)
+#define _STRUCTURED_PROC 1
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/procfs.h>
+
+#include "proc-utils.h"
+
+/*  Much of the information used in the /proc interface, particularly for
+    printing status information, is kept as tables of structures of the
+    following form.  These tables can be used to map numeric values to
+    their symbolic names and to a string that describes their specific use. */
+
+struct trans {
+  int value;                    /* The numeric value */
+  char *name;                   /* The equivalent symbolic value */
+  char *desc;                   /* Short description of value */
+};
+
+/*  Translate values in the pr_why field of the prstatus struct. */
+
+static struct trans pr_why_table[] =
+{
+#if defined (PR_REQUESTED)
+  /* All platforms */
+  { PR_REQUESTED, "PR_REQUESTED", 
+    "Directed to stop by debugger via P(IO)CSTOP or P(IO)CWSTOP" },
+#endif
+#if defined (PR_SIGNALLED)
+  /* All platforms */
+  { PR_SIGNALLED, "PR_SIGNALLED", "Receipt of a traced signal" },
+#endif
+#if defined (PR_SYSENTRY)
+  /* All platforms */
+  { PR_SYSENTRY, "PR_SYSENTRY", "Entry to a traced system call" },
+#endif
+#if defined (PR_SYSEXIT)
+  /* All platforms */
+  { PR_SYSEXIT, "PR_SYSEXIT", "Exit from a traced system call" },
+#endif
+#if defined (PR_JOBCONTROL)
+  /* All platforms */
+  { PR_JOBCONTROL, "PR_JOBCONTROL", "Default job control stop signal action" },
+#endif
+#if defined (PR_FAULTED)
+  /* All platforms */
+  { PR_FAULTED, "PR_FAULTED", "Incurred a traced hardware fault" },
+#endif
+#if defined (PR_SUSPENDED)
+  /* Solaris and UnixWare */
+  { PR_SUSPENDED, "PR_SUSPENDED", "Process suspended" },
+#endif
+#if defined (PR_CHECKPOINT)
+  /* Solaris only */
+  { PR_CHECKPOINT, "PR_CHECKPOINT", "Process stopped at checkpoint" },
+#endif
+#if defined (PR_FORKSTOP)
+  /* OSF only */
+  { PR_FORKSTOP, "PR_FORKSTOP", "Process stopped at end of fork call" },
+#endif
+#if defined (PR_TCRSTOP)
+  /* OSF only */
+  { PR_TCRSTOP, "PR_TCRSTOP", "Process stopped on thread creation" },
+#endif
+#if defined (PR_TTSTOP)
+  /* OSF only */
+  { PR_TTSTOP, "PR_TTSTOP", "Process stopped on thread termination" },
+#endif
+#if defined (PR_DEAD)
+  /* OSF only */
+  { PR_DEAD, "PR_DEAD", "Process stopped in exit system call" },
+#endif
+};
+
+void
+proc_prettyfprint_why (file, why, what, verbose)
+     FILE         *file;
+     unsigned long why; 
+     unsigned long what; 
+     int           verbose;
+{
+  int i;
+
+  if (why == 0)
+    return;
+
+  for (i = 0; i < sizeof (pr_why_table) / sizeof (pr_why_table[0]); i++)
+    if (why == pr_why_table[i].value)
+      {
+	fprintf (file, "%s ", pr_why_table[i].name);
+	if (verbose)
+	  fprintf (file, ": %s ", pr_why_table[i].desc);
+
+	switch (why) {
+#ifdef PR_REQUESTED
+	case PR_REQUESTED:
+	  break;	/* Nothing more to print. */
+#endif
+#ifdef PR_SIGNALLED
+	case PR_SIGNALLED:
+	  proc_prettyfprint_signal (file, what, verbose);
+	  break;
+#endif
+#ifdef PR_FAULTED
+	case PR_FAULTED:
+	  proc_prettyfprint_fault (file, what, verbose);
+	  break;
+#endif
+#ifdef PR_SYSENTRY
+	case PR_SYSENTRY:
+	  fprintf (file, "Entry to ");
+	  proc_prettyfprint_syscall (file, what, verbose);
+	  break;
+#endif
+#ifdef PR_SYSEXIT
+	case PR_SYSEXIT:
+	  fprintf (file, "Exit from ");
+	  proc_prettyfprint_syscall (file, what, verbose);
+	  break;
+#endif
+#ifdef PR_JOBCONTROL
+	case PR_JOBCONTROL:
+	  proc_prettyfprint_signal (file, what, verbose);
+	  break;
+#endif
+#ifdef PR_DEAD
+	case PR_DEAD:
+	  fprintf (file, "Exit status: %d\n", what);
+	  break;
+#endif
+	default:
+	  fprintf (file, "Unknown why %ld, what %ld\n", why, what);
+	  break;
+	}
+	fprintf (file, "\n");
+
+	return;
+      }
+  fprintf (file, "Unknown pr_why.\n");
+}
+
+void
+proc_prettyprint_why (why, what, verbose)
+     unsigned long why; 
+     unsigned long what; 
+     int           verbose;
+{
+  proc_prettyfprint_why (stdout, why, what, verbose);
+}
diff --git a/gdb/procfs.c b/gdb/procfs.c
index d176386..920019f 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -24,6 +24,7 @@ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "target.h"
 #include "gdbcore.h"
 #include "gdbcmd.h"
+#include "gdbthread.h"
 
 #if defined (NEW_PROC_API)
 #define _STRUCTURED_PROC 1	/* Should be done by configure script. */
@@ -33,6 +34,11 @@ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include <sys/fault.h>
 #include <sys/syscall.h>
 #include <sys/errno.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <ctype.h>
+
+#include "proc-utils.h"
 
 /* 
  * PROCFS.C
@@ -403,11 +409,13 @@ find_procinfo_or_die (pid, tid)
   procinfo *pi = find_procinfo (pid, tid);
 
   if (pi == NULL)
-    if (tid)
-      error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.", 
-	     pid, tid);
-    else
-      error ("procfs: couldn't find pid %d in procinfo list.", pid);
+    {
+      if (tid)
+	error ("procfs: couldn't find pid %d (kernel thread %d) in procinfo list.", 
+	       pid, tid);
+      else
+	error ("procfs: couldn't find pid %d in procinfo list.", pid);
+    }
   return pi;
 }
 
@@ -431,7 +439,9 @@ open_procinfo_files (pi, which)
      procinfo *pi;
      int       which;
 {
+#ifdef NEW_PROC_API
   char tmp[MAX_PROC_NAME_SIZE];
+#endif
   int  fd;
 
   /* 
@@ -2627,11 +2637,14 @@ proc_iterate_over_mappings (func)
   struct prmap *map;
   procinfo *pi;
 #ifndef NEW_PROC_API	/* avoid compiler warning */
-  int nmaps = 0, i;
+  int nmaps = 0;
+  int i;
+#else
+  int map_fd;
+  char pathname[MAX_PROC_NAME_SIZE];
 #endif
   int funcstat = 0;
-  int fd, map_fd;
-  char pathname[MAX_PROC_NAME_SIZE];
+  int fd;
 
   pi = find_procinfo_or_die (PIDGET (inferior_pid), 0);
 
@@ -3762,9 +3775,9 @@ wait_again:
 		    if ((nsysargs = proc_nsysarg (pi)) > 0 &&
 			(sysargs  = proc_sysargs (pi)) != NULL)
 		      {
-			printf_filtered ("%d syscall arguments:\n", nsysargs);
+			printf_filtered ("%ld syscall arguments:\n", nsysargs);
 			for (i = 0; i < nsysargs; i++)
-			  printf_filtered ("#%d: 0x%08x\n", 
+			  printf_filtered ("#%ld: 0x%08x\n", 
 					   i, sysargs[i]);
 		      }
 
@@ -3876,9 +3889,9 @@ wait_again:
 		    if ((nsysargs = proc_nsysarg (pi)) > 0 &&
 			(sysargs  = proc_sysargs (pi)) != NULL)
 		      {
-			printf_filtered ("%d syscall arguments:\n", nsysargs);
+			printf_filtered ("%ld syscall arguments:\n", nsysargs);
 			for (i = 0; i < nsysargs; i++)
-			  printf_filtered ("#%d: 0x%08x\n", 
+			  printf_filtered ("#%ld: 0x%08x\n", 
 					   i, sysargs[i]);
 		      }
 		  }
@@ -4141,6 +4154,7 @@ invalidate_cache (parent, pi, ptr)
   return 0;
 }
 
+#if 0
 /*
  * Function: make_signal_thread_runnable
  *
@@ -4165,6 +4179,7 @@ make_signal_thread_runnable (process, pi, ptr)
 #endif
   return 0;
 }
+#endif
 
 /*
  * Function: target_resume
@@ -4216,7 +4231,7 @@ procfs_resume (pid, step, signo)
 
   /* Convert signal to host numbering.  */
   if (signo == 0 ||
-      signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop)
+      (signo == TARGET_SIGNAL_STOP && pi->ignore_next_sigstop))
     native_signo = 0;
   else
     native_signo = target_signal_to_host (signo);
@@ -4603,7 +4618,6 @@ procfs_set_exec_trap ()
 
   procinfo *pi;
   sysset_t exitset;
-  sysset_t entryset;
 
   if ((pi = create_procinfo (getpid (), 0)) == NULL)
     perror_with_name ("procfs: create_procinfo failed in child.");
@@ -5027,11 +5041,12 @@ info_proc_cmd (args, from_tty)
 
   old_chain = make_cleanup (null_cleanup, 0);
   if (args)
-    if ((argv = buildargv (args)) == NULL)
-      nomem (0);
-    else
-      make_cleanup ((make_cleanup_func) freeargv, argv);
-
+    {
+      if ((argv = buildargv (args)) == NULL)
+	nomem (0);
+      else
+	make_cleanup ((make_cleanup_func) freeargv, argv);
+    }
   while (argv != NULL && *argv != NULL)
     {
       if (isdigit (argv[0][0]))
diff --git a/gdb/rdi-share/devsw.c b/gdb/rdi-share/devsw.c
index ea666a1..58c0bfe 100644
--- a/gdb/rdi-share/devsw.c
+++ b/gdb/rdi-share/devsw.c
@@ -15,6 +15,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <fcntl.h>
 
 #include "adp.h"
 #include "sys.h"
@@ -48,9 +49,14 @@ static void openLogFile ()
       perror ("fopen");
     }
   else
-    /* The following line is equivalent to: */
-    /* setlinebuf (angelDebugLogFile); */
-    setvbuf(angelDebugLogFile, (char *)NULL, _IOLBF, 0);
+    {
+      /* The following line is equivalent to: */
+      /* setlinebuf (angelDebugLogFile); */
+      setvbuf(angelDebugLogFile, (char *)NULL, _IOLBF, 0);
+#if defined(__CYGWIN32__) || defined(__CYGWIN__)
+      setmode(fileno(angelDebugLogFile), O_TEXT);
+#endif
+    }
   
   time (&t);
   fprintf (angelDebugLogFile,"ADP log file opened at %s\n",asctime(localtime(&t)));
diff --git a/gdb/utils.c b/gdb/utils.c
index 596c0ae..ab790d9 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -3203,12 +3203,31 @@ get_field (data, order, total_len, start, len)
   int cur_bitshift;
 
   /* Start at the least significant part of the field.  */
-  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
   if (order == floatformat_little || order == floatformat_littlebyte_bigword)
-    cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
-  cur_bitshift =
-    ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
-  result = *(data + cur_byte) >> (-cur_bitshift);
+    {
+      /* We start counting from the other end (i.e, from the high bytes
+	 rather than the low bytes).  As such, we need to be concerned
+	 with what happens if bit 0 doesn't start on a byte boundary. 
+	 I.e, we need to properly handle the case where total_len is
+	 not evenly divisible by 8.  So we compute ``excess'' which
+	 represents the number of bits from the end of our starting
+	 byte needed to get to bit 0. */
+      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
+      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
+                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
+      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 
+                     - FLOATFORMAT_CHAR_BIT;
+    }
+  else
+    {
+      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
+      cur_bitshift =
+	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
+    }
+  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
+    result = *(data + cur_byte) >> (-cur_bitshift);
+  else
+    result = 0;
   cur_bitshift += FLOATFORMAT_CHAR_BIT;
   if (order == floatformat_little || order == floatformat_littlebyte_bigword)
     ++cur_byte;
@@ -3218,20 +3237,16 @@ get_field (data, order, total_len, start, len)
   /* Move towards the most significant part of the field.  */
   while (cur_bitshift < len)
     {
-      if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
-	/* This is the last byte; zero out the bits which are not part of
-	   this field.  */
-	result |=
-	  (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
-	  << cur_bitshift;
-      else
-	result |= *(data + cur_byte) << cur_bitshift;
+      result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
       cur_bitshift += FLOATFORMAT_CHAR_BIT;
       if (order == floatformat_little || order == floatformat_littlebyte_bigword)
 	++cur_byte;
       else
 	--cur_byte;
     }
+  if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
+    /* Mask out bits which are not part of the field */
+    result &= ((1UL << len) - 1);
   return result;
 }
 
@@ -3368,15 +3383,28 @@ put_field (data, order, total_len, start, len, stuff_to_put)
   int cur_bitshift;
 
   /* Start at the least significant part of the field.  */
-  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
   if (order == floatformat_little || order == floatformat_littlebyte_bigword)
-    cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
-  cur_bitshift =
-    ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
-  *(data + cur_byte) &=
-    ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
-  *(data + cur_byte) |=
-    (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
+    {
+      int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
+      cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
+                 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
+      cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 
+                     - FLOATFORMAT_CHAR_BIT;
+    }
+  else
+    {
+      cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
+      cur_bitshift =
+	((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
+    }
+  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
+    {
+      *(data + cur_byte) &=
+	~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
+	  << (-cur_bitshift));
+      *(data + cur_byte) |=
+	(stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
+    }
   cur_bitshift += FLOATFORMAT_CHAR_BIT;
   if (order == floatformat_little || order == floatformat_littlebyte_bigword)
     ++cur_byte;