gdb-2.4+.aux.coff

118 files changed, 48217 insertions, 0 deletions

diff --git a/gdb/=emacs b/gdb/=emacs
new file mode 100644
index 0000000..74097b7
--- /dev/null
+++ b/gdb/=emacs
@@ -0,0 +1,108 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; gdb code changes
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+/*
+ * Core Problem:  when gdb says something like (../src/file.c 1234), the
+ * real file might be in any of the active dirs in use by gdb and thus
+ * emacs can not always find the file at "../src".  Emacs cannot just
+ * scan for GDB dir commands because these might be given in the .gdbinit
+ * file or other scripts.  The only solution is to have gdb be a bit more
+ * specific when it prints file names.
+ * 
+ * Remaining defects:
+ * 
+ * 1. Do I really have to open the file to find out if it exists?
+ *    There should be a faster way.
+ * 
+ * 2. Should there be a bdb command to toggle between short and absolute
+ * forms of the file name?
+ */
+
+
+/* Add this to ~emacs/gdb/source.c after the openp function */
+
+char *
+get_absolute_filename(table)
+/* Added by Lynn Slater, Silvar-Lisco 10/6/87
+   returns the address of the best possible name to use for the file
+   in the passed symtab.  Returns the filename if the path cannot be
+   resolved.
+   Please remember to free the absolute name after use.*/
+struct symtab *table;
+{
+  register int desc;
+  char *absolute_name;
+
+  desc = openp (source_path, 0, table->filename, O_RDONLY, 0, &absolute_name);
+  if (desc < 0)
+    return( savestring(table->filename, strlen(table->filename)));
+
+  close (desc);
+  return(absolute_name);
+}
+
+/* Replace this fcn in ~emacs/gdb/stack.c */
+void
+print_frame_info (fi, level, source, args)
+     struct frame_info *fi;
+     register int level;
+     int source;
+     int args;
+{
+  register FRAME frame = fi->frame;
+  struct symtab_and_line sal;
+  struct symbol *func;
+  register char *funname = 0;
+  int numargs;
+
+  sal = find_pc_line (fi->pc, fi->next_frame);
+  func = get_frame_function (frame);
+  if (func)
+    funname = SYMBOL_NAME (func);
+  else
+    {
+      register int misc_index = find_pc_misc_function (fi->pc);
+      if (misc_index >= 0)
+	funname = misc_function_vector[misc_index].name;
+    }
+
+  if (source >= 0 || !sal.symtab)
+    {
+      /* This avoids a bug in cc on the sun.  */
+      struct frame_info tem;
+      tem = *fi;
+
+      if (level >= 0)
+	printf ("#%-2d ", level);
+      if (fi->pc != sal.pc || !sal.symtab)
+	printf ("0x%x in ", fi->pc);
+      printf ("%s (", funname ? funname : "??");
+      if (args)
+        {
+	  FRAME_NUM_ARGS (numargs, tem);
+	  print_frame_args (func, FRAME_ARGS_ADDRESS (tem), numargs, stdout);
+	}
+      printf (")");
+      if (sal.symtab)
+        {
+	  char * absolute_filename;
+	  absolute_filename = (char *) get_absolute_filename(sal.symtab);
+	  printf (" (%s line %d)", absolute_filename, sal.line);
+	  free(absolute_filename);
+	}
+      printf ("\n");
+    }
+
+  if (source != 0 && sal.symtab)
+    {
+      if (source < 0 && fi->pc != sal.pc)
+	printf ("0x%x\t", fi->pc);
+      print_source_lines (sal.symtab, sal.line, sal.line + 1);
+      current_source_line = max (sal.line - 5, 1);
+    }
+  if (source != 0)
+    set_default_breakpoint (1, fi->pc, sal.symtab, sal.line);
+
+  fflush (stdout);
+}
+
diff --git a/gdb/=news b/gdb/=news
new file mode 100644
index 0000000..43de9bc
--- /dev/null
+++ b/gdb/=news
@@ -0,0 +1,136 @@
+===================================================================
+RCS file: RCS/printcmd.c,v
+retrieving revision 1.1
+diff -c3 -r1.1 printcmd.c
+*** /tmp/,RCSt1011248	Tue Jan 12 14:06:06 1988
+--- printcmd.c	Mon Sep 21 21:33:39 1987
+***************
+*** 174,179
+  	VALUE_TYPE (val) = builtin_type_float;
+        if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
+  	VALUE_TYPE (val) = builtin_type_double;
+        printf ("%g", value_as_double (val));
+        break;
+  
+
+--- 174,185 -----
+  	VALUE_TYPE (val) = builtin_type_float;
+        if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
+  	VALUE_TYPE (val) = builtin_type_double;
++ #ifdef PRINTF_BUG
++       if (is_nan(value_as_double (val)))
++       printf ("Nan");
++       else
++         printf ("%g", value_as_double (val));
++ #else
+        printf ("%g", value_as_double (val));
+  #endif
+        break;
+***************
+*** 175,180
+        if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
+  	VALUE_TYPE (val) = builtin_type_double;
+        printf ("%g", value_as_double (val));
+        break;
+  
+      case 0:
+
+--- 181,187 -----
+          printf ("%g", value_as_double (val));
+  #else
+        printf ("%g", value_as_double (val));
++ #endif
+        break;
+  
+      case 0:
+===================================================================
+RCS file: RCS/valprint.c,v
+retrieving revision 1.1
+diff -c3 -r1.1 valprint.c
+*** /tmp/,RCSt1011248	Tue Jan 12 14:06:09 1988
+--- valprint.c	Mon Sep 21 21:35:45 1987
+***************
+*** 21,26
+  #include <stdio.h>
+  #include "defs.h"
+  #include "initialize.h"
+  #include "symtab.h"
+  #include "value.h"
+  
+
+--- 21,27 -----
+  #include <stdio.h>
+  #include "defs.h"
+  #include "initialize.h"
++ #include "param.h"
+  #include "symtab.h"
+  #include "value.h"
+  
+***************
+*** 249,255
+        break;
+  
+      case TYPE_CODE_FLT:
+!       fprintf (stream, "%g", unpack_double (type, valaddr));
+        break;
+  
+      case TYPE_CODE_VOID:
+
+--- 250,265 -----
+        break;
+  
+      case TYPE_CODE_FLT:
+!       { double d = unpack_double (type, valaddr);
+! #ifdef PRINTF_BUG
+! 	if (is_nan(d))
+! 	    fprintf (stream, "Nan");
+! 	else
+! 	    fprintf (stream, "%g", d);
+! #else
+! 	fprintf (stream, "%g", d);
+! #endif
+!       }
+        break;
+  
+      case TYPE_CODE_VOID:
+***************
+*** 559,563
+    float_type_table[sizeof (float)] = "float";
+    float_type_table[sizeof (double)] = "double";
+  }
+  
+  END_FILE
+
+--- 569,599 -----
+    float_type_table[sizeof (float)] = "float";
+    float_type_table[sizeof (double)] = "double";
+  }
++ 
++ 
++ #ifdef PRINTF_BUG
++ 
++ struct ieee {                         /* IEEE floating format */
++   unsigned int s:1;
++   unsigned int e:11;
++   unsigned int f1:20;
++   unsigned int f2;
++ };
++ 
++ #define ZERO_F(x)  ((x.f1 == 0) && (x.f2 == 0))     /* zero fraction ? */
++ #define ZERO_E(x)  (x.e == 0)                       /* zero exponential ? */
++ #define MAX_E(x)   (x.e == 0x7ff)                   /* max exponential ? */
++ #define MINUS_S(x) (x.s == 1)                       /* minus ? */
++ 
++ int
++ is_nan(arg)                            /* Not a Number ? */
++ struct ieee arg;
++ {
++   if (MAX_E(arg) && !ZERO_F(arg))
++     return (1);
++   else
++     return (0);
++ }
++ #endif
+  
+  END_FILE
+
diff --git a/gdb/=ns32k.msg b/gdb/=ns32k.msg
new file mode 100644
index 0000000..5268fc7
--- /dev/null
+++ b/gdb/=ns32k.msg
@@ -0,0 +1,1182 @@
+From uwvax!sequent!ogcvax!reed!keith@RUTGERS.EDU Thu Jul 23 21:46:44 1987
+Received: by PREP.AI.MIT.EDU; Thu, 23 Jul 87 21:44:35 EDT
+Received: by RUTGERS.EDU (5.54/1.14) with UUCP 
+	id AA04584; Thu, 23 Jul 87 21:42:33 EDT
+Received: from sequent.UUCP by spool.WISC.EDU; Thu, 23 Jul 87 20:36:20 CDT
+Received: from reed.UUCP by ogcvax.OGC.EDU (5.51/OGC_4.6+)
+		id AA05332; Thu, 23 Jul 87 13:31:52 PDT
+Received: by reed.UUCP (5.51/5.17)
+	id AA23265; Thu, 23 Jul 87 11:19:20 PDT
+From: uwvax!sequent!ogcvax!reed!keith@RUTGERS.EDU (Keith Packard)
+Message-Id: <8707231819.AA23265@reed.UUCP>
+To: phr@prep.ai.mit.edu (Paul Rubin)
+Subject: Re: gdb 
+In-Reply-To: Your message of Thu, 23 Jul 87 02:06:52 EDT.
+             <8707230603.AA11722@EDDIE.MIT.EDU> 
+Date: Thu, 23 Jul 87 11:19:13 PDT
+Status: R
+
+
+Thanks much for the address -- the 2.1 sources that I have do not contain
+any bug reporting address.  The only real bug that I found was in
+write_register_bytes in findvar.c:
+
+was:
+
+  bcopy (myaddr, &registers[regbyte], len);
+  if (have_inferior_p ())
+    store_inferior_registers (0);
+
+should be:
+
+  bcopy (myaddr, &registers[regbyte], len);
+  if (have_inferior_p ())
+    store_inferior_registers (-1);
+
+Other than that, most of the porting effort to the 32k was in removing
+references to alloca - the 32k is adamant about not using alloca -- in fact
+someone at tektronix wrote a replacement which accepted another argument
+pointing to the function entry instruction so that the stack could be maimed
+mercilessly...  I just replaced them all with malloc and used free at
+judicious times.  It's not perfect but it worked fine.
+
+I would upload gdb 2.3 if I could, however I am not on the arpa net.  I'll
+probably end up sending GNU a tape.
+
+It's a great debugger, thanks!
+
+	keith packard
+	tektronix!reed!keith
+
+Here are the param files and instruction printer for the 32032:
+
+#!/bin/sh
+# shar:	Shell Archiver
+#	Run the following text with /bin/sh to create:
+#	m-merlin.h
+#	n32k-opcode.h
+#	n32k-pinsn.c
+sed 's/^X//' << 'SHAR_EOF' > m-merlin.h
+X/* Definitions to make GDB run on a merlin under utek 2.1
+X   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+X
+XGDB is distributed in the hope that it will be useful, but WITHOUT ANY
+XWARRANTY.  No author or distributor accepts responsibility to anyone
+Xfor the consequences of using it or for whether it serves any
+Xparticular purpose or works at all, unless he says so in writing.
+XRefer to the GDB General Public License for full details.
+X
+XEveryone is granted permission to copy, modify and redistribute GDB,
+Xbut only under the conditions described in the GDB General Public
+XLicense.  A copy of this license is supposed to have been given to you
+Xalong with GDB so you can know your rights and responsibilities.  It
+Xshould be in a file named COPYING.  Among other things, the copyright
+Xnotice and this notice must be preserved on all copies.
+X
+XIn other words, go ahead and share GDB, but don't try to stop
+Xanyone else from sharing it farther.  Help stamp out software hoarding!
+X*/
+X
+X#ifndef ns16000
+X#define ns16000
+X#endif
+X
+X# include	<machine/reg.h>
+X
+X/* Define this if the C compiler puts an underscore at the front
+X   of external names before giving them to the linker.  */
+X
+X#define NAMES_HAVE_UNDERSCORE
+X
+X/* Offset from address of function to start of its code.
+X   Zero on most machines.  */
+X
+X#define FUNCTION_START_OFFSET 0
+X
+X/* Advance PC across any function entry prologue instructions
+X   to reach some "real" code.  */
+X
+X#define SKIP_PROLOGUE(pc)   				\
+X{ register int op = read_memory_integer (pc, 1);	\
+X  if (op == 0x82) { op = read_memory_integer (pc+2,1);  \
+X  		    if ((op & 0x80) == 0) pc += 3;	\
+X		    else if ((op & 0xc0) == 0x80) pc += 4;	\
+X		    else pc += 6;			\
+X		   }					\
+X}
+X
+X/* Immediately after a function call, return the saved pc.
+X   Can't always go through the frames for this because on some machines
+X   the new frame is not set up until the new function executes
+X   some instructions.  */
+X
+X#define SAVED_PC_AFTER_CALL(frame) \
+X	read_memory_integer (read_register (SP_REGNUM), 4)
+X
+X/* This is the amount to subtract from u.u_ar0
+X   to get the offset in the core file of the register values.  */
+X
+X#define KERNEL_U_ADDR (0xfef000)
+X
+X/* Address of end of stack space.  */
+X
+X#define STACK_END_ADDR (0x800000)
+X
+X/* Stack grows downward.  */
+X
+X#define INNER_THAN <
+X
+X/* Sequence of bytes for breakpoint instruction.  */
+X
+X#define BREAKPOINT {0xf2}
+X
+X/* Amount PC must be decremented by after a breakpoint.
+X   This is often the number of bytes in BREAKPOINT
+X   but not always.  */
+X
+X#define DECR_PC_AFTER_BREAK 0
+X
+X/* Nonzero if instruction at PC is a return instruction.  */
+X
+X#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
+X
+X/* Return 1 if P points to an invalid floating point value.  */
+X
+X#define INVALID_FLOAT(p) (0)
+X
+X/* Say how long (ordinary) registers are.  */
+X
+X#define REGISTER_TYPE long
+X
+X/* Number of machine registers */
+X
+X#define NUM_REGS		25
+X
+X#define NUM_GENERAL_REGS	8
+X
+X/* Initializer for an array of names of registers.
+X   There should be NUM_REGS strings in this initializer.  */
+X
+X#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",	\
+X			"pc", "sp", "fp", "ps",				\
+X 			"fsr",						\
+X 			"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",	\
+X			"l0", "l1", "l2", "l3", "l4",			\
+X 			}
+X
+X/* Register numbers of various important registers.
+X   Note that some of these values are "real" register numbers,
+X   and correspond to the general registers of the machine,
+X   and some are "phony" register numbers which are too large
+X   to be actual register numbers as far as the user is concerned
+X   but do serve to get the desired values when passed to read_register.  */
+X
+X#define AP_REGNUM FP_REGNUM
+X#define FP_REGNUM 10		/* Contains address of executing stack frame */
+X#define SP_REGNUM 9		/* Contains address of top of stack */
+X#define PC_REGNUM 8		/* Contains program counter */
+X#define PS_REGNUM 11		/* Contains processor status */
+X#define FPS_REGNUM 12		/* Floating point status register */
+X#define FP0_REGNUM 13		/* Floating point register 0 */
+X#define LP0_REGNUM 21		/* Double register 0 (same as FP0) */
+X
+X#define REGISTER_U_ADDR(addr, blockend, regno) \
+X{ 									\
+X  switch (regno) {							\
+X  case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:	\
+X	addr = blockend + (R0 - regno) * sizeof (int); break;		\
+X  case PC_REGNUM:							\
+X  	addr = blockend + PC * sizeof (int); break;			\
+X  case SP_REGNUM:							\
+X  	addr = blockend + SP * sizeof (int); break;			\
+X  case FP_REGNUM:							\
+X  	addr = blockend + FP * sizeof (int); break;			\
+X  case PS_REGNUM:							\
+X  	addr = blockend + 12 * sizeof (int); break;			\
+X  case FPS_REGNUM:							\
+X  	addr = 108; break;						\
+X  case FP0_REGNUM + 0: case FP0_REGNUM + 1:				\
+X  case FP0_REGNUM + 2: case FP0_REGNUM + 3: 				\
+X  case FP0_REGNUM + 4: case FP0_REGNUM + 5: 				\
+X  case FP0_REGNUM + 6: case FP0_REGNUM + 7: 				\
+X  	addr = 76 + (regno - FP0_REGNUM) * sizeof (float); break;	\
+X  case LP0_REGNUM + 0: case LP0_REGNUM + 1:				\
+X  case LP0_REGNUM + 2: case LP0_REGNUM + 3:				\
+X  	addr = 76 + (regno - LP0_REGNUM) * sizeof (double); break;	\
+X  default:								\
+X  	printf ("bad argument to REGISTER_U_ADDR %d\n", regno);		\
+X	abort ();							\
+X  }									\
+X}
+X
+X/* Total amount of space needed to store our copies of the machine's
+X   register state, the array `registers'.  */
+X#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
+X
+X/* Index within `registers' of the first byte of the space for
+X   register N.  */
+X
+X#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
+X	LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
+X
+X/* Number of bytes of storage in the actual machine representation
+X   for register N.  On the 32000, all regs are 4 bytes
+X   except for the doubled floating registers. */
+X
+X#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+X
+X/* Number of bytes of storage in the program's representation
+X   for register N.  On the 32000, all regs are 4 bytes
+X   except for the doubled floating registers. */
+X
+X#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+X
+X/* Largest value REGISTER_RAW_SIZE can have.  */
+X
+X#define MAX_REGISTER_RAW_SIZE 8
+X
+X/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+X
+X#define MAX_REGISTER_VIRTUAL_SIZE 8
+X
+X/* Nonzero if register N requires conversion
+X   from raw format to virtual format.  */
+X
+X#define REGISTER_CONVERTIBLE(N) 0
+X
+X/* Convert data from raw format for register REGNUM
+X   to virtual format for register REGNUM.  */
+X
+X#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+X  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+X
+X/* Convert data from virtual format for register REGNUM
+X   to raw format for register REGNUM.  */
+X
+X#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+X  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+X
+X/* Return the GDB type object for the "standard" data type
+X   of data in register N.  */
+X
+X#define REGISTER_VIRTUAL_TYPE(N) \
+X	((N) >= FP0_REGNUM ?			\
+X 		(N) >= LP0_REGNUM ?		\
+X 			builtin_type_double	\
+X		 	: builtin_type_float	\
+X 		: builtin_type_int)	
+X
+X/* Describe the pointer in each stack frame to the previous stack frame
+X   (its caller).  */
+X
+X/* FRAME_CHAIN takes a frame's nominal address
+X   and produces the frame's chain-pointer.
+X
+X   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+X   and produces the nominal address of the caller frame.
+X
+X   However, if FRAME_CHAIN_VALID returns zero,
+X   it means the given frame is the outermost one and has no caller.
+X   In that case, FRAME_CHAIN_COMBINE is not used.  */
+X
+X/* In the case of the Merlin, the frame's nominal address is the FP value,
+X   and at that address is saved previous FP value as a 4-byte word.  */
+X
+X#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+X
+X#define FRAME_CHAIN_VALID(chain, thisframe) \
+X  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+X
+X#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+X
+X/* Define other aspects of the stack frame.  */
+X
+X#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+X
+X/* compute base of arguments */
+X#define FRAME_ARGS_ADDRESS(fi) ((fi).frame)
+X
+X#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
+X
+X/* Return number of args passed to a frame.
+X   Can return -1, meaning no way to tell.  */
+X
+X#define FRAME_NUM_ARGS(numargs, fi)				\
+X{	CORE_ADDR pc;						\
+X	int insn;						\
+X	int addr_mode;						\
+X	int width;						\
+X								\
+X	pc = FRAME_SAVED_PC (fi.frame);				\
+X 	insn = read_memory_integer (pc,2);			\
+X	addr_mode = (insn >> 11) & 0x1f;			\
+X	insn = insn & 0x7ff;					\
+X	if ((insn & 0x7fc) == 0x57c &&				\
+X	    addr_mode == 0x14) { /* immediate */		\
+X		if (insn == 0x57c) /* adjspb */			\
+X			width = 1;				\
+X		else if (insn == 0x57d) /* adjspw */		\
+X			width = 2;				\
+X		else if (insn == 0x57f) /* adjspd */		\
+X			width = 4;				\
+X		numargs = read_memory_integer (pc+2,width);	\
+X		if (width > 1)					\
+X			flip_bytes (&numargs, width);		\
+X		numargs = - sign_extend (numargs, width*8) / 4;	\
+X	} else {						\
+X	 	numargs = -1;					\
+X	}							\
+X}
+X
+X/* Return number of bytes at start of arglist that are not really args.  */
+X
+X#define FRAME_ARGS_SKIP 8
+X
+X/* Put here the code to store, into a struct frame_saved_regs,
+X   the addresses of the saved registers of frame described by FRAME_INFO.
+X   This includes special registers such as pc and fp saved in special
+X   ways in the stack frame.  sp is even more special:
+X   the address we return for it IS the sp for the next frame.  */
+X
+X#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+X{ 								\
+X	int	regmask,regnum;					\
+X	int	localcount;					\
+X	CORE_ADDR	enter_addr;				\
+X	CORE_ADDR	next_addr;				\
+X								\
+X	enter_addr = get_pc_function_start ((frame_info).pc);	\
+X	regmask = read_memory_integer (enter_addr+1, 1);	\
+X	localcount = n32k_localcount (enter_addr);		\
+X	next_addr = (frame_info).frame + localcount;		\
+X	for (regnum = 0; regnum < 8; regnum++, regmask >>= 1)	\
+X		(frame_saved_regs).regs[regnum] = (regmask & 1) ?	\
+X				(next_addr -= 4) : 0;		\
+X	(frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4;	\
+X	(frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;	\
+X	(frame_saved_regs).regs[FP_REGNUM] = (read_memory_integer	\
+X					((frame_info).frame, 4));	\
+X}
+X
+X/* Things needed for making the inferior call functions.  */
+X
+X/* Push an empty stack frame, to record the current PC, etc.  */
+X
+X#define PUSH_DUMMY_FRAME \
+X{ register CORE_ADDR sp = read_register (SP_REGNUM);\
+X  register int regnum;				    \
+X  sp = push_word (sp, read_register (PC_REGNUM));   \
+X  sp = push_word (sp, read_register (FP_REGNUM));   \
+X  write_register (FP_REGNUM, sp);		    \
+X  for (regnum = 0; regnum < 8; regnum++)  \
+X    sp = push_word (sp, read_register (regnum));    \
+X  write_register (SP_REGNUM, sp);  			\
+X}
+X
+X/* Discard from the stack the innermost frame, restoring all registers.  */
+X
+X#define POP_FRAME  \
+X{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+X  register int regnum;						 \
+X  struct frame_saved_regs fsr;					 \
+X  struct frame_info fi;						 \
+X  fi = get_frame_info (fp);					 \
+X  get_frame_saved_regs (&fi, &fsr);				 \
+X  for (regnum = 0; regnum < 8; regnum++)			 \
+X    if (fsr.regs[regnum])					 \
+X      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+X  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+X  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+X  write_register (SP_REGNUM, fp + 8);				 \
+X}
+X
+X/* This sequence of words is the instructions
+X     enter	0xff,0		82 ff 00
+X     jsr	@0x00010203	7f ae c0 01 02 03
+X     adjspd	0x69696969	7f a5 01 02 03 04
+X     bpt			f2
+X   Note this is 16 bytes.  */
+X
+X#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
+X
+X#define CALL_DUMMY_START_OFFSET	3
+X#define CALL_DUMMY_LENGTH	16
+X#define CALL_DUMMY_ADDR		5
+X#define CALL_DUMMY_NARGS	11
+X
+X/* Insert the specified number of args and function address
+X   into a call sequence of the above form stored at DUMMYNAME.  */
+X
+X#define FIX_CALL_DUMMY(dummyname, fun, nargs)   		\
+X{								\
+X	int	flipped;					\
+X	flipped = fun | 0xc0000000;				\
+X	flip_bytes (&flipped, 4);				\
+X	*((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped;	\
+X	flipped = - nargs * 4;					\
+X	flip_bytes (&flipped, 4);				\
+X	*((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped;	\
+X}
+X
+X#ifdef notdef
+X/* Interface definitions for kernel debugger KDB.  */
+X
+X/* Map machine fault codes into signal numbers.
+X   First subtract 0, divide by 4, then index in a table.
+X   Faults for which the entry in this table is 0
+X   are not handled by KDB; the program's own trap handler
+X   gets to handle then.  */
+X
+X#define FAULT_CODE_ORIGIN 0
+X#define FAULT_CODE_UNITS 4
+X#define FAULT_TABLE    \
+X{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \
+X  0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \
+X  0, 0, 0, 0, 0, 0, 0, 0}
+X
+X/* Start running with a stack stretching from BEG to END.
+X   BEG and END should be symbols meaningful to the assembler.
+X   This is used only for kdb.  */
+X
+X#define INIT_STACK(beg, end)  \
+X{ asm (".globl end");         \
+X  asm ("movl $ end, sp");      \
+X  asm ("clrl fp"); }
+X
+X/* Push the frame pointer register on the stack.  */
+X#define PUSH_FRAME_PTR        \
+X  asm ("pushl fp");
+X
+X/* Copy the top-of-stack to the frame pointer register.  */
+X#define POP_FRAME_PTR  \
+X  asm ("movl (sp), fp");
+X
+X/* After KDB is entered by a fault, push all registers
+X   that GDB thinks about (all NUM_REGS of them),
+X   so that they appear in order of ascending GDB register number.
+X   The fault code will be on the stack beyond the last register.  */
+X
+X#define PUSH_REGISTERS        \
+X{ asm ("pushl 8(sp)");        \
+X  asm ("pushl 8(sp)");        \
+X  asm ("pushal 0x14(sp)");    \
+X  asm ("pushr $037777"); }
+X
+X/* Assuming the registers (including processor status) have been
+X   pushed on the stack in order of ascending GDB register number,
+X   restore them and return to the address in the saved PC register.  */
+X
+X#define POP_REGISTERS      \
+X{ asm ("popr $037777");    \
+X  asm ("subl2 $8,(sp)");   \
+X  asm ("movl (sp),sp");    \
+X  asm ("rei"); }
+X#endif
+SHAR_EOF
+sed 's/^X//' << 'SHAR_EOF' > n32k-opcode.h
+X/* n32k-opcode.h */
+X
+X#ifndef n32k_opcodeT
+X#define n32k_opcodeT int
+X#endif /* no n32k_opcodeT */
+X
+Xstruct not_wot			/* n32k opcode table: wot to do with this */
+X				/* particular opcode */
+X{
+X	int		obits;	/* number of opcode bits */
+X	int		ibits;	/* number of instruction bits */
+X  	n32k_opcodeT	code;	/* op-code (may be > 8 bits!) */
+X	char 		*args;	/* how to compile said opcode */
+X};
+X
+Xstruct not			/* n32k opcode text */
+X{
+X  char *            name;	/* opcode name: lowercase string  [key]  */
+X  struct not_wot    detail;	/* rest of opcode table          [datum] */
+X};
+X
+X/* F : 32 bit float
+X * L : 64 bit float
+X * B : byte
+X * W : word
+X * D : double-word
+X * Q : quad-word
+X * d : displacement
+X * q : quick
+X * i : immediate (8 bits)
+X * r : register number (3 bits)
+X * p : displacement - pc relative addressing
+X*/
+Xstatic struct not
+Xnotstrs[] =
+X{
+X{ "absf",	14,24,	0x35be,	"1F2F" },
+X{ "absl",	14,24,	0x34be,	"1L2L" },
+X{ "absb",	14,24,	0x304e, "1B2B" },
+X{ "absw",	14,24,	0x314e, "1W2W" },
+X{ "absd",	14,24,	0x334e, "1D2D" },
+X{ "acbb",	 7,16,	0x4c,	"2B1q3p" },
+X{ "addf",	14,24,	0x01be,	"1F2F" },
+X{ "addl",	14,24,	0x00be, "1L2L" },
+X{ "addb",	 6,16,	0x00,	"1B2B" },
+X{ "addw",	 6,16,	0x01,	"1W2W" },
+X{ "addd",	 6,16,	0x03,	"1D2D" },
+X{ "addcb",	 6,16,	0x10,	"1B2B" },
+X{ "addcw",	 6,16,	0x11,	"1W2W" },
+X{ "addcd",	 6,16,	0x13,	"1D2D" },
+X{ "addpb",	14,24,	0x3c4e,	"1B2B" },
+X{ "addpw",	14,24,	0x3d4e,	"1W2W" },
+X{ "addpd",	14,24,	0x3f4e,	"1D2D" },
+X{ "addqb",	 7,16,	0x0c,	"2B1q" },
+X{ "addqw",	 7,16,	0x0d,	"2W1q" },
+X{ "addqd",	 7,16,	0x0f,	"2D1q" },
+X{ "addr",	 6,16,	0x27,	"1D2D" },
+X{ "adjspb",	11,16,	0x057c,	"1B" },
+X{ "adjspw",	11,16,	0x057d,	"1W" },
+X{ "adjspd",	11,16,	0x057f,	"1D" },
+X{ "andb",	 6,16,	0x28,	"1B2B" },
+X{ "andw",	 6,16,	0x29,	"1W2W" },
+X{ "andd",	 6,16,	0x2b,	"1D2D" },
+X{ "ashb",	14,24,	0x044e,	"1B2B" },
+X{ "ashw",	14,24,	0x054e,	"1B2W" },
+X{ "ashd",	14,24,	0x074e,	"1B2D" },
+X{ "beq",	 8,8,	0x0a,	"1p" },
+X{ "bne",	 8,8,	0x1a,	"1p" },
+X{ "bcs",	 8,8,	0x2a,	"1p" },
+X{ "bcc",	 8,8,	0x3a,	"1p" },
+X{ "bhi",	 8,8,	0x4a,	"1p" },
+X{ "bls",	 8,8,	0x5a,	"1p" },
+X{ "bgt",	 8,8,	0x6a,	"1p" },
+X{ "ble",	 8,8,	0x7a,	"1p" },
+X{ "bfs",	 8,8,	0x8a,	"1p" },
+X{ "bfc",	 8,8,	0x9a,	"1p" },
+X{ "blo",	 8,8,	0xaa,	"1p" },
+X{ "bhs",	 8,8,	0xba,	"1p" },
+X{ "blt",	 8,8,	0xca,	"1p" },
+X{ "bge",	 8,8,	0xda,	"1p" },
+X{ "bicb",	 6,16,	0x08,	"1B2B" },
+X{ "bicw",	 6,16,	0x09,	"1W2W" },
+X{ "bicd",	 6,16,	0x0b,	"1D2D" },
+X{ "bicpsrb",	11,16,	0x17c,	"1B" },
+X{ "bicpsrw",	11,16,	0x17d,	"1W" },
+X{ "bispsrb",	11,16,	0x37c,	"1B" },
+X{ "bispsrw",	11,16,	0x37d,	"1W" },
+X{ "bpt",	 8,8,	0xf2,	"" },
+X{ "br",		 8,8,	0xea,	"1p" },
+X{ "bsr",	 8,8,	0x02,	"1p" },
+X{ "caseb",	11,16,	0x77c,	"1B" },
+X{ "casew",	11,16,	0x77d,	"1W" },
+X{ "cased",	11,16,	0x77f,	"1D" },
+X{ "cbitb",	14,24,	0x084e,	"1B2D" },
+X{ "cbitw",	14,24,	0x094e,	"1W2D" },
+X{ "cbitd",	14,24,	0x0b4e,	"1D2D" },
+X{ "cbitib",	14,24,	0x0c4e,	"1B2D" },
+X{ "cbitiw",	14,24,	0x0d4e,	"1W2D" },
+X{ "cbitid",	14,24,	0x0f4e,	"1D2D" },
+X{ "checkb",	11,24,	0x0ee,	"2A3B1r" },
+X{ "checkw",	11,24,	0x1ee,	"2A3B1r" },
+X{ "checkd",	11,24,	0x3ee,	"2A3D1r" },
+X{ "cmpf",	14,24,	0x09be,	"1F2F" },
+X{ "cmpl",	14,24,	0x08be,	"1L2L" },
+X{ "cmpb",	 6,16,	0x04,	"1B2B" },
+X{ "cmpw",	 6,16,	0x05,	"1W2W" },
+X{ "cmpd",	 6,16,	0x07,	"1D2D" },
+X{ "cmpmb",	14,24,	0x04ce,	"1D2D3d" },
+X{ "cmpmw",	14,24,	0x05ce,	"1D2D3d" },
+X{ "cmpmd",	14,24,	0x07ce,	"1D2D3d" },
+X{ "cmpqb",	 7,16,	0x1c,	"2B1q" },
+X{ "cmpqw",	 7,16,	0x1d,	"2W1q" },
+X{ "cmpqd",	 7,16,	0x1f,	"2D1q" },
+X{ "cmpsb",	16,16,	0x040e,	"i" },
+X{ "cmpsw",	16,16,	0x050e,	"i" },
+X{ "cmpsd",	16,16,	0x070e,	"i" },
+X{ "cmpst",	16,16,	0x840e,	"i" },
+X{ "comb",	14,24,	0x344e,	"1B2B" },
+X{ "comw",	14,24,	0x354e,	"1W2W" },
+X{ "comd",	14,24,	0x374e,	"1D2D" },
+X{ "cvtp",	11,24,	0x036e,	"2D3D1r" },
+X{ "cxp",	 8,8,	0x22,	"1p" },
+X{ "cxpd",	11,16,	0x07f,	"1D" },
+X{ "deib",	14,24,	0x2cce,	"1B2W" },
+X{ "deiw",	14,24,	0x2cce,	"1W2D" },
+X{ "deid",	14,24,	0x2cce,	"1D2Q" },
+X{ "dia",	 8,8,	0xc2,	"" },
+X{ "divf",	14,24,	0x21be,	"1F2F" },
+X{ "divl",	14,24,	0x20be,	"1L2L" },
+X{ "divb",	14,24,	0x3cce,	"1B2B" },
+X{ "divw",	14,24,	0x3dce,	"1W2W" },
+X{ "divd",	14,24,	0x3fce,	"1D2D" },
+X{ "enter",	 8,8,	0x82,	"1i2d" },
+X{ "exit",	 8,8,	0x92,	"1i" },
+X{ "extb",	11,24,	0x02e,	"2D3B1r4d" },
+X{ "extw",	11,24,	0x12e,	"2D3W1r4d" },
+X{ "extd",	11,24,	0x32e,	"2D3D1r4d" },
+X{ "extsb",	14,24,	0x0cce,	"1D2B3i" },
+X{ "extsw",	14,24,	0x0dce,	"1D2W3i" },
+X{ "extsd",	14,24,	0x0fce,	"1D2D3i" },
+X{ "ffsb",	14,24,	0x046e,	"1B2B" },
+X{ "ffsw",	14,24,	0x056e,	"1W2B" },
+X{ "ffsd",	14,24,	0x076e,	"1D2B" },
+X{ "flag",	 8,8,	0xd2,	"" },
+X{ "floorfb",	14,24,	0x3c3e,	"1F2B" },
+X{ "floorfw",	14,24,	0x3d3e,	"1F2W" },
+X{ "floorfd",	14,24,	0x3f3e,	"1F2D" },
+X{ "floorlb",	14,24,	0x383e,	"1L2B" },
+X{ "floorlw",	14,24,	0x393e,	"1L2W" },
+X{ "floorld",	14,24,	0x3b3e,	"1L2D" },
+X{ "ibitb",	14,24,	0x384e,	"1B2D" },
+X{ "ibitw",	14,24,	0x394e,	"1W2D" },
+X{ "ibitd",	14,24,	0x3b4e,	"1D2D" },
+X{ "indexb",	11,24,	0x42e,	"2B3B1r" },
+X{ "indexw",	11,24,	0x52e,	"2W3W1r" },
+X{ "indexd",	11,24,	0x72e,	"2D3D1r" },
+X{ "insb",	11,24,	0x0ae,	"2B3B1r4d" },
+X{ "insw",	11,24,	0x1ae,	"2W3W1r4d" },
+X{ "insd",	11,24,	0x3ae,	"2D3D1r4d" },
+X{ "inssb",	14,24,	0x08ce,	"1B2D3i" },
+X{ "inssw",	14,24,	0x09ce,	"1W2D3i" },
+X{ "inssd",	14,24,	0x0bce,	"1D2D3i" },
+X{ "jsr",	11,16,	0x67f,	"1A" },
+X{ "jump",	11,16,	0x27f,	"1A" },
+X{ "lfsr",	19,24,	0x00f3e,"1D" },
+X{ "lmr",	15,24,	0x0b1e,	"2D1q" },
+X{ "lprb",	 7,16,	0x6c,	"2B1q" },
+X{ "lprw",	 7,16,	0x6d,	"2W1q" },
+X{ "lprd",	 7,16,	0x6f,	"2D1q" },
+X{ "lshb",	14,24,	0x144e,	"1B2B" },
+X{ "lshw",	14,24,	0x154e,	"1B2W" },
+X{ "lshd",	14,24,	0x174e,	"1B2D" },
+X{ "meib",	14,24,	0x24ce,	"1B2W" },
+X{ "meiw",	14,24,	0x25ce,	"1W2D" },
+X{ "meid",	14,24,	0x27ce,	"1D2Q" },
+X{ "modb",	14,24,	0x38ce,	"1B2B" },
+X{ "modw",	14,24,	0x39ce,	"1W2W" },
+X{ "modd",	14,24,	0x3bce,	"1D2D" },
+X{ "movf",	14,24,	0x05be,	"1F2F" },
+X{ "movl",	14,24,	0x04be,	"1L2L" },
+X{ "movb",	 6,16,	0x14,	"1B2B" },
+X{ "movw",	 6,16,	0x15,	"1W2W" },
+X{ "movd",	 6,16,	0x17,	"1D2D" },
+X{ "movbf",	14,24,	0x043e,	"1B2F" },
+X{ "movwf",	14,24,	0x053e,	"1W2F" },
+X{ "movdf",	14,24,	0x073e,	"1D2F" },
+X{ "movbl",	14,24,	0x003e,	"1B2L" },
+X{ "movwl",	14,24,	0x013e,	"1W2L" },
+X{ "movdl",	14,24,	0x033e,	"1D2L" },
+X{ "movfl",	14,24,	0x1b3e,	"1F2L" },
+X{ "movlf",	14,24,	0x163e,	"1L2F" },
+X{ "movmb",	14,24,	0x00ce,	"1D2D3d" },
+X{ "movmw",	14,24,	0x00de,	"1D2D3d" },
+X{ "movmd",	14,24,	0x00fe,	"1D2D3d" },
+X{ "movqb",	 7,16,	0x5c,	"2B1q" },
+X{ "movqw",	 7,16,	0x5d,	"2B1q" },
+X{ "movqd",	 7,16,	0x5f,	"2B1q" },
+X{ "movsb",	16,16,	0x000e,	"i" },
+X{ "movsw",	16,16,	0x010e,	"i" },
+X{ "movsd",	16,16,	0x030e,	"i" },
+X{ "movst",	16,16,	0x800e,	"i" },
+X{ "movsub",	14,24,	0x0cae,	"1A1A" },
+X{ "movsuw",	14,24,	0x0dae,	"1A1A" },
+X{ "movsud",	14,24,	0x0fae,	"1A1A" },
+X{ "movusb",	14,24,	0x1cae,	"1A1A" },
+X{ "movusw",	14,24,	0x1dae,	"1A1A" },
+X{ "movusd",	14,24,	0x1fae,	"1A1A" },
+X{ "movxbd",	14,24,	0x1cce,	"1B2D" },
+X{ "movxwd",	14,24,	0x1dce,	"1W2D" },
+X{ "movxbw",	14,24,	0x10ce,	"1B2W" },
+X{ "movzbd",	14,24,	0x18ce,	"1B2D" },
+X{ "movzwd",	14,24,	0x19ce,	"1W2D" },
+X{ "movzbw",	14,24,	0x14ce,	"1B2W" },
+X{ "mulf",	14,24,	0x31be,	"1F2F" },
+X{ "mull",	14,24,	0x30be,	"1L2L" },
+X{ "mulb",	14,24,	0x20ce, "1B2B" },
+X{ "mulw",	14,24,	0x21ce, "1W2W" },
+X{ "muld",	14,24,	0x23ce, "1D2D" },
+X{ "negf",	14,24,	0x15be, "1F2F" },
+X{ "negl",	14,24,	0x14be, "1L2L" },
+X{ "negb",	14,24,	0x204e, "1B2B" },
+X{ "negw",	14,24,	0x214e, "1W2W" },
+X{ "negd",	14,24,	0x234e, "1D2D" },
+X{ "nop",	 8,8,	0xa2,	"" },
+X{ "notb",	14,24,	0x244e, "1B2B" },
+X{ "notw",	14,24,	0x254e, "1W2W" },
+X{ "notd",	14,24,	0x274e, "1D2D" },
+X{ "orb",	 6,16,	0x18,	"1B1B" },
+X{ "orw",	 6,16,	0x19,	"1W1W" },
+X{ "ord",	 6,16,	0x1b,	"1D1D" },
+X{ "quob",	14,24,	0x30ce,	"1B2B" },
+X{ "quow",	14,24,	0x31ce,	"1W2W" },
+X{ "quod",	14,24,	0x33ce,	"1D2D" },
+X{ "rdval",	19,24,	0x0031e,"1A" },
+X{ "remb",	14,24,	0x34ce,	"1B2B" },
+X{ "remw",	14,24,	0x35ce,	"1W2W" },
+X{ "remd",	14,24,	0x37ce,	"1D2D" },
+X{ "restore",	 8,8,	0x72,	"1i" },
+X{ "ret",	 8,8,	0x12,	"1d" },
+X{ "reti",	 8,8,	0x52,	"" },
+X{ "rett",	 8,8,	0x42,	"" },
+X{ "rotb",	14,24,	0x004e,	"1B2B" },
+X{ "rotw",	14,24,	0x014e,	"1B2W" },
+X{ "rotd",	14,24,	0x034e,	"1B2D" },
+X{ "roundfb",	14,24,	0x243e,	"1F2B" },
+X{ "roundfw",	14,24,	0x253e,	"1F2W" },
+X{ "roundfd",	14,24,	0x273e,	"1F2D" },
+X{ "roundlb",	14,24,	0x203e,	"1L2B" },
+X{ "roundlw",	14,24,	0x213e,	"1L2W" },
+X{ "roundld",	14,24,	0x233e,	"1L2D" },
+X{ "rxp",	 8,8,	0x32,	"1d" },
+X{ "sCONDb",	 7,16,	0x3c,	"2B1q" },
+X{ "sCONDw",	 7,16,	0x3d,	"2D1q" },
+X{ "sCONDd",	 7,16,	0x3f,	"2D1q" },
+X{ "save",	 8,8,	0x62,	"1i" },
+X{ "sbitb",	14,24,	0x184e,	"1B2A" },
+X{ "sbitw",	14,24,	0x194e,	"1W2A" },
+X{ "sbitd",	14,24,	0x1b4e,	"1D2A" },
+X{ "sbitib",	14,24,	0x1c4e,	"1B2A" },
+X{ "sbitiw",	14,24,	0x1d4e,	"1W2A" },
+X{ "sbitid",	14,24,	0x1f4e,	"1D2A" },
+X{ "setcfg",	15,24,	0x0b0e,	"5D1q" },
+X{ "sfsr",	14,24,	0x673e,	"5D1D" },
+X{ "skpsb",	16,16,	0x0c0e,	"i" },
+X{ "skpsw",	16,16,	0x0d0e,	"i" },
+X{ "skpsd",	16,16,	0x0f0e, "i" },
+X{ "skpst",	16,16,	0x8c0e,	"i" },
+X{ "smr",	15,24,	0x0f1e,	"2D1q" },
+X{ "sprb",	 7,16,	0x2c,	"2B1q" },
+X{ "sprw",	 7,16,	0x2d,	"2W1q" },
+X{ "sprd",	 7,16,	0x2f,	"2D1q" },
+X{ "subf",	14,24,	0x11be,	"1F2F" },
+X{ "subl",	14,24,	0x10be,	"1L2L" },
+X{ "subb",	 6,16,	0x20,	"1B2B" },
+X{ "subw",	 6,16,	0x21,	"1W2W" },
+X{ "subd",	 6,16,	0x23,	"1D2D" },
+X{ "subcb",	 6,16,	0x30,	"1B2B" },
+X{ "subcw",	 6,16,	0x31,	"1W2W" },
+X{ "subcd",	 6,16,	0x33,	"1D2D" },
+X{ "subpb",	14,24,	0x2c4e,	"1B2B" },
+X{ "subpw",	14,24,	0x2d4e,	"1W2W" },
+X{ "subpd",	14,24,	0x2f4e,	"1D2D" },
+X{ "svc",	 8,8,	0xe2,	"2i1i" }, /* not really, but unix uses it */
+X{ "tbitb",	 6,16,	0x34,	"1B2A" },
+X{ "tbitw",	 6,16,	0x35,	"1W2A" },
+X{ "tbitd",	 6,16,	0x37,	"1D2A" },
+X{ "truncfb",	14,24,	0x2c3e,	"1F2B" },
+X{ "truncfw",	14,24,	0x2d3e,	"1F2W" },
+X{ "truncfd",	14,24,	0x2f3e,	"1F2D" },
+X{ "trunclb",	14,24,	0x283e,	"1L2B" },
+X{ "trunclw",	14,24,	0x293e,	"1L2W" },
+X{ "truncld",	14,24,	0x2b3e,	"1L2D" },
+X{ "wait",	 8,8,	0xb2,	"" },
+X{ "wrval",	19,24,	0x0071e,"1A" },
+X{ "xorb",	 6,16,	0x38,	"1B2B" },
+X{ "xorw",	 6,16,	0x39,	"1W2W" },
+X{ "xord",	 6,16,	0x3b,	"1D2D" },
+X};				/* notstrs */
+X
+X/* end: n32k.opcode.h */
+X
+X# define	MAX_ARGS	4
+X# define	ARG_LEN		50
+SHAR_EOF
+sed 's/^X//' << 'SHAR_EOF' > n32k-pinsn.c
+X/* Print 32000 instructions for GDB, the GNU debugger.
+X   Copyright (C) 1986 Free Software Foundation, Inc.
+X
+XGDB is distributed in the hope that it will be useful, but WITHOUT ANY
+XWARRANTY.  No author or distributor accepts responsibility to anyone
+Xfor the consequences of using it or for whether it serves any
+Xparticular purpose or works at all, unless he says so in writing.
+XRefer to the GDB General Public License for full details.
+X
+XEveryone is granted permission to copy, modify and redistribute GDB,
+Xbut only under the conditions described in the GDB General Public
+XLicense.  A copy of this license is supposed to have been given to you
+Xalong with GDB so you can know your rights and responsibilities.  It
+Xshould be in a file named COPYING.  Among other things, the copyright
+Xnotice and this notice must be preserved on all copies.
+X
+XIn other words, go ahead and share GDB, but don't try to stop
+Xanyone else from sharing it farther.  Help stamp out software hoarding!
+X*/
+X
+X#include <stdio.h>
+X
+X#include "defs.h"
+X#include "param.h"
+X#include "symtab.h"
+X#include "n32k-opcode.h"
+X
+X/* 32000 instructions are never longer than this.  */
+X#define MAXLEN 62
+X
+X/* Number of elements in the opcode table.  */
+X#define NOPCODES (sizeof notstrs / sizeof notstrs[0])
+X
+Xextern char *reg_names[];
+X
+X#define NEXT_IS_ADDR	'|'
+X
+X/*
+X * extract "count" bits starting "offset" bits
+X * into buffer
+X */
+X
+Xint
+Xbit_extract (buffer, offset, count)
+Xchar	*buffer;
+Xint	offset;
+Xint	count;
+X{
+X	int	result;
+X	int	mask;
+X	int	bit;
+X
+X	buffer += offset >> 3;
+X	offset &= 7;
+X	bit = 1;
+X	result = 0;
+X	while (count--) {
+X		if ((*buffer & (1 << offset)))
+X			result |= bit;
+X		if (++offset == 8) {
+X			offset = 0;
+X			buffer++;
+X		}
+X		bit <<= 1;
+X	}
+X	return result;
+X}
+X
+Xdouble
+Xdbit_extract (buffer, offset, count)
+X{
+X	union {
+X		struct {
+X			int	low, high;
+X		} ival;
+X		double	dval;
+X	} foo;
+X
+X	foo.ival.low = bit_extract (buffer, offset, 32);
+X	foo.ival.high = bit_extract (buffer, offset+32, 32);
+X	return foo.dval;
+X}
+X
+Xsign_extend (value, bits)
+X{
+X	value = value & ((1 << bits) - 1);
+X	return (value & (1 << (bits-1))) ?
+X		(value | (~((1 << bits) - 1)))
+X		: value;
+X}
+X
+Xflip_bytes (ptr, count)
+Xchar	*ptr;
+Xint	count;
+X{
+X	char	tmp;
+X
+X	while (count > 0) {
+X		tmp = *ptr;
+X		ptr[0] = ptr[count-1];
+X		ptr[count-1] = tmp;
+X		ptr++;
+X		count -= 2;
+X	}
+X}
+X
+X
+X/* Print the 32000 instruction at address MEMADDR in debugged memory,
+X   on STREAM.  Returns length of the instruction, in bytes.  */
+X
+Xint
+Xprint_insn (memaddr, stream)
+XCORE_ADDR memaddr;
+XFILE *stream;
+X{
+X	unsigned char buffer[MAXLEN];
+X	register int i;
+X	register unsigned char *p;
+X	register char *d;
+X	unsigned short	first_word;
+X	int	gen, disp;
+X	int	ioffset;	/* bits into instruction */
+X	int	aoffset;	/* bits into arguments */
+X	char	arg_bufs[MAX_ARGS+1][ARG_LEN];
+X	int	argnum;
+X	int	maxarg;
+X
+X	read_memory (memaddr, buffer, MAXLEN);
+X
+X	first_word = *(unsigned short *) buffer;
+X	for (i = 0; i < NOPCODES; i++) {
+X		if ((first_word & ((1 << notstrs[i].detail.obits) - 1)) ==
+X		    notstrs[i].detail.code)
+X			break;
+X	}
+X
+X	/* Handle undefined instructions.  */
+X	if (i == NOPCODES) {
+X		fprintf (stream, "0%o", buffer[0]);
+X		return 1;
+X	}
+X
+X	fprintf (stream, "%s", notstrs[i].name);
+X
+X	ioffset = notstrs[i].detail.ibits;
+X	aoffset = notstrs[i].detail.ibits;
+X	d = notstrs[i].detail.args;
+X
+X	if (*d) {
+X		fputc ('\t', stream);
+X
+X		maxarg = 0;
+X		while (*d)
+X		{
+X			argnum = *d - '1';
+X			d++;
+X			if (argnum > maxarg && argnum < MAX_ARGS)
+X				maxarg = argnum;
+X			ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer,
+X	 				memaddr, arg_bufs[argnum]);
+X			d++;
+X		}
+X		for (argnum = 0; argnum <= maxarg; argnum++) {
+X			CORE_ADDR	addr;
+X			char		*ch, *index ();
+X			for (ch = arg_bufs[argnum]; *ch;) {
+X				if (*ch == NEXT_IS_ADDR) {
+X					++ch;
+X					addr = atoi (ch);
+X					print_address (addr, stream);
+X					while (*ch && *ch != NEXT_IS_ADDR)
+X						++ch;
+X					if (*ch)
+X						++ch;
+X				} else
+X					putc (*ch++, stream);
+X			}
+X			if (argnum < maxarg)
+X				fprintf (stream, ", ");
+X		}
+X	}
+X	return aoffset / 8;
+X}
+X
+Xprint_insn_arg (d, ioffset, aoffsetp, buffer, addr, result)
+Xchar 	d;
+Xint	ioffset, *aoffsetp;
+Xchar	*buffer;
+XCORE_ADDR addr;
+Xchar	*result;
+X{
+X	int	addr_mode;
+X	float	Fvalue;
+X	double	Lvalue;
+X	int	Ivalue;
+X	int	disp1, disp2;
+X	int	index;
+X
+X	switch (d) {
+X	case 'F':
+X	case 'L':
+X	case 'B':
+X	case 'W':
+X	case 'D':
+X	case 'A':
+X		addr_mode = bit_extract (buffer, ioffset-5, 5);
+X		ioffset -= 5;
+X		switch (addr_mode) {
+X		case 0x0: case 0x1: case 0x2: case 0x3:
+X		case 0x4: case 0x5: case 0x6: case 0x7:
+X			sprintf (result, "r%d", addr_mode);
+X			break;
+X		case 0x8: case 0x9: case 0xa: case 0xb:
+X		case 0xc: case 0xd: case 0xe: case 0xf:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
+X			break;
+X		case 0x10:
+X		case 0x11:
+X		case 0x12:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			disp2 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "%d(%d(%s))", disp2, disp1,
+X				addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
+X			break;
+X		case 0x13:
+X			sprintf (result, "reserved");
+X			break;
+X		case 0x14:
+X			switch (d) {
+X			case 'B':
+X				Ivalue = bit_extract (buffer, *aoffsetp, 8);
+X				Ivalue = sign_extend (Ivalue, 8);
+X				*aoffsetp += 8;
+X				sprintf (result, "$%d", Ivalue);
+X				break;
+X			case 'W':
+X				Ivalue = bit_extract (buffer, *aoffsetp, 16);
+X				flip_bytes (&Ivalue, 2);
+X				*aoffsetp += 16;
+X				Ivalue = sign_extend (Ivalue, 16);
+X				sprintf (result, "$%d", Ivalue);
+X				break;
+X			case 'D':
+X				Ivalue = bit_extract (buffer, *aoffsetp, 32);
+X				flip_bytes (&Ivalue, 4);
+X				*aoffsetp += 32;
+X				sprintf (result, "$%d", Ivalue);
+X				break;
+X			case 'A':
+X				Ivalue = bit_extract (buffer, *aoffsetp, 32);
+X				flip_bytes (&Ivalue, 4);
+X				*aoffsetp += 32;
+X				sprintf (result, "$|%d|", Ivalue);
+X				break;
+X			case 'F':
+X				Fvalue = (float) bit_extract
+X 					(buffer, *aoffsetp, 32);
+X				flip_bytes (&Fvalue, 4);
+X				*aoffsetp += 32;
+X				sprintf (result, "$%g", Fvalue);
+X				break;
+X			case 'L':
+X				Lvalue = dbit_extract
+X 					(buffer, *aoffsetp, 64);
+X				flip_bytes (&Lvalue, 8);
+X				*aoffsetp += 64;
+X				sprintf (result, "$%g", Lvalue);
+X				break;
+X			}
+X			break;
+X		case 0x15:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "@|%d|", disp1);
+X			break;
+X		case 0x16:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			disp2 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "EXT(%d) + %d", disp1, disp2);
+X			break;
+X		case 0x17:
+X			sprintf (result, "tos");
+X			break;
+X		case 0x18:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "%d(fp)", disp1);
+X			break;
+X		case 0x19:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "%d(sp)", disp1);
+X			break;
+X		case 0x1a:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "%d(sb)", disp1);
+X			break;
+X		case 0x1b:
+X			disp1 = get_displacement (buffer, aoffsetp);
+X			sprintf (result, "|%d|", addr + disp1);
+X			break;
+X		case 0x1c:
+X		case 0x1d:
+X		case 0x1e:
+X		case 0x1f:
+X			index = bit_extract (buffer, *aoffsetp, 8);
+X			*aoffsetp += 8;
+X			print_insn_arg (d, *aoffsetp, aoffsetp, buffer, addr,
+X				result);
+X			{
+X 				static char	*ind[] = {"b", "w", "d", "q"};
+X				char		*off;
+X
+X				off = result + strlen (result);
+X				sprintf (off, "[r%d:%s]", index & 7,
+X					ind[addr_mode & 3]);
+X			}
+X			break;
+X		}
+X		break;
+X	case 'q':
+X		Ivalue = bit_extract (buffer, ioffset-4, 4);
+X		Ivalue = sign_extend (Ivalue, 4);
+X		sprintf (result, "%d", Ivalue);
+X		ioffset -= 4;
+X		break;
+X	case 'r':
+X		Ivalue = bit_extract (buffer, ioffset-3, 3);
+X		sprintf (result, "r%d", Ivalue&7);
+X		ioffset -= 3;
+X		break;
+X	case 'd':
+X		sprintf (result, "%d", get_displacement (buffer, aoffsetp));
+X		break;
+X	case 'p':
+X		sprintf (result, "%c%d%c", NEXT_IS_ADDR, addr +
+X 			get_displacement (buffer, aoffsetp),
+X			NEXT_IS_ADDR);
+X		break;
+X	case 'i':
+X		Ivalue = bit_extract (buffer, *aoffsetp, 8);
+X		*aoffsetp += 8;
+X		sprintf (result, "0x%x", Ivalue);
+X		break;
+X	}
+X	return ioffset;
+X}
+X
+Xget_displacement (buffer, aoffsetp)
+Xchar	*buffer;
+Xint	*aoffsetp;
+X{
+X	int	Ivalue;
+X
+X	Ivalue = bit_extract (buffer, *aoffsetp, 8);
+X	switch (Ivalue & 0xc0) {
+X	case 0x00:
+X	case 0x40:
+X		Ivalue = sign_extend (Ivalue, 7);
+X		*aoffsetp += 8;
+X		break;
+X	case 0x80:
+X		Ivalue = bit_extract (buffer, *aoffsetp, 16);
+X		flip_bytes (&Ivalue, 2);
+X		Ivalue = sign_extend (Ivalue, 14);
+X		*aoffsetp += 16;
+X		break;
+X	case 0xc0:
+X		Ivalue = bit_extract (buffer, *aoffsetp, 32);
+X		flip_bytes (&Ivalue, 4);
+X		Ivalue = sign_extend (Ivalue, 30);
+X		*aoffsetp += 32;
+X		break;
+X	}
+X	return Ivalue;
+X}
+X/*
+X * return the number of locals in the current frame given a pc
+X * pointing to the enter instruction
+X */
+Xn32k_localcount (enter_pc)
+XCORE_ADDR	enter_pc;
+X{
+X	int	localtype, localcount;
+X
+X	localtype = read_memory_integer (enter_pc+2, 1);
+X	if ((localtype & 0x80) == 0)
+X		localcount = localtype;
+X	else if ((localtype & 0xc0) == 0x80)
+X		localcount =
+X		    ((read_memory_integer (enter_pc+2, 1) & ~0xc0) << 8) |
+X		    ((read_memory_integer (enter_pc+3, 1)));
+X	else
+X		localcount =
+X		    ((read_memory_integer (enter_pc+2, 1) & ~0xc0) << 24) |
+X		    ((read_memory_integer (enter_pc+3, 1)) << 16) |
+X		    ((read_memory_integer (enter_pc+4, 1)) << 8 ) |
+X		    ((read_memory_integer (enter_pc+5, 1)));
+X	return localcount;
+X}
+SHAR_EOF
+exit
+
diff --git a/gdb/=rt-ans2 b/gdb/=rt-ans2
new file mode 100644
index 0000000..cd5f9fa
--- /dev/null
+++ b/gdb/=rt-ans2
@@ -0,0 +1,103 @@
+BABYL OPTIONS:
+Version: 5
+Labels:
+Note:   This is the header of an rmail file.
+Note:   If you are seeing it in rmail,
+Note:    it means the file has no messages in it.
+
+1,answered,,
+Received: by PREP.AI.MIT.EDU; Tue, 26 May 87 14:03:00 EDT
+Received: by po2.andrew.cmu.edu (5.54/3.15) id <AA00274> for rms@PREP.AI.MIT.EDU; Tue, 26 May 87 13:12:52 EDT
+Received: via switchmail; Tue, 26 May 87 13:12:49 edt
+Received: FROM mooncrest VIA qmail
+          ID </cmu/common/mailqs/q004/QF.mooncrest.20b9cce3.d0134>;
+          Tue, 26 May 87 13:12:08 edt
+Received: FROM mooncrest VIA qmail
+          ID </cmu/itc/kazar/.Outgoing/QF.mooncrest.20b9ccb0.1b570>;
+          Tue, 26 May 87 13:11:14 edt
+Message-Id: <0UiQmky00UkA06w0Ci@andrew.cmu.edu>
+X-Trace: MS Version 3.24 on ibm032 host mooncrest, by kazar (71).
+Date: Tue, 26 May 87 13:11:12 edt
+From: kazar#@andrew.cmu.edu (Mike Kazar)
+To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
+Subject: Re: Fwd: RT diffs for gdb version 2.1
+Cc: zs01#@andrew.cmu.edu (Zalman Stern)
+In-Reply-To: <4UiN0ly00Vs8Njw0PC@andrew.cmu.edu>
+
+*** EOOH ***
+X-Trace: MS Version 3.24 on ibm032 host mooncrest, by kazar (71).
+Date: Tue, 26 May 87 13:11:12 edt
+From: kazar#@andrew.cmu.edu (Mike Kazar)
+To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
+Subject: Re: Fwd: RT diffs for gdb version 2.1
+Cc: zs01#@andrew.cmu.edu (Zalman Stern)
+In-Reply-To: <4UiN0ly00Vs8Njw0PC@andrew.cmu.edu>
+
+I'm afraid that neither of your proposed simplifications to the gdb RT port
+actually work.
+
+First, the trace table problem.  The fundamental problem is that gdb expects
+to be able to pass in a frame pointer and get that frame's parent.  This is
+the purpose of FRAME_CHAIN, a macro whose one parameter is the frame whose
+parent is desired.
+
+This is simply insufficient information with which to compute the preceding
+frame's address.  In order to truly appreciate how bad things are, let me
+describe the procedure involved in going from a set of saved registers
+(including the pc), say after a core dump occurs, to the address of the
+preceding frame.  I assure you that you'll be shocked by its complexity....
+
+I start off knowing only one thing: the PC of the guy who pushed the last
+stack frame.  At the time of a core dump, this is in the saved PC, and for
+other stack frames, it is in register R15 (the return address is put in R15
+by the procedure call sequence).  My first goal is to compute the frame
+register number!  Not the contents of the frame register, but the register
+number itself, because the RT calling convention lets you change frame
+pointers from procedure to procedure!  So, I scan for the trace table, based
+on the PC, and obtain a structure that gives the frame register number (for
+both of our C compilers, this is R13, but it doesn't have to be), the number
+of arguments to the procedure, the space used by the locals and the number of
+registers saved by the procedure prolog.  This enables me to take the frame
+pointer, compute the offset of the saved registers off of this frame pointer
+and essentially restore the registers to the state they were at the time this
+procedure was called.  R15 now contains *its* callers PC, and I can redo this
+procedure again to back up another frame.
+
+In essence, in order to compute the preceding frame's address, I need more
+than just the current frame's address.  I need the full machine state at the
+time of the call, including all of the registers since I don't know which one
+will even turn out to be the frame pointer for the preceding procedure.
+
+This is why I put in the frame caching code.  Note that even were I to assume
+that the frame pointer is always in R13 (and this is almost certainly a
+mistake; IBM will surely eventually come up with a compiler where the frame
+pointer is NOT r13), I still either need r15 or the PC (depending upon which
+frame we're dealing with) in order to compute the preceding frame address.
+
+As for the _foo v.s. _.foo issue, there are two problems.  First, we can not
+simply ignore _foo symbols, since an _foo symbol is only "junk" if there is
+(possibly later) an _.foo symbol.  We might be able to have the processing
+for the "_.foo" change the value in the symbol table placed under the name
+_foo.  I do not know if this will work, since I do not know what processing
+is done when a symbol is first encountered, and how much can be done a second
+time.  The second problem is that sometimes we need to see what is in the
+variable named _foo, and we can't if it actually refers to _.foo.  I
+personally might be willing to live with this loss of functionality, but
+other people probably would not.
+
+As for initialize.h, we simply have no guarantees that IBM won't again change
+the junk they stick in front of procedures in the text segment.  Already,
+depending upon which compiler (and we use both), pcc puts a funny string (and
+maybe an integer, too) in front of every procedure, while the metaware hc
+compiler puts a funny string in front of the first procedure in a file, but
+nothing in front of the others.  IBM has made it clear to us that they feel
+free to change this at any time, so I feel quite strongly that it would be a
+mistake to assume that they've finished playing around with junk at the start
+of the text.  BTW, for all I know, some of these magic text strings disappear
+when you compile with -O.  They certainly *should*.
+
+	Mike
+
+
+
+
\ No newline at end of file
diff --git a/gdb/=rt-answers b/gdb/=rt-answers
new file mode 100644
index 0000000..b23cfee
--- /dev/null
+++ b/gdb/=rt-answers
@@ -0,0 +1,147 @@
+X-Trace: MS Version 3.24 on ibm032 host dublin.itc.cmu.edu, by zs01 (623).
+Date: Mon, 25 May 87 10:30:10 edt
+From: zs01#@andrew.cmu.edu (Zalman Stern)
+To: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
+Subject: Re: RT diffs for gdb version 2.1
+Cc: kazar#@andrew.cmu.edu (Mike Kazar), zs01#@andrew.cmu.edu (Zalman Stern)
+In-Reply-To: <8705250107.AA13256@prep.ai.mit.edu>
+
+Richard,
+
+First I will cover the easy questions.
+
+Either of our fixes to environ.c (i.e. with respect to version 1.9 which was
+broken) will work. As I understand it, the intent of init_environ is to fill
+in the environment and leave a little extra space for later additions. I do
+not understand why you would want to only leave the extra space when the
+original size was within 10 elements of the final size.
+
+add_com returning something is probably left over from a fix I put in which
+is superceeded by the "user" class to distinguish command lists from function
+pointers. I should have removed it.
+
+We use csh instead of sh because I got tired of putting up with sh's crapping
+out on large environments.
+
+The change to inferior_args involves putting an explicit initializer of NULL
+on it, and testing it for NULL before freeing it. I guess most
+implementations of free ignore NULL pointers. The one we have on our Sun-2's
+does not.
+
+I can't remember why the alloca's were moved out of the variable
+initializations. It may have been to avoid a compiler problem. In any event,
+ignoring this modification shouldn't hurt.
+
+Now for the hard ones...
+
+The RT is a very different architecture from either a Sun or a VAX. It does
+not use a self-describing stack frame and it does not use the same
+conventions for symbols within object modules. There are also certain
+subtleties to the way it lays out its address space that cause problems. Many
+people at the ITC, including myself, are very impressed with the quality of
+the port Mike did in spite of these obstacles. You may feel that these
+problems are not worth effort. I have attempted to describe the differences
+involved with the RT in case you choose to address them. If not, we are still
+quite happy with the debugger we have and thank you for providing us with the
+code...
+
+Both the 68k family and the VAX have a frame pointer and a stack pointer.
+Using these to values and the information on the stack, one can do a complete
+stack trace. The RT on the other hand has only a stack pointer and a very
+loose concept of a frame pointer. The stack pointer will point just below a
+section of the stack dedicated to the maximum number of outgoing parameters
+minus 4 (the first 4 are in registers). The frame pointer will point
+somewhere in the stack where the compiler has deemed it optimal for
+addressing locals and parameters. There are variable length fields in the
+stack frame, such as the register save areas. In all, the thing looks like
+so:
+
+
+Higher Address
+-----------------
+
+a) Incoming args 5 through N	<---- Previous sp was here
+    (part of previous function's stack frame)
+b) Four words to save register passed arguments.
+c) Four words of linkage area (reserved).
+d) 1 word static link.
+e) 1 - 16 words of register save area.
+    (Variable length, return address is at the top of this since it was in
+r15)
+f) 0 -8 words of floating point reg. save area. (Variable length)
+g) Local variables (variable length)
+h) Outgoing arguments, words 5 - N <---- Current sp points to bottom of this.
+
+Lower Address
+----------------
+
+These and the stack contents are not enough to get back to the previous stack
+frame because you do not know how far back it is to the register save area.
+The code works because each function has been compiled to know how to pop its
+stack frame (i.e. it has embedded constants). In order to facilitate
+debugging, there is a trace table at the end of each function containing all
+the necessary information. (Namely the offset from the frame pointer to the
+top of the stack frame b in the above diagram) The trace table is located by
+starting at the beginning of the function and looking for the illegal
+instruction sequence 0xdf07df. Since the RT does not have 32bit constants in
+the instruction stream, this actually works. In general, the iar and the
+stack pointer are needed to do frame manipulations. The cache is necessary
+because finding the trace table is very expensive. In short, the machinery
+present in gdb was not up to handling this system, so we added what we
+thought would work. It is interesting to note that similar calling
+conventions are used on other RISC machines, notably the MIPS R2000. If you
+wish to take advantage of these high performance machines, you will have to
+do something like what we have done.
+
+The POP_DUMMY_FRAME problem is related to this. The RT stores return address
+in r15. We can not use this location to store the current iar since we must
+store r15 for later restoration. This rules out using the same function for
+popping both kinds of frames. There is also some hassle involved in getting
+the stack and frame pointers correct, but I think this might be fixed by
+generating an appropriate trace back table for the dummy function.
+
+The other problem we faced is the non-standard use of symbols within object
+modules. The RT defines two symbols for a function foo. There is "_.foo"
+which corresponds to the actual code in the text segment (just like "_foo" on
+a Sun or VAX), and "_foo" which points to the data area for the function in
+the data segment. The first word of the data area contains a pointer to the
+code. A function pointer (i.e. int (*foo)()) points to the data area (_foo),
+not the code (_.foo). This is what the TYPE_CODE_PTR modification in valops.c
+is for. Since both of these symbols are used for certain things, we cannot
+simply remove the dots. This is a bogus IBM feature and we do not like it any
+better than you do. We have to live with it if we want a working debugger.
+
+The "fix" to find_pc_misc function handles a special case on the RT where
+certain functions are in the high end of the address space. The RT uses the
+top 4 bits of an address as a segment number. The text segment is seg. 0, the
+data segment is seg. 1, and the kernel is mapped into seg. 14. Certain kernel
+functions (i.e. floating point functions) are directly callable by user code
+and so occur in the misc_function_vector. I realize this is bogus.
+
+The initialization code will not run because both the RT compilers (pcc and
+hc) output ascii data in the text section preceding the first function. Pcc
+outputs the name of each function before the function. Hc outputs the name of
+the source file at the beginning of the object module. Coding around this may
+be possible, but what is the point? I see no reason for this hackery. I have
+had problems getting it to work not only on the RT, but on the Sun-3. It is
+guaranteed to be a portability headache on many other machines as well. If
+you intend for gdb to only work when compiled with gcc, I suppose you may be
+able to use this method.
+
+I strongly agree with your statements that cleaner solutions are better in
+every way. Unfortunately, we did not write gdb, nor is the system we are
+working with particularly supportive of symbolic debugging. We were faced
+with the task of both figuring out gdb, and hacking our way around a
+contorted system (featuring among other things, a plethora of compiler bugs).
+The fact that our version of gdb is the only working symbolic debugger on the
+IBM RT (despite much effort by IBM) is proof that we have done something
+right. I am willing to discuss what would make this port better. However, it
+is not our intent to maintain or rewrite gdb. We merely wish to use it, and
+if not a terrible hassle, let other people use it too. Mike and I would
+prefer a copyright assignment. I would appreciate it if you would send me
+info on what we need to do.
+
+-Z-
+
+
+
diff --git a/gdb/=rt-changes b/gdb/=rt-changes
new file mode 100644
index 0000000..1eda81c
--- /dev/null
+++ b/gdb/=rt-changes
@@ -0,0 +1,3338 @@
+From: zs01#@andrew.cmu.edu (Zalman Stern)
+Date: Sun, 24 May 87 03:20:57 edt
+To: rms@prep.ai.mit.edu
+Subject: RT diffs for gdb version 2.1
+
+Here are the new files, followed by the diffs to old files. The first file below
+is ITCMODS which is my attempt to document some of our changes. Unfortunately,
+it has not been maintained particularly well and notably does not include info
+about our changes to support the HIGH-C compiler. One big change we put in was
+to use a number of initialize routines instead of the "linked list of object
+modules" that is used on other machines. The RT object file format appears to
+have a variable size header before the code, making it very difficult
+(impossible?) to get the initialization stuff to work. If you have any
+questions, don't hesitate to send me mail.
+
+-Z-
+
+Only in .: ITCMODS
+
+blockframe.c:
+    set_current_frame now takes an extra argument.
+    RT specific code for interpreting and caching of trace table entries.
+    Added initialize routine.
+
+breakpoint.c:
+    Added new_breakpoint_commands flag to prevent incorrect interpretation of command lists containing a continue statement.
+    Modified do_breakpoint_commands to know about new_breakpoint_commands.
+    Modified clear_breakpoint_commands to set new_breakpoint_commands.
+    Added initialize routine.
+
+core.c:
+    RT specific code to find the uarea.
+    RT specific code to indicate the start of the data segment.
+    set_current_frame now takes an extra argument.
+    Added initialize routine.
+
+dbxread.c:
+    Added support for the Camphor dynamic loading system. (All under #ifdef CAMPHOR).
+    Fix for multiple declarations of register variables (i.e. they are declared twice). The fix munges the incorrect declaration (i.e. the one which is not register).
+    set_rel_command to set relocation offset for camphor loaded files. (Under #ifdef CAMPHOR).
+    add_file_command to append a file's symbols to the current symbol table instead of replacing it. (Under #ifdef CAMPHOR).
+    RT specific code to deal with function names being _.foo instead of _foo.
+    Added initialize routine.
+
+    Feb 8, 1987 Zalman Stern.
+        Added test in symbol_file_command to see if file was compiled with debugging. If not print an error message instead of dumping core.
+        Added same test in add_file_command and made it run through BZPATH, CLASSPATH, and PATH in that order (Under #ifdef CAMPHOR).
+
+environ.c:
+    Fixed error in calculating new size of a reallocated environment.
+
+eval.c:
+    Added initialize routine.
+
+expread.y:
+    Moved alloca call out of variable initializations.
+
+findvar.c:
+    Added initialize routine.
+
+firstfile.c:
+    Added main initialization driver routine.
+
+frame.h:
+    Added RT specific declarations to hold frame information, and to deal with trace table caching.
+
+ibm032-pinsn.c:
+    New file, contains RT disassembler.
+
+ibm032-opcode.h:
+    New file, contains RT opcode definitions.
+
+infcmd.c
+    Changed code to use csh instead of sh to avoid the anoyance of the environment bug.
+    Added initialize routine.
+
+inflow.c:
+    Added initialize routine.
+
+infrun.c:
+    set_current_frame now takes an extra argument.
+    Added some code to deal with stopping in the middle of a camphor link. (Under #ifdef CAMPHOR).
+    Added RT specific code to get the return values from the right registers. Replaces code that was there for RT.
+    RT specific code to do a "POP_DUMMY_FRAME." Dummy frames are to store more complete state than a normal frame. Makes calling a function in inferior more reliable. Perhaps this should be expanded to other machine types.
+    Added initialize routine.
+
+    Feb 9, 1987 Zalman Stern.
+        Added call to select_frame after popping a stack dummy frame in normal_stop. This fixes the bug where you could not print variables without doing a "frame 0" after printing an expression with a function call in it.
+
+iniitialize.h:
+    Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
+
+m-ibm032.h:
+    New file, contains RT specific macros and variables.
+
+param.h:
+    Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
+
+pinsn.c:
+    Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
+
+printcmd.c:
+    Moved alloca calls out of variable initialization.
+    Added initialize routine.
+
+source.c:
+    Added initialize routine.
+
+stack.c:
+    Added initialize routine.
+
+symmisc.c:
+    Added initialize routine.
+
+symtab.c:
+    RT specific code to deal with function names being _.foo instead of _foo.
+    Added initialize routine.
+
+utils.c:
+    Added comment.
+
+valarith.c:
+    Added initialize routine.
+
+valops.c:
+    Added initialize routine.
+
+valprint.c:
+    Added initialize routine.
+
+values.c:
+    Added initialize routine.
+
+Only in .: ibm032-opcode.h
+
+/* The opcode table consists of a 256 element array containing an
+ * instruction mnemonic and an instruction type field. This can be
+ * indexed directly by the first eight bits of an RT instruction.
+ * The instruction type consists of a type field and some flags. 
+ * In addition to this, there is an ifdef'd out "instruction" table
+ * at the end of the file. This is an alphabetical listing of the instructions
+ * containing mnemonic, opcode, and type. This is useful for modification
+ * purposes. There is also some code in the ifdef to convert the
+ * instruction table into an opcode table.
+ */
+
+/* Various useful bit masks. */
+#define ibm032_typeMask		0x0f /* Mask to get actual type info out of instruction type. */
+#define LOW4			0x0f
+#define HIGH4			0xf0
+#define LOW16			0x0000ffff
+#define HIGH16			0xffff0000
+#define LOW20			0x000fffff
+#define LOW24			0x00ffffff
+
+/* Instruction types consist of a type id in the low 4 bits and flags above that. */
+
+/* Flags. */
+#define ibm032_conditional 	0x10
+#define ibm032_negative		0x20
+
+/* Format types. */
+#define ibm032_JI	0x0	/* Jump immediate. */
+#define ibm032_X	0x1	/* ??? */
+
+/* These next ones are in a special bit position. Do not change their defines. */
+#define ibm032_DS0	0x2	/* Data short with no shift for immediate value. */
+#define ibm032_DS1	0x3	/* Data short with 1 bit shift for immediate value. */
+#define ibm032_DS2	0x4	/* Data short with 2 bit shift for immediate value */
+#define ibm032_DSShiftOffset	ibm032_DS0 /* Offset to get shift value from ibm032_DS? types. */
+
+#define ibm032_RR	0x5	/* R format where second argument is a register */
+#define ibm032_RI	0x6	/* R format where second argument is 4 bit immediate. */
+#define ibm032_BI	0x7	/* Branch immediate. */
+#define ibm032_BA	0x8	/* Branch absolute. */
+#define ibm032_D	0x9	/* Data. */
+
+/* What an instruction looks like. */
+struct ibm032_opcode {
+    char *mnemonic; /* the name. NULL indicates illegal instruction. */
+    int type; /* See above. */
+};
+
+#define MAXOPCODES 256 /* Pretty well hardwired. */
+
+#ifndef BUILDTABLE
+/* The actual data. */
+struct ibm032_opcode ibm032_opcodes[] = {
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional | ibm032_negative},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"j%s",		ibm032_JI | ibm032_conditional},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"stcs",		ibm032_DS0},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sths",		ibm032_DS1},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"sts",		ibm032_DS2},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lcs",		ibm032_DS0},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"lhas",		ibm032_DS1},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"cas",		ibm032_X},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {"ls",		ibm032_DS2},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {"b%s",		ibm032_BI | ibm032_conditional | ibm032_negative},
+    {"b%sx",		ibm032_BI | ibm032_conditional | ibm032_negative},
+    {"bala",		ibm032_BA},
+    {"balax",		ibm032_BA},
+    {"bali",		ibm032_BI},
+    {"balix",		ibm032_BI},
+    {"b%s",		ibm032_BI | ibm032_conditional},
+    {"b%sx",		ibm032_BI | ibm032_conditional},
+    {"ais",		ibm032_RI},
+    {"inc",		ibm032_RI},
+    {"sis",		ibm032_RI},
+    {"dec",		ibm032_RI},
+    {"cis",		ibm032_RI},
+    {"clrsb",		ibm032_RI},
+    {"mfs",		ibm032_RR},
+    {"setsb",		ibm032_RI},
+    {"clrbu",		ibm032_RI},
+    {"clrbl",		ibm032_RI},
+    {"setbu",		ibm032_RI},
+    {"setbl",		ibm032_RI},
+    {"mftbiu",		ibm032_RI},
+    {"mftbil",		ibm032_RI},
+    {"mttbiu",		ibm032_RI},
+    {"mttbil",		ibm032_RI},
+    {"sari",		ibm032_RI},
+    {"sari16",		ibm032_RI},
+    {0,			0},
+    {0,			0},
+    {"lis",		ibm032_RI},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {"sri",		ibm032_RI},
+    {"sri16",		ibm032_RI},
+    {"sli",		ibm032_RI},
+    {"sli16",		ibm032_RI},
+    {"srpi",		ibm032_RI},
+    {"srpi16",		ibm032_RI},
+    {"slpi",		ibm032_RI},
+    {"slpi16",		ibm032_RI},
+    {"sar",		ibm032_RR},
+    {"exts",		ibm032_RR},
+    {"sf",		ibm032_RR},
+    {"cl",		ibm032_RR},
+    {"c",		ibm032_RR},
+    {"mts",		ibm032_RR},
+    {"d",		ibm032_RR},
+    {0,			0},
+    {"sr",		ibm032_RR},
+    {"srp",		ibm032_RR},
+    {"sl",		ibm032_RR},
+    {"slp",		ibm032_RR},
+    {"mftb",		ibm032_RR},
+    {"tgte",		ibm032_RR},
+    {"tlt",		ibm032_RR},
+    {"mttb",		ibm032_RR},
+    {"svc",		ibm032_D},
+    {"ai",		ibm032_D},
+    {"cal16",		ibm032_D},
+    {"oiu",		ibm032_D},
+    {"oil",		ibm032_D},
+    {"nilz",		ibm032_D},
+    {"nilo",		ibm032_D},
+    {"xil",		ibm032_D},
+    {"cal",		ibm032_D},
+    {"lm",		ibm032_D},
+    {"lha",		ibm032_D},
+    {"ior",		ibm032_D},
+    {"ti",		ibm032_D},
+    {"l",		ibm032_D},
+    {"lc",		ibm032_D},
+    {"tsh",		ibm032_D},
+    {"lps",		ibm032_D},
+    {"aei",		ibm032_D},
+    {"sfi",		ibm032_D},
+    {"cli",		ibm032_D},
+    {"ci",		ibm032_D},
+    {"niuz",		ibm032_D},
+    {"niuo",		ibm032_D},
+    {"xiu",		ibm032_D},
+    {"cau",		ibm032_D},
+    {"stm",		ibm032_D},
+    {"lh",		ibm032_D},
+    {"iow",		ibm032_D},
+    {"sth",		ibm032_D},
+    {"st",		ibm032_D},
+    {"stc",		ibm032_D},
+    {0,			0},
+    {"abs",		ibm032_RR},
+    {"a",		ibm032_RR},
+    {"s",		ibm032_RR},
+    {"o",		ibm032_RR},
+    {"twoc",		ibm032_RR},
+    {"n",		ibm032_RR},
+    {"m",		ibm032_RR},
+    {"x",		ibm032_RR},
+    {"b%sr",		ibm032_RR | ibm032_conditional | ibm032_negative},
+    {"b%srx",		ibm032_RR | ibm032_conditional | ibm032_negative},
+    {0,			0},
+    {"lhs",		ibm032_RR},
+    {"balr",		ibm032_RR},
+    {"balrx",		ibm032_RR},
+    {"b%sr",		ibm032_RR | ibm032_conditional},
+    {"b%srx",		ibm032_RR | ibm032_conditional},
+    {"wait",		ibm032_RR},
+    {"ae",		ibm032_RR},
+    {"se",		ibm032_RR},
+    {"ca16",		ibm032_RR},
+    {"onec",		ibm032_RR},
+    {"clz",		ibm032_RR},
+    {0,			0},
+    {0,			0},
+    {0,			0},
+    {"mc03",		ibm032_RR},
+    {"mc13",		ibm032_RR},
+    {"mc23",		ibm032_RR},
+    {"mc33",		ibm032_RR},
+    {"mc30",		ibm032_RR},
+    {"mc31",		ibm032_RR},
+    {"mc32",		ibm032_RR},
+};
+
+#else
+struct ibm032_opcode ibm032_opcodes[MAXOPCODES];
+
+struct ibm032_instruction {
+    char *mnemonic; /* Mnemonic for this instruction */
+    char opcode; /* Numerical value of opcode. */
+    int type; /* This instructions format. */
+};
+
+struct ibm032_instruction ibm032_instructions[] =
+{
+ {"a",		0xe1, ibm032_RR},
+ {"abs",	0xe0, ibm032_RR},
+ {"ae",		0xf1, ibm032_RR},
+ {"aei",	0xd1, ibm032_D},
+ {"ai",		0xc1, ibm032_D},
+ {"ais",	0x90, ibm032_RI},
+ {"bala",	0x8a, ibm032_BA},
+ {"balax",	0x8b, ibm032_BA},
+ {"bali",	0x8c, ibm032_BI},
+ {"balix",	0x8d, ibm032_BI},
+ {"balr",	0xec, ibm032_RR},
+ {"balrx",	0xed, ibm032_RR},
+ {"b%s",	0x8e, ibm032_BI | ibm032_conditional},
+ {"b%sr",	0xee, ibm032_RR | ibm032_conditional},
+ {"b%srx",	0xef, ibm032_RR | ibm032_conditional},
+ {"b%sx",	0x8f, ibm032_BI | ibm032_conditional},
+ {"b%s",	0x88, ibm032_BI | ibm032_conditional | ibm032_negative},
+ {"b%sr",	0xe8, ibm032_RR | ibm032_conditional | ibm032_negative},
+ {"b%srx",	0xe9, ibm032_RR | ibm032_conditional | ibm032_negative},
+ {"b%sx",	0x89, ibm032_BI | ibm032_conditional | ibm032_negative},
+ {"c",		0xb4, ibm032_RR},
+ {"cal",	0xc8, ibm032_D},
+ {"cal16",	0xc2, ibm032_D},
+ {"cas",	0x60, ibm032_X},
+ {"cau",	0xd8, ibm032_D},
+ {"ca16",	0xf3, ibm032_RR},
+ {"ci",		0xd4, ibm032_D},
+ {"cis",	0x94, ibm032_RI},
+ {"cl",		0xb3, ibm032_RR},
+ {"cli",	0xd3, ibm032_D},
+ {"clrbl",	0x99, ibm032_RI},
+ {"clrbu",	0x98, ibm032_RI},
+ {"clrsb",	0x95, ibm032_RI},
+ {"clz",	0xf5, ibm032_RR},
+ {"d",		0xb6, ibm032_RR},
+ {"dec",	0x93, ibm032_RI},
+ {"exts",	0xb1, ibm032_RR},
+ {"inc",	0x91, ibm032_RI},
+ {"ior",	0xcb, ibm032_D},
+ {"iow",	0xdb, ibm032_D},
+
+ {"j%s",	0x08, ibm032_JI | ibm032_conditional},
+ {"j%s",	0x00, ibm032_JI | ibm032_conditional | ibm032_negative},
+
+ {"l",		0xcd, ibm032_D},
+ {"lc",		0xce, ibm032_D},
+ {"lcs",	0x40, ibm032_DS0},
+ {"lh",		0xda, ibm032_D},
+ {"lha",	0xca, ibm032_D},
+ {"lhas",	0x50, ibm032_DS1},
+ {"lhs",	0xeb, ibm032_RR},
+ {"lis",	0xa4, ibm032_RI},
+ {"lm",		0xc9, ibm032_D},
+ {"lps",	0xd0, ibm032_D},
+ {"ls",		0x70, ibm032_DS2},
+ {"m",		0xe6, ibm032_RR},
+ {"mc03",	0xf9, ibm032_RR},
+ {"mc13",	0xfa, ibm032_RR},
+ {"mc23",	0xfb, ibm032_RR},
+ {"mc33",	0xfc, ibm032_RR},
+ {"mc30",	0xfd, ibm032_RR},
+ {"mc31",	0xfe, ibm032_RR},
+ {"mc32",	0xff, ibm032_RR},
+ {"mfs",	0x96, ibm032_RR},
+ {"mftb",	0xbc, ibm032_RR},
+ {"mftbil",	0x9d, ibm032_RI},
+ {"mftbiu",	0x9c, ibm032_RI},
+ {"mts",	0xb5, ibm032_RR},
+ {"mttb",	0xbf, ibm032_RR},
+ {"mttbil",	0x9f, ibm032_RI},
+ {"mttbiu",	0x9e, ibm032_RI},
+ {"n",		0xe5, ibm032_RR},
+
+ {"nilo",	0xc6, ibm032_D},
+ {"nilz",	0xc5, ibm032_D},
+ {"niuo",	0xd6, ibm032_D},
+ {"niuz",	0xd5, ibm032_D},
+ {"o",		0xe3, ibm032_RR},
+ {"oil",	0xc4, ibm032_D},
+ {"oiu",	0xc3, ibm032_D},
+ {"onec",	0xf4, ibm032_RR},
+ {"s",		0xe2, ibm032_RR},
+ {"sar",	0xb0, ibm032_RR},
+ {"sari",	0xa0, ibm032_RI},
+ {"sari16",	0xa1, ibm032_RI},
+ {"se",		0xf2, ibm032_RR},
+ {"setbl",	0x9b, ibm032_RI},
+ {"setbu",	0x9a, ibm032_RI},
+ {"setsb",	0x97, ibm032_RI},
+ {"sf",		0xb2, ibm032_RR},
+
+ {"sfi",	0xd2, ibm032_D},
+
+ {"sis",	0x92, ibm032_RI},
+ {"sl",		0xba, ibm032_RR},
+ {"sli",	0xaa, ibm032_RI},
+ {"sli16",	0xab, ibm032_RI},
+ {"slp",	0xbb, ibm032_RR},
+ {"slpi",	0xae, ibm032_RI},
+ {"slpi16",	0xaf, ibm032_RI},
+ {"sr",		0xb8, ibm032_RR},
+ {"sri",	0xa8, ibm032_RI},
+ {"sri16",	0xa9, ibm032_RI},
+ {"srp",	0xb9, ibm032_RR},
+ {"srpi",	0xac, ibm032_RI},
+ {"srpi16",	0xad, ibm032_RI},
+
+ {"st",		0xdd, ibm032_D},
+
+ {"stc",	0xde, ibm032_D},
+ {"stcs",	0x10, ibm032_DS0},
+ {"sth",	0xdc, ibm032_D},
+ {"sths",	0x20, ibm032_DS1},
+ {"stm",	0xd9, ibm032_D},
+ {"sts",	0x30, ibm032_DS2},
+ {"svc",	0xc0, ibm032_D},
+ {"tgte",	0xbd, ibm032_RR},
+ {"ti",		0xcc, ibm032_D},
+ {"tlt",	0xbe, ibm032_RR},
+ {"tsh",	0xcf, ibm032_D},
+ {"twoc",	0xe4, ibm032_RR},
+ {"wait",	0xf0, ibm032_RR},
+ {"x",		0xe7, ibm032_RR},
+ {"xil",	0xc7, ibm032_D},
+ {"xiu",	0xd7, ibm032_D}
+};
+
+/* Code to generate the packed opcode table from the instructions table. */
+
+#include <stdio.h>
+
+char *typeNames[] = {
+    "ibm032_JI",
+    "ibm032_X",
+    "ibm032_DS0",
+    "ibm032_DS1",
+    "ibm032_DS2",
+    "ibm032_RR",
+    "ibm032_RI",
+    "ibm032_BI",
+    "ibm032_BA",
+    "ibm032_D"
+};
+
+main()
+{
+
+    int i, j, opcode, type;
+
+    for (j = (sizeof(ibm032_instructions) / sizeof(struct ibm032_instruction)); j >= 0; j--) {
+        opcode = ibm032_instructions[j].opcode;
+        switch (ibm032_instructions[j].type & ibm032_typeMask) {
+            case ibm032_JI:
+                i = 7;
+                break;
+            case ibm032_X:
+            case ibm032_DS0:
+            case ibm032_DS1:
+            case ibm032_DS2:
+                i = 15;
+                break;
+            case ibm032_RR:
+            case ibm032_RI:
+            default:
+                i = 0;
+                break;
+        }
+        for (;i >= 0; i--) {
+            ibm032_opcodes[opcode + i].mnemonic = ibm032_instructions[j].mnemonic;
+            ibm032_opcodes[opcode + i].type = ibm032_instructions[j].type;
+        }
+    }
+
+    printf("struct ibm032_opcode ibm032_opcodes[] = {\n");
+    for ( j = 0; j < 256; j++) {
+        type = ibm032_opcodes[j].type;      
+        if (ibm032_opcodes[j].mnemonic != NULL)
+            printf("    {\"%s\",\t\t%s%s%s},\n", ibm032_opcodes[j].mnemonic,
+                   typeNames[type & ibm032_typeMask],
+                   (type & ibm032_conditional) ? " | ibm032_conditional" : "",
+                   (type & ibm032_negative) ? " | ibm032_negative" : "");
+        else
+            printf("    {0,\t\t\t0},\n");
+    }
+    printf("};\n");
+}
+#endif /* BUILDTABLE */
+
+Only in .: ibm032-pinsn.c
+
+/* Print ibm032 instructions for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "ibm032-opcode.h"
+
+/* ibm032 instructions are never longer than this many bytes.  */
+#define MAXLEN 4
+
+extern char *reg_names[];
+
+static char *mapCondition();
+
+
+/* Print the ibm032 instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  int opcodeIndex, instructionBits, type;
+  char *mnemonic;
+
+  read_memory (memaddr, buffer, MAXLEN);
+  instructionBits = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; /* Get it into an int for easy use. */
+
+  if ((mnemonic = ibm032_opcodes[opcodeIndex = buffer[0]].mnemonic) == NULL)
+    {
+      fprintf (stream, "0%o", (instructionBits & HIGH16) >> 16);
+      return 2;
+    }
+  type = ibm032_opcodes[opcodeIndex].type;
+  if (!(type & ibm032_conditional)) {
+    fprintf (stream, "%s", mnemonic);
+
+    switch (type) {
+
+      int displacement; /* Used for sign extensions. */
+      char *sign;
+
+      case ibm032_X:
+        fprintf(stream, "\t%s, %s(%s)", reg_names[buffer[0] & LOW4], (buffer[1] & HIGH4) ? (reg_names[(buffer[1] & HIGH4) >> 4]) : "", reg_names[buffer[1] & LOW4]);
+        return 2;
+      case ibm032_DS0:
+      case ibm032_DS1:
+      case ibm032_DS2:
+        fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], (buffer[0] & LOW4) << (ibm032_opcodes[opcodeIndex].type - ibm032_DSShiftOffset)); /* Hacked to shift imediate field. */
+        if (buffer[1] & LOW4)
+          fprintf(stream, "(%s)", reg_names[buffer[1] & LOW4]);
+        return 2;
+      case ibm032_RR:
+        fprintf(stream, "\t%s, %s", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & 0x0f]);
+        return 2;
+      case ibm032_RI:
+        fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], buffer[1] & LOW4);
+        return 2;
+      case ibm032_BI:
+        fprintf(stream, "\t%s, ", reg_names[(buffer[1] & HIGH4) >> 4]);
+        displacement = (instructionBits & LOW20);
+        if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
+            displacement |= 0xfff00000;
+        print_address(memaddr + (displacement * 2), stream); /* Need sign extension. */
+        return 4;
+      case ibm032_BA:
+        print_address((instructionBits & LOW24) & ~1, stream);
+        return 4;
+      case ibm032_D:
+        displacement = (instructionBits & LOW16);
+        if ((displacement & (1 << 15)) != 0) { /* Cover sign extension. */
+          displacement = - (displacement | 0xffff0000);
+          sign = "-";
+        }
+        else
+          sign = "";
+        fprintf(stream, "\t%s, %s, %s%x", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & LOW4], sign, displacement);
+        return 4;
+    }
+  }
+  else { /* Conditional branches are hacked. */
+    switch (type & 0x0f) {
+
+      int displacement;
+
+      case ibm032_JI:
+        fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, buffer[0] & LOW4));
+      putc('\t', stream);
+      print_address((buffer[1] << 1) + memaddr, stream);
+      return 2;
+    case ibm032_BI:
+      fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
+      putc('\t', stream);
+        displacement = (instructionBits & LOW20);
+        if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
+            displacement |= 0xfff00000;
+        print_address((displacement * 2) + memaddr, stream);
+      return 4;
+    case ibm032_RR:
+      fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
+      fprintf(stream, "\t%s", reg_names[buffer[1] & LOW4]);
+      return 2;   
+    }
+  }
+}
+
+/* Converts a 4 bit "conditional specifier" into a semi-meaningful name. */
+static char *mapCondition(negative, conditionBits)
+    int conditionBits;
+{
+
+    char *condition;
+
+    if (negative)
+        switch (conditionBits) {
+            case 0x8:
+                condition = "";
+                break;
+            case 0x9:
+                condition = "ge";
+                break;
+            case 0xa:
+                condition = "ne";
+                break;
+            case 0xb:
+                condition = "le";
+                break;
+            case 0xc:
+                condition = "nc";
+                break;
+            case 0xd: /* Reserved. */
+                condition = "notbogus";
+                break;
+            case 0xe:
+                 condition = "no";
+                break;
+            case 0xf:
+                condition = "ntb";
+                break;
+            default:
+                condition = "notbogus";
+                break;
+        }
+    else
+        switch (conditionBits) {
+            case 0x8:
+                condition = "nop";
+                break;
+            case 0x9:
+                condition = "lt";
+                break;
+            case 0xa:
+                condition = "eq";
+                break;
+            case 0xb:
+                condition = "gt";
+                break;
+            case 0xc:
+                condition = "c";
+                break;
+            case 0xd: /* Reserved. */
+                condition = "bogus";
+                break;
+            case 0xe:
+                condition = "o";
+                break;
+            case 0xf:
+                condition = "tb";
+                break;
+            default:
+                condition = "bogus";
+                break;
+        }
+    return condition;
+}
+
+Only in .: m-ibm032.h
+
+/* Parameters for execution on an IBM RT, for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 1) & 0x00ff; \
+    if (op == 0xd9) { \
+	pc += 4; \
+	op = read_memory_integer (pc, 2); \
+	if ((op & 0xff00) == 0xc100) { /* pcc prolog add r1, number */ \
+	    pc += 4; \
+	    op = read_memory_integer (pc, 1) & 0x00ff; \
+	    if (op == 0x6e) { 			/* cas r14, 0 */ \
+		pc += 2; \
+		op = read_memory_integer (pc, 2) & 0xffff; \
+		if (op == 0xc8d1) pc += 4; /* cal r13, junk(r1) */ \
+	    } \
+	} \
+	else if ((op & 0xffff) == 0x6e00) { /* hc prolog cas r14, 0 */ \
+	    pc += 4; \
+	    op = read_memory_integer(pc, 1) & 0xff; \
+	    if (op == 0x6d) { /* cas r13 junk, probably */ \
+		pc += 2; \
+		op = read_memory_integer(pc, 2) & 0xffff; \
+		if (op == 0xc811) pc += 4; /* cal r1,  foo(r1) */	\
+	    } \
+	} \
+    } \
+    while (1) { \
+	/* now watch for st, sth, stc, and short versions thereof, cas instructions and exts */ \
+	/* which are all used to store the parameters from r2-r5 onto the stack or into reg vars */ \
+	op = read_memory_integer (pc, 2); \
+	if ((op & 0xff00) == 0x3000 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
+	else if ((op & 0xff00) == 0x2300 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
+	else if ((op & 0xff00) == 0x1b00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
+	else if ((op & 0xff00) == 0x6c00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
+	else if ((op & 0xff00) == 0xb100) pc += 2; /* extend sign */ \
+	else if ((op & 0xff00) == 0xdd00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 4; \
+	else break; \
+    } \
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_register (15)
+
+/* This is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values.  */
+
+#define KERNEL_U_ADDR (0x20000000 - NBPG * (UPAGES))
+
+/* Address of end of stack space.  */
+
+/* extra page is for the "red zone" */
+#define STACK_END_ADDR (0x20000000 - NBPG * (UPAGES+1))
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0xbd, 0x00}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) & 0x00ff == 0xc9)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p) 0   /* Just a first guess; not checked */
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 18
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "iar", "mq"}
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 13		/* Contains address of executing stack frame */
+#define SP_REGNUM 1		/* Contains address of top of stack */
+#define PS_REGNUM 17		/* Contains processor status */
+#define PC_REGNUM 16		/* Contains program counter */
+
+#define REGISTER_U_ADDR(addr, blockend, regno)		\
+{ addr = blockend + regno * 4; }
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (NUM_REGS*4)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N) ((N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the vax, all regs are 4 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) 4
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the vax, all regs are 4 bytes.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) 4
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 4
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 4
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) 0
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), 4);
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), 4);
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Sun, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (rt_prev_frame(thisframe))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain >= 0x10000000 && chain < 0x20000000)
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (rt_frame_reg(frame, 15))
+
+#define FRAME_ARGS_ADDRESS(fi) (rt_frame_args(fi.frame))
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.  */
+
+#define FRAME_NUM_ARGS(val, fi)  \
+{register struct rt_frame *tf; \
+    tf = get_cached_frame(fi.frame); \
+    val = -1; \
+    if (tf) val = tf->nParms;\
+}
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 0
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register struct rt_frame *tf;			\
+  register CORE_ADDR next_addr;						\
+  bzero (&(frame_saved_regs), sizeof (frame_saved_regs));			\
+  tf = get_cached_frame((frame_info).frame);					\
+  if (tf) {											\
+    for(regnum = tf->firstReg; regnum < 16; regnum++) {		\
+      (frame_saved_regs).regs[regnum] = tf->firstRLoc+ 4*(regnum - tf->firstReg); \
+    } \
+  } \
+}
+
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);\
+  register int regnum;				    \
+  sp = push_word (sp, read_register (PC_REGNUM));   \
+  for (regnum = 15; regnum >= 0; regnum--)  \
+    sp = push_word (sp, read_register (regnum));    \
+  write_register (FP_REGNUM, sp+64);		    \
+  write_register (SP_REGNUM, sp);  }
+
+/* discard special frame pushed by PUSH_DUMMY_FRAME */
+#define POP_DUMMY_FRAME \
+    {register CORE_ADDR sp; \
+    register int regnum; \
+    sp = read_register(FP_REGNUM)-64; \
+    for(regnum = 0; regnum < 16;regnum++) { \
+	write_register(regnum, read_memory_integer(sp, 4)); \
+	sp += 4; \
+    } \
+    /* now get the pc */ \
+    write_register(PC_REGNUM, read_memory_integer(sp, 4)); \
+    sp += 4; \
+    }
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+/* THIS ROUTINE DOES NOT SET R1 (SP_REGNUM) CORRECTLY */
+/* REALLY MUST CONSULT TRACE TBL TO FIND OUT FRAME SIZE */
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  register struct rt_frame *tf;			\
+  tf = (struct rt_frame *) get_cached_frame(fp);			\
+  if (tf) {							\
+    for(regnum = tf->firstReg; regnum < 16; regnum++) {		\
+	write_register(regnum,				\
+	    read_memory_integer (tf->firstRLoc + 4*(regnum-tf->firstReg), 4)	\
+	    );	\
+    }		\
+    write_register(PC_REGNUM, read_register(15));		\
+    write_register(SP_REGNUM, tf->firstRLoc + 4*(16-tf->firstReg) + 36);	\
+  }		\
+}
+
+/* This sequence of words is the instructions
+     ls		r2,0(r1)			2 bytes		pick up args
+     ls		r3,4(r1)			2 bytes		pick up args
+     ls		r4,8(r1)			2 bytes		pick up args
+     ls		r5,c(r1)			2 bytes		pick up args
+     cal	r1,16(r1)			4 bytes		fix up ap (==sp)
+     cal16	r15,<low>			4 bytes		do call
+     oiu	r15,<high>(r15)	4
+     lr		r0,r15			2
+     ls		r15,0(r15)			2
+     balr	r15				2
+     bpt					2			get back to gdb
+     <4 byte trace table>		4
+
+This is 16 bytes.
+*/
+
+#define CALL_DUMMY {0x70217131, 0x72417351, 0xc8110010, 0xc2f06969, \
+    0xc3ff6969, 0x60f070ff, 0xecffbd00, 0xdf7fdf00}
+
+#define CALL_DUMMY_LENGTH 32
+
+#define CALL_DUMMY_START_OFFSET 0
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *((short *)(((char *)dummyname)+14)) = fun&0xffff; \
+*((short *)(((char *)dummyname)+18)) = (fun>>16)&0xffff; \
+}
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb, which we do not support. */
+
+#define INIT_STACK(beg, end)  \
+{  }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR \
+{ }
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR \
+{ }
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ }
+
+Only in .: m-ibm032init.h
+
+/* This is how the size of an individual .o file's text segment
+   is rounded on a sun.  */
+
+#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
+
+diff -c ../../gnu/gdb/blockframe.c ./blockframe.c
+*** ../../gnu/gdb/blockframe.c	Sat Apr  4 22:06:18 1987
+--- ./blockframe.c	Mon Apr 27 01:06:06 1987
+***************
+*** 53,62 ****
+  }
+  
+  void
+! set_current_frame (frame)
+       FRAME frame;
+  {
+    current_frame = frame;
+  }
+  
+  /* Return the frame that called FRAME.
+--- 53,67 ----
+  }
+  
+  void
+! set_current_frame (frame, validp)
+       FRAME frame;
++      int validp;
+  {
+    current_frame = frame;
++ #ifdef ibm032
++   if (validp)
++     recache_frames();
++ #endif
+  }
+  
+  /* Return the frame that called FRAME.
+***************
+*** 291,301 ****
+       CORE_ADDR pc;
+  {
+    register int i;
+  
+    /* Note that the last thing in the vector is always _etext.  */
+    for (i = 0; i < misc_function_count; i++)
+      {
+!       if (pc < misc_function_vector[i].address)
+  	return i - 1;
+      }
+    return -1;
+--- 296,309 ----
+       CORE_ADDR pc;
+  {
+    register int i;
++   register long j;
+  
+    /* Note that the last thing in the vector is always _etext.  */
+    for (i = 0; i < misc_function_count; i++)
+      {
+!       if ((j = misc_function_vector[i].address) < 0)
+!         continue;
+!       if (pc < j)
+  	return i - 1;
+      }
+    return -1;
+***************
+*** 325,333 ****
+--- 333,610 ----
+      }
+  }
+  
++ #ifdef ibm032
++ /* RT frame format:
++     arg 3	these are not really here, but are in regs
++     arg 2
++     arg 1
++     arg 0
++     resvd 20 bytes
++     rn to r15	saved regs
++     floating regs (at first assume 0 bytes, fix later)
++     locals
++ 
++ N.B. r13 points 64 bytes below the end of the locals.
++ */
++ 
++ /*
++  * Routine for ibm032 stack trace.  Called after a new frame has been set.  Do an entire stack
++  * trace, and squirrel away the information.  We need to do this since the ibm032 (rt) does
++  * not have enough info in a known place off of the frame ptr (r13) to do anything useful.
++  * Instead, one also requires the pc, and can then perform various operations to find
++  * out how that procedure built its frame, and thus, to decode it.  However, since this is
++  * fairly slow, we only do it after a set_current_frame operation has been performed.
++ */
++ 
++ #define rtTTSize 50
++ static struct rtTTCache {
++     CORE_ADDR lbound;		/* lowest address so far known as using this trace table */
++     CORE_ADDR ttaddr;		/* address of the last '0xdf' in the trace table */
++     char ttype;				/* type of the trace table -- 0 == unused */
++ } ttcache[rtTTSize];
++ short ttptr = 0;
++ 
++ #define rtSize	50
++ static struct rt_frame rtFrames[rtSize];
++ static int rtCount;
++ static CORE_ADDR rt_next_frame, rt_next_pc;
++ 
++ static struct rtTTCache *ttfind (addr)
++     CORE_ADDR addr; {
++     register int i;
++     register struct rtTTCache *tp;
++     for(i=0,tp=ttcache;i<rtTTSize;i++,tp++) {
++ 	if (addr >= tp->lbound && addr <= tp->ttaddr) return tp;
++     }
++     return 0;
++ }
++ 
++ static ttadd(lowaddr, ttaddr, type)
++     register CORE_ADDR lowaddr, ttaddr;
++     char type; {
++     register struct rtTTCache *tp;
++     if (tp = ttfind(ttaddr)) {
++ 	/* possibly increase the bound on this cache element */
++ 	if (lowaddr < tp->lbound) tp->lbound = lowaddr;
++     }
++     else {
++ 	/* add a new element */
++ 	tp = &ttcache[ttptr++];
++ 	tp->lbound = lowaddr;
++ 	tp->ttaddr = ttaddr;
++ 	tp->ttype = type;
++ 	if (ttptr >= rtTTSize) ttptr = 0;	/* keep it in bounds */
++     }
++ }
++ 
++ /* this routine scans for a trace table, and returns 4 bytes: 0 0 <n params> <first saved reg> */
++ rt_num_regs (pc, tf)
++ register struct rt_frame *tf;
++ CORE_ADDR pc; {
++     register state = 0;
++     register long newpc = pc;
++     register int tc;
++     short nparms, firstreg;
++     short ttype;
++     short optx;
++     long offset;
++     char offtype;
++     struct rtTTCache *tp;
++     CORE_ADDR frame;
++ 
++     frame = tf->frame;
++     /* first see if it is in our ttcache */
++     if (tp = ttfind(pc)) {
++ 	state = 3;
++ 	ttype = tp->ttype;
++ 	newpc = tp->ttaddr;
++     }
++     else {
++ 	/* state machine to look for 'df' 'xx' 'df' */
++ 	while (1) {
++ 	    tc = read_memory_integer(newpc, 2);
++ 	    if (state == 0 && (tc&0xff00) == 0xdf00) {
++ 		state = 1;
++ 		ttype = tc & 0xff;
++ 	    }
++ 	    else if (state == 1 && (tc & 0xff00) == 0xdf00) {
++ 		state = 3;
++ 		break;
++ 	    }
++ 	    else state = 0;
++ 	    if (newpc - pc > 20000) break;
++ 	    newpc += 2;
++ 	}
++ 	if (state == 3) ttadd(pc, newpc, ttype);	/* add to cache */
++     }
++     if (state != 3) {
++ 	printf("No trace table for pc %x, making one up.\n", pc);
++ 	tf->nParms = 0;
++ 	tf->firstReg = 12;
++ 	tf->firstRLoc = frame+64;
++ 	rt_next_pc = read_memory_integer(frame+64+12, 4);
++ 	rt_next_frame = read_memory_integer(frame+64+4, 4);
++ 	return 0;
++     }
++     /* otherwise newpc is pointing at the last 'df' in the trace table */
++     else if (ttype == 3) {
++ 	/* funny trace table found by OBSERVATION (not doc) to be in program prolog */
++ 	return -1;		/* special value checked by recache_frames */
++     }
++     else if (ttype == 2) {
++ 	/* assembly: no registers were saved */
++ 	tf->nParms = 0;
++ 	tf->firstReg = 16;
++ 	tf->firstRLoc = 0;
++ 	rt_next_pc = read_register(15);		/* where we go back to */
++ 	rt_next_frame = frame;
++ 	tf->frame -= 100;		/* hack to eliminate duplicate tags */
++ 	return 0;
++     }
++     else if (ttype == 0x7f) {
++ 	/* special machine state frame saved by STACK_DUMMY */
++ 	tf->nParms = 0;
++ 	tf->firstReg = 16;
++ 	tf->firstRLoc = 0;
++ 	rt_next_pc = read_memory_integer(frame + 64 - 64, 4);
++ 	rt_next_frame = read_memory_integer(frame -64 + 13*4, 4);
++ 	return 0;
++     }
++     else {
++ 	/* C program, I hope */
++ 	nparms = (read_memory_integer(newpc+2, 1) >> 4) & 0x0f;
++ 	firstreg = ((tc=read_memory_integer(newpc+1, 1)) >> 4) & 0x0f;
++ 	optx = ((tc&4)? 1 : 0);	/* flags says if floating registers described */
++ 	offtype = read_memory_integer(newpc+optx+3, 1) & 0xff;
++ 	if ((offtype & 0xc0) == 0) {
++ 	    /* 6 bits of local offset */
++ 	    offset = offtype & 0x3f;
++ 	}
++ 	else if ((offtype & 0xc0) == 0x40) {
++ 	    /* 14 bits of local offset */
++ 	    offset = (offtype & 0x3f) << 8;
++ 	    offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
++ 	}
++ 	else if ((offtype & 0xc0) == 0x80) {
++ 	    /* 22 bits of local offset */
++ 	    offset = (offtype & 0x3f) << 8;
++ 	    offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
++ 	    offset <<= 8;
++ 	    offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
++ 	}
++ 	else if ((offtype & 0xc0) == 0xc0) {
++ 	    /* 30 bits of local offset */
++ 	    offset = (offtype & 0x3f) << 8;
++ 	    offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
++ 	    offset <<= 8;
++ 	    offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
++ 	    offset <<= 8;
++ 	    offset += (read_memory_integer(newpc+optx+6, 1) & 0xff);
++ 	}
++ 	offset <<= 2;
++ 	tf->nParms = nparms;
++ 	tf->firstReg = firstreg;
++ 	tf->firstRLoc = frame	/* initial frame location */
++ 	    + offset				/* to top of frame */
++ 	    - 36				/* pascal static link, incomings args and linkage */
++ 	    - (4*(16-firstreg));	/* space used by general regs */
++ 	rt_next_pc = read_memory_integer(tf->firstRLoc + 4*(15-firstreg), 4);
++ 	rt_next_frame = read_memory_integer(tf->firstRLoc + 4*(13-firstreg), 4);
++ 	return 0;
++     }
++ }
++ 
++ recache_frames() {
++     register long i, j;
++     long pc;
++     CORE_ADDR curfp;
++     struct rt_frame *tf;
++ 
++     pc = read_pc();
++     curfp = current_frame;
++     rtCount = 0;
++     /* these next special cases can only occur with frame #0; others can't make calls
++         in these intermediate states.
++     */
++     /* if pc points at br or brx, we're doing a return, so set the pc to the target */
++     i=read_memory_integer(pc, 2);
++     if ((i & 0xfe00) == 0xe800) {
++ 	/* we're looking at a br or brx instruction */
++ 	pc = read_register(i&0x0f);
++     }
++     /* also, if pc points at d9xx or c111 we're in the middle of a frame push, and should
++        use r15 for the pc.
++    */
++    if ((i & 0xff00) == 0xd900 || (i & 0xffff) == 0xc111) {
++ 	pc = read_register(15);
++    }
++     while (1) {
++ 	if (curfp <= 0x10000000 || curfp >= 0x20000000) break;
++ 	if (pc > 0x20000000) break;
++ 	/* otherwise try to add a new frame structure */
++ 	if (rtCount >= rtTTSize) break;
++ 	tf = &rtFrames[rtCount++];
++ 	tf->frame = curfp;
++ 	tf->pc = pc;
++ 	i = rt_num_regs(pc, tf);
++ 	if (i<0) {	/* exceptional values */
++ 	    rtCount--;		/* last frame was bogus */
++ 	    break;
++ 	}
++ 	/* now setup for next iteration */
++ 	pc = rt_next_pc;
++ 	curfp = rt_next_frame;
++     }
++ }
++ 
++ struct rt_frame *get_cached_frame(aframe)
++ CORE_ADDR aframe; {
++     register int i;
++     for(i=0;i<rtCount;i++) {
++ 	if (rtFrames[i].frame == aframe) return &rtFrames[i];
++     }
++     return 0;
++ }
++ 
++ long rt_prev_frame(frame)
++ register CORE_ADDR frame; {
++     register int i;
++     for(i=0;i<rtCount-1;i++) {
++ 	if (rtFrames[i].frame == frame) return rtFrames[i+1].frame;
++     }
++     return 0;
++ }
++ 
++ long rt_frame_reg(frame, reg)
++ CORE_ADDR frame;
++ register long reg; {
++     register struct rt_frame *tf;
++     tf = get_cached_frame(frame);
++     if (tf == 0) return 0;
++     if (tf->firstReg > reg) return 0;	/* didn't save this one! */
++     return read_memory_integer(tf->firstRLoc + 4 * (reg - tf->firstReg), 4);
++ }
++ 
++ long rt_frame_args(frame)
++ CORE_ADDR frame; {
++     register struct rt_frame *tf;
++     tf = get_cached_frame(frame);
++     if (!tf) return 0;
++     return tf->firstRLoc + 20 + 4*(16 - tf->firstReg);
++ }
++ #endif
++ 
++ blockinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
++ #ifdef ibm032
++ #ifdef CAMPHOR
++   add_com ("recache-frames", class_stack, recache_frames,
++       "Tell debugger to recompute PC/RT stack frame cache\n");
++ #endif
++ #endif
+  }
+  
+  END_FILE
+diff -c ../../gnu/gdb/breakpoint.c ./breakpoint.c
+*** ../../gnu/gdb/breakpoint.c	Sat Apr  4 22:22:44 1987
+--- ./breakpoint.c	Sun Apr 26 23:02:20 1987
+***************
+*** 94,99 ****
+--- 94,100 ----
+     of last breakpoint hit.  */
+  
+  struct command_line *breakpoint_commands;
++ char new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
+  
+  START_FILE
+  
+***************
+*** 203,210 ****
+      {
+        execute_command (breakpoint_commands->line, 0);
+        /* If command was "cont", breakpoint_commands is 0 now.  */
+!       if (breakpoint_commands)
+  	breakpoint_commands = breakpoint_commands->next;
+      }
+    clear_momentary_breakpoints ();
+  }
+--- 204,213 ----
+      {
+        execute_command (breakpoint_commands->line, 0);
+        /* If command was "cont", breakpoint_commands is 0 now.  */
+!       if (breakpoint_commands && !new_breakpoint_commands) /* Zalman Stern, ITC 1/12/1987 */
+  	breakpoint_commands = breakpoint_commands->next;
++       else /* Zalman Stern, ITC 1/12/1987 */
++         new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
+      }
+    clear_momentary_breakpoints ();
+  }
+***************
+*** 215,220 ****
+--- 218,225 ----
+  void
+  clear_breakpoint_commands ()
+  {
++   if (breakpoint_commands != 0) /* Zalman Stern, ITC 1/12/1987 */
++     new_breakpoint_commands = 1; /* Zalman Stern, ITC 1/12/1987 */
+    breakpoint_commands = 0;
+    breakpoint_auto_delete (0);
+  }
+***************
+*** 921,926 ****
+--- 926,933 ----
+  struct cmd_list_element *enablelist;
+  
+  extern struct cmd_list_element *cmdlist;
++ 
++ breakinitialize() {initialize();}
+  
+  static
+  initialize ()
+diff -c ../../gnu/gdb/command.c ./command.c
+*** ../../gnu/gdb/command.c	Sat Apr  4 22:24:07 1987
+--- ./command.c	Sat Apr 25 17:18:15 1987
+***************
+*** 94,100 ****
+  You are forbidden to forbid anyone else to use, share and improve
+  what you give them.   Help stamp out software-hoarding!  */
+  
+- 
+  #include "command.h"
+  #include <stdio.h>
+  
+--- 94,99 ----
+***************
+*** 388,394 ****
+      {
+        if (nfound > 1 && allow_unknown >= 0)
+  	{
+! 	  *p = 0;
+  	  ambbuf[0] = 0;
+  	  for (c = list; c; c = c->next)
+  	    if (!strncmp (*line, c->name, p - *line))
+--- 387,393 ----
+      {
+        if (nfound > 1 && allow_unknown >= 0)
+  	{
+!           *p = 0;
+  	  ambbuf[0] = 0;
+  	  for (c = list; c; c = c->next)
+  	    if (!strncmp (*line, c->name, p - *line))
+diff -c ../../gnu/gdb/core.c ./core.c
+*** ../../gnu/gdb/core.c	Sat Apr  4 22:27:23 1987
+--- ./core.c	Mon Apr 27 13:20:47 1987
+***************
+*** 163,172 ****
+  	int reg_offset;
+  
+  	/* 4.2bsd-style core dump */
+  	val = myread (corechan, &u, sizeof u);
+  	if (val < 0)
+! 	  perror_with_name (filename);
+  	data_start = exec_data_start;
+  	data_end = data_start + NBPG * u.u_dsize;
+  	stack_start = stack_end - NBPG * u.u_ssize;
+  	data_offset = NBPG * UPAGES;
+--- 163,180 ----
+  	int reg_offset;
+  
+  	/* 4.2bsd-style core dump */
++ #ifdef ibm032
++ 	/* on ibm032, uarea is at the far end of the u pages */
++ 	lseek(corechan, UPAGES*NBPG - sizeof(u), 0);
++ #endif
+  	val = myread (corechan, &u, sizeof u);
+  	if (val < 0)
+! 	  perror_with_name (execfile);
+! #ifdef ibm032
+! 	data_start = 0x10000000;
+! #else
+  	data_start = exec_data_start;
++ #endif
+  	data_end = data_start + NBPG * u.u_dsize;
+  	stack_start = stack_end - NBPG * u.u_ssize;
+  	data_offset = NBPG * UPAGES;
+***************
+*** 208,214 ****
+  	  corefile = concat (dirname, "/", filename);
+  	}
+  
+!       set_current_frame (read_register (FP_REGNUM));
+        select_frame (get_current_frame (), 0);
+        validate_files ();
+      }
+--- 216,222 ----
+  	  corefile = concat (dirname, "/", filename);
+  	}
+  
+!       set_current_frame (read_register (FP_REGNUM), 1);
+        select_frame (get_current_frame (), 0);
+        validate_files ();
+      }
+***************
+*** 523,528 ****
+--- 531,539 ----
+  
+  #endif /* not NEW_SUN_CORE */
+  
++ 
++ coreinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/dbxread.c ./dbxread.c
+*** ../../gnu/gdb/dbxread.c	Sat Apr  4 22:29:54 1987
+--- ./dbxread.c	Fri May 15 15:52:24 1987
+***************
+*** 28,33 ****
+--- 28,36 ----
+  #include "initialize.h"
+  #include "symtab.h"
+  #include "param.h"
++ #ifdef CAMPHOR
++ #include "value.h"
++ #endif
+  
+  static void add_symbol_to_list ();
+  static void read_dbx_symtab ();
+***************
+*** 89,94 ****
+--- 92,109 ----
+    int prev_line_number;
+  };
+  
++ /*  When dealing with dynamically loaded objects, the symbol table in the sym file
++     does not match where we actually load the files.  Thus, gdb has to relocate those
++     symbols during dbxread.  This is only used by the camphor support code, and
++     probably should be under an ifdef camphor.  */
++ 
++ struct dlreloc
++   {
++     long text;
++     long data;
++     long bss;
++   } dlreloc;
++ 
+  static struct subfile *subfiles;
+  
+  static struct subfile *current_subfile;
+***************
+*** 1015,1020 ****
+--- 1030,1037 ----
+    register int i, nbl;
+    register struct blockvector *bv;
+    register struct block *b;
++   int j;
++   struct symbol *ts1, *ts2;
+  
+    for (s = symtab_list; s; s = s->next)
+      {
+***************
+*** 1025,1034 ****
+--- 1042,1238 ----
+  	  b = BLOCKVECTOR_BLOCK (bv, i);
+  	  qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
+  		 sizeof (struct symbol *), compare_symbols);
++           /* Register parms have two decls, but the register one is the only one of interest */
++ 	  /* So, trash the name of the bad one, since binary srch could get either.  Yucko. */
++ 	  /* doing name this way enables symbol freeing code to keep working */
++           for(j=1;j<BLOCK_NSYMS(b);j++)
++ 	     {
++ 		ts1 = BLOCK_SYM(b,j-1);
++                 ts2 = BLOCK_SYM(b, j);
++ 		if (SYMBOL_NAMESPACE(ts1) == VAR_NAMESPACE
++ 		 && SYMBOL_NAMESPACE(ts2) == VAR_NAMESPACE
++ 		 && strcmp(SYMBOL_NAME(ts1), SYMBOL_NAME(ts2)) == 0)
++ 		  {if (SYMBOL_CLASS(ts1) == LOC_REGISTER)
++ 		    {SYMBOL_CLASS(ts2) = LOC_REGISTER;
++ 		    SYMBOL_TYPE(ts2) = SYMBOL_TYPE(ts1);
++ 		    SYMBOL_VALUE(ts2) = SYMBOL_VALUE(ts1);
++ 		    }
++ 		  else if (SYMBOL_CLASS(ts2) == LOC_REGISTER )
++ 		    {SYMBOL_CLASS(ts1) = LOC_REGISTER;
++ 		    SYMBOL_TYPE(ts1) = SYMBOL_TYPE(ts2);
++ 		    SYMBOL_VALUE(ts1) = SYMBOL_VALUE(ts2);
++ 		    }
++ #ifdef notdef
++ 		  else printf("Check out def of symbol %s\n", SYMBOL_NAME(ts1));
++ #endif
++ 		  }
++ 	     }
+  	}
+      }
+  }
+  
++ 
++ #ifdef CAMPHOR
++ set_rel_command(exp)
++       char *exp;
++ {
++   struct expression *expr = (struct expression *) parse_c_expression (exp);
++   register value val;
++   register long temp;
++   register struct cleanup *old_chain
++     = make_cleanup (free_current_contents, &expr);
++   val = evaluate_expression (expr);
++   temp = value_as_long (val);
++   dlreloc.text = dlreloc.data = dlreloc.bss = temp;
++   printf("Relocation for all segs set to %x.\n", temp);
++   do_cleanups (old_chain);
++ }
++ 
++ void
++ add_file_command (name)
++      char *name;
++ {
++   register int desc;
++   struct exec hdr;
++   struct nlist *nlist;
++   char *stringtab;
++   long buffer;
++   register int val;
++   extern void close ();
++   struct cleanup *old_chain;
++   int in_this_dir = 1;
++   struct symtab *symtab_temp;
++ 
++   dont_repeat ();
++ 
++   if (name == 0)
++     error_no_arg ("file to add symbols from");
++ 
++   if (symtab_list && !query ("Add more symbols from \"%s\"? ", name))
++     error ("Not confirmed.");
++ 
++   if (symfile)
++     free (symfile);
++   symfile = 0;
++ 
++   desc = open (name, 0);
++   if (desc < 0)
++     {
++       if ((desc = openp (getenv ("BZPATH"), name, 0, 0)) < 0)
++         if ((desc = openp (getenv ("CLASSPATH"), name, 0, 0)) < 0)
++           desc = openp (getenv ("PATH"), name, 0, 0);
++ 
++       in_this_dir = 0;
++     }
++   if (desc < 0)
++     perror_with_name (name);
++ 
++   old_chain = make_cleanup (close, desc);
++ 
++   val = myread (desc, &hdr, sizeof hdr);
++   if (val < 0)
++     perror_with_name (name);
++ 
++   if (N_BADMAG (hdr))
++     error ("File \"%s\" not in executable format.", name);
++ 
++   if (hdr.a_syms == 0)
++     {
++       free_all_symtabs ();		/* check this */
++       return;
++     }
++ 
++   /* Now read the string table, all at once.  */
++   val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
++   if (val < 0)
++     perror_with_name (name);
++   val = myread (desc, &buffer, sizeof buffer);
++   if (val < 0)
++     perror_with_name (name);
++   stringtab = (char *) alloca (buffer);
++   bcopy (&buffer, stringtab, sizeof buffer);
++   val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
++   if (val < 0)
++     perror_with_name (name);
++ 
++ #ifdef READ_GDB_SYMSEGS
++   /* That puts us at the symsegs.  Read them.  */
++   symseg_chain = read_symsegs (desc, name);
++   hash_symsegs ();
++ #else
++   /* Where people are using the 4.2 ld program, must not check for
++      symsegs, because that ld puts randonm garbage at the end of
++      the output file and that would trigger an error message.  */
++   symseg_chain = 0;
++ #endif
++ 
++   /* Position to read the symbol table.  Do not read it all at once. */
++   val = lseek (desc, N_SYMOFF (hdr), 0);
++   if (val < 0)
++     perror_with_name (name);
++ 
++   printf ("Reading symbol data from %s...", name);
++   fflush (stdout);
++ 
++   init_misc_functions ();
++   make_cleanup (discard_misc_bunches, 0);
++   init_header_files ();
++   make_cleanup (free_header_files, 0);
++ 
++  /* Remember symtab_list to check if the added file had any dbx info in it. */
++   symtab_temp = symtab_list;
++ 
++   /* Now that the symbol table data of the executable file are all in core,
++      process them and define symbols accordingly.  Closes desc.  */
++ 
++   read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
++ 
++   if (symtab_list == symtab_temp) {
++     printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
++     fflush(stdout);
++   }
++   else {
++ 
++   /* Sort symbols alphabetically within each block.  */
++ 
++     sort_syms ();
++ 
++   /* Go over the misc functions and install them in vector.  */
++ 
++     condense_misc_bunches ();
++ 
++   /* Make a default for file to list.  */
++ 
++     select_source_symtab (symtab_list);
++   }
++ 
++   do_cleanups (old_chain);
++ 
++   /* Free the symtabs made by read_symsegs, but not their contents,
++      which have been copied into symtabs on symtab_list.  */
++   while (symseg_chain)
++     {
++       register struct symtab *s = symseg_chain->next;
++       free (symseg_chain);
++       symseg_chain = s;
++     }
++ 
++   if (in_this_dir && name[0] != '/')
++     {
++       char dirname[MAXPATHLEN];
++ 
++       getwd (dirname);
++       symfile = concat (dirname, "/",
++ 			savestring (name, strlen (name)));
++     }
++   else
++     symfile = savestring (name, strlen (name));
++ 
++   printf ("done.\n");
++   fflush (stdout);
++ }
++ #endif
++ 
+  /* This is the symbol-file command.  Read the file, analyze its symbols,
+     and add a struct symtab to symtab_list.  */
+  
+***************
+*** 1047,1052 ****
+--- 1251,1263 ----
+  
+    dont_repeat ();
+  
++ #ifdef CAMPHOR
++   /* this command does not deal with automatically relocated stuff */
++   dlreloc.text = 0;
++   dlreloc.data = 0;
++   dlreloc.bss = 0;
++ #endif
++ 
+    if (name == 0)
+      error_no_arg ("file to read symbols from");
+  
+***************
+*** 1130,1151 ****
+  
+    read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
+  
+    /* Sort symbols alphabetically within each block.  */
+  
+!   sort_syms ();
+  
+    /* Go over the misc functions and install them in vector.  */
+  
+!   condense_misc_bunches ();
+  
+    /* Don't allow char * to have a typename (else would get caddr_t.)  */
+  
+!   TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+  
+    /* Make a default for file to list.  */
+  
+!   select_source_symtab (symtab_list);
+  
+    symfile = savestring (name, strlen (name));
+  
+    do_cleanups (old_chain);
+--- 1341,1372 ----
+  
+    read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
+  
++   /* Check to make sure file was compiled with -g. */
++ 
++   if (symtab_list == NULL) {
++     printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
++     fflush(stdout);
++   }
++   else {
++ 
+    /* Sort symbols alphabetically within each block.  */
+  
+!     sort_syms ();
+  
+    /* Go over the misc functions and install them in vector.  */
+  
+!     condense_misc_bunches ();
+  
+    /* Don't allow char * to have a typename (else would get caddr_t.)  */
+  
+!     TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+  
+    /* Make a default for file to list.  */
+  
+!     select_source_symtab (symtab_list);
+  
++   }
++ 
+    symfile = savestring (name, strlen (name));
+  
+    do_cleanups (old_chain);
+***************
+*** 1204,1209 ****
+--- 1425,1440 ----
+      {
+        fread (&buf, sizeof buf, 1, stream);
+        namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : 0;
++ #ifdef CAMPHOR
++       if ((buf.n_type & N_TYPE) == N_UNDF) {
++ 	  /* don't screw around with undefined symbols */
++       }
++       else {
++ 	if ((buf.n_type & N_TYPE) == N_TEXT) buf.n_value += dlreloc.text;
++ 	else if ((buf.n_type & N_TYPE) == N_DATA) buf.n_value += dlreloc.data;
++ 	else if ((buf.n_type & N_TYPE) == N_BSS) buf.n_value += dlreloc.bss;
++       }
++ #endif
+        if (buf.n_type & N_STAB)
+  	process_one_symbol (buf.n_type, buf.n_desc,
+  			    buf.n_value, namestring);
+***************
+*** 1356,1361 ****
+--- 1587,1596 ----
+      }
+  }
+  
++ #ifdef ibm032
++ static  char hcState;		/* two different, incompatible compilers for the RT */
++ #endif
++   
+  static void
+  process_one_symbol (type, desc, value, name)
+       int type, desc;
+***************
+*** 1363,1369 ****
+       char *name;
+  {
+    register struct context_stack *new;
+!   
+    /* Something is wrong if we see real data before
+       seeing a source file name.  */
+    
+--- 1598,1633 ----
+       char *name;
+  {
+    register struct context_stack *new;
+!   char tname[256];
+!   /* Now, there are two compilers for the RT, and they are seriously incompatible.
+!       pcc is just like normal c compilers: stabs for a block occur before the LBRAC
+!       stab for that same block.  Thus this code squirrels them away in the context
+!       and when the RBRAC is hit, restores local_symbols as of the time the LBRAC
+!       was encountered, and adds these symbosl to the block that just ended.
+!       
+!       However, with the HC compiler, those symbols occur *after* the LBRAC symbol
+!       declaring the block's start.  Totally incompatible, of course.  One expects no
+!       less from IBM.  For hc compiled  programs, we use the symbols in local_symbols
+!       *before* the RBRAC command pops the context stack.
+!       
+!       Amazingly enough, when we complained to IBM/Palo Alto about this incompatibility,
+!       they claimed that Mark Linton (original author of dbx) liked the new way better, and
+!       that he didn't even know that pcc used a different order.  Sorta explains some things
+!       about dbx, n'est-ce pas?  Furthermore, of course, IBM  doesn't want to change
+!       either pcc or hc.
+! 
+!       Anyway, hc and pcc compiled .o files often co-exist in programs.  How do we
+!       tell which is which?  Stupid heuristic which doesn't work with programs
+!       with no top-level locals or parameters: after seeing a function's start, if we see
+!       an LBRAC before seeing a variable, then we are using hc, otherwise it is pcc.
+!       Stupid heuristics are better than none, so we use it.
+!       
+!       The variable hcState is used to keep track of this crap.
+!       0 ==> saw function symbol
+!       1 ==> saw lbrac in state 0, this is hc.
+!       2 ==> saw symbol in state 0, this is pcc.
+!   */
+! 
+    /* Something is wrong if we see real data before
+       seeing a source file name.  */
+    
+***************
+*** 1384,1389 ****
+--- 1648,1656 ----
+  	 also the end of the lexical context for the previous function.  */
+        new = context_stack;
+        within_function = 1;
++ #ifdef ibm032
++       hcState = 0;
++ #endif
+        if (new)
+  	{
+  	  /* Make a block for the local symbols within.  */
+***************
+*** 1400,1406 ****
+--- 1667,1679 ----
+        new->locals = 0;
+        new->old_blocks = pending_blocks;
+        new->start_addr = value;
++ #ifdef ibm032
++       strcpy(tname, ".");
++       strcat(tname, name);
++       new->name = define_symbol(value, tname);
++ #else
+        new->name = define_symbol (value, name);
++ #endif
+        local_symbols = 0;
+        break;
+  
+***************
+*** 1407,1412 ****
+--- 1680,1688 ----
+      case N_LBRAC:
+        /* This "symbol" just indicates the start of an inner lexical
+  	 context within a function.  */
++ #ifdef ibm032
++       if (hcState == 0) hcState = 1;
++ #endif
+        new = (struct context_stack *) xmalloc (sizeof (struct context_stack));
+        new->depth = desc;
+        new->next = context_stack;
+***************
+*** 1422,1430 ****
+        /* This "symbol" just indicates the end of an inner lexical
+  	 context that was started with N_RBRAC.  */
+        new = context_stack;
+        if (new == 0 || desc != new->depth)
+  	error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
+-       local_symbols = new->locals;
+        context_stack = new->next;
+        /* If this is not the outermost LBRAC...RBRAC pair in the
+  	 function, its local symbols preceded it, and are the ones
+--- 1698,1711 ----
+        /* This "symbol" just indicates the end of an inner lexical
+  	 context that was started with N_RBRAC.  */
+        new = context_stack;
++ #ifdef ibm032
++       if (hcState == 2)	/* pcc */
++ 	  local_symbols = new->locals;
++ #else
++       local_symbols = new->locals;
++ #endif
+        if (new == 0 || desc != new->depth)
+  	error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
+        context_stack = new->next;
+        /* If this is not the outermost LBRAC...RBRAC pair in the
+  	 function, its local symbols preceded it, and are the ones
+***************
+*** 1443,1448 ****
+--- 1724,1733 ----
+  			new->start_addr + last_source_start_addr,
+  			value + last_source_start_addr);
+  	}
++ #ifdef ibm032
++       if (hcState == 1 && context_stack->next)	/* hc */
++         local_symbols = new->locals;		/* now we get them */
++ #endif
+        free (new);
+        break;
+  
+***************
+*** 1493,1498 ****
+--- 1778,1786 ----
+        break;
+  
+      default:
++ #ifdef ibm032
++       if (hcState == 0) hcState = 2;
++ #endif
+        if (name)
+  	define_symbol (value, name);
+      }
+***************
+*** 1553,1558 ****
+--- 1841,1849 ----
+  	 Dbx data never actually contains 'l'.  */
+      case 'l':
+        SYMBOL_CLASS (sym) = LOC_LOCAL;
++ #ifdef ibm032
++       if (hcState == 1) value += 1000000;		/* temporary hack until rel 3 pcc matches hc */
++ #endif
+        SYMBOL_VALUE (sym) = value;
+        SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+        add_symbol_to_list (sym, &local_symbols);
+***************
+*** 1572,1577 ****
+--- 1863,1875 ----
+        add_symbol_to_list (sym, &local_symbols);
+        break;
+  
++     case 'R':
++       SYMBOL_CLASS (sym) = LOC_REGISTER;
++       SYMBOL_VALUE (sym) = value;
++       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
++       add_symbol_to_list (sym, &local_symbols);
++       break;
++ 
+      case 'S':
+        /* Static symbol at top level of file */
+        SYMBOL_CLASS (sym) = LOC_STATIC;
+***************
+*** 1616,1622 ****
+        break;
+  
+      default:
+!       error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
+      }
+    return sym;
+  }
+--- 1914,1928 ----
+        break;
+  
+      default:
+!       printf ("Unknown symbol-type code '%c' in dbx symbol table, assuming local.\n", deftype);
+!       SYMBOL_CLASS (sym) = LOC_LOCAL;
+! #ifdef ibm032
+!       if (hcState == 1) value += 1000000;		/* temporary hack until rel 3 pcc matches hc */
+! #endif
+!       SYMBOL_VALUE (sym) = value;
+!       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+!       add_symbol_to_list (sym, &local_symbols);      
+!       break;
+      }
+    return sym;
+  }
+***************
+*** 1741,1746 ****
+--- 2047,2056 ----
+  	(*pp) += 5;
+        else if (!strncmp (*pp, "r(0,1);0;", 9))
+  	(*pp) += 9;
++ #if 1
++       else if ((**pp == 'r') && (!strncmp(*pp + 2, ";0;", 3)))
++         (*pp) += 5;
++ #endif
+        else break;
+  
+        TYPE_CODE (type) = TYPE_CODE_ARRAY;
+***************
+*** 1980,1986 ****
+       rather than -128 which is what I would like.
+       So use n1 != 0 to prevent char from being taken as unsigned.  */
+  
+!   else if (n2 == 0 && n1 == 1)
+      {
+        /* an unsigned type */
+        if (n3 == (1 << (8 * sizeof (int))))
+--- 2290,2296 ----
+       rather than -128 which is what I would like.
+       So use n1 != 0 to prevent char from being taken as unsigned.  */
+  
+!   if (n2 == 0)
+      {
+        /* an unsigned type */
+        if (n3 == (1 << (8 * sizeof (int))))
+***************
+*** 1989,1994 ****
+--- 2299,2306 ----
+  	return builtin_type_unsigned_short;
+        if (n3 == (1 << (8 * sizeof (char))))
+  	return builtin_type_unsigned_char;
++       if (n3 == (1 << (8 * sizeof (char) - 1)))
++ 	return builtin_type_char;
+      }
+    else
+      {
+***************
+*** 2002,2007 ****
+--- 2314,2321 ----
+        if (n3 == (1 << (8 * sizeof (char) - 1)))
+  	return builtin_type_char;
+      }
++    if (n2 == 0 && n3 == 1)
++     return builtin_type_void;
+    error ("Invalid symbol data: range type spec %s at symtab pos %d.",
+  	 errp - 1, symnum);
+  }
+***************
+*** 2033,2040 ****
+--- 2347,2364 ----
+  
+    /* Read the digits, as far as they go.  */
+  
++ #if 0 /* Yet another "Compiler sucks" fix. */
+    while ((c = *p++) >= '0' && c <= '9')
++ #else
++   while (((c = *p++) >= '0' && c <= '9') || ((end != '\n') && (c == '\n')))
++ #endif
+      {
++ #if 1
++       if (c == '\n') {
++         printf("Ignoring bogus newline in stabs entry. Your compiler should be fixed.\n");
++         continue;
++       }
++ #endif
+        n *= 10;
+        n += c - '0';
+      }
+***************
+*** 2050,2060 ****
+--- 2374,2392 ----
+    return n * sign;
+  }
+  
++ dbxinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+    symfile = 0;
+  
++ #ifdef CAMPHOR
++   add_com ("add-file", class_files, add_file_command,
++            "Add a new symbol table (in dbx format) from file FILE.");
++   add_com("set-rel", class_files, set_rel_command,
++            "Set relocation for add-file command to NUMBER.");
++ #endif
+    add_com ("symbol-file", class_files, symbol_file_command,
+  	   "Load symbol table (in dbx format) from executable file FILE.");
+  }
+diff -c ../../gnu/gdb/environ.c ./environ.c
+*** ../../gnu/gdb/environ.c	Sat Apr  4 22:31:16 1987
+--- ./environ.c	Sun Apr 26 23:48:05 1987
+***************
+*** 129,135 ****
+  
+    if (e->allocated < i)
+      {
+!       e->allocated = max (i, e->allocated + 10);
+        e->vector = (char **) xrealloc (e->vector,
+  				      (e->allocated + 1) * sizeof (char *));
+      }
+--- 129,136 ----
+  
+    if (e->allocated < i)
+      {
+!       e->allocated = i + 10;
+        e->vector = (char **) xrealloc (e->vector,
+  				      (e->allocated + 1) * sizeof (char *));
+      }
+diff -c ../../gnu/gdb/eval.c ./eval.c
+*** ../../gnu/gdb/eval.c	Sat Apr  4 22:32:36 1987
+--- ./eval.c	Mon Apr 27 00:01:27 1987
+***************
+*** 546,551 ****
+--- 546,553 ----
+      }
+  }
+  
++ evalinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  { }
+diff -c ../../gnu/gdb/expread.y ./expread.y
+*** ../../gnu/gdb/expread.y	Sat Apr  4 22:35:27 1987
+--- ./expread.y	Sun Apr 26 23:56:51 1987
+***************
+*** 650,655 ****
+--- 650,656 ----
+  	    ;
+  	  else
+  	    {
++ 	      /*N.B. error does a longjmp, so we do not have to worry about storage */
+  	      err_copy = (char *) alloca (olen + 1);
+  	      bcopy (lexptr, err_copy, olen);
+  	      err_copy[olen] = 0;
+***************
+*** 945,953 ****
+  {
+    register int len = sizeof (struct expression) +
+  				    expr->nelts * sizeof (union exp_element);
+!   register struct expression *temp
+!     = (struct expression *) alloca (len);
+    register int inpos = expr->nelts, outpos = 0;
+  
+    /* Copy the original expression into temp.  */
+    bcopy (expr, temp, len);
+--- 946,955 ----
+  {
+    register int len = sizeof (struct expression) +
+  				    expr->nelts * sizeof (union exp_element);
+!   register struct expression *temp;
+    register int inpos = expr->nelts, outpos = 0;
++ 
++   temp = (struct expression *) alloca(len);
+  
+    /* Copy the original expression into temp.  */
+    bcopy (expr, temp, len);
+diff -c ../../gnu/gdb/findvar.c ./findvar.c
+*** ../../gnu/gdb/findvar.c	Sat Apr  4 22:36:38 1987
+--- ./findvar.c	Mon Apr 27 00:01:44 1987
+***************
+*** 359,364 ****
+--- 359,366 ----
+    return value_cast (lookup_pointer_type (SYMBOL_TYPE (var)),
+  		     value_from_long (builtin_type_long, addr));
+  }
++ 
++ findinitialize() {initialize();}
+  
+  static
+  initialize ()
+diff -c ../../gnu/gdb/firstfile.c ./firstfile.c
+*** ../../gnu/gdb/firstfile.c	Sat Apr  4 22:37:06 1987
+--- ./firstfile.c	Mon Apr 27 00:02:06 1987
+***************
+*** 125,130 ****
+--- 125,152 ----
+  static initialize_dummy_1 ();
+  static initialize_dummy_2 ();
+  
++ initialize_all_files() {
++     blockinitialize();
++     breakinitialize();
++     coreinitialize();
++     dbxinitialize();
++     evalinitialize();
++     findinitialize();
++     infcmdinitialize();
++     inflowinitialize();
++     infruninitialize();
++     symmiscinitialize();
++     symtabinitialize();
++     valarithinitialize();
++     valopsinitialize();
++     valprintinitialize();
++     valuesinitialize();
++     printcmdinitialize();
++     sourceinitialize();
++     stackinitialize();
++ }
++ 
++ #if 0
+  initialize_all_files ()
+  {
+    initialize_next_file ((char *) initialize_dummy_2
+***************
+*** 148,153 ****
+--- 170,176 ----
+  initialize_dummy_2 ()
+  {
+  }
++ #endif
+  
+  /* This makes the function initialize_next_file.  */
+  
+diff -c ../../gnu/gdb/frame.h ./frame.h
+*** ../../gnu/gdb/frame.h	Sat Apr  4 22:37:22 1987
+--- ./frame.h	Mon Apr 27 00:02:14 1987
+***************
+*** 20,25 ****
+--- 20,35 ----
+  
+  /* Note that frame.h requires param.h! */
+  
++ #ifdef ibm032
++ struct rt_frame {
++     CORE_ADDR frame;		/* frame address */
++     CORE_ADDR pc;			/* pc we called from */
++     CORE_ADDR firstRLoc;	/* loc'n of first saved general reg */
++     short nParms;			/* number of parameters to this frame */
++     short firstReg;			/* the reg stored at 64(fp) */
++ };
++ #endif
++ 
+  #define FRAME CORE_ADDR
+  
+  struct frame_info
+***************
+*** 62,64 ****
+--- 72,77 ----
+  extern struct block *get_selected_block ();
+  extern struct symbol *get_frame_function ();
+  extern struct symbol *get_pc_function ();
++ #ifdef ibm032
++ extern struct rt_frame *get_cached_frame();
++ #endif
+diff -c ../../gnu/gdb/infcmd.c ./infcmd.c
+*** ../../gnu/gdb/infcmd.c	Sat Apr  4 22:47:22 1987
+--- ./infcmd.c	Mon Apr 27 00:07:53 1987
+***************
+*** 39,45 ****
+  /* String containing arguments to give to the program,
+     with a space added at the front.  Just a space means no args.  */
+  
+! static char *inferior_args;
+  
+  /* Pid of our debugged inferior, or 0 if no inferior now.  */
+  
+--- 39,45 ----
+  /* String containing arguments to give to the program,
+     with a space added at the front.  Just a space means no args.  */
+  
+! static char *inferior_args = NULL;
+  
+  /* Pid of our debugged inferior, or 0 if no inferior now.  */
+  
+***************
+*** 112,119 ****
+  set_args_command (args)
+       char *args;
+  {
+!   free (inferior_args);
+!   if (!args) args = "";
+    inferior_args = concat (" ", args, "");
+  }
+  
+--- 112,121 ----
+  set_args_command (args)
+       char *args;
+  {
+!   if (inferior_args != NULL)
+!     free (inferior_args);
+!   if (!args)
+!     args = "";
+    inferior_args = concat (" ", args, "");
+  }
+  
+***************
+*** 171,177 ****
+        signal (SIGINT, SIG_DFL);  */
+  
+        ptrace (0);
+!       execle ("/bin/sh", "sh", "-c", allargs, 0,
+  	      environ_vector (inferior_environ));
+  
+        fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
+--- 173,180 ----
+        signal (SIGINT, SIG_DFL);  */
+  
+        ptrace (0);
+! 
+!       execle ("/bin/csh", "csh", "-f", "-c", allargs, 0,
+  	      environ_vector (inferior_environ));
+  
+        fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
+***************
+*** 473,478 ****
+--- 476,482 ----
+  
+        retbuf[0] = stop_r0;
+        retbuf[1] = stop_r1;
++ 
+        val = value_being_returned (value_type, retbuf);
+        printf ("Value returned is $%d = ", record_latest_value (val));
+        value_print (val, stdout);
+***************
+*** 705,710 ****
+--- 709,716 ----
+    printf ("Contents are relative to selected stack frame.\n");
+  }
+  
++ infcmdinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/inflow.c ./inflow.c
+*** ../../gnu/gdb/inflow.c	Sat Apr  4 22:56:34 1987
+--- ./inflow.c	Mon Apr 27 00:12:10 1987
+***************
+*** 188,194 ****
+    inferior_pid = 0;
+    mark_breakpoints_out ();
+    if (have_core_file_p ())
+!     set_current_frame (read_register (FP_REGNUM));
+  }
+  
+  /* Resume execution of the inferior process.
+--- 188,194 ----
+    inferior_pid = 0;
+    mark_breakpoints_out ();
+    if (have_core_file_p ())
+!     set_current_frame (read_register (FP_REGNUM), 1);
+  }
+  
+  /* Resume execution of the inferior process.
+***************
+*** 266,271 ****
+--- 266,274 ----
+    char buf[MAX_REGISTER_RAW_SIZE];
+    register int i;
+  
++ #ifdef ibm032
++   offset += UPAGES*NBPG - sizeof(u);	/* ibm032: ustruct at end of uarea */
++ #endif
+    offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
+    for (regno = 0; regno < NUM_REGS; regno++)
+      {
+***************
+*** 291,296 ****
+--- 294,303 ----
+    register unsigned int regaddr;
+    char buf[80];
+  
++ #ifdef ibm032
++   offset += UPAGES*NBPG - sizeof(u);	/* ibm032: ustruct at end of uarea */
++ #endif
++ 
+    offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
+  
+    if (regno >= 0)
+***************
+*** 340,347 ****
+    register int count
+      = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+    /* Allocate buffer of that many longwords.  */
+!   register int *buffer = (int *) alloca (count * sizeof (int));
+  
+    /* Read all the longwords */
+    for (i = 0; i < count; i++, addr += sizeof (int))
+      buffer[i] = ptrace (1, inferior_pid, addr, 0);
+--- 347,355 ----
+    register int count
+      = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+    /* Allocate buffer of that many longwords.  */
+!   register int *buffer;
+  
++   buffer = (int *) alloca(count * sizeof(int));
+    /* Read all the longwords */
+    for (i = 0; i < count; i++, addr += sizeof (int))
+      buffer[i] = ptrace (1, inferior_pid, addr, 0);
+***************
+*** 367,377 ****
+    register int count
+      = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+    /* Allocate buffer of that many longwords.  */
+!   register int *buffer = (int *) alloca (count * sizeof (int));
+    extern int errno;
+  
+    /* Fill start and end extra bytes of buffer with existing memory data.  */
+  
+    buffer[0] = ptrace (1, inferior_pid, addr, 0);
+    if (count > 1)
+      buffer[count - 1]
+--- 375,386 ----
+    register int count
+      = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+    /* Allocate buffer of that many longwords.  */
+!   register int *buffer;
+    extern int errno;
+  
+    /* Fill start and end extra bytes of buffer with existing memory data.  */
+  
++   buffer = (int *) alloca (count * sizeof (int));
+    buffer[0] = ptrace (1, inferior_pid, addr, 0);
+    if (count > 1)
+      buffer[count - 1]
+***************
+*** 388,397 ****
+      {
+        errno = 0;
+        ptrace (4, inferior_pid, addr, buffer[i]);
+!       if (errno)
+  	return 1;
+      }
+- 
+    return 0;
+  }
+  
+--- 397,406 ----
+      {
+        errno = 0;
+        ptrace (4, inferior_pid, addr, buffer[i]);
+!       if (errno) {
+  	return 1;
++ 	}
+      }
+    return 0;
+  }
+  
+***************
+*** 421,426 ****
+--- 430,437 ----
+      }
+  }
+  
++ inflowinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/infrun.c ./infrun.c
+*** ../../gnu/gdb/infrun.c	Sat Apr  4 22:57:15 1987
+--- ./infrun.c	Mon Apr 27 00:17:40 1987
+***************
+*** 257,263 ****
+        pc_changed = 0;
+        fetch_inferior_registers ();
+        stop_pc = read_pc ();
+!       set_current_frame (read_register (FP_REGNUM));
+        stop_frame = get_current_frame ();
+        stop_sp = read_register (SP_REGNUM);
+        another_trap = 0;
+--- 257,271 ----
+        pc_changed = 0;
+        fetch_inferior_registers ();
+        stop_pc = read_pc ();
+! #ifdef CAMPHOR
+!       /* if we're not going to stop, don't bother with a stack trace */
+!       if (WIFSTOPPED(w) && !signal_stop[WSTOPSIG(w)])
+! 	  set_current_frame(read_register(FP_REGNUM), 0);
+!       else
+! 	  set_current_frame(read_register(FP_REGNUM), 1);
+! #else
+!       set_current_frame (read_register (FP_REGNUM), 1);
+! #endif
+        stop_frame = get_current_frame ();
+        stop_sp = read_register (SP_REGNUM);
+        another_trap = 0;
+***************
+*** 688,700 ****
+  
+    /* Save the function value return registers
+       We might be about to restore their previous contents.  */
+!   stop_r0 = read_register (0);
+!   stop_r1 = read_register (1);
+  
+    if (stop_stack_dummy)
+      {
+        /* Pop the empty frame that contains the stack dummy.  */
+        POP_FRAME;
+        select_frame (read_register (FP_REGNUM), 0);
+      }
+  }
+--- 696,717 ----
+  
+    /* Save the function value return registers
+       We might be about to restore their previous contents.  */
+! #ifdef ibm032
+!     stop_r0 = read_register (2);
+!     stop_r1 = read_register (3);
+! #else
+!     stop_r0 = read_register (0);
+!     stop_r1 = read_register (1);
+! #endif
+  
+    if (stop_stack_dummy)
+      {
+        /* Pop the empty frame that contains the stack dummy.  */
++ #ifdef ibm032
++       POP_DUMMY_FRAME;
++ #else
+        POP_FRAME;
++ #endif
+        select_frame (read_register (FP_REGNUM), 0);
+      }
+  }
+***************
+*** 841,846 ****
+--- 858,865 ----
+    printf ("\nUse the \"handle\" command to change these tables.\n");
+  }
+  
++ infruninitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/initialize.h ./initialize.h
+*** ../../gnu/gdb/initialize.h	Sat Apr  4 22:58:27 1987
+--- ./initialize.h	Sun May 24 00:19:21 1987
+***************
+*** 103,109 ****
+--- 103,120 ----
+     of the end of one object file's text to the start of the next
+     object file's text.  */
+  
++ /* Changed to use ifdefs on the machine type.  David Nichols, 11/28/86 */
++ #ifdef ibm032
++ #include "m-ibm032init.h"
++ #endif
++ 
++ #ifdef vax
+  #include "m-vaxinit.h"
++ #endif
++ 
++ #ifdef sun
++ #include "m-suninit.h"
++ #endif
+  
+  /* This is used to make a file's initialization function.
+     It calls another function named `initialize', which must
+diff -c ../../gnu/gdb/main.c ./main.c
+*** ../../gnu/gdb/main.c	Sat Apr  4 23:11:59 1987
+--- ./main.c	Mon Apr 27 00:27:21 1987
+***************
+*** 236,241 ****
+--- 236,243 ----
+    if (*p)
+      {
+        c = lookup_cmd (&p, cmdlist, "", 0);
++       if (c->function == 0)
++ 	error ("That is not a command, just a help topic.");
+        if (c->class == (int) class_user)
+  	{
+  	  if (*p)
+***************
+*** 457,463 ****
+  
+  /* Add an element to the list of commands.  */
+  
+! void
+  add_com (name, class, fun, doc)
+       char *name;
+       int class;
+--- 459,465 ----
+  
+  /* Add an element to the list of commands.  */
+  
+! struct cmd_list_element *
+  add_com (name, class, fun, doc)
+       char *name;
+       int class;
+***************
+*** 464,470 ****
+       void (*fun) ();
+       char *doc;
+  {
+!   add_cmd (name, class, fun, doc, &cmdlist);
+  }
+  
+  /* Add an alias or abbreviation command to the list of commands.  */
+--- 466,473 ----
+       void (*fun) ();
+       char *doc;
+  {
+! 
+!   return add_cmd (name, class, fun, doc, &cmdlist);
+  }
+  
+  /* Add an alias or abbreviation command to the list of commands.  */
+***************
+*** 547,552 ****
+--- 550,556 ----
+  
+    if (c && c->class == (int) class_user)
+      free_command_lines (&c->function);
++ 
+  
+    add_com (comname, class_user, cmds,
+  	   (c && c->class == (int) class_user)
+diff -c ../../gnu/gdb/param.h ./param.h
+*** ../../gnu/gdb/param.h	Sat Apr  4 23:15:44 1987
+--- ./param.h	Mon Apr 27 00:28:17 1987
+***************
+*** 1 ****
+--- 1,19 ----
++ /* Changed to use ifdefs so we don't have to edit it all the time.
++ David Nichols
++ 28 November 1986 */
++ 
++ #ifdef vax
+  #include "m-vax.h"
++ #endif
++ 
++ #ifdef ibm032
++ #include "m-ibm032.h"
++ #endif
++ 
++ #ifdef sun
++ #ifdef mc68020
++ #include "m-sun3.h"
++ #else
++ #include "m-sun2.h"
++ #endif
++ #endif
+diff -c ../../gnu/gdb/pinsn.c ./pinsn.c
+*** ../../gnu/gdb/pinsn.c	Sat Apr  4 23:15:58 1987
+--- ./pinsn.c	Mon Apr 27 00:28:36 1987
+***************
+*** 1 ****
+--- 1,15 ----
++ /* Changed to use ifdefs so we don't have to edit this.
++ David Nichols
++ 28 Nov 1986 */
++ 
++ #ifdef ibm032
++ #include "ibm032-pinsn.c"
++ #endif
++ 
++ #ifdef vax
+  #include "vax-pinsn.c"
++ #endif
++ 
++ #ifdef sun
++ #include "m68k-pinsn.c"
++ #endif
+diff -c ../../gnu/gdb/printcmd.c ./printcmd.c
+*** ../../gnu/gdb/printcmd.c	Sat Apr  4 23:17:03 1987
+--- ./printcmd.c	Mon Apr 27 00:30:52 1987
+***************
+*** 797,804 ****
+       CORE_ADDR frame;
+       FILE *stream;
+  {
+!   char *space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
+    value val = read_var_value (var, frame);
+    value_print (val, stream);
+  }
+  
+--- 797,805 ----
+       CORE_ADDR frame;
+       FILE *stream;
+  {
+!   char *space;
+    value val = read_var_value (var, frame);
++   space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
+    value_print (val, stream);
+  }
+  
+***************
+*** 883,888 ****
+--- 884,891 ----
+      }
+  }
+  
++ printcmdinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/source.c ./source.c
+*** ../../gnu/gdb/source.c	Sat Apr  4 23:17:55 1987
+--- ./source.c	Mon Apr 27 00:31:25 1987
+***************
+*** 276,282 ****
+    if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
+      printf ("Source file is more recent than executable.\n");
+  
+!   data = (char *) alloca (st.st_size);
+    myread (desc, data, st.st_size, s->filename);
+    end = data + st.st_size;
+    p = data;
+--- 276,283 ----
+    if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
+      printf ("Source file is more recent than executable.\n");
+  
+!   data = (char *) alloca(st.st_size);
+! 
+    myread (desc, data, st.st_size, s->filename);
+    end = data + st.st_size;
+    p = data;
+***************
+*** 530,535 ****
+--- 531,538 ----
+      printf ("Line number %d is out of range for \"%s\".\n",
+  	    sal.line, sal.symtab->filename);
+  }
++ 
++ sourceinitialize() {initialize();}
+  
+  static
+  initialize ()
+diff -c ../../gnu/gdb/stack.c ./stack.c
+*** ../../gnu/gdb/stack.c	Sun Apr  5 00:28:05 1987
+--- ./stack.c	Mon Apr 27 00:31:50 1987
+***************
+*** 511,516 ****
+--- 511,517 ----
+  
+    print_stack_frame (selected_frame, selected_frame_level, 1);
+  }
++ 
+  
+  static void
+  return_command (retval_exp)
+***************
+*** 538,543 ****
+--- 539,546 ----
+    frame_command ("0", 1);
+  }
+  
++ stackinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/symmisc.c ./symmisc.c
+*** ../../gnu/gdb/symmisc.c	Sun Apr  5 00:33:16 1987
+--- ./symmisc.c	Mon Apr 27 00:37:46 1987
+***************
+*** 504,509 ****
+--- 504,511 ----
+    return i;
+  }
+  
++ symmiscinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/symtab.c ./symtab.c
+*** ../../gnu/gdb/symtab.c	Sun Apr  5 00:35:45 1987
+--- ./symtab.c	Mon Apr 27 00:38:19 1987
+***************
+*** 71,78 ****
+    strcpy (copy, name);
+    strcat (copy, ".c");
+    for (s = symtab_list; s; s = s->next)
+!     if (!strcmp (copy, s->filename))
+        return s;
+  
+    return 0;
+  }
+--- 71,79 ----
+    strcpy (copy, name);
+    strcat (copy, ".c");
+    for (s = symtab_list; s; s = s->next)
+!     if (!strcmp (copy, s->filename)) {
+        return s;
++     }
+  
+    return 0;
+  }
+***************
+*** 703,709 ****
+    register struct symbol *sym;
+    register CORE_ADDR pc;
+    register int i;
+!   char *copy;
+  
+    /* Defaults have defaults.  */
+  
+--- 704,710 ----
+    register struct symbol *sym;
+    register CORE_ADDR pc;
+    register int i;
+!   char *copy, *dotcopy;
+  
+    /* Defaults have defaults.  */
+  
+***************
+*** 818,825 ****
+--- 819,847 ----
+    /* Look up that token as a function.
+       If file specified, use that file's per-file block to start with.  */
+  
++ #ifdef ibm032
++   /* RT has stupid dots in front of function names (_.foo), and worse, has bogus _foo
++       symbol to confuse us, too.
++   */
++   if (*copy != '.') {
++       dotcopy = (char *) alloca (strlen(copy)+2);	/* one for the null and one for the dot */
++       dotcopy[0] = '.';
++       strcpy(dotcopy+1, copy);
++       sym = lookup_symbol (dotcopy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
++ 			   VAR_NAMESPACE);
++       }
++   else {
++       sym = 0;
++       dotcopy = 0;
++   }
++   if (!sym || SYMBOL_CLASS(sym) != LOC_BLOCK) {
++       sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
++ 	   VAR_NAMESPACE);
++   }
++ #else
+    sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
+  		       VAR_NAMESPACE);
++ #endif
+  
+    if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+      {
+***************
+*** 835,840 ****
+--- 857,875 ----
+    if (sym)
+      error ("%s is not a function.", copy);
+  
++ #ifdef ibm032
++   /* try the dot version first */
++   if (dotcopy) for (i = 0; i < misc_function_count; i++)
++     if (!strcmp (misc_function_vector[i].name, dotcopy))
++       {
++ 	value.symtab = 0;
++ 	value.line = 0;
++ 	value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
++ 	if (funfirstline)
++ 	  SKIP_PROLOGUE (value.pc);
++ 	return value;
++       }
++ #endif
+    for (i = 0; i < misc_function_count; i++)
+      if (!strcmp (misc_function_vector[i].name, copy))
+        {
+***************
+*** 1027,1032 ****
+--- 1062,1069 ----
+  
+    return type;
+  }
++ 
++ symtabinitialize() {initialize();}
+  
+  static
+  initialize ()
+diff -c ../../gnu/gdb/utils.c ./utils.c
+*** ../../gnu/gdb/utils.c	Sun Apr  5 00:40:01 1987
+--- ./utils.c	Mon Apr 27 00:40:01 1987
+***************
+*** 151,156 ****
+--- 151,157 ----
+    else
+      err = "unknown error";
+  
++   /* ibm032: no core leak or other problems 'cause we alway call error -> longjmps away */
+    combined = (char *) alloca (strlen (err) + strlen (string) + 3);
+    strcpy (combined, string);
+    strcat (combined, ": ");
+diff -c ../../gnu/gdb/valarith.c ./valarith.c
+*** ../../gnu/gdb/valarith.c	Sun Apr  5 00:40:44 1987
+--- ./valarith.c	Fri May 22 20:18:46 1987
+***************
+*** 239,245 ****
+    COERCE_ARRAY (arg1);
+  
+    len = TYPE_LENGTH (VALUE_TYPE (arg1));
+!   p = VALUE_CONTENTS (arg1);
+  
+    while (--len >= 0)
+      {
+--- 239,245 ----
+    COERCE_ARRAY (arg1);
+  
+    len = TYPE_LENGTH (VALUE_TYPE (arg1));
+!   p = (char *) VALUE_CONTENTS (arg1);
+  
+    while (--len >= 0)
+      {
+***************
+*** 281,288 ****
+  	   && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
+  	       == TYPE_LENGTH (VALUE_TYPE (arg2))))
+      {
+!       p1 = VALUE_CONTENTS (arg1);
+!       p2 = VALUE_CONTENTS (arg2);
+        while (--len >= 0)
+  	{
+  	  if (*p1++ != *p2++)
+--- 281,288 ----
+  	   && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
+  	       == TYPE_LENGTH (VALUE_TYPE (arg2))))
+      {
+!       p1 = (char *) VALUE_CONTENTS (arg1);
+!       p2 = (char *) VALUE_CONTENTS (arg2);
+        while (--len >= 0)
+  	{
+  	  if (*p1++ != *p2++)
+***************
+*** 348,353 ****
+--- 348,355 ----
+    return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
+  }
+  
++ valarithinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/valops.c ./valops.c
+*** ../../gnu/gdb/valops.c	Sun Apr  5 00:41:32 1987
+--- ./valops.c	Fri May 22 20:13:02 1987
+***************
+*** 174,180 ****
+    /* Return a value just like TOVAL except with the contents of FROMVAL.  */
+  
+    val = allocate_value (type);
+!   bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
+    bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
+  
+    return val;
+--- 174,180 ----
+    /* Return a value just like TOVAL except with the contents of FROMVAL.  */
+  
+    val = allocate_value (type);
+!   bcopy (toval, val, (char *) VALUE_CONTENTS (val) - (char *) val);
+    bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
+  
+    return val;
+***************
+*** 413,419 ****
+--- 413,427 ----
+        }
+      else if (code == TYPE_CODE_PTR)
+        {
++ #ifdef ibm032
++ 	/* apparently '_a' pseudoprocedure has lval_memory as its lval type */
++ 	if (VALUE_LVAL(function) == lval_memory) 
++ 	  funaddr = VALUE_ADDRESS(function);
++ 	else
++           funaddr = value_as_long (function);
++ #else
+  	funaddr = value_as_long (function);
++ #endif
+  	if (TYPE_CODE (TYPE_TARGET_TYPE (ftype))
+  	    == TYPE_CODE_FUNC)
+  	  value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
+***************
+*** 429,439 ****
+  	else
+  	  /* Handle integer used as address of a function.  */
+  	  funaddr = value_as_long (function);
+- 
+  	value_type = builtin_type_int;
+        }
+!     else
+        error ("Invalid data type for function to be called.");
+  
+      /* Create a call sequence customized for this function
+         and the number of arguments for it.  */
+--- 437,447 ----
+  	else
+  	  /* Handle integer used as address of a function.  */
+  	  funaddr = value_as_long (function);
+  	value_type = builtin_type_int;
+        }
+!     else {
+        error ("Invalid data type for function to be called.");
++     }
+  
+      /* Create a call sequence customized for this function
+         and the number of arguments for it.  */
+***************
+*** 590,595 ****
+--- 598,605 ----
+    return value_field (arg1, i);
+  }
+  
++ valopsinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  { }
+diff -c ../../gnu/gdb/valprint.c ./valprint.c
+*** ../../gnu/gdb/valprint.c	Sun Apr  5 00:42:28 1987
+--- ./valprint.c	Mon Apr 27 00:40:56 1987
+***************
+*** 529,534 ****
+--- 529,536 ----
+    print_max = atoi (arg);
+  }
+  
++ valprintinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+diff -c ../../gnu/gdb/value.h ./value.h
+*** ../../gnu/gdb/value.h	Sun Apr  5 00:43:44 1987
+--- ./value.h	Fri May 22 20:03:32 1987
+***************
+*** 37,43 ****
+      short repeated;
+      short repetitions;
+      short regno;
+!     char contents[1];
+    };
+  
+  typedef struct value *value;
+--- 37,43 ----
+      short repeated;
+      short repetitions;
+      short regno;
+!     long contents[1]; /* Forces alignment... */
+    };
+  
+  typedef struct value *value;
+diff -c ../../gnu/gdb/values.c ./values.c
+*** ../../gnu/gdb/values.c	Sun Apr  5 00:45:14 1987
+--- ./values.c	Fri May 22 20:12:40 1987
+***************
+*** 338,344 ****
+       int offset, bitpos, bitsize;
+       value newval;
+  {
+!   register char *addr = VALUE_CONTENTS (var->value) + offset;
+    if (bitsize)
+      modify_field (addr, value_as_long (newval),
+  		  bitpos, bitsize);
+--- 338,344 ----
+       int offset, bitpos, bitsize;
+       value newval;
+  {
+!   register char *addr = (char *) VALUE_CONTENTS (var->value) + offset;
+    if (bitsize)
+      modify_field (addr, value_as_long (newval),
+  		  bitpos, bitsize);
+***************
+*** 733,738 ****
+--- 733,740 ----
+    write_register (1, retbuf[1]);
+  }
+  
++ valuesinitialize() {initialize();}
++ 
+  static
+  initialize ()
+  {
+
diff --git a/gdb/=rt-extra b/gdb/=rt-extra
new file mode 100644
index 0000000..827e1a1
--- /dev/null
+++ b/gdb/=rt-extra
@@ -0,0 +1,84 @@
+BABYL OPTIONS:
+Version: 5
+Labels:
+Note:   This is the header of an rmail file.
+Note:   If you are seeing it in rmail,
+Note:    it means the file has no messages in it.
+
+1,,
+Received: by PREP.AI.MIT.EDU; Mon, 25 May 87 04:03:20 EDT
+Message-Id: <8705250803.AA14993@prep.ai.mit.edu>
+Received: by po2.andrew.cmu.edu (5.54/3.15) id <AA00199> for rms@prep.ai.mit.edu; Mon, 25 May 87 04:02:41 EDT
+Received: via switchmail; Mon, 25 May 87 04:02:29 edt
+Received: FROM z.itc.cmu.edu VIA qmail
+          ID </cmu/common/mailqs/q004/QF.z.itc.cmu.edu.20b7fa53.6bb39>;
+          Mon, 25 May 87 04:01:27 edt
+Received: FROM z.itc.cmu.edu VIA qmail
+          ID </cmu/itc/zs01/.Outgoing/QF.z.itc.cmu.edu.20b7fa49.a49502>;
+          Mon, 25 May 87 04:01:15 edt
+From: zs01#@andrew.cmu.edu (Zalman Stern)
+Date: Mon, 25 May 87 04:01:13 edt
+To: rms@prep.ai.mit.edu
+Subject: Small diff to yesterdays gdb diffs.
+
+*** EOOH ***
+From: zs01#@andrew.cmu.edu (Zalman Stern)
+Date: Mon, 25 May 87 04:01:13 edt
+To: rms@prep.ai.mit.edu
+Subject: Small diff to yesterdays gdb diffs.
+
+Richard,
+
+Here is another minor diff to the diassembler to get certain conditional
+branches instructions correct...
+
+Also, I noticed that gcc.tar.Z is out of date with respect to gcc.tar .
+When I go to get these files, should I go ahead and replace the compressed
+version with a newer one or should I leave it alone? Likewise, should I try and
+make a split version on prep?
+
+-Z-
+
+*** ibm032-pinsn.c.old	Mon May 25 03:31:04 1987
+--- ibm032-pinsn.c	Mon May 25 03:47:12 1987
+***************
+*** 101,112 ****
+      }
+    }
+    else { /* Conditional branches are hacked. */
+!     switch (type & 0x0f) {
+  
+        int displacement;
+  
+        case ibm032_JI:
+!         fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, buffer[0] & LOW4));
+        putc('\t', stream);
+        print_address((buffer[1] << 1) + memaddr, stream);
+        return 2;
+--- 101,112 ----
+      }
+    }
+    else { /* Conditional branches are hacked. */
+!     switch (type & LOW4) {
+  
+        int displacement;
+  
+        case ibm032_JI:
+!         fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[0] & LOW3) + 8));
+        putc('\t', stream);
+        print_address((buffer[1] << 1) + memaddr, stream);
+        return 2;
+*** ibm032-opcode.h.old	Mon May 25 03:33:19 1987
+--- ibm032-opcode.h	Mon May 25 03:33:24 1987
+***************
+*** 11,16 ****
+--- 11,17 ----
+  
+  /* Various useful bit masks. */
+  #define ibm032_typeMask		0x0f /* Mask to get actual type info out of instruction type. */
++ #define LOW3			0x07
+  #define LOW4			0x0f
+  #define HIGH4			0xf0
+  #define LOW16			0x0000ffff
+
+
\ No newline at end of file
diff --git a/gdb/=xgdb.msg b/gdb/=xgdb.msg
new file mode 100644
index 0000000..ac32300
--- /dev/null
+++ b/gdb/=xgdb.msg
@@ -0,0 +1,997 @@
+From beatty@unh.cs.cmu.edu Sat Jul  4 12:04:01 1987
+Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:03:37 EDT
+Message-Id: <8707041603.AA08600@prep.ai.mit.edu>
+To: phr@prep.ai.mit.edu (Paul Rubin)
+Date: Sat, 4 Jul 87 12:03:01 EDT
+From: Derek Beatty <beatty@unh.cs.cmu.edu>
+Subject: Re: gdb and X (msg 1 of 3)
+Status: R
+
+This is part 1 of 3 parts.  It consists of the cursor I used, and a message
+I sent to Zalman Stern at Andrew regarding what I did, and why.  The
+code and context diffs will follow in other messages.
+
+#define gdb_width 16
+#define gdb_height 16
+#define gdb_x_hot 7
+#define gdb_y_hot 0
+static short gdb_bits[] = {
+   0x0000, 0x0140, 0x0220, 0x0220,
+   0x23e2, 0x13e4, 0x09c8, 0x0ff8,
+   0x0220, 0x3ffe, 0x0630, 0x03e0,
+   0x0220, 0x1ffc, 0x2632, 0x01c0};
+
+#define gdb_mask_width 16
+#define gdb_mask_height 16
+#define gdb_mask_x_hot 7
+#define gdb_mask_y_hot 0
+static short gdb_mask_bits[] = {
+   0x0360, 0x07f0, 0x07f0, 0x77f7,
+   0x7fff, 0x7fff, 0x1ffc, 0x1ffc,
+   0x7fff, 0x7fff, 0x7fff, 0x0ff8,
+   0x3ffe, 0x7fff, 0x7fff, 0x7fff};
+
+> 
+> The X support I added is minimal; it was inspired by Suntools' dbxtool,
+> together with the availability of the V10 implementation of the X V11
+> toolkit specification.  Design was guided by simplicity and the facilities
+> of the toolkit.  The debugger window provides a view into the code 
+> corresponding to the current stack frame, and several buttons for the
+> breakpoint, print, step, next, continue, finish, up, and down commands.
+> The standard gdb command interface remains available in the tty window from
+> which gdb was started.  The breakpoint and print buttons make use of the
+> current selection, so you can do simple things like click at text in the
+> source window, then click the "Go 'til" button to continue until that
+> point.  
+> 
+> Such an interface is simple to program ( ~ 20 hours, about 700 lines), 
+> but it has some drawbacks.  First, I didn't take the time to understand
+> the longjmp's in gdb, and I'm not exactly happy with the idea of them
+> jumping out of my callback procedures that were invoked by toolkit routines. 
+> There's one core dump bug (it shows up when gdb can't find a source
+> file) that I haven't tracked down, and it may be related to this.  Second,
+> selection in the text window is not particularly graceful: double-clicking
+> highlights one word of text, as the toolkit defines a word.  It would
+> be much more graceful were double-clicking to highlight a C identifier. 
+> Finally, and most seriously, most buttons operate by building textual
+> command lines and passing them to gdb's execute_command function.  This
+> means that all selected expressions are evaluated and printed in the
+> lexical scope corresponding to the current stack frame, although the
+> selected text may be in a different lexical scope.  This serious bug would
+> require work to fix.
+> 
+> I wrote the X support out of frustration at not having dbxtool available
+> when I work on a vax.  The hope of portability to V11 via the toolkit
+> also helped motivate me to write V10 code at this late date.  Finally,
+> I'd never written any nontrivial code that ran on a windowing system
+> (although that turns out still to be the case). Were I to make a more
+> serious effort at this project, I would probably add a general "define-button"
+> command akin to gdb's "define" command.
+> 
+> Look in /usr/beatty/gnu/gdb on vlsi.cs.cmu.edu.  All files I have modified
+> are marked, and also have associated backups (.B extensions). Bennet
+> Yee has a copy of the toolkit library; see /usr/bsy/Xtlib on f.gp.cs.cmu.edu.
+> 
+>  -- Derek
+> 
+
+ -- Derek Beatty
+
+From beatty@unh.cs.cmu.edu Sat Jul  4 12:12:47 1987
+Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:09:20 EDT
+Message-Id: <8707041609.AA08643@prep.ai.mit.edu>
+To: phr@PREP.AI.MIT.EDU (Paul Rubin)
+Date: Sat, 4 Jul 87 12:07:25 EDT
+From: Derek Beatty <beatty@unh.cs.cmu.edu>
+Subject: Re: gdb and X (msg 2 of 3)
+In-Reply-To: Message from "Paul Rubin" of Jul 4, 87 at 1:22 am
+Status: R
+
+The following is "tool.c".  I hereby grant permission to do anything you
+like with it.
+
+ -- Derek Beatty
+
+[nosave]
+/* 
+ * gdb tool for X V10R4 (using V11-compatible toolkit).
+ * Derek Beatty 30 June 87.
+ */
+#include <X/Xlib.h>
+#include <X/Xt/Xtlib.h>
+#include <stdio.h>
+
+#include "defs.h"
+#include "symtab.h"
+
+#include "gdb.cursor"
+#include "gdb_mask.cursor"
+
+
+
+/* forward refs */
+
+static Window createFileText();
+/* 
+ * Windows manipulated by this package.
+ */
+
+static Window 
+  icon,
+  frame, 
+  srcLabelStrip,
+  srcText,
+  ctlPanel,
+  execLabelStrip;
+
+static Cursor curse;
+
+/*
+ * Source text display.
+ */
+
+static struct symtab *displayedSymtab= 0;
+
+extern struct symtab *current_source_symtab;
+extern int current_source_line;
+
+toolDisplaySource()
+{
+  char *fullName;
+  static Arg labelArgs[1];
+  int linenumbers_changed= 0;
+  static int newWidget= 1;
+
+  struct symtab_and_line get_selected_frame_sal();
+  struct symtab_and_line sal;
+
+  /* we could be called before we are initialized */
+  if (!frame) return;
+  
+  sal= get_selected_frame_sal();
+
+  /* strictly this is wrong, but better than a blank display */
+  if (sal.symtab==NULL) {
+    sal.symtab= current_source_symtab;
+    /* current_source_line may be off by a small number like 4 */
+    sal.line= current_source_line;
+  }
+
+  /*
+   * Switch to a new file if necessary.
+   */
+
+  if (sal.symtab)
+    linenumbers_changed= get_filename_and_charpos(sal.symtab, 
+  						sal.line,
+  						&fullName);
+  if (!fullName) sal.symtab= NULL;
+  /* if the display may be wrong, destroy it */
+  if (linenumbers_changed || displayedSymtab != sal.symtab) {
+    XtVPanedWindowDeletePane( srcText);
+    XtSendDestroyNotify( srcText);
+    XDestroyWindow( srcText);
+    srcText= 0;
+  }
+  /* if there's no display, create one */
+  if (!srcText) {
+    newWidget= 1;
+    /* if there's no valid display, create a dummy display */
+    if (!sal.symtab ) {
+      displayedSymtab= NULL;
+      srcText= createFileText(frame, "/dev/null");
+      XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
+      /* create /dev/null text widget */
+      XtSetArg(labelArgs[0], XtNlabel, "No source displayed.");
+      XtLabelSetValues(srcLabelStrip, labelArgs, XtNumber(labelArgs));
+     } else {
+      displayedSymtab= sal.symtab;
+      srcText= createFileText(frame, fullName);
+      XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
+      XtSetArg(labelArgs[0], XtNlabel, fullName);
+      XtLabelSetValues(srcLabelStrip, labelArgs, XtNumber(labelArgs));
+      /* free filename (maybe: check gdb code!) */
+    }
+  }
+
+  /*
+   * Update display and cursor positions as necessary.
+   * Cursor should be placed on line sal.line.
+   */
+
+  {
+    static int prevTop= 0, highWaterMark= 0;
+    int currentTop;
+    Arg textArgs[1];
+
+    /* get positions of start of display, and caret */
+    XtSetArg(textArgs[0], XtNdisplayPosition, NULL);
+    XtTextGetValues(srcText, textArgs, XtNumber(textArgs));
+    currentTop= cvtCharToLine(displayedSymtab,
+    			      (int) textArgs[0].value);
+    
+    highWaterMark += currentTop - prevTop;
+
+    if (    sal.line < currentTop
+    	 || sal.line > highWaterMark
+         || newWidget) {
+    
+      /* warp the display */
+
+      newWidget= 0;
+
+	/* yes, these magic numbers are ugly, but I don't know how
+	 * to get the height of a text widget in a V11-portable way
+	 */
+      currentTop= (sal.line > 15) ? sal.line - 15 : 0;
+      highWaterMark= currentTop + 35;
+      
+      XtSetArg(textArgs[0], XtNdisplayPosition,
+      	       cvtLineToChar(displayedSymtab, currentTop));
+      XtTextSetValues(srcText, textArgs, XtNumber(textArgs));
+    }
+    XtSetArg(textArgs[0], XtNinsertPosition, 
+    	     cvtLineToChar(displayedSymtab, sal.line));
+    XtTextSetValues(srcText, textArgs, XtNumber(textArgs));
+
+    prevTop=  currentTop;
+  }
+}
+
+/* return the character position of a line */
+int
+cvtLineToChar( s, line)
+  struct symtab *s;
+  int line;
+{
+  if (!s) return 0;
+  if (!s->line_charpos) return 0;
+  if (line < 0) line= 0;
+  if (line > s->nlines) line= s->nlines;
+  return *(s->line_charpos + line-1);
+}
+
+/* return the line position of a character */
+int
+cvtCharToLine( s, chr)
+    register struct symtab *s;
+    register int chr;
+{
+    register int lineNumber= 0;
+    register int *lnp;
+    
+    if (!s) return 0;
+    lnp= s->line_charpos;
+    /* files are usually short, so sequential search is Ok */
+    while ( lineNumber < s->nlines  && *lnp <= chr) {
+    	lineNumber++;
+    	lnp++;
+    }
+    if (lineNumber >= s->nlines)
+       lineNumber= s->nlines;
+    return lineNumber;
+}
+
+/* 
+ * title bar at bottom
+ */
+
+static char *execFileName;
+
+toolSetExecFile(s)
+  char *s;
+{
+  execFileName= s;
+  if (execLabelStrip) {
+    static Arg labelArgs[1];
+
+    XtSetArg(labelArgs[0], XtNlabel, execFileName);
+    XtLabelSetValues(execLabelStrip, labelArgs, XtNumber(labelArgs));
+  }
+}
+
+/*
+ * Command line into which command are placed for execution.
+ * There's some ugly interaction between this and readline in main.c.
+ */
+extern char *line;
+extern int linesize;
+
+/*
+ * Do any necessary prompting, etc.
+ */
+static char *gdbPrompt;
+
+static void
+printPrompt()
+{
+  if (gdbPrompt) {
+    printf("%s", gdbPrompt);
+    fflush(stdout);
+  }
+}
+
+/*
+ * Callback procedures for control panel.
+ */
+
+/* used by "print" and "print*" buttons */
+static void printButnProc_1( starflag)
+  int starflag;
+{
+  int selnLen;
+  char *seln;
+
+  char *cmd= starflag ? "print * " : "print ";
+  register int cmdlen= strlen(cmd);
+  
+  seln= XFetchBytes(&selnLen);
+  if (selnLen) {
+    if (selnLen+cmdlen >= linesize-1) {
+     linesize= (selnLen+cmdlen > linesize*2-1) ? selnLen+cmdlen+1 : linesize*2;
+     line= (char *) xrealloc(line, linesize);
+    }
+    strcpy(line, cmd);
+    strncpy(line+cmdlen, seln, selnLen);
+    *(line+cmdlen+selnLen)= '\0';
+    execute_command(line, 0);
+    free(seln);
+  }
+  printPrompt();
+}
+
+static void printButnProc() 
+{
+  printButnProc_1( 0);
+}
+
+static void printStarButnProc() 
+{
+  printButnProc_1( 1);
+}
+
+static void nextButnProc()
+{
+  strcpy(line, "next");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+static void stepButnProc()
+{
+  strcpy(line, "step");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+static void contButnProc()
+{
+  strcpy(line, "cont");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+static void finButnProc()
+{
+  strcpy(line, "finish");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+/* used by "stop at" and "go till" buttons */
+static void stopAtButnProc_1( gotillFlag)
+  int gotillFlag;
+{
+  XtTextPosition start, finish;
+  static int lineNumber; 
+  
+  XtTextGetSelectionPos(srcText, &start, &finish);
+  if (!displayedSymtab)
+    printf("No source file displayed.\n");
+  else {
+    break_command_for_tool( displayedSymtab, 
+    			    cvtCharToLine(displayedSymtab, start),
+    			    gotillFlag);
+    if (gotillFlag) {
+      strcpy(line, "cont");
+      execute_command(line, 0);
+      toolDisplaySource();
+    }
+  }
+  printPrompt();
+}
+
+static void stopAtButnProc()
+{
+  stopAtButnProc_1( 0);
+}
+
+static void untilButnProc()
+{
+  stopAtButnProc_1( 1);
+}
+
+/* decide if a character is trash */
+static int
+garbage(c)
+  char c;
+{
+  if ('a' <= c && c <= 'z') return 0;
+  if ('A' <= c && c <= 'Z') return 0;
+  if ('0' <= c && c <= '9') return 0;
+  if (c == '_') return 0;
+  return 1;
+}
+
+static void stopInButnProc()
+{
+  static int selnLen;
+  static char *seln;
+  char *sp, *selnp;
+
+  seln= XFetchBytes(&selnLen);
+  if (selnLen) {
+    if (selnLen+6 >= linesize-1) {
+      linesize= (selnLen+6 > linesize*2-1) ? selnLen+7 : linesize*2;
+      line= (char *) xrealloc(line, linesize);
+    }
+    strcpy(line, "break ");
+    /* copy selection but not garbage */
+    selnp= seln;
+    sp= line+strlen(line);
+    while (garbage(*selnp) && selnLen) selnp++, selnLen--;
+    while (!garbage(*selnp) && selnLen) {
+      *sp++= *selnp++;
+      selnLen--;
+    }
+    *sp= '\0';
+    execute_command(line, 0);
+    free(seln);
+  }
+  printPrompt();
+}
+
+static void deIconifyButnProc()
+{
+  XUnmapWindow(icon);
+  XMapWindow(frame);
+}
+
+static void iconifyButnProc()
+{
+  static Arg iconArgs[1];
+  XtSetArg(iconArgs[0], XtNlabel, gdbPrompt);
+  XtCommandSetValues(icon, iconArgs, XtNumber(iconArgs));
+  XUnmapWindow(frame);
+  XMapWindow(icon);
+}
+
+static void upButnProc()
+{
+  strcpy(line, "up");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+static void downButnProc()
+{
+  strcpy(line, "down");
+  execute_command(line, 0);
+  toolDisplaySource();
+  printPrompt();
+}
+
+#define addbutton(w) XtSetArg(buttons[buttoncount], XtNwindow, w); \
+		     buttoncount++;
+static Arg buttons[20];
+static int buttoncount= 0;
+
+/*
+ * Create control panel buttons.
+ */
+static createButtons(parent)
+  Window parent;
+{
+  static Window button;
+  static Arg commandArgs[2];
+
+#define crButn(label,fn)	\
+	XtSetArg(commandArgs[0], XtNlabel, label);\
+	XtSetArg(commandArgs[1], XtNfunction, fn);\
+	button= XtCommandCreate(parent, commandArgs, XtNumber(commandArgs));\
+	addbutton(button);
+
+  crButn("Brk At", stopAtButnProc);
+  crButn("Brk In", stopInButnProc);
+  crButn("Go 'til", untilButnProc);
+
+  crButn("Print", printButnProc);
+  crButn("Print*", printStarButnProc);
+
+  crButn("Next", nextButnProc);
+  crButn("Step", stepButnProc);
+  crButn("Cont", contButnProc);
+  crButn("Finish", finButnProc);
+  
+  crButn("Up", upButnProc);
+  crButn("Down", downButnProc);
+
+  crButn("Iconify", iconifyButnProc);
+#undef crButn
+}
+
+static Window createLabel(parent, name, label)
+  Window parent;
+  char *name, *label;
+{
+  static Arg labelArgs[2];
+  
+  XtSetArg(labelArgs[0], XtNname, name);
+  XtSetArg(labelArgs[1], XtNlabel, label);
+  return XtLabelCreate(frame, labelArgs, XtNumber(labelArgs));
+}
+
+static Window createFileText( parent, filename)
+  Window parent;
+  char *filename;
+{
+  static Arg fileArgs[2];
+  
+  XtSetArg(fileArgs[0], XtNfile, filename);
+  XtSetArg(fileArgs[1], XtNtextOptions, scrollVertical);
+  return XtTextDiskCreate(parent, fileArgs, XtNumber(fileArgs));
+}
+
+/***************** Externally referenced routine **************/
+int createTool()
+{
+  static Arg frameArgs[]= {
+      {XtNwidth, (XtArgVal) 600},
+      {XtNheight, (XtArgVal) 700},
+  };
+  
+  ResourceDataBase db;
+  FILE *rdbFile;
+  
+  /*
+   * init and database stuff... this is wrong but what the heck
+   */
+  if (XOpenDisplay("") == NULL)
+    return 0;
+  printf("Initializing tool..."); fflush(stdout);
+  XtInitialize();
+  /* should be checking .Xdefaults in $HOME */
+  if ((rdbFile= fopen(".Xresources", "r")) != NULL) {
+    XtGetDataBase(rdbFile, &db);
+    XtSetCurrentDataBase(db);
+    fclose(rdbFile);
+  }
+  
+  /*
+   * create the frame
+   */
+  frame= XtVPanedWindowCreate(RootWindow, frameArgs, XtNumber(frameArgs));
+  
+  /* create source label strip and add to frame */
+  srcLabelStrip= createLabel(frame, "Source File", "No source file yet.");
+  XtVPanedWindowAddPane(frame, srcLabelStrip, 0, 15, 15, 0);
+
+  /* create text widget and add to frame */
+  srcText= createFileText(frame, "/dev/null");
+  XtVPanedWindowAddPane(frame, srcText, 1, 20, 1000, 1);
+
+  /* create button box */
+  ctlPanel= XtButtonBoxCreate(frame, NULL, 0);
+  createButtons( ctlPanel);
+  XtButtonBoxAddButton(ctlPanel, buttons, buttoncount);
+  XtVPanedWindowAddPane(frame, ctlPanel, 2, 30, 30, 0);
+
+  /* create exec label strip and add */
+  execLabelStrip= createLabel(frame, "Executable", 
+     execFileName ? execFileName : "No executable specified.");
+  XtVPanedWindowAddPane(frame, execLabelStrip, 3, 15, 15, 0);
+  
+  
+  /* create icon */
+  {
+    static Arg iconArgs[2];
+    XtSetArg(iconArgs[0], XtNlabel, "(gdb)");
+    XtSetArg(iconArgs[1], XtNfunction, deIconifyButnProc);
+    icon= XtCommandCreate(RootWindow, iconArgs, XtNumber(iconArgs));
+    XMoveWindow(icon, 100, 100);	/* HACK */
+    XSetIconWindow(frame, icon);
+  }
+  
+  /* throw it onto the display */
+  curse= XCreateCursor(gdb_width, gdb_height, gdb_bits, gdb_mask_bits,
+  		gdb_x_hot, gdb_y_hot,
+  		BlackPixel, WhitePixel, GXcopy);
+  XDefineCursor(frame, curse);
+  XDefineCursor(icon, curse);
+  XMapWindow(frame);
+  XMapSubwindows(frame);
+  XFlush();
+  printf("done\n");
+  return 1;
+}
+
+/**************** Externally referenced routine. ***********/
+/* toolDispatcher -- dispatch events until data is available on fp */
+toolDispatcher(fp, prompt)
+  FILE *fp;
+  char *prompt;
+{
+  int inMask= 1 << fileno(fp);
+  int xMask= 1 << dpyno();
+  int rfds= 0;
+  int nfds;
+  XEvent ev;
+  int pend;
+  
+  gdbPrompt= prompt;
+  
+  while (! (rfds & inMask)) {
+    pend= XPending();
+    if (!pend) {
+      rfds= inMask | xMask;
+      /* this isn't right for 4.3 but it works 'cuz of 4.2 compatibility */
+      nfds= select( 32, &rfds, 0, 0, (struct timeval *) 0);
+    }
+    if (pend || rfds & xMask) {
+      XNextEvent(&ev);
+      XtDispatchEvent(&ev);
+    }
+  }
+}  
+
+From beatty@unh.cs.cmu.edu Sat Jul  4 12:17:44 1987
+Received: by PREP.AI.MIT.EDU; Sat, 4 Jul 87 12:15:18 EDT
+Message-Id: <8707041615.AA08691@prep.ai.mit.edu>
+To: phr@PREP.AI.MIT.EDU (Paul Rubin)
+Date: Sat, 4 Jul 87 12:14:08 EDT
+From: Derek Beatty <beatty@unh.cs.cmu.edu>
+Subject: Re: gdb and X (msg 3 of 3)
+In-Reply-To: Message from "Paul Rubin" of Jul 4, 87 at 1:22 am
+Status: R
+
+Context diffs follow.  The original files are from GDB 2.1 (emacs distribution
+18.40).
+
+ -- Derek Beatty
+[nosave]
+*** /usr/misc/.gdb/src/core.c	Fri Mar 27 12:20:14 1987
+--- core.c	Sat Jul  4 11:12:16 1987
+***************
+*** 1,3
+  /* Work with core dump and executable files, for GDB.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+
+--- 1,5 -----
++ /* modified by Beatty 1 Jul 87 for gdb tool. */
++ 
+  /* Work with core dump and executable files, for GDB.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+***************
+*** 257,262
+      }
+    else if (from_tty)
+      printf ("No exec file now.\n");
+  }
+  
+  /* If we have both a core file and an exec file,
+
+--- 259,267 -----
+      }
+    else if (from_tty)
+      printf ("No exec file now.\n");
++ #ifdef TOOL
++     toolSetExecFile( filename ? filename : "No executable specified.\n");
++ #endif /* def TOOL */
+  }
+  
+  /* If we have both a core file and an exec file,
+*** /usr/misc/.gdb/src/breakpoint.c	Fri Mar 27 12:20:11 1987
+--- breakpoint.c	Wed Jul  1 11:27:31 1987
+***************
+*** 1,3
+  /* Everything about breakpoints, for GDB.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+
+--- 1,5 -----
++ /* modified by Beatty 1 Jul 87 for gdbtool */
++ 
+  /* Everything about breakpoints, for GDB.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+***************
+*** 513,518
+  	break;
+        }
+  }
+  
+  /* Set a breakpoint according to ARG (function, linenum or *address)
+     and make it temporary if TEMPFLAG is nonzero.  */
+
+--- 515,571 -----
+  	break;
+        }
+  }
++ 
++ #ifdef TOOL
++ /* set a breakpoint from a symtab and line */
++ void break_command_for_tool( s, line, tempflag)
++   struct symtab *s;
++   int line;
++   int tempflag;
++ {
++   register struct breakpoint *b;
++   struct symtab_and_line sal;
++   
++   sal.symtab= s;
++   sal.line= line;
++   sal.pc= find_line_pc( sal.symtab, sal.line);
++   if (sal.pc==0) {
++     error("No line %d in file \"%s\".\n", sal.line, sal.symtab->filename);
++   } else {
++     b= set_raw_breakpoint( sal);
++     b->number= ++breakpoint_count;
++     b->cond= 0;
++     if (tempflag)
++       b->enable= temporary;
++ 
++   printf ("Breakpoint %d at 0x%x", b->number, b->address);
++   if (b->symtab)
++     printf (": file %s, line %d.", b->symtab->filename, b->line_number);
++   printf ("\n");
++ 
++     {
++       int others = 0;
++       ALL_BREAKPOINTS (b)
++ 	if (b->address == sal.pc && b->number != breakpoint_count)
++ 	  others++;
++       if (others > 0)
++ 	{
++ 	  printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
++ 	  ALL_BREAKPOINTS (b)
++ 	    if (b->address == sal.pc && b->number != breakpoint_count)
++ 	      {
++ 		others--;
++ 		printf ("%d%s%s ",
++ 			b->number,
++ 			(b->enable == disabled) ? " (disabled)" : "",
++ 			(others > 1) ? "," : ((others == 1) ? " and" : ""));
++ 	      }
++ 	  printf (" also set at pc 0x%x\n", sal.pc);
++ 	}
++     }
++   }
++ }
++ #endif /* def TOOL */
+  
+  /* Set a breakpoint according to ARG (function, linenum or *address)
+     and make it temporary if TEMPFLAG is nonzero.  */
+*** /usr/misc/.gdb/src/main.c	Fri Mar 27 12:20:45 1987
+--- main.c	Sat Jul  4 11:13:32 1987
+***************
+*** 1,3
+  /* Top level for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+
+--- 1,5 -----
++ /* modified by Beatty 30 june 87 for gdb tool */
++ 
+  /* Top level for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+***************
+*** 42,47
+  
+  FILE *instream;
+  
+  void free_command_lines ();
+  char *read_line ();
+  static void initialize_main ();
+
+--- 44,54 -----
+  
+  FILE *instream;
+  
++ #ifdef TOOL
++ /* flag indicating whether we are running in a window system */
++ int isaTool= 0;
++ #endif /* def TOOL */
++ 
+  void free_command_lines ();
+  char *read_line ();
+  static void initialize_main ();
+***************
+*** 214,219
+  
+    while (1)
+      {
+        if (!setjmp (to_top_level))
+  	command_loop ();
+        clearerr (stdin);		/* Don't get hung if C-d is typed.  */
+
+--- 221,232 -----
+  
+    while (1)
+      {
++ 
++ #ifdef TOOL
++       if (!isaTool)
++         isaTool= createTool();
++ #endif /* def TOOL */
++ 
+        if (!setjmp (to_top_level))
+  	command_loop ();
+        clearerr (stdin);		/* Don't get hung if C-d is typed.  */
+***************
+*** 270,275
+  	printf ("%s", prompt);
+        fflush (stdout);
+  
+        quit_flag = 0;
+        execute_command (read_line (instream == stdin), instream == stdin);
+        /* Do any commands attached to breakpoint we stopped at.  */
+
+--- 283,294 -----
+  	printf ("%s", prompt);
+        fflush (stdout);
+  
++ #ifdef TOOL
++       toolDisplaySource();
++       if (isaTool) toolDispatcher(instream, 
++       				  instream==stdin ? prompt : NULL);
++ #endif /* def TOOL */
++ 
+        quit_flag = 0;
+        execute_command (read_line (instream == stdin), instream == stdin);
+        /* Do any commands attached to breakpoint we stopped at.  */
+***************
+*** 320,325
+  
+    while (1)
+      {
+        c = fgetc (instream);
+        if (c == -1 || c == '\n')
+  	break;
+
+--- 339,345 -----
+  
+    while (1)
+      {
++ 
+        c = fgetc (instream);
+        if (c == -1 || c == '\n')
+  	break;
+***************
+*** 765,770
+  GDB is free software and you are welcome to distribute copies of it\n\
+   under certain conditions; type \"info copying\" to see the conditions.\n",
+  	  version);
+  }
+  
+  static void
+
+--- 785,793 -----
+  GDB is free software and you are welcome to distribute copies of it\n\
+   under certain conditions; type \"info copying\" to see the conditions.\n",
+  	  version);
++ #ifdef TOOL
++   printf( "(CMU X support is available in this version.)\n");
++ #endif
+  }
+  
+  static void
+*** /usr/misc/.gdb/src/source.c	Fri Mar 27 12:20:50 1987
+--- source.c	Wed Jul  1 17:56:58 1987
+***************
+*** 1,3
+  /* List lines of source files for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+
+--- 1,5 -----
++ /* modified 1 July 87 by Beatty for gdbtool */
++ 
+  /* List lines of source files for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+***************
+*** 295,300
+    s->nlines = nlines;
+    s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
+  }
+  
+  /* Print source lines from the file of symtab S,
+     starting with line number LINE and stopping before line number STOPLINE.  */
+
+--- 297,328 -----
+    s->nlines = nlines;
+    s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
+  }
++ 
++ #ifdef TOOL
++ /* Get full pathname and line number positions for a symtab 
++  *	return nonzero if line numbers may have changed
++  *	set full pathname to NULL if no file found
++  */
++ int
++ get_filename_and_charpos(s, line, fullname)
++   struct symtab *s;
++   int line;
++   char **fullname;
++ {
++   register int desc, linenums_changed= 0;
++   
++   desc= openp(source_path, 0, s->filename, O_RDONLY, 0, fullname);
++   if (desc < 0) {
++     *fullname= NULL;
++     return 0;
++   }  
++   if (s->line_charpos==0) linenums_changed= 1;
++   if (linenums_changed) find_source_lines(s, desc);
++   close(desc);
++   return linenums_changed;
++ }
++ #endif /* def TOOL */
++ 
+  
+  /* Print source lines from the file of symtab S,
+     starting with line number LINE and stopping before line number STOPLINE.  */
+*** /usr/misc/.gdb/src/stack.c	Fri Mar 27 12:20:51 1987
+--- stack.c	Wed Jul  1 17:27:34 1987
+***************
+*** 1,3
+  /* Print and select stack frames for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+
+--- 1,5 -----
++ /* modified by Beatty 1 Jul 87 for gdbtool */
++ 
+  /* Print and select stack frames for GDB, the GNU debugger.
+     Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+  
+***************
+*** 42,47
+  static void select_calling_frame ();
+  
+  void print_frame_info ();
+  
+  /* Print a stack frame briefly.  FRAME should be the frame address
+     and LEVEL should be its level in the stack (or -1 for level not defined).
+
+--- 44,62 -----
+  static void select_calling_frame ();
+  
+  void print_frame_info ();
++ 
++ #ifdef TOOL
++ /* get symtab and line of selected frame, for tool display */
++ struct symtab_and_line
++ get_selected_frame_sal()
++ {
++   struct frame_info fi;
++ 
++   fi= get_frame_info( selected_frame);
++   return find_pc_line(fi.pc, fi.next_frame);
++ }
++ 
++ #endif /* TOOL */
+  
+  /* Print a stack frame briefly.  FRAME should be the frame address
+     and LEVEL should be its level in the stack (or -1 for level not defined).
+End of context diffs.  The presence of this line verifies that this message
+has not been truncated.
+
diff --git a/gdb/COPYING b/gdb/COPYING
new file mode 100644
index 0000000..9f3a6dc
--- /dev/null
+++ b/gdb/COPYING
@@ -0,0 +1,138 @@
+
+		    GDB GENERAL PUBLIC LICENSE
+		    (Clarified 20 March 1987)
+
+ Copyright (C) 1986 Richard M. Stallman
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license, but changing it is not allowed.
+
+  The license agreements of most software companies keep you at the
+mercy of those companies.  By contrast, our general public license is
+intended to give everyone the right to share GDB.  To make sure that
+you get the rights we want you to have, we need to make restrictions
+that forbid anyone to deny you these rights or to ask you to surrender
+the rights.  Hence this license agreement.
+
+  Specifically, we want to make sure that you have the right to give
+away copies of GDB, that you receive source code or else can get it
+if you want it, that you can change GDB or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights.  For example, if you distribute
+copies of GDB, you must give the recipients all the rights that you
+have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+
+  Also, for our own protection, we must make certain that everyone
+finds out that there is no warranty for GDB.  If GDB is modified by
+someone else and passed on, we want its recipients to know that what
+they have is not what we distributed, so that any problems introduced
+by others will not reflect on our reputation.
+
+  Therefore we (Richard Stallman and the Free Software Foundation,
+Inc.) make the following terms which say what you must do to be
+allowed to distribute or change GDB.
+
+
+			COPYING POLICIES
+
+  1. You may copy and distribute verbatim copies of GDB source code as
+you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc." (or with the year updated if
+that is appropriate); keep intact the notices on all files that refer
+to this License Agreement and to the absence of any warranty; and give
+any other recipients of the GDB program a copy of this License
+Agreement along with the program.  You may charge a distribution fee
+for the physical act of transferring a copy.
+
+  2. You may modify your copy or copies of GDB or any portion of it,
+and copy and distribute such modifications under the terms of
+Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of GDB or any
+    part thereof, to be licensed at no charge to all third parties on
+    terms identical to those contained in this License Agreement
+    (except that you may choose to grant more extensive warranty
+    protection to third parties, at your option).
+
+    c) if the modified program serves as a debugger, cause it
+    when started running in the simplest and usual way, to print
+    an announcement including a valid copyright notice
+    "Copyright (C) 1986 Free Software Foundation, Inc." (or with
+    the year updated if appropriate), saying that there
+    is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of
+    this License Agreement.
+
+    d) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute GDB or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of GDB in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer GDB
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer GDB is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of GDB into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse
+of software.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+
+		       NO WARRANTY
+
+  BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO
+WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF GDB IS WITH YOU.  SHOULD GDB PROVE DEFECTIVE, YOU
+ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE GDB AS PERMITTED ABOVE, BE LIABLE TO
+YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
+SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
+INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
+BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
+FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN
+IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR
+ANY CLAIM BY ANY OTHER PARTY.
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
new file mode 100644
index 0000000..301bdac
--- /dev/null
+++ b/gdb/ChangeLog
@@ -0,0 +1,1025 @@
+Fri Jan 15 05:09:18 1988  Richard Stallman  (rms at frosted-flakes)
+
+	* valprint.c [IEEE_FLOAT]: New function `is_nan' checks
+	whether a double is a nan.
+
+	* printcmd.c (print_formatted) [IEEE_FLOAT]:
+	Detect nans and print specially.
+	* valprint.c (val_print) [IEEE_FLOAT]: Same thing.
+
+	* m68k-pinsn.c (convert_{to,from}_68881): Hand-assemble
+	all the assembler code.
+
+	* m-newsinit.h, m-news800.h: Two new files.
+
+Thu Jan  7 22:25:16 1988  Richard Stallman  (rms at frosted-flakes)
+
+	* valops.c (value_assign): Don't coerce the arg being stored in.
+	Coercion is not right either for an array or for an enum.
+
+Tue Jan  5 00:59:29 1988  Richard Stallman  (rms at frosted-flakes)
+
+	* symtab.c (decode_line_1): Don't complain about no symtabs loaded
+	until after trying the misc function table.
+
+Sat Jan  2 13:16:08 1988  Richard Stallman  (rms at frosted-flakes)
+
+	* stack.c (record_selected_frame): New fn to access
+	the selected frame and its level.
+	* infcmd.c (run_stack_dummy): Save and restore the selected
+	frame and its level.
+
+Wed Dec 30 18:44:41 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* valprint.c (type_print_varspec_prefix):
+	Treat arrays just like functions.
+	* valprint.c (type_print_varspec_{prefix,suffix}):
+	When passed_a_ptr is handled, pass 0 for it in the recursive call.
+
+Fri Dec 18 10:24:14 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* findvar.c (read_var_value): Share code between values really
+	in registers and values in saved registers.
+	Register short on a big-endian machine needs a VALUE_OFFSET.
+
+	* findvar.c (locate_var_value): Offset the address of a
+	saved register variable that's shorter than the register.
+
+Thu Dec 17 08:26:31 1987  Richard Stallman  (rms at lucky-charms)
+
+	* valprint.c (type_print_base): Print nameless bit fields
+	to indicate gaps before bit fields.
+
+	* source.c (select_source_symtab): Ignore .h files.
+	Also, if a function `main' exists, make the default listing line
+	the beginning of `main'.
+
+	* breakpoint.c ({get,set}_breakpoint_commands):
+	Commands to examine or set the pending breakpoint-commands.
+
+	* infcmd.c (run_stack_dummy): Save and restore the breakpoint
+	commands around the function call.
+
+	* stack.c (return_command): Don't query or print if not interactive.
+
+	* value.h (COERCE_ENUM): New macro: if arg is enum, convert to int.
+	* value.h (COERCE_ARRAY): Do that, as well as old job.
+
+	* valarith.c (value_binop, value_neg, value_lognot):
+	Use COERCE_ENUM on the arguments.
+	* valops.c (value_arg_coerce): Likewise.
+	* valops.c (value_cast): AVOID coercing enums when arrays are.
+
+	* eval.c (evaluate_subexp): In the BINOP_SUB case,
+	use evaluate_subexp_with_coercion.
+
+	* inflow.c (terminal_ours_1, terminal_inferior):
+	Ignore inferior_thisrun_terminal since our terminal
+	is the inferior's controlling terminal regardless.
+
+	* m-sun3.h: Fix assembler syntax for kdb macros.
+
+	* infcmd.c ({attach,detach}_command): New functions from Dave Taylor.
+	* inflow.c (attach, detach): New functions from Dave Taylor.
+	* infrun.c (attach_process): New function, middle-level.
+	Does all the work of attaching a process, assuming there is no
+	inferior yet, except for printing and querying.
+
+	* infrun.c (clear_proceed_status): Clear `stop_after_attach'.
+	* infrun.c (wait_for_inferior): Handle `stop_after_attach'.
+
+Sat Dec 12 04:36:39 1987  Richard Stallman  (rms at corn-chex)
+
+	* dbxread.c (end_symtab): The free_code for a symseg got
+	from a file should be free_linetable.
+
+	* dbxread.c: Allocate blockvector, blocks, symbols and symbol names
+	from the symbol-obstack, and use free_linetable for all files.
+	The typevector is still malloc'd, so put it in the free_ptr
+	to get it freed.
+
+	* symmisc.c (free_symtab): Always free the `free_ptr' if nonzero.
+	`free_explicit' therefore now the same as `free_nothing'.
+
+	* dbxread.c (define_symbol): Handle defn code 'c', used by
+	fortran, which defines integer and real constant symbols.
+
+	* symseg.h: Define LOC_CONST_BYTES for constants longer than a
+	word.  New `bytes' alternative for the value of a symbol.
+
+	* symtab.h (SYMBOL_VALUE_BYTES): Macro to access `bytes'.
+
+	* findvar.c ({read,locate}_var_value): Handle LOC_CONST_BYTES.
+	* printcmd.c (address_info): Handle LOC_CONST_BYTES.
+	* symmisc.c (print_symbol): Handle LOC_CONST_BYTES.
+
+Tue Dec  8 20:26:37 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* symtab.c (find_line_pc_range): Detection of last line in file
+	was erroneous.
+
+Fri Dec  4 21:52:52 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* dbxread.c (read_range_type): Accept the typenums as argument.
+	Use read_type_number to read the subrange-of type.
+	A type defined as a subrange of itself is void.
+
+Thu Dec  3 12:45:10 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* inflow.c ({fetch,store}_inferior_registers): Support UMAX_PTRACE.
+
+	* m-umax.h: New file, for Encore machines.
+
+	* core.c (exec_file_command, etc): Decode COFF files.
+	* core.c (core_file_command): Support UMAX_CORE format.
+	* core.c (validate_files, exec_file_command):
+	Set exec_mtime in exec_file_command so that COFF vs non-COFF
+	differences appear all in one place.
+
+	* coffread.c: New file from Dave Johnson.
+
+	* core.c (specify_exec_file_hook): New function to specify
+	a hook to be called by exec_file_command.  Last #ifdef X_WINDOWS gone.
+	* xgdb.c (initialize): Specify a hook.
+
+	* infrun.c, inferior.h: Replace stop_r0 and stop_r1 with an array
+	`stop_registers' that will hold ALL the registers.
+	* infcmd.c (run_stack_dummy): Get the value from `stop_registers'
+	and copy all of that into BUFFER.
+	* infcmd.c (finish_command): Specify `stop_registers'
+	to `value_being_returned'.
+	* values.c (value_being_returned): Use the new EXTRACT... macros.
+	* values.c (set_return_value): Use new STORE_RETURN_VALUE macro.
+	* valops.c (call_function): Allocate retbuf long enough for all regs.
+	* m-*.h: New macros EXTRACT_RETURN_VALUE, STORE_RETURN_VALUE and
+	EXTRACT_STRUCT_VALUE_ADDRESS that express machine-dependencies
+	in where return values are stored.
+
+	* valops.c (call_function): Flush default for CALL_DUMMY_START_OFFSET.
+	Assume it is defined.
+	* m-vax.h: Define CALL_DUMMY_START_OFFSET.
+
+	* ns32k-pinsn.c (ns32k-localcount): Fix decoding of `enter' insn.
+	* ns32k-pinsn.c (n32k_get_enter_addr): New fn used from m-umax.h.
+
+	* m-*.h: Change INVALID_FLOAT to accept 2nd arg which is length
+	of the float.
+	* values.c (unpack_double): Pass the 2nd arg.
+	* vax-pinsn.c (print_insn_arg): Pass the 2nd arg.
+	* infcmd.c (registers_info): Pass the 2nd arg.
+
+Wed Nov 25 15:06:55 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* Bug fixes by David Johnson (ddj%cs.brown.edu@relay.cs.net).
+
+	* symtab.c (list_symbols): Print typedef names, and don't call
+	them `static'.
+
+	* symmisc.c (print_symtabs): Allow immediate quit, and close the
+	output file if that happens.
+
+	* stack.c (frame_command): Declare args `unsigned' so a negative
+	number is a frame address, not a level number.
+
+	* source.c: Check for error-return from calls to `getwd'.
+
+	* printcmd.c (address_info): Fix error in case of a function name.
+
+	* inflow.c (create_inferior): Return the inferior pid properly.
+
+	* inferior.h: Define `inferior_io_terminal'.
+	* infrun.c (tty_command): New command to specify inferior_io_terminal.
+	* inflow.c (new_tty): Open specified terminal for the inferior.
+	* inflow.c (terminal_{ours,inferior}): Do nothing if inferior was
+	started with its own terminal.
+	* main.c (main): -t switch calls `tty_command'.
+
+	* expread.y (rule for `block'): `copy_name' was called in wrong
+	place and with wrong args.
+
+	* dbxread.c: Entire file #ifdef READ_DBX_FORMAT.
+	* m-*.h: Define READ_DBX_FORMAT.
+
+	* breakpoint.c (initialize): Error in doc string of `info breakpoints'.
+
+Wed Nov 11 12:57:28 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* ns32k-opcode.h, ns32k-pinsn.c: Two new files.
+	* m-merlin.h: New file, for one 32000 box.
+
+Mon Nov  9 10:31:42 1987  Brian Fox  (bfox at sugar-smacks)
+
+	* eval.c (evaluate_subexp): Made the case of OP_FUNCALL use
+	evaluate_subexp_with_coercion, so that array references would
+	get converted into pointer references.
+
+Mon Nov  9 05:50:24 1987  Richard Stallman  (rms at sugar-smacks)
+
+	* breakpoint.c (ignore_command): Error if no arg.
+
+Sat Nov  7 13:57:40 1987  Richard Stallman  (rms at frosted-flakes)
+
+	* main.c (quit_command): Get rid of execfile before the kill_inferior.
+
+	* xgdb.c: New file, interface to X windows.
+
+	* main.c (main): Look for flag arguments before
+	calling the initialization functions.  -nw switch sets
+	`inhibit_windows' which xgdb.c looks at.
+	* main.c (command_loop): Call the window hook function, if any.
+
+	* source.c (get_filename_and_charpos): New function
+	that interfaces to find_source_lines.
+	* source.c (source_line_charpos, source_charpos_line):
+	New functions translate source line number to char pos and vice versa.
+
+	* breakpoint.c (describe_other_breakpoints): New subroutine
+	to list all breakpoints at PC in a message about "other
+	breakpoints".
+	* breakpoint.c (break_command_1): Use describe_other_breakpoints.
+	* breakpoint.c (set_breakpoint): Like break_command_1
+	but takes arg predecoded into symtab and line.
+
+	* core.c (exec_file_command): Call xgdb_display_exec_file.
+
+	* valprint.c (type_print_base): For struct bitfields,
+	print the bit size.
+
+Thu Aug 20 02:46:47 1987  Richard M. Stallman  (rms at prep)
+
+	* Version 2.4.
+
+	* m68k-pinsn.c (print_insn_arg): Implement place = '3'.
+
+	* findvar.c (write_register_bytes): Arg to
+	store_inferior_registers should be -1: write all registers.
+
+	* dbxread.c (symbol_file_command): If no arg,
+	just discard all symbols.
+
+	* core.c (myread): Flush the 4th arg (filename).
+	* source.c (find_source_lines): Don't pass 4th arg.
+	* symmisc.c (read_symsegs): Ditto.
+
+	* dbxread.c (process_one_symbol): One call to `define_symbol'
+	lacked 3rd arg.
+
+	* inflow.c (write_inferior_memory): On failure, return the errno value.
+	* core.c (write_memory): ditto.
+	* breakpoint.c ({insert,remove}_breakpoints): ditto.
+	* utils.c (print_sys_errmsg): Like perror_with_name but don't
+	signal an error; also, the error code is an arg instead of from
+	`errno'.
+	* infrun.c : Save the value from insert_breakpoints and pass it to
+	print_sys_errmsg.
+
+	* main.c (input_from_terminal_p): Put in omitted `return'.
+
+	* Makefile (expread.o): Use $(CC).
+
+Sun Jun  7 04:42:51 1987  Richard M. Stallman  (rms at prep)
+
+	* version.c: Version 2.3.
+
+	* inflow.c (terminal_ours): Save fcntl flags correctly.
+	* inflow.c (term_status_command):
+	Print the tchars and ltchars structures, byte by byte.
+
+Mon May 25 14:37:14 1987  Richard M. Stallman  (rms at prep)
+
+	* version.c: Version 2.2.
+
+	* breakpoint.c (do_breakpoint_commands):
+	Advance breakpoint_commands before executing the command,
+	in case command is `cont' and it hits another bpt with commands.
+
+Sun May 24 20:45:04 1987  Richard M. Stallman  (rms at prep)
+
+	* value.h: Declare `contents' long and cast its address to char *.
+
+	* expread.y (prefixify_expression): Don't call alloca among the decls.
+
+	* printcmd.c (print_variable_value): Flush unused local `space'.
+
+	* main.c (execute_command): Barf on "user" like other class names.
+
+Fri May 22 01:34:37 1987  Richard M. Stallman  (rms at prep)
+
+	* m68k-pinsn.c (fetch_arg): New arg position 'j', for movec.
+	(print_insn_arg): New arg syntax 'J', for movec.
+	* m68k-opcode.h: movec uses 'Jj'.  Everything reformatted.
+	bf... and cas... insns were corrected.
+
+	* inflow.c (create_inferior): Fork and exec with given args and env.
+	Call close_exec_file.
+	(inferior_died): Record the fact that the inferior no longer exists.
+	Call reopen_exec_file.
+
+	* core.c (close_exec_file): New fn: Close the execchan if it's open.
+	(reopen_exec_file): New fn: Reopen execchan if not currently open.
+
+	* infrun.c (wait_for_inferior): Call inferior_died if it exits.
+
+	* infcmd.c (run_command): Don't fork and exec; call create_inferior.
+
+	* findvar.c (read_var_value): For reg var in a convertable reg,
+	fetch reg in its own virtual type and then cast to variable's type.
+
+	* symtab.h: Declare xmalloc to return char *.
+
+	* dbxread.c (read_dbx_symtab): Record static text syms as
+	misc-functions.  But if an assembler symbol supplies the address
+	for a debugger symbol, don't record it as a misc-function.
+
+	* utils.c (query): Do clearerr (stdin) frequently in case of C-d.
+
+	* dbxread.c (process_one_symbol, define_symbol):
+	Pass the stab's DESC down to define_symbol.
+	DESC = 0 means GCC output: if type is "short", believe it.
+
+	* dbxread.c (read_enum_type): Don't allocate the type here;
+	take it as an argument.  (Like read_struct_type.)
+	(read_type)): Before call to read_enum_type, allocate the type
+	or get the one already allocated.
+
+	* printcmd.c (print_frame_args): Print a comma before
+	every arg except the first.
+
+Wed May 13 00:36:00 1987  Richard M. Stallman  (rms at prep)
+
+	* m68k-pinsn.c (convert_{to,from}_68881):
+	Hand-assemble the fmoved and fmovex insns.
+
+	* dbxread.c (define_symbol): For case 'p', a parameter,
+	if specified type is short or char, change it to int.
+	This is for how PCC handles arguments.
+	Define new case 'P' that does what 'p' used to do.
+	Maybe GCC will use this.
+
+Mon May  4 21:52:44 1987  Richard M. Stallman  (rms at prep)
+
+	* main.c (main): If SET_STACK_LIMIT_HUGE, set the
+	run-time stack limit as high as it can go.
+	* m-sun3.h, m-vax.h: define SET_STACK_LIMIT_HUGE.
+
+Sun May  3 08:46:23 1987  Richard Mlynarik  (mly at prep)
+
+	* command.c, expread.y, findvar.c, infcmd.c, inflow.c, utils.c,
+	values.c, defs.h:  Various ANSI C compatibility changes
+	(fouts@wilbur.arpa <8705010117.AA13112@wilbur.arpa>)
+
+	* core.c, inflow.c: Fix calls to supply_register.
+	* findvar.c (supply_register): Instead of register value as int,
+	pass address of buffer in core containing contents in raw form.
+
+Sat Apr 18 17:09:42 1987  Richard Mlynarik  (mly at prep)
+
+	* main.c (command_loop):
+	Do any cleanups made by a executing a command each time around.
+
+	* source.c (directory_command):
+	make_cleanup (free, dirname), not
+	make_cleanup (free_current_contents, &dirname)
+	(rlk <8704180416.AA29572@PARIS.MIT.EDU>)
+
+Mon Apr 13 20:28:26 1987  Leonard H. Tower Jr.  (tower at prep)
+
+	* gdb.1: fixed typo and italicization errors.
+	(<kgk%cs.brown.edu@RELAY.CS.NET> id AA16470;Sun,12 Apr 87 14:30:07 EST)
+
+Sat Apr 11 15:41:01 1987  Richard Mlynarik  (mly at prep)
+
+	* dbxread.c (read_dbx_symtab):
+	No name for symbol => "" not 0 (avoid referencing memory 0)
+	(tower <8704081854.AA00135@buit3.bu.edu>)
+
+Mon Mar 30 22:24:07 1987  Leonard H. Tower Jr.  (tower at prep)
+
+	* gdb.1: Unix style manual page pointing at internal gdb
+	documentation, and info sub-system in GNU Emacs.
+
+Fri Mar 20 12:07:15 1987  Richard M. Stallman  (rms at prep)
+
+	* COPYING: Clarifications about distribution fees and mixing.
+	* main.c (copying_info): Same changes.
+
+Tue Mar 17 17:40:14 1987  Richard M. Stallman  (rms at prep)
+
+	* values.c (unpack_field_as_long): Avoid >>= operator
+	since ISI compiler has a bug.
+
+Sat Mar  7 12:19:35 1987  Richard M. Stallman  (rms at prep)
+
+	* GDB version 2.1.
+
+	* values.c (unpack-field-as-long): Tests for endianness were broken.
+	* findvar.c (read_var_value):
+	Now we initialize the union as an int and test it as a char.
+
+Sun Mar  1 16:16:20 1987  Richard M. Stallman  (rms at prep)
+
+	* main.c (define_command): Command class symbols
+	must be cast to int.
+
+Mon Feb 23 02:47:44 1987  Richard M. Stallman  (rms at prep)
+
+	* source.c (list_command): Reword error messages.
+	New message for case of first arg not just a line-number
+	and no symtab specified by it.
+
+Sun Feb 22 21:15:19 1987  Richard M. Stallman  (rms at prep)
+
+	* dbxread.c (compare_misc_functions):
+	Compare the addresses as unsigned numbers.
+
+Sun Feb 22 13:11:45 1987  Richard Mlynarik  (mly at prep)
+
+	* main.c (define_command, document_command):
+	Stuff was being unnecessarily malloced (-and- not freed!)
+
+	* main.c (execute_command):
+	User-defined commands don't take args.
+	Don't confuse empty user command with no command.
+	Replace bogus `etext' test with a comparison against
+	class_user.
+
+	* main.c (define_command):
+	If the command of the specified name is built-in, note that when
+	asking whether to redefine it (this is suppressed for class_alias
+	-- should it not be?)
+
+	* main.c (define_command):
+	If command was previously built-in, don't preserve its
+	documentation (otherwise could get error later when trying to free
+	the non-malloced text of built-in documentation strings)
+
+Tue Feb 17 16:23:57 1987  Richard Mlynarik  (mly at prep)
+
+	* main.c (echo_command): Don't die if not given any arg.
+	* main.c (cd_command):  Echo new cwd if interactive.
+
+Thu Feb 12 11:22:56 1987  Richard M. Stallman  (rms at prep)
+
+	* stack.c (initialize): "bt" now appears in help aliases.
+
+	* Version 2.0 released.
+
+Wed Feb 11 17:45:45 1987  Richard M. Stallman  (rms at prep)
+
+	* m68k-opcode.h: Errors corrected in several instructions
+	and reordering done for assembler's sake.
+
+	* m-vax.h (POP_FRAME): End with call to set_current_frame.
+
+Tue Feb 10 15:06:07 1987  Richard M. Stallman  (rms at prep)
+
+	* infrun.c (wait_for_inferior): Set stop_print_frame to 1
+	after checking breakpoint condition.
+
+	* infcmd.c (run_stack_dummy): Save many flags.
+
+Thu Feb  5 07:12:20 1987  Richard Mlynarik  (mly at prep)
+
+	* source.c (directory_command):
+	Step over `:'
+
+Mon Feb  2 23:40:32 1987  Richard M. Stallman  (rms at prep)
+
+	* infcmd.c (set_environment_command): Fix stupid error
+	for case where no "=" appears in the string.
+
+Mon Jan 26 13:46:52 1987  Richard M. Stallman  (rms at prep)
+
+	* printcmd.c (print_frame_args): Round end-of-arg offset
+	up rather than down to multiple of int.
+
+Fri Jan 23 15:11:50 1987  Richard M. Stallman  (rms at prep)
+
+	* source.c (directory_command): If dir is not added cause already
+	present, print explanation.
+
+	* infrun.c (proceed): Use read_pc (), not stop_pc,
+	to get current pc to think about.  stop_pc could have been
+	clobbered by call_function.
+
+Fri Jan 23 15:00:55 1987  Richard Mlynarik  (mly at prep)
+
+	* source.c (directory_command):
+	If dir is already in source_path, don't append another copy of it.
+
+Thu Jan 22 00:31:03 1987  Richard M. Stallman  (rms at prep)
+
+	* Version 2.0.
+
+	* blockframe.c (get_pc_function_start):
+	Understand misc functions.
+
+	* core.c (core_file_command):
+	Copy all register contents into the array `registers'
+	Save a.out header of executable file in core_aouthdr.
+	Print name of executable file that was running, if we know
+	where to find it.
+
+	* core.c (exec_file_command):
+	Save a.out header in exec_aouthdr and file's mtime
+	in exec_mtime.
+
+	* core.c (validate_files): Check that core file's a.out hdr
+	matches exec file's.
+
+	* New handling of registers:
+	Now all registers are fetched once when the program stops or
+	when a core file is selected.  Their contents are kept in
+	`registers', an array of bytes.  This is done by
+	`fetch_inferior_registers'.  `read_register', etc., just look
+	there.  Writing a register works through
+	`store_inferior_registers' which writes one or all registers
+	from `registers' back to the inferior.
+
+	A register now can have a "raw" data format and a "virtual"
+	data format, which may require conversion or even be different sizes.
+	The conversion can be different for different registers.
+	For example, the 68000 cpu registers need no conversion
+	and both raw and virtual size is 4, but the 68881 floating point
+	registers have raw size 12 (for extended fmt) and virtual size 8
+	(for double).  Macros in the m- file such as REGISTER_BYTES,
+	REGISTER_BYTE, REGISTER_{RAW,VIRTUAL}_SIZE, and
+	REGISTER_CONVERT_TO_{RAW,VIRTUAL} control these things.
+
+	`read_register' and `write_register' are usable only on registers
+	which hold an int and need no conversion (raw fmt = virtual fmt).
+	For other registers, `read_register_bytes' is used, or
+	`read_relative_register_raw_bytes'.
+
+	* m-sun3.h: Define the 68881 fp registers.
+	Know how to recognize insns that save them.
+	Make dummy frames save them.
+
+	* core.c (read_register, write_registers): Functions deleted.
+	* findvar.c (read_register, write_registers): New functions,
+	not the same as the old ones of the same name.
+
+	* findvar.c (supply_register): Function used by
+	fetch_inferior_registers, etc., to install the register
+	values fetched from the inferior.
+
+	* findvar.c (read_register_bytes, write_register_bytes):
+	Read spec'd number of bytes from the byte-array `registers'.
+
+	* findvar.c (read_relative_register_raw_bytes):
+	Replaces old function `read_relative_register'; accepts
+	address of where to store the contents; # bytes stored is size
+	of the specified register in raw format.
+
+	* findvar.c (value_of_register, read_var_value):
+	Convert register values and values of register variables
+	from raw format to virtual format.
+
+	* findvar.c (locate_var_value): Like `read_var_value' but
+	returns value for variable's address.
+
+	* value.h: Add new field VALUE_REGNO to each value.  It holds
+	register number to control virtual-to-raw conversion
+	for assignments to the value.
+
+	* valops.c (value_assign): Convert data from virtual to raw format
+	if value came from a register variable.
+	Use read_register_bytes and write_register_bytes.
+
+
+	* infcmd.c (continue_command): Subtract 1 from arg
+	before setting breakpoint's ignore-count.
+
+	* infcmd.c (jump_command): Query if spec'd line is outside
+	of the current function.
+
+	* infcmd.c (finish_command): Now finish the selected frame,
+	and no arg required.
+
+	* infcmd.c (set_environment_command): Allow space to separate
+	varname and value.
+
+	* infcmd.c (registers_info): Print both raw and virtual data
+	format if they differ.  Allow register name as arg.
+	Ask for a Newline each 16 registers.
+
+	* inflow.c (kill_inferior): call mark_breakpoints_out.
+	* inflow.c ({fetch,store}_inferior_registers for Sun):
+	Get the fp registers and store them in right places in
+	`registers'.
+	* inflow.c ({read,write}_inferior_register): Deleted.
+
+	* infrun.c (wait_for_inferior): Single-stepping is not considered
+	to have hit a breakpoint unless the pc before the step matches the
+	address of the breakpoint.  Necessary on machines where
+	breakpoints leave the pc incremented.
+
+	If shell gets SIGSEGV, pass the signal silently to it.
+
+	* m68k-pinsn.c, m68k-opcode.h:
+	Add the 68881 instructions.  New operand codes `F', `I', `s'
+	and `k' are needed for them.  New place codes `78tcik'.
+	NEXTBYTE now skips a word but fetches just a byte.
+	Explicit sign-extension removed from NEXTBYTE and NEXTWORD.
+	NEXTSINGLE, NEXTDOUBLE, NEXTEXTEND and NEXTPACKED defined.
+	Various changes to implement the new operand and place codes.
+	print_index changed because displacement-size codes for
+	word and long displacement were interchanged.
+
+	* m68k-pinsn.c (convert_{from,to}_68881): Functions added
+	to support REGISTER_CONVERT_TO_{RAW,VIRTUAL} on 68000.
+
+	* main.c (main): Move around calls to setjmp.
+	* main.c (define_command, document_command):
+	Accept a from_tty argument instead of calling input_from_terminal_p.
+
+	* printcmd.c (address_info): Print info on class and address
+	of a specified symbol.  For register symbols, gives name of register.
+
+	* printcmd.c (print_command): Remember explicitly whether
+	`make_cleanup' was called.
+
+	* printcmd.c (print_frame_args): Know how arg-addresses vary with
+	data type on big-endian machines.
+
+	* source.c (directory_command): Detect `:' in arg and reject it.
+	Free the old directory-path.  Simplify things like `/.' in
+	dirname.
+
+	* source.c (openp): Simplify `./' in specified name.
+
+	* source.c (find_source_lines): Compare source mtime against
+	`exec_mtime' and warn if source is newer.
+
+	* source.c (line_info): No arg means use last line listed
+	or line following last one this command was used on.
+	If from tty, clear out argument so Return is like `i li' without
+	arg.
+
+	* stack.c (frame_info): Print addresses registers are saved at.
+
+	* stack.c (return_command): When asking for confirmation, give
+	name of function that will be made to return.
+
+	* valops.c (call_function): If function type is
+	pointer-to-function, dereference it to compute return type.
+	If pointer-to-object, assume function returns int.
+	If char, assume that the value's address is the function address
+	(because it's a misc functon).  If int, the value itself is the
+	function address.
+
+	* dbxread.c (compare_symbols): Sort register symbols
+	before all others.
+
+	* eval.c (evaluate_subexp_for_address): New function like
+	`evaluate_subexp' but returns a value for the address where
+	the subexpression's value would be located.
+
+	* eval.c (evaluate_subexp_for_sizeof): New function like
+	`evaluate_subexp' but returns a value for the size of the subexp.
+
+	* eval.c (evaluate_subexp_with_coercion): Like `evaluate_subexp'
+	but coerces arrays to pointers (without taking the time to
+	read the array contents).
+
+	* eval.c (evaluate_subexp): Use the three new functions above
+	when appropriate instead of calling self recursively.
+
+Wed Jan 14 17:00:03 1987  Richard Mlynarik  (mly at prep)
+
+	* core.c (core_file_command):
+	Use correct file in calls to perror_with_name
+
+Mon Jan 12 03:34:35 1987  Richard Mlynarik  (mly at prep)
+
+	* breakpoint.c (map_breakpoint_numbers):
+	Err if no args not supplied, otherwise would get mpv.
+
+	* main.c (main):
+	Command-line arg "-d dir" adds dir to source-file directory
+	search-list.
+
+Sun Jan 11 19:19:52 1987  Richard Mlynarik  (mly at prep)
+
+	* symmisc.c (free_all_symtabs):
+	Don't call free on 0.
+
+	* core.c (exec_file_command):
+	Use correct name in call to perror_with_name.
+	Record absolute pathname.
+	Don't savestring an arg to concat.
+
+	* dbxread.c (symbol_file_command):
+	Record absolute name of pathname opened.
+	Print a message if file doesn't have a symbol-table.
+	Don't savestring an arg to concat.
+
+	* source.c (openp):
+	Add new arg filename_opened, which if non-zero will be set to a
+	malloced string of the absolute name of the actual filename opened.
+
+	* breakpoint.c (clear_command):
+	If from_tty or cleared more than one breakpoint at location,
+	print which bpts were deleted.
+
+	* breakpoint.c (break_command_1, break_command, tbreak_command):
+	If from_tty, mention any other breakpoints set at same location.
+
+	* symtab.c (decode_line_1):
+	If no symtabs, err mentioning `symbol-file' command rather than
+	saying "function foo not defined"
+
+Fri Jan  9 01:25:19 1987 Richard Mlynarik  (mly at prep)
+
+	* main.c (set_prompt_command):
+	Add support command "set-prompt"
+
+	* printcmd.c (undisplay_command):
+	Fix paren error to make "undisplay <number>" work.
+
+Wed Jan  7 12:06:09 1987  Richard Mlynarik  (mly at prep)
+
+	* main.c (print_gdb_version, gdb_version_info):
+	Add command "info version" to report the version
+	of gdb for use in bug reports.
+
+	* infcmd.c:
+	Ensure inferior_args always points to string starting with a space
+	and is never 0.	
+
+	* printcmd.c: (clear_displays, undisplay_command):
+	Fix bug in clear_displays which led to looping.
+	Make undisplay_command call it instead of wrong-looking code which
+	looked at (display->number == 0) instead of (display == 0) to
+	determine if it were at the end of the chain.
+
+Mon Dec 15 20:57:06 1986  Richard M. Stallman  (rms at prep)
+
+	* utils.c (query): Don't ignore a second line if given a null line.
+
+	* infrun.c (normal_stop): Print "bug in shell" message
+	only for a segmentation fault.
+
+	* main.c (main): Read init file from home directory if any,
+	before init file from current directory.
+
+Thu Dec  4 09:05:35 1986  Richard M. Stallman  (rms at prep)
+
+	* source.c (select_source_symtab): Don't ref thru arg if null.
+
+	* m68k.opcode.h: For trap instruction code, use type T.
+	* m68k-pinsn.c (print_insn_arg): Recognize new arg-code T
+	and print the trap vector properly.
+
+	* m-sun[23].h (FRAME_FIND_SAVED_REGS): Recognize a movl REG,-(sp)
+	as a way to save one register.  Recognize clrw -(sp); movw -(sp)
+	after saving regs as a way to save the PS register.  Adjust the
+	way to find the starting pc of a stack dummy frame for the fact
+	that these frames now save the PS.
+
+	* m-sun[23].h (POP_FRAME): Restore PS register if frame saved it.
+
+	* m-sun[23].h (PUSH_DUMMY_FRAME): Push the old PS register.
+
+	* m-sun[23].h (CALL_DUMMY, etc.): Fix erroneous binary code for
+	the addl #nnn,sp instruction.  Insert clrw -(sp); movw -(sp)
+	to indicate that the PS has been saved.
+
+	* infrun.c (wait_for_inferior): If inferior exits, call
+	mark_breakpoints_out so it works to delete breakpoints afterward.
+
+	* infrun.c (normal_stop): After popping a stack dummy frame,
+	select the frame that we get to.
+
+	* dbxread.c (process_one_symbol): Store new `depth' field
+	in all context_stack elements created.  For N_RBRAC, test
+	that depth matches that in the context_stack; if not, error.
+
+	* dbxread.c (all callers of error): Make all error messages
+	start "Invalid symbol data: " and end with value of symnum.
+	Also change a few aborts to errors.
+
+Mon Dec  1 20:20:37 1986  Richard M. Stallman  (rms at prep)
+
+	* version.c: Version 1.11.
+
+	* breakpoint.c (condition_command): If no condition spec'd,
+	print "breakpoint N now unconditional".
+
+	* breakpoint.c (commands_command): Give different error messages
+	for cases of args not containing a breakpoint number
+	and args containing anything after the breakpoint number.
+
+	* commands.c (lookup_command): Don't store a zero in *p
+	if have an undefined subcommand that is not an error.
+
+	* commands.c (lookup_command): For recursive call,
+	pass subcommand list properly.  Was passing the address
+	of the word containing the list.
+
+	* core.c ({core,exec}_file_name): If no arg, tell user
+	what the effect is.
+
+	* dbxread.c (define_symbol): Accept class code 'v'
+	for static variable within a function.
+
+	* dbxread.c (read_type): Now allow any plain number or
+	pair of numbers in parens, with no code letter.  This means
+	define new type same as type with specified number, or define
+	it as void if specified number's type is not yet mentioned.
+
+	* m68k-pinsn.c (print_insn_arg): Case of general operand
+	in byte insn that happened to be immediate used wrong arg-size.
+
+	* printcmd.c (set_next_address): Set next_address from arg
+	and also set value of `$_' from it.
+
+	* printcmd.c (do_examine): Save address in last_examine_address
+	and value fetched to examine in last_examine_value.
+
+	* printcmd.c (x_command): Copy last_examine_{address,value}
+	into values of `$_' and `$__'.  Change `x' documentation string.
+
+	* source.c (directory_command): Query when no args now says
+	what new value it wants use for the path.
+
+	* source.c (list_command): Don't die in cases like `list ,+30'.
+
+	* source.c (line_info): Call `set_next_address' to make `x'
+	display the text of the line.  Change `info list' doc string.
+
+Sat Nov 29 07:59:29 1986  Richard M. Stallman  (rms at prep)
+
+	* printcmd.c (undisplay_command): If get no arg,
+	rather than crashing, query and then delete undisplay everything.
+
+Fri Nov 28 15:43:52 1986  Richard M. Stallman  (rms at prep)
+
+	* dbxread.c (process_one_symbol): If N_LBRAC sym
+	has a greater value that N_RBRAC, ignore the
+	N_LBRAC value and give the block zero length.
+
+Tue Nov 25 03:10:12 1986  Richard M. Stallman  (rms at prep)
+
+	* dbxread.c (process_one_symbol): Ignore N_NSYMS symbols
+	that appear in Ultrix.
+
+Sat Nov 22 22:49:06 1986  Richard M. Stallman  (rms at prep)
+
+	* version.c: version 1.10.
+
+	* valprint.c (type_print*):
+	SHOW < 0 now means abbreviate struct/union members
+	or enum values with `...'.  SHOW now decremented on
+	each recursion in type_print_base.  Several places
+	that used to check !show now check show <= 0.
+
+	* valprint.c (val_print): Pass -1 for SHOW to type_print
+	when printing typename inside parens or braces.
+
+	* printcmd.c (print_command): If no value specified to print,
+	print the value of $.
+
+	* expression.h, expread.y, eval.c, expprint.c:
+	OP_MEMVAL renamed UNOP_MEMVAL
+	and now allows any expression, not just an integer address.
+	It now has same format as UNOP_CAST and works almost like it.
+	Each place that referred to it has been rewritten
+	starting with a copy of the code that handles UNOP_CAST.
+	Doc for `print' command changed for this.
+
+	* source.c (init_source_path):
+	Free and zero out any line_charpos's saved in source symtabs.
+
+	* breakpoint.c (condition_command):
+	Parse the condition in the environment of the code where the
+	breakpoint is set.  This requires finding the breakpoint
+	before parsing, so code is rearranged.
+
+	* dbxread.c (dbx_alloc_type):
+	New function given typenums returns the type for those typenums
+	or allocates a new, empty type for those typenums and returns it.
+
+	* symtab.c (smash_type_to_{pointer,function}):
+	New functions modify an already-allocated type object
+	to be a pointer to or function returning some given type.
+
+	* dbxread.c (read_type): Uses dbx_alloc_type in many cases.
+	Reading a pointer or function type now works by doing that,
+	then reading the value type or type pointed to, then smashing
+	it into the type already allocated.  This makes some fwd refs win.
+	Likewise for structs and unions.
+
+	* dbxread.c (read_struct_type): Now receives the type object
+	as args.  Used to get typenums as args and look up the type
+	itself.
+
+	* dbxread.c (symbol_file_command):
+	At very end, clear out any type name that `char *' has received.
+
+Thu Nov 20 16:43:53 1986  Richard M. Stallman  (rms at prep)
+
+	* m-sun2.h, m-sun3.h (FIND_FRAME_SAVED_REGS):
+	Was incrementing address even for regs not saved.
+
+Sun Nov 16 14:59:07 1986  Richard M. Stallman  (rms at prep)
+
+	* values.c (value_field): Was adding in byte offset
+	before calling unpack_field_as_long, which itself
+	adds in the offset.  Now pass addr of start of structure.
+
+	* infrun.c (normal_stop): Clean up inferior_pid conditionals:
+	just return early if no inferior.
+
+Thu Nov 13 15:45:50 1986  Richard M. Stallman  (rms at prep)
+
+	* dbxread.c (struct header_file): add new field .instance
+	to distinguish the various entries for one header file.
+
+	* dbxread.c (process_one_symbol): Use the `value' of
+	a N_BINCL or N_EXCL as the instance code for the header file.
+
+	* dbxread.c (add_{new,old}_header_file):
+	Accept an instance code as arg and treat it as if it were
+	part of the file name for distinguishing and finding entries.
+
+	* dbxread.c (add_new_header_file, read_type):
+	Turn off the header_file_prev_index feature with #if 0.
+
+	* values.c (unpack_field_as_long, modify_field):
+	Run-time test to distinguish big and little endian machines
+	and do shifting accordingly.
+
+Tue Nov 11 00:31:18 1986  Richard M. Stallman  (rms at prep)
+
+	* version.c: version 1.9.
+
+	* breakpoint.c (delete_command):
+	Don't query if 2nd arg is zero.
+
+	* breakpoint.c (clear_breakpoints):
+	Pass 2nd arg of zero to delete_command.
+
+Sat Nov  8 23:29:19 1986  Richard M. Stallman  (rms at prep)
+
+	* breakpoint.c (delete_command):
+	Ask for confirmation when used with no arg (delete all).
+
+Fri Nov  7 11:23:09 1986  Richard M. Stallman  (rms at prep)
+
+	* infrun.c (start_inferior, wait_for_inferior):
+	Eliminate `stop_in_shell' which was not being maintained right.
+	New variable `running_in_shell' is set to 1 or 0 when the
+	expected SIGTRAPs happen, and is simply examined at other times.
+
+	* infrun.c (wait_for_inferior):
+	If get SIGSEGV with running_in_shell == 1, it is sh
+	allocating memory.  Pass the signal silently to the shell.
+
+	* core.c (exec_file_command):
+	data_{start,end} are adjusted unconditionally when an
+	exec file is opened, so closing counter-adjustment is
+	now unconditional as well.
+
+	* printcmd.c (x_command):
+	Don't erase the expression from the calling args
+	if cllaed noninteractively (used to be clobbering
+	definitions of user-defined commands).
+
+	* source.c (list_command): likewise.
+
+Wed Nov  5 09:41:00 1986  Richard M. Stallman  (rms at prep)
+
+	* Makefile: New variable OBSTACK1 that people can use
+	to make obstack.o a dependency of gdb.
+
+	* breakpoint.c (initialize):
+	Define new aliases "br", "bre" and "brea" for "break".
+
+Sun Nov  2 21:16:06 1986  Richard Mlynarik  (mly at prep)
+
+	* symmisc.c (read_symsegs):
+	Add an extra protection against invalid symbol-file
+
+	* m-vax.h:
+	Set KERNEL_U_ADDR and STACK_END_ADDR non-4.2-specifically
+
+Tue Oct 21 13:34:14 1986  Richard Mlynarik  (mly at prep)
+
+	* breakpoints.c (initialize):
+	Delet reference to non-existent command "tenable" from doc of "enable"
+
+Tue Oct 14 19:58:27 1986  Richard Mlynarik  (mly at prep)
+
+	* printcmd.c (display_command, undisplay_command):
+	* infcmd.c (run_command):
+	Call dont_repeat. 
+
+
+Local Variables:
+mode: indented-text
+eval: (auto-fill-mode 1)
+left-margin: 8
+fill-column: 74
+version-control: never
+End:
diff --git a/gdb/Makefile b/gdb/Makefile
new file mode 100644
index 0000000..c1fd60c
--- /dev/null
+++ b/gdb/Makefile
@@ -0,0 +1,85 @@
+# -I. for "#include <obstack.h>"
+CFLAGS = -g -I. -Dvfork=fork -DDEBUG
+# NOTE!!! -O  may FAIL TO WORK!  See initialize.h for some weird hacks.
+
+# define this to be "obstack.o" if you don't have the obstack library installed
+# you must at the same time define OBSTACK1 as "obstack.o" 
+# so that the dependencies work right.
+OBSTACK = obstack.o alloca.o -lPW
+OBSTACK1 = obstack.o alloca.o
+
+STARTOBS = main.o firstfile.o
+
+OBS = blockframe.o breakpoint.o findvar.o stack.o source.o \
+    values.o eval.o valops.o valarith.o valprint.o printcmd.o \
+    symtab.o symmisc.o coffread.o dbxread.o infcmd.o infrun.o
+
+TSOBS = core.o inflow.o
+
+NTSOBS = standalone.o
+
+ENDOBS = lastfile.o command.o utils.o expread.o expprint.o pinsn.o \
+	environ.o version.o
+
+TSSTART = /lib/crt0.o
+
+NTSSTART = kdb-start.o
+
+gdb : $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) $(OBSTACK1)
+	$(CC) -o gdb $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) -lg $(OBSTACK)
+
+xgdb : $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) $(OBSTACK1)
+	$(CC) -o xgdb $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) \
+           -lXtk11 -lXrm -lX11 -lg $(OBSTACK)
+
+kdb : $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) $(OBSTACK1)
+	ld -o kdb $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) -lc -lg $(OBSTACK)
+
+clean:
+	rm -f $(STARTOBS) $(OBS) $(TSOBS) $(OBSTACK1) $(NTSSTART) $(NTSOBS)
+	rm -f xgdb.o gdb xgdb kdb tags errs expread.tab.c
+
+blockframe.o : blockframe.c defs.h initialize.h param.h symtab.h frame.h
+breakpoint.o : breakpoint.c defs.h initialize.h param.h symtab.h frame.h
+command.o : command.c command.h
+coffread.o : coffread.c defs.h initialize.h param.h symtab.h
+core.o : core.c defs.h initialize.h param.h
+dbxread.o : dbxread.c defs.h initialize.h param.h symtab.h
+environ.o : environ.c environ.h
+expprint.o : expprint.c defs.h symtab.h expression.h
+expread.tab.c : expread.y
+	@echo 'Expect 96 shift/reduce conflicts.'
+	yacc expread.y
+	mv y.tab.c expread.tab.c
+expread.o : expread.tab.c defs.h param.h symtab.h frame.h expression.h
+	$(CC) -c ${CFLAGS} expread.tab.c
+	mv expread.tab.o expread.o
+eval.o : eval.c defs.h initialize.h symtab.h value.h expression.h
+findvar.o : findvar.c defs.h initialize.h param.h symtab.h frame.h value.h
+firstfile.o : firstfile.c initialize.h
+infcmd.o : infcmd.c defs.h initialize.h param.h symtab.h frame.h inferior.h environ.h value.h
+inflow.o : inflow.c defs.h initialize.h param.h frame.h inferior.h
+infrun.o : infrun.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
+kdb-start.o : kdb-start.c defs.h param.h
+lastfile.o : lastfile.c
+main.o : main.c defs.h command.h
+# pinsn.o depends on ALL the opcode printers
+# since we don't know which one is really being used.
+pinsn.o : pinsn.c defs.h param.h symtab.h \
+    vax-opcode.h vax-pinsn.c m68k-opcode.h m68k-pinsn.c
+printcmd.o : printcmd.c defs.h initialize.h param.h symtab.h value.h expression.h
+source.o : source.c defs.h initialize.h symtab.h
+stack.o : stack.c defs.h initialize.h param.h symtab.h frame.h
+standalone.o : standalone.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
+symmisc.o : symmisc.c defs.h initialize.h symtab.h
+symtab.o : symtab.c defs.h initialize.h param.h symtab.h
+utils.o : utils.c defs.h
+valarith.o : valarith.c defs.h initialize.h param.h symtab.h value.h expression.h
+valops.o : valops.c defs.h initialize.h param.h symtab.h value.h
+valprint.o : valprint.c defs.h initialize.h symtab.h value.h
+values.o : values.c defs.h initialize.h param.h symtab.h value.h
+version.o : version.c
+xgdb.o : xgdb.c defs.h initialize.h param.h symtab.h frame.h
+	$(CC) -c $(CFLAGS) xgdb.c -o $@
+
+obstack.o : obstack.c
diff --git a/gdb/RCS/Makefile,v b/gdb/RCS/Makefile,v
new file mode 100644
index 0000000..d942be0
--- /dev/null
+++ b/gdb/RCS/Makefile,v
@@ -0,0 +1,160 @@
+head     1.4;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @# @;
+
+
+1.4
+date     88.06.08.23.14.28;  author gnu;  state Exp;
+branches ;
+next     1.3;
+
+1.3
+date     88.02.28.03.38.17;  author gnu;  state Exp;
+branches ;
+next     1.2;
+
+1.2
+date     88.01.26.05.14.43;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.05.14.07;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS's wheaties devl dirs
+@
+
+
+1.4
+log
+@Add -DEBUG
+@
+text
+@# -I. for "#include <obstack.h>"
+CFLAGS = -g -I. -Dvfork=fork -DDEBUG
+# NOTE!!! -O  may FAIL TO WORK!  See initialize.h for some weird hacks.
+
+# define this to be "obstack.o" if you don't have the obstack library installed
+# you must at the same time define OBSTACK1 as "obstack.o" 
+# so that the dependencies work right.
+OBSTACK = obstack.o alloca.o -lPW
+OBSTACK1 = obstack.o alloca.o
+
+STARTOBS = main.o firstfile.o
+
+OBS = blockframe.o breakpoint.o findvar.o stack.o source.o \
+    values.o eval.o valops.o valarith.o valprint.o printcmd.o \
+    symtab.o symmisc.o coffread.o dbxread.o infcmd.o infrun.o
+
+TSOBS = core.o inflow.o
+
+NTSOBS = standalone.o
+
+ENDOBS = lastfile.o command.o utils.o expread.o expprint.o pinsn.o \
+	environ.o version.o
+
+TSSTART = /lib/crt0.o
+
+NTSSTART = kdb-start.o
+
+gdb : $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) $(OBSTACK1)
+	$(CC) -o gdb $(STARTOBS) $(OBS) $(TSOBS) $(ENDOBS) -lg $(OBSTACK)
+
+xgdb : $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) $(OBSTACK1)
+	$(CC) -o xgdb $(STARTOBS) $(OBS) xgdb.o $(TSOBS) $(ENDOBS) \
+           -lXtk11 -lXrm -lX11 -lg $(OBSTACK)
+
+kdb : $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) $(OBSTACK1)
+	ld -o kdb $(NTSSTART) $(STARTOBS) $(OBS) $(NTSOBS) $(ENDOBS) -lc -lg $(OBSTACK)
+
+clean:
+	rm -f $(STARTOBS) $(OBS) $(TSOBS) $(OBSTACK1) $(NTSSTART) $(NTSOBS)
+	rm -f xgdb.o gdb xgdb kdb tags errs expread.tab.c
+
+blockframe.o : blockframe.c defs.h initialize.h param.h symtab.h frame.h
+breakpoint.o : breakpoint.c defs.h initialize.h param.h symtab.h frame.h
+command.o : command.c command.h
+coffread.o : coffread.c defs.h initialize.h param.h symtab.h
+core.o : core.c defs.h initialize.h param.h
+dbxread.o : dbxread.c defs.h initialize.h param.h symtab.h
+environ.o : environ.c environ.h
+expprint.o : expprint.c defs.h symtab.h expression.h
+expread.tab.c : expread.y
+	@@echo 'Expect 96 shift/reduce conflicts.'
+	yacc expread.y
+	mv y.tab.c expread.tab.c
+expread.o : expread.tab.c defs.h param.h symtab.h frame.h expression.h
+	$(CC) -c ${CFLAGS} expread.tab.c
+	mv expread.tab.o expread.o
+eval.o : eval.c defs.h initialize.h symtab.h value.h expression.h
+findvar.o : findvar.c defs.h initialize.h param.h symtab.h frame.h value.h
+firstfile.o : firstfile.c initialize.h
+infcmd.o : infcmd.c defs.h initialize.h param.h symtab.h frame.h inferior.h environ.h value.h
+inflow.o : inflow.c defs.h initialize.h param.h frame.h inferior.h
+infrun.o : infrun.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
+kdb-start.o : kdb-start.c defs.h param.h
+lastfile.o : lastfile.c
+main.o : main.c defs.h command.h
+# pinsn.o depends on ALL the opcode printers
+# since we don't know which one is really being used.
+pinsn.o : pinsn.c defs.h param.h symtab.h \
+    vax-opcode.h vax-pinsn.c m68k-opcode.h m68k-pinsn.c
+printcmd.o : printcmd.c defs.h initialize.h param.h symtab.h value.h expression.h
+source.o : source.c defs.h initialize.h symtab.h
+stack.o : stack.c defs.h initialize.h param.h symtab.h frame.h
+standalone.o : standalone.c defs.h initialize.h param.h symtab.h frame.h inferior.h wait.h
+symmisc.o : symmisc.c defs.h initialize.h symtab.h
+symtab.o : symtab.c defs.h initialize.h param.h symtab.h
+utils.o : utils.c defs.h
+valarith.o : valarith.c defs.h initialize.h param.h symtab.h value.h expression.h
+valops.o : valops.c defs.h initialize.h param.h symtab.h value.h
+valprint.o : valprint.c defs.h initialize.h symtab.h value.h
+values.o : values.c defs.h initialize.h param.h symtab.h value.h
+version.o : version.c
+xgdb.o : xgdb.c defs.h initialize.h param.h symtab.h frame.h
+	$(CC) -c $(CFLAGS) xgdb.c -o $@@
+
+obstack.o : obstack.c
+@
+
+
+1.3
+log
+@Make clean
+@
+text
+@d2 1
+a2 1
+CFLAGS = -g -I. -Dvfork=fork
+@
+
+
+1.2
+log
+@We don't have vfork or alloca, and regexp routines are in libPW.a for
+no good reason.
+@
+text
+@d38 4
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d2 1
+a2 1
+CFLAGS = -g -I.
+d8 2
+a9 2
+OBSTACK = obstack.o
+OBSTACK1 = obstack.o
+@
diff --git a/gdb/RCS/coffread.c,v b/gdb/RCS/coffread.c,v
new file mode 100644
index 0000000..7542030
--- /dev/null
+++ b/gdb/RCS/coffread.c,v
@@ -0,0 +1,304 @@
+head     1.4;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.4
+date     88.06.08.23.13.40;  author gnu;  state Exp;
+branches ;
+next     1.3;
+
+1.3
+date     88.02.28.03.37.53;  author gnu;  state Exp;
+branches ;
+next     1.2;
+
+1.2
+date     88.01.26.05.02.32;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.00.38.04;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS's work dirs on Wheaties
+@
+
+
+1.4
+log
+@Half reasonable reading of coff files.  Problem was that it assumed
+that a .text would show up sometime, and it never did.  We have to close
+out each source file's symtab as we hit the next one.
+@
+text
+@/* Read coff symbol tables and convert to internal format, for GDB.
+   Design and support routines derived from dbxread.c, and UMAX COFF
+   specific routines written 9/1/87 by David D. Johnson, Brown University.
+   Revised 11/27/87 ddj@@cs.brown.edu
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "param.h"
+#ifdef COFF_FORMAT
+#include "initialize.h"
+#include "symtab.h"
+
+#include <a.out.h>
+#include <stdio.h>
+#include <obstack.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/file.h>
+
+static void add_symbol_to_list ();
+static void read_coff_symtab ();
+static void patch_opaque_types ();
+static struct type *decode_function_type ();
+static struct type *decode_type ();
+static struct type *decode_base_type ();
+static struct type *read_enum_type ();
+static struct type *read_struct_type ();
+static void finish_block ();
+static struct blockvector *make_blockvector ();
+static struct symbol *process_coff_symbol ();
+static int init_stringtab ();
+static void free_stringtab ();
+static char *getfilename ();
+static char *getsymname ();
+static int init_lineno ();
+static void enter_linenos ();
+
+START_FILE
+
+/* Name of source file whose symbol data we are now processing.
+   This comes from a symbol named ".file".  */
+
+static char *last_source_file;
+
+/* Core address of start and end of text of current source file.
+   This comes from a ".text" symbol where x_nlinno > 0.  */
+
+static CORE_ADDR cur_src_start_addr;
+static CORE_ADDR cur_src_end_addr;
+
+/* End of the text segment of the executable file,
+   as found in the symbol _etext.  */
+
+static CORE_ADDR end_of_text_addr;
+
+/* The addresses of the symbol table stream and number of symbols
+   of the object file we are reading (as copied into core).  */
+
+static FILE *nlist_stream_global;
+static int nlist_nsyms_global;
+
+/* The file and text section headers of the symbol file */
+
+static FILHDR file_hdr;
+static SCNHDR text_hdr;
+
+/* The index in the symbol table of the last coff symbol that was processed.  */
+
+static int symnum;
+
+/* Vector of types defined so far, indexed by their coff symnum.  */
+
+static struct typevector *type_vector;
+
+/* Number of elements allocated for type_vector currently.  */
+
+static int type_vector_length;
+
+/* Vector of line number information.  */
+
+static struct linetable *line_vector;
+
+/* Index of next entry to go in line_vector_index.  */
+
+static int line_vector_index;
+
+/* Last line number recorded in the line vector.  */
+
+static int prev_line_number;
+
+/* Number of elements allocated for line_vector currently.  */
+
+static int line_vector_length;
+
+/* Chain of typedefs of pointers to empty struct/union types.
+   They are chained thru the SYMBOL_VALUE.  */
+
+#define HASHSIZE 127
+static struct symbol *opaque_type_chain[HASHSIZE];
+
+/* Record the symbols defined for each context in a list.
+   We don't create a struct block for the context until we
+   know how long to make it.  */
+
+struct pending
+{
+  struct pending *next;
+  struct symbol *symbol;
+};
+
+/* Here are the three lists that symbols are put on.  */
+
+struct pending *file_symbols;	/* static at top level, and types */
+
+struct pending *global_symbols;	/* global functions and variables */
+
+struct pending *local_symbols;	/* everything local to lexical context */
+
+/* List of unclosed lexical contexts
+   (that will become blocks, eventually).  */
+
+struct context_stack
+{
+  struct context_stack *next;
+  struct pending *locals;
+  struct pending_block *old_blocks;
+  struct symbol *name;
+  CORE_ADDR start_addr;
+  int depth;
+};
+
+struct context_stack *context_stack;
+
+/* Nonzero if within a function (so symbols should be local,
+   if nothing says specifically).  */
+
+int within_function;
+
+/* List of blocks already made (lexical contexts already closed).
+   This is used at the end to make the blockvector.  */
+
+struct pending_block
+{
+  struct pending_block *next;
+  struct block *block;
+};
+
+struct pending_block *pending_blocks;
+
+extern CORE_ADDR first_object_file_end;	/* From blockframe.c */
+
+/* File name symbols were loaded from.  */
+
+static char *symfile;
+
+int debug = 1;
+
+
+/* Look up a coff type-number index.  Return the address of the slot
+   where the type for that index is stored.
+   The type-number is in INDEX. 
+
+   This can be used for finding the type associated with that index
+   or for associating a new type with the index.  */
+
+static struct type **
+coff_lookup_type (index)
+     register int index;
+{
+  if (index >= type_vector_length)
+    {
+      type_vector_length *= 2;
+      type_vector = (struct typevector *)
+	xrealloc (type_vector, sizeof (struct typevector)
+				+ type_vector_length * sizeof (struct type *));
+      bzero (&type_vector->type[type_vector_length / 2],
+	     type_vector_length * sizeof (struct type *) / 2);
+    }
+  return &type_vector->type[index];
+}
+
+/* Make sure there is a type allocated for type number index
+   and return the type object.
+   This can create an empty (zeroed) type object.  */
+
+static struct type *
+coff_alloc_type (index)
+     int index;
+{
+  register struct type **type_addr = coff_lookup_type (index);
+  register struct type *type = *type_addr;
+
+  /* If we are referring to a type not known at all yet,
+     allocate an empty type for it.
+     We will fill it in later if we find out how.  */
+  if (type == 0)
+    {
+      type = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+      bzero (type, sizeof (struct type));
+      *type_addr = type;
+    }
+  return type;
+}
+
+/* maintain the lists of symbols and blocks */
+
+/* Add a symbol to one of the lists of symbols.  */
+static void
+add_symbol_to_list (symbol, listhead)
+     struct symbol *symbol;
+     struct pending **listhead;
+{
+  register struct pending *link
+    = (struct pending *) xmalloc (sizeof (struct pending));
+
+  link->next = *listhead;
+  link->symbol = symbol;
+  *listhead = link;
+}
+
+/* Take one of the lists of symbols and make a block from it.
+   Put the block on the list of pending blocks.  */
+
+static void
+finish_block (symbol, listhead, old_blocks, start, end)
+     struct symbol *symbol;
+     struct pending **listhead;
+     struct pending_block *old_blocks;
+     CORE_ADDR start, end;
+{
+  register struct pending *next, *next1;
+  register struct block *block;
+  register struct pending_block *pblock;
+  struct pending_block *opblock;
+  register int i;
+
+  /* Count the length of the list of symbols.  */
+
+  for (next = *listhead, i = 0; next; next = next->next, i++);
+
+  block = (struct block *) xmalloc (sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
+
+  /* Copy the symbols into the block.  */
+
+  BLOCK_NSYMS (block) = i;
+  for (next = *listhead; next; next = next->next
\ No newline at end of file
diff --git a/gdb/RCS/core.c,v b/gdb/RCS/core.c,v
new file mode 100644
index 0000000..99547f8
--- /dev/null
+++ b/gdb/RCS/core.c,v
@@ -0,0 +1,763 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.04.52;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.05.04.03;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@From RMS's development version on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Hacks to get it to compile on a/ux.  Needs work at finding the registers
+in a core file.
+@
+text
+@/* Work with core dump and executable files, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "initialize.h"
+#include "defs.h"
+#include "param.h"
+
+#include <a.out.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/dir.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+
+/* Recognize COFF format systems because a.out.h defines AOUTHDR.  */
+#ifdef AOUTHDR
+#define COFF_FORMAT
+#endif
+
+#ifdef NEW_SUN_CORE
+#include <sys/core.h>
+#else /* not NEW_SUN_CORE */
+#ifdef UMAX_CORE
+#include <sys/ptrace.h>
+#else /* not UMAX_CORE */
+#ifdef mac_aux
+#include <sys/seg.h>
+#include <sys/mmu.h>
+#include <sys/signal.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#else
+#include <sys/user.h>
+#endif /* mac_aux */
+#endif /* UMAX_CORE */
+#endif /* NEW_SUN_CORE */
+
+#ifndef N_TXTADDR
+#define N_TXTADDR(hdr) 0
+#endif /* no N_TXTADDR */
+
+#ifndef N_DATADDR
+#define N_DATADDR(hdr) hdr.a_text
+#endif /* no N_DATADDR */
+
+/* Make COFF and non-COFF names for things a little more compatible
+   to reduce conditionals later.  */
+
+#ifdef COFF_FORMAT
+#define a_magic magic
+#endif
+
+#ifndef COFF_FORMAT
+#define AOUTHDR struct exec
+#endif
+
+START_FILE
+
+/* Hook for `exec_file_command' command to call.  */
+
+void (*exec_file_display_hook) ();
+   
+/* File names of core file and executable file.  */
+
+static char *corefile;
+static char *execfile;
+
+/* Descriptors on which core file and executable file are open.
+   Note that the execchan is closed when an inferior is created
+   and reopened if the inferior dies or is killed.  */
+
+static int corechan;
+static int execchan;
+
+/* Last modification time of executable file.
+   Also used in source.c to compare against mtime of a source file.  */
+
+int exec_mtime;
+
+/* Virtual addresses of bounds of the two areas of memory in the core file.  */
+
+static CORE_ADDR data_start;
+static CORE_ADDR data_end;
+static CORE_ADDR stack_start;
+static CORE_ADDR stack_end;
+
+/* Virtual addresses of bounds of two areas of memory in the exec file.
+   Note that the data area in the exec file is used only when there is no core file.  */
+
+static CORE_ADDR text_start;
+static CORE_ADDR text_end;
+static CORE_ADDR exec_data_start;
+static CORE_ADDR exec_data_end;
+
+/* Address in executable file of start of text area data.  */
+
+static int text_offset;
+
+/* Address in executable file of start of data area data.  */
+
+static int exec_data_offset;
+
+/* Address in core file of start of data area data.  */
+
+static int data_offset;
+
+/* Address in core file of start of stack area data.  */
+
+static int stack_offset;
+  
+#ifdef COFF_FORMAT
+/* various coff data structures */
+
+static FILHDR file_hdr;
+static SCNHDR text_hdr;
+static SCNHDR data_hdr;
+
+#endif /* not COFF_FORMAT */
+
+/* a.out header saved in core file.  */
+  
+static AOUTHDR core_aouthdr;
+
+/* a.out header of exec file.  */
+
+static AOUTHDR exec_aouthdr;
+
+static void validate_files ();
+unsigned int register_addr ();
+
+core_file_command (filename, from_tty)
+     char *filename;
+     int from_tty;
+{
+  int val;
+  extern char registers[];
+
+  /* Discard all vestiges of any previous core file
+     and mark data and stack spaces as empty.  */
+
+  if (corefile)
+    free (corefile);
+  corefile = 0;
+
+  if (corechan >= 0)
+    close (corechan);
+  corechan = -1;
+
+  data_start = 0;
+  data_end = 0;
+  stack_start = STACK_END_ADDR;
+  stack_end = STACK_END_ADDR;
+
+  /* Now, if a new core file was specified, open it and digest it.  */
+
+  if (filename)
+    {
+      if (have_inferior_p ())
+	error ("To look at a core file, you must kill the inferior with \"kill\".");
+      corechan = open (filename, O_RDONLY, 0);
+      if (corechan < 0)
+	perror_with_name (filename);
+#ifdef NEW_SUN_CORE
+      {
+	struct core corestr;
+
+	val = myread (corechan, &corestr, sizeof corestr);
+	if (val < 0)
+	  perror_with_name (filename);
+	if (corestr.c_magic != CORE_MAGIC)
+	  error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)",
+		 filename, corestr.c_magic, (int) CORE_MAGIC);
+	else if (sizeof (struct core) != corestr.c_len)
+	  error ("\"%s\" has an invalid struct core length (%d, expected %d)",
+		 filename, corestr.c_len, (int) sizeof (struct core));
+
+	data_start = exec_data_start;
+	data_end = data_start + corestr.c_dsize;
+	stack_start = stack_end - corestr.c_ssize;
+	data_offset = sizeof corestr;
+	stack_offset = sizeof corestr + corestr.c_dsize;
+
+	bcopy (&corestr.c_regs, registers, 16 * 4);
+	*(int *)&registers[REGISTER_BYTE (PS_REGNUM)] = corestr.c_regs.r_ps;
+	*(int *)&registers[REGISTER_BYTE (PC_REGNUM)] = corestr.c_regs.r_pc;
+	bcopy (corestr.c_fpstatus.fps_regs,
+	       &registers[REGISTER_BYTE (FP0_REGNUM)],
+	       sizeof corestr.c_fpstatus.fps_regs);
+	bcopy (&corestr.c_fpstatus.fps_control,
+	       &registers[REGISTER_BYTE (FPC_REGNUM)],
+	       sizeof corestr.c_fpstatus - sizeof corestr.c_fpstatus.fps_regs);
+
+	bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
+
+	printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
+      }
+#else /* not NEW_SUN_CORE */
+      /* 4.2-style (and perhaps also sysV-style) core dump file.  */
+      {
+#ifdef UMAX_CORE
+	struct ptrace_user u;
+#else
+	struct user u;
+#endif
+	int reg_offset;
+
+	val = myread (corechan, &u, sizeof u);
+	if (val < 0)
+	  perror_with_name (filename);
+	data_start = exec_data_start;
+
+#ifdef UMAX_CORE
+	data_end = data_start + u.pt_dsize;
+	stack_start = stack_end - u.pt_ssize;
+	data_offset = sizeof u;
+	stack_offset = data_offset + u.pt_dsize;
+	reg_offset = 0;
+
+	bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR));
+
+#else /* not UMAX_CORE */
+#ifdef mac_aux
+	/* This may well not work for 0407 (nonshared text) a.out's */
+	data_end = data_start + u.u_dsize << PAGESHIFT;
+	stack_start = stack_end - u.u_ssize << PAGESHIFT;
+	data_offset = USIZE;
+	stack_offset = USIZE + u.u_dsize << PAGESHIFT;
+	reg_offset = (int) &u.u_ar0[0] - (int) &u;
+
+	core_aouthdr.a_magic = u.u_exdata.ux_mag;
+#else
+	data_end = data_start + NBPG * u.u_dsize;
+	stack_start = stack_end - NBPG * u.u_ssize;
+	data_offset = NBPG * UPAGES;
+	stack_offset = NBPG * (UPAGES + u.u_dsize);
+	reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR;
+
+	/* I don't know where to find this info.
+	   So, for now, mark it as not available.  */
+	core_aouthdr.a_magic = 0;
+#endif /* not mac_aux */
+#endif /* not UMAX_CORE */
+
+	/* Read the register values out of the core file and store
+	   them where `read_register' will find them.  */
+
+	{
+	  register int regno;
+
+	  for (regno = 0; regno < NUM_REGS; regno++)
+	    {
+	      char buf[MAX_REGISTER_RAW_SIZE];
+
+	      val = lseek (corechan, register_addr (regno, reg_offset), 0);
+	      if (val < 0)
+		perror_with_name (filename);
+
+ 	      val = myread (corechan, buf, sizeof buf);
+	      if (val < 0)
+		perror_with_name (filename);
+	      supply_register (regno, buf);
+	    }
+	}
+      }
+#endif /* not NEW_SUN_CORE */
+      if (filename[0] == '/')
+	corefile = savestring (filename, strlen (filename));
+      else
+	{
+	  char dirname[MAXPATHLEN];
+
+	  getwd (dirname);
+	  corefile = concat (dirname, "/", filename);
+	}
+
+      set_current_frame (read_register (FP_REGNUM));
+      select_frame (get_current_frame (), 0);
+      validate_files ();
+    }
+  else if (from_tty)
+    printf ("No core file now.\n");
+}
+
+exec_file_command (filename, from_tty)
+     char *filename;
+     int from_tty;
+{
+  int val;
+
+  /* Eliminate all traces of old exec file.
+     Mark text segment as empty.  */
+
+  if (execfile)
+    free (execfile);
+  execfile = 0;
+  data_start = 0;
+  data_end -= exec_data_start;
+  text_start = 0;
+  text_end = 0;
+  exec_data_start = 0;
+  exec_data_end = 0;
+  if (execchan >= 0)
+    close (execchan);
+  execchan = -1;
+
+  /* Now open and digest the file the user requested, if any.  */
+
+  if (filename)
+    {
+      execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
+			&execfile);
+      if (execchan < 0)
+	perror_with_name (filename);
+
+#ifdef COFF_FORMAT
+      {
+	int aout_hdrsize;
+	int num_sections;
+
+	if (read_file_hdr (execchan, &file_hdr) < 0)
+	  error ("\"%s\": not in executable format.", execfile);
+
+	aout_hdrsize = file_hdr.f_opthdr;
+	num_sections = file_hdr.f_nscns;
+
+	if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
+	  error ("\"%s\": can't read optional aouthdr", execfile);
+
+	if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections) < 0)
+	  error ("\"%s\": can't read text section header", execfile);
+
+	if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections) < 0)
+	  error ("\"%s\": can't read data section header", execfile);
+
+	text_start = exec_aouthdr.text_start;
+	text_end = text_start + exec_aouthdr.tsize;
+	text_offset = text_hdr.s_scnptr;
+	exec_data_start = exec_aouthdr.data_start;
+	exec_data_end = exec_data_start + exec_aouthdr.dsize;
+	exec_data_offset = data_hdr.s_scnptr;
+	data_start = exec_data_start;
+	data_end += exec_data_start;
+	exec_mtime = file_hdr.f_timdat;
+      }
+#else /* not COFF_FORMAT */
+      {
+	struct stat st_exec;
+
+	val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR));
+
+	if (val < 0)
+	  perror_with_name (filename);
+
+	text_start = N_TXTADDR (exec_aouthdr);
+	text_end = text_start + exec_aouthdr.a_text;
+	text_offset = N_TXTOFF (exec_aouthdr);
+	exec_data_start = N_DATADDR (exec_aouthdr);
+	exec_data_end = exec_data_start + exec_aouthdr.a_data;
+	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
+	data_start = exec_data_start;
+	data_end += exec_data_start;
+
+	fstat (execchan, &st_exec);
+	exec_mtime = st_exec.st_mtime;
+      }
+#endif /* not COFF_FORMAT */
+
+      validate_files ();
+    }
+  else if (from_tty)
+    printf ("No exec file now.\n");
+
+  /* Tell display code (if any) about the changed file name.  */
+  if (exec_file_display_hook)
+    (*exec_file_display_hook)
+      (filename ? filename : "No executable specified.\n");
+}
+
+/* Call this to specify the hook for exec_file_command to call back.
+   This is called from the x-window display code.  */
+
+specify_exec_file_hook (hook)
+     void (*hook) ();
+{
+  exec_file_display_hook = hook;
+}
+
+/* The exec file must be closed before running an inferior.
+   If it is needed again after the inferior dies, it must
+   be reopened.  */
+
+close_exec_file ()
+{
+  if (execchan >= 0)
+    close (execchan);
+  execchan = -1;
+}
+
+reopen_exec_file ()
+{
+  if (execchan < 0 && execfile != 0)
+    {
+      char *filename = concat (execfile, "", "");
+      exec_file_command (filename, 0);
+      free (filename);
+    }
+}
+
+/* If we have both a core file and an exec file,
+   print a warning if they don't go together.
+   This should really check that the core file came
+   from that exec file, but I don't know how to do it.  */
+
+static void
+validate_files ()
+{
+  if (execfile != 0 && corefile != 0)
+    {
+      struct stat st_core;
+
+      fstat (corechan, &st_core);
+
+      if (core_aouthdr.a_magic != 0
+	  && bcmp (&core_aouthdr, &exec_aouthdr, sizeof core_aouthdr))
+	printf ("Warning: core file does not match specified executable file.\n");
+      else if (exec_mtime > st_core.st_mtime)
+	printf ("Warning: exec file is newer than core file.\n");
+    }
+}
+
+char *
+get_exec_file ()
+{
+  if (execfile == 0)
+    error ("No executable file specified.\n\
+Use the \"exec-file\" and \"symbol-file\" commands.");
+  return execfile;
+}
+
+int
+have_core_file_p ()
+{
+  return corefile != 0;
+}
+
+static void
+files_info ()
+{
+  char *symfile;
+  extern char *get_sym_file ();
+
+  if (execfile)
+    printf ("Executable file \"%s\".\n", execfile);
+  else
+    printf ("No executable file\n");
+  if (corefile == 0)
+    printf ("No core dump file\n");
+  else
+    printf ("Core dump file \"%s\".\n", corefile);
+
+  if (have_inferior_p ())
+    printf ("Using the running image of the program, rather than these files.\n");
+
+  symfile = get_sym_file ();
+  if (symfile != 0)
+    printf ("Symbols loaded from \"%s\".\n", symfile);
+
+  if (! have_inferior_p ())
+    {
+      if (execfile)
+	{
+	  printf ("Text segment from 0x%x to 0x%x.\n",
+		  text_start, text_end);
+	}
+      if (corefile)
+	{
+	  printf ("Data segment from 0x%x to 0x%x.\nStack segment from 0x%x to 0x%x.\n",
+		  data_start, data_end, stack_start, stack_end);
+	}
+      else
+	{
+	  printf ("Data segment in executable from 0x%x to 0x%x.\n",
+		  exec_data_start, exec_data_end);
+	}
+    }
+}
+
+/* Read "memory data" from core file and/or executable file */
+
+read_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  if (have_inferior_p ())
+    read_inferior_memory (memaddr, myaddr, len);
+  else
+    xfer_core_file (memaddr, myaddr, len, 0);
+}
+
+/* Write LEN bytes of data starting at address MYADDR
+   into debugged program memory at address MEMADDR.
+   Returns zero if successful, or an errno value if ptrace failed.  */
+
+int
+write_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  if (have_inferior_p ())
+    return write_inferior_memory (memaddr, myaddr, len);
+  else
+    error ("Can write memory only when program being debugged is running.");
+}
+
+xfer_core_file (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  register int val;
+  int xferchan;
+  char **xferfile;
+  int fileptr;
+
+  while (len > 0)
+    {
+      xferfile = 0;
+      xferchan = 0;
+
+      /* Determine which file the next bunch of addresses reside in,
+	 and where in the file.  Set the file's read/write pointer
+	 to point at the proper place for the desired address
+	 and set xferfile and xferchan for the correct file.
+	 If desired address is nonexistent, leave them zero.
+	 i is set to the number of bytes that can be handled
+	 along with the next address.  */
+
+      if (memaddr < text_start)
+	{
+	  i = min (len, text_start - memaddr);
+	}
+      else if (memaddr >= text_end && memaddr < data_start)
+	{
+	  i = min (len, data_start - memaddr);
+	}
+      else if (memaddr >= (corechan >= 0 ? data_end : exec_data_end)
+	       && memaddr < stack_start)
+	{
+	  i = min (len, stack_start - memaddr);
+	}
+      else if (memaddr >= stack_end && stack_end != 0)
+	{
+	  i = min (len, - memaddr);
+	}
+      /* Note that if there is no core file
+	 data_start and data_end are equal.  */
+      else if (memaddr >= data_start && memaddr < data_end)
+	{
+	  i = min (len, data_end - memaddr);
+	  fileptr = memaddr - data_start + data_offset;
+	  xferfile = &corefile;
+	  xferchan = corechan;
+	}
+      /* Note that if there is no core file
+	 stack_start and stack_end are equal.  */
+      else if (memaddr >= stack_start && memaddr < stack_end)
+	{
+	  i = min (len, stack_end - memaddr);
+	  fileptr = memaddr - stack_start + stack_offset;
+	  xferfile = &corefile;
+	  xferchan = corechan;
+	}
+      else if (corechan < 0
+	       && memaddr >= exec_data_start && memaddr < exec_data_end)
+	{
+	  i = min (len, exec_data_end - memaddr);
+	  fileptr = memaddr - exec_data_start + exec_data_offset;
+	  xferfile = &execfile;
+	  xferchan = execchan;
+	}
+      else if (memaddr >= text_start && memaddr < text_end)
+	{
+	  i = min (len, text_end - memaddr);
+	  fileptr = memaddr - text_start + text_offset;
+	  xferfile = &execfile;
+	  xferchan = execchan;
+	}
+
+      /* Now we know which file to use.
+	 Set up its pointer and transfer the data.  */
+      if (xferfile)
+	{
+	  if (*xferfile == 0)
+	    if (xferfile == &execfile)
+	      error ("No program file to examine.");
+	    else
+	      error ("No core dump file or running program to examine.");
+	  val = lseek (xferchan, fileptr, 0);
+	  if (val < 0)
+	    perror_with_name (*xferfile);
+	  val = myread (xferchan, myaddr, i);
+	  if (val < 0)
+	    perror_with_name (*xferfile);
+	}
+      /* If this address is for nonexistent memory,
+	 read zeros if reading, or do nothing if writing.  */
+      else
+	bzero (myaddr, i);
+
+      memaddr += i;
+      myaddr += i;
+      len -= i;
+    }
+}
+
+/* My replacement for the read system call.
+   Used like `read' but keeps going if `read' returns too soon.  */
+
+myread (desc, addr, len)
+     int desc;
+     char *addr;
+     int len;
+{
+  register int val;
+  int orglen = len;
+
+  while (len > 0)
+    {
+      val = read (desc, addr, len);
+      if (val < 0)
+	return val;
+      if (val == 0)
+	return orglen - len;
+      len -= val;
+      addr += val;
+    }
+}
+
+#ifndef NEW_SUN_CORE
+
+/* Return the address in the core dump or inferior of register REGNO.
+   BLOCKEND is the address of the end of the user structure.  */
+
+unsigned int
+register_addr (regno, blockend)
+     int regno;
+     int blockend;
+{
+  int addr;
+
+  if (regno < 0 || regno >= NUM_REGS)
+    error ("Invalid register number %d.", regno);
+
+#ifdef mac_aux
+/* FIXME, we don't know where the regs are.  Maybe the test command
+ * that tests what parts of the upage are writeable will find 'em for us.
+ */
+#define REGISTER_U_ADDR(addr, foo, bar)  addr = 0;
+#endif
+  REGISTER_U_ADDR (addr, blockend, regno);
+
+  return addr;
+}
+
+#endif /* not NEW_SUN_CORE */
+
+static
+initialize ()
+{
+  corechan = -1;
+  execchan = -1;
+  corefile = 0;
+  execfile = 0;
+  exec_file_display_hook = 0;
+
+  text_start = 0;
+  text_end = 0;
+  data_start = 0;
+  data_end = 0;
+  exec_data_start = 0;
+  exec_data_end = 0;
+  stack_start = STACK_END_ADDR;
+  stack_end = STACK_END_ADDR;
+
+  add_com ("core-file", class_files, core_file_command,
+	   "Use FILE as core dump for examining memory and registers.\n\
+No arg means have no core file.");
+  add_com ("exec-file", class_files, exec_file_command,
+	   "Use FILE as program for getting contents of pure memory.\n\
+If FILE cannot be found as specified, your execution directory path\n\
+is searched for a command of that name.\n\
+No arg means have no executable file.");
+  add_info ("files", files_info, "Names of files being debugged.");
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d27 1
+d44 5
+d50 4
+a53 1
+#endif
+d240 10
+d259 1
+d675 6
+@
diff --git a/gdb/RCS/infcmd.c,v b/gdb/RCS/infcmd.c,v
new file mode 100644
index 0000000..cc30fe4
--- /dev/null
+++ b/gdb/RCS/infcmd.c,v
@@ -0,0 +1,966 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.06.19;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.01.19.05;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS's wheaties devl sources
+@
+
+
+1.2
+log
+@Add local sys_siglist for a/ux because they don't provide one, sigh.
+@
+text
+@/* Memory-access and commands for inferior process, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "param.h"
+#include "frame.h"
+#include "inferior.h"
+#include "environ.h"
+#include "value.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <sys/param.h>
+
+#ifdef mac_aux
+/* Warning!  This table is positional and highly dependent on the local
+   system.  Check it closely against <sys/signal.h> when porting. */
+char *sys_siglist[] = {
+	"Signal 0",
+	"Hangup",
+	"Interrupt",
+	"Quit",
+	"Invalid instruction",
+	"Trace/breakpoint trap",
+	"IOT trap",
+	"EMT trap",
+	"Floating point exception",
+	"Killed",
+	"Bus error",
+	"Segmentation fault",
+	"Bad system call",
+	"Broken pipe",
+	"Alarm clock",
+	"Terminated",
+	"User signal 1",
+	"User signal 2",
+	"Child exited",
+	"Power-fail restart",
+	"Stopped",
+	"Stopped (tty input)",
+	"Stopped (tty output)",
+	"Stopped (signal)",
+	"Cputime limit exceeded",
+	"File size limit exceeded",
+	"Virtual timer expired",
+	"Profiling timer expired",
+	"Window changed",
+	"Continued",
+	"Urgent I/O condition",
+	"I/O possible",
+};
+#else
+/* More portable systems do it for you */
+extern char *sys_siglist[];
+#endif
+
+#define ERROR_NO_INFERIOR \
+   if (inferior_pid == 0) error ("The program is not being run.");
+
+/* String containing arguments to give to the program,
+   with a space added at the front.  Just a space means no args.  */
+
+static char *inferior_args;
+
+/* File name for default use for standard in/out in the inferior.  */
+
+char *inferior_io_terminal;
+
+/* Pid of our debugged inferior, or 0 if no inferior now.  */
+
+int inferior_pid;
+
+/* Last signal that the inferior received (why it stopped).  */
+
+int stop_signal;
+
+/* Address at which inferior stopped.  */
+
+CORE_ADDR stop_pc;
+
+/* Stack frame when program stopped.  */
+
+FRAME stop_frame;
+
+/* Number of breakpoint it stopped at, or 0 if none.  */
+
+int stop_breakpoint;
+
+/* Nonzero if stopped due to a step command.  */
+
+int stop_step;
+
+/* Nonzero if stopped due to completion of a stack dummy routine.  */
+
+int stop_stack_dummy;
+
+/* Range to single step within.
+   If this is nonzero, respond to a single-step signal
+   by continuing to step if the pc is in this range.  */
+
+CORE_ADDR step_range_start; /* Inclusive */
+CORE_ADDR step_range_end; /* Exclusive */
+
+/* Stack frame address as of when stepping command was issued.
+   This is how we know when we step into a subroutine call,
+   and how to set the frame for the breakpoint used to step out.  */
+
+CORE_ADDR step_frame;
+
+/* 1 means step over all subroutine calls.
+   -1 means step over calls to undebuggable functions.  */
+
+int step_over_calls;
+
+/* If stepping, nonzero means step count is > 1
+   so don't print frame next time inferior stops
+   if it stops due to stepping.  */
+
+int step_multi;
+
+/* Environment to use for running inferior,
+   in format described in environ.h.  */
+
+struct environ *inferior_environ;
+
+CORE_ADDR read_pc ();
+struct command_line *get_breakpoint_commands ();
+
+START_FILE
+
+int
+have_inferior_p ()
+{
+  return inferior_pid != 0;
+}
+
+static void 
+set_args_command (args)
+     char *args;
+{
+  free (inferior_args);
+  if (!args) args = "";
+  inferior_args = concat (" ", args, "");
+}
+  
+void
+tty_command (file)
+     char *file;
+{
+  if (file == 0)
+    error_no_arg ("terminal name for running target process");
+
+  inferior_io_terminal = savestring (file, strlen (file));
+}
+
+static void
+run_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  extern char **environ;
+  register int i;
+  char *exec_file;
+  char *allargs;
+
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+
+  dont_repeat ();
+
+  if (inferior_pid)
+    {
+      if (query ("The program being debugged has been started already.\n\
+Start it from the beginning? "))
+	kill_inferior ();
+      else
+	error ("Program already started.");
+    }
+
+  if (args)
+    set_args_command (args);
+
+  exec_file = (char *) get_exec_file ();
+  if (from_tty)
+    {
+      printf ("Starting program: %s%s\n",
+	      exec_file, inferior_args);
+      fflush (stdout);
+    }
+
+  allargs = concat ("exec ", exec_file, inferior_args);
+  inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
+
+  clear_proceed_status ();
+
+  start_inferior ();
+}
+
+void
+cont_command (proc_count_exp, from_tty)
+     char *proc_count_exp;
+     int from_tty;
+{
+  ERROR_NO_INFERIOR;
+
+  clear_proceed_status ();
+
+  /* If have argument, set proceed count of breakpoint we stopped at.  */
+
+  if (stop_breakpoint && proc_count_exp)
+    {
+      set_ignore_count (stop_breakpoint,
+			parse_and_eval_address (proc_count_exp) - 1,
+			from_tty);
+      if (from_tty)
+	printf ("  ");
+    }
+
+  if (from_tty)
+    printf ("Continuing.\n");
+
+  proceed (-1, -1, 0);
+}
+
+/* Step until outside of current statement.  */
+static void step_1 ();
+
+static void
+step_command (count_string)
+{
+  step_1 (0, 0, count_string);
+}
+
+/* Likewise, but skip over subroutine calls as if single instructions.  */
+
+static void
+next_command (count_string)
+{
+  step_1 (1, 0, count_string);
+}
+
+/* Likewise, but step only one instruction.  */
+
+static void
+stepi_command (count_string)
+{
+  step_1 (0, 1, count_string);
+}
+
+static void
+nexti_command (count_string)
+{
+  step_1 (1, 1, count_string);
+}
+
+static void
+step_1 (skip_subroutines, single_inst, count_string)
+     int skip_subroutines;
+     int single_inst;
+     char *count_string;
+{
+  register int count = 1;
+
+  ERROR_NO_INFERIOR;
+  count = count_string ? parse_and_eval_address (count_string) : 1;
+
+  for (; count > 0; count--)
+    {
+      clear_proceed_status ();
+
+      step_frame = get_current_frame ();
+
+      if (! single_inst)
+	{
+	  find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
+	  if (step_range_end == 0)
+	    {
+	      terminal_ours ();
+	      error ("Current function has no line number information.");
+	    }
+	}
+      else
+	{
+	  /* Say we are stepping, but stop after one insn whatever it does.
+	     Don't step through subroutine calls even to undebuggable functions.  */
+	  step_range_start = step_range_end = 1;
+	  if (!skip_subroutines)
+	    step_over_calls = 0;
+	}
+
+      if (skip_subroutines)
+	step_over_calls = 1;
+
+      step_multi = (count > 1);
+      proceed (-1, -1, 1);
+      if (! stop_step)
+	break;
+    }
+}
+
+/* Continue program at specified address.  */
+
+static void
+jump_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  register CORE_ADDR addr;
+  struct symtab_and_line sal;
+
+  ERROR_NO_INFERIOR;
+
+  if (!arg)
+    error_no_arg ("starting address");
+
+  sal = decode_line_spec (arg, 1);
+
+  if (sal.symtab == 0 && sal.pc == 0)
+    error ("No source file has been specified.");
+
+  if (sal.pc == 0)
+    sal.pc = find_line_pc (sal.symtab, sal.line);
+
+  {
+    struct symbol *fn = get_frame_function (get_current_frame ());
+    struct symbol *sfn = find_pc_function (sal.pc);
+    if (fn != 0 && sfn != fn
+	&& ! query ("That is not in function %s.  Continue there? ",
+		    sal.line, SYMBOL_NAME (fn)))
+      error ("Not confirmed.");
+  }
+
+  if (sal.pc == 0)
+    error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
+
+  addr = sal.pc;
+
+  clear_proceed_status ();
+
+  if (from_tty)
+    printf ("Continuing at 0x%x.\n", addr);
+
+  proceed (addr, 0, 0);
+}
+
+/* Continue program giving it specified signal.  */
+
+static void
+signal_command (signum_exp, from_tty)
+     char *signum_exp;
+     int from_tty;
+{
+  register int signum;
+
+  dont_repeat ();		/* Too dangerous.  */
+  ERROR_NO_INFERIOR;
+
+  if (!signum_exp)
+    error_no_arg ("signal number");
+
+  signum = parse_and_eval_address (signum_exp);
+
+  clear_proceed_status ();
+
+  if (from_tty)
+    printf ("Continuing with signal %d.\n", signum);
+
+  proceed (stop_pc, signum, 0);
+}
+
+/* Execute a "stack dummy", a piece of code stored in the stack
+   by the debugger to be executed in the inferior.
+
+   To call: first, do PUSH_DUMMY_FRAME.
+   Then push the contents of the dummy.  It should end with a breakpoint insn.
+   Then call here, passing address at which to start the dummy.
+
+   The contents of all registers are saved before the dummy frame is popped
+   and copied into the buffer BUFFER.
+
+   The dummy's frame is automatically popped whenever that break is hit.
+   If that is the first time the program stops, run_stack_dummy
+   returns to its caller with that frame already gone.
+   Otherwise, the caller never gets returned to.  */
+
+/* 4 => return instead of letting the stack dummy run.  */
+
+static int stack_dummy_testing = 0;
+
+void
+run_stack_dummy (addr, buffer)
+     CORE_ADDR addr;
+     REGISTER_TYPE *buffer;
+{
+  int saved_pc_changed = pc_changed;
+  int saved_stop_signal = stop_signal;
+  int saved_stop_pc = stop_pc;
+  int saved_stop_frame = stop_frame;
+  int saved_stop_breakpoint = stop_breakpoint;
+  int saved_stop_step = stop_step;
+  int saved_stop_stack_dummy = stop_stack_dummy;
+  FRAME saved_selected_frame;
+  int saved_selected_level;
+  struct command_line *saved_breakpoint_commands
+    = get_breakpoint_commands ();
+
+  record_selected_frame (&saved_selected_frame, &saved_selected_level);
+
+  /* Now proceed, having reached the desired place.  */
+  clear_proceed_status ();
+  if (stack_dummy_testing & 4)
+    {
+      POP_FRAME;
+      return;
+    }
+  proceed (addr, 0, 0);
+
+  if (!stop_stack_dummy)
+    error ("Cannot continue previously requested operation.");
+
+  set_breakpoint_commands (saved_breakpoint_commands);
+  select_frame (saved_selected_frame, saved_selected_level);
+  stop_signal = saved_stop_signal;
+  stop_pc = saved_stop_pc;
+  stop_frame = saved_stop_frame;
+  stop_breakpoint = saved_stop_breakpoint;
+  stop_step = saved_stop_step;
+  stop_stack_dummy = saved_stop_stack_dummy;
+  pc_changed = saved_pc_changed;
+
+  /* On return, the stack dummy has been popped already.  */
+
+  bcopy (stop_registers, buffer, sizeof stop_registers);
+}
+
+/* "finish": Set a temporary breakpoint at the place
+   the selected frame will return to, then continue.  */
+
+static void
+finish_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal;
+  register FRAME frame;
+  struct frame_info fi;
+
+  register struct symbol *function;
+
+  if (!have_inferior_p ())
+    error ("The program is not being run.");
+  if (arg)
+    error ("The \"finish\" command does not take any arguments.");
+
+  frame = get_prev_frame (selected_frame);
+  if (frame == 0)
+    error ("\"finish\" not meaningful in the outermost frame.");
+
+  clear_proceed_status ();
+
+  fi = get_frame_info (frame);
+  sal = find_pc_line (fi.pc, 0);
+  sal.pc = fi.pc;
+  set_momentary_breakpoint (sal, frame);
+
+  /* Find the function we will return from.  */
+
+  fi = get_frame_info (fi.next_frame);
+  function = find_pc_function (fi.pc);
+
+  if (from_tty)
+    {
+      printf ("Run till exit from ");
+      print_selected_frame ();
+    }
+
+  proceed (-1, -1, 0);
+
+  if (stop_breakpoint == -3 && function != 0)
+    {
+      struct type *value_type;
+      register value val;
+
+      if (TYPE_CODE (SYMBOL_TYPE (function)) != TYPE_CODE_VOID)
+	value_type = SYMBOL_TYPE (function);
+      else
+	return;
+
+      val = value_being_returned (value_type, stop_registers);
+      printf ("Value returned is $%d = ", record_latest_value (val));
+      value_print (val, stdout);
+      putchar ('\n');
+    }
+}
+
+static void
+program_info ()
+{
+  if (inferior_pid == 0)
+    {
+      printf ("The program being debugged is not being run.\n");
+      return;
+    }
+
+  printf ("Program being debugged is in process %d, stopped at 0x%x.\n",
+	  inferior_pid, stop_pc);
+  if (stop_step)
+    printf ("It stopped after being stepped.\n");
+  else if (stop_breakpoint)
+    printf ("It stopped at breakpoint %d.\n", stop_breakpoint);
+  else if (stop_signal)
+    printf ("It stopped with signal %d (%s).\n",
+	    stop_signal, sys_siglist[stop_signal]);
+
+  printf ("\nType \"info stack\" or \"info reg\" for more information.\n");
+}
+
+static void
+environment_info (var)
+     char *var;
+{
+  if (var)
+    {
+      register char *val = get_in_environ (inferior_environ, var);
+      if (val)
+	printf ("%s = %s\n", var, val);
+      else
+	printf ("Environment variable \"%s\" not defined.\n", var);
+    }
+  else
+    {
+      register char **vector = environ_vector (inferior_environ);
+      while (*vector)
+	printf ("%s\n", *vector++);
+    }
+}
+
+static void
+set_environment_command (arg)
+     char *arg;
+{
+  register char *p, *val, *var;
+
+  if (arg == 0)
+    error_no_arg ("environment variable and value");
+
+  p = (char *) index (arg, '=');
+  val = (char *) index (arg, ' ');
+  if (p != 0 && val != 0)
+    p = arg + min (p - arg, val - arg);
+  else if (val != 0 && p == 0)
+    p = val;
+
+  if (p == 0)
+    error ("Space or \"=\" must separate variable name and its value");
+  if (p[1] == 0)
+    error_no_arg ("value for the variable");
+  if (p == arg)
+    error_no_arg ("environment variable to set");
+
+  val = p + 1;
+  while (*val == ' ' || *val == '\t') val++;
+  while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) p--;
+
+  var = savestring (arg, p - arg);
+  set_in_environ (inferior_environ, var, val);
+  free (var);
+}
+
+static void
+unset_environment_command (var)
+     char *var;
+{
+  if (var == 0)
+    error_no_arg ("environment variable");
+
+  unset_in_environ (inferior_environ, var);
+}
+
+/* Read an integer from debugged memory, given address and number of bytes.  */
+
+read_memory_integer (memaddr, len)
+     CORE_ADDR memaddr;
+     int len;
+{
+  char cbuf;
+  short sbuf;
+  int ibuf;
+  long lbuf;
+
+  if (len == sizeof (char))
+    {
+      read_memory (memaddr, &cbuf, len);
+      return cbuf;
+    }
+  if (len == sizeof (short))
+    {
+      read_memory (memaddr, &sbuf, len);
+      return sbuf;
+    }
+  if (len == sizeof (int))
+    {
+      read_memory (memaddr, &ibuf, len);
+      return ibuf;
+    }
+  if (len == sizeof (lbuf))
+    {
+      read_memory (memaddr, &lbuf, len);
+      return lbuf;
+    }
+  error ("Cannot handle integers of %d bytes.", len);
+}
+
+CORE_ADDR
+read_pc ()
+{
+  return (CORE_ADDR) read_register (PC_REGNUM);
+}
+
+write_pc (val)
+     CORE_ADDR val;
+{
+  write_register (PC_REGNUM, (long) val);
+}
+
+char *reg_names[] = REGISTER_NAMES;
+
+static void
+registers_info (addr_exp)
+     char *addr_exp;
+{
+  register int i;
+  int regnum;
+
+  if (addr_exp)
+    {
+      if (*addr_exp >= '0' && *addr_exp <= '9')
+	regnum = atoi (addr_exp);
+      else
+	{
+	  register char *p = addr_exp;
+	  if (p[0] == '$')
+	    p++;
+	  for (regnum = 0; regnum < NUM_REGS; regnum++)
+	    if (!strcmp (p, reg_names[regnum]))
+	      break;
+	  if (regnum == NUM_REGS)
+	    error ("%s: invalid register name.", addr_exp);
+	}
+    }
+  else
+    printf ("Reg\tContents\n\n");
+
+  for (i = 0; i < NUM_REGS; i++)
+    {
+      unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
+      unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+      REGISTER_TYPE val;
+
+      if (addr_exp != 0 && i != regnum)
+	continue;
+
+      /* On machines with lots of registers, pause every 16 lines
+	 so user can read the output.  */
+      if (addr_exp == 0 && i > 0 && i % 16 == 0)
+	{
+	  printf ("--Type Return to print more--");
+	  fflush (stdout);
+	  read_line ();
+	}
+
+      /* Get the data in raw format, then convert also to virtual format.  */
+      read_relative_register_raw_bytes (i, raw_buffer);
+      REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
+
+      printf ("%s\t", reg_names[i]);
+
+      /* If virtual format is floating, print it that way.  */
+      if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
+	  && ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
+	val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout);
+      /* Else if virtual format is too long for printf,
+	 print in hex a byte at a time.  */
+      else if (REGISTER_VIRTUAL_SIZE (i) > sizeof (long))
+	{
+	  register int j;
+	  printf ("0x");
+	  for (j = 0; j < REGISTER_VIRTUAL_SIZE (i); j++)
+	    printf ("%02x", virtual_buffer[j]);
+	}
+      /* Else print as integer in hex and in decimal.  */
+      else
+	{
+	  long val;
+
+	  bcopy (virtual_buffer, &val, sizeof (long));
+	  if (val == 0)
+	    printf ("0");
+	  else
+	    printf ("0x%08x  %d", val, val);
+	}
+
+      /* If register has different raw and virtual formats,
+	 print the raw format in hex now.  */
+
+      if (REGISTER_CONVERTIBLE (i))
+	{
+	  register int j;
+
+	  printf ("  (raw 0x");
+	  for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+	    printf ("%02x", raw_buffer[j]);
+	  printf (")");
+	}
+      printf ("\n");
+    }
+
+  printf ("Contents are relative to selected stack frame.\n");
+}
+
+#ifdef ATTACH_DETACH
+/*
+ * TODO:
+ * Should save/restore the tty state since it might be that the
+ * program to be debugged was started on this tty and it wants
+ * the tty in some state other than what we want.  If it's running
+ * on another terminal or without a terminal, then saving and
+ * restoring the tty state is a harmless no-op.
+ */
+
+/*
+ * attach_command --
+ * takes a program started up outside of gdb and ``attaches'' to it.
+ * This stops it cold in it's tracks and allows us to start tracing
+ * it.  For this to work, we must be able to send the process a
+ * signal and we must have the same effective uid as the program.
+ */
+static void
+attach_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  char *exec_file;
+  int pid;
+
+  dont_repeat();
+
+  if (!args)
+    error_no_arg ("process-id to attach");
+  else
+    pid = atoi (args);
+
+  if (inferior_pid)
+    {
+      if (query ("A program is being debugged already.  Kill it? "))
+	kill_inferior ();
+      else
+	error ("Inferior not killed.");
+    }
+
+  exec_file = (char *) get_exec_file ();
+
+  if (from_tty)
+    {
+      printf ("Attaching program: %s pid %d\n",
+	      exec_file, pid);
+      fflush (stdout);
+    }
+
+  attach_program (pid);
+}
+
+/*
+ * detach_command --
+ * takes a program previously attached to and detaches it.
+ * The program resumes execution and will no longer stop
+ * on signals, etc.  We better not have left any breakpoints
+ * in the program or it'll die when it hits one.  For this
+ * to work, it may be necessary for the process to have been
+ * previously attached.  It *might* work if the program was
+ * started via the normal ptrace (PTRACE_TRACEME).
+ */
+
+static void
+detach_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  char *exec_file = (char *)get_exec_file ();
+  int signal = 0;
+
+  if (!inferior_pid)
+    error ("Not currently tracing a program\n");
+  if (from_tty)
+    {
+      printf ("Detaching program: %s pid %d\n",
+	      exec_file, inferior_pid);
+      fflush (stdout);
+    }
+  if (args)
+    signal = atoi (args);
+
+  detach (signal);
+  inferior_pid = 0;
+}
+#endif /* ATTACH_DETACH */
+
+static
+initialize ()
+{
+  add_com ("tty", class_run, tty_command,
+	   "Set terminal for future runs of program being debugged.");
+
+  add_com ("set-args", class_run, set_args_command,
+	   "Specify arguments to give program being debugged when it is started.\n\
+Follow this command with any number of args, to be passed to the program.");
+
+  add_info ("environment", environment_info,
+	    "The environment to give the program, or one variable's value.\n\
+With an argument VAR, prints the value of environment variable VAR to\n\
+give the program being debugged.  With no arguments, prints the entire\n\
+environment to be given to the program.");
+
+  add_com ("unset-environment", class_run, unset_environment_command,
+	   "Cancel environment variable VAR for the program.\n\
+This does not affect the program until the next \"run\" command.");
+  add_com ("set-environment", class_run, set_environment_command,
+	   "Set environment variable value to give the program.\n\
+Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
+VALUES of environment variables are uninterpreted strings.\n\
+This does not affect the program until the next \"run\" command.");
+ 
+#ifdef ATTACH_DETACH
+ add_com ("attach", class_run, attach_command,
+ 	   "Attach to a process that was started up outside of GDB.\n\
+To do this, you must have permission to send the process a signal.\n\
+And it must have the same effective uid as the debugger.\n\n\
+Before using \"attach\", you must use the \"exec-file\" command\n\
+to specify the program running in the process,\n\
+and the \"symbol-file\" command to load its symbol table.");
+  add_com ("detach", class_run, detach_command,
+	   "Detach the process previously attached.\n\
+The process is no longer traced and continues its execution.");
+#endif /* ATTACH_DETACH */
+
+  add_com ("signal", class_run, signal_command,
+	   "Continue program giving it signal number SIGNUMBER.");
+
+  add_com ("stepi", class_run, stepi_command,
+	   "Step one instruction exactly.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("si", "stepi", class_alias, 0);
+
+  add_com ("nexti", class_run, nexti_command,
+	   "Step one instruction, but proceed through subroutine calls.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("ni", "nexti", class_alias, 0);
+
+  add_com ("finish", class_run, finish_command,
+	   "Execute until selected stack frame returns.\n\
+Upon return, the value returned is printed and put in the value history.");
+
+  add_com ("next", class_run, next_command,
+	   "Step program, proceeding through subroutine calls.\n\
+Like the \"step\" command as long as subroutine calls do not happen;\n\
+when they do, the call is treated as one instruction.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("n", "next", class_run, 1);
+
+  add_com ("step", class_run, step_command,
+	   "Step program until it reaches a different source line.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("s", "step", class_run, 1);
+
+  add_com ("jump", class_run, jump_command,
+	   "Continue program being debugged at specified line or address.\n\
+Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
+for an address to start at.");
+
+  add_com ("cont", class_run, cont_command,
+	   "Continue program being debugged, after signal or breakpoint.\n\
+If proceeding from breakpoint, a number N may be used as an argument:\n\
+then the same breakpoint won't break until the Nth time it is reached.");
+  add_com_alias ("c", "cont", class_run, 1);
+
+  add_com ("run", class_run, run_command,
+	   "Start debugged program.  You may specify arguments to give it.\n\
+Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
+Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
+With no arguments, uses arguments last specified (with \"run\" or \"set-args\".\n\
+To cancel previous arguments and run with no arguments,\n\
+use \"set-args\" without arguments.");
+  add_com_alias ("r", "run", class_run, 1);
+
+  add_info ("registers", registers_info,
+	    "List of registers and their contents, for selected stack frame.\n\
+Register name as argument means describe only that register.");
+
+  add_info ("program", program_info,
+	    "Execution status of the program.");
+
+  inferior_args = savestring (" ", 1); /* By default, no args.  */
+  inferior_environ = make_environ ();
+  init_environ (inferior_environ);
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d34 39
+d74 1
+@
diff --git a/gdb/RCS/inflow.c,v b/gdb/RCS/inflow.c,v
new file mode 100644
index 0000000..83f44d9
--- /dev/null
+++ b/gdb/RCS/inflow.c,v
@@ -0,0 +1,731 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.07.38;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.05.04.57;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@From RMS's development sources on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Major Sys V tty changes, and a few changes to try to find the registers
+in the upage (untested yet).
+@
+text
+@/* Low level interface to ptrace, for GDB when running under Unix.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "frame.h"
+#include "inferior.h"
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/dir.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sgtty.h>
+#include <fcntl.h>
+
+#ifdef mac_aux
+#include <sys/seg.h>
+#include <sys/mmu.h>
+#include <sys/signal.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#else
+#include <sys/user.h>
+#endif /* mac_aux */
+
+
+#ifdef UMAX_PTRACE
+#include <a.out.h>
+#endif
+
+#ifdef NEW_SUN_PTRACE
+#include <sys/ptrace.h>
+#include <machine/reg.h>
+#endif
+
+#ifdef SYSV_TTYS
+#include <termio.h>
+#endif
+
+extern int errno;
+
+/* Nonzero if we are debugging an attached outside process
+   rather than an inferior.  */
+
+static int attach_flag;
+
+#define	UPAGE_MASK	0x00003FFF
+
+START_FILE
+
+/* Record terminal status separately for debugger and inferior.  */
+
+#ifdef SYSV_TTYS
+static struct termio ti_inferior;
+#else
+static struct sgttyb sg_inferior;
+static struct tchars tc_inferior;
+static struct ltchars ltc_inferior;
+static int lmode_inferior;
+#endif
+static int tflags_inferior;
+static int pgrp_inferior;
+
+#ifdef SYSV_TTYS
+static struct termio ti_ours;
+#else
+static struct sgttyb sg_ours;
+static struct tchars tc_ours;
+static struct ltchars ltc_ours;
+static int lmode_ours;
+#endif
+static int tflags_ours;
+static int pgrp_ours;
+
+/* Copy of inferior_io_terminal when inferior was last started.  */
+static char *inferior_thisrun_terminal;
+
+static void terminal_ours_1 ();
+
+/* Nonzero if our terminal settings are in effect.
+   Zero if the inferior's settings are in effect.  */
+static int terminal_is_ours;
+
+/* Initialize the terminal settings we record for the inferior,
+   before we actually run the inferior.  */
+
+void
+terminal_init_inferior ()
+{
+
+#ifdef SYSV_TTYS
+  ti_inferior = ti_ours;
+#else
+  sg_inferior = sg_ours;
+  tc_inferior = tc_ours;
+  ltc_inferior = ltc_ours;
+  lmode_inferior = lmode_ours;
+#endif
+  tflags_inferior = tflags_ours;
+  pgrp_inferior = inferior_pid;
+
+  terminal_is_ours = 1;
+}
+
+/* Put the inferior's terminal settings into effect.
+   This is preparation for starting or resuming the inferior.  */
+
+void
+terminal_inferior ()
+{
+  if (terminal_is_ours)   /*  && inferior_thisrun_terminal == 0) */
+    {
+      fcntl (0, F_SETFL, tflags_inferior);
+      fcntl (0, F_SETFL, tflags_inferior);
+#ifdef SYSV_TTYS
+      ioctl (0, TCSETA, &ti_inferior);
+#else
+      ioctl (0, TIOCSETN, &sg_inferior);
+      ioctl (0, TIOCSETC, &tc_inferior);
+      ioctl (0, TIOCSLTC, &ltc_inferior);
+      ioctl (0, TIOCLSET, &lmode_inferior);
+#endif
+      ioctl (0, TIOCSPGRP, &pgrp_inferior);
+    }
+  terminal_is_ours = 0;
+}
+
+/* Put some of our terminal settings into effect,
+   enough to get proper results from our output,
+   but do not change into or out of RAW mode
+   so that no input is discarded.
+
+   After doing this, either terminal_ours or terminal_inferior
+   should be called to get back to a normal state of affairs.  */
+
+void
+terminal_ours_for_output ()
+{
+  terminal_ours_1 (1);
+}
+
+/* Put our terminal settings into effect.
+   First record the inferior's terminal settings
+   so they can be restored properly later.  */
+
+void
+terminal_ours ()
+{
+  terminal_ours_1 (0);
+}
+
+static void
+terminal_ours_1 (output_only)
+     int output_only;
+{
+  /* Ignore this signal since it will happen when we try to set the pgrp.  */
+  int (*osigttou) ();
+
+  if (!terminal_is_ours)  /*   && inferior_thisrun_terminal == 0)  */
+    {
+      terminal_is_ours = 1;
+
+      osigttou = signal (SIGTTOU, SIG_IGN);
+
+      ioctl (0, TIOCGPGRP, &pgrp_inferior);
+      ioctl (0, TIOCSPGRP, &pgrp_ours);
+
+      signal (SIGTTOU, osigttou);
+
+      tflags_inferior = fcntl (0, F_GETFL, 0);
+#ifdef SYSV_TTYS
+      ioctl (0, TCGETA, &ti_inferior);
+#else
+      ioctl (0, TIOCGETP, &sg_inferior);
+      ioctl (0, TIOCGETC, &tc_inferior);
+      ioctl (0, TIOCGLTC, &ltc_inferior);
+      ioctl (0, TIOCLGET, &lmode_inferior);
+#endif
+    }
+
+  fcntl (0, F_SETFL, tflags_ours);
+  fcntl (0, F_SETFL, tflags_ours);
+
+
+#ifdef SYSV_TTYS
+  ti_ours.c_lflag |= ICANON | ISIG;
+  if (output_only)
+    ti_ours.c_lflag &= ~((ICANON|ISIG)&ti_inferior.c_lflag);
+  ioctl (0, TCSETA, &ti_ours);
+  ti_ours.c_lflag |= ICANON | ISIG;
+#else
+  sg_ours.sg_flags &= ~RAW & ~CBREAK;
+  if (output_only)
+    sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags;
+  ioctl (0, TIOCSETN, &sg_ours);
+  ioctl (0, TIOCSETC, &tc_ours);
+  ioctl (0, TIOCSLTC, &ltc_ours);
+  ioctl (0, TIOCLSET, &lmode_ours);
+  sg_ours.sg_flags &= ~RAW & ~CBREAK;
+#endif
+}
+
+static void
+term_status_command ()
+{
+  register int i;
+  printf ("Inferior's terminal status (currently saved by GDB):\n");
+#ifdef SYSV_TTYS
+  printf ("fcntl flags = 0x%x, owner pid = %d.\n",
+	  tflags_inferior, pgrp_inferior);
+  printf ("iflag = 0x%04x, oflag = 0x%04x, cflag = 0x%04x, lflag = 0x%04x\n",
+	  ti_inferior.c_iflag, ti_inferior.c_oflag,
+	  ti_inferior.c_cflag, ti_inferior.c_lflag);
+  printf ("line discipline = %d\n", ti_inferior.c_line);
+  printf ("control chars: ");
+  for (i = 0; i < NCC; i++)
+    printf ("0x%x ", ti_inferior.c_cc[i]);
+  printf ("\n");
+#else
+  printf ("fcntl flags = 0x%x, lmode = 0x%x,\nsgttyb.sg_flags = 0x%x, owner pid = %d.\n",
+	  tflags_inferior, lmode_inferior,
+	  sg_inferior.sg_flags, pgrp_inferior);
+  printf ("tchars: ");
+  for (i = 0; i < sizeof (struct tchars); i++)
+    printf ("0x%x ", ((char *)&tc_inferior)[i]);
+  printf ("\n");
+  printf ("ltchars: ");
+  for (i = 0; i < sizeof (struct ltchars); i++)
+    printf ("0x%x ", ((char *)&ltc_inferior)[i]);
+  printf ("\n");
+#endif
+}
+
+static void
+new_tty (ttyname)
+     char *ttyname;
+{
+  register int tty;
+  register int fd;
+
+#if 0
+  /* I think it is better not to do this.  Then C-z on the GDB terminal
+     will still stop the program, while C-z on the data terminal
+     will be input.  */
+
+  /* Disconnect the child process from our controlling terminal.  */
+  tty = open("/dev/tty", O_RDWR);
+  if (tty > 0)
+    {
+      ioctl(tty, TIOCNOTTY, 0);
+      close(tty);
+    }
+#endif
+  /* Now open the specified new terminal.  */
+
+  tty = open(ttyname, O_RDWR);
+  if (tty == -1)
+    _exit(1);
+
+  dup2(tty, 0);
+  dup2(tty, 1);
+  dup2(tty, 2);
+  close(tty);
+}
+
+/* Start an inferior process and returns its pid.
+   ALLARGS is a vector of program-name and args.
+   ENV is the environment vector to pass.  */
+
+int
+create_inferior (allargs, env)
+     char **allargs;
+     char **env;
+{
+  int pid;
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+
+  /* exec is said to fail if the executable is open.  */
+  close_exec_file ();
+
+  pid = vfork ();
+  if (pid < 0)
+    perror_with_name ("vfork");
+
+  if (pid == 0)
+    {
+      /* Run inferior in a separate process group.  */
+      setpgrp (getpid (), getpid ());
+
+      inferior_thisrun_terminal = inferior_io_terminal;
+      if (inferior_io_terminal != 0)
+	new_tty (inferior_io_terminal);
+
+/* Not needed on Sun, at least, and loses there
+   because it clobbers the superior.  */
+/*???      signal (SIGQUIT, SIG_DFL);
+      signal (SIGINT, SIG_DFL);  */
+
+      ptrace (0);
+      execle ("/bin/sh", "sh", "-c", allargs, 0, env);
+
+      fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
+	       errno < sys_nerr ? sys_errlist[errno] : "unknown error");
+      fflush (stderr);
+      _exit (0177);
+    }
+  return pid;
+}
+
+/* Kill the inferior process.  Make us have no inferior.  */
+
+static void
+kill_command ()
+{
+  if (inferior_pid == 0)
+    error ("The program is not being run.");
+  if (!query ("Kill the inferior process? "))
+    error ("Not confirmed.");
+  kill_inferior ();
+}
+
+kill_inferior ()
+{
+  if (inferior_pid == 0)
+    return;
+  ptrace (8, inferior_pid, 0, 0);
+  wait (0);
+  inferior_died ();
+}
+
+inferior_died ()
+{
+  inferior_pid = 0;
+  attach_flag = 0;
+  mark_breakpoints_out ();
+  reopen_exec_file ();
+  if (have_core_file_p ())
+    set_current_frame (read_register (FP_REGNUM));
+}
+
+/* Resume execution of the inferior process.
+   If STEP is nonzero, single-step it.
+   If SIGNAL is nonzero, give it that signal.  */
+
+void
+resume (step, signal)
+     int step;
+     int signal;
+{
+  errno = 0;
+  ptrace (step ? 9 : 7, inferior_pid, 1, signal);
+  if (errno)
+    perror_with_name ("ptrace");
+}
+
+#ifdef NEW_SUN_PTRACE
+
+/* Start debugging the process whose number is PID.  */
+
+attach (pid)
+     int pid;
+{
+  errno = 0;
+  ptrace (PTRACE_ATTACH, pid, 0, 0);
+  if (errno)
+    perror_with_name ("ptrace");
+  attach_flag = 1;
+  return pid;
+}
+
+/* Stop debugging the process whose number is PID
+   and continue it with signal number SIGNAL.
+   SIGNAL = 0 means just continue it.  */
+
+void
+detach (signal)
+     int signal;
+{
+  errno = 0;
+  ptrace (PTRACE_DETACH, inferior_pid, 1, signal);
+  if (errno)
+    perror_with_name ("ptrace");
+  attach_flag = 0;
+}
+#endif
+
+#ifdef NEW_SUN_PTRACE
+
+void
+fetch_inferior_registers ()
+{
+  struct regs inferior_registers;
+  struct fp_status inferior_fp_registers;
+  extern char registers[];
+
+  ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
+  ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
+
+  bcopy (&inferior_registers, registers, 16 * 4);
+  bcopy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
+	 sizeof inferior_fp_registers.fps_regs);
+  *(int *)&registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+  *(int *)&registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+  bcopy (&inferior_fp_registers.fps_control,
+	 &registers[REGISTER_BYTE (FPC_REGNUM)],
+	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+}
+
+/* Store our register values back into the inferior.
+   If REGNO is -1, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+
+store_inferior_registers (regno)
+     int regno;
+{
+  struct regs inferior_registers;
+  struct fp_status inferior_fp_registers;
+  extern char registers[];
+
+  bcopy (registers, &inferior_registers, 16 * 4);
+  bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+	 sizeof inferior_fp_registers.fps_regs);
+  inferior_registers.r_ps = *(int *)&registers[REGISTER_BYTE (PS_REGNUM)];
+  inferior_registers.r_pc = *(int *)&registers[REGISTER_BYTE (PC_REGNUM)];
+  bcopy (&registers[REGISTER_BYTE (FPC_REGNUM)],
+	 &inferior_fp_registers.fps_control,
+	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+
+  ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
+  ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
+}
+
+#else
+
+void
+fetch_inferior_registers ()
+{
+  register int regno;
+  register unsigned int regaddr;
+  char buf[MAX_REGISTER_RAW_SIZE];
+  register int i;
+
+#ifdef UMAX_PTRACE
+  unsigned int offset = 0;
+#else
+  struct user u;
+  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
+  offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+#endif
+
+  for (regno = 0; regno < NUM_REGS; regno++)
+    {
+      regaddr = register_addr (regno, offset);
+      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+ 	{
+ 	  *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0);
+ 	  regaddr += sizeof (int);
+ 	}
+      supply_register (regno, buf);
+    }
+}
+
+/* Store our register values back into the inferior.
+   If REGNO is -1, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+
+store_inferior_registers (regno)
+     int regno;
+{
+  register unsigned int regaddr;
+  char buf[80];
+
+#ifdef UMAX_PTRACE
+  unsigned int offset = 0;
+#else
+  struct user u;
+  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
+  offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+#endif
+
+  if (regno >= 0)
+    {
+      regaddr = register_addr (regno, offset);
+      errno = 0;
+      ptrace (6, inferior_pid, regaddr, read_register (regno));
+      if (errno != 0)
+	{
+	  sprintf (buf, "writing register number %d", regno);
+	  perror_with_name (buf);
+	}
+    }
+  else for (regno = 0; regno < NUM_REGS; regno++)
+    {
+      regaddr = register_addr (regno, offset);
+      errno = 0;
+      ptrace (6, inferior_pid, regaddr, read_register (regno));
+      if (errno != 0)
+	{
+	  sprintf (buf, "writing register number %d", regno);
+	  perror_with_name (buf);
+	}
+    }
+}
+
+#endif /* not NEW_SUN_PTRACE */
+
+/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
+   in the NEW_SUN_PTRACE case.
+   It ought to be straightforward.  But it appears that writing did
+   not write the data that I specified.  I cannot understand where
+   it got the data that it actually did write.  */
+
+/* Copy LEN bytes from inferior's memory starting at MEMADDR
+   to debugger memory starting at MYADDR.  */
+
+read_inferior_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  /* Round starting address down to longword boundary.  */
+  register CORE_ADDR addr = memaddr & - sizeof (int);
+  /* Round ending address up; get number of longwords that makes.  */
+  register int count
+    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  /* Allocate buffer of that many longwords.  */
+  register int *buffer = (int *) alloca (count * sizeof (int));
+
+  /* Read all the longwords */
+  for (i = 0; i < count; i++, addr += sizeof (int))
+    buffer[i] = ptrace (1, inferior_pid, addr, 0);
+
+  /* Copy appropriate bytes out of the buffer.  */
+  bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+}
+
+/* Copy LEN bytes of data from debugger memnory at MYADDR
+   to inferior's memory at MEMADDR.
+   On failure (cannot write the inferior)
+   returns the value of errno.  */
+
+int
+write_inferior_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  /* Round starting address down to longword boundary.  */
+  register CORE_ADDR addr = memaddr & - sizeof (int);
+  /* Round ending address up; get number of longwords that makes.  */
+  register int count
+    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  /* Allocate buffer of that many longwords.  */
+  register int *buffer = (int *) alloca (count * sizeof (int));
+  extern int errno;
+
+  /* Fill start and end extra bytes of buffer with existing memory data.  */
+
+  buffer[0] = ptrace (1, inferior_pid, addr, 0);
+  if (count > 1)
+    buffer[count - 1]
+      = ptrace (1, inferior_pid,
+		addr + (count - 1) * sizeof (int), 0);
+
+  /* Copy data to be written over corresponding part of buffer */
+
+  bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+
+  /* Write the entire buffer.  */
+
+  for (i = 0; i < count; i++, addr += sizeof (int))
+    {
+      errno = 0;
+      ptrace (4, inferior_pid, addr, buffer[i]);
+      if (errno)
+	return errno;
+    }
+
+  return 0;
+}
+
+static void
+try_writing_regs_command ()
+{
+  register int i;
+  register int value;
+  extern int errno;
+
+  if (inferior_pid == 0)
+    error ("The program is not being run.");
+
+  for (i = 0; ; i += 2)
+    {
+      QUIT;
+      errno = 0;
+      value = ptrace (3, inferior_pid, i, 0);
+      ptrace (6, inferior_pid, i, value);
+      if (errno == 0)
+	{
+	  printf (" Succeeded with address 0x%x; value 0x%x (%d).\n",
+		  i, value, value);
+	}
+      else if ((i & 0377) == 0)
+	printf (" Failed at 0x%x.\n", i);
+    }
+}
+
+static
+initialize ()
+{
+  add_com ("term-status", class_obscure, term_status_command,
+	   "Print info on inferior's saved terminal status.");
+
+  add_com ("try-writing-regs", class_obscure, try_writing_regs_command,
+	   "Try writing all locations in inferior's system block.\n\
+Report which ones can be written.");
+
+  add_com ("kill", class_run, kill_command,
+	   "Kill execution of program being debugged.");
+
+  inferior_pid = 0;
+
+#ifdef SYSV_TTYS
+  ioctl (0, TCGETA, &ti_ours);
+#else
+  ioctl (0, TIOCGETP, &sg_ours);
+  ioctl (0, TIOCGETC, &tc_ours);
+  ioctl (0, TIOCGLTC, &ltc_ours);
+  ioctl (0, TIOCLGET, &lmode_ours);
+#endif
+  fcntl (0, F_GETFL, tflags_ours);
+  ioctl (0, TIOCGPGRP, &pgrp_ours);
+
+  terminal_is_ours = 1;
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d28 1
+a30 1
+#include <sys/user.h>
+d36 11
+d56 4
+d67 2
+d73 3
+d80 1
+d84 3
+d91 1
+d110 4
+d118 1
+d135 3
+d142 1
+d191 3
+d198 1
+d201 11
+a214 3
+
+  fcntl (0, F_SETFL, tflags_ours);
+  fcntl (0, F_SETFL, tflags_ours);
+d220 1
+d228 12
+d251 1
+d470 1
+a470 1
+  offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
+d500 1
+a500 1
+  offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
+d647 3
+d654 1
+@
diff --git a/gdb/RCS/m-mac-aux.h,v b/gdb/RCS/m-mac-aux.h,v
new file mode 100644
index 0000000..eaac3dd
--- /dev/null
+++ b/gdb/RCS/m-mac-aux.h,v
@@ -0,0 +1,523 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.16.06;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.05.15.44;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Originally nonexistent, I create it.
+@
+
+
+1.2
+log
+@Original new config file for Mac-II running A/UX.
+@
+text
+@/* Parameters for execution on Macintosh under A/UX, for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef mac_aux
+#define mac_aux
+#endif
+
+/* Get rid of any system-imposed stack limit if possible.  */
+
+#undef SET_STACK_LIMIT_HUGE
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#undef NAMES_HAVE_UNDERSCORE
+
+/* COFF format object files */
+
+#define COFF_FORMAT
+
+/* System eVil ttys */
+
+#define SYSV_TTYS
+
+/* Debugger information will not be in DBX format.  */
+
+#undef READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)				\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)			\
+    pc += 6;   /* Skip link #long */			\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR 0x20000000
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 2
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 31
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES  \
+ {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
+  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
+  "ps", "pc",  \
+  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
+  "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" }
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PS_REGNUM 16		/* Contains processor status */
+#define PC_REGNUM 17		/* Contains program counter */
+#define FP0_REGNUM 18		/* Floating point register 0 */
+#define FPC_REGNUM 26		/* 68881 control register */
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8*12+8+20)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  \
+ ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168	\
+  : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72	\
+  : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 12 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 8-byte doubles.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_from_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_to_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Enable use of alternate code to read and write registers.  */
+
+#undef NEW_SUN_PTRACE
+
+/* Enable use of alternate code for Sun's format of core dump file.  */
+
+#undef NEW_SUN_CORE
+
+/* Do implement the attach and detach commands.  */
+
+#undef ATTACH_DETACH
+
+/* It is safe to look for symsegs on a Sun, because Sun's ld
+   does not screw up with random garbage at end of file.  */
+
+#define READ_GDB_SYMSEGS
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Sun, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Set VAL to the number of args passed to frame described by FI.
+   Can set VAL to -1, meaning no way to tell.  */
+
+/* We can't tell how many args there are
+   now that the C compiler delays popping them.  */
+#define FRAME_NUM_ARGS(val,fi) (val = -1)
+
+#if 0
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+#endif
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  int nextinsn;								\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+      if (044016 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (047126 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
+      else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  /* But before that can come an fmovem.  Check for it.  */		\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf227 == nextinsn						\
+      && (regmask & 0xff00) == 0xe000)					\
+    { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 12);		\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  if (0044327 == read_memory_integer (pc, 2))				\
+    { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; }	\
+  else if (0044347 == read_memory_integer (pc, 2))			\
+    { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2))		\
+    { regnum = 0xf & read_memory_integer (pc, 2); pc += 2;		\
+      (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* fmovemx to index of sp may follow.  */				\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf236 == nextinsn						\
+      && (regmask & 0xff00) == 0xf000)					\
+    { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12;	\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (0x426742e7 == read_memory_integer (pc, 4))			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
+  register int regnum;							\
+  char raw_buffer[12];							\
+  sp = push_word (sp, read_register (PC_REGNUM));			\
+  sp = push_word (sp, read_register (FP_REGNUM));			\
+  write_register (FP_REGNUM, sp);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);	\
+      sp = push_bytes (sp, raw_buffer, 12); }				\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    sp = push_word (sp, read_register (regnum));			\
+  sp = push_word (sp, read_register (PS_REGNUM));			\
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, 
+   restoring all saved registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  char raw_buffer[12];						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)	 \
+    if (fsr.regs[regnum])					 \
+      { read_memory (fsr.regs[regnum], raw_buffer, 12);		 \
+        write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)		 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])					 \
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+  set_current_frame (read_register (FP_REGNUM)); }
+
+/* This sequence of words is the instructions
+     fmovem 0xff,-(sp)
+     moveml 0xfffc,-(sp)
+     clrw -(sp)
+     movew ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jsr @@#32323232
+     addl #69696969,sp
+     bpt
+     nop
+Note this is 28 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 28
+
+#define CALL_DUMMY_START_OFFSET 12
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 20) = nargs * 4;  \
+  *(int *)((char *) dummyname + 14) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movel #end, sp");      \
+  asm ("movel #0,a6"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("movel a6,sp@@-");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl sp@@,a6");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea sp@@(10)");	      \
+  asm ("movem #0xfffe,sp@@-"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ asm ("subil #8,sp@@(28)");     \
+  asm ("movem sp@@,#0xffff"); \
+  asm ("rte"); }
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d1 485
+@
diff --git a/gdb/RCS/m-mac-auxinit.h,v b/gdb/RCS/m-mac-auxinit.h,v
new file mode 100644
index 0000000..796bc8d
--- /dev/null
+++ b/gdb/RCS/m-mac-auxinit.h,v
@@ -0,0 +1,43 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.19.09;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.05.18.45;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Originally nonexistent.
+@
+
+
+1.2
+log
+@Created by John Gilmore for Mac A/UX
+@
+text
+@
+/* This is how the size of an individual .o file's text segment
+   is rounded on a mac under a/ux.  */
+
+#define FILEADDR_ROUND(addr) (addr)
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d1 5
+@
diff --git a/gdb/RCS/m68k-pinsn.c,v b/gdb/RCS/m68k-pinsn.c,v
new file mode 100644
index 0000000..dedc0e7
--- /dev/null
+++ b/gdb/RCS/m68k-pinsn.c,v
@@ -0,0 +1,828 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.08.29;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.22.04.55;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@From RMS's development sources on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Avoid the so-called "portable" preassembled instructions; call a macro
+to generate them, since a/ux assembler uses a different syntax (grumble)
+@
+text
+@/* Print m68k instructions for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "m68k-opcode.h"
+
+/* 68k instructions are never longer than this many bytes.  */
+#define MAXLEN 22
+
+/* Number of elements in the opcode table.  */
+#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
+
+extern char *reg_names[];
+char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
+		     "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
+
+static unsigned char *print_insn_arg ();
+static unsigned char *print_indexed ();
+static void print_base ();
+static int fetch_arg ();
+
+#define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
+
+#define NEXTWORD(p)  \
+  (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
+
+#define NEXTLONG(p)  \
+  (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
+
+#define NEXTSINGLE(p) \
+  (p += 4, *((float *)(p - 4)))
+
+#define NEXTDOUBLE(p) \
+  (p += 8, *((double *)(p - 8)))
+
+#define NEXTEXTEND(p) \
+  (p += 12, 0.0)	/* Need a function to convert from extended to double
+			   precision... */
+
+#define NEXTPACKED(p) \
+  (p += 12, 0.0)	/* Need a function to convert from packed to double
+			   precision.   Actually, it's easier to print a
+			   packed number than a double anyway, so maybe
+			   there should be a special case to handle this... */
+
+/* Print the m68k instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  register int i;
+  register unsigned char *p;
+  register char *d;
+  register int bestmask;
+  int best;
+
+  read_memory (memaddr, buffer, MAXLEN);
+
+  bestmask = 0;
+  best = -1;
+  for (i = 0; i < NOPCODES; i++)
+    {
+      register unsigned int opcode = m68k_opcodes[i].opcode;
+      register unsigned int match = m68k_opcodes[i].match;
+      if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
+	  && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
+	  && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
+	  && ((0xff & buffer[3] & match) == (0xff & opcode)))
+	{
+	  /* Don't use for printout the variants of divul and divsl
+	     that have the same register number in two places.
+	     The more general variants will match instead.  */
+	  for (d = m68k_opcodes[i].args; *d; d += 2)
+	    if (d[1] == 'D')
+	      break;
+
+	  /* Don't use for printout the variants of most floating
+	     point coprocessor instructions which use the same
+	     register number in two places, as above. */
+	  if (*d == 0)
+	    for (d = m68k_opcodes[i].args; *d; d += 2)
+	      if (d[1] == 't')
+		break;
+
+	  if (*d == 0 && match > bestmask)
+	    {
+	      best = i;
+	      bestmask = match;
+	    }
+	}
+    }
+
+  /* Handle undefined instructions.  */
+  if (best < 0)
+    {
+      fprintf (stream, "0%o", (buffer[0] << 8) + buffer[1]);
+      return 2;
+    }
+
+  fprintf (stream, "%s", m68k_opcodes[best].name);
+
+  /* Point at first word of argument data,
+     and at descriptor for first argument.  */
+  p = buffer + 2;
+  
+  /* Why do this this way? -MelloN */
+  for (d = m68k_opcodes[best].args; *d; d += 2)
+    {
+      if (d[0] == '#')
+	{
+	  if (d[1] == 'l' && p - buffer < 6)
+	    p = buffer + 6;
+	  else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
+	    p = buffer + 4;
+	}
+      if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
+	p = buffer + 4;
+      if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
+	p = buffer + 6;
+    }
+
+  d = m68k_opcodes[best].args;
+
+  if (*d)
+    fputc (' ', stream);
+
+  while (*d)
+    {
+      p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
+      d += 2;
+      if (*d && *(d - 2) != 'I' && *d != 'k')
+	fprintf (stream, ",");
+    }
+  return p - buffer;
+}
+
+static unsigned char *
+print_insn_arg (d, buffer, p, addr, stream)
+     char *d;
+     unsigned char *buffer;
+     register unsigned char *p;
+     CORE_ADDR addr;		/* PC for this arg to be relative to */
+     FILE *stream;
+{
+  register int val;
+  register int place = d[1];
+  int regno;
+  register char *regname;
+  register unsigned char *p1;
+  register double flval;
+  int flt_p;
+
+  switch (*d)
+    {
+    case 'C':
+      fprintf (stream, "ccr");
+      break;
+
+    case 'S':
+      fprintf (stream, "sr");
+      break;
+
+    case 'U':
+      fprintf (stream, "usp");
+      break;
+
+    case 'J':
+      {
+	static struct { char *name; int value; } names[]
+	  = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
+	     {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
+	     {"msp", 0x803}, {"isp", 0x804}};
+
+	val = fetch_arg (buffer, place, 12);
+	for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
+	  if (names[regno].value == val)
+	    {
+	      fprintf (stream, names[regno].name);
+	      break;
+	    }
+	if (regno < 0)
+	  fprintf (stream, "%d", val);
+      }
+      break;
+
+    case 'Q':
+      val = fetch_arg (buffer, place, 3);
+      if (val == 0) val = 8;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'M':
+      val = fetch_arg (buffer, place, 8);
+      if (val & 0x80)
+	val = val - 0x100;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'T':
+      val = fetch_arg (buffer, place, 4);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'D':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'A':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3) + 010]);
+      break;
+
+    case 'R':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
+      break;
+
+    case 'F':
+      fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
+      break;
+
+    case 'O':
+      val = fetch_arg (buffer, place, 6);
+      if (val & 0x20)
+	fprintf (stream, "%s", reg_names [val & 7]);
+      else
+	fprintf (stream, "%d", val);
+      break;
+
+    case '+':
+      fprintf (stream, "(%s)+", reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case '-':
+      fprintf (stream, "-(%s)", reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case 'k':
+      if (place == 'k')
+	fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
+      else if (place == 'C')
+	{
+	  val = fetch_arg (buffer, place, 7);
+	  if ( val > 63 )		/* This is a signed constant. */
+	    val -= 128;
+	  fprintf (stream, "{#%d}", val);
+	}
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      break;
+
+    case '#':
+      p1 = buffer + 2;
+      if (place == 's')
+	val = fetch_arg (buffer, place, 4);
+      else if (place == 'C')
+	val = fetch_arg (buffer, place, 7);
+      else if (place == '8')
+	val = fetch_arg (buffer, place, 3);
+      else if (place == '3')
+	val = fetch_arg (buffer, place, 8);
+      else if (place == 'b')
+	val = NEXTBYTE (p1);
+      else if (place == 'w')
+	val = NEXTWORD (p1);
+      else if (place == 'l')
+	val = NEXTLONG (p1);
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case '^':
+      if (place == 's')
+	val = fetch_arg (buffer, place, 4);
+      else if (place == 'C')
+	val = fetch_arg (buffer, place, 7);
+      else if (place == '8')
+	val = fetch_arg (buffer, place, 3);
+      else if (place == 'b')
+	val = NEXTBYTE (p);
+      else if (place == 'w')
+	val = NEXTWORD (p);
+      else if (place == 'l')
+	val = NEXTLONG (p);
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'B':
+      if (place == 'b')
+	val = NEXTBYTE (p);
+      else if (place == 'w')
+	val = NEXTWORD (p);
+      else if (place == 'l')
+	val = NEXTLONG (p);
+      else if (place == 'g')
+	{
+	  val = ((char *)buffer)[1];
+	  if (val == 0)
+	    val = NEXTWORD (p);
+	  else if (val == -1)
+	    val = NEXTLONG (p);
+	}
+      else if (place == 'c')
+	{
+	  if (buffer[1] & 0x40)		/* If bit six is one, long offset */
+	    val = NEXTLONG (p);
+	  else
+	    val = NEXTWORD (p);
+	}
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+
+      print_address (addr + val, stream);
+      break;
+
+    case 'd':
+      val = NEXTWORD (p);
+      fprintf (stream, "%d(%s)", val, fetch_arg (buffer, place, 3));
+      break;
+
+    case 's':
+      fprintf (stream, "%s", fpcr_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'I':
+      val = fetch_arg (buffer, 'd', 3);		  /* Get coprocessor ID... */
+      if (val != 1)				/* Unusual coprocessor ID? */
+	fprintf (stream, "(cpid=%d) ", val);
+      if (place == 'i')
+	p += 2;			     /* Skip coprocessor extended operands */
+      break;
+
+    case '*':
+    case '~':
+    case '%':
+    case ';':
+    case '@@':
+    case '!':
+    case '$':
+    case '?':
+    case '/':
+    case '&':
+
+      if (place == 'd')
+	{
+	  val = fetch_arg (buffer, 'x', 6);
+	  val = ((val & 7) << 3) + ((val >> 3) & 7);
+	}
+      else
+	val = fetch_arg (buffer, 's', 6);
+
+      /* Get register number assuming address register.  */
+      regno = (val & 7) + 8;
+      regname = reg_names[regno];
+      switch (val >> 3)
+	{
+	case 0:
+	  fprintf (stream, "%s", reg_names[val]);
+	  break;
+
+	case 1:
+	  fprintf (stream, "%s", regname);
+	  break;
+
+	case 2:
+	  fprintf (stream, "(%s)", regname);
+	  break;
+
+	case 3:
+	  fprintf (stream, "(%s)+", regname);
+	  break;
+
+	case 4:
+	  fprintf (stream, "-(%s)", regname);
+	  break;
+
+	case 5:
+	  val = NEXTWORD (p);
+	  fprintf (stream, "%d(%s)", val, regname);
+	  break;
+
+	case 6:
+	  p = print_indexed (regno, p, addr, stream);
+	  break;
+
+	case 7:
+	  switch (val & 7)
+	    {
+	    case 0:
+	      val = NEXTWORD (p);
+	      fprintf (stream, "@@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 1:
+	      val = NEXTLONG (p);
+	      fprintf (stream, "@@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 2:
+	      val = NEXTWORD (p);
+	      print_address (addr + val, stream);
+	      break;
+
+	    case 3:
+	      p = print_indexed (-1, p, addr, stream);
+	      break;
+
+	    case 4:
+	      flt_p = 1;	/* Assume it's a float... */
+	      switch( place )
+	      {
+		case 'b':
+		  val = NEXTBYTE (p);
+		  flt_p = 0;
+		  break;
+
+		case 'w':
+		  val = NEXTWORD (p);
+		  flt_p = 0;
+		  break;
+
+		case 'l':
+		  val = NEXTLONG (p);
+		  flt_p = 0;
+		  break;
+
+		case 'f':
+		  flval = NEXTSINGLE(p);
+		  break;
+
+		case 'F':
+		  flval = NEXTDOUBLE(p);
+		  break;
+
+		case 'x':
+		  flval = NEXTEXTEND(p);
+		  break;
+
+		case 'p':
+		  flval = NEXTPACKED(p);
+		  break;
+
+		default:
+		  error ("Invalid arg format in opcode table: \"%c%c\".",
+		       *d, place);
+	      }
+	      if ( flt_p )	/* Print a float? */
+		fprintf (stream, "#%g", flval);
+	      else
+		fprintf (stream, "#%d", val);
+	      break;
+
+	    default:
+	      fprintf (stream, "<invalid address mode 0%o>", val);
+	    }
+	}
+      break;
+
+    default:
+      error ("Invalid arg format in opcode table: \"%c\".", *d);
+    }
+
+  return (unsigned char *) p;
+}
+
+/* Fetch BITS bits from a position in the instruction specified by CODE.
+   CODE is a "place to put an argument", or 'x' for a destination
+   that is a general address (mode and register).
+   BUFFER contains the instruction.  */
+
+static int
+fetch_arg (buffer, code, bits)
+     unsigned char *buffer;
+     char code;
+     int bits;
+{
+  register int val;
+  switch (code)
+    {
+    case 's':
+      val = buffer[1];
+      break;
+
+    case 'd':			/* Destination, for register or quick.  */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 9;
+      break;
+
+    case 'x':			/* Destination, for general arg */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 6;
+      break;
+
+    case 'k':
+      val = (buffer[3] >> 4);
+      break;
+
+    case 'C':
+      val = buffer[3];
+      break;
+
+    case '1':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 12;
+      break;
+
+    case '2':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 6;
+      break;
+
+    case '3':
+    case 'j':
+      val = (buffer[2] << 8) + buffer[3];
+      break;
+
+    case '4':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 12;
+      break;
+
+    case '5':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 6;
+      break;
+
+    case '6':
+      val = (buffer[4] << 8) + buffer[5];
+      break;
+
+    case '7':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 7;
+      break;
+      
+    case '8':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 10;
+      break;
+
+    default:
+      abort ();
+    }
+
+  switch (bits)
+    {
+    case 3:
+      return val & 7;
+    case 4:
+      return val & 017;
+    case 5:
+      return val & 037;
+    case 6:
+      return val & 077;
+    case 7:
+      return val & 0177;
+    case 8:
+      return val & 0377;
+    case 12:
+      return val & 07777;
+    default:
+      abort ();
+    }
+}
+
+/* Print an indexed argument.  The base register is BASEREG (-1 for pc).
+   P points to extension word, in buffer.
+   ADDR is the nominal core address of that extension word.  */
+
+static unsigned char *
+print_indexed (basereg, p, addr, stream)
+     int basereg;
+     unsigned char *p;
+     FILE *stream;
+     CORE_ADDR addr;
+{
+  register int word;
+  static char *scales[] = {"", "*2", "*4", "*8"};
+  register int base_disp;
+  register int outer_disp;
+  char buf[40];
+
+  word = NEXTWORD (p);
+
+  /* Generate the text for the index register.
+     Where this will be output is not yet determined.  */
+  sprintf (buf, "[%s.%c%s]",
+	   reg_names[(word >> 12) & 0xf],
+	   (word & 0x800) ? 'l' : 'w',
+	   scales[(word >> 9) & 3]);
+
+  /* Handle the 68000 style of indexing.  */
+
+  if ((word & 0x100) == 0)
+    {
+      print_base (basereg,
+		  ((word & 0x80) ? word | 0xff00 : word & 0xff)
+		  + ((basereg == -1) ? addr : 0),
+		  stream);
+      fprintf (stream, "%s", buf);
+      return p;
+    }
+
+  /* Handle the generalized kind.  */
+  /* First, compute the displacement to add to the base register.  */
+
+  if (word & 0200)
+    basereg = -2;
+  if (word & 0100)
+    buf[0] = 0;
+  base_disp = 0;
+  switch ((word >> 4) & 3)
+    {
+    case 2:
+      base_disp = NEXTWORD (p);
+      break;
+    case 3:
+      base_disp = NEXTLONG (p);
+    }
+  if (basereg == -1)
+    base_disp += addr;
+
+  /* Handle single-level case (not indirect) */
+
+  if ((word & 7) == 0)
+    {
+      print_base (basereg, base_disp, stream);
+      fprintf (stream, "%s", buf);
+      return p;
+    }
+
+  /* Two level.  Compute displacement to add after indirection.  */
+
+  outer_disp = 0;
+  switch (word & 3)
+    {
+    case 2:
+      outer_disp = NEXTWORD (p);
+      break;
+    case 3:
+      outer_disp = NEXTLONG (p);
+    }
+
+  fprintf (stream, "%d(", outer_disp);
+  print_base (basereg, base_disp, stream);
+
+  /* If postindexed, print the closeparen before the index.  */
+  if (word & 4)
+    fprintf (stream, ")%s", buf);
+  /* If preindexed, print the closeparen after the index.  */
+  else
+    fprintf (stream, "%s)", buf);
+
+  return p;
+}
+
+/* Print a base register REGNO and displacement DISP, on STREAM.
+   REGNO = -1 for pc, -2 for none (suppressed).  */
+
+static void
+print_base (regno, disp, stream)
+     int regno;
+     int disp;
+     FILE *stream;
+{
+  if (regno == -2)
+    fprintf (stream, "%d", disp);
+  else if (regno == -1)
+    fprintf (stream, "0x%x", disp);
+  else
+    fprintf (stream, "%d(%s)", disp, reg_names[regno]);
+}
+
+/* This is not part of insn printing, but it is machine-specific,
+   so this is a convenient place to put it.
+
+   Convert a 68881 extended float to a double.
+   FROM is the address of the extended float.
+   Store the double in *TO.  */
+
+#ifdef mac_aux
+#ifdef __STDC__
+#define	asm16(str)	asm ("short	" str#)
+#else
+#define	asm16(str)	asm ("short	str")
+#endif
+#else
+#ifdef __STDC__
+#define	asm16(str)	asm (".word	" str#)
+#else
+#define	asm16(str)	asm (".word	str")
+#endif
+#endif
+
+convert_from_68881 (from, to)
+     char *from;
+     double *to;
+{
+#if 0
+  asm ("movl a6@@(8),a0");
+  asm ("movl a6@@(12),a1");
+  asm ("fmovex a0@@,fp0");
+  asm ("fmoved fp0,a1@@");
+#else
+  /* Hand-assemble those insns since some assemblers lose
+     and some have different syntax.  */
+  asm16 (020156);
+  asm16 (8);
+  asm16 (021156);
+  asm16 (12);
+  asm16 (0xf210);
+  asm16 (0x4800);
+  asm16 (0xf211);
+  asm16 (0x7400);
+#endif
+}
+
+/* The converse: convert the double *FROM to an extended float
+   and store where TO points.  */
+
+convert_to_68881 (from, to)
+     double *from;
+     char *to;
+{
+#if 0
+  asm ("movl a6@@(8),a0");
+  asm ("movl a6@@(12),a1");
+  asm ("fmoved a0@@,fp0");
+  asm ("fmovex fp0,a1@@");
+#else
+  /* Hand-assemble those insns since some assemblers lose.  */
+  asm16 (020156);
+  asm16 (8);
+  asm16 (021156);
+  asm16 (12);
+  asm16 (0xf210);
+  asm16 (0x5400);
+  asm16 (0xf211);
+  asm16 (0x6800);
+#endif
+}
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d713 14
+d739 8
+a746 6
+  asm (".word 020156");
+  asm (".word 8");
+  asm (".word 021156");
+  asm (".word 12");
+  asm (".long 0xf2104800");
+  asm (".long 0xf2117400");
+d764 8
+a771 6
+  asm (".word 020156");
+  asm (".word 8");
+  asm (".word 021156");
+  asm (".word 12");
+  asm (".long 0xf2105400");
+  asm (".long 0xf2116800");
+@
diff --git a/gdb/RCS/main.c,v b/gdb/RCS/main.c,v
new file mode 100644
index 0000000..ae6615f
--- /dev/null
+++ b/gdb/RCS/main.c,v
@@ -0,0 +1,1110 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.09.12;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.04.23.16;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS development on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Add <sys/types.h>
+@
+text
+@/* Top level for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <sys/param.h>
+#include "defs.h"
+#include "command.h"
+#include "param.h"
+
+#ifdef SET_STACK_LIMIT_HUGE
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
+/* Version number of GDB, as a string.  */
+
+extern char *version;
+
+/* Chain containing all defined commands.  */
+
+struct cmd_list_element *cmdlist;
+
+/* Chain containing all defined info subcommands.  */
+
+struct cmd_list_element *infolist;
+
+/* stdio stream that command input is being read from.  */
+
+FILE *instream;
+
+/* Nonzero if we should refrain from using an X window.  */
+
+int inhibit_windows = 0;
+
+/* Function to call before reading a command, if nonzero.
+   The function receives two args: an input stream,
+   and a prompt string.  */
+   
+void (*window_hook) ();
+
+void free_command_lines ();
+char *read_line ();
+static void initialize_main ();
+void command_loop ();
+static void source_command ();
+void print_gdb_version ();
+
+/* gdb prints this when reading a command interactively */
+static char *prompt;
+
+/* Buffer used for reading command lines, and the size
+   allocated for it so far.  */
+
+char *line;
+int linesize;
+
+/* This is how `error' returns to command level.  */
+
+jmp_buf to_top_level;
+
+return_to_top_level ()
+{
+  quit_flag = 0;
+  immediate_quit = 0;
+  clear_breakpoint_commands ();
+  clear_momentary_breakpoints ();
+  do_cleanups (0);
+  longjmp (to_top_level, 1);
+}
+
+main (argc, argv, envp)
+     int argc;
+     char **argv;
+     char **envp;
+{
+  extern void request_quit ();
+  int count;
+  int inhibit_gdbinit = 0;
+  int quiet = 0;
+  int batch = 0;
+  register int i;
+
+  quit_flag = 0;
+  linesize = 100;
+  line = (char *) xmalloc (linesize);
+  instream = stdin;
+
+#ifdef SET_STACK_LIMIT_HUGE
+  {
+    struct rlimit rlim;
+
+    /* Set the stack limit huge so that alloca (particularly stringtab
+     * in dbxread.c) does not fail. */
+    getrlimit (RLIMIT_STACK, &rlim);
+    rlim.rlim_cur = rlim.rlim_max;
+    setrlimit (RLIMIT_STACK, &rlim);
+  }
+#endif /* SET_STACK_LIMIT_HUGE */
+
+  /* Look for flag arguments.  */
+
+  for (i = 1; i < argc; i++)
+    {
+      if (!strcmp (argv[i], "-q") || !strcmp (argv[i], "-quiet"))
+	quiet = 1;
+      else if (!strcmp (argv[i], "-nx"))
+	inhibit_gdbinit = 1;
+      else if (!strcmp (argv[i], "-nw"))
+	inhibit_windows = 1;
+      else if (!strcmp (argv[i], "-batch"))
+	batch = 1, quiet = 1;
+      else if (argv[i][0] == '-')
+	i++;
+    }
+
+  /* Run the init function of each source file */
+
+  initialize_all_files ();
+  initialize_main ();		/* But that omits this file!  Do it now */
+
+  signal (SIGINT, request_quit);
+  signal (SIGQUIT, SIG_IGN);
+
+  if (!quiet)
+    print_gdb_version ();
+
+  /* Process the command line arguments.  */
+
+  count = 0;
+  for (i = 1; i < argc; i++)
+    {
+      register char *arg = argv[i];
+      /* Args starting with - say what to do with the following arg
+	 as a filename.  */
+      if (arg[0] == '-')
+	{
+	  extern void exec_file_command (), symbol_file_command ();
+	  extern void core_file_command (), directory_command ();
+	  extern void tty_command ();
+
+	  if (!strcmp (arg, "-q") || !strcmp (arg, "-nx")
+	      || !strcmp (arg, "quiet") || !strcmp (arg, "-batch"))
+	    /* Already processed above */
+	    continue;
+
+	  if (++i == argc)
+	    fprintf (stderr, "No argument follows \"%s\".\n", arg);
+	  if (!setjmp (to_top_level))
+	    {
+	      /* -s foo: get syms from foo.  -e foo: execute foo.
+		 -se foo: do both with foo.  -c foo: use foo as core dump.  */
+	      if (!strcmp (arg, "-se"))
+		{
+		  exec_file_command (argv[i], !batch);
+		  symbol_file_command (argv[i], !batch);
+		}
+	      else if (!strcmp (arg, "-s") || !strcmp (arg, "-symbols"))
+		symbol_file_command (argv[i], !batch);
+	      else if (!strcmp (arg, "-e") || !strcmp (arg, "-exec"))
+		exec_file_command (argv[i], !batch);
+	      else if (!strcmp (arg, "-c") || !strcmp (arg, "-core"))
+		core_file_command (argv[i], !batch);
+	      /* -x foo: execute commands from foo.  */
+	      else if (!strcmp (arg, "-x") || !strcmp (arg, "-command")
+		       || !strcmp (arg, "-commands"))
+		source_command (argv[i]);
+	      /* -d foo: add directory `foo' to source-file directory
+		         search-list */
+	      else if (!strcmp (arg, "-d") || !strcmp (arg, "-dir")
+		       || !strcmp (arg, "-directory"))
+		directory_command (argv[i], 0);
+	      /* -t /def/ttyp1: use /dev/ttyp1 for inferior I/O.  */
+	      else if (!strcmp (arg, "-t") || !strcmp (arg, "-tty"))
+		tty_command (argv[i], 0);
+	      else
+		error ("Unknown command-line switch: \"%s\"\n", arg);
+	    }
+	}
+      else
+	{
+	  /* Args not thus accounted for
+	     are treated as, first, the symbol/executable file
+	     and, second, the core dump file.  */
+	  count++;
+	  if (!setjmp (to_top_level))
+	    switch (count)
+	      {
+	      case 1:
+		exec_file_command (arg, !batch);
+		symbol_file_command (arg, !batch);
+		break;
+
+	      case 2:
+		core_file_command (arg, !batch);
+		break;
+
+	      case 3:
+		fprintf (stderr, "Excess command line args ignored. (%s%s)\n",
+			 arg, (i == argc - 1) ? "" : " ...");
+	      }
+	}
+    }
+
+  /* Read init file, if it exists in home directory  */
+  if (getenv ("HOME"))
+    {
+      char *s;
+      s = (char *) xmalloc (strlen (getenv ("HOME")) + 10);
+      strcpy (s, getenv ("HOME"));
+      strcat (s, "/.gdbinit");
+      if (!inhibit_gdbinit && access (s, R_OK) == 0)
+	if (!setjmp (to_top_level))
+	  source_command (s);
+    }
+
+  /* Read init file, if it exists in current directory.  */
+  if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0)
+    if (!setjmp (to_top_level))
+      source_command (".gdbinit");
+
+  if (batch)
+    fatal ("Attempt to read commands from stdin in batch mode.");
+
+  if (!quiet)
+    printf ("Type \"help\" for a list of commands.\n");
+
+  /* The command loop.  */
+
+  while (1)
+    {
+      if (!setjmp (to_top_level))
+	command_loop ();
+      clearerr (stdin);		/* Don't get hung if C-d is typed.  */
+    }
+}
+
+/* Execute the line P as a command.
+   Pass FROM_TTY as second argument to the defining function.  */
+
+void
+execute_command (p, from_tty)
+     char *p;
+     int from_tty;
+{
+  register struct cmd_list_element *c;
+  register struct command_line *cmdlines;
+
+  free_all_values ();
+  while (*p == ' ' || *p == '\t') p++;
+  if (*p)
+    {
+      c = lookup_cmd (&p, cmdlist, "", 0);
+      if (c->function == 0)
+	error ("That is not a command, just a help topic.");
+      else if (c->class == (int) class_user)
+	{
+	  if (*p)
+	    error ("User-defined commands cannot take command-line arguments: \"%s\"",
+		   p);
+	  cmdlines = (struct command_line *) c->function;
+	  if (cmdlines == (struct command_line *) 0)
+	    /* Null command */
+	    return;
+	  while (cmdlines)
+	    {
+	      execute_command (cmdlines->line, 0);
+	      cmdlines = cmdlines->next;
+	    }
+	}
+      else
+	/* Pass null arg rather than an empty one.  */
+	(*c->function) (*p ? p : 0, from_tty);
+    }
+}
+
+static void
+do_nothing ()
+{
+}
+
+/* Read commands from `instream' and execute them
+   until end of file.  */
+void
+command_loop ()
+{
+  struct cleanup *old_chain;
+  while (!feof (instream))
+    {
+      if (instream == stdin)
+	printf ("%s", prompt);
+      fflush (stdout);
+
+      if (window_hook && instream == stdin)
+	(*window_hook) (instream, prompt);
+
+      quit_flag = 0;
+      old_chain = make_cleanup (do_nothing, 0);
+      execute_command (read_line (instream == stdin), instream == stdin);
+      /* Do any commands attached to breakpoint we stopped at.  */
+      do_breakpoint_commands ();
+      do_cleanups (old_chain);
+    }
+}
+
+static void
+stop_sig ()
+{
+  signal (SIGTSTP, SIG_DFL);
+  sigsetmask (0);
+  kill (getpid (), SIGTSTP);
+  signal (SIGTSTP, stop_sig);
+  printf ("%s", prompt);
+  fflush (stdout);
+
+  /* Forget about any previous command -- null line now will do nothing.  */
+  *line = 0;
+}
+
+/* Commands call this if they do not want to be repeated by null lines.  */
+
+void
+dont_repeat ()
+{
+  *line = 0;
+}
+
+/* Read one line from the command input stream `instream'
+   into the buffer `line' (whose current length is `linesize').
+   The buffer is made bigger as necessary.
+   Returns the address of the start of the line.  */
+
+char *
+read_line (repeat)
+     int repeat;
+{
+  register char *p = line;
+  register char *p1;
+  register int c;
+  char *nline;
+
+  /* Control-C quits instantly if typed while in this loop
+     since it should not wait until the user types a newline.  */
+  immediate_quit++;
+  signal (SIGTSTP, stop_sig);
+
+  while (1)
+    {
+      c = fgetc (instream);
+      if (c == -1 || c == '\n')
+	break;
+      if (p - line == linesize - 1)
+	{
+	  linesize *= 2;
+	  nline = (char *) xrealloc (line, linesize);
+	  p += nline - line;
+	  line = nline;
+	}
+      *p++ = c;
+    }
+
+  signal (SIGTSTP, SIG_DFL);
+  immediate_quit--;
+
+  /* If we just got an empty line, and that is supposed
+     to repeat the previous command, leave the last input unchanged.  */
+  if (p == line && repeat)
+    return line;
+
+  /* If line is a comment, clear it out.  */
+  p1 = line;
+  while ((c = *p1) == ' ' || c == '\t') p1++;
+  if (c == '#')
+    p = line;
+
+  *p = 0;
+
+  return line;
+}
+
+/* Read lines from the input stream
+   and accumulate them in a chain of struct command_line's
+   which is then returned.  */
+
+struct command_line *
+read_command_lines ()
+{
+  struct command_line *first = 0;
+  register struct command_line *next, *tail = 0;
+  register char *p, *p1;
+  struct cleanup *old_chain = 0;
+
+  while (1)
+    {
+      dont_repeat ();
+      p = read_line (1);
+      /* Remove leading and trailing blanks.  */
+      while (*p == ' ' || *p == '\t') p++;
+      p1 = p + strlen (p);
+      while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) p1--;
+
+      /* Is this "end"?  */
+      if (p1 - p == 3 && !strncmp (p, "end", 3))
+	break;
+
+      /* No => add this line to the chain of command lines.  */
+      next = (struct command_line *) xmalloc (sizeof (struct command_line));
+      next->line = savestring (p, p1 - p);
+      next->next = 0;
+      if (tail)
+	{
+	  tail->next = next;
+	}
+      else
+	{
+	  /* We just read the first line.
+	     From now on, arrange to throw away the lines we have
+	     if we quit or get an error while inside this function.  */
+	  first = next;
+	  old_chain = make_cleanup (free_command_lines, &first);
+	}
+      tail = next;
+    }
+
+  dont_repeat ();
+
+  /* Now we are about to return the chain to our caller,
+     so freeing it becomes his responsibility.  */
+  if (first)
+    discard_cleanups (old_chain);
+  return first;
+}
+
+/* Free a chain of struct command_line's.  */
+
+void
+free_command_lines (lptr)
+      struct command_line **lptr;
+{
+  register struct command_line *l = *lptr;
+  register struct command_line *next;
+
+  while (l)
+    {
+      next = l->next;
+      free (l->line);
+      free (l);
+      l = next;
+    }
+}
+
+/* Add an element to the list of info subcommands.  */
+
+void
+add_info (name, fun, doc)
+     char *name;
+     void (*fun) ();
+     char *doc;
+{
+  add_cmd (name, 0, fun, doc, &infolist);
+}
+
+/* Add an alias to the list of info subcommands.  */
+
+void
+add_info_alias (name, oldname, abbrev_flag)
+     char *name;
+     char *oldname;
+     int abbrev_flag;
+{
+  add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
+}
+
+/* The "info" command is defined as a prefix, with allow_unknown = 0.
+   Therefore, its own definition is called only for "info" with no args.  */
+
+static void
+info_command ()
+{
+  printf ("\"info\" must be followed by the name of an info command.\n");
+  help_cmd (0, infolist, "info ", -1, stdout);
+}
+
+/* Add an element to the list of commands.  */
+
+void
+add_com (name, class, fun, doc)
+     char *name;
+     int class;
+     void (*fun) ();
+     char *doc;
+{
+  add_cmd (name, class, fun, doc, &cmdlist);
+}
+
+/* Add an alias or abbreviation command to the list of commands.  */
+
+void
+add_com_alias (name, oldname, class, abbrev_flag)
+     char *name;
+     char *oldname;
+     int class;
+     int abbrev_flag;
+{
+  add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
+}
+
+void
+error_no_arg (why)
+     char *why;
+{
+  error ("Argument required (%s).", why);
+}
+
+static void
+help_command (command, from_tty)
+     char *command;
+     int from_tty; /* Ignored */
+{
+  help_cmd (command, cmdlist, "", -2, stdout);
+}
+
+static void
+validate_comname (comname)
+     char *comname;
+{
+  register char *p;
+
+  if (comname == 0)
+    error_no_arg ("name of command to define");
+
+  p = comname;
+  while (*p)
+    {
+      if (!(*p >= 'A' && *p <= 'Z')
+	  && !(*p >= 'a' && *p <= 'z')
+	  && !(*p >= '1' && *p <= '9')
+	  && *p != '-')
+	error ("Junk in argument list: \"%s\"", p);
+      p++;
+    }
+}
+
+static void
+define_command (comname, from_tty)
+     char *comname;
+     int from_tty;
+{
+  register struct command_line *cmds;
+  register struct cmd_list_element *c;
+  char *tem = comname;
+
+  validate_comname (comname);
+
+  c = lookup_cmd (&tem, cmdlist, "", -1);
+  if (c)
+    {
+      if (c->class == (int) class_user || c->class == (int) class_alias)
+	tem = "Redefine command \"%s\"? ";
+      else
+	tem = "Really redefine built-in command \"%s\"? ";
+      if (!query (tem, comname))
+	error ("Command \"%s\" not redefined.", comname);
+    }
+
+  if (from_tty)
+    printf ("Type commands for definition of \"%s\".\n\
+End with a line saying just \"end\".\n", comname);
+
+  comname = savestring (comname, strlen (comname));
+
+  cmds = read_command_lines ();
+
+  if (c && c->class == (int) class_user)
+    free_command_lines (&c->function);
+
+  add_com (comname, class_user, cmds,
+	   (c && c->class == (int) class_user)
+	   ? c->doc : savestring ("User-defined.", 13));
+}
+
+static void
+document_command (comname, from_tty)
+     char *comname;
+     int from_tty;
+{
+  struct command_line *doclines;
+  register struct cmd_list_element *c;
+  char *tem = comname;
+
+  validate_comname (comname);
+
+  c = lookup_cmd (&tem, cmdlist, "", 0);
+
+  if (c->class != (int) class_user)
+    error ("Command \"%s\" is built-in.", comname);
+
+  if (from_tty)
+    printf ("Type documentation for \"%s\".\n\
+End with a line saying just \"end\".\n", comname);
+
+  doclines = read_command_lines ();
+
+  if (c->doc) free (c->doc);
+
+  {
+    register struct command_line *cl1;
+    register int len = 0;
+
+    for (cl1 = doclines; cl1; cl1 = cl1->next)
+      len += strlen (cl1->line) + 1;
+
+    c->doc = (char *) xmalloc (len + 1);
+    *c->doc = 0;
+
+    for (cl1 = doclines; cl1; cl1 = cl1->next)
+      {
+	strcat (c->doc, cl1->line);
+	if (cl1->next)
+	  strcat (c->doc, "\n");
+      }
+  }
+
+  free_command_lines (&doclines);
+}
+
+static void
+copying_info ()
+{
+  immediate_quit++;
+  printf ("		    GDB GENERAL PUBLIC LICENSE\n\
+\n\
+ Copyright (C) 1986 Richard M. Stallman\n\
+ Everyone is permitted to copy and distribute verbatim copies\n\
+ of this license, but changing it is not allowed.\n\
+\n\
+  The license agreements of most software companies keep you at the\n\
+mercy of those companies.  By contrast, our general public license is\n\
+intended to give everyone the right to share GDB.  To make sure that\n\
+you get the rights we want you to have, we need to make restrictions\n\
+that forbid anyone to deny you these rights or to ask you to surrender\n\
+the rights.  Hence this license agreement.\n\
+\n\
+  Specifically, we want to make sure that you have the right to give\n\
+away copies of GDB, that you receive source code or else can get it\n\
+if you want it, that you can change GDB or use pieces of it in new\n\
+free programs, and that you know you can do these things.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  To make sure that everyone has such rights, we have to forbid you to\n\
+deprive anyone else of these rights.  For example, if you distribute\n\
+copies of GDB, you must give the recipients all the rights that you\n\
+have.  You must make sure that they, too, receive or can get the\n\
+source code.  And you must tell them their rights.\n\
+\n\
+  Also, for our own protection, we must make certain that everyone\n\
+finds out that there is no warranty for GDB.  If GDB is modified by\n\
+someone else and passed on, we want its recipients to know that what\n\
+they have is not what we distributed, so that any problems introduced\n\
+by others will not reflect on our reputation.\n\
+\n\
+  Therefore we (Richard Stallman and the Free Software Foundation,\n\
+Inc.) make the following terms which say what you must do to be\n\
+allowed to distribute or change GDB.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+			COPYING POLICIES\n\
+\n\
+  1. You may copy and distribute verbatim copies of GDB source code as\n\
+you receive it, in any medium, provided that you conspicuously and\n\
+appropriately publish on each copy a valid copyright notice \"Copyright\n\
+\(C) 1987 Free Software Foundation, Inc.\" (or with the year updated if\n\
+that is appropriate); keep intact the notices on all files that refer\n\
+to this License Agreement and to the absence of any warranty; and give\n\
+any other recipients of the GDB program a copy of this License\n\
+Agreement along with the program.  You may charge a distribution fee\n\
+for the physical act of transferring a copy.\n\
+\n\
+  2. You may modify your copy or copies of GDB or any portion of it,\n\
+and copy and distribute such modifications under the terms of\n\
+Paragraph 1 above, provided that you also do the following:\n\
+\n\
+    a) cause the modified files to carry prominent notices stating\n\
+    that you changed the files and the date of any change; and\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+    b) cause the whole of any work that you distribute or publish,\n\
+    that in whole or in part contains or is a derivative of GDB\n\
+    or any part thereof, to be licensed to all third parties on terms\n\
+    identical to those contained in this License Agreement (except that\n\
+    you may choose to grant more extensive warranty protection to third\n\
+    parties, at your option).\n\
+\n");
+  printf ("\
+    c) if the modified program serves as a debugger, cause it\n\
+    when started running in the simplest and usual way, to print\n\
+    an announcement including a valid copyright notice\n\
+    \"Copyright (C) 1987 Free Software Foundation, Inc.\" (or with\n\
+    the year updated if appropriate), saying that there\n\
+    is no warranty (or else, saying that you provide\n\
+    a warranty) and that users may redistribute the program under\n\
+    these conditions, and telling the user how to view a copy of\n\
+    this License Agreement.\n\
+\n\
+    d) You may charge a distribution fee for the physical act of\n\
+    transferring a copy, and you may at your option offer warranty\n\
+    protection in exchange for a fee.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  3. You may copy and distribute GDB or any portion of it in\n\
+compiled, executable or object code form under the terms of Paragraphs\n\
+1 and 2 above provided that you do the following:\n\
+\n\
+    a) cause each such copy to be accompanied by the\n\
+    corresponding machine-readable source code, which must\n\
+    be distributed under the terms of Paragraphs 1 and 2 above; or,\n\
+\n\
+    b) cause each such copy to be accompanied by a\n\
+    written offer, with no time limit, to give any third party\n\
+    free (except for a nominal shipping charge) a machine readable\n\
+    copy of the corresponding source code, to be distributed\n\
+    under the terms of Paragraphs 1 and 2 above; or,\n\n");
+
+  printf ("\
+    c) in the case of a recipient of GDB in compiled, executable\n\
+    or object code form (without the corresponding source code) you\n\
+    shall cause copies you distribute to be accompanied by a copy\n\
+    of the written offer of source code which you received along\n\
+    with the copy you received.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  4. You may not copy, sublicense, distribute or transfer GDB\n\
+except as expressly provided under this License Agreement.  Any attempt\n\
+otherwise to copy, sublicense, distribute or transfer GDB is void and\n\
+your rights to use the program under this License agreement shall be\n\
+automatically terminated.  However, parties who have received computer\n\
+software programs from you with this License Agreement will not have\n\
+their licenses terminated so long as such parties remain in full compliance.\n\
+\n\
+  5. If you wish to incorporate parts of GDB into other free\n\
+programs whose distribution conditions are different, write to the Free\n\
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet\n\
+worked out a simple rule that can be stated here, but we will often permit\n\
+this.  We will be guided by the two goals of preserving the free status of\n\
+all derivatives of our free software and of promoting the sharing and reuse\n\
+of software.\n\
+\n\
+In other words, go ahead and share GDB, but don't try to stop\n\
+anyone else from sharing it farther.  Help stamp out software hoarding!\n\
+");
+  immediate_quit--;
+}
+
+static void
+warranty_info ()
+{
+  immediate_quit++;
+  printf ("			 NO WARRANTY\n\
+\n\
+  BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO\n\
+WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT\n\
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,\n\
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB \"AS IS\" WITHOUT\n\
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT\n\
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\
+A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND\n\
+PERFORMANCE OF GDB IS WITH YOU.  SHOULD GDB PROVE DEFECTIVE, YOU\n\
+ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n");
+
+  printf ("\
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.\n\
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY\n\
+WHO MAY MODIFY AND REDISTRIBUTE GDB, BE LIABLE TO\n\
+YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER\n\
+SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR\n\
+INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA\n\
+BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A\n\
+FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN\n\
+IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR\n\
+ANY CLAIM BY ANY OTHER PARTY.\n");
+  immediate_quit--;
+}
+
+static void
+print_gdb_version ()
+{
+  printf ("GDB %s, Copyright (C) 1987 Free Software Foundation, Inc.\n\
+There is ABSOLUTELY NO WARRANTY for GDB; type \"info warranty\" for details.\n\
+GDB is free software and you are welcome to distribute copies of it\n\
+ under certain conditions; type \"info copying\" to see the conditions.\n",
+	  version);
+}
+
+static void
+version_info ()
+{
+  immediate_quit++;
+  print_gdb_version ();
+  immediate_quit--;
+}
+
+static void
+set_prompt_command (text)
+     char *text;
+{
+  char *p, *q;
+  register int c;
+  char *new;
+
+  if (text == 0)
+    error_no_arg ("string to which to set prompt");
+
+  new = (char *) xmalloc (strlen (text) + 2);
+  p = text; q = new;
+  while (c = *p++)
+    {
+      if (c == '\\')
+	{
+	  /* \ at end of argument is used after spaces
+	     so they won't be lost.  */
+	  if (*p == 0)
+	    break;
+	  c = parse_escape (&p);
+	  if (c == 0)
+	    break; /* C loses */
+	  else if (c > 0)
+	    *q++ = c;
+	}
+      else
+	*q++ = c;
+    }
+  if (*(p - 1) != '\\')
+    *q++ = ' ';
+  *q++ = '\0';
+  new = (char *) xrealloc (new, q - new);
+  free (prompt);
+  prompt = new;
+}
+
+static void
+quit_command ()
+{
+  if (have_inferior_p ())
+    {
+      if (query ("The program is running.  Quit anyway? "))
+	{
+	  /* Prevent any warning message from reopen_exec_file, in case
+	     we have a core file that's inconsistent with the exec file.  */
+	  exec_file_command (0, 0);
+	  kill_inferior ();
+	}
+      else
+	error ("Not confirmed.");
+    }
+  exit (0);
+}
+
+int
+input_from_terminal_p ()
+{
+  return instream == stdin;
+}
+
+static void
+pwd_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  char buf[MAXPATHLEN];
+  if (arg) error ("The \"pwd\" command does not take an argument: %s", arg);
+  printf ("Working directory %s.\n", getwd (buf));
+}
+
+static void
+cd_command (dir, from_tty)
+     char *dir;
+     int from_tty;
+{
+  if (dir == 0)
+    error_no_arg ("new working directory");
+
+  if (chdir (dir) < 0)
+    perror_with_name (dir);
+  if (from_tty)
+    pwd_command ((char *) 0, 1);
+}
+
+
+/* Clean up on error during a "source" command.
+   Close the file opened by the command
+   and restore the previous input stream.  */
+
+static void
+source_cleanup (stream)
+     FILE *stream;
+{
+  fclose (instream);
+  instream = stream;
+}
+
+static void
+source_command (file)
+     char *file;
+{
+  FILE *stream;
+  struct cleanup *cleanups;
+
+  if (file == 0)
+    error_no_arg ("file to read commands from");
+
+  stream = fopen (file, "r");
+  if (stream == 0)
+    perror_with_name (file);
+
+  cleanups = make_cleanup (source_cleanup, instream);
+
+  instream = stream;
+
+  command_loop ();
+
+  do_cleanups (cleanups);
+}
+
+static void
+echo_command (text)
+     char *text;
+{
+  char *p = text;
+  register int c;
+
+  if (text)
+    while (c = *p++)
+      {
+	if (c == '\\')
+	  {
+	    /* \ at end of argument is used after spaces
+	       so they won't be lost.  */
+	    if (*p == 0)
+	      return;
+
+	    c = parse_escape (&p);
+	    if (c >= 0)
+	      fputc (c, stdout);
+	  }
+	else
+	  fputc (c, stdout);
+      }
+}
+
+static void
+dump_me_command ()
+{
+  if (query ("Should GDB dump core? "))
+    {
+      signal (SIGQUIT, SIG_DFL);
+      kill (getpid (), SIGQUIT);
+    }
+}
+
+
+static void
+initialize_main ()
+{
+  prompt = savestring ("(gdb) ", 6);
+
+  /* Define the classes of commands.
+     They will appear in the help list in the reverse of this order.  */
+
+  add_cmd ("obscure", class_obscure, 0, "Obscure features.", &cmdlist);
+  add_cmd ("alias", class_alias, 0, "Aliases of other commands.", &cmdlist);
+  add_cmd ("user", class_user, 0, "User-defined commands.\n\
+The commands in this class are those defined by the user.\n\
+Use the \"define\" command to define a command.", &cmdlist);
+  add_cmd ("support", class_support, 0, "Support facilities.", &cmdlist);
+  add_cmd ("status", class_info, 0, "Status inquiries.", &cmdlist);
+  add_cmd ("files", class_files, 0, "Specifying and examining files.", &cmdlist);
+  add_cmd ("breakpoints", class_breakpoint, 0, "Making program stop at certain points.", &cmdlist);
+  add_cmd ("data", class_vars, 0, "Examining data.", &cmdlist);
+  add_cmd ("stack", class_stack, 0, "Examining the stack.\n\
+The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
+counting from zero for the innermost (currently executing) frame.\n\n\
+At any time gdb identifies one frame as the \"selected\" frame.\n\
+Variable lookups are done with respect to the selected frame.\n\
+When the program being debugged stops, gdb selects the innermost frame.\n\
+The commands below can be used to select other frames by number or address.",
+	   &cmdlist);
+  add_cmd ("running", class_run, 0, "Running the program.", &cmdlist);
+
+  add_com ("pwd", class_files, pwd_command,
+	   "Print working directory.  This is used for your program as well.");
+  add_com ("cd", class_files, cd_command,
+	   "Set working directory to DIR for debugger and program being debugged.\n\
+The change does not take effect for the program being debugged\n\
+until the next time it is started.");
+
+  add_com ("set-prompt", class_support, set_prompt_command,
+	   "Change gdb's prompt from the default of \"(gdb)\"");
+  add_com ("echo", class_support, echo_command,
+	   "Print a constant string.  Give string as argument.\n\
+C escape sequences may be used in the argument.\n\
+No newline is added at the end of the argument;\n\
+use \"\\n\" if you want a newline to be printed.\n\
+Since leading and trailing whitespace are ignored in command arguments,\n\
+if you want to print some you must use \"\\\" before leading whitespace\n\
+to be printed or after trailing whitespace.");
+  add_com ("document", class_support, document_command,
+	   "Document a user-defined command.\n\
+Give command name as argument.  Give documentation on following lines.\n\
+End with a line of just \"end\".");
+  add_com ("define", class_support, define_command,
+	   "Define a new command name.  Command name is argument.\n\
+Definition appears on following lines, one command per line.\n\
+End with a line of just \"end\".\n\
+Use the \"document\" command to give documentation for the new command.\n\
+Commands defined in this way do not take arguments.");
+
+  add_com ("source", class_support, source_command,
+	   "Read commands from a file named FILE.\n\
+Note that the file \".gdbinit\" is read automatically in this way\n\
+when gdb is started.");
+  add_com ("quit", class_support, quit_command, "Exit gdb.");
+  add_com ("help", class_support, help_command, "Print list of commands.");
+  add_com_alias ("q", "quit", class_support, 1);
+  add_com_alias ("h", "help", class_support, 1);
+
+  add_com ("dump-me", class_obscure, dump_me_command,
+	   "Get fatal error; make debugger dump its core.");
+
+  add_prefix_cmd ("info", class_info, info_command,
+		  "Generic command for printing status.",
+		  &infolist, "info ", 0, &cmdlist);
+  add_com_alias ("i", "info", class_info, 1);
+
+  add_info ("copying", copying_info, "Conditions for redistributing copies of GDB.");
+  add_info ("warranty", warranty_info, "Various kinds of warranty you do not have.");
+  add_info ("version", version_info, "Report what version of GDB this is.");
+}
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d21 1
+@
diff --git a/gdb/RCS/source.c,v b/gdb/RCS/source.c,v
new file mode 100644
index 0000000..bd3218b
--- /dev/null
+++ b/gdb/RCS/source.c,v
@@ -0,0 +1,705 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.09.34;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.04.30.11;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS development sources on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Add <sys/types.h>
+@
+text
+@/* List lines of source files for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+
+/* Path of directories to search for source files.
+   Same format as the PATH environment variable's value.  */
+
+static char *source_path;
+
+/* Symtab of default file for listing lines of.  */
+
+struct symtab *current_source_symtab;
+
+/* Default next line to list.  */
+
+int current_source_line;
+
+/* Line for "info line" to work on if no line specified.  */
+
+static int line_info_default_line;
+
+/* First line number listed by last listing command.  */
+
+static int first_line_listed;
+
+START_FILE
+
+/* Set the source file default for the "list" command,
+   specifying a symtab.  */
+
+void
+select_source_symtab (s)
+     register struct symtab *s;
+{
+  if (s)
+    {
+      struct symtab_and_line sal;
+
+      /* Make the default place to list be the function `main'
+	 if one exists.  */
+      if (lookup_symbol ("main", 0, VAR_NAMESPACE))
+	{
+	  sal = decode_line_spec ("main", 1);
+	  current_source_symtab = sal.symtab;
+	  current_source_line = sal.line - 9;
+	  return;
+	}
+
+      /* If there is no `main', use the last symtab in the list,
+	 which is actually the first found in the file's symbol table.
+	 But ignore .h files.  */
+      do
+	{
+	  char *name = s->filename;
+	  int len = strlen (name);
+	  if (! (len > 2 && !strcmp (&name[len - 2], ".h")))
+	    current_source_symtab = s;
+	  s = s->next;
+	}
+      while (s);
+      current_source_line = 1;
+    }
+}
+
+static void
+directories_info ()
+{
+  printf ("Source directories searched: %s\n", source_path);
+}
+
+static void
+init_source_path ()
+{
+  register struct symtab *s;
+  char wd[MAXPATHLEN];
+  if (getwd (wd) == NULL)
+    perror_with_name ("getwd");
+
+  source_path = savestring (wd, strlen (wd));
+
+  /* Forget what we learned about line positions in source files;
+     must check again now since files may be found in
+     a different directory now.  */
+  for (s = symtab_list; s; s = s->next)
+    if (s->line_charpos != 0)
+      {
+	free (s->line_charpos);
+	s->line_charpos = 0;
+      }
+}
+
+void
+directory_command (dirname, from_tty)
+     char *dirname;
+     int from_tty;
+{
+  char *old = source_path;
+
+  char wd[MAXPATHLEN];
+  if (getwd (wd) == NULL)
+    perror_with_name ("getwd");
+
+  if (dirname == 0)
+    {
+      if (query ("Reinitialize source path to %s? ", wd))
+	{
+	  init_source_path ();
+	  free (old);
+	}
+    }
+  else
+    {
+      struct stat st;
+      register int len = strlen (dirname);
+      register char *tem;
+      extern char *index ();
+
+      if (index (dirname, ':'))
+	error ("Please add one directory at a time to the source path.");
+      if (dirname[len - 1] == '/')
+	  /* Sigh. "foo/" => "foo" */
+	  dirname[--len] == '\0';
+
+      while (dirname[len - 1] == '.')
+	{
+	  if (len == 1)
+	    {
+	      /* "." => getwd () */
+	      dirname = wd;
+	      goto append;
+	    }
+	  else if (dirname[len - 2] == '/')
+	    {
+	      if (len == 2)
+		{
+		  /* "/." => "/" */
+		  dirname[--len] = '\0';
+		  goto append;
+		}
+	      else
+		{
+		  /* "...foo/." => "...foo" */
+		  dirname[len -= 2] = '\0';
+		  continue;
+		}
+	    }
+	  break;
+	}
+
+      if (dirname[0] != '/')
+	dirname = concat (wd, "/", dirname);
+      else
+	dirname = savestring (dirname, len);
+      make_cleanup (free, dirname);
+
+      if (stat (dirname, &st) < 0)
+	perror_with_name (dirname);
+      if ((st.st_mode & S_IFMT) != S_IFDIR)
+	error ("%s is not a directory.", dirname);
+
+    append:
+      len = strlen (dirname);
+      tem = source_path;
+      while (1)
+	{
+	  if (!strncmp (tem, dirname, len)
+	      && (tem[len] == '\0' || tem[len] == ':'))
+	    {
+	      printf ("\"%s\" is already in the source path.\n",
+		      dirname);
+	      break;
+	    }
+	  tem = index (tem, ':');
+	  if (tem)
+	    tem++;
+	  else
+	    {
+	      source_path = concat (old, ":", dirname);
+	      free (old);
+	      break;
+	    }
+	}
+      if (from_tty)
+	directories_info ();
+    }
+}
+
+/* Open a file named STRING, searching path PATH (dir names sep by colons)
+   using mode MODE and protection bits PROT in the calls to open.
+   If TRY_CWD_FIRST, try to open ./STRING before searching PATH.
+   (ie pretend the first element of PATH is ".")
+   If FILENAMED_OPENED is non-null, set it to a newly allocated string naming
+   the actual file opened (this string will always start with a "/"
+
+   If a file is found, return the descriptor.
+   Otherwise, return -1, with errno set for the last name we tried to open.  */
+
+/*  >>>> This should only allow files of certain types,
+    >>>>  eg executable, non-directory */
+int
+openp (path, try_cwd_first, string, mode, prot, filename_opened)
+     char *path;
+     int try_cwd_first;
+     char *string;
+     int mode;
+     int prot;
+     char **filename_opened;
+{
+  register int fd;
+  register char *filename;
+  register char *p, *p1;
+  register int len;
+
+  /* ./foo => foo */
+  while (string[0] == '.' && string[1] == '/')
+    string += 2;
+
+  if (try_cwd_first || string[0] == '/')
+    {
+      filename = string;
+      fd = open (filename, mode, prot);
+      if (fd >= 0 || string[0] == '/')
+	goto done;
+    }
+
+  filename = (char *) alloca (strlen (path) + strlen (string) + 2);
+  fd = -1;
+  for (p = path; p; p = p1 ? p1 + 1 : 0)
+    {
+      p1 = (char *) index (p, ':');
+      if (p1)
+	len = p1 - p;
+      else
+	len = strlen (p);
+
+      strncpy (filename, p, len);
+      filename[len] = 0;
+      strcat (filename, "/");
+      strcat (filename, string);
+
+      fd = open (filename, mode, prot);
+      if (fd >= 0) break;
+    }
+
+ done:
+  if (filename_opened)
+    if (fd < 0)
+      *filename_opened = (char *) 0;
+    else if (filename[0] == '/')
+      *filename_opened = savestring (filename, strlen (filename));
+    else
+      {
+	char dirname[MAXPATHLEN];
+	if (getwd (dirname) == NULL)
+	  perror_with_name ("getwd");
+	*filename_opened = concat (dirname, "/", filename);
+      }
+
+  return fd;
+}
+
+/* Create and initialize the table S->line_charpos that records
+   the positions of the lines in the source file, which is assumed
+   to be open on descriptor DESC.
+   All set S->nlines to the number of such lines.  */
+
+static void
+find_source_lines (s, desc)
+     struct symtab *s;
+     int desc;
+{
+  struct stat st;
+  register char *data, *p, *end;
+  int nlines = 0;
+  int lines_allocated = 1000;
+  int *line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
+  extern int exec_mtime;
+
+  fstat (desc, &st);
+  if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
+    printf ("Source file is more recent than executable.\n");
+
+  data = (char *) alloca (st.st_size);
+  myread (desc, data, st.st_size);
+  end = data + st.st_size;
+  p = data;
+  line_charpos[0] = 0;
+  nlines = 1;
+  while (p != end)
+    {
+      if (*p++ == '\n')
+	{
+	  if (nlines == lines_allocated)
+	    line_charpos = (int *) xrealloc (line_charpos,
+					     sizeof (int) * (lines_allocated *= 2));
+	  line_charpos[nlines++] = p - data;
+	}
+    }
+  s->nlines = nlines;
+  s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
+}
+
+/* Return the character position of a line LINE in symtab S.
+   Return 0 if anything is invalid.  */
+
+int
+source_line_charpos (s, line)
+     struct symtab *s;
+     int line;
+{
+  if (!s) return 0;
+  if (!s->line_charpos || line <= 0) return 0;
+  if (line > s->nlines)
+    line = s->nlines;
+  return s->line_charpos[line - 1];
+}
+
+/* Return the line number of character position POS in symtab S.  */
+
+int
+source_charpos_line (s, chr)
+    register struct symtab *s;
+    register int chr;
+{
+  register int line = 0;
+  register int *lnp;
+    
+  if (s == 0 || s->line_charpos == 0) return 0;
+  lnp = s->line_charpos;
+  /* Files are usually short, so sequential search is Ok */
+  while (line < s->nlines  && *lnp <= chr)
+    {
+      line++;
+      lnp++;
+    }
+  if (line >= s->nlines)
+    line = s->nlines;
+  return line;
+}
+
+/* Get full pathname and line number positions for a symtab.
+   Return nonzero if line numbers may have changed.
+   Set *FULLNAME to actual name of the file as found by `openp',
+   or to 0 if the file is not found.  */
+
+int
+get_filename_and_charpos (s, line, fullname)
+     struct symtab *s;
+     int line;
+     char **fullname;
+{
+  register int desc, linenums_changed = 0;
+  
+  desc = openp (source_path, 0, s->filename, O_RDONLY, 0, fullname);
+  if (desc < 0)
+    {
+      *fullname = NULL;
+      return 0;
+    }  
+  if (s->line_charpos == 0) linenums_changed = 1;
+  if (linenums_changed) find_source_lines (s, desc);
+  close (desc);
+  return linenums_changed;
+}
+
+/* Print source lines from the file of symtab S,
+   starting with line number LINE and stopping before line number STOPLINE.  */
+
+void
+print_source_lines (s, line, stopline)
+     struct symtab *s;
+     int line, stopline;
+{
+  register int c;
+  register int desc;
+  register FILE *stream;
+  int nlines = stopline - line;
+
+  desc = openp (source_path, 0, s->filename, O_RDONLY, 0, (char **) 0);
+  if (desc < 0)
+    perror_with_name (s->filename);
+
+  if (s->line_charpos == 0)
+    find_source_lines (s, desc);
+
+  if (line < 1 || line >= s->nlines)
+    {
+      close (desc);
+      error ("Line number out of range; %s has %d lines.",
+	     s->filename, s->nlines);
+    }
+
+  if (lseek (desc, s->line_charpos[line - 1], 0) < 0)
+    {
+      close (desc);
+      perror_with_name (s->filename);
+    }
+
+  current_source_symtab = s;
+  current_source_line = line;
+  first_line_listed = line;
+  
+  stream = fdopen (desc, "r");
+  clearerr (stream);
+
+  while (nlines-- > 0)
+    {
+      c = fgetc (stream);
+      if (c == EOF) break;
+      line_info_default_line = current_source_line;
+      printf ("%d\t", current_source_line++);
+      do
+	{
+	  if (c < 040 && c != '\t' && c != '\n')
+	    {
+	      fputc ('^', stdout);
+	      fputc (c + 0100, stdout);
+	    }
+	  else if (c == 0177)
+	    printf ("^?");
+	  else
+	    fputc (c, stdout);
+	} while (c != '\n' && (c = fgetc (stream)) >= 0);
+    }
+
+  fclose (stream);
+}
+
+static void
+list_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal, sal_end;
+  struct symbol *sym;
+  char *arg1;
+  int no_end = 1;
+  int dummy_end = 0;
+  int dummy_beg = 0;
+  int linenum_beg = 0;
+  char *p;
+
+  if (symtab_list == 0)
+    error ("Listing source lines requires symbols.");
+
+  /* "l" or "l +" lists next ten lines.  */
+
+  if (arg == 0 || !strcmp (arg, "+"))
+    {
+      if (current_source_symtab == 0)
+	error ("No default source file yet.  Do \"help list\".");
+      print_source_lines (current_source_symtab, current_source_line,
+			  current_source_line + 10);
+      return;
+    }
+
+  /* "l -" lists previous ten lines, the ones before the ten just listed.  */
+  if (!strcmp (arg, "-"))
+    {
+      if (current_source_symtab == 0)
+	error ("No default source file yet.  Do \"help list\".");
+      print_source_lines (current_source_symtab,
+			  max (first_line_listed - 10, 1),
+			  first_line_listed);
+      return;
+    }
+
+  /* Now if there is only one argument, decode it in SAL
+     and set NO_END.
+     If there are two arguments, decode them in SAL and SAL_END
+     and clear NO_END; however, if one of the arguments is blank,
+     set DUMMY_BEG or DUMMY_END to record that fact.  */
+
+  arg1 = arg;
+  if (*arg1 == ',')
+    dummy_beg = 1;
+  else
+    sal = decode_line_1 (&arg1, 0, 0, 0);
+
+  /* Record whether the BEG arg is all digits.  */
+
+  for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
+  linenum_beg = (p == arg1);
+
+  while (*arg1 == ' ' || *arg1 == '\t')
+    arg1++;
+  if (*arg1 == ',')
+    {
+      no_end = 0;
+      arg1++;
+      while (*arg1 == ' ' || *arg1 == '\t')
+	arg1++;
+      if (*arg1 == 0)
+	dummy_end = 1;
+      else if (dummy_beg)
+	sal_end = decode_line_1 (&arg1, 0, 0, 0);
+      else
+	sal_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line);
+    }
+
+  if (*arg1)
+    error ("Junk at end of line specification.");
+
+  if (!no_end && !dummy_beg && !dummy_end
+      && sal.symtab != sal_end.symtab)
+    error ("Specified start and end are in different files.");
+  if (dummy_beg && dummy_end)
+    error ("Two empty args do not say what lines to list.");
+ 
+  /* if line was specified by address,
+     first print exactly which line, and which file.
+     In this case, sal.symtab == 0 means address is outside
+     of all known source files, not that user failed to give a filename.  */
+  if (*arg == '*')
+    {
+      if (sal.symtab == 0)
+	error ("No source file for address 0x%x.", sal.pc);
+      sym = find_pc_function (sal.pc);
+      if (sym)
+	printf ("0x%x is in %s (%s, line %d).\n",
+		sal.pc, SYMBOL_NAME (sym), sal.symtab->filename, sal.line);
+      else
+	printf ("0x%x is in %s, line %d.\n",
+		sal.pc, sal.symtab->filename, sal.line);
+    }
+
+  /* If line was not specified by just a line number,
+     and it does not imply a symtab, it must be an undebuggable symbol
+     which means no source code.  */
+
+  if (! linenum_beg && sal.symtab == 0)
+    error ("No line number known for %s.", arg);
+
+  /* If this command is repeated with RET,
+     turn it into the no-arg variant.  */
+
+  if (from_tty)
+    *arg = 0;
+
+  if (dummy_beg && sal_end.symtab == 0)
+    error ("No default source file yet.  Do \"help list\".");
+  if (dummy_beg)
+    print_source_lines (sal_end.symtab, max (sal_end.line - 9, 1),
+			sal_end.line + 1);
+  else if (sal.symtab == 0)
+    error ("No default source file yet.  Do \"help list\".");
+  else if (no_end)
+    print_source_lines (sal.symtab, max (sal.line - 5, 1), sal.line + 5);
+  else
+    print_source_lines (sal.symtab, sal.line,
+			dummy_end ? sal.line + 10 : sal_end.line + 1);
+}
+
+/* Print info on range of pc's in a specified line.  */
+
+static void
+line_info (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal;
+  int start_pc, end_pc;
+
+  if (arg == 0)
+    {
+      sal.symtab = current_source_symtab;
+      sal.line = line_info_default_line;
+    }
+  else
+    {
+      sal = decode_line_spec (arg);
+
+      /* If this command is repeated with RET,
+	 turn it into the no-arg variant.  */
+
+      if (from_tty)
+	*arg = 0;
+    }
+
+  if (sal.symtab == 0)
+    error ("No source file specified.");
+  if (sal.line > 0
+      && find_line_pc_range (sal.symtab, sal.line, &start_pc, &end_pc))
+    {
+      if (start_pc == end_pc)
+	printf ("Line %d of \"%s\" is at pc 0x%x but contains no code.\n",
+		sal.line, sal.symtab->filename, start_pc);
+      else
+	printf ("Line %d of \"%s\" starts at pc 0x%x and ends at 0x%x.\n",
+		sal.line, sal.symtab->filename, start_pc, end_pc);
+      /* x/i should display this line's code.  */
+      set_next_address (start_pc);
+      /* Repeating "info line" should do the following line.  */
+      line_info_default_line = sal.line + 1;
+    }
+  else
+    printf ("Line number %d is out of range for \"%s\".\n",
+	    sal.line, sal.symtab->filename);
+}
+
+static
+initialize ()
+{
+  current_source_symtab = 0;
+  init_source_path ();
+
+  add_com ("directory", class_files, directory_command,
+	   "Add directory DIR to end of search path for source files.\n\
+With no argument, reset the search path to just the working directory\n\
+and forget cached info on line positions in source files.");
+
+  add_info ("directories", directories_info,
+	    "Current search path for finding source files.");
+
+  add_info ("line", line_info,
+	    "Core addresses of the code for a source line.\n\
+Line can be specified as\n\
+  LINENUM, to list around that line in current file,\n\
+  FILE:LINENUM, to list around that line in that file,\n\
+  FUNCTION, to list around beginning of that function,\n\
+  FILE:FUNCTION, to distinguish among like-named static functions.\n\
+Default is to describe the last source line that was listed.\n\n\
+This sets the default address for \"x\" to the line's first instruction\n\
+so that \"x/i\" suffices to start examining the machine code.\n\
+The address is also stored as the value of \"$_\".");
+
+  add_com ("list", class_files, list_command,
+	   "List specified function or line.\n\
+With no argument, lists ten more lines after or around previous listing.\n\
+\"list -\" lists the ten lines before a previous ten-line listing.\n\
+One argument specifies a line, and ten lines are listed around that line.\n\
+Two arguments with comma between specify starting and ending lines to list.\n\
+Lines can be specified in these ways:\n\
+  LINENUM, to list around that line in current file,\n\
+  FILE:LINENUM, to list around that line in that file,\n\
+  FUNCTION, to list around beginning of that function,\n\
+  FILE:FUNCTION, to distinguish among like-named static functions.\n\
+  *ADDRESS, to list around the line containing that address.\n\
+With two args if one is empty it stands for ten lines away from the other arg.");
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d22 1
+@
diff --git a/gdb/RCS/symmisc.c,v b/gdb/RCS/symmisc.c,v
new file mode 100644
index 0000000..42653dfb
--- /dev/null
+++ b/gdb/RCS/symmisc.c,v
@@ -0,0 +1,575 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.09.53;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.04.25.22;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS's devl sources on wheaties
+@
+
+
+1.2
+log
+@Check for null pointer passed to free()...
+@
+text
+@/* Do various things to symbol tables (other than lookup)), for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+
+#include <stdio.h>
+#include <obstack.h>
+
+static void free_symtab ();
+
+START_FILE
+
+/* Free all the symtabs that are currently installed,
+   and all storage associated with them.
+   Leaves us in a consistent state with no symtabs installed.  */
+
+void
+free_all_symtabs ()
+{
+  register struct symtab *s, *snext;
+
+  /* All values will be invalid because their types will be!  */
+
+  clear_value_history ();
+  clear_displays ();
+  clear_internalvars ();
+  clear_breakpoints ();
+  set_default_breakpoint (0, 0, 0, 0);
+
+  current_source_symtab = 0;
+
+  for (s = symtab_list; s; s = snext)
+    {
+      snext = s->next;
+      free_symtab (s);
+    }
+  symtab_list = 0;
+  obstack_free (symbol_obstack, 0);
+  obstack_init (symbol_obstack);
+
+  if (misc_function_vector)
+    free (misc_function_vector);
+  misc_function_count = 0;
+  misc_function_vector = 0;
+}
+
+/* Free a struct block <- B and all the symbols defined in that block.  */
+
+static void
+free_symtab_block (b)
+     struct block *b;
+{
+  register int i, n;
+  n = BLOCK_NSYMS (b);
+  for (i = 0; i < n; i++)
+    {
+      free (SYMBOL_NAME (BLOCK_SYM (b, i)));
+      free (BLOCK_SYM (b, i));
+    }
+  free (b);
+}
+
+/* Free all the storage associated with the struct symtab <- S.
+   Note that some symtabs have contents malloc'ed structure by structure,
+   while some have contents that all live inside one big block of memory,
+   and some share the contents of another symbol table and so you should
+   not free the contents on their behalf (except sometimes the linetable,
+   which maybe per symtab even when the rest is not).
+   It is s->free_code that says which alternative to use.  */
+
+static void
+free_symtab (s)
+     register struct symtab *s;
+{
+  register int i, n;
+  register struct blockvector *bv;
+  register struct type *type;
+  register struct typevector *tv;
+
+  switch (s->free_code)
+    {
+    case free_nothing:
+      /* All the contents are part of a big block of memory
+	 and some other symtab is in charge of freeing that block.
+	 Therefore, do nothing.  */
+      break;
+
+    case free_explicit:
+      /* All the contents are part of a big block of memory
+	 and that is our `free_ptr' and will be freed below.  */
+      break;
+
+    case free_contents:
+      /* Here all the contents were malloc'ed structure by structure
+	 and must be freed that way.  */
+      /* First free the blocks (and their symbols.  */
+      bv = BLOCKVECTOR (s);
+      n = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < n; i++)
+	free_symtab_block (BLOCKVECTOR_BLOCK (bv, i));
+      /* Free the blockvector itself.  */
+      free (bv);
+      /* Free the type vector.  */
+      tv = TYPEVECTOR (s);
+      if (tv)		/* FIXME, should this happen?  It does... */
+	free (tv);
+      /* Also free the linetable.  */
+      
+    case free_linetable:
+      /* Everything will be freed either by our `free_ptr'
+	 or by some other symbatb, except for our linetable.
+	 Free that now.  */
+      free (LINETABLE (s));
+      break;
+    }
+
+  /* If there is a single block of memory to free, free it.  */
+  if (s->free_ptr)
+    free (s->free_ptr);
+
+  if (s->line_charpos)
+    free (s->line_charpos);
+  free (s->filename);
+  free (s);
+}
+
+/* Convert a raw symbol-segment to a struct symtab,
+   and relocate its internal pointers so that it is valid.  */
+
+/* This is how to relocate one pointer, given a name for it.
+   Works independent of the type of object pointed to.  */
+#define RELOCATE(slot) (slot ? (* (char **) &slot += relocation) : 0)
+
+/* This is the inverse of RELOCATE.  We use it when storing
+   a core address into a slot that has yet to be relocated.  */
+#define UNRELOCATE(slot) (slot ? (* (char **) &slot -= relocation) : 0)
+
+/* During the process of relocation, this holds the amount to relocate by
+   (the address of the file's symtab data, in core in the debugger).  */
+static int relocation;
+
+#define CORE_RELOCATE(slot) \
+  ((slot) += (((slot) < data_start) ? text_relocation		\
+	      : ((slot) < bss_start) ? data_relocation : bss_relocation))
+
+#define TEXT_RELOCATE(slot)  ((slot) += text_relocation)
+
+/* Relocation amounts for addresses in the program's core image.  */
+static int text_relocation, data_relocation, bss_relocation;
+
+/* Boundaries that divide program core addresses into text, data and bss;
+   used to determine which relocation amount to use.  */
+static int data_start, bss_start;
+
+static void relocate_typevector ();
+static void relocate_blockvector ();
+static void relocate_type ();
+static void relocate_block ();
+static void relocate_symbol ();
+
+/* Relocate a file symbol table so that all the pointers
+   are valid C pointers.  Pass the struct symtab for the file
+   and the amount to relocate by.  */
+
+static struct symtab *
+relocate_symtab (root)
+     struct symbol_root *root;
+{
+  struct symtab *sp = (struct symtab *) xmalloc (sizeof (struct symtab));
+  bzero (sp, sizeof (struct symtab));
+
+  relocation = (int) root;
+  text_relocation = root->textrel;
+  data_relocation = root->datarel;
+  bss_relocation = root->bssrel;
+  data_start = root->databeg;
+  bss_start = root->bssbeg;
+
+  sp->filename = root->filename;
+  sp->ldsymoff = root->ldsymoff;
+  sp->language = root->language;
+  sp->compilation = root->compilation;
+  sp->version = root->version;
+  sp->blockvector = root->blockvector;
+  sp->typevector = root->typevector;
+  sp->free_code = free_explicit;
+  sp->free_ptr = (char *) root;
+
+  RELOCATE (TYPEVECTOR (sp));
+  RELOCATE (BLOCKVECTOR (sp));
+  RELOCATE (sp->version);
+  RELOCATE (sp->compilation);
+  RELOCATE (sp->filename);
+
+  relocate_typevector (TYPEVECTOR (sp));
+  relocate_blockvector (BLOCKVECTOR (sp));
+
+  return sp;
+}
+
+static void
+relocate_typevector (tv)
+     struct typevector *tv;
+{
+  register int ntypes = TYPEVECTOR_NTYPES (tv);
+  register int i;
+
+  for (i = 0; i < ntypes; i++)
+    RELOCATE (TYPEVECTOR_TYPE (tv, i));
+  for (i = 0; i < ntypes; i++)
+    relocate_type (TYPEVECTOR_TYPE (tv, i));
+}
+
+static void
+relocate_blockvector (blp)
+     register struct blockvector *blp;
+{
+  register int nblocks = BLOCKVECTOR_NBLOCKS (blp);
+  register int i;
+  for (i = 0; i < nblocks; i++)
+    RELOCATE (BLOCKVECTOR_BLOCK (blp, i));
+  for (i = 0; i < nblocks; i++)
+    relocate_block (BLOCKVECTOR_BLOCK (blp, i));
+}
+
+static void
+relocate_block (bp)
+     register struct block *bp;
+{
+  register int nsyms = BLOCK_NSYMS (bp);
+  register int i;
+
+  TEXT_RELOCATE (BLOCK_START (bp));
+  TEXT_RELOCATE (BLOCK_END (bp));
+
+  /* These two should not be recursively processed.
+     The superblock need not be because all blocks are
+     processed from relocate_blockvector.
+     The function need not be because it will be processed
+     under the block which is its scope.  */
+  RELOCATE (BLOCK_SUPERBLOCK (bp));
+  RELOCATE (BLOCK_FUNCTION (bp));
+
+  for (i = 0; i < nsyms; i++)
+    RELOCATE (BLOCK_SYM (bp, i));
+
+  for (i = 0; i < nsyms; i++)
+    relocate_symbol (BLOCK_SYM (bp, i));
+}
+
+static void
+relocate_symbol (sp)
+     register struct symbol *sp;
+{
+  RELOCATE (SYMBOL_NAME (sp));
+  if (SYMBOL_CLASS (sp) == LOC_BLOCK)
+    {
+      RELOCATE (SYMBOL_BLOCK_VALUE (sp));
+      /* We can assume the block that belongs to this symbol
+	 is not relocated yet, since it comes after
+	 the block that contains this symbol.  */
+      BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)) = sp;
+      UNRELOCATE (BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)));
+    }
+  else if (SYMBOL_CLASS (sp) == LOC_STATIC)
+    CORE_RELOCATE (SYMBOL_VALUE (sp));
+  else if (SYMBOL_CLASS (sp) == LOC_LABEL)
+    TEXT_RELOCATE (SYMBOL_VALUE (sp));
+  RELOCATE (SYMBOL_TYPE (sp));
+}
+
+/* We cannot come up with an a priori spanning tree
+   for the network of types, since types can be used
+   for many symbols and also as components of other types.
+   Therefore, we need to be able to mark types that we
+   already have relocated (or are already in the middle of relocating)
+   as in a garbage collector.  */
+
+static void
+relocate_type (tp)
+     register struct type *tp;
+{
+  register int nfields = TYPE_NFIELDS (tp);
+  register int i;
+
+  RELOCATE (TYPE_NAME (tp));
+  RELOCATE (TYPE_TARGET_TYPE (tp));
+  RELOCATE (TYPE_FIELDS (tp));
+  RELOCATE (TYPE_POINTER_TYPE (tp));
+
+  for (i = 0; i < nfields; i++)
+    {
+      RELOCATE (TYPE_FIELD_TYPE (tp, i));
+      RELOCATE (TYPE_FIELD_NAME (tp, i));
+    }
+}
+
+/* Read symsegs from file named NAME open on DESC,
+   make symtabs from them, and return a chain of them.
+   Assumes DESC is prepositioned at the end of the string table,
+   just before the symsegs if there are any.  */
+
+struct symtab *
+read_symsegs (desc, name)
+     int desc;
+     char *name;
+{
+  struct symbol_root root;
+  register char *data;
+  register struct symtab *sp, *chain = 0;
+  register int len;
+
+  while (1)
+    {
+      len = myread (desc, &root, sizeof root);
+      if (len == 0 || root.format == 0)
+	break;
+      if (root.format != 1 ||
+	  root.length < sizeof root)
+	error ("Invalid symbol segment format code");
+      data = (char *) xmalloc (root.length);
+      bcopy (&root, data, sizeof root);
+      len = myread (desc, data + sizeof root,
+		    root.length - sizeof root);
+      sp = relocate_symtab (data);
+      sp->next = chain;
+      chain = sp;
+    }
+
+  return chain;
+}
+
+static int block_depth ();
+static void print_spaces ();
+static void print_symbol ();
+
+print_symtabs (filename)
+     char *filename;
+{
+  FILE *outfile;
+  register struct symtab *s;
+  register int i, j;
+  int len, line, blen;
+  register struct linetable *l;
+  struct blockvector *bv;
+  register struct block *b;
+  int depth;
+  struct cleanup *cleanups;
+  extern int fclose();
+
+  if (filename == 0)
+    error_no_arg ("file to write symbol data in");
+  outfile = fopen (filename, "w");
+
+  cleanups = make_cleanup (fclose, outfile);
+  immediate_quit++;
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      /* First print the line table.  */
+      fprintf (outfile, "Symtab for file %s\n\n", s->filename);
+      fprintf (outfile, "Line table:\n\n");
+      l = LINETABLE (s);
+      len = l->nitems;
+      for (i = 0; i < len; i++)
+	{
+	  if (l->item[i] < 0)
+	    line = - l->item[i] - 1;
+	  else
+	    fprintf (outfile, " line %d at %x\n", ++line, l->item[i]);
+	}
+      /* Now print the block info.  */
+      fprintf (outfile, "\nBlockvector:\n\n");
+      bv = BLOCKVECTOR (s);
+      len = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < len; i++)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, i);
+	  depth = block_depth (b) * 2;
+	  print_spaces (depth, outfile);
+	  fprintf (outfile, "block #%03d (object 0x%x) ", i, b);
+	  fprintf (outfile, "[0x%x..0x%x]", BLOCK_START (b), BLOCK_END (b));
+	  if (BLOCK_SUPERBLOCK (b))
+	    fprintf (outfile, " (under 0x%x)", BLOCK_SUPERBLOCK (b));
+	  if (BLOCK_FUNCTION (b))
+	    fprintf (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
+	  fputc ('\n', outfile);
+	  blen = BLOCK_NSYMS (b);
+	  for (j = 0; j < blen; j++)
+	    {
+	      print_symbol (BLOCK_SYM (b, j), depth + 1, outfile);
+	    }
+	}
+
+      fprintf (outfile, "\n\n");
+    }
+
+  immediate_quit--;
+  do_cleanups (cleanups);
+}
+
+static void
+print_symbol (symbol, depth, outfile)
+     struct symbol *symbol;
+     int depth;
+     FILE *outfile;
+{
+  print_spaces (depth, outfile);
+  if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
+    {
+      fprintf (outfile, "label %s at 0x%x", SYMBOL_NAME (symbol),
+	       SYMBOL_VALUE (symbol));
+      return;
+    }
+  if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
+    {
+      if (TYPE_NAME (SYMBOL_TYPE (symbol)))
+	{
+	  type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+	}
+      else
+	{
+	  fprintf (outfile, "%s %s = ",
+	       (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
+		? "enum"
+		: (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
+		   ? "struct" : "union")),
+	       SYMBOL_NAME (symbol));
+	  type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+	}
+      fprintf (outfile, ";\n");
+    }
+  else
+    {
+      if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
+	fprintf (outfile, "typedef ");
+      if (SYMBOL_TYPE (symbol))
+	{
+	  type_print_1 (SYMBOL_TYPE (symbol), SYMBOL_NAME (symbol),
+			outfile, 1, depth);
+	  fprintf (outfile, "; ");
+	}
+      else
+	fprintf (outfile, "%s ", SYMBOL_NAME (symbol));
+
+      switch (SYMBOL_CLASS (symbol))
+	{
+	case LOC_CONST:
+	  fprintf (outfile, "const %d (0x%x),",
+		   SYMBOL_VALUE (symbol), SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_CONST_BYTES:
+	  fprintf (outfile, "const %d hex bytes:",
+		   TYPE_LENGTH (SYMBOL_TYPE (symbol)));
+	  {
+	    int i;
+	    for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
+	      fprintf (outfile, " %2x", SYMBOL_VALUE_BYTES (symbol) [i]);
+	    fprintf (outfile, ",");
+	  }
+	  break;
+
+	case LOC_STATIC:
+	  fprintf (outfile, "static at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_REGISTER:
+	  fprintf (outfile, "register %d,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_ARG:
+	  fprintf (outfile, "arg at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_LOCAL:
+	  fprintf (outfile, "local at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_TYPEDEF:
+	  break;
+
+	case LOC_LABEL:
+	  fprintf (outfile, "label at 0x%x", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_BLOCK:
+	  fprintf (outfile, "block (object 0x%x) starting at 0x%x,",
+		   SYMBOL_VALUE (symbol),
+		   BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)));
+	  break;
+	}
+    }
+  fprintf (outfile, "\n");
+}
+
+/* Return the nexting depth of a block within other blocks in its symtab.  */
+
+static int
+block_depth (block)
+     struct block *block;
+{
+  register int i = 0;
+  while (block = BLOCK_SUPERBLOCK (block)) i++;
+  return i;
+}
+
+static
+initialize ()
+{
+  add_com ("printsyms", class_obscure, print_symtabs,
+	   "Print dump of current symbol definitions to file OUTFILE.");
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d125 2
+a126 1
+      free (tv);
+@
diff --git a/gdb/RCS/symtab.c,v b/gdb/RCS/symtab.c,v
new file mode 100644
index 0000000..7ccdaac
--- /dev/null
+++ b/gdb/RCS/symtab.c,v
@@ -0,0 +1,1153 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.10.33;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.26.02.18.56;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@Original from RMS's wheaties devel sources
+@
+
+
+1.2
+log
+@Permit SYS V regular expression library as well as real Unix one.
+@
+text
+@/* Symbol table lookup for the GNU debugger, GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "param.h"
+
+#include <stdio.h>
+#include <obstack.h>
+
+#ifdef mac_aux
+#define REGCMP
+#endif
+
+START_FILE
+
+/* Allocate an obstack to hold objects that should be freed
+   when we load a new symbol table.
+   This includes the symbols made by dbxread
+   and the types that are not permanent.  */
+
+struct obstack obstack1;
+
+struct obstack *symbol_obstack = &obstack1;
+
+/* These variables point to the objects
+   representing the predefined C data types.  */
+
+struct type *builtin_type_void;
+struct type *builtin_type_char;
+struct type *builtin_type_short;
+struct type *builtin_type_int;
+struct type *builtin_type_long;
+struct type *builtin_type_unsigned_char;
+struct type *builtin_type_unsigned_short;
+struct type *builtin_type_unsigned_int;
+struct type *builtin_type_unsigned_long;
+struct type *builtin_type_float;
+struct type *builtin_type_double;
+
+/* Lookup the symbol table of a source file named NAME.  */
+
+struct symtab *
+lookup_symtab (name)
+     char *name;
+{
+  register struct symtab *s;
+  register char *copy;
+
+  for (s = symtab_list; s; s = s->next)
+    if (!strcmp (name, s->filename))
+      return s;
+
+  /* If name not found as specified, see if adding ".c" helps.  */
+
+  copy = (char *) alloca (strlen (name) + 3);
+  strcpy (copy, name);
+  strcat (copy, ".c");
+  for (s = symtab_list; s; s = s->next)
+    if (!strcmp (copy, s->filename))
+      return s;
+
+  return 0;
+}
+
+/* Lookup a typedef or primitive type named NAME,
+   visible in lexical block BLOCK.
+   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
+
+struct type *
+lookup_typename (name, block, noerr)
+     char *name;
+     struct block *block;
+     int noerr;
+{
+  register struct symbol *sym = lookup_symbol (name, block, VAR_NAMESPACE);
+  if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
+    {
+      if (!strcmp (name, "int"))
+	return builtin_type_int;
+      if (!strcmp (name, "long"))
+	return builtin_type_long;
+      if (!strcmp (name, "short"))
+	return builtin_type_short;
+      if (!strcmp (name, "char"))
+	return builtin_type_char;
+      if (!strcmp (name, "float"))
+	return builtin_type_float;
+      if (!strcmp (name, "double"))
+	return builtin_type_double;
+      if (!strcmp (name, "void"))
+	return builtin_type_void;
+
+      if (noerr)
+	return 0;
+      error ("No type named %s.", name);
+    }
+  return SYMBOL_TYPE (sym);
+}
+
+struct type *
+lookup_unsigned_typename (name)
+     char *name;
+{
+  if (!strcmp (name, "int"))
+    return builtin_type_unsigned_int;
+  if (!strcmp (name, "long"))
+    return builtin_type_unsigned_long;
+  if (!strcmp (name, "short"))
+    return builtin_type_unsigned_short;
+  if (!strcmp (name, "char"))
+    return builtin_type_unsigned_char;
+  error ("No type named unsigned %s.", name);
+}
+
+/* Lookup a structure type named "struct NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_struct (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No struct type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
+    error ("This context has union or enum %s, not a struct.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Lookup a union type named "union NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_union (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No union type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
+    error ("This context has struct or enum %s, not a union.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Lookup an enum type named "enum NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_enum (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No enum type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
+    error ("This context has struct or union %s, not an enum.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Given a type TYPE, return a type of pointers to that type.
+   May need to construct such a type if this is the first use.  */
+
+struct type *
+lookup_pointer_type (type)
+     struct type *type;
+{
+  register struct type *ptype = TYPE_POINTER_TYPE (type);
+  if (ptype) return ptype;
+
+  /* This is the first time anyone wanted a pointer to a TYPE.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    ptype  = (struct type *) xmalloc (sizeof (struct type));
+  else
+    ptype  = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+
+  bzero (ptype, sizeof (struct type));
+  TYPE_TARGET_TYPE (ptype) = type;
+  TYPE_POINTER_TYPE (type) = ptype;
+  /* New type is permanent if type pointed to is permanent.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
+  /* We assume the machine has only one representation for pointers!  */
+  TYPE_LENGTH (ptype) = sizeof (char *);
+  TYPE_CODE (ptype) = TYPE_CODE_PTR;
+  return ptype;
+}
+
+/* Given a type TYPE, return a type of functions that return that type.
+   May need to construct such a type if this is the first use.  */
+
+struct type *
+lookup_function_type (type)
+     struct type *type;
+{
+  register struct type *ptype = TYPE_FUNCTION_TYPE (type);
+  if (ptype) return ptype;
+
+  /* This is the first time anyone wanted a function returning a TYPE.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    ptype  = (struct type *) xmalloc (sizeof (struct type));
+  else
+    ptype  = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+
+  bzero (ptype, sizeof (struct type));
+  TYPE_TARGET_TYPE (ptype) = type;
+  TYPE_FUNCTION_TYPE (type) = ptype;
+  /* New type is permanent if type returned is permanent.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
+  TYPE_LENGTH (ptype) = 1;
+  TYPE_CODE (ptype) = TYPE_CODE_FUNC;
+  TYPE_NFIELDS (ptype) = 0;
+  return ptype;
+}
+
+/* Smash TYPE to be a type of pointers to TO_TYPE.
+   If TO_TYPE is not permanent and has no pointer-type yet,
+   record TYPE as its pointer-type.  */
+
+void
+smash_to_pointer_type (type, to_type)
+     struct type *type, *to_type;
+{
+  bzero (type, sizeof (struct type));
+  TYPE_TARGET_TYPE (type) = to_type;
+  /* We assume the machine has only one representation for pointers!  */
+  TYPE_LENGTH (type) = sizeof (char *);
+  TYPE_CODE (type) = TYPE_CODE_PTR;
+
+  if (TYPE_POINTER_TYPE (to_type) == 0
+      && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+    {
+      TYPE_POINTER_TYPE (to_type) = type;
+    }
+}
+
+/* Smash TYPE to be a type of functions returning TO_TYPE.
+   If TO_TYPE is not permanent and has no function-type yet,
+   record TYPE as its function-type.  */
+
+void
+smash_to_function_type (type, to_type)
+     struct type *type, *to_type;
+{
+  bzero (type, sizeof (struct type));
+  TYPE_TARGET_TYPE (type) = to_type;
+  TYPE_LENGTH (type) = 1;
+  TYPE_CODE (type) = TYPE_CODE_FUNC;
+  TYPE_NFIELDS (type) = 0;
+
+  if (TYPE_FUNCTION_TYPE (to_type) == 0
+      && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+    {
+      TYPE_FUNCTION_TYPE (to_type) = type;
+    }
+}
+
+static struct symbol *lookup_block_symbol ();
+
+/* Find the definition for a specified symbol name NAME
+   in namespace NAMESPACE, visible from lexical block BLOCK.
+   Returns the struct symbol pointer, or zero if no symbol is found.  */
+
+struct symbol *
+lookup_symbol (name, block, namespace)
+     char *name;
+     register struct block *block;
+     enum namespace namespace;
+{
+  register int i, n;
+  register struct symbol *sym;
+  register struct symtab *s;
+  struct blockvector *bv;
+
+  /* Search specified block and its superiors.  */
+
+  while (block != 0)
+    {
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  /* Now search all symtabs' global blocks.  */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      block = BLOCKVECTOR_BLOCK (bv, 0);
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+    }
+
+  /* Now search all symtabs' per-file blocks.
+     Not strictly correct, but more useful than an error.  */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      block = BLOCKVECTOR_BLOCK (bv, 1);
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+    }
+  return 0;
+}
+
+/* Look for a symbol in block BLOCK using binary search.  */
+
+static struct symbol *
+lookup_block_symbol (block, name, namespace)
+     register struct block *block;
+     char *name;
+     enum namespace namespace;
+{
+  register int bot, top, inc;
+  register struct symbol *sym;
+
+  top = BLOCK_NSYMS (block);
+  bot = 0;
+
+  /* First, advance BOT to not far before
+     the first symbol whose name is NAME.  */
+
+  while (1)
+    {
+      inc = (top - bot + 1);
+      /* No need to keep binary searching for the last few bits worth.  */
+      if (inc < 7)
+	break;
+      inc >>= 1;
+      sym = BLOCK_SYM (block, bot + inc);
+      if (strcmp (SYMBOL_NAME (sym), name) < 0)
+	bot += inc;
+      else
+	top = bot + inc;
+    }
+
+  /* Now scan forward until we run out of symbols,
+     find one whose name is greater than NAME,
+     or find one we want.
+     If there is more than one symbol with the right name and namespace,
+     we return the first one.  dbxread.c is careful to make sure
+     that if one is a register then it comes first.  */
+
+  top = BLOCK_NSYMS (block);
+  while (bot < top)
+    {
+      sym = BLOCK_SYM (block, bot);
+      inc = strcmp (SYMBOL_NAME (sym), name);
+      if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
+	return sym;
+      if (inc > 0)
+	return 0;
+      bot++;
+    }
+  return 0;
+}
+
+/* Return the symbol for the function which contains a specified
+   lexical block, described by a struct block BL.  */
+
+struct symbol *
+block_function (bl)
+     struct block *bl;
+{
+  while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
+    bl = BLOCK_SUPERBLOCK (bl);
+
+  return BLOCK_FUNCTION (bl);
+}
+
+/* Subroutine of find_pc_line */
+
+static struct symtab *
+find_pc_symtab (pc)
+     register CORE_ADDR pc;
+{
+  register struct block *b;
+  struct blockvector *bv;
+  register struct symtab *s;
+
+  /* Search all symtabs for one whose file contains our pc */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      b = BLOCKVECTOR_BLOCK (bv, 0);
+      if (BLOCK_START (b) <= pc
+	  && BLOCK_END (b) > pc)
+	break;
+    }
+
+  return s;
+}
+
+/* Find the source file and line number for a given PC value.
+   Return a structure containing a symtab pointer, a line number,
+   and a pc range for the entire source line.
+   The value's .pc field is NOT the specified pc.
+   NOTCURRENT nonzero means, if specified pc is on a line boundary,
+   use the line that ends there.  Otherwise, in that case, the line
+   that begins there is used.  */
+
+struct symtab_and_line
+find_pc_line (pc, notcurrent)
+     CORE_ADDR pc;
+     int notcurrent;
+{
+  struct symtab *s;
+  register struct linetable *l;
+  register int len;
+  register int i, item;
+  int line;
+  struct symtab_and_line value;
+  struct blockvector *bv;
+
+  /* Info on best line seen so far, and where it starts, and its file.  */
+
+  int best_line = 0;
+  CORE_ADDR best_pc = 0;
+  CORE_ADDR best_end = 0;
+  struct symtab *best_symtab = 0;
+
+  /* Store here the first line number
+     of a file which contains the line at the smallest pc after PC.
+     If we don't find a line whose range contains PC,
+     we will use a line one less than this,
+     with a range from the start of that file to the first line's pc.  */
+  int alt_line = 0;
+  CORE_ADDR alt_pc = 0;
+  struct symtab *alt_symtab = 0;
+
+  /* Info on best line seen in this file.  */
+
+  int prev_line;
+  CORE_ADDR prev_pc;
+
+  /* Info on first line of this file.  */
+
+  int first_line;
+  CORE_ADDR first_pc;
+
+  /* If this pc is not from the current frame,
+     it is the address of the end of a call instruction.
+     Quite likely that is the start of the following statement.
+     But what we want is the statement containing the instruction.
+     Fudge the pc to make sure we get that.  */
+
+  if (notcurrent) pc -= 1;
+
+  s = find_pc_symtab (pc);
+  if (s == 0)
+    {
+      value.symtab = 0;
+      value.line = 0;
+      value.pc = pc;
+      return value;
+    }
+
+  bv = BLOCKVECTOR (s);
+
+  /* Look at all the symtabs that share this blockvector.
+     They all have the same apriori range, that we found was right;
+     but they have different line tables.  */
+
+  for (; s && BLOCKVECTOR (s) == bv; s = s->next)
+    {
+      /* Find the best line in this symtab.  */
+      l = LINETABLE (s);
+      len = l->nitems;
+      prev_line = -1;
+      first_line = -1;
+      for (i = 0; i < len; i++)
+	{
+	  item = l->item[i];
+	  if (item < 0)
+	    line = - item - 1;
+	  else
+	    {
+	      line++;
+	      if (first_line < 0)
+		{
+		  first_line = line;
+		  first_pc = item;
+		}
+	      /* Return the last line that did not start after PC.  */
+	      if (pc >= item)
+		{
+		  prev_line = line;
+		  prev_pc = item;
+		}
+	      else
+		break;
+	    }
+	}
+
+      /* Is this file's best line closer than the best in the other files?
+	 If so, record this file, and its best line, as best so far.  */
+      if (prev_line >= 0 && prev_pc > best_pc)
+	{
+	  best_pc = prev_pc;
+	  best_line = prev_line;
+	  best_symtab = s;
+	  if (i < len)
+	    best_end = item;
+	  else
+	    best_end = 0;
+	}
+      /* Is this file's first line closer than the first lines of other files?
+	 If so, record this file, and its first line, as best alternate.  */
+      if (first_line >= 0 && first_pc > pc
+	  && (alt_pc == 0 || first_pc < alt_pc))
+	{
+	  alt_pc = first_pc;
+	  alt_line = first_line;
+	  alt_symtab = s;
+	}
+    }
+  if (best_symtab == 0)
+    {
+      value.symtab = alt_symtab;
+      value.line = alt_line - 1;
+      value.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0));
+      value.end = alt_pc;
+    }
+  else
+    {
+      value.symtab = best_symtab;
+      value.line = best_line;
+      value.pc = best_pc;
+      value.end = (best_end ? best_end
+		   : (alt_pc ? alt_pc
+		      : BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0))));
+    }
+  return value;
+}
+
+/* Find the range of pc values in a line.
+   Store the starting pc of the line into *STARTPTR
+   and the ending pc (start of next line) into *ENDPTR.
+   Returns 1 to indicate success.
+   Returns 0 if could not find the specified line.  */
+
+int
+find_line_pc_range (symtab, thisline, startptr, endptr)
+     struct symtab *symtab;
+     int thisline;
+     CORE_ADDR *startptr, *endptr;
+{
+  register struct linetable *l;
+  register int i, line, item;
+  int len;
+  register CORE_ADDR prev_pc;
+  CORE_ADDR last_pc;
+
+  if (symtab == 0)
+    return 0;
+
+  l = LINETABLE (symtab);
+  len = l->nitems;
+  prev_pc = -1;
+  for (i = 0; i < len; i++)
+    {
+      item = l->item[i];
+      if (item < 0)
+	line = - item - 1;
+      else
+	{
+	  line++;
+	  /* As soon as we find a line following the specified one
+	     we know the end pc and can return.  */
+	  if (line > thisline)
+	    {
+	      /* If we have not seen an entry for the specified line,
+		 assume that means the specified line has zero bytes.  */
+	      *startptr = prev_pc == -1 ? item : prev_pc;
+	      *endptr = item;
+	      return 1;
+	    }
+	  /* If we see an entry for the specified line,
+	     it gives the beginning.  */
+	  if (line == thisline)
+	    prev_pc = item;
+	  last_pc = item;
+	}
+    }
+  if (prev_pc != -1)
+    {
+      /* If we found the specified line but no later line, it's file's last.
+	 Its range is from line's pc to file's end pc.  */
+      *startptr = last_pc;
+      *endptr = BLOCK_END (BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), 0));
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Find the PC value for a given source file and line number.
+   Returns zero for invalid line number.
+   The source file is specified with a struct symtab.  */
+
+CORE_ADDR
+find_line_pc (symtab, line)
+     struct symtab *symtab;
+     int line;
+{
+  register struct linetable *l;
+  register int len;
+  register int i;
+  register int item;
+  register int nextline = -1;
+
+  if (line <= 0)
+    return 0;
+
+  l = LINETABLE (symtab);
+  len = l->nitems;
+  for (i = 0; i < len; i++)
+    {
+      item = l->item[i];
+      if (item < 0)
+	nextline = - item - 1;
+      else
+	{
+	  nextline++;
+	  if (line <= nextline)
+	    return item;
+	}
+    }
+  return 0;
+}
+
+int
+find_pc_line_pc_range (pc, startptr, endptr)
+     CORE_ADDR pc;
+     CORE_ADDR *startptr, *endptr;
+{
+  struct symtab_and_line sal;
+  sal = find_pc_line (pc, 0);
+  *startptr = sal.pc;
+  *endptr = sal.end;
+  return sal.symtab != 0;
+}
+
+/* Parse a string that specifies a line number.
+   Pass the address of a char * variable; that variable will be
+   advanced over the characters actually parsed.
+
+   The string can be:
+
+   LINENUM -- that line number in current file.  PC returned is 0.
+   FILE:LINENUM -- that line in that file.  PC returned is 0.
+   FUNCTION -- line number of openbrace of that function.
+      PC returned is the start of the function.
+   FILE:FUNCTION -- likewise, but prefer functions in that file.
+   *EXPR -- line in which address EXPR appears.
+
+   FUNCTION may be an undebuggable function found in misc_function_vector.
+
+   If the argument FUNFIRSTLINE is nonzero, we want the first line
+   of real code inside a function when a function is specified.
+
+   DEFAULT_SYMTAB specifies the file to use if none is specified.
+   It defaults to current_source_symtab.
+   DEFAULT_LINE specifies the line number to use for relative
+   line numbers (that start with signs).  Defaults to current_source_line.
+
+   Note that it is possible to return zero for the symtab
+   if no file is validly specified.  Callers must check that.
+   Also, the line number returned may be invalid.  */
+
+struct symtab_and_line
+decode_line_1 (argptr, funfirstline, default_symtab, default_line)
+     char **argptr;
+     int funfirstline;
+     struct symtab *default_symtab;
+     int default_line;
+{
+  struct symtab_and_line value;
+  register char *p, *p1;
+  register struct symtab *s;
+  register struct symbol *sym;
+  register CORE_ADDR pc;
+  register int i;
+  char *copy;
+
+  /* Defaults have defaults.  */
+
+  if (default_symtab == 0)
+    {
+      default_symtab = current_source_symtab;
+      default_line = current_source_line;
+    }
+
+  /* See if arg is *PC */
+
+  if (**argptr == '*')
+    {
+      (*argptr)++;
+      pc = parse_and_eval_address_1 (argptr);
+      value = find_pc_line (pc, 0);
+      value.pc = pc;
+      return value;
+    }
+
+  /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
+
+  s = 0;
+
+  for (p = *argptr; *p; p++)
+    {
+      if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
+	break;
+    }
+  while (p[0] == ' ' || p[0] == '\t') p++;
+
+  if (p[0] == ':')
+    {
+      /* Extract the file name.  */
+      p1 = p;
+      while (p != *argptr && p[-1] == ' ') --p;
+      copy = (char *) alloca (p - *argptr + 1);
+      bcopy (*argptr, copy, p - *argptr);
+      copy[p - *argptr] = 0;
+
+      /* Find that file's data.  */
+      s = lookup_symtab (copy);
+      if (s == 0)
+	{
+	  if (symtab_list == 0)
+	    error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+	  error ("No source file named %s.", copy);
+	}
+
+      /* Discard the file name from the arg.  */
+      p = p1 + 1;
+      while (*p == ' ' || *p == '\t') p++;
+      *argptr = p;
+    }
+
+  /* S is specified file's symtab, or 0 if no file specified.
+     arg no longer contains the file name.  */
+
+  /* Check whether arg is all digits (and sign) */
+
+  p = *argptr;
+  if (*p == '-' || *p == '+') p++;
+  while (*p >= '0' && *p <= '9')
+    p++;
+
+  if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
+    {
+      /* We found a token consisting of all digits -- at least one digit.  */
+      enum sign {none, plus, minus} sign = none;
+
+      if (**argptr == '+')
+	sign = plus, (*argptr)++;
+      else if (**argptr == '-')
+	sign = minus, (*argptr)++;
+      value.line = atoi (*argptr);
+      switch (sign)
+	{
+	case plus:
+	  if (p == *argptr)
+	    value.line = 5;
+	  if (s == 0)
+	    value.line = default_line + value.line;
+	  break;
+	case minus:
+	  if (p == *argptr)
+	    value.line = 15;
+	  if (s == 0)
+	    value.line = default_line - value.line;
+	  else
+	    value.line = 1;
+	  break;
+	}
+
+      while (*p == ' ' || *p == '\t') p++;
+      *argptr = p;
+      if (s == 0)
+	s = default_symtab;
+      value.symtab = s;
+      value.pc = 0;
+      return value;
+    }
+
+  /* Arg token is not digits => try it as a function name
+     Find the next token (everything up to end or next whitespace).  */
+  p = *argptr;
+  while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
+  copy = (char *) alloca (p - *argptr + 1);
+  bcopy (*argptr, copy, p - *argptr);
+  copy[p - *argptr] = 0;
+  while (*p == ' ' || *p == '\t') p++;
+  *argptr = p;
+
+  /* Look up that token as a function.
+     If file specified, use that file's per-file block to start with.  */
+
+  sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
+		       VAR_NAMESPACE);
+
+  if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+    {
+      /* Arg is the name of a function */
+      pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
+      if (funfirstline)
+	SKIP_PROLOGUE (pc);
+      value = find_pc_line (pc, 0);
+      value.pc = (value.end && value.pc != pc) ? value.end : pc;
+      return value;
+    }
+
+  if (sym)
+    error ("%s is not a function.", copy);
+
+  for (i = 0; i < misc_function_count; i++)
+    if (!strcmp (misc_function_vector[i].name, copy))
+      {
+	value.symtab = 0;
+	value.line = 0;
+	value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
+	if (funfirstline)
+	  SKIP_PROLOGUE (value.pc);
+	return value;
+      }
+
+  if (symtab_list == 0)
+    error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+  error ("Function %s not defined.", copy);
+}
+
+struct symtab_and_line
+decode_line_spec (string, funfirstline)
+     char *string;
+     int funfirstline;
+{
+  struct symtab_and_line sal;
+  if (string == 0)
+    error ("Empty line specification.");
+  sal = decode_line_1 (&string, funfirstline,
+		       current_source_symtab, current_source_line);
+  if (*string)
+    error ("Junk at end of line specification: %s", string);
+  return sal;
+}
+
+static void
+sources_info ()
+{
+  register struct symtab *s;
+  register int column = 0;
+
+  if (symtab_list == 0)
+    {
+      printf ("No symbol table is loaded.\n");
+      return;
+    }
+  printf ("Source files for which symbol table is known:\n");
+  for (s = symtab_list; s; s = s->next)
+    {
+      if (column != 0 && column + strlen (s->filename) >= 70)
+	{
+	  printf ("\n");
+	  column = 0;
+	}
+      else if (column != 0)
+	{
+	  printf (" ");
+	  column++;
+	}
+      printf ("%s", s->filename);
+      column += strlen (s->filename);
+      if (s->next)
+	{
+	  printf (",");
+	  column++;
+	}
+    }
+  printf ("\n");
+}
+
+/* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
+   If CLASS is zero, list all symbols except functions and type names.
+   If CLASS is 1, list only functions.
+   If CLASS is 2, list only type names.  */
+
+#define MORE  \
+{ print_count++;		\
+  if (print_count >= 21)	\
+    { printf ("--Type Return to print more--");	\
+      print_count = 0;		\
+      fflush (stdout);		\
+      read_line (); } }
+
+static void
+list_symbols (regexp, class)
+     char *regexp;
+     int class;
+{
+  register struct symtab *s;
+  register struct blockvector *bv;
+  struct blockvector *prev_bv = 0;
+  register struct block *b;
+  register int i, j;
+  register struct symbol *sym;
+  char *val = 0;
+  int found_in_file;
+  static char *classnames[]
+    = {"variable", "function", "type"};
+  int print_count = 0;
+#ifdef REGCMP
+  extern char *regcmp(), *regex(), *loc1;
+#endif
+
+  if (regexp) {
+#ifdef REGCMP
+    val = regcmp(regexp, (char *)0);
+    if (val == 0)
+      error ("Invalid regexp: %s", regexp);
+#else
+    if (val = (char *) re_comp (regexp))
+      error ("Invalid regexp: %s", val);
+#endif
+  }
+
+  printf (regexp
+	  ? "All %ss matching regular expression \"%s\":\n"
+	  : "All defined %ss:\n",
+	  classnames[class],
+	  regexp);
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      found_in_file = 0;
+      bv = BLOCKVECTOR (s);
+      /* Often many files share a blockvector.
+	 Scan each blockvector only once so that
+	 we don't get every symbol many times.
+	 It happens that the first symtab in the list
+	 for any given blockvector is the main file.  */
+      if (bv != prev_bv)
+	for (i = 0; i < 2; i++)
+	  {
+	    b = BLOCKVECTOR_BLOCK (bv, i);
+	    for (j = 0; j < BLOCK_NSYMS (b); j++)
+	      {
+		QUIT;
+		sym = BLOCK_SYM (b, j);
+		if (regexp) {
+#ifdef REGCMP
+		  if (!regex(val, SYMBOL_NAME (sym)))
+		    continue;
+#else
+		  if (!re_exec (SYMBOL_NAME (sym)))
+		    continue;
+#endif
+		}
+		if ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+			 && SYMBOL_CLASS (sym) != LOC_BLOCK)
+			|| (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
+			|| (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))
+		  {
+		    if (!found_in_file)
+		      {
+			printf ("\nFile %s:\n", s->filename);
+			print_count += 2;
+		      }
+		    found_in_file = 1;
+		    MORE;
+		    if (class != 2 && i == 1)
+		      printf ("static ");
+		    if (class == 2
+			&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
+		      printf ("typedef ");
+
+		    type_print (SYMBOL_TYPE (sym),
+				(SYMBOL_CLASS (sym) == LOC_TYPEDEF
+				 ? "" : SYMBOL_NAME (sym)),
+				stdout, 0);
+		    if (class == 2
+			&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
+			&& (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
+			    || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
+					    SYMBOL_NAME (sym))))
+		      printf (" %s", SYMBOL_NAME (sym));
+		    printf (";\n");
+		  }
+	      }
+	  }
+      prev_bv = bv;
+    }
+#ifdef REGCMP
+    if (val)
+      (void)free(val);
+#endif
+}
+
+static void
+variables_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 0);
+}
+
+static void
+functions_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 1);
+}
+
+static void
+types_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 2);
+}
+
+/* Initialize the standard C scalar types.  */
+
+static
+struct type *
+init_type (code, length, uns, name)
+     enum type_code code;
+     int length, uns;
+     char *name;
+{
+  register struct type *type;
+
+  type = (struct type *) xmalloc (sizeof (struct type));
+  bzero (type, sizeof *type);
+  TYPE_CODE (type) = code;
+  TYPE_LENGTH (type) = length;
+  TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
+  TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
+  TYPE_NFIELDS (type) = 0;
+  TYPE_NAME (type) = name;
+
+  return type;
+}
+
+static
+initialize ()
+{
+  add_info ("variables", variables_info,
+	    "All global and static variable names, or those matching REGEXP.");
+  add_info ("functions", functions_info,
+	    "All function names, or those matching REGEXP.");
+  add_info ("types", types_info,
+	    "All types names, or those matching REGEXP.");
+  add_info ("sources", sources_info,
+	    "Source files in the program.");
+
+  obstack_init (symbol_obstack);
+
+  builtin_type_void = init_type (TYPE_CODE_VOID, 0, 0, "void");
+
+  builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float");
+  builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double");
+
+  builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char");
+  builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short");
+  builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long");
+  builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int");
+
+  builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char");
+  builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short");
+  builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long");
+  builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int");
+}
+
+END_FILE
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d29 4
+d933 1
+a933 1
+  char *val;
+d938 3
+d942 6
+a947 1
+  if (regexp)
+d950 2
+d976 10
+a985 2
+		if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
+		    && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+d988 1
+a988 1
+			|| (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)))
+d1019 4
+@
diff --git a/gdb/RCS/utils.c,v b/gdb/RCS/utils.c,v
new file mode 100644
index 0000000..3f7a836
--- /dev/null
+++ b/gdb/RCS/utils.c,v
@@ -0,0 +1,461 @@
+head     1.2;
+access   ;
+symbols  RMS-has:1.2;
+locks    ; strict;
+comment  @ * @;
+
+
+1.2
+date     88.01.26.05.11.12;  author gnu;  state Exp;
+branches ;
+next     1.1;
+
+1.1
+date     88.01.21.05.11.11;  author gnu;  state Exp;
+branches ;
+next     ;
+
+
+desc
+@From RMS's development sources on wheaties, 20Jan88
+@
+
+
+1.2
+log
+@Avoid using TIOCFLUSH if it is not defined.
+@
+text
+@/* General utility routines for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include "defs.h"
+
+void error ();
+void fatal ();
+
+/* Chain of cleanup actions established with make_cleanup,
+   to be executed if an error happens.  */
+
+static struct cleanup *cleanup_chain;
+
+/* Nonzero means a quit has been requested.  */
+
+int quit_flag;
+
+/* Nonzero means quit immediately if Control-C is typed now,
+   rather than waiting until QUIT is executed.  */
+
+int immediate_quit;
+
+/* Add a new cleanup to the cleanup_chain,
+   and return the previous chain pointer
+   to be passed later to do_cleanups or discard_cleanups.
+   Args are FUNCTION to clean up with, and ARG to pass to it.  */
+
+struct cleanup *
+make_cleanup (function, arg)
+     void (*function) ();
+     int arg;
+{
+  register struct cleanup *new
+    = (struct cleanup *) xmalloc (sizeof (struct cleanup));
+  register struct cleanup *old_chain = cleanup_chain;
+
+  new->next = cleanup_chain;
+  new->function = function;
+  new->arg = arg;
+  cleanup_chain = new;
+
+  return old_chain;
+}
+
+/* Discard cleanups and do the actions they describe
+   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
+
+void
+do_cleanups (old_chain)
+     register struct cleanup *old_chain;
+{
+  register struct cleanup *ptr;
+  while ((ptr = cleanup_chain) != old_chain)
+    {
+      (*ptr->function) (ptr->arg);
+      cleanup_chain = ptr->next;
+      free (ptr);
+    }
+}
+
+/* Discard cleanups, not doing the actions they describe,
+   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
+
+void
+discard_cleanups (old_chain)
+     register struct cleanup *old_chain;
+{
+  register struct cleanup *ptr;
+  while ((ptr = cleanup_chain) != old_chain)
+    {
+      cleanup_chain = ptr->next;
+      free (ptr);
+    }
+}
+
+/* This function is useful for cleanups.
+   Do
+
+     foo = xmalloc (...);
+     old_chain = make_cleanup (free_current_contents, &foo);
+
+   to arrange to free the object thus allocated.  */
+
+void
+free_current_contents (location)
+     char **location;
+{
+  free (*location);
+}
+
+/* Generally useful subroutines used throughout the program.  */
+
+/* Like malloc but get error if no storage available.  */
+
+char *
+xmalloc (size)
+     long size;
+{
+  register char *val = (char *) malloc (size);
+  if (!val)
+    fatal ("virtual memory exhausted.", 0);
+  return val;
+}
+
+/* Like realloc but get error if no storage available.  */
+
+char *
+xrealloc (ptr, size)
+     char *ptr;
+     long size;
+{
+  register char *val = (char *) realloc (ptr, size);
+  if (!val)
+    fatal ("virtual memory exhausted.", 0);
+  return val;
+}
+
+/* Print the system error message for errno, and also mention STRING
+   as the file name for which the error was encountered.
+   Then return to command level.  */
+
+void
+perror_with_name (string)
+     char *string;
+{
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+  char *err;
+  char *combined;
+
+  if (errno < sys_nerr)
+    err = sys_errlist[errno];
+  else
+    err = "unknown error";
+
+  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
+  strcpy (combined, string);
+  strcat (combined, ": ");
+  strcat (combined, err);
+
+  error ("%s.", combined);
+}
+
+/* Print the system error message for ERRCODE, and also mention STRING
+   as the file name for which the error was encountered.  */
+
+void
+print_sys_errmsg (string, errcode)
+     char *string;
+     int errcode;
+{
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  char *err;
+  char *combined;
+
+  if (errcode < sys_nerr)
+    err = sys_errlist[errcode];
+  else
+    err = "unknown error";
+
+  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
+  strcpy (combined, string);
+  strcat (combined, ": ");
+  strcat (combined, err);
+
+  printf ("%s.\n", combined);
+}
+
+void
+quit ()
+{
+  fflush (stdout);
+#ifdef TIOCFLUSH
+  ioctl (fileno (stdout), TIOCFLUSH, 0);
+#endif
+  error ("Quit");
+}
+
+/* Control C comes here */
+
+void
+request_quit ()
+{
+  quit_flag = 1;
+  if (immediate_quit)
+    quit ();
+}
+
+/* Print an error message and return to command level.
+   STRING is the error message, used as a fprintf string,
+   and ARG is passed as an argument to it.  */
+
+void
+error (string, arg1, arg2, arg3)
+     char *string;
+     int arg1, arg2, arg3;
+{
+  fflush (stdout);
+  fprintf (stderr, string, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+  return_to_top_level ();
+}
+
+/* Print an error message and exit reporting failure.
+   This is for a error that we cannot continue from.
+   STRING and ARG are passed to fprintf.  */
+
+void
+fatal (string, arg)
+     char *string;
+     int arg;
+{
+  fprintf (stderr, "gdb: ");
+  fprintf (stderr, string, arg);
+  fprintf (stderr, "\n");
+  exit (1);
+}
+
+/* Make a copy of the string at PTR with SIZE characters
+   (and add a null character at the end in the copy).
+   Uses malloc to get the space.  Returns the address of the copy.  */
+
+char *
+savestring (ptr, size)
+     char *ptr;
+     int size;
+{
+  register char *p = (char *) xmalloc (size + 1);
+  bcopy (ptr, p, size);
+  p[size] = 0;
+  return p;
+}
+
+char *
+concat (s1, s2, s3)
+     char *s1, *s2, *s3;
+{
+  register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
+  register char *val = (char *) xmalloc (len);
+  strcpy (val, s1);
+  strcat (val, s2);
+  strcat (val, s3);
+  return val;
+}
+
+void
+print_spaces (n, file)
+     register int n;
+     register FILE *file;
+{
+  while (n-- > 0)
+    fputc (' ', file);
+}
+
+/* Ask user a y-or-n question and return 1 iff answer is yes.
+   Takes three args which are given to printf to print the question.
+   The first, a control string, should end in "? ".
+   It should not say how to answer, because we do that.  */
+
+int
+query (ctlstr, arg1, arg2)
+     char *ctlstr;
+{
+  register int answer;
+
+  /* Automatically answer "yes" if input is not from a terminal.  */
+  if (!input_from_terminal_p ())
+    return 1;
+
+  while (1)
+    {
+      printf (ctlstr, arg1, arg2);
+      printf ("(y or n) ");
+      fflush (stdout);
+      answer = fgetc (stdin);
+      clearerr (stdin);		/* in case of C-d */
+      if (answer != '\n')
+	while (fgetc (stdin) != '\n') clearerr (stdin);
+      if (answer >= 'a')
+	answer -= 040;
+      if (answer == 'Y')
+	return 1;
+      if (answer == 'N')
+	return 0;
+      printf ("Please answer y or n.\n");
+    }
+}
+
+/* Parse a C escape sequence.  STRING_PTR points to a variable
+   containing a pointer to the string to parse.  That pointer
+   is updated past the characters we use.  The value of the
+   escape sequence is returned.
+
+   A negative value means the sequence \ newline was seen,
+   which is supposed to be equivalent to nothing at all.
+
+   If \ is followed by a null character, we return a negative
+   value and leave the string pointer pointing at the null character.
+
+   If \ is followed by 000, we return 0 and leave the string pointer
+   after the zeros.  A value of 0 does not mean end of string.  */
+
+int
+parse_escape (string_ptr)
+     char **string_ptr;
+{
+  register int c = *(*string_ptr)++;
+  switch (c)
+    {
+    case 'a':
+      return '\a';
+    case 'b':
+      return '\b';
+    case 'e':
+      return 033;
+    case 'f':
+      return '\f';
+    case 'n':
+      return '\n';
+    case 'r':
+      return '\r';
+    case 't':
+      return '\t';
+    case 'v':
+      return '\v';
+    case '\n':
+      return -2;
+    case 0:
+      (*string_ptr)--;
+      return 0;
+    case '^':
+      c = *(*string_ptr)++;
+      if (c == '\\')
+	c = parse_escape (string_ptr);
+      if (c == '?')
+	return 0177;
+      return (c & 0200) | (c & 037);
+      
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+      {
+	register int i = c - '0';
+	register int count = 0;
+	while (++count < 3)
+	  {
+	    if ((c = *(*string_ptr)++) >= '0' && c <= '7')
+	      {
+		i *= 8;
+		i += c - '0';
+	      }
+	    else
+	      {
+		(*string_ptr)--;
+		break;
+	      }
+	  }
+	return i;
+      }
+    default:
+      return c;
+    }
+}
+
+void
+printchar (ch, stream)
+     unsigned char ch;
+     FILE *stream;
+{
+  register int c = ch;
+  if (c < 040 || c >= 0177)
+    {
+      if (c == '\n')
+	fprintf (stream, "\\n");
+      else if (c == '\b')
+	fprintf (stream, "\\b");
+      else if (c == '\t')
+	fprintf (stream, "\\t");
+      else if (c == '\f')
+	fprintf (stream, "\\f");
+      else if (c == '\r')
+	fprintf (stream, "\\r");
+      else if (c == 033)
+	fprintf (stream, "\\e");
+      else if (c == '\a')
+	fprintf (stream, "\\a");
+      else
+	fprintf (stream, "\\%03o", c);
+    }
+  else
+    {
+      if (c == '\\' || c == '"' || c == '\'')
+	fputc ('\\', stream);
+      fputc (c, stream);
+    }
+}
+@
+
+
+1.1
+log
+@Initial revision
+@
+text
+@d194 1
+d196 1
+@
diff --git a/gdb/README b/gdb/README
new file mode 100644
index 0000000..6e985de
--- /dev/null
+++ b/gdb/README
@@ -0,0 +1,29 @@
+This is GDB, a source-level debugger intended for GNU,
+presently running under un*x.
+
+Before compiling GDB, you must set three files according to
+the kind of machine you are running on.
+
+param.h must be set up to #include an m- file for the machine.
+The m- files written so far are m-vax.h, m-sun2.h and m-sun3.h.
+(I believe that it is the operating system version and not
+the cpu type which determines which of the two is right on a Sun.)
+This file contains macro definitions that express information
+about the machine's registers, stack frame format and instructions.
+
+initialize.h must be set up to #include an m-...init.h file.
+There are two of them written: m-vaxinit.h and m-suninit.h.
+This file defines one macro, which says how to round up from the
+address of the end of the text of one .o file to the beginning of
+the text of the next .o file.
+
+pinsn.c must be set up to include the instruction printer for
+your cpu type.  The two printers that exist are vax-pinsn.c
+and m68k-pinsn.c.
+
+`Makefile' must be changed to say `OBSTACK = obstack.o' instead of
+`OBSTACK=-lobstack' (unless you want to install obstack.o as
+/lib/libobstack.a).
+
+Once these files are set up, just `make' will do everything,
+producing an executable `gdb' in this directory.
diff --git a/gdb/TAGS b/gdb/TAGS
new file mode 100644
index 0000000..e01cba9
--- /dev/null
+++ b/gdb/TAGS
@@ -0,0 +1,852 @@
+
+blockframe.c,436
+block_for_pc 221,5337
+block_innermost_frame 308,7200
+find_pc_function 276,6473
+find_pc_misc_function 290,6806
+get_current_block 182,4485
+get_current_frame 47,1553
+get_frame_block 172,4336
+get_frame_function 208,5053
+get_frame_info 90,2661
+get_frame_pc 150,3800
+get_frame_saved_regs 161,3986
+get_pc_function_start 188,4557
+get_prev_frame 66,1893
+get_prev_frame_info 128,3455
+initialize 329,7603
+set_current_frame 56,1705
+
+breakpoint.c,1102
+#define ALL_BREAKPOINTS(71,2545
+break_command 604,14937
+break_command_1 528,13121
+breakpoint_1 360,9438
+breakpoint_auto_delete 687,16916
+breakpoint_here_p 288,7887
+breakpoint_stop_status 308,8410
+breakpoints_info 409,10520
+check_duplicates 443,11290
+clear_breakpoint_commands 218,6186
+clear_breakpoints 757,18298
+clear_command 620,15179
+clear_momentary_breakpoints 513,12821
+commands_command 154,4443
+condition_command 109,3533
+delete_breakpoint 704,17221
+delete_command 733,17741
+disable_breakpoint 873,20658
+disable_command 882,20791
+do_breakpoint_commands 200,5626
+enable_breakpoint 857,20419
+enable_command 866,20550
+enable_delete_breakpoint 910,21276
+enable_delete_command 919,21413
+enable_once_breakpoint 894,21020
+enable_once_command 903,21158
+ignore_command 797,19190
+initialize 933,21666
+insert_breakpoints 230,6503
+map_breakpoint_numbers 822,19738
+mark_breakpoints_out 275,7576
+remove_breakpoints 251,7042
+set_default_breakpoint 426,10820
+set_ignore_count 767,18523
+set_momentary_breakpoint 501,12597
+set_raw_breakpoint 464,11810
+tbreak_command 612,15057
+
+command.c,151
+add_alias_cmd 141,6077
+add_cmd 116,5529
+add_prefix_cmd 177,7140
+delete_cmd 198,7681
+help_cmd 230,8515
+lookup_cmd 336,11651
+savestring 446,13891
+
+core.c,397
+#define N_DATADDR(41,1348
+#define N_TXTADDR(37,1278
+close_exec_file 268,7417
+core_file_command 104,2838
+exec_file_command 221,6183
+files_info 330,8673
+get_exec_file 315,8446
+have_core_file_p 324,8612
+initialize 548,13957
+myread 505,13219
+read_memory 373,9666
+register_addr 531,13685
+reopen_exec_file 275,7501
+validate_files 291,7907
+write_memory 389,10073
+xfer_core_file 400,10338
+
+dbxread.c,1108
+add_new_header_file 346,10622
+add_old_header_file 317,9604
+add_symbol_to_list 496,14905
+add_this_object_header_file 297,8977
+compare_misc_functions 931,26566
+compare_symbols 1000,28016
+condense_misc_bunches 957,27070
+dbx_alloc_type 454,13833
+dbx_lookup_type 404,12394
+define_symbol 1516,42011
+discard_misc_bunches 944,26878
+end_symtab 756,22240
+explicit_lookup_type 475,14373
+finish_block 512,15299
+free_header_files 273,8395
+get_sym_file 1174,32423
+hash_symsegs 1343,36983
+hashname 1318,36533
+init_header_files 260,8046
+init_misc_functions 903,25961
+initialize 2078,57588
+make_blockvector 590,17428
+new_object_header_files 286,8705
+next_symbol_text 1309,36368
+pop_subfile 861,25120
+process_one_symbol 1374,37801
+push_subfile 847,24770
+read_dbx_symtab 1186,32790
+read_enum_type 1892,52804
+read_number 2041,57023
+read_range_type 1962,54881
+read_struct_type 1809,50421
+read_type 1685,47313
+read_type_number 1658,46658
+record_line 627,18511
+record_misc_function 911,26075
+sort_syms 1012,28407
+start_subfile 699,20484
+start_symtab 662,19485
+symbol_file_command 1036,28951
+
+environ.c,213
+environ_vector 164,6337
+free_environ 118,5334
+get_in_environ 173,6472
+init_environ 134,5661
+make_environ 103,5036
+#define max(96,4912
+#define min(95,4870
+set_in_environ 192,6807
+unset_in_environ 232,7561
+
+eval.c,309
+evaluate_expression 95,2716
+evaluate_subexp 114,3104
+evaluate_subexp_for_address 440,13032
+evaluate_subexp_for_sizeof 509,14789
+evaluate_subexp_with_coercion 477,13979
+evaluate_type 106,2961
+initialize 550,15888
+parse_and_eval 64,1977
+parse_and_eval_address 33,1188
+parse_and_eval_address_1 50,1650
+
+expprint.c,49
+print_expression 88,3265
+print_subexp 102,3660
+
+expread.tab.c,358
+copy_name 538,12121
+end_arglist 125,2565
+free_funcalls 139,2867
+length_of_subexp 572,13025
+parse_c_1 751,17140
+parse_c_expression 790,18194
+parse_number 217,5038
+prefixify_expression 552,12457
+prefixify_subexp 644,14362
+start_arglist 111,2206
+write_exp_elt 156,3206
+write_exp_string 173,3660
+yyerror 529,11966
+yylex 315,7081
+yyparse(985,25972
+
+findvar.c,309
+find_saved_register 38,1432
+initialize 386,10456
+locate_var_value 334,9235
+read_register 165,4621
+read_register_bytes 140,4050
+read_relative_register_raw_bytes 68,2095
+read_var_value 202,5600
+supply_register 190,5277
+value_of_register 102,2842
+write_register 175,4862
+write_register_bytes 151,4328
+
+firstfile.c,89
+initialize_all_files 128,6009
+initialize_dummy_1 140,6338
+initialize_dummy_2 148,6497
+
+infcmd.c,550
+cont_command 165,3979
+environment_info 479,11280
+finish_command 397,9291
+have_inferior_p 106,2907
+initialize 682,15823
+jump_command 269,6035
+next_command 202,4695
+nexti_command 216,4897
+program_info 457,10675
+read_memory_integer 542,12697
+read_pc 575,13293
+registers_info 589,13488
+run_command 121,3120
+run_stack_dummy 355,8179
+set_args_command 112,2972
+set_environment_command 499,11682
+signal_command 314,7007
+step_1 222,4974
+step_command 194,4543
+stepi_command 210,4820
+unset_environment_command 531,12458
+write_pc 580,13357
+
+inflow.c,551
+create_inferior 187,5073
+fetch_inferior_registers 271,6793
+fetch_inferior_registers 317,8482
+inferior_died 244,6286
+initialize 483,13062
+kill_command 226,5974
+kill_inferior 235,6161
+read_inferior_memory 388,10475
+resume 258,6596
+store_inferior_registers 294,7707
+store_inferior_registers 343,9249
+term_status_command 165,4365
+terminal_inferior 87,2428
+terminal_init_inferior 71,2074
+terminal_ours 121,3326
+terminal_ours_1 127,3383
+terminal_ours_for_output 111,3126
+try_writing_regs_command 457,12556
+write_inferior_memory 416,11420
+
+infrun.c,286
+clear_proceed_status 111,3347
+handle_command 728,21384
+initialize 848,24793
+insert_step_breakpoint 706,20807
+normal_stop 618,18254
+proceed 138,4172
+remove_step_breakpoint 718,21109
+signals_info 810,23832
+start_inferior 214,6079
+wait_for_inferior 242,7039
+writing_pc 202,5763
+
+kdb-start.c,14
+start 10,140
+
+lastfile.c,28
+initialize_last_file 4,144
+
+m68k-pinsn.c,361
+#define NEXTBYTE(43,1554
+#define NEXTDOUBLE(54,1819
+#define NEXTEXTEND(57,1877
+#define NEXTLONG(48,1671
+#define NEXTPACKED(61,1995
+#define NEXTSINGLE(51,1762
+#define NEXTWORD(45,1602
+convert_from_68881 713,16392
+convert_to_68881 732,16806
+fetch_arg 504,12082
+print_base 693,15890
+print_indexed 603,13871
+print_insn 71,2389
+print_insn_arg 163,4738
+
+main.c,841
+add_com 487,11896
+add_com_alias 499,12123
+add_info 455,11186
+add_info_alias 466,11372
+cd_command 885,24375
+command_loop 288,7462
+copying_info 628,14816
+define_command 545,12933
+do_nothing 281,7362
+document_command 583,13895
+dont_repeat 323,8255
+dump_me_command 961,25608
+echo_command 935,25224
+error_no_arg 509,12321
+execute_command 245,6496
+free_command_lines 437,10877
+help_command 516,12415
+info_command 478,11700
+initialize_main 972,25764
+input_from_terminal_p 869,24072
+main 81,2147
+print_gdb_version 800,22767
+pwd_command 875,24143
+quit_command 856,23880
+read_command_lines 386,9603
+read_line 334,8514
+return_to_top_level 71,1965
+set_prompt_command 818,23215
+source_cleanup 904,24752
+source_command 912,24854
+stop_sig 307,7915
+validate_comname 524,12566
+version_info 810,23117
+warranty_info 770,21356
+
+obstack.c,77
+_obstack_begin 101,4993
+_obstack_free 148,6461
+_obstack_newchunk 121,5631
+
+pinsn.c,0
+
+printcmd.c,585
+address_info 385,9015
+clear_displays 661,15183
+decode_format 70,2061
+display_command 606,14214
+display_info 769,17310
+do_displays 731,16450
+do_examine 231,5522
+free_display 649,14965
+initialize 888,20497
+output_command 346,8219
+print_address 208,4990
+print_command 306,7398
+print_formatted 109,2860
+print_frame_args 810,18392
+print_frame_nameless_args 870,20125
+print_variable_value 795,17951
+ptype_command 525,12189
+set_command 374,8765
+set_next_address 193,4626
+undisplay_command 677,15445
+validate_format 291,6959
+whatis_command 500,11716
+x_command 452,10410
+
+source.c,249
+directories_info 53,1637
+directory_command 79,2168
+find_source_lines 264,6263
+init_source_path 59,1735
+initialize 535,13376
+line_info 490,12220
+list_command 363,8569
+openp 186,4596
+print_source_lines 303,7291
+select_source_symtab 250,5960
+
+stack.c,502
+args_info 350,8833
+backtrace_command 232,6280
+down_command 498,12939
+find_relative_frame 391,10010
+frame_command 444,11623
+frame_info 149,4137
+get_selected_block 371,9306
+initialize 542,13968
+locals_info 312,8132
+print_block_frame_locals 257,6820
+print_frame_arg_vars 318,8214
+print_frame_info 70,2167
+print_frame_local_vars 291,7614
+print_sel_frame 131,3689
+print_selected_frame 140,3894
+print_stack_frame 57,1964
+return_command 516,13439
+select_frame 359,9033
+up_command 477,12347
+
+standalone.c,1165
+_exit 436,8533
+_flsbuf 326,6852
+access 76,1743
+chdir 62,1588
+close 164,4224
+core_file_command 340,7028
+exec_file_command 337,7003
+execle 433,8519
+exit 81,1771
+fault 514,9963
+fclose 189,4597
+fdopen 183,4539
+fflush 331,6910
+fgetc 247,5466
+fopen 175,4414
+fprintf 298,6263
+fputc 314,6593
+fread 229,5154
+fstat 195,4647
+fwrite 305,6422
+get_exec_file 344,7060
+getpid 54,1543
+getrlimit 474,9005
+getwd 66,1608
+have_core_file_p 350,7176
+initialize 585,11686
+ioctl 45,1478
+kill 51,1531
+kill_command 355,7213
+lseek 266,5714
+malloc_warning 441,8575
+myread 208,4831
+open 129,3606
+printf 291,6110
+ptrace 427,8490
+read_inferior_register 372,7361
+read_memory 375,7391
+read_register 397,7764
+restore_gdb 528,10282
+resume 490,9429
+save_frame_pointer 502,9633
+save_registers 540,10627
+sbrk 451,8691
+setpgrp 430,8504
+int (* signal 48,1506
+sigsetmask 59,1570
+int kdb_stack_beg[STACK_SIZE / sizeof 581,11613
+terminal_inferior 360,7254
+terminal_init_inferior 366,7300
+terminal_ours 363,7279
+ulimit 463,8913
+vfork 417,8200
+vlimit 469,8955
+wait 554,10975
+write_inferior_register 369,7330
+write_memory 385,7564
+write_register 406,7933
+
+stuff.c,70
+err 162,5253
+find_symbol 141,4686
+get_offset 97,3038
+main 32,1184
+
+symmisc.c,473
+#define CORE_RELOCATE(158,4817
+#define RELOCATE(148,4378
+#define TEXT_RELOCATE(162,4972
+#define UNRELOCATE(152,4573
+block_depth 499,13854
+free_all_symtabs 38,1310
+free_symtab 92,2701
+free_symtab_block 70,1994
+initialize 508,13995
+print_symbol 413,11786
+print_symtabs 353,10199
+read_symsegs 320,9451
+relocate_block 243,7195
+relocate_blockvector 231,6886
+relocate_symbol 268,7855
+relocate_symtab 182,5675
+relocate_type 296,8833
+relocate_typevector 218,6602
+
+symtab.c,716
+block_function 383,10928
+decode_line_1 694,18782
+decode_line_spec 853,22739
+find_line_pc 624,16888
+find_line_pc_range 565,15457
+find_pc_line 425,11975
+find_pc_line_pc_range 655,17363
+find_pc_symtab 395,11161
+functions_info 995,26000
+init_type 1012,26230
+initialize 1032,26680
+list_symbols 916,24143
+lookup_block_symbol 330,9572
+lookup_enum 166,4758
+lookup_function_type 211,6260
+lookup_pointer_type 182,5269
+lookup_struct 134,3824
+lookup_symbol 285,8458
+lookup_symtab 58,1929
+lookup_typename 85,2559
+lookup_union 150,4293
+lookup_unsigned_typename 116,3346
+smash_to_function_type 262,7816
+smash_to_pointer_type 241,7206
+sources_info 868,23119
+types_info 1002,26088
+variables_info 988,25912
+
+test2.c,11
+main 6,86
+
+test3.c,25
+bar 12,123
+newfun 5,51
+
+testbit.c,11
+main 7,58
+
+testfun.c,44
+do_add 7,62
+do_float_add 13,104
+main 1,0
+
+testkill.c,11
+	main(2,1
+
+testrec.c,20
+foo 6,24
+main 1,0
+
+testreg.c,22
+foo 19,341
+main 1,0
+
+testregs.c,23
+foo 2,11
+main 15,321
+
+utils.c,382
+concat 254,5912
+discard_cleanups 84,2483
+do_cleanups 68,2104
+error 213,5038
+fatal 228,5397
+free_current_contents 104,2893
+make_cleanup 48,1636
+parse_escape 323,7736
+perror_with_name 142,3676
+print_spaces 266,6154
+print_sys_errmsg 168,4235
+printchar 390,8781
+query 280,6518
+quit 191,4675
+request_quit 201,4799
+savestring 243,5745
+xmalloc 115,3106
+xrealloc 127,3326
+
+valarith.c,215
+initialize 352,8246
+value_add 31,1128
+value_binop 116,3276
+value_equal 257,5535
+value_less 301,6746
+value_lognot 342,7998
+value_neg 328,7619
+value_sub 70,2102
+value_subscript 105,2971
+value_zerop 233,5184
+
+valops.c,395
+call_function 388,10791
+initialize 594,16295
+push_bytes 314,9135
+push_word 294,8769
+value_addr 247,7400
+value_arg_coerce 354,9928
+value_arg_push 373,10344
+value_assign 85,2697
+value_at 68,2289
+value_cast 34,1302
+value_coerce_array 219,6610
+value_ind 274,8155
+value_of_variable 209,6404
+value_push 333,9476
+value_repeat 186,5819
+value_string 485,13581
+value_struct_elt 555,15503
+
+valprint.c,237
+initialize 533,13661
+set_maximum_command 525,13515
+type_print 272,7365
+type_print_1 283,7591
+type_print_base 403,10889
+type_print_varspec_prefix 316,8617
+type_print_varspec_suffix 352,9476
+val_print 113,3308
+value_print 46,1539
+
+values.c,762
+access_value_history 212,5551
+allocate_repeat_value 83,2505
+allocate_value 59,1948
+clear_internalvars 371,9239
+clear_value_history 251,6511
+convenience_info 386,9475
+free_all_values 108,3143
+history_info 270,6920
+initialize 737,18259
+internalvar_name 361,9048
+lookup_internalvar 308,7852
+modify_field 602,14750
+record_latest_value 178,4634
+release_value 125,3410
+set_internalvar 351,8879
+set_internalvar_component 336,8485
+set_return_value 709,17666
+unpack_double 486,11851
+unpack_field_as_long 578,14176
+unpack_long 430,10615
+value_as_double 418,10252
+value_as_long 411,10132
+value_being_returned 688,17121
+value_copy 151,3834
+value_field 542,13135
+value_from_double 654,16089
+value_from_long 626,15329
+value_of_internalvar 327,8298
+
+vax-pinsn.c,44
+print_insn 42,1456
+print_insn_arg 86,2396
+
+version.c,0
+
+command.h,0
+
+defs.h,42
+#define max(24,1043
+#define min(23,1001
+
+environ.h,0
+
+expression.h,0
+
+frame.h,0
+
+inferior.h,0
+
+initialize.h,0
+
+m-isi-ov.h,852
+#define ABOUT_TO_RETURN(136,4974
+#define FIX_CALL_DUMMY(447,17543
+#define FRAME_ARGS_ADDRESS(275,9997
+#define FRAME_CHAIN(264,9636
+#define FRAME_CHAIN_COMBINE(269,9825
+#define FRAME_CHAIN_VALID(266,9706
+#define FRAME_FIND_SAVED_REGS(305,11191
+#define FRAME_LOCALS_ADDRESS(277,10040
+#define FRAME_NUM_ARGS(282,10176
+#define FRAME_SAVED_PC(273,9929
+#define INIT_STACK(471,18339
+#define INVALID_FLOAT(140,5108
+#define N_DATADDR(120,4437
+#define N_TXTADDR(125,4616
+#define REGISTER_BYTE(194,7220
+#define REGISTER_CONVERTIBLE(222,8151
+#define REGISTER_CONVERT_TO_RAW(236,8614
+#define REGISTER_CONVERT_TO_VIRTUAL(227,8318
+#define REGISTER_RAW_SIZE(203,7555
+#define REGISTER_U_ADDR(174,6379
+#define REGISTER_VIRTUAL_SIZE(209,7811
+#define REGISTER_VIRTUAL_TYPE(245,8895
+#define SAVED_PC_AFTER_CALL(97,3881
+#define SKIP_PROLOGUE(77,3210
+
+m-sun2.h,824
+#define ABOUT_TO_RETURN(79,2505
+#define FIX_CALL_DUMMY(344,12862
+#define FRAME_ARGS_ADDRESS(196,6448
+#define FRAME_CHAIN(185,6087
+#define FRAME_CHAIN_COMBINE(190,6276
+#define FRAME_CHAIN_VALID(187,6157
+#define FRAME_FIND_SAVED_REGS(232,7817
+#define FRAME_LOCALS_ADDRESS(198,6491
+#define FRAME_NUM_ARGS(205,6746
+#define FRAME_NUM_ARGS(208,6795
+#define FRAME_SAVED_PC(194,6380
+#define INIT_STACK(368,13658
+#define INVALID_FLOAT(83,2639
+#define REGISTER_BYTE(121,3997
+#define REGISTER_CONVERTIBLE(144,4615
+#define REGISTER_CONVERT_TO_RAW(154,4927
+#define REGISTER_CONVERT_TO_VIRTUAL(149,4749
+#define REGISTER_RAW_SIZE(126,4162
+#define REGISTER_U_ADDR(166,5375
+#define REGISTER_VIRTUAL_SIZE(131,4317
+#define REGISTER_VIRTUAL_TYPE(159,5092
+#define SAVED_PC_AFTER_CALL(51,1836
+#define SKIP_PROLOGUE(38,1400
+
+m-sun3.h,790
+#define ABOUT_TO_RETURN(78,2454
+#define FIX_CALL_DUMMY(392,15189
+#define FRAME_ARGS_ADDRESS(213,7102
+#define FRAME_CHAIN(202,6741
+#define FRAME_CHAIN_COMBINE(207,6930
+#define FRAME_CHAIN_VALID(204,6811
+#define FRAME_FIND_SAVED_REGS(249,8471
+#define FRAME_LOCALS_ADDRESS(215,7145
+#define FRAME_NUM_ARGS(222,7400
+#define FRAME_NUM_ARGS(225,7449
+#define FRAME_SAVED_PC(211,7034
+#define INIT_STACK(416,15985
+#define INVALID_FLOAT(82,2588
+#define REGISTER_BYTE(123,4130
+#define REGISTER_CONVERTIBLE(151,5061
+#define REGISTER_CONVERT_TO_RAW(165,5524
+#define REGISTER_CONVERT_TO_VIRTUAL(156,5228
+#define REGISTER_RAW_SIZE(132,4465
+#define REGISTER_VIRTUAL_SIZE(138,4721
+#define REGISTER_VIRTUAL_TYPE(174,5805
+#define SAVED_PC_AFTER_CALL(55,1929
+#define SKIP_PROLOGUE(42,1493
+
+m-suninit.h,29
+#define FILEADDR_ROUND(5,94
+
+m-vax.h,791
+#define ABOUT_TO_RETURN(80,2551
+#define FIX_CALL_DUMMY(294,10681
+#define FRAME_ARGS_ADDRESS(199,6661
+#define FRAME_CHAIN(185,6120
+#define FRAME_CHAIN_COMBINE(190,6314
+#define FRAME_CHAIN_VALID(187,6195
+#define FRAME_FIND_SAVED_REGS(222,7517
+#define FRAME_LOCALS_ADDRESS(204,6836
+#define FRAME_NUM_ARGS(209,6972
+#define FRAME_SAVED_PC(194,6418
+#define INIT_STACK(317,11455
+#define INVALID_FLOAT(84,2681
+#define REGISTER_BYTE(127,4329
+#define REGISTER_CONVERTIBLE(150,4942
+#define REGISTER_CONVERT_TO_RAW(161,5257
+#define REGISTER_CONVERT_TO_VIRTUAL(155,5076
+#define REGISTER_RAW_SIZE(132,4491
+#define REGISTER_U_ADDR(112,3753
+#define REGISTER_VIRTUAL_SIZE(137,4644
+#define REGISTER_VIRTUAL_TYPE(167,5425
+#define SAVED_PC_AFTER_CALL(53,1877
+#define SKIP_PROLOGUE(42,1480
+
+m-vaxinit.h,29
+#define FILEADDR_ROUND(5,94
+
+m68k-opcode.h,138
+#define one(130,5680
+int numopcodes=sizeof(1270,68164
+struct m68k_opcode *endop = m68k_opcodes+sizeof(1272,68226
+#define two(131,5707
+
+obstack.h,618
+#define obstack_1grow(252,11387
+#define obstack_1grow_fast(275,12190
+#define obstack_alignment_mask(228,10489
+#define obstack_alloc(263,11796
+#define obstack_base(216,10145
+#define obstack_begin(232,10606
+#define obstack_blank(257,11569
+#define obstack_blank_fast(277,12257
+#define obstack_copy(266,11889
+#define obstack_copy0(269,11994
+#define obstack_finish(279,12314
+#define obstack_free(290,12730
+#define obstack_grow(237,10784
+#define obstack_grow0(244,11064
+#define obstack_init(230,10547
+#define obstack_next_free(220,10254
+#define obstack_object_size(224,10341
+#define obstack_room(272,12101
+
+param.h,0
+
+symseg.h,0
+
+symtab.h,1291
+#define BLOCKLIST(108,3923
+#define BLOCKLIST_BLOCK(137,4911
+#define BLOCKLIST_NBLOCKS(136,4853
+#define BLOCKVECTOR(109,3971
+#define BLOCKVECTOR_BLOCK(139,5030
+#define BLOCKVECTOR_NBLOCKS(138,4970
+#define BLOCK_END(145,5244
+#define BLOCK_FUNCTION(148,5354
+#define BLOCK_NSYMS(146,5280
+#define BLOCK_START(144,5204
+#define BLOCK_SUPERBLOCK(149,5396
+#define BLOCK_SYM(147,5316
+#define LINELIST(113,4071
+#define LINETABLE(114,4116
+#define SYMBOL_BLOCK_VALUE(155,5635
+#define SYMBOL_CLASS(153,5539
+#define SYMBOL_NAME(151,5443
+#define SYMBOL_NAMESPACE(152,5486
+#define SYMBOL_TYPE(156,5692
+#define SYMBOL_VALUE(154,5584
+#define TYPEVECTOR(111,4022
+#define TYPEVECTOR_NTYPES(141,5092
+#define TYPEVECTOR_TYPE(142,5147
+#define TYPE_CODE(170,6307
+#define TYPE_FIELD(174,6453
+#define TYPE_FIELDS(172,6403
+#define TYPE_FIELD_BITPOS(178,6712
+#define TYPE_FIELD_BITSIZE(179,6780
+#define TYPE_FIELD_NAME(176,6571
+#define TYPE_FIELD_PACKED(180,6850
+#define TYPE_FIELD_TYPE(175,6507
+#define TYPE_FIELD_VALUE(177,6635
+#define TYPE_FLAGS(168,6187
+#define TYPE_FUNCTION_TYPE(166,6075
+#define TYPE_LENGTH(167,6138
+#define TYPE_NAME(163,5910
+#define TYPE_NFIELDS(171,6352
+#define TYPE_POINTER_TYPE(165,6014
+#define TYPE_TARGET_TYPE(164,5955
+#define TYPE_UNSIGNED(169,6234
+
+value.h,399
+#define COERCE_ARRAY(58,1961
+#define VALUE_ADDRESS(48,1560
+#define VALUE_BITPOS(52,1752
+#define VALUE_BITSIZE(51,1710
+#define VALUE_CONTENTS(46,1469
+#define VALUE_INTERNALVAR(49,1611
+#define VALUE_LVAL(47,1524
+#define VALUE_NEXT(53,1792
+#define VALUE_OFFSET(50,1670
+#define VALUE_REGNO(56,1922
+#define VALUE_REPEATED(54,1828
+#define VALUE_REPETITIONS(55,1872
+#define VALUE_TYPE(45,1433
+
+vax-opcode.h,0
+
+wait.h,331
+#define WCOREDUMP(13,439
+#define WCOREDUMP(21,690
+#define WIFEXITED(10,338
+#define WIFSIGNALED(9,274
+#define WIFSTOPPED(8,231
+#define WRETCODE(11,377
+#define WRETCODE(19,622
+#define WSETSTOP(15,511
+#define WSETSTOP(23,760
+#define WSTOPSIG(12,408
+#define WSTOPSIG(20,656
+#define WTERMSIG(14,478
+#define WTERMSIG(22,726
+
+expread.y,349
+copy_name 929,20955
+end_arglist 516,11399
+free_funcalls 530,11701
+length_of_subexp 963,21859
+parse_c_1 1142,25974
+parse_c_expression 1181,27028
+parse_number 608,13872
+prefixify_expression 943,21291
+prefixify_subexp 1035,23196
+start_arglist 502,11040
+write_exp_elt 547,12040
+write_exp_string 564,12494
+yyerror 920,20800
+yylex 706,15915
diff --git a/gdb/alloca.c b/gdb/alloca.c
new file mode 100644
index 0000000..cfe98f9
--- /dev/null
+++ b/gdb/alloca.c
@@ -0,0 +1,191 @@
+/*
+	alloca -- (mostly) portable public-domain implementation -- D A Gwyn
+
+	last edit:	86/05/30	rms
+	   include config.h, since on VMS it renames some symbols.
+	   Use xmalloc instead of malloc.
+
+	This implementation of the PWB library alloca() function,
+	which is used to allocate space off the run-time stack so
+	that it is automatically reclaimed upon procedure exit, 
+	was inspired by discussions with J. Q. Johnson of Cornell.
+
+	It should work under any C implementation that uses an
+	actual procedure stack (as opposed to a linked list of
+	frames).  There are some preprocessor constants that can
+	be defined when compiling for your specific system, for
+	improved efficiency; however, the defaults should be okay.
+
+	The general concept of this implementation is to keep
+	track of all alloca()-allocated blocks, and reclaim any
+	that are found to be deeper in the stack than the current
+	invocation.  This heuristic does not reclaim storage as
+	soon as it becomes invalid, but it will do so eventually.
+
+	As a special case, alloca(0) reclaims storage without
+	allocating any.  It is a good idea to use alloca(0) in
+	your main control loop, etc. to force garbage collection.
+*/
+#ifndef lint
+static char	SCCSid[] = "@(#)alloca.c	1.1";	/* for the "what" utility */
+#endif
+
+#ifdef emacs
+#include "config.h"
+#ifdef static
+/* actually, only want this if static is defined as ""
+   -- this is for usg, in which emacs must undefine static
+   in order to make unexec workable
+   */
+#ifndef STACK_DIRECTION
+you
+lose
+-- must know STACK_DIRECTION at compile-time
+#endif /* STACK_DIRECTION undefined */
+#endif static
+#endif emacs
+
+#ifdef X3J11
+typedef void	*pointer;		/* generic pointer type */
+#else
+typedef char	*pointer;		/* generic pointer type */
+#endif
+
+#define	NULL	0			/* null pointer constant */
+
+extern void	free();
+extern pointer	xmalloc();
+
+/*
+	Define STACK_DIRECTION if you know the direction of stack
+	growth for your system; otherwise it will be automatically
+	deduced at run-time.
+
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown
+*/
+
+#ifndef STACK_DIRECTION
+#define	STACK_DIRECTION	0		/* direction unknown */
+#endif
+
+#if STACK_DIRECTION != 0
+
+#define	STACK_DIR	STACK_DIRECTION	/* known at compile-time */
+
+#else	/* STACK_DIRECTION == 0; need run-time code */
+
+static int	stack_dir;		/* 1 or -1 once known */
+#define	STACK_DIR	stack_dir
+
+static void
+find_stack_direction (/* void */)
+{
+  static char	*addr = NULL;	/* address of first
+				   `dummy', once known */
+  auto char	dummy;		/* to get stack address */
+
+  if (addr == NULL)
+    {				/* initial entry */
+      addr = &dummy;
+
+      find_stack_direction ();	/* recurse once */
+    }
+  else				/* second entry */
+    if (&dummy > addr)
+      stack_dir = 1;		/* stack grew upward */
+    else
+      stack_dir = -1;		/* stack grew downward */
+}
+
+#endif	/* STACK_DIRECTION == 0 */
+
+/*
+	An "alloca header" is used to:
+	(a) chain together all alloca()ed blocks;
+	(b) keep track of stack depth.
+
+	It is very important that sizeof(header) agree with malloc()
+	alignment chunk size.  The following default should work okay.
+*/
+
+#ifndef	ALIGN_SIZE
+#define	ALIGN_SIZE	sizeof(double)
+#endif
+
+typedef union hdr
+{
+  char	align[ALIGN_SIZE];	/* to force sizeof(header) */
+  struct
+    {
+      union hdr *next;		/* for chaining headers */
+      char *deep;		/* for stack depth measure */
+    } h;
+} header;
+
+/*
+	alloca( size ) returns a pointer to at least `size' bytes of
+	storage which will be automatically reclaimed upon exit from
+	the procedure that called alloca().  Originally, this space
+	was supposed to be taken from the current stack frame of the
+	caller, but that method cannot be made to work for some
+	implementations of C, for example under Gould's UTX/32.
+*/
+
+static header *last_alloca_header = NULL; /* -> last alloca header */
+
+pointer
+alloca (size)			/* returns pointer to storage */
+     unsigned	size;		/* # bytes to allocate */
+{
+  auto char	probe;		/* probes stack depth: */
+  register char	*depth = &probe;
+
+#if STACK_DIRECTION == 0
+  if (STACK_DIR == 0)		/* unknown growth direction */
+    find_stack_direction ();
+#endif
+
+				/* Reclaim garbage, defined as all alloca()ed storage that
+				   was allocated from deeper in the stack than currently. */
+
+  {
+    register header	*hp;	/* traverses linked list */
+
+    for (hp = last_alloca_header; hp != NULL;)
+      if (STACK_DIR > 0 && hp->h.deep > depth
+	  || STACK_DIR < 0 && hp->h.deep < depth)
+	{
+	  register header	*np = hp->h.next;
+
+	  free ((pointer) hp);	/* collect garbage */
+
+	  hp = np;		/* -> next header */
+	}
+      else
+	break;			/* rest are not deeper */
+
+    last_alloca_header = hp;	/* -> last valid storage */
+  }
+
+  if (size == 0)
+    return NULL;		/* no allocation required */
+
+  /* Allocate combined header + user data storage. */
+
+  {
+    register pointer	new = xmalloc (sizeof (header) + size);
+    /* address of header */
+
+    ((header *)new)->h.next = last_alloca_header;
+    ((header *)new)->h.deep = depth;
+
+    last_alloca_header = (header *)new;
+
+    /* User storage begins just after header. */
+
+    return (pointer)((char *)new + sizeof(header));
+  }
+}
+
diff --git a/gdb/bar.c b/gdb/bar.c
new file mode 100644
index 0000000..59e559f
--- /dev/null
+++ b/gdb/bar.c
@@ -0,0 +1,13 @@
+main() {
+	int i;
+
+	for (i = 0; i >= 0; i++)
+		bar();
+}
+
+bar()
+{
+	int i;
+
+	i = 10;
+}
diff --git a/gdb/bar.nm b/gdb/bar.nm
new file mode 100644
index 0000000..6f2df5c
--- /dev/null
+++ b/gdb/bar.nm
@@ -0,0 +1,65 @@
+0000003e - 00 0002 RBRAC 
+000020de - 00 000d SLINE 
+000020d6 - 00 000c SLINE 
+000020c8 - 00 0009 SLINE 
+000020c4 - 00 0006 SLINE 
+00000024 - 00 0002 RBRAC 
+000020be - 00 0004 SLINE 
+000020b8 - 00 0005 SLINE 
+000020ae - 00 0004 SLINE 
+0000000e - 00 0002 LBRAC 
+000020d6 - 00 0009 SLINE 
+000020e4 - 00 ffff SLINE 
+000020ae - 00 0001 SLINE 
+000020a0 - 00 0001 SLINE 
+00000036 - 00 0002 LBRAC 
+000020e4 t -lg
+00000000 - 00 0000  LSYM ???:t(0,12)=(0,1)
+00002098 t Fcrt1.o
+0002001c D _Fmode
+00020020 D _Fstatus
+0000215c T __cleanup
+00002164 T __exit
+00020052 D __exit_nhandlers
+00020056 D __exit_tnames
+00020018 D __skybase
+000020c8 T _bar
+00020000 D _environ
+00020118 D _errno
+00002110 T _exit
+00002164 t _exit.o
+000020e4 T _finitfp_
+00020010 D _fp_state_mc68881
+0002000c D _fp_state_skyffp
+00020008 D _fp_state_software
+00020014 D _fp_state_sunfpa
+00020004 D _fp_switch
+000020a0 T _main
+000020a0 - 00 0000    SO bar.c
+000020a0 t bar.o
+000020c8 - 00 0004   FUN bar:F(0,1)
+0000216c T cerror
+0000216c t cerror.o
+00000000 - 00 0000  LSYM char:t(0,2)=r(0,2);0;127;
+00002020 t crt0.o
+00000000 - 00 0000  LSYM double:t(0,10)=r(0,1);8;0;
+00002110 t exit.o
+0000215c t fakcu.o
+000020e4 t finitfp.o
+00000000 - 00 0000  LSYM float:t(0,9)=r(0,1);4;0;
+00002110 t fp_globals.o
+00002098 T fsoft_used
+fffffffc - 00 0004  LSYM i:(0,1)
+fffffffc - 00 0004  LSYM i:(0,1)
+00000000 - 00 0000  LSYM int:t(0,1)=r(0,1);-2147483648;2147483647;
+000020e4 - 00 0000    SO libg.s
+00000000 - 00 0000  LSYM long:t(0,3)=r(0,1);-2147483648;2147483647;
+000020a0 - 00 0004   FUN main:F(0,1)
+00000000 - 00 0000  LSYM short:t(0,4)=r(0,1);-32768;32767;
+00002020 T start
+00002098 T start_float
+00000000 - 00 0000  LSYM unsigned char:t(0,5)=r(0,1);0;255;
+00000000 - 00 0000  LSYM unsigned int:t(0,8)=r(0,1);0;-1;
+00000000 - 00 0000  LSYM unsigned long:t(0,7)=r(0,1);0;-1;
+00000000 - 00 0000  LSYM unsigned short:t(0,6)=r(0,1);0;65535;
+00000000 - 00 0000  LSYM void:t(0,11)=(0,11)
diff --git a/gdb/bar.s b/gdb/bar.s
new file mode 100644
index 0000000..96b4c07
--- /dev/null
+++ b/gdb/bar.s
@@ -0,0 +1,93 @@
+	.stabs	"bar.c",0144,0,0,LL0
+LL0:
+	.data
+	.stabs	"int:t(0,1)=r(0,1);-2147483648;2147483647;",0x80,0,0,0
+	.stabs	"char:t(0,2)=r(0,2);0;127;",0x80,0,0,0
+	.stabs	"long:t(0,3)=r(0,1);-2147483648;2147483647;",0x80,0,0,0
+	.stabs	"short:t(0,4)=r(0,1);-32768;32767;",0x80,0,0,0
+	.stabs	"unsigned char:t(0,5)=r(0,1);0;255;",0x80,0,0,0
+	.stabs	"unsigned short:t(0,6)=r(0,1);0;65535;",0x80,0,0,0
+	.stabs	"unsigned long:t(0,7)=r(0,1);0;-1;",0x80,0,0,0
+	.stabs	"unsigned int:t(0,8)=r(0,1);0;-1;",0x80,0,0,0
+	.stabs	"float:t(0,9)=r(0,1);4;0;",0x80,0,0,0
+	.stabs	"double:t(0,10)=r(0,1);8;0;",0x80,0,0,0
+	.stabs	"void:t(0,11)=(0,11)",0x80,0,0,0
+	.stabs	"???:t(0,12)=(0,1)",0x80,0,0,0
+	.stabs	"main:F(0,1)",0x24,0,4,_main
+	.text
+	.stabn	0104,0,1,LL1
+LL1:
+|#PROC# 04
+	.globl	_main
+_main:
+|#PROLOGUE# 0
+	link	a6,#0
+	addl	#-LF12,sp
+	moveml	#LS12,sp@
+|#PROLOGUE# 1
+	.stabn	0104,0,1,LL2
+LL2:
+	.stabs	"i:(0,1)",0x80,0,4,-4
+	.stabn	0300,0,2,LL3
+LL3:
+	.stabn	0104,0,4,LL4
+LL4:
+	clrl	a6@(-0x4)
+L16:
+	tstl	a6@(-0x4)
+	jlt	L15
+	.stabn	0104,0,5,LL5
+LL5:
+	jbsr	_bar
+L14:
+	.stabn	0104,0,4,LL6
+LL6:
+	addql	#0x1,a6@(-0x4)
+	jra	L16
+L15:
+	.stabn	0340,0,2,LL7
+LL7:
+	.stabn	0104,0,6,LL8
+LL8:
+LE12:
+	unlk	a6
+	rts
+	LF12 = 4
+	LS12 = 0x0
+	LFF12 = 4
+	LSS12 = 0x0
+	LP12 =	0x8
+	.data
+	.stabs	"bar:F(0,1)",0x24,0,4,_bar
+	.text
+	.stabn	0104,0,9,LL9
+LL9:
+|#PROC# 04
+	.globl	_bar
+_bar:
+|#PROLOGUE# 0
+	link	a6,#0
+	addl	#-LF18,sp
+	moveml	#LS18,sp@
+|#PROLOGUE# 1
+	.stabn	0104,0,9,LL10
+LL10:
+	.stabs	"i:(0,1)",0x80,0,4,-4
+	.stabn	0300,0,2,LL11
+LL11:
+	.stabn	0104,0,12,LL12
+LL12:
+	movl	#0xa,a6@(-0x4)
+	.stabn	0340,0,2,LL13
+LL13:
+	.stabn	0104,0,13,LL14
+LL14:
+LE18:
+	unlk	a6
+	rts
+	LF18 = 4
+	LS18 = 0x0
+	LFF18 = 4
+	LSS18 = 0x0
+	LP18 =	0x8
+	.data
diff --git a/gdb/bar.sym b/gdb/bar.sym
new file mode 100644
index 0000000..a3f4131
--- /dev/null
+++ b/gdb/bar.sym
@@ -0,0 +1,51 @@
+Symtab for file libg.s
+
+Line table:
+
+ line 2 at 20e4
+
+Blockvector:
+
+block #000 (object 0x56f90) [0x20e4..0x20e4]
+  block #001 (object 0x56f7c) [0x20e4..0x20e4] (under 0x56f90)
+
+
+Symtab for file bar.c
+
+Line table:
+
+ line 1 at 20a0
+ line 1 at 20ae
+ line 4 at 20ae
+ line 5 at 20b8
+ line 4 at 20be
+ line 6 at 20c4
+ line 9 at 20c8
+ line 9 at 20d6
+ line 12 at 20d6
+ line 13 at 20de
+
+Blockvector:
+
+block #000 (object 0x56f4c) [0x20a0..0x20e4]
+ int bar; block (object 0x56ef0) starting at 0x20c8,
+ int main; block (object 0x56ea8) starting at 0x20a0,
+  block #001 (object 0x56f08) [0x20a0..0x20e4] (under 0x56f4c)
+   typedef int ???; 
+   typedef char char; 
+   typedef double double; 
+   typedef float float; 
+   typedef int int; 
+   typedef int long; 
+   typedef short short; 
+   typedef unsigned char unsigned char; 
+   typedef unsigned int unsigned int; 
+   typedef unsigned int unsigned long; 
+   typedef unsigned short unsigned short; 
+   typedef void void; 
+    block #002 (object 0x56ea8) [0x20a0..0x20c8] (under 0x56f08) main
+     int i; local at 0xfffffffc,
+    block #003 (object 0x56ef0) [0x20c8..0x20e4] (under 0x56f08) bar
+     int i; local at 0xfffffffc,
+
+
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
new file mode 100644
index 0000000..5ed025c
--- /dev/null
+++ b/gdb/blockframe.c
@@ -0,0 +1,333 @@
+/* Get info from stack frames;
+   convert between frames, blocks, functions and pc values.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+
+/* Address of end of first object file.
+   This file is assumed to be a startup file
+   and frames with pc's inside it
+   are treated as nonexistent.  */
+
+CORE_ADDR first_object_file_end;
+
+/* Address of innermost stack frame (contents of FP register) */
+
+static FRAME current_frame;
+
+struct block *block_for_pc ();
+CORE_ADDR get_pc_function_start ();
+
+START_FILE
+
+/* Return the innermost (currently executing) stack frame.  */
+
+FRAME
+get_current_frame ()
+{
+  /* We assume its address is kept in a general register;
+     param.h says which register.  */
+
+  return current_frame;
+}
+
+void
+set_current_frame (frame)
+     FRAME frame;
+{
+  current_frame = frame;
+}
+
+/* Return the frame that called FRAME.
+   If FRAME is the original frame (it has no caller), return 0.  */
+
+FRAME
+get_prev_frame (frame)
+     FRAME frame;
+{
+  CORE_ADDR pointer;
+  /* The caller of "no frame" is the innermost frame.  */
+  if (frame == 0)
+    return get_current_frame ();
+
+  /* Two macros defined in param.h specify the machine-dependent
+     actions to be performed here.  */
+  /* First, get the frame's chain-pointer.
+     If that is zero, the frame is the outermost frame.  */
+  pointer = FRAME_CHAIN (frame);
+  if (!FRAME_CHAIN_VALID (pointer, frame))
+    return 0;
+  /* If frame has a caller, combine the chain pointer and the frame's own
+     address to get the address of the caller.  */
+  return FRAME_CHAIN_COMBINE (pointer, frame);
+}
+
+/* Return a structure containing various interesting information
+   about a specified stack frame.  */
+
+struct frame_info
+get_frame_info (frame)
+     FRAME frame;
+{
+  struct frame_info val;
+  FRAME current = get_current_frame ();
+  register FRAME frame1;
+
+  val.frame = frame;
+
+  if (frame == current)
+    {
+      val.pc = read_pc ();
+      val.next_frame = 0;
+    }
+  else 
+    {
+      for (frame1 = current; frame1; frame1 = get_prev_frame (frame1))
+	{
+	  QUIT;
+	  if (frame1 == frame)
+	    break;
+
+	  val.pc = FRAME_SAVED_PC (frame1);
+	  val.next_frame = frame1;
+	}
+    }
+
+  return val;
+}
+
+/* Return a structure containing various interesting information
+   about the frame that called FRAME.
+
+   This is much faster than get_frame_info (get_prev_frame (FRAME))
+   because it does not need to search the entire stack
+   to find the frame called by the one being described -- that is FRAME.  */
+
+struct frame_info
+get_prev_frame_info (next_frame)
+     FRAME next_frame;
+{
+  struct frame_info val;
+  register FRAME frame = get_prev_frame (next_frame);
+
+  val.frame = frame;
+  val.next_frame = next_frame;
+
+  if (next_frame == 0)
+    {
+      val.pc = read_pc ();
+    }
+  else 
+    {
+      val.pc = FRAME_SAVED_PC (next_frame);
+    }
+
+  return val;
+}
+
+CORE_ADDR
+get_frame_pc (frame)
+     FRAME frame;
+{
+  struct frame_info fi;
+  fi = get_frame_info (frame);
+  return fi.pc;
+}
+
+/* Find the addresses in which registers are saved in FRAME.  */
+
+void
+get_frame_saved_regs (frame_info_addr, saved_regs_addr)
+     struct frame_info *frame_info_addr;
+     struct frame_saved_regs *saved_regs_addr;
+{
+  FRAME_FIND_SAVED_REGS (*frame_info_addr, *saved_regs_addr);
+}
+
+/* Return the innermost lexical block in execution
+   in a specified stack frame.  The frame address is assumed valid.  */
+
+struct block *
+get_frame_block (frame)
+     FRAME frame;
+{
+  struct frame_info fi;
+
+  fi = get_frame_info (frame);
+  return block_for_pc (fi.pc);
+}
+
+struct block *
+get_current_block ()
+{
+  return block_for_pc (read_pc ());
+}
+
+CORE_ADDR
+get_pc_function_start (pc)
+     CORE_ADDR pc;
+{
+  register struct block *bl = block_for_pc (pc);
+  register struct symbol *symbol;
+  if (bl == 0)
+    {
+      register int misc_index = find_pc_misc_function (pc);
+      if (misc_index >= 0)
+	return misc_function_vector[misc_index].address;
+      return 0;
+    }
+  symbol = block_function (bl);
+  bl = SYMBOL_BLOCK_VALUE (symbol);
+  return BLOCK_START (bl);
+}  
+
+/* Return the symbol for the function executing in frame FRAME.  */
+
+struct symbol *
+get_frame_function (frame)
+     FRAME frame;
+{
+  register struct block *bl = get_frame_block (frame);
+  if (bl == 0)
+    return 0;
+  return block_function (bl);
+}
+
+/* Return the innermost lexical block containing the specified pc value,
+   or 0 if there is none.  */
+
+struct block *
+block_for_pc (pc)
+     register CORE_ADDR pc;
+{
+  register struct block *b;
+  register int bot, top, half;
+  register struct symtab *s;
+  struct blockvector *bl;
+
+  /* First search all symtabs for one whose file contains our pc */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bl = BLOCKVECTOR (s);
+      b = BLOCKVECTOR_BLOCK (bl, 0);
+      if (BLOCK_START (b) <= pc
+	  && BLOCK_END (b) > pc)
+	break;
+    }
+
+  if (s == 0)
+    return 0;
+
+  /* Then search that symtab for the smallest block that wins.  */
+  /* Use binary search to find the last block that starts before PC.  */
+
+  bot = 0;
+  top = BLOCKVECTOR_NBLOCKS (bl);
+
+  while (top - bot > 1)
+    {
+      half = (top - bot + 1) >> 1;
+      b = BLOCKVECTOR_BLOCK (bl, bot + half);
+      if (BLOCK_START (b) <= pc)
+	bot += half;
+      else
+	top = bot + half;
+    }
+
+  /* Now search backward for a block that ends after PC.  */
+
+  while (bot >= 0)
+    {
+      b = BLOCKVECTOR_BLOCK (bl, bot);
+      if (BLOCK_END (b) > pc)
+	return b;
+      bot--;
+    }
+
+  return 0;
+}
+
+/* Return the function containing pc value PC.
+   Returns 0 if function is not known.  */
+
+struct symbol *
+find_pc_function (pc)
+     CORE_ADDR pc;
+{
+  register struct block *b = block_for_pc (pc);
+  if (b == 0)
+    return 0;
+  return block_function (b);
+}
+
+/* Find the misc function whose address is the largest
+   while being less than PC.  Return its index in misc_function_vector.
+   Returns -1 if PC is not in suitable range.  */
+
+int
+find_pc_misc_function (pc)
+     CORE_ADDR pc;
+{
+  register int i;
+
+  /* Note that the last thing in the vector is always _etext.  */
+  for (i = 0; i < misc_function_count; i++)
+    {
+      if (pc < misc_function_vector[i].address)
+	return i - 1;
+    }
+  return -1;
+}
+
+/* Return the innermost stack frame executing inside of the specified block,
+   or zero if there is no such frame.  */
+
+FRAME
+block_innermost_frame (block)
+     struct block *block;
+{
+  struct frame_info fi;
+  register FRAME frame;
+  register CORE_ADDR start = BLOCK_START (block);
+  register CORE_ADDR end = BLOCK_END (block);
+
+  frame = 0;
+  while (1)
+    {
+      fi = get_prev_frame_info (frame);
+      frame = fi.frame;
+      if (frame == 0)
+	return 0;
+      if (fi.pc >= start && fi.pc < end)
+	return frame;
+    }
+}
+
+static
+initialize ()
+{
+}
+
+END_FILE
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
new file mode 100644
index 0000000..82e4075
--- /dev/null
+++ b/gdb/breakpoint.c
@@ -0,0 +1,1096 @@
+/* Everything about breakpoints, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+
+#include <stdio.h>
+
+/* This is the sequence of bytes we insert for a breakpoint.  */
+
+static char break_insn[] = BREAKPOINT;
+
+/* States of enablement of breakpoint.
+   `temporary' means disable when hit.
+   `once' means delete when hit.  */
+
+enum enable { disabled, enabled, temporary, delete};
+
+struct breakpoint
+{
+  struct breakpoint *next;
+  /* Number assigned to distinguish breakpoints.  */
+  int number;
+  /* Address to break at.  */
+  CORE_ADDR address;
+  /* Line number of this address.  Redundant.  */
+  int line_number;
+  /* Symtab of file of this address.  Redundant.  */
+  struct symtab *symtab;
+  /* Zero means disabled; remember the info but don't break here.  */
+  enum enable enable;
+  /* Number of stops at this breakpoint that should
+     be continued automatically before really stopping.  */
+  int ignore_count;
+  /* "Real" contents of byte where breakpoint has been inserted.
+     Valid only when breakpoints are in the program.  */
+  char shadow_contents[sizeof break_insn];
+  /* Nonzero if this breakpoint is now inserted.  */
+  char inserted;
+  /* Nonzero if this is not the first breakpoint in the list
+     for the given address.  */
+  char duplicate;
+  /* Chain of command lines to execute when this breakpoint is hit.  */
+  struct command_line *commands;
+  /* Stack depth (frame).  If nonzero, break only if fp equals this.  */
+  FRAME frame;
+  /* Conditional.  Break only if this expression's value is nonzero.  */
+  struct expression *cond;
+};
+
+#define ALL_BREAKPOINTS(b)  for (b = breakpoint_chain; b; b = b->next)
+
+/* Chain of all breakpoints defined.  */
+
+struct breakpoint *breakpoint_chain;
+
+/* Number of last breakpoint made.  */
+
+static int breakpoint_count;
+
+/* Default address, symtab and line to put a breakpoint at
+   for "break" command with no arg.
+   if default_breakpoint_valid is zero, the other three are
+   not valid, and "break" with no arg is an error.
+
+   This set by print_stack_frame, which calls set_default_breakpoint.  */
+
+int default_breakpoint_valid;
+CORE_ADDR default_breakpoint_address;
+struct symtab *default_breakpoint_symtab;
+int default_breakpoint_line;
+
+/* Remaining commands (not yet executed)
+   of last breakpoint hit.  */
+
+struct command_line *breakpoint_commands;
+
+START_FILE
+
+extern char *read_line ();
+
+static void delete_breakpoint ();
+void clear_momentary_breakpoints ();
+void breakpoint_auto_delete ();
+
+/* condition N EXP -- set break condition of breakpoint N to EXP.  */
+
+static void
+condition_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  register struct breakpoint *b;
+  register char *p;
+  register int bnum;
+  register struct expression *expr;
+
+  if (arg == 0)
+    error_no_arg ("breakpoint number");
+
+  p = arg;
+  while (*p >= '0' && *p <= '9') p++;
+  bnum = atoi (arg);
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bnum)
+      {
+	if (b->cond)
+	  free (b->cond);
+	if (*p == 0)
+	  {
+	    b->cond = 0;
+	    if (from_tty)
+	      printf ("Breakpoint %d now unconditional.\n", bnum);
+	  }
+	else
+	  {
+	    if (*p != ' ' && *p != '\t')
+	      error ("Arguments must be an integer (breakpoint number) and an expression.");
+
+	    /* Find start of expression */
+	    while (*p == ' ' || *p == '\t') p++;
+
+	    arg = p;
+	    b->cond = (struct expression *) parse_c_1 (&arg, block_for_pc (b->address));
+	  }
+	return;
+      }
+
+  error ("No breakpoint number %d.", bnum);
+}
+
+static void
+commands_command (arg)
+     char *arg;
+{
+  register struct breakpoint *b;
+  register char *p, *p1;
+  register int bnum;
+  struct command_line *l;
+
+  if (arg == 0)
+    error_no_arg ("breakpoint number");
+
+  /* If we allowed this, we would have problems with when to
+     free the storage, if we change the commands currently
+     being read from.  */
+
+  if (breakpoint_commands)
+    error ("Can't use the \"commands\" command among a breakpoint's commands.");
+
+  p = arg;
+  if (! (*p >= '0' && *p <= '9'))
+    error ("Argument must be integer (a breakpoint number).");
+
+  while (*p >= '0' && *p <= '9') p++;
+  if (*p)
+    error ("Unexpected extra arguments following breakpoint number.");
+
+  bnum = atoi (arg);
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bnum)
+      {
+	if (input_from_terminal_p ())
+	  printf ("Type commands for when breakpoint %d is hit, one per line.\n\
+End with a line saying just \"end\".\n", bnum);
+	l = read_command_lines ();
+	free_command_lines (&b->commands);
+	b->commands = l;
+	return;
+      }
+  error ("No breakpoint number %d.", bnum);
+}
+
+/* Called from command loop to execute the commands
+   associated with the breakpoint we just stopped at.  */
+
+void
+do_breakpoint_commands ()
+{
+  while (breakpoint_commands)
+    {
+      char *line = breakpoint_commands->line;
+      breakpoint_commands = breakpoint_commands->next;
+      execute_command (line, 0);
+      /* If command was "cont", breakpoint_commands is now 0,
+	 of if we stopped at yet another breakpoint which has commands,
+	 it is now the commands for the new breakpoint.  */
+    }
+  clear_momentary_breakpoints ();
+}
+
+/* Used when the program is proceeded, to eliminate any remaining
+   commands attached to the previous breakpoint we stopped at.  */
+
+void
+clear_breakpoint_commands ()
+{
+  breakpoint_commands = 0;
+  breakpoint_auto_delete (0);
+}
+
+/* Functions to get and set the current list of pending
+   breakpoint commands.  These are used by run_stack_dummy
+   to preserve the commands around a function call.  */
+
+struct command_line *
+get_breakpoint_commands ()
+{
+  return breakpoint_commands;
+}
+
+void
+set_breakpoint_commands (cmds)
+     struct command_line *cmds;
+{
+  breakpoint_commands = cmds;
+}
+
+/* insert_breakpoints is used when starting or continuing the program.
+   remove_breakpoints is used when the program stops.
+   Both return zero if successful,
+   or an `errno' value if could not write the inferior.  */
+
+int
+insert_breakpoints ()
+{
+  register struct breakpoint *b;
+  int val;
+
+/*   printf ("Inserting breakpoints.\n"); */
+  ALL_BREAKPOINTS (b)
+    if (b->enable != disabled && ! b->inserted && ! b->duplicate)
+      {
+	read_memory (b->address, b->shadow_contents, sizeof break_insn);
+	val = write_memory (b->address, break_insn, sizeof break_insn);
+	if (val)
+	  return val;
+/*	printf ("Inserted breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
+		b->address, b->shadow_contents[0], b->shadow_contents[1]); */
+	b->inserted = 1;
+      }
+  return 0;
+}
+
+int
+remove_breakpoints ()
+{
+  register struct breakpoint *b;
+  int val;
+
+/*   printf ("Removing breakpoints.\n"); */
+  ALL_BREAKPOINTS (b)
+    if (b->inserted)
+      {
+	val = write_memory (b->address, b->shadow_contents, sizeof break_insn);
+	if (val)
+	  return val;
+	b->inserted = 0;
+/*	printf ("Removed breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
+		b->address, b->shadow_contents[0], b->shadow_contents[1]); */
+      }
+
+  return 0;
+}
+
+/* Clear the "inserted" flag in all breakpoints.
+   This is done when the inferior is loaded.  */
+
+int
+mark_breakpoints_out ()
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    b->inserted = 0;
+}
+
+/* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
+   When continuing from a location with a breakpoint,
+   we actually single step once before calling insert_breakpoints.  */
+
+int
+breakpoint_here_p (pc)
+     CORE_ADDR pc;
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable != disabled && b->address == pc)
+      return 1;
+
+  return 0;
+}
+
+/* Return 0 if PC is not the address just after a breakpoint,
+   or -1 if breakpoint says do not stop now,
+   or -2 if breakpoint says it has deleted itself and don't stop,
+   or -3 if hit a breakpoint number -3 (delete when program stops),
+   or else the number of the breakpoint,
+   with 0x1000000 added for a silent breakpoint.  */
+
+int
+breakpoint_stop_status (pc, frame)
+     CORE_ADDR pc;
+     FRAME frame;
+{
+  register struct breakpoint *b;
+  register int cont = 0;
+
+  /* Get the address where the breakpoint would have been.  */
+  pc -= DECR_PC_AFTER_BREAK;
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable != disabled && b->address == pc)
+      {
+	if (b->frame && b->frame != frame)
+	  cont = -1;
+	else
+	  {
+	    int value_zero;
+	    if (b->cond)
+	      {
+		value_zero = value_zerop (evaluate_expression (b->cond));
+		free_all_values ();
+	      }
+	    if (b->cond && value_zero)
+	      {
+		cont = -1;
+	      }
+	    else if (b->ignore_count > 0)
+	      {
+		b->ignore_count--;
+		cont = -1;
+	      }
+	    else
+	      {
+		if (b->enable == temporary)
+		  b->enable = disabled;
+		breakpoint_commands = b->commands;
+		if (breakpoint_commands
+		    && !strcmp ("silent", breakpoint_commands->line))
+		  {
+		    breakpoint_commands = breakpoint_commands->next;
+		    return 0x1000000 + b->number;
+		  }
+		return b->number;
+	      }
+	  }
+      }
+
+  return cont;
+}
+
+static void
+breakpoint_1 (bnum)
+     int bnum;
+{
+  register struct breakpoint *b;
+  register struct command_line *l;
+  register struct symbol *sym;
+  CORE_ADDR last_addr = -1;
+
+  ALL_BREAKPOINTS (b)
+    if (bnum == -1 || bnum == b->number)
+      {
+	printf ("#%-3d %c  0x%08x ", b->number,
+		"nyod"[(int) b->enable],
+		b->address);
+	last_addr = b->address;
+	if (b->symtab)
+	  {
+	    sym = find_pc_function (b->address);
+	    if (sym)
+	      printf (" in %s (%s line %d)", SYMBOL_NAME (sym),
+		      b->symtab->filename, b->line_number);
+	    else
+	      printf ("%s line %d", b->symtab->filename, b->line_number);
+	  }
+	printf ("\n");
+
+	if (b->ignore_count)
+	  printf ("\tignore next %d hits\n", b->ignore_count);
+	if (b->frame)
+	  printf ("\tstop only in stack frame at 0x%x\n", b->frame);
+	if (b->cond)
+	  {
+	    printf ("\tbreak only if ");
+	    print_expression (b->cond, stdout);
+	    printf ("\n");
+	  }
+	if (l = b->commands)
+	  while (l)
+	    {
+	      printf ("\t%s\n", l->line);
+	      l = l->next;
+	    }
+      }
+
+  if (last_addr != -1)
+    set_next_address (last_addr);
+}
+
+static void
+breakpoints_info (bnum_exp)
+     char *bnum_exp;
+{
+  int bnum = -1;
+
+  if (bnum_exp)
+    bnum = parse_and_eval_address (bnum_exp);
+  else if (breakpoint_chain == 0)
+    printf ("No breakpoints.\n");
+  else
+    printf ("Breakpoints:\n\
+Num Enb   Address    Where\n");
+
+  breakpoint_1 (bnum);
+}
+
+/* Print a message describing any breakpoints set at PC.  */
+
+static void
+describe_other_breakpoints (pc)
+     register CORE_ADDR pc;
+{
+  register int others = 0;
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->address == pc)
+      others++;
+  if (others > 0)
+    {
+      printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
+      ALL_BREAKPOINTS (b)
+	if (b->address == pc)
+	  {
+	    others--;
+	    printf ("%d%s%s ",
+		    b->number,
+		    (b->enable == disabled) ? " (disabled)" : "",
+		    (others > 1) ? "," : ((others == 1) ? " and" : ""));
+	  }
+      printf (" also set at pc 0x%x\n", pc);
+    }
+}
+
+/* Set the default place to put a breakpoint
+   for the `break' command with no arguments.  */
+
+void
+set_default_breakpoint (valid, addr, symtab, line)
+     int valid;
+     CORE_ADDR addr;
+     struct symtab *symtab;
+     int line;
+{
+  default_breakpoint_valid = valid;
+  default_breakpoint_address = addr;
+  default_breakpoint_symtab = symtab;
+  default_breakpoint_line = line;
+}
+
+/* Rescan breakpoints at address ADDRESS,
+   marking the first one as "first" and any others as "duplicates".
+   This is so that the bpt instruction is only inserted once.  */
+
+static void
+check_duplicates (address)
+     CORE_ADDR address;
+{
+  register struct breakpoint *b;
+  register int count = 0;
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable != disabled && b->address == address)
+      {
+	count++;
+	b->duplicate = count > 1;
+      }
+}
+
+/* Low level routine to set a breakpoint.
+   Takes as args the three things that every breakpoint must have.
+   Returns the breakpoint object so caller can set other things.
+   Does not set the breakpoint number!
+   Does not print anything.  */
+
+static struct breakpoint *
+set_raw_breakpoint (sal)
+     struct symtab_and_line sal;
+{
+  register struct breakpoint *b, *b1;
+
+  b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
+  bzero (b, sizeof *b);
+  b->address = sal.pc;
+  b->symtab = sal.symtab;
+  b->line_number = sal.line;
+  b->enable = enabled;
+  b->next = 0;
+
+  /* Add this breakpoint to the end of the chain
+     so that a list of breakpoints will come out in order
+     of increasing numbers.  */
+
+  b1 = breakpoint_chain;
+  if (b1 == 0)
+    breakpoint_chain = b;
+  else
+    {
+      while (b1->next)
+	b1 = b1->next;
+      b1->next = b;
+    }
+
+  check_duplicates (sal.pc);
+
+  return b;
+}
+
+/* Set a breakpoint that will evaporate an end of command
+   at address specified by SAL.
+   Restrict it to frame FRAME if FRAME is nonzero.  */
+
+void
+set_momentary_breakpoint (sal, frame)
+     struct symtab_and_line sal;
+     FRAME frame;
+{
+  register struct breakpoint *b;
+  b = set_raw_breakpoint (sal);
+  b->number = -3;
+  b->enable = delete;
+  b->frame = frame;
+}
+
+void
+clear_momentary_breakpoints ()
+{
+  register struct breakpoint *b;
+  ALL_BREAKPOINTS (b)
+    if (b->number == -3)
+      {
+	delete_breakpoint (b);
+	break;
+      }
+}
+
+/* Set a breakpoint from a symtab and line.
+   If TEMPFLAG is nonzero, it is a temporary breakpoint.
+   Print the same confirmation messages that the breakpoint command prints.  */
+
+void
+set_breakpoint (s, line, tempflag)
+     struct symtab *s;
+     int line;
+     int tempflag;
+{
+  register struct breakpoint *b;
+  struct symtab_and_line sal;
+  
+  sal.symtab = s;
+  sal.line = line;
+  sal.pc = find_line_pc (sal.symtab, sal.line);
+  if (sal.pc == 0)
+    error ("No line %d in file \"%s\".\n", sal.line, sal.symtab->filename);
+  else
+    {
+      describe_other_breakpoints (sal.pc);
+
+      b = set_raw_breakpoint (sal);
+      b->number = ++breakpoint_count;
+      b->cond = 0;
+      if (tempflag)
+	b->enable = temporary;
+
+      printf ("Breakpoint %d at 0x%x", b->number, b->address);
+      if (b->symtab)
+	printf (": file %s, line %d.", b->symtab->filename, b->line_number);
+      printf ("\n");
+    }
+}
+
+/* Set a breakpoint according to ARG (function, linenum or *address)
+   and make it temporary if TEMPFLAG is nonzero.  */
+
+static void
+break_command_1 (arg, tempflag, from_tty)
+     char *arg;
+     int tempflag, from_tty;
+{
+  struct symtab_and_line sal;
+  register struct expression *cond = 0;
+  register struct breakpoint *b;
+
+  sal.pc = 0;
+
+  if (arg)
+    {
+      sal = decode_line_1 (&arg, 1, 0, 0);
+
+      if (sal.pc == 0 && sal.symtab != 0)
+	{
+	  sal.pc = find_line_pc (sal.symtab, sal.line);
+	  if (sal.pc == 0)
+	    error ("No line %d in file \"%s\".",
+		   sal.line, sal.symtab->filename);
+	}
+
+      while (*arg)
+	{
+	  if (arg[0] == 'i' && arg[1] == 'f'
+	      && (arg[2] == ' ' || arg[2] == '\t'))
+	    cond = (struct expression *) parse_c_1 ((arg += 2, &arg),
+						    block_for_pc (sal.pc));
+	  else
+	    error ("Junk at end of arguments.");
+	}
+    }
+  else if (default_breakpoint_valid)
+    {
+      sal.pc = default_breakpoint_address;
+      sal.line = default_breakpoint_line;
+      sal.symtab = default_breakpoint_symtab;
+    }
+  else
+    error ("No default breakpoint address now.");
+
+  if (from_tty)
+    describe_other_breakpoints (sal.pc);
+
+  b = set_raw_breakpoint (sal);
+  b->number = ++breakpoint_count;
+  b->cond = cond;
+  if (tempflag)
+    b->enable = temporary;
+
+  printf ("Breakpoint %d at 0x%x", b->number, b->address);
+  if (b->symtab)
+    printf (": file %s, line %d.", b->symtab->filename, b->line_number);
+  printf ("\n");
+}
+
+static void
+break_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  break_command_1 (arg, 0, from_tty);
+}
+
+static void
+tbreak_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  break_command_1 (arg, 1, from_tty);
+}
+
+static void
+clear_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  register struct breakpoint *b, *b1;
+  struct symtab_and_line sal;
+  register struct breakpoint *found;
+
+  if (arg)
+    sal = decode_line_spec (arg, 1);
+  else
+    {
+      sal.line = default_breakpoint_line;
+      sal.symtab = default_breakpoint_symtab;
+      sal.pc = 0;
+      if (sal.symtab == 0)
+	error ("No source file specified.");
+    }
+
+  /* If exact pc given, clear bpts at that pc.
+     But if sal.pc is zero, clear all bpts on specified line.  */
+
+  found = (struct breakpoint *) 0;
+  while (breakpoint_chain
+	 && (sal.pc ? breakpoint_chain->address == sal.pc
+	     : (breakpoint_chain->symtab == sal.symtab
+		&& breakpoint_chain->line_number == sal.line)))
+    {
+      b1 = breakpoint_chain;
+      breakpoint_chain = b1->next;
+      b1->next = found;
+      found = b1;
+    }
+
+  ALL_BREAKPOINTS (b)
+    while (b->next
+	   && (sal.pc ? b->next->address == sal.pc
+	       : (b->next->symtab == sal.symtab
+		  && b->next->line_number == sal.line)))
+      {
+	b1 = b->next;
+	b->next = b1->next;
+	b1->next = found;
+	found = b1;
+      }
+
+  if (found == 0)
+    error ("No breakpoint at %s.", arg);
+
+  if (found->next) from_tty = 1; /* Alwats report if deleted more than one */
+  if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
+  while (found)
+    {
+      if (from_tty) printf ("%d ", found->number);
+      b1 = found->next;
+      delete_breakpoint (found);
+      found = b1;
+    }
+  if (from_tty) putchar ('\n');
+}
+
+/* Delete breakpoint number BNUM if it is a `delete' breakpoint.
+   This is called after breakpoint BNUM has been hit.
+   Also delete any breakpoint numbered -3 unless there are breakpoint
+   commands to be executed.  */
+
+void
+breakpoint_auto_delete (bnum)
+     int bnum;
+{
+  register struct breakpoint *b;
+  if (bnum != 0)
+    ALL_BREAKPOINTS (b)
+      if (b->number == bnum)
+	{
+	  if (b->enable == delete)
+	    delete_breakpoint (b);
+	  break;
+	}
+  if (breakpoint_commands == 0)
+    clear_momentary_breakpoints ();
+}
+
+static void
+delete_breakpoint (bpt)
+     struct breakpoint *bpt;
+{
+  register struct breakpoint *b;
+
+  if (bpt->inserted)
+    write_memory (bpt->address, bpt->shadow_contents, sizeof break_insn);
+
+  if (breakpoint_chain == bpt)
+    breakpoint_chain = bpt->next;
+
+  ALL_BREAKPOINTS (b)
+    if (b->next == bpt)
+      {
+	b->next = bpt->next;
+	break;
+      }
+
+  check_duplicates (bpt->address);
+
+  free_command_lines (&bpt->commands);
+  if (bpt->cond)
+    free (bpt->cond);
+  free (bpt);
+}
+
+void map_breakpoint_numbers ();
+
+static void
+delete_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  register struct breakpoint *b, *b1;
+
+  if (arg == 0)
+    {
+      if (!from_tty || query ("Delete all breakpoints? "))
+	{
+	  /* No arg; clear all breakpoints.  */
+	  while (breakpoint_chain)
+	    delete_breakpoint (breakpoint_chain);
+	}
+    }
+  else
+    map_breakpoint_numbers (arg, delete_breakpoint);
+}
+
+/* Delete all breakpoints.
+   Done when new symtabs are loaded, since the break condition expressions
+   may become invalid, and the breakpoints are probably wrong anyway.  */
+
+void
+clear_breakpoints ()
+{
+  delete_command (0, 0);
+}
+
+/* Set ignore-count of breakpoint number BPTNUM to COUNT.
+   If from_tty is nonzero, it prints a message to that effect,
+   which ends with a period (no newline).  */
+
+void
+set_ignore_count (bptnum, count, from_tty)
+     int bptnum, count, from_tty;
+{
+  register struct breakpoint *b;
+
+  if (count < 0)
+    count = 0;
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bptnum)
+      {
+	b->ignore_count = count;
+	if (!from_tty)
+	  return;
+	else if (count == 0)
+	  printf ("Will stop next time breakpoint %d is reached.", bptnum);
+	else if (count == 1)
+	  printf ("Will ignore next crossing of breakpoint %d.", bptnum);
+	else
+	  printf ("Will ignore next %d crossings of breakpoint %d.",
+		  count, bptnum);
+	return;
+      }
+
+  error ("No breakpoint number %d.", bptnum);
+}
+
+/* Command to set ignore-count of breakpoint N to COUNT.  */
+
+static void
+ignore_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  register char *p;
+  register int num;
+
+  if (p == 0)
+    error_no_arg ("a breakpoint number");
+  
+  p = args;
+  while (*p >= '0' && *p <= '9') p++;
+  if (*p && *p != ' ' && *p != '\t')
+    error ("First argument must be a breakpoint number.");
+
+  num = atoi (args);
+
+  if (*p == 0)
+    error ("Second argument (specified ignore-count) is missing.");
+
+  set_ignore_count (num, parse_and_eval_address (p), from_tty);
+  printf ("\n");
+}
+
+/* Call FUNCTION on each of the breakpoints
+   whose numbers are given in ARGS.  */
+
+static void
+map_breakpoint_numbers (args, function)
+     char *args;
+     void (*function) ();
+{
+  register char *p = args;
+  register char *p1;
+  register int num;
+  register struct breakpoint *b;
+
+  if (p == 0)
+    error_no_arg ("one or more breakpoint numbers");
+
+  while (*p)
+    {
+      p1 = p;
+      while (*p1 >= '0' && *p1 <= '9') p1++;
+      if (*p1 && *p1 != ' ' && *p1 != '\t')
+	error ("Arguments must be breakpoint numbers.");
+
+      num = atoi (p);
+
+      ALL_BREAKPOINTS (b)
+	if (b->number == num)
+	  {
+	    function (b);
+	    goto win;
+	  }
+      printf ("No breakpoint number %d.\n", num);
+    win:
+      p = p1;
+      while (*p == ' ' || *p == '\t') p++;
+    }
+}
+
+static void
+enable_breakpoint (bpt)
+     struct breakpoint *bpt;
+{
+  bpt->enable = enabled;
+
+  check_duplicates (bpt->address);
+}
+
+static void
+enable_command (args)
+     char *args;
+{
+  map_breakpoint_numbers (args, enable_breakpoint);
+}
+
+static void
+disable_breakpoint (bpt)
+     struct breakpoint *bpt;
+{
+  bpt->enable = disabled;
+
+  check_duplicates (bpt->address);
+}
+
+static void
+disable_command (args)
+     char *args;
+{
+  register struct breakpoint *bpt;
+  if (args == 0)
+    ALL_BREAKPOINTS (bpt)
+      disable_breakpoint (bpt);
+  else
+    map_breakpoint_numbers (args, disable_breakpoint);
+}
+
+static void
+enable_once_breakpoint (bpt)
+     struct breakpoint *bpt;
+{
+  bpt->enable = temporary;
+
+  check_duplicates (bpt->address);
+}
+
+static void
+enable_once_command (args)
+     char *args;
+{
+  map_breakpoint_numbers (args, enable_once_breakpoint);
+}
+
+static void
+enable_delete_breakpoint (bpt)
+     struct breakpoint *bpt;
+{
+  bpt->enable = delete;
+
+  check_duplicates (bpt->address);
+}
+
+static void
+enable_delete_command (args)
+     char *args;
+{
+  map_breakpoint_numbers (args, enable_delete_breakpoint);
+}
+
+
+/* Chain containing all defined enable commands.  */
+
+struct cmd_list_element *enablelist;
+
+extern struct cmd_list_element *cmdlist;
+
+static
+initialize ()
+{
+  breakpoint_chain = 0;
+  breakpoint_count = 0;
+  enablelist = 0;
+
+  add_com ("ignore", class_breakpoint, ignore_command,
+	   "Set ignore-count of breakpoint number N to COUNT.");
+
+  add_com ("commands", class_breakpoint, commands_command,
+	   "Set commands to be executed when a breakpoint is hit.\n\
+Give breakpoint number as argument after \"commands\".\n\
+The commands themselves follow starting on the next line.\n\
+Type a line containing \"end\" to indicate the end of them.\n\
+Give \"silent\" as the first line to make the breakpoint silent;\n\
+then no output is printed when it is hit, except what the commands print.");
+
+  add_com ("condition", class_breakpoint, condition_command,
+	   "Specify breakpoint number N to break only if COND is true.\n\
+N is an integer; COND is a C expression to be evaluated whenever\n\
+breakpoint N is reached.  Actually break only when COND is nonzero.");
+
+  add_com ("tbreak", class_breakpoint, tbreak_command,
+	   "Set a temporary breakpoint.  Args like \"break\" command.\n\
+Like \"break\" except the breakpoint is only enabled temporarily,\n\
+so it will be disabled when hit.  Equivalent to \"break\" followed\n\
+by using \"enable once\" on the breakpoint number.");
+
+  add_prefix_cmd ("enable", class_breakpoint, enable_command,
+		  "Enable some breakpoints.  Give breakpoint numbers as arguments.\n\
+With no subcommand, breakpoints are enabled until you command otherwise.\n\
+This is used to cancel the effect of the \"disable\" command.\n\
+With a subcommand you can enable temporarily.",
+		  &enablelist, "enable ", 1, &cmdlist);
+
+  add_cmd ("delete", 0, enable_delete_command,
+	   "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it is deleted.",
+	   &enablelist);
+
+  add_cmd ("once", 0, enable_once_command,
+	   "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
+See the \"tbreak\" command which sets a breakpoint and enables it once.",
+	   &enablelist);
+
+  add_com ("disable", class_breakpoint, disable_command,
+	   "Disable some breakpoints.  Give breakpoint numbers as arguments.\n\
+With no arguments, disable all breakpoints.\n\
+A disabled breakpoint is not forgotten,\n\
+but it has no effect until enabled again.");
+  add_com_alias ("dis", "disable", class_breakpoint, 1);
+
+  add_com ("delete", class_breakpoint, delete_command,
+	   "Delete breakpoints, specifying breakpoint numbers; or all breakpoints.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To delete all breakpoints, give no argument.");
+  add_com_alias ("d", "delete", class_breakpoint, 1);
+
+  add_com ("clear", class_breakpoint, clear_command,
+	   "Clear breakpoint at specified line or function.\n\
+Argument may be line number, function name, or \"*\" and an address.\n\
+If line number is specified, all breakpoints in that line are cleared.\n\
+If function is specified, breakpoints at beginning of function are cleared.\n\
+If an address is specified, breakpoints at that address are cleared.\n\n\
+With no argument, clears all breakpoints in the line that the selected frame\n\
+is executing in.\n\
+\n\
+See also the \"delete\" command which clears breakpoints by number.");
+
+  add_com ("break", class_breakpoint, break_command,
+	   "Set breakpoint at specified line or function.\n\
+Argument may be line number, function name, or \"*\" and an address.\n\
+If line number is specified, break at start of code for that line.\n\
+If function is specified, break at start of code for that function.\n\
+If an address is specified, break at that exact address.\n\
+With no arg, uses current execution address of selected stack frame.\n\
+This is useful for breaking on return to a stack frame.\n\
+\n\
+Multiple breakpoints at one place are permitted, and useful if conditional.\n\
+\n\
+Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
+  add_com_alias ("b", "break", class_run, 1);
+  add_com_alias ("br", "break", class_run, 1);
+  add_com_alias ("bre", "break", class_run, 1);
+  add_com_alias ("brea", "break", class_run, 1);
+
+  add_info ("breakpoints", breakpoints_info,
+	    "Status of all breakpoints, or breakpoint number NUMBER.\n\
+Second column is \"y\" for enabled breakpoint, \"n\" for disabled,\n\
+\"o\" for enabled once (disable when hit), \"d\" for enable but delete when hit.\n\
+Then come the address and the file/line number.\n\n\
+Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.");
+}
+
+END_FILE
diff --git a/gdb/coffread.c b/gdb/coffread.c
new file mode 100644
index 0000000..626b16f
--- /dev/null
+++ b/gdb/coffread.c
@@ -0,0 +1,1860 @@
+/* Read coff symbol tables and convert to internal format, for GDB.
+   Design and support routines derived from dbxread.c, and UMAX COFF
+   specific routines written 9/1/87 by David D. Johnson, Brown University.
+   Revised 11/27/87 ddj@cs.brown.edu
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "param.h"
+#ifdef COFF_FORMAT
+#include "initialize.h"
+#include "symtab.h"
+
+#include <a.out.h>
+#include <stdio.h>
+#include <obstack.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/file.h>
+
+static void add_symbol_to_list ();
+static void read_coff_symtab ();
+static void patch_opaque_types ();
+static struct type *decode_function_type ();
+static struct type *decode_type ();
+static struct type *decode_base_type ();
+static struct type *read_enum_type ();
+static struct type *read_struct_type ();
+static void finish_block ();
+static struct blockvector *make_blockvector ();
+static struct symbol *process_coff_symbol ();
+static int init_stringtab ();
+static void free_stringtab ();
+static char *getfilename ();
+static char *getsymname ();
+static int init_lineno ();
+static void enter_linenos ();
+
+START_FILE
+
+/* Name of source file whose symbol data we are now processing.
+   This comes from a symbol named ".file".  */
+
+static char *last_source_file;
+
+/* Core address of start and end of text of current source file.
+   This comes from a ".text" symbol where x_nlinno > 0.  */
+
+static CORE_ADDR cur_src_start_addr;
+static CORE_ADDR cur_src_end_addr;
+
+/* End of the text segment of the executable file,
+   as found in the symbol _etext.  */
+
+static CORE_ADDR end_of_text_addr;
+
+/* The addresses of the symbol table stream and number of symbols
+   of the object file we are reading (as copied into core).  */
+
+static FILE *nlist_stream_global;
+static int nlist_nsyms_global;
+
+/* The file and text section headers of the symbol file */
+
+static FILHDR file_hdr;
+static SCNHDR text_hdr;
+
+/* The index in the symbol table of the last coff symbol that was processed.  */
+
+static int symnum;
+
+/* Vector of types defined so far, indexed by their coff symnum.  */
+
+static struct typevector *type_vector;
+
+/* Number of elements allocated for type_vector currently.  */
+
+static int type_vector_length;
+
+/* Vector of line number information.  */
+
+static struct linetable *line_vector;
+
+/* Index of next entry to go in line_vector_index.  */
+
+static int line_vector_index;
+
+/* Last line number recorded in the line vector.  */
+
+static int prev_line_number;
+
+/* Number of elements allocated for line_vector currently.  */
+
+static int line_vector_length;
+
+/* Chain of typedefs of pointers to empty struct/union types.
+   They are chained thru the SYMBOL_VALUE.  */
+
+#define HASHSIZE 127
+static struct symbol *opaque_type_chain[HASHSIZE];
+
+/* Record the symbols defined for each context in a list.
+   We don't create a struct block for the context until we
+   know how long to make it.  */
+
+struct pending
+{
+  struct pending *next;
+  struct symbol *symbol;
+};
+
+/* Here are the three lists that symbols are put on.  */
+
+struct pending *file_symbols;	/* static at top level, and types */
+
+struct pending *global_symbols;	/* global functions and variables */
+
+struct pending *local_symbols;	/* everything local to lexical context */
+
+/* List of unclosed lexical contexts
+   (that will become blocks, eventually).  */
+
+struct context_stack
+{
+  struct context_stack *next;
+  struct pending *locals;
+  struct pending_block *old_blocks;
+  struct symbol *name;
+  CORE_ADDR start_addr;
+  int depth;
+};
+
+struct context_stack *context_stack;
+
+/* Nonzero if within a function (so symbols should be local,
+   if nothing says specifically).  */
+
+int within_function;
+
+/* List of blocks already made (lexical contexts already closed).
+   This is used at the end to make the blockvector.  */
+
+struct pending_block
+{
+  struct pending_block *next;
+  struct block *block;
+};
+
+struct pending_block *pending_blocks;
+
+extern CORE_ADDR first_object_file_end;	/* From blockframe.c */
+
+/* File name symbols were loaded from.  */
+
+static char *symfile;
+
+int debug = 1;
+
+
+/* Look up a coff type-number index.  Return the address of the slot
+   where the type for that index is stored.
+   The type-number is in INDEX. 
+
+   This can be used for finding the type associated with that index
+   or for associating a new type with the index.  */
+
+static struct type **
+coff_lookup_type (index)
+     register int index;
+{
+  if (index >= type_vector_length)
+    {
+      type_vector_length *= 2;
+      type_vector = (struct typevector *)
+	xrealloc (type_vector, sizeof (struct typevector)
+				+ type_vector_length * sizeof (struct type *));
+      bzero (&type_vector->type[type_vector_length / 2],
+	     type_vector_length * sizeof (struct type *) / 2);
+    }
+  return &type_vector->type[index];
+}
+
+/* Make sure there is a type allocated for type number index
+   and return the type object.
+   This can create an empty (zeroed) type object.  */
+
+static struct type *
+coff_alloc_type (index)
+     int index;
+{
+  register struct type **type_addr = coff_lookup_type (index);
+  register struct type *type = *type_addr;
+
+  /* If we are referring to a type not known at all yet,
+     allocate an empty type for it.
+     We will fill it in later if we find out how.  */
+  if (type == 0)
+    {
+      type = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+      bzero (type, sizeof (struct type));
+      *type_addr = type;
+    }
+  return type;
+}
+
+/* maintain the lists of symbols and blocks */
+
+/* Add a symbol to one of the lists of symbols.  */
+static void
+add_symbol_to_list (symbol, listhead)
+     struct symbol *symbol;
+     struct pending **listhead;
+{
+  register struct pending *link
+    = (struct pending *) xmalloc (sizeof (struct pending));
+
+  link->next = *listhead;
+  link->symbol = symbol;
+  *listhead = link;
+}
+
+/* Take one of the lists of symbols and make a block from it.
+   Put the block on the list of pending blocks.  */
+
+static void
+finish_block (symbol, listhead, old_blocks, start, end)
+     struct symbol *symbol;
+     struct pending **listhead;
+     struct pending_block *old_blocks;
+     CORE_ADDR start, end;
+{
+  register struct pending *next, *next1;
+  register struct block *block;
+  register struct pending_block *pblock;
+  struct pending_block *opblock;
+  register int i;
+
+  /* Count the length of the list of symbols.  */
+
+  for (next = *listhead, i = 0; next; next = next->next, i++);
+
+  block = (struct block *) xmalloc (sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
+
+  /* Copy the symbols into the block.  */
+
+  BLOCK_NSYMS (block) = i;
+  for (next = *listhead; next; next = next->next)
+    BLOCK_SYM (block, --i) = next->symbol;
+
+  BLOCK_START (block) = start;
+  BLOCK_END (block) = end;
+  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
+
+  /* Put the block in as the value of the symbol that names it.  */
+
+  if (symbol)
+    {
+      SYMBOL_BLOCK_VALUE (symbol) = block;
+      BLOCK_FUNCTION (block) = symbol;
+    }
+  else
+    BLOCK_FUNCTION (block) = 0;
+
+  /* Now free the links of the list, and empty the list.  */
+
+  for (next = *listhead; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  *listhead = 0;
+
+  /* Install this block as the superblock
+     of all blocks made since the start of this scope
+     that don't have superblocks yet.  */
+
+  opblock = 0;
+  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
+    {
+      if (BLOCK_SUPERBLOCK (pblock->block) == 0)
+	BLOCK_SUPERBLOCK (pblock->block) = block;
+      opblock = pblock;
+    }
+
+  /* Record this block on the list of all blocks in the file.
+     Put it after opblock, or at the beginning if opblock is 0.
+     This puts the block in the list after all its subblocks.  */
+
+  pblock = (struct pending_block *) xmalloc (sizeof (struct pending_block));
+  pblock->block = block;
+  if (opblock)
+    {
+      pblock->next = opblock->next;
+      opblock->next = pblock;
+    }
+  else
+    {
+      pblock->next = pending_blocks;
+      pending_blocks = pblock;
+    }
+}
+
+static struct blockvector *
+make_blockvector ()
+{
+  register struct pending_block *next, *next1;
+  register struct blockvector *blockvector;
+  register int i;
+
+  /* Count the length of the list of blocks.  */
+
+  for (next = pending_blocks, i = 0; next; next = next->next, i++);
+
+  blockvector = (struct blockvector *) xmalloc (sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
+
+  /* Copy the blocks into the blockvector.
+     This is done in reverse order, which happens to put
+     the blocks into the proper order (ascending starting address).
+     finish_block has hair to insert each block into the list
+     after its subblocks in order to make sure this is true.  */
+
+  BLOCKVECTOR_NBLOCKS (blockvector) = i;
+  for (next = pending_blocks; next; next = next->next)
+    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
+
+  /* Now free the links of the list, and empty the list.  */
+
+  for (next = pending_blocks; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  pending_blocks = 0;
+
+  return blockvector;
+}
+
+/* Manage the vector of line numbers.  */
+
+static
+record_line (line, pc)
+     int line;
+     CORE_ADDR pc;
+{
+  /* Make sure line vector is big enough.  */
+
+  if (line_vector_index + 2 >= line_vector_length)
+    {
+      line_vector_length *= 2;
+      line_vector = (struct linetable *)
+	xrealloc (line_vector, sizeof (struct linetable)
+				+ line_vector_length * sizeof (int));
+    }
+
+  /* If this line is not continguous with previous one recorded,
+     all lines between subsequent line and current one are same pc.
+     Add one item to line vector, and if more than one line skipped, 
+     record a line-number entry for it.  */
+  if (prev_line_number > 0 && line != prev_line_number + 1)
+    line_vector->item[line_vector_index++] = pc;
+  if (prev_line_number < 0 || line > prev_line_number + 2)
+    line_vector->item[line_vector_index++] = - line;
+  prev_line_number = line;
+
+  /* Record the core address of the line.  */
+  line_vector->item[line_vector_index++] = pc;
+}
+
+/* Start a new symtab for a new source file.
+   This is called when a COFF ".file" symbol is seen;
+   it indicates the start of data for one original source file.  */
+
+static void
+start_symtab ()
+{
+  file_symbols = 0;
+  global_symbols = 0;
+  context_stack = 0;
+  within_function = 0;
+  last_source_file = 0;
+
+  /* Initialize the source file information for this file.  */
+
+  line_vector_index = 0;
+  line_vector_length = 1000;
+  prev_line_number = -2;	/* Force first line number to be explicit */
+  line_vector = (struct linetable *)
+    xmalloc (sizeof (struct linetable) + line_vector_length * sizeof (int));
+}
+
+/* Save the vital information for use when closing off the current file.
+   NAME is the file name the symbols came from, START_ADDR is the first
+   text address for the file, and SIZE is the number of bytes of text.  */
+
+static void
+complete_symtab (name, start_addr, size)
+    char *name;
+    CORE_ADDR start_addr;
+    unsigned int size;
+{
+  last_source_file = savestring (name, strlen (name));
+  cur_src_start_addr = start_addr;
+  cur_src_end_addr = start_addr + size;
+}
+
+/* Finish the symbol definitions for one main source file,
+   close off all the lexical contexts for that file
+   (creating struct block's for them), then make the
+   struct symtab for that file and put it in the list of all such. */
+
+static void
+end_symtab ()
+{
+  register struct symtab *symtab;
+  register struct context_stack *cstk;
+  register struct blockvector *blockvector;
+  register struct linetable *lv;
+
+  /* Finish the lexical context of the last function in the file.  */
+
+  if (context_stack)
+    {
+      cstk = context_stack;
+      /* Make a block for the local symbols within.  */
+      finish_block (cstk->name, &local_symbols, cstk->old_blocks,
+		    cstk->start_addr, cur_src_end_addr);
+      free (cstk);
+    }
+
+  finish_block (0, &file_symbols, 0, cur_src_start_addr, cur_src_end_addr);
+  finish_block (0, &global_symbols, 0, cur_src_start_addr, cur_src_end_addr);
+  blockvector = make_blockvector ();
+
+  /* Now create the symtab objects proper this source file.  */
+
+  symtab = (struct symtab *) xmalloc (sizeof (struct symtab));
+  /* Fill in its components.  */
+  symtab->blockvector = blockvector;
+  symtab->free_code = free_contents;
+  symtab->free_ptr = 0;
+  symtab->filename = last_source_file;
+  lv = line_vector;
+  lv->nitems = line_vector_index;
+  symtab->linetable = (struct linetable *)
+    xrealloc (lv, sizeof (struct linetable) + lv->nitems * sizeof (int));
+  symtab->nlines = 0;
+  symtab->line_charpos = 0;
+
+  /* Link the new symtab into the list of such.  */
+  symtab->next = symtab_list;
+  symtab_list = symtab;
+
+  line_vector = 0;
+  line_vector_length = -1;
+  last_source_file = 0;
+}
+
+/* Accumulate the misc functions in bunches of 127.
+   At the end, copy them all into one newly allocated structure.  */
+
+#define MISC_BUNCH_SIZE 127
+
+struct misc_bunch
+{
+  struct misc_bunch *next;
+  struct misc_function contents[MISC_BUNCH_SIZE];
+};
+
+/* Bunch currently being filled up.
+   The next field points to chain of filled bunches.  */
+
+static struct misc_bunch *misc_bunch;
+
+/* Number of slots filled in current bunch.  */
+
+static int misc_bunch_index;
+
+/* Total number of misc functions recorded so far.  */
+
+static int misc_count;
+
+static void
+init_misc_functions ()
+{
+  misc_count = 0;
+  misc_bunch = 0;
+  misc_bunch_index = MISC_BUNCH_SIZE;
+}
+
+static void
+record_misc_function (name, address)
+     char *name;
+     CORE_ADDR address;
+{
+  register struct misc_bunch *new;
+
+  if (misc_bunch_index == MISC_BUNCH_SIZE)
+    {
+      new = (struct misc_bunch *) xmalloc (sizeof (struct misc_bunch));
+      misc_bunch_index = 0;
+      new->next = misc_bunch;
+      misc_bunch = new;
+    }
+  misc_bunch->contents[misc_bunch_index].name = savestring (name, strlen (name));
+  misc_bunch->contents[misc_bunch_index].address = address;
+  misc_bunch_index++;
+  misc_count++;
+}
+
+static int
+compare_misc_functions (fn1, fn2)
+     struct misc_function *fn1, *fn2;
+{
+  /* Return a signed result based on unsigned comparisons
+     so that we sort into unsigned numeric order.  */
+  if (fn1->address < fn2->address)
+    return -1;
+  if (fn1->address > fn2->address)
+    return 1;
+  return 0;
+}
+
+static void
+discard_misc_bunches ()
+{
+  register struct misc_bunch *next;
+
+  while (misc_bunch)
+    {
+      next = misc_bunch->next;
+      free (misc_bunch);
+      misc_bunch = next;
+    }
+}
+
+static void
+condense_misc_bunches ()
+{
+  register int i, j;
+  register struct misc_bunch *bunch;
+#ifdef NAMES_HAVE_UNDERSCORE
+  int offset = 1;
+#else
+  int offset = 0;
+#endif
+
+  misc_function_vector
+    = (struct misc_function *)
+      xmalloc (misc_count * sizeof (struct misc_function));
+
+  j = 0;
+  bunch = misc_bunch;
+  while (bunch)
+    {
+      for (i = 0; i < misc_bunch_index; i++)
+	{
+	  register char *tmp;
+
+	  misc_function_vector[j] = bunch->contents[i];
+	  tmp = misc_function_vector[j].name;
+	  misc_function_vector[j].name = (tmp[0] == '_' ? tmp + offset : tmp);
+	  j++;
+	}
+      bunch = bunch->next;
+      misc_bunch_index = MISC_BUNCH_SIZE;
+    }
+
+  misc_function_count = j;
+
+  /* Sort the misc functions by address.  */
+
+  qsort (misc_function_vector, j, sizeof (struct misc_function),
+	 compare_misc_functions);
+}
+
+/* Call sort_syms to sort alphabetically
+   the symbols of each block of each symtab.  */
+
+static int
+compare_symbols (s1, s2)
+     struct symbol **s1, **s2;
+{
+  /* Names that are less should come first.  */
+  register int namediff = strcmp (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2));
+  if (namediff != 0) return namediff;
+  /* For symbols of the same name, registers should come first.  */
+  return ((SYMBOL_CLASS (*s2) == LOC_REGISTER)
+	  - (SYMBOL_CLASS (*s1) == LOC_REGISTER));
+}
+
+static void
+sort_syms ()
+{
+  register struct symtab *s;
+  register int i, nbl;
+  register struct blockvector *bv;
+  register struct block *b;
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      nbl = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < nbl; i++)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, i);
+	  qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
+		 sizeof (struct symbol *), compare_symbols);
+	}
+    }
+}
+
+/* This is the symbol-file command.  Read the file, analyze its symbols,
+   and add a struct symtab to symtab_list.  */
+
+void
+symbol_file_command (name)
+     char *name;
+{
+  int desc;
+  int num_symbols;
+  int num_sections;
+  int symtab_offset;
+  extern void close ();
+  register int val;
+  struct cleanup *old_chain;
+
+  dont_repeat ();
+
+  if (name == 0)
+    {
+      if (symtab_list && !query ("Discard symbol table? ", 0))
+	error ("Not confirmed.");
+      free_all_symtabs ();
+      return;
+    }
+
+  if (symtab_list && !query ("Load new symbol table from \"%s\"? ", name))
+    error ("Not confirmed.");
+
+  if (symfile)
+    free (symfile);
+  symfile = 0;
+
+  {
+    char *absolute_name;
+
+    desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name);
+    if (desc < 0)
+      perror_with_name (name);
+    else
+      name = absolute_name;
+  }
+
+  old_chain = make_cleanup (close, desc);
+  make_cleanup (free_current_contents, &name);
+
+  if ((num_symbols = read_file_hdr (desc, &file_hdr)) < 0)
+    error ("File \"%s\" not in executable format.", name);
+
+  if (num_symbols == 0)
+    {
+      free_all_symtabs ();
+      printf ("%s does not have a symbol-table.\n", name);
+      fflush (stdout);
+      return;
+    }
+
+  num_sections = file_hdr.f_nscns;
+  symtab_offset = file_hdr.f_symptr;
+
+  if (read_section_hdr (desc, _TEXT, &text_hdr, num_sections) < 0)
+    error ("\"%s\": can't read text section header", name);
+
+  /* Read the line number table, all at once.  */
+
+  val = init_lineno (desc, text_hdr.s_lnnoptr, text_hdr.s_nlnno);
+  if (val < 0)
+    error ("\"%s\": error reading line numbers\n", name);
+
+  /* Now read the string table, all at once.  */
+
+  val = init_stringtab (desc, symtab_offset + num_symbols * SYMESZ);
+  if (val < 0)
+    error ("\"%s\": can't get string table", name);
+  make_cleanup (free_stringtab, 0);
+
+  /* Position to read the symbol table.  Do not read it all at once. */
+  val = lseek (desc, (long)symtab_offset, 0);
+  if (val < 0)
+    perror_with_name (name);
+
+  printf ("Reading symbol data from %s...", name);
+  fflush (stdout);
+
+  /* Throw away the old symbol table.  */
+
+  free_all_symtabs ();
+
+  init_misc_functions ();
+  make_cleanup (discard_misc_bunches, 0);
+
+  /* Now that the executable file is positioned at symbol table,
+     process it and define symbols accordingly.  */
+
+  read_coff_symtab (desc, num_symbols);
+
+  patch_opaque_types ();
+
+  /* Sort symbols alphabetically within each block.  */
+
+  sort_syms ();
+
+  /* Go over the misc functions and install them in vector.  */
+
+  condense_misc_bunches ();
+
+  /* Don't allow char * to have a typename (else would get caddr_t.)  */
+
+  TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+
+  /* Make a default for file to list.  */
+
+  select_source_symtab (symtab_list);
+
+  symfile = savestring (name, strlen (name));
+
+  do_cleanups (old_chain);
+
+  printf ("done.\n");
+  fflush (stdout);
+}
+
+/* Return name of file symbols were loaded from, or 0 if none..  */
+
+char *
+get_sym_file ()
+{
+  return symfile;
+}
+
+/* Simplified internal version of coff symbol table information */
+
+struct coff_symbol {
+  char *c_name;
+  int c_symnum;		/* symbol number of this entry */
+  int c_nsyms;		/* 1 if syment only, 2 if syment + auxent */
+  long c_value;
+  int c_sclass;
+  int c_secnum;
+  unsigned int c_type;
+};
+
+/* Given pointers to a symbol table in coff style exec file,
+   analyze them and create struct symtab's describing the symbols.
+   NSYMS is the number of symbols in the symbol table.
+   We read them one at a time using read_one_sym ().  */
+
+static void
+read_coff_symtab (desc, nsyms)
+     int desc;
+     int nsyms;
+{
+  FILE *stream = fdopen (desc, "r");
+  register struct context_stack *new;
+  struct coff_symbol coff_symbol;
+  register struct coff_symbol *cs = &coff_symbol;
+  static SYMENT main_sym;
+  static AUXENT main_aux;
+
+  int num_object_files = 0;
+  int next_file_symnum = 0;
+  char *filestring;
+  int depth;
+  int fcn_first_line;
+  int fcn_last_line;
+  long fcn_line_ptr;
+
+  nlist_stream_global = stream;
+  nlist_nsyms_global = nsyms;
+  last_source_file = 0;
+  bzero (opaque_type_chain, sizeof opaque_type_chain);
+
+  type_vector_length = 160;
+  type_vector = (struct typevector *)
+		xmalloc (sizeof (struct typevector)
+				+ type_vector_length * sizeof (struct type *));
+  bzero (type_vector->type, type_vector_length * sizeof (struct type *));
+
+  start_symtab ();
+
+  symnum = 0;
+  while (symnum < nsyms)
+    {
+      read_one_sym (cs, &main_sym, &main_aux);
+
+      /*
+       * If we are finished with the previous file's symbols, and the
+       * next thing is not a C_FILE, then we have hit the global symbols.
+       */
+      if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
+	{
+	  CORE_ADDR last_file_end = cur_src_end_addr;
+
+	  if (last_source_file)
+	    end_symtab ();
+
+	  start_symtab ();
+	  complete_symtab ("_globals_", 0, first_object_file_end);
+	  /* done with all files, everything from here on out is globals */
+	}
+
+      if (ISFCN (cs->c_type))
+	{
+	  /*
+	   * gdb expects all functions to also be in misc_function
+	   * list -- why not...
+	   */
+	  record_misc_function (cs->c_name, cs->c_value);
+
+	  fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
+	  within_function = 1;
+
+	  new = (struct context_stack *)
+		    xmalloc (sizeof (struct context_stack));
+	  new->depth = depth = 0;
+	  new->next = 0;
+	  context_stack = new;
+	  new->locals = 0;
+	  new->old_blocks = pending_blocks;
+	  new->start_addr = cs->c_value;
+	  new->name = process_coff_symbol (cs, &main_aux);
+	  continue;
+	}
+
+      switch (cs->c_sclass)
+	{
+	  case C_EFCN:
+	  case C_EXTDEF:
+	  case C_ULABEL:
+	  case C_USTATIC:
+	  case C_LINE:
+	  case C_ALIAS:
+	  case C_HIDDEN:
+	    printf ("Bad n_sclass = %d\n", cs->c_sclass);
+	    break;
+
+	  case C_FILE:
+	    /*
+	     * c_value field contains symnum of next .file entry in table
+	     * or symnum of first global after last .file.
+	     */
+	    next_file_symnum = cs->c_value;
+	    filestring = getfilename (&main_aux);
+	    /*
+	     * Complete symbol table for last object file
+	     * containing debugging information.
+	     */
+	    if (last_source_file)
+	      {
+		end_symtab ();
+		start_symtab ();
+	      }
+	    complete_symtab (filestring, 0, 0);	/* FIXME, 0 0 is wrong */
+	    num_object_files++;
+	    break;
+
+	  case C_EXT:
+	    if (cs->c_secnum == N_ABS && strcmp (cs->c_name, _ETEXT) == 0)
+	      {
+		end_of_text_addr = cs->c_value;
+	      }
+	    if (cs->c_type == T_NULL)
+	      {
+		if (cs->c_secnum <= 1)	/* text or abs */
+		  {
+		    record_misc_function (cs->c_name, cs->c_value);
+		    break;
+		  }
+		else
+		  cs->c_type = T_INT;
+	      }
+	    (void) process_coff_symbol (cs, &main_aux);
+	    break;
+
+	  case C_STAT:
+	    if (cs->c_type == T_NULL && cs->c_secnum > N_UNDEF)
+	      {
+		/* These ".text", ".data", ".bss" entries don't seem to
+		 * appear in A/UX COFF output.   -- gnu@toad.com  4Apr88
+		 */
+		if (strcmp (cs->c_name, _TEXT) == 0)
+		  {
+		    /* We have a ".text" symbol */
+		    if (num_object_files == 1)
+		      {
+			/* Record end address of first file, crt0.s */
+			first_object_file_end =
+			    cs->c_value + main_aux.x_scn.x_scnlen;
+		      }
+		    /*
+		     * Fill in missing information for debugged 
+		     * object file only if we have line number info.
+		     */
+		    if (main_aux.x_scn.x_nlinno > 0)
+		      {
+			complete_symtab (filestring, cs->c_value,
+					  main_aux.x_scn.x_scnlen);
+		      }
+		    break;
+		  }
+		else if (strcmp (cs->c_name, _DATA) == 0)
+		  break;
+		else if (strcmp (cs->c_name, _BSS) == 0)
+		  break;
+
+		/* get rid of assembly labels here */
+		/* record_misc_function (cs->c_name, cs->c_value); */
+		break;
+	      }
+	    (void) process_coff_symbol (cs, &main_aux);
+	    break;
+
+	  case C_FCN:
+	    if (strcmp (cs->c_name, ".bf") == 0)
+	      {
+		/* value contains address of first non-init type code */
+		/* main_aux.x_sym.x_misc.x_lnsz.x_lnno
+			    contains line number of '{' } */
+		fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+	      }
+	    else if (strcmp (cs->c_name, ".ef") == 0)
+	      {
+		/* value contains address of exit/return from function */
+			/* round it up to next multiple of 16 */
+		cs->c_value = (cs->c_value + 15) & -16;
+		/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
+			    contains number of lines to '}' */
+		fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+		enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line);
+
+		new = context_stack;
+		finish_block (new->name, &local_symbols, new->old_blocks,
+			      new->start_addr, cs->c_value);
+		context_stack = 0;
+		within_function = 0;
+		free (new);
+	      }
+	    break;
+
+	  case C_BLOCK:
+	    if (strcmp (cs->c_name, ".bb") == 0)
+	      {
+		new = (struct context_stack *)
+			    xmalloc (sizeof (struct context_stack));
+		depth++;
+		new->depth = depth;
+		new->next = context_stack;
+		context_stack = new;
+		new->locals = local_symbols;
+		new->old_blocks = pending_blocks;
+		new->start_addr = cs->c_value;
+		new->name = 0;
+		local_symbols = 0;
+	      }
+	    else if (strcmp (cs->c_name, ".eb") == 0)
+	      {
+		new = context_stack;
+		if (new == 0 || depth != new->depth)
+		  error ("Invalid symbol data: .bb/.eb symbol mismatch.");
+		if (local_symbols && context_stack->next)
+		  {
+		    /* Make a block for the local symbols within.  */
+		    finish_block (0, &local_symbols, new->old_blocks,
+				  new->start_addr, cs->c_value);
+		  }
+		depth--;
+		local_symbols = new->locals;
+		context_stack = new->next;
+		free (new);
+	      }
+	    break;
+
+	  default:
+	    (void) process_coff_symbol (cs, &main_aux);
+	    break;
+	}
+    }
+
+  if (last_source_file)
+    end_symtab ();
+  fclose (stream);
+}
+
+/* Routines for reading headers and symbols from executable.  */
+
+/* Read COFF file header, check magic number,
+   and return number of symbols. */
+read_file_hdr (chan, file_hdr)
+    int chan;
+    FILHDR *file_hdr;
+{
+  lseek (chan, 0L, 0);
+  if (myread (chan, (char *)file_hdr, FILHSZ) < 0)
+    return -1;
+
+  if (BADMAG(file_hdr))
+    return -1;			/* Non understood file */
+  return file_hdr->f_nsyms;	/* OK magic number, return # syms */
+}
+
+read_aout_hdr (chan, aout_hdr, size)
+    int chan;
+    AOUTHDR *aout_hdr;
+    int size;
+{
+  lseek (chan, (long)FILHSZ, 0);
+  if (size != sizeof (AOUTHDR))
+    return -1;
+  if (myread (chan, (char *)aout_hdr, size) != size)
+    return -1;
+  return 0;
+}
+
+read_section_hdr (chan, section_name, section_hdr, nsects)
+    register int chan;
+    register char *section_name;
+    SCNHDR *section_hdr;
+    register int nsects;
+{
+  register int i;
+
+  if (lseek (chan, FILHSZ + sizeof (AOUTHDR), 0) < 0)
+    return -1;
+
+  for (i = 0; i < nsects; i++)
+    {
+      if (myread (chan, (char *)section_hdr, SCNHSZ) < 0)
+	return -1;
+      if (strncmp (section_hdr->s_name, section_name, 8) == 0)
+	return 0;
+    }
+    return -1;
+}
+
+read_one_sym (cs, sym, aux)
+    register struct coff_symbol *cs;
+    register SYMENT *sym;
+    register AUXENT *aux;
+{
+  cs->c_symnum = symnum;
+  fread ((char *)sym, SYMESZ, 1, nlist_stream_global);
+  cs->c_nsyms = (sym->n_numaux & 0xff) + 1;
+  if (cs->c_nsyms == 2)
+    {
+      /* doc for coff says there is either no aux entry or just one */
+      fread ((char *)aux, AUXESZ, 1, nlist_stream_global);
+    }
+  else if (cs->c_nsyms > 2)
+    error ("more than one aux symbol table entry at symnum=%d\n", symnum);
+
+  cs->c_name = getsymname (sym);
+  cs->c_value = sym->n_value;
+  cs->c_sclass = (sym->n_sclass & 0xff);
+  cs->c_secnum = sym->n_scnum;
+  cs->c_type = (unsigned) sym->n_type;
+
+#ifdef DEBUG
+  if (debug) {
+    fprintf(stderr, "sym %3x: %2x %s %x %x %x", cs->c_symnum,
+	  cs->c_sclass, cs->c_name, cs->c_value, cs->c_secnum, cs->c_type);
+    if (cs->c_nsyms > 1)
+      fprintf(stderr, " +aux %s\n", (char *)aux);
+    else
+      fprintf(stderr, "\n");
+  }
+#endif
+
+  symnum += cs->c_nsyms;
+}
+
+/* Support for string table handling */
+
+static char *stringtab = NULL;
+
+static int
+init_stringtab (chan, offset)
+    int chan;
+    long offset;
+{
+  long buffer;
+  int val;
+
+  if (lseek (chan, offset, 0) < 0)
+    return -1;
+
+  val = myread (chan, (char *)&buffer, sizeof buffer);
+
+  /* If no string table, we get 0 bytes back from the read.  That's OK. */
+  if (val == 0) {
+    free_stringtab();
+    return 0;
+  }
+
+  if (val != sizeof buffer)
+    return -1;
+
+  if (stringtab)
+    free (stringtab);
+  stringtab = (char *) xmalloc (buffer);
+  bcopy (&buffer, stringtab, sizeof buffer);
+
+  val = myread (chan, stringtab + sizeof buffer, buffer - sizeof buffer);
+  if (val != buffer - sizeof buffer || stringtab[buffer - 1] != '\0')
+    return -1;
+
+  return 0;
+}
+
+static void
+free_stringtab ()
+{
+  if (stringtab)
+    free (stringtab);
+  stringtab = NULL;
+}
+
+static char *
+getsymname (symbol_entry)
+    SYMENT *symbol_entry;
+{
+  static char buffer[SYMNMLEN+1];
+  char *result;
+
+  if (symbol_entry->n_zeroes == 0)
+    {
+      if (!stringtab)
+	error("Symbol entry references nonexistent string table");
+      result = stringtab + symbol_entry->n_offset;
+    }
+  else
+    {
+      strncpy (buffer, symbol_entry->n_name, SYMNMLEN);
+      buffer[SYMNMLEN] = '\0';
+      result = buffer;
+    }
+  return result;
+}
+
+static char *
+getfilename (aux_entry)
+    AUXENT *aux_entry;
+{
+  static char buffer[BUFSIZ];
+  register char *temp;
+  char *result;
+  extern char *rindex ();
+
+#ifndef mac_aux
+  if (aux_entry->x_file.x_foff != 0)
+    strcpy (buffer, stringtab + aux_entry->x_file.x_foff);
+  else
+#endif
+    {
+      strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
+      buffer[FILNMLEN] = '\0';
+    }
+  result = buffer;
+  if ((temp = rindex (result, '/')) != NULL)
+    result = temp + 1;
+  return (result);
+}
+
+/* Support for line number handling */
+static char *linetab = NULL;
+static long linetab_offset;
+static int linetab_count;
+
+static int
+init_lineno (chan, offset, count)
+    int chan;
+    long offset;
+    int count;
+{
+  int val;
+
+  if (lseek (chan, offset, 0) < 0)
+    return -1;
+  
+  if (linetab)
+    free (linetab);
+  linetab = (char *) xmalloc (count * LINESZ);
+
+  val = myread (chan, linetab, count * LINESZ);
+  if (val != count * LINESZ)
+    return -1;
+
+  linetab_offset = offset;
+  linetab_count = count;
+  return 0;
+}
+
+static void
+enter_linenos (file_offset, first_line, last_line)
+    long file_offset;
+    register int first_line;
+    register int last_line;
+{
+  register char *rawptr = &linetab[file_offset - linetab_offset];
+  register struct lineno *lptr;
+
+  /* skip first line entry for each function */
+  rawptr += LINESZ;
+  /* line numbers start at one for the first line of the function */
+  first_line--;
+
+  for (lptr = (struct lineno *)rawptr;
+	lptr->l_lnno && lptr->l_lnno <= last_line;
+	rawptr += LINESZ, lptr = (struct lineno *)rawptr)
+    {
+      record_line (first_line + lptr->l_lnno, lptr->l_addr.l_paddr);
+    }
+}
+
+static int
+hashname (name)
+     char *name;
+{
+  register char *p = name;
+  register int total = p[0];
+  register int c;
+
+  c = p[1];
+  total += c << 2;
+  if (c)
+    {
+      c = p[2];
+      total += c << 4;
+      if (c)
+	total += p[3] << 6;
+    }
+  
+  return total % HASHSIZE;
+}
+
+static void
+patch_type (type, real_type)
+    struct type *type;
+    struct type *real_type;
+{
+  register struct type *target = TYPE_TARGET_TYPE (type);
+  register struct type *real_target = TYPE_TARGET_TYPE (real_type);
+  int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
+
+  TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
+  TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
+  TYPE_FIELDS (target) = (struct field *)
+				obstack_alloc (symbol_obstack, field_size);
+
+  bcopy (TYPE_FIELDS (real_target), TYPE_FIELDS (target), field_size);
+
+  if (TYPE_NAME (real_target))
+    {
+      if (TYPE_NAME (target))
+	free (TYPE_NAME (target));
+      TYPE_NAME (target) = concat (TYPE_NAME (real_target), "", "");
+    }
+}
+
+/* Patch up all appropriate typdef symbols in the opaque_type_chains
+   so that they can be used to print out opaque data structures properly */
+
+static void
+patch_opaque_types ()
+{
+  struct symtab *s;
+
+  /* Look at each symbol in the per-file block of each symtab.  */
+  for (s = symtab_list; s; s = s->next)
+    {
+      register struct block *b;
+      register int i;
+
+      /* Go through the per-file symbols only */
+      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1);
+      for (i = BLOCK_NSYMS (b) - 1; i >= 0; i--)
+	{
+	  register struct symbol *real_sym;
+
+	  /* Find completed typedefs to use to fix opaque ones.
+	     Remove syms from the chain when their types are stored,
+	     but search the whole chain, as there may be several syms
+	     from different files with the same name.  */
+	  real_sym = BLOCK_SYM (b, i);
+	  if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
+	      SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE &&
+	      TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
+	      TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
+	    {
+	      register char *name = SYMBOL_NAME (real_sym);
+	      register int hash = hashname (name);
+	      register struct symbol *sym, *prev;
+
+	      prev = 0;
+	      for (sym = opaque_type_chain[hash]; sym;)
+		{
+		  if (name[0] == SYMBOL_NAME (sym)[0] &&
+		      !strcmp (name + 1, SYMBOL_NAME (sym) + 1))
+		    {
+		      if (prev)
+			SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
+		      else
+			opaque_type_chain[hash]
+			  = (struct symbol *) SYMBOL_VALUE (sym);
+
+		      patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
+
+		      if (prev)
+			sym = (struct symbol *) SYMBOL_VALUE (prev);
+		      else
+			sym = opaque_type_chain[hash];
+		    }
+		  else
+		    {
+		      prev = sym;
+		      sym = (struct symbol *) SYMBOL_VALUE (sym);
+		    }
+		}
+	    }
+	}
+    }
+}
+
+static struct symbol *
+process_coff_symbol (cs, aux)
+     register struct coff_symbol *cs;
+     register AUXENT *aux;
+{
+  register struct symbol *sym = (struct symbol *)
+				xmalloc (sizeof (struct symbol));
+  char *name;
+  char *dot;
+#ifdef NAMES_HAVE_UNDERSCORE
+  int offset = 1;
+#else
+  int offset = 0;
+#endif
+
+  bzero (sym, sizeof (struct symbol));
+  name = cs->c_name;
+  name = (name[0] == '_' ? name + offset : name);
+  SYMBOL_NAME (sym) = savestring (name, strlen (name));
+
+  /* default assumptions */
+  SYMBOL_VALUE (sym) = cs->c_value;
+  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+  if (ISFCN (cs->c_type))
+    {
+      SYMBOL_TYPE (sym) = decode_function_type (cs, cs->c_type, aux);
+      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      if (cs->c_sclass == C_STAT)
+	add_symbol_to_list (sym, &file_symbols);
+      else if (cs->c_sclass == C_EXT)
+	add_symbol_to_list (sym, &global_symbols);
+    }
+  else
+    {
+      SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
+      switch (cs->c_sclass)
+	{
+	  case C_NULL:
+	    break;
+
+	  case C_AUTO:
+	    SYMBOL_CLASS (sym) = LOC_LOCAL;
+	    add_symbol_to_list (sym, &local_symbols);
+	    break;
+
+	  case C_EXT:
+	    SYMBOL_CLASS (sym) = LOC_STATIC;
+	    add_symbol_to_list (sym, &global_symbols);
+	    break;
+
+	  case C_STAT:
+	    SYMBOL_CLASS (sym) = LOC_STATIC;
+	    if (within_function) {
+	      /* Static symbol of local scope */
+	      add_symbol_to_list (sym, &local_symbols);
+	    }
+	    else {
+	      /* Static symbol at top level of file */
+	      add_symbol_to_list (sym, &file_symbols);
+	    }
+	    break;
+
+	  case C_REG:
+	  case C_REGPARM:
+	    SYMBOL_CLASS (sym) = LOC_REGISTER;
+	    add_symbol_to_list (sym, &local_symbols);
+	    break;
+
+	  case C_LABEL:
+	    break;
+
+	  case C_ARG:
+	    SYMBOL_CLASS (sym) = LOC_ARG;
+	    add_symbol_to_list (sym, &local_symbols);
+	    /* If PCC says a parameter is a short or a char,
+	       it is really an int.  */
+	    if (SYMBOL_TYPE (sym) == builtin_type_char
+		|| SYMBOL_TYPE (sym) == builtin_type_short)
+	      SYMBOL_TYPE (sym) = builtin_type_int;
+	    else if (SYMBOL_TYPE (sym) == builtin_type_unsigned_char
+		     || SYMBOL_TYPE (sym) == builtin_type_unsigned_short)
+	      SYMBOL_TYPE (sym) = builtin_type_unsigned_int;
+	    break;
+
+	  case C_TPDEF:
+	    SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+	    /* If type has no name, give it one */
+	    if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0 
+		&& (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	      TYPE_NAME (SYMBOL_TYPE (sym))
+					  = concat (SYMBOL_NAME (sym), "", "");
+
+	    /* Keep track of any type which points to empty structured type,
+		so it can be filled from a definition from another file */
+	    if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
+		TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0)
+	      {
+		register int i = hashname (SYMBOL_NAME (sym));
+
+		SYMBOL_VALUE (sym) = (int) opaque_type_chain[i];
+		opaque_type_chain[i] = sym;
+	      }
+	    add_symbol_to_list (sym, &file_symbols);
+	    break;
+
+	  case C_STRTAG:
+	  case C_UNTAG:
+	  case C_ENTAG:
+	    SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+	    SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+	    if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
+		&& (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	      TYPE_NAME (SYMBOL_TYPE (sym))
+		= concat ("",
+			  (cs->c_sclass == C_ENTAG
+			   ? "enum "
+			   : (cs->c_sclass == C_STRTAG
+			      ? "struct " : "union ")),
+			  SYMBOL_NAME (sym));
+	    add_symbol_to_list (sym, &file_symbols);
+	    break;
+
+	  default:
+	    break;
+	}
+    }
+  return sym;
+}
+
+/* Decode a coff type specifier;
+   return the type that is meant.  */
+
+static
+struct type *
+decode_type (cs, c_type, aux)
+     register struct coff_symbol *cs;
+     unsigned int c_type;
+     register AUXENT *aux;
+{
+  register struct type *type = 0;
+  register int n;
+  unsigned int new_c_type;
+
+  if (c_type & ~N_BTMASK)
+    {
+      new_c_type = DECREF (c_type);
+      if (ISPTR (c_type))
+	{
+	  type = decode_type (cs, new_c_type, aux);
+	  type = lookup_pointer_type (type);
+	}
+      else if (ISFCN (c_type))
+	{
+	  type = decode_type (cs, new_c_type, aux);
+	  type = lookup_function_type (type);
+	}
+      else if (ISARY (c_type))
+	{
+	  int i, n;
+	  register unsigned short *dim;
+	  struct type *base_type;
+
+	  /* Define an array type.  */
+	  /* auxent refers to array, not base type */
+	  if (aux->x_sym.x_tagndx == 0)
+	    cs->c_nsyms = 1;
+
+	  /* shift the indices down */
+	  dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
+	  i = 1;
+	  n = dim[0];
+	  for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
+	    *dim = *(dim + 1);
+	  *dim = 0;
+
+	  type = (struct type *)
+		    obstack_alloc (symbol_obstack, sizeof (struct type));
+	  bzero (type, sizeof (struct type));
+
+	  base_type = decode_type (cs, new_c_type, aux);
+
+	  TYPE_CODE (type) = TYPE_CODE_ARRAY;
+	  TYPE_TARGET_TYPE (type) = base_type;
+	  TYPE_LENGTH (type) = n * TYPE_LENGTH (base_type);
+	}
+      return type;
+    }
+
+  /* Reference to existing type */
+  if (cs->c_nsyms > 1 && aux->x_sym.x_tagndx != 0)
+    {
+      type = coff_alloc_type (aux->x_sym.x_tagndx);
+      return type;
+    }
+
+  return decode_base_type (cs, BTYPE (c_type), aux);
+}
+
+/* Decode a coff type specifier for function definition;
+   return the type that the function returns.  */
+
+static
+struct type *
+decode_function_type (cs, c_type, aux)
+     register struct coff_symbol *cs;
+     unsigned int c_type;
+     register AUXENT *aux;
+{
+  if (aux->x_sym.x_tagndx == 0)
+    cs->c_nsyms = 1;	/* auxent refers to function, not base type */
+
+  return decode_type (cs, DECREF (cs->c_type), aux);
+}
+
+/* basic C types */
+
+static
+struct type *
+decode_base_type (cs, c_type, aux)
+     register struct coff_symbol *cs;
+     unsigned int c_type;
+     register AUXENT *aux;
+{
+  struct type *type;
+
+  switch (c_type)
+    {
+      case T_NULL:
+	/* NULL seems to be used as the basic type of void functions */
+	return builtin_type_void;	
+	break;
+
+      case T_ARG:
+	/* shouldn't show up here */
+	break;
+
+      case T_CHAR:
+	return builtin_type_char;
+
+      case T_SHORT:
+	return builtin_type_short;
+
+      case T_INT:
+	return builtin_type_int;
+
+      case T_LONG:
+	return builtin_type_long;
+
+      case T_FLOAT:
+	return builtin_type_float;
+
+      case T_DOUBLE:
+	return builtin_type_double;
+
+      case T_STRUCT:
+	if (cs->c_nsyms != 2)
+	  {
+	    /* anonymous structure type */
+	    type = coff_alloc_type (cs->c_symnum);
+	    TYPE_CODE (type) = TYPE_CODE_STRUCT;
+	    TYPE_NAME (type) = concat ("struct ", "<opaque>", "");
+	    TYPE_LENGTH (type) = 0;
+	    TYPE_FIELDS (type) = 0;
+	    TYPE_NFIELDS (type) = 0;
+	  }
+	else
+	  {
+	    type = read_struct_type (cs->c_symnum,
+				    aux->x_sym.x_misc.x_lnsz.x_size,
+				    aux->x_sym.x_fcnary.x_fcn.x_endndx);
+	  }
+	return type;
+
+      case T_UNION:
+	if (cs->c_nsyms != 2)
+	  {
+	    /* anonymous union type */
+	    type = coff_alloc_type (cs->c_symnum);
+	    TYPE_NAME (type) = concat ("union ", "<opaque>", "");
+	    TYPE_LENGTH (type) = 0;
+	    TYPE_FIELDS (type) = 0;
+	    TYPE_NFIELDS (type) = 0;
+	  }
+	else
+	  {
+	    type = read_struct_type (cs->c_symnum,
+				    aux->x_sym.x_misc.x_lnsz.x_size,
+				    aux->x_sym.x_fcnary.x_fcn.x_endndx);
+	  }
+	TYPE_CODE (type) = TYPE_CODE_UNION;
+	return type;
+
+      case T_ENUM:
+	return read_enum_type (cs->c_symnum,
+				    aux->x_sym.x_misc.x_lnsz.x_size,
+				    aux->x_sym.x_fcnary.x_fcn.x_endndx);
+
+      case T_MOE:
+	/* shouldn't show up here */
+	break;
+
+      case T_UCHAR:
+	return builtin_type_unsigned_char;
+
+      case T_USHORT:
+	return builtin_type_unsigned_short;
+
+      case T_UINT:
+	return builtin_type_unsigned_int;
+
+      case T_ULONG:
+	return builtin_type_unsigned_long;
+    }
+  printf ("unexpected type %d at symnum %d, name %s\n", c_type, cs->c_symnum,
+	cs->c_name);
+  return builtin_type_void;
+}
+
+/* This page contains subroutines of read_type.  */
+
+/* Read the description of a structure (or union type)
+   and return an object describing the type.  */
+
+static struct type *
+read_struct_type (index, length, lastsym)
+     int index;
+     int length;
+     int lastsym;
+{
+  struct nextfield
+    {
+      struct nextfield *next;
+      struct field field;
+    };
+
+  register struct type *type;
+  register struct nextfield *list = 0;
+  struct nextfield *new;
+  int nfields = 0;
+  register int n;
+  char *name;
+#ifdef NAMES_HAVE_UNDERSCORE
+  int offset = 1;
+#else
+  int offset = 0;
+#endif
+  struct coff_symbol member_sym;
+  register struct coff_symbol *ms = &member_sym;
+  SYMENT sub_sym;
+  AUXENT sub_aux;
+
+  type = coff_alloc_type (index);
+  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+  TYPE_LENGTH (type) = length;
+
+  while (symnum < lastsym && symnum < nlist_nsyms_global)
+    {
+      read_one_sym (ms, &sub_sym, &sub_aux);
+      name = ms->c_name;
+      name = (name[0] == '_' ? name + offset : name);
+
+      switch (ms->c_sclass)
+	{
+	  case C_MOS:
+	  case C_MOU:
+
+	    /* Get space to record the next field's data.  */
+	    new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	    new->next = list;
+	    list = new;
+
+	    /* Save the data.  */
+	    list->field.name = savestring (name, strlen (name));
+	    list->field.type = decode_type (ms, ms->c_type, &sub_aux);
+	    list->field.bitpos = 8 * ms->c_value;
+	    list->field.bitsize = 0;
+	    nfields++;
+	    break;
+
+	  case C_FIELD:
+
+	    /* Get space to record the next field's data.  */
+	    new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	    new->next = list;
+	    list = new;
+
+	    /* Save the data.  */
+	    list->field.name = savestring (name, strlen (name));
+	    list->field.type = decode_type (ms, ms->c_type, &sub_aux);
+	    list->field.bitpos = ms->c_value;
+	    list->field.bitsize = sub_aux.x_sym.x_misc.x_lnsz.x_size;
+	    nfields++;
+	    break;
+
+	  case C_EOS:
+	    break;
+	}
+    }
+  /* Now create the vector of fields, and record how big it is.  */
+
+  TYPE_NFIELDS (type) = nfields;
+  TYPE_FIELDS (type) = (struct field *)
+		obstack_alloc (symbol_obstack, sizeof (struct field) * nfields);
+
+  /* Copy the saved-up fields into the field vector.  */
+
+  for (n = nfields; list; list = list->next)
+    TYPE_FIELD (type, --n) = list->field;
+
+  return type;
+}
+
+/* Read a definition of an enumeration type,
+   and create and return a suitable type object.
+   Also defines the symbols that represent the values of the type.  */
+
+static struct type *
+read_enum_type (index, length, lastsym)
+     int index;
+     int length;
+     int lastsym;
+{
+  register struct symbol *sym;
+  register struct type *type;
+  int nsyms = 0;
+  struct pending **symlist;
+  struct coff_symbol member_sym;
+  register struct coff_symbol *ms = &member_sym;
+  SYMENT sub_sym;
+  AUXENT sub_aux;
+  struct pending *osyms, *syms;
+  register int n;
+  char *name;
+#ifdef NAMES_HAVE_UNDERSCORE
+  int offset = 1;
+#else
+  int offset = 0;
+#endif
+
+  type = coff_alloc_type (index);
+  if (within_function)
+    symlist = &local_symbols;
+  else
+    symlist = &file_symbols;
+  osyms = *symlist;
+
+  while (symnum < lastsym && symnum < nlist_nsyms_global)
+    {
+      read_one_sym (ms, &sub_sym, &sub_aux);
+      name = ms->c_name;
+      name = (name[0] == '_' ? name + offset : name);
+
+      switch (ms->c_sclass)
+	{
+	  case C_MOE:
+	    sym = (struct symbol *) xmalloc (sizeof (struct symbol));
+	    bzero (sym, sizeof (struct symbol));
+
+	    SYMBOL_NAME (sym) = savestring (name, strlen (name));
+	    SYMBOL_CLASS (sym) = LOC_CONST;
+	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+	    SYMBOL_VALUE (sym) = ms->c_value;
+	    add_symbol_to_list (sym, symlist);
+	    nsyms++;
+	    break;
+
+	  case C_EOS:
+	    break;
+	}
+    }
+
+  /* Now fill in the fields of the type-structure.  */
+
+  TYPE_LENGTH (type) = sizeof (int);
+  TYPE_CODE (type) = TYPE_CODE_ENUM;
+  TYPE_NFIELDS (type) = nsyms;
+  TYPE_FIELDS (type) = (struct field *)
+		obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
+
+  /* Find the symbols for the values and put them into the type.
+     The symbols can be found in the symlist that we put them on
+     to cause them to be defined.  osyms contains the old value
+     of that symlist; everything up to there was defined by us.  */
+
+  for (syms = *symlist, n = nsyms; syms != osyms; syms = syms->next)
+    {
+      SYMBOL_TYPE (syms->symbol) = type;
+      TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (syms->symbol);
+      TYPE_FIELD_VALUE (type, n) = SYMBOL_VALUE (syms->symbol);
+      TYPE_FIELD_BITPOS (type, n) = 0;
+      TYPE_FIELD_BITSIZE (type, n) = 0;
+    }
+  return type;
+}
+
+static
+initialize ()
+{
+  symfile = 0;
+
+  add_com ("symbol-file", class_files, symbol_file_command,
+	   "Load symbol table (in coff format) from executable file FILE.");
+}
+
+END_FILE
+
+#endif /* COFF_FORMAT */
+
diff --git a/gdb/command.c b/gdb/command.c
new file mode 100644
index 0000000..fed5ff9
--- /dev/null
+++ b/gdb/command.c
@@ -0,0 +1,454 @@
+/* Library for reading command lines and decoding commands.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+		       NO WARRANTY
+
+  BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+		GENERAL PUBLIC LICENSE TO COPY
+
+  1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of this
+    program or any part thereof, to be licensed at no charge to all
+    third parties on terms identical to those contained in this
+    License Agreement (except that you may choose to grant more
+    extensive warranty protection to third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of this program in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them.   Help stamp out software-hoarding!  */
+
+
+#include "command.h"
+#include <stdio.h>
+
+extern char *xmalloc ();
+
+static char *savestring ();
+
+/* Add element named NAME to command list *LIST.
+   FUN should be the function to execute the command;
+   it will get a character string as argument, with leading
+   and trailing blanks already eliminated.
+
+   DOC is a documentation string for the command.
+   Its first line should be a complete sentence.
+   It should start with ? for a command that is an abbreviation
+   or with * for a command that most users don't need to know about.  */
+
+struct cmd_list_element *
+add_cmd (name, class, fun, doc, list)
+     char *name;
+     int class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c
+    = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
+
+  delete_cmd (name, list);
+  c->next = *list;
+  c->name = savestring (name, strlen (name));
+  c->class = class;
+  c->function = fun;
+  c->doc = doc;
+  c->prefixlist = 0;
+  c->allow_unknown = 0;
+  c->abbrev_flag = 0;
+  c->aux = 0;
+  *list = c;
+  return c;
+}
+
+struct cmd_list_element *
+add_alias_cmd (name, oldname, class, abbrev_flag, list)
+     char *name;
+     char *oldname;
+     int class;
+     int abbrev_flag;
+     struct cmd_list_element **list;
+{
+  /* Must do this since lookup_cmd tries to side-effect its first arg */
+  char *copied_name;
+  register struct cmd_list_element *old;
+  register struct cmd_list_element *c;
+  copied_name = (char *) alloca (strlen (oldname) + 1);
+  strcpy (copied_name, oldname);
+  old  = lookup_cmd (&copied_name, *list, 0, 1);
+
+  if (old == 0)
+    {
+      delete_cmd (name, list);
+      return 0;
+    }
+
+  c = add_cmd (name, class, old->function, old->doc, list);
+  c->prefixlist = old->prefixlist;
+  c->prefixname = old->prefixname;
+  c->allow_unknown = old->allow_unknown;
+  c->abbrev_flag = abbrev_flag;
+  c->aux = old->aux;
+  return c;
+}
+
+/* Like add_prefix_cmd but adds an element for a command prefix:
+   a name that should be followed by a subcommand to be looked up
+   in another command list.  PREFIXLIST should be the address
+   of the variable containing that list.  */
+
+struct cmd_list_element *
+add_prefix_cmd (name, class, fun, doc, prefixlist, prefixname,
+		allow_unknown, list)
+     char *name;
+     int class;
+     void (*fun) ();
+     char *doc;
+     struct cmd_list_element **prefixlist;
+     char *prefixname;
+     int allow_unknown;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list);
+  c->prefixlist = prefixlist;
+  c->prefixname = prefixname;
+  c->allow_unknown = allow_unknown;
+  return c;
+}
+
+/* Remove the command named NAME from the command list.  */
+
+void
+delete_cmd (name, list)
+     char *name;
+     struct cmd_list_element **list;
+{
+  register struct cmd_list_element *c;
+
+  while (*list && !strcmp ((*list)->name, name))
+    {
+      *list = (*list)->next;
+    }
+
+  if (*list)
+    for (c = *list; c->next;)
+      {
+	if (!strcmp (c->next->name, name))
+	  c->next = c->next->next;
+	else
+	  c = c->next;
+      }
+}
+
+/* Implement a help command on command list LIST.
+   COMMAND is the argument given (a command from the list to document)
+   or zero for no arg (describe briefly all the commands in the list).
+   CMDTYPE is a string to use in the error message if command COMMAND
+   is not found in the list.  */
+
+/* CLASS should be -1 to list all commands in LIST,
+   or a nonnegative class number value to list just commands in that class,
+   or -2 to list the classes themselves.  */
+
+void
+help_cmd (command, list, cmdtype, class, stream)
+     char *command;
+     struct cmd_list_element *list;
+     char *cmdtype;
+     int class;
+     FILE *stream;
+{
+  register struct cmd_list_element *c;
+  register char *p;
+  register int ncmds;
+  struct cmdvec { struct cmd_list_element *cmd; int class; };
+  register struct cmdvec *cmdvec;
+  char *cmdtype1, *cmdtype2;
+  int len;
+
+  if (command)
+    {
+      c = lookup_cmd (&command, list, cmdtype, 0);
+      if (c == 0)
+	return;
+
+      /* There are three cases here.
+	 If c->prefixlist is nonzer, we have a prefix command.
+	 Print its documentation, then list its subcommands.
+
+	 If c->function is nonzero, we really have a command.
+	 Print its documentation and return.
+
+	 If c->function is zero, we have a class name.
+	 Print its documentation (as if it were a command)
+	 and then set class to he number of this class
+	 so that the commands in the class will be listed.  */
+
+      p = c->doc;
+      fprintf (stream, "%s\n", p);
+      if (c->function != 0 && c->prefixlist == 0)
+	return;
+      fputc ('\n', stream);
+      if (c->prefixlist)
+	{
+	  list = *c->prefixlist;
+	  class = 0;
+	  cmdtype = c->prefixname;
+	}
+      else
+	class = c->class;
+    }
+
+  /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub"  */
+  len = strlen (cmdtype);
+  cmdtype1 = (char *) alloca (len + 1);
+  cmdtype1[0] = 0;
+  cmdtype2 = (char *) alloca (len + 4);
+  cmdtype2[0] = 0;
+  if (len)
+    {
+      cmdtype1[0] = ' ';
+      strncpy (cmdtype1 + 1, cmdtype, len - 1);
+      cmdtype1[len] = 0;
+      strncpy (cmdtype2, cmdtype, len - 1);
+      strcpy (cmdtype2 + len - 1, " sub");
+    }
+
+  if (class == -2)
+    fprintf (stream, "List of classes of %scommands:\n\n", cmdtype2);
+  else
+    fprintf (stream, "List of %scommands:\n\n", cmdtype2);
+
+  for (c = list; c; c = c->next)
+    {
+      if (c->abbrev_flag == 0
+	  && (class == -1	/* Listing all */
+	      || (c->class == class && c->function != 0) /* Listing one class */
+	      || (class == -2 && c->function == 0)))	/* Listing the classes */
+	{
+	  fprintf (stream, "%s -- ", c->name);
+	  /* Print just first line of documentation.  */
+	  p = c->doc;
+	  while (*p && *p != '\n') p++;
+	  fwrite (c->doc, 1, p - c->doc, stream);
+	  fputc ('\n', stream);
+	}
+    }
+
+  if (class == -2)
+    fprintf (stream, "\n\
+Type \"help%s\" followed by a class name for a list of commands in that class.",
+	     cmdtype1);
+
+  fprintf (stream, "\n\
+Type \"help%s\" followed by %scommand name for full documentation.\n\
+Command name abbreviations are allowed if unambiguous.\n",
+	   cmdtype1, cmdtype2);
+}
+
+/* Look up the contents of *LINE as a command in the command list LIST.
+   LIST is a chain of struct cmd_list_element's.
+   If it is found, return the struct cmd_list_element for that command
+   and update *LINE to point after the command name, at the first argument.
+   If not found, call error if ALLOW_UNKNOWN is zero
+   otherwise (or if error returns) return zero.
+   Call error if specified command is ambiguous,
+   unless ALLOW_UNKNOWN is negative.
+   CMDTYPE precedes the word "command" in the error message.  */
+
+struct cmd_list_element *
+lookup_cmd (line, list, cmdtype, allow_unknown)
+     char **line;
+     struct cmd_list_element *list;
+     char *cmdtype;
+     int allow_unknown;
+{
+  register char *p;
+  register struct cmd_list_element *c, *found;
+  int nfound;
+  char ambbuf[100];
+
+  /* Skip leading whitespace.  */
+
+  while (**line == ' ' || **line == '\t')
+    (*line)++;
+
+  /* Clear out trailing whitespace.  */
+
+  p = *line + strlen (*line);
+  while (p != *line && (p[-1] == ' ' || p[-1] == '\t'))
+    p--;
+  *p = 0;
+
+  /* Find end of command name.  */
+
+  p = *line;
+  while (*p == '-'
+	 || (*p >= 'a' && *p <= 'z')
+	 || (*p >= 'A' && *p <= 'Z')
+	 || (*p >= '1' && *p <= '9'))
+    {
+      if (*p >= 'A' && *p <= 'Z')
+	*p += 'a' - 'A';
+      p++;
+    }
+
+  /* Look up the command name.
+     If exact match, keep that.
+     Otherwise, take command abbreviated, if unique.  */
+
+  found = 0;
+  nfound = 0;
+  for (c = list; c; c = c->next)
+    {
+      if (!strncmp (*line, c->name, p - *line))
+	{
+	  found = c;
+	  nfound++;
+	  if (c->name[p - *line] == 0)
+	    {
+	      nfound = 1;
+	      break;
+	    }
+	}
+    }
+
+  /* Report error for undefined command name.  */
+
+  if (nfound != 1)
+    {
+      if (nfound > 1 && allow_unknown >= 0)
+	{
+	  *p = 0;
+	  ambbuf[0] = 0;
+	  for (c = list; c; c = c->next)
+	    if (!strncmp (*line, c->name, p - *line))
+	      {
+		if (strlen (ambbuf) + strlen (c->name) + 6 < sizeof ambbuf)
+		  {
+		    if (strlen (ambbuf))
+		      strcat (ambbuf, ", ");
+		    strcat (ambbuf, c->name);
+		  }
+		else
+		  {
+		    strcat (ambbuf, "..");
+		    break;
+		  }
+	      }
+	  error ("Ambiguous %scommand \"%s\": %s.", cmdtype, *line, ambbuf);
+	}
+      else if (!allow_unknown)
+	{
+	  *p = 0;
+	  error ("Undefined %scommand: \"%s\".", cmdtype, *line);
+	}
+      return 0;
+    }
+
+  /* Skip whitespace before the argument.  */
+
+  while (*p == ' ' || *p == '\t') p++;
+  *line = p;
+
+  if (found->prefixlist && *p)
+    {
+      c = lookup_cmd (line, *found->prefixlist, found->prefixname,
+		      found->allow_unknown);
+      if (c)
+	return c;
+    }
+
+  return found;
+}
+
+/* Make a copy of the string at PTR with SIZE characters
+   (and add a null character at the end in the copy).
+   Uses malloc to get the space.  Returns the address of the copy.  */
+
+static char *
+savestring (ptr, size)
+     char *ptr;
+     int size;
+{
+  register char *p = (char *) xmalloc (size + 1);
+  bcopy (ptr, p, size);
+  p[size] = 0;
+  return p;
+}
diff --git a/gdb/command.h b/gdb/command.h
new file mode 100644
index 0000000..687741c
--- /dev/null
+++ b/gdb/command.h
@@ -0,0 +1,154 @@
+/* Header file for command-reading library command.c.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+		       NO WARRANTY
+
+  BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+		GENERAL PUBLIC LICENSE TO COPY
+
+  1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of this
+    program or any part thereof, to be licensed at no charge to all
+    third parties on terms identical to those contained in this
+    License Agreement (except that you may choose to grant more
+    extensive warranty protection to third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of this program in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them.   Help stamp out software-hoarding!  */
+
+
+/* This structure records one command'd definition.  */
+
+struct cmd_list_element
+  {
+    /* Points to next command in this list.  */
+    struct cmd_list_element *next;
+
+    /* Name of this command.  */
+    char *name;
+
+    /* Command class; class values are chosen by application program.  */
+    int class;
+
+    /* Function definition of this command.
+       Zero for command class names and for help topics that
+       are not really commands.  */
+    void (*function) ();
+
+    /* Documentation of this command (or help topic).
+       First line is brief documentation; remaining lines form, with it,
+       the full documentation.  First line should end with a period.
+       Entire string should also end with a period, not a newline.  */
+    char *doc;
+
+    /* Auxiliary information.
+       It is up to the calling program to decide what this means.  */
+    char *aux;
+
+    /* Nonzero identifies a prefix command.  For them, the address
+       of the variable containing the list of subcommands.  */
+    struct cmd_list_element **prefixlist;
+
+    /* For prefix commands only:
+       String containing prefix commands to get here: this one
+       plus any others needed to get to it.  Should end in a space.
+       It is used before the word "command" in describing the
+       commands reached through this prefix.  */
+    char *prefixname;
+
+    /* For prefix commands only:
+       nonzero means do not get an error if subcommand is not
+       recognized; call the prefix's own function in that case.  */
+    char allow_unknown;
+
+    /* Nonzero says this is an abbreviation, and should not
+       be mentioned in lists of commands.  */
+    char abbrev_flag;
+  };
+
+/* Forward-declarations of the entry-points of command.c.  */
+
+extern struct cmd_list_element *add_cmd ();
+extern struct cmd_list_element *add_alias_cmd ();
+extern struct cmd_list_element *add_prefix_cmd ();
+extern struct cmd_list_element *lookup_cmd ();
+extern void delete_cmd ();
+extern void help_cmd ();
diff --git a/gdb/core.c b/gdb/core.c
new file mode 100644
index 0000000..7d3c68c
--- /dev/null
+++ b/gdb/core.c
@@ -0,0 +1,717 @@
+/* Work with core dump and executable files, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "initialize.h"
+#include "defs.h"
+#include "param.h"
+
+#include <a.out.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/dir.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+
+/* Recognize COFF format systems because a.out.h defines AOUTHDR.  */
+#ifdef AOUTHDR
+#define COFF_FORMAT
+#endif
+
+#ifdef NEW_SUN_CORE
+#include <sys/core.h>
+#else /* not NEW_SUN_CORE */
+#ifdef UMAX_CORE
+#include <sys/ptrace.h>
+#else /* not UMAX_CORE */
+#ifdef mac_aux
+#include <sys/seg.h>
+#include <sys/mmu.h>
+#include <sys/signal.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#else
+#include <sys/user.h>
+#endif /* mac_aux */
+#endif /* UMAX_CORE */
+#endif /* NEW_SUN_CORE */
+
+#ifndef N_TXTADDR
+#define N_TXTADDR(hdr) 0
+#endif /* no N_TXTADDR */
+
+#ifndef N_DATADDR
+#define N_DATADDR(hdr) hdr.a_text
+#endif /* no N_DATADDR */
+
+/* Make COFF and non-COFF names for things a little more compatible
+   to reduce conditionals later.  */
+
+#ifdef COFF_FORMAT
+#define a_magic magic
+#endif
+
+#ifndef COFF_FORMAT
+#define AOUTHDR struct exec
+#endif
+
+START_FILE
+
+/* Hook for `exec_file_command' command to call.  */
+
+void (*exec_file_display_hook) ();
+   
+/* File names of core file and executable file.  */
+
+static char *corefile;
+static char *execfile;
+
+/* Descriptors on which core file and executable file are open.
+   Note that the execchan is closed when an inferior is created
+   and reopened if the inferior dies or is killed.  */
+
+static int corechan;
+static int execchan;
+
+/* Last modification time of executable file.
+   Also used in source.c to compare against mtime of a source file.  */
+
+int exec_mtime;
+
+/* Virtual addresses of bounds of the two areas of memory in the core file.  */
+
+static CORE_ADDR data_start;
+static CORE_ADDR data_end;
+static CORE_ADDR stack_start;
+static CORE_ADDR stack_end;
+
+/* Virtual addresses of bounds of two areas of memory in the exec file.
+   Note that the data area in the exec file is used only when there is no core file.  */
+
+static CORE_ADDR text_start;
+static CORE_ADDR text_end;
+static CORE_ADDR exec_data_start;
+static CORE_ADDR exec_data_end;
+
+/* Address in executable file of start of text area data.  */
+
+static int text_offset;
+
+/* Address in executable file of start of data area data.  */
+
+static int exec_data_offset;
+
+/* Address in core file of start of data area data.  */
+
+static int data_offset;
+
+/* Address in core file of start of stack area data.  */
+
+static int stack_offset;
+  
+#ifdef COFF_FORMAT
+/* various coff data structures */
+
+static FILHDR file_hdr;
+static SCNHDR text_hdr;
+static SCNHDR data_hdr;
+
+#endif /* not COFF_FORMAT */
+
+/* a.out header saved in core file.  */
+  
+static AOUTHDR core_aouthdr;
+
+/* a.out header of exec file.  */
+
+static AOUTHDR exec_aouthdr;
+
+static void validate_files ();
+unsigned int register_addr ();
+
+core_file_command (filename, from_tty)
+     char *filename;
+     int from_tty;
+{
+  int val;
+  extern char registers[];
+
+  /* Discard all vestiges of any previous core file
+     and mark data and stack spaces as empty.  */
+
+  if (corefile)
+    free (corefile);
+  corefile = 0;
+
+  if (corechan >= 0)
+    close (corechan);
+  corechan = -1;
+
+  data_start = 0;
+  data_end = 0;
+  stack_start = STACK_END_ADDR;
+  stack_end = STACK_END_ADDR;
+
+  /* Now, if a new core file was specified, open it and digest it.  */
+
+  if (filename)
+    {
+      if (have_inferior_p ())
+	error ("To look at a core file, you must kill the inferior with \"kill\".");
+      corechan = open (filename, O_RDONLY, 0);
+      if (corechan < 0)
+	perror_with_name (filename);
+#ifdef NEW_SUN_CORE
+      {
+	struct core corestr;
+
+	val = myread (corechan, &corestr, sizeof corestr);
+	if (val < 0)
+	  perror_with_name (filename);
+	if (corestr.c_magic != CORE_MAGIC)
+	  error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)",
+		 filename, corestr.c_magic, (int) CORE_MAGIC);
+	else if (sizeof (struct core) != corestr.c_len)
+	  error ("\"%s\" has an invalid struct core length (%d, expected %d)",
+		 filename, corestr.c_len, (int) sizeof (struct core));
+
+	data_start = exec_data_start;
+	data_end = data_start + corestr.c_dsize;
+	stack_start = stack_end - corestr.c_ssize;
+	data_offset = sizeof corestr;
+	stack_offset = sizeof corestr + corestr.c_dsize;
+
+	bcopy (&corestr.c_regs, registers, 16 * 4);
+	*(int *)&registers[REGISTER_BYTE (PS_REGNUM)] = corestr.c_regs.r_ps;
+	*(int *)&registers[REGISTER_BYTE (PC_REGNUM)] = corestr.c_regs.r_pc;
+	bcopy (corestr.c_fpstatus.fps_regs,
+	       &registers[REGISTER_BYTE (FP0_REGNUM)],
+	       sizeof corestr.c_fpstatus.fps_regs);
+	bcopy (&corestr.c_fpstatus.fps_control,
+	       &registers[REGISTER_BYTE (FPC_REGNUM)],
+	       sizeof corestr.c_fpstatus - sizeof corestr.c_fpstatus.fps_regs);
+
+	bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
+
+	printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
+      }
+#else /* not NEW_SUN_CORE */
+      /* 4.2-style (and perhaps also sysV-style) core dump file.  */
+      {
+#ifdef UMAX_CORE
+	struct ptrace_user u;
+#else
+	struct user u;
+#endif
+	int reg_offset;
+
+	val = myread (corechan, &u, sizeof u);
+	if (val < 0)
+	  perror_with_name (filename);
+	data_start = exec_data_start;
+
+#ifdef UMAX_CORE
+	data_end = data_start + u.pt_dsize;
+	stack_start = stack_end - u.pt_ssize;
+	data_offset = sizeof u;
+	stack_offset = data_offset + u.pt_dsize;
+	reg_offset = 0;
+
+	bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR));
+
+#else /* not UMAX_CORE */
+#ifdef mac_aux
+	/* This may well not work for 0407 (nonshared text) a.out's */
+	data_end = data_start + u.u_dsize << PAGESHIFT;
+	stack_start = stack_end - u.u_ssize << PAGESHIFT;
+	data_offset = USIZE;
+	stack_offset = USIZE + u.u_dsize << PAGESHIFT;
+	reg_offset = (int) &u.u_ar0[0] - (int) &u;
+
+	core_aouthdr.a_magic = u.u_exdata.ux_mag;
+#else
+	data_end = data_start + NBPG * u.u_dsize;
+	stack_start = stack_end - NBPG * u.u_ssize;
+	data_offset = NBPG * UPAGES;
+	stack_offset = NBPG * (UPAGES + u.u_dsize);
+	reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR;
+
+	/* I don't know where to find this info.
+	   So, for now, mark it as not available.  */
+	core_aouthdr.a_magic = 0;
+#endif /* not mac_aux */
+#endif /* not UMAX_CORE */
+
+	/* Read the register values out of the core file and store
+	   them where `read_register' will find them.  */
+
+	{
+	  register int regno;
+
+	  for (regno = 0; regno < NUM_REGS; regno++)
+	    {
+	      char buf[MAX_REGISTER_RAW_SIZE];
+
+	      val = lseek (corechan, register_addr (regno, reg_offset), 0);
+	      if (val < 0)
+		perror_with_name (filename);
+
+ 	      val = myread (corechan, buf, sizeof buf);
+	      if (val < 0)
+		perror_with_name (filename);
+	      supply_register (regno, buf);
+	    }
+	}
+      }
+#endif /* not NEW_SUN_CORE */
+      if (filename[0] == '/')
+	corefile = savestring (filename, strlen (filename));
+      else
+	{
+	  char dirname[MAXPATHLEN];
+
+	  getwd (dirname);
+	  corefile = concat (dirname, "/", filename);
+	}
+
+      set_current_frame (read_register (FP_REGNUM));
+      select_frame (get_current_frame (), 0);
+      validate_files ();
+    }
+  else if (from_tty)
+    printf ("No core file now.\n");
+}
+
+exec_file_command (filename, from_tty)
+     char *filename;
+     int from_tty;
+{
+  int val;
+
+  /* Eliminate all traces of old exec file.
+     Mark text segment as empty.  */
+
+  if (execfile)
+    free (execfile);
+  execfile = 0;
+  data_start = 0;
+  data_end -= exec_data_start;
+  text_start = 0;
+  text_end = 0;
+  exec_data_start = 0;
+  exec_data_end = 0;
+  if (execchan >= 0)
+    close (execchan);
+  execchan = -1;
+
+  /* Now open and digest the file the user requested, if any.  */
+
+  if (filename)
+    {
+      execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
+			&execfile);
+      if (execchan < 0)
+	perror_with_name (filename);
+
+#ifdef COFF_FORMAT
+      {
+	int aout_hdrsize;
+	int num_sections;
+
+	if (read_file_hdr (execchan, &file_hdr) < 0)
+	  error ("\"%s\": not in executable format.", execfile);
+
+	aout_hdrsize = file_hdr.f_opthdr;
+	num_sections = file_hdr.f_nscns;
+
+	if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
+	  error ("\"%s\": can't read optional aouthdr", execfile);
+
+	if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections) < 0)
+	  error ("\"%s\": can't read text section header", execfile);
+
+	if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections) < 0)
+	  error ("\"%s\": can't read data section header", execfile);
+
+	text_start = exec_aouthdr.text_start;
+	text_end = text_start + exec_aouthdr.tsize;
+	text_offset = text_hdr.s_scnptr;
+	exec_data_start = exec_aouthdr.data_start;
+	exec_data_end = exec_data_start + exec_aouthdr.dsize;
+	exec_data_offset = data_hdr.s_scnptr;
+	data_start = exec_data_start;
+	data_end += exec_data_start;
+	exec_mtime = file_hdr.f_timdat;
+      }
+#else /* not COFF_FORMAT */
+      {
+	struct stat st_exec;
+
+	val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR));
+
+	if (val < 0)
+	  perror_with_name (filename);
+
+	text_start = N_TXTADDR (exec_aouthdr);
+	text_end = text_start + exec_aouthdr.a_text;
+	text_offset = N_TXTOFF (exec_aouthdr);
+	exec_data_start = N_DATADDR (exec_aouthdr);
+	exec_data_end = exec_data_start + exec_aouthdr.a_data;
+	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
+	data_start = exec_data_start;
+	data_end += exec_data_start;
+
+	fstat (execchan, &st_exec);
+	exec_mtime = st_exec.st_mtime;
+      }
+#endif /* not COFF_FORMAT */
+
+      validate_files ();
+    }
+  else if (from_tty)
+    printf ("No exec file now.\n");
+
+  /* Tell display code (if any) about the changed file name.  */
+  if (exec_file_display_hook)
+    (*exec_file_display_hook)
+      (filename ? filename : "No executable specified.\n");
+}
+
+/* Call this to specify the hook for exec_file_command to call back.
+   This is called from the x-window display code.  */
+
+specify_exec_file_hook (hook)
+     void (*hook) ();
+{
+  exec_file_display_hook = hook;
+}
+
+/* The exec file must be closed before running an inferior.
+   If it is needed again after the inferior dies, it must
+   be reopened.  */
+
+close_exec_file ()
+{
+  if (execchan >= 0)
+    close (execchan);
+  execchan = -1;
+}
+
+reopen_exec_file ()
+{
+  if (execchan < 0 && execfile != 0)
+    {
+      char *filename = concat (execfile, "", "");
+      exec_file_command (filename, 0);
+      free (filename);
+    }
+}
+
+/* If we have both a core file and an exec file,
+   print a warning if they don't go together.
+   This should really check that the core file came
+   from that exec file, but I don't know how to do it.  */
+
+static void
+validate_files ()
+{
+  if (execfile != 0 && corefile != 0)
+    {
+      struct stat st_core;
+
+      fstat (corechan, &st_core);
+
+      if (core_aouthdr.a_magic != 0
+	  && bcmp (&core_aouthdr, &exec_aouthdr, sizeof core_aouthdr))
+	printf ("Warning: core file does not match specified executable file.\n");
+      else if (exec_mtime > st_core.st_mtime)
+	printf ("Warning: exec file is newer than core file.\n");
+    }
+}
+
+char *
+get_exec_file ()
+{
+  if (execfile == 0)
+    error ("No executable file specified.\n\
+Use the \"exec-file\" and \"symbol-file\" commands.");
+  return execfile;
+}
+
+int
+have_core_file_p ()
+{
+  return corefile != 0;
+}
+
+static void
+files_info ()
+{
+  char *symfile;
+  extern char *get_sym_file ();
+
+  if (execfile)
+    printf ("Executable file \"%s\".\n", execfile);
+  else
+    printf ("No executable file\n");
+  if (corefile == 0)
+    printf ("No core dump file\n");
+  else
+    printf ("Core dump file \"%s\".\n", corefile);
+
+  if (have_inferior_p ())
+    printf ("Using the running image of the program, rather than these files.\n");
+
+  symfile = get_sym_file ();
+  if (symfile != 0)
+    printf ("Symbols loaded from \"%s\".\n", symfile);
+
+  if (! have_inferior_p ())
+    {
+      if (execfile)
+	{
+	  printf ("Text segment from 0x%x to 0x%x.\n",
+		  text_start, text_end);
+	}
+      if (corefile)
+	{
+	  printf ("Data segment from 0x%x to 0x%x.\nStack segment from 0x%x to 0x%x.\n",
+		  data_start, data_end, stack_start, stack_end);
+	}
+      else
+	{
+	  printf ("Data segment in executable from 0x%x to 0x%x.\n",
+		  exec_data_start, exec_data_end);
+	}
+    }
+}
+
+/* Read "memory data" from core file and/or executable file */
+
+read_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  if (have_inferior_p ())
+    read_inferior_memory (memaddr, myaddr, len);
+  else
+    xfer_core_file (memaddr, myaddr, len, 0);
+}
+
+/* Write LEN bytes of data starting at address MYADDR
+   into debugged program memory at address MEMADDR.
+   Returns zero if successful, or an errno value if ptrace failed.  */
+
+int
+write_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  if (have_inferior_p ())
+    return write_inferior_memory (memaddr, myaddr, len);
+  else
+    error ("Can write memory only when program being debugged is running.");
+}
+
+xfer_core_file (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  register int val;
+  int xferchan;
+  char **xferfile;
+  int fileptr;
+
+  while (len > 0)
+    {
+      xferfile = 0;
+      xferchan = 0;
+
+      /* Determine which file the next bunch of addresses reside in,
+	 and where in the file.  Set the file's read/write pointer
+	 to point at the proper place for the desired address
+	 and set xferfile and xferchan for the correct file.
+	 If desired address is nonexistent, leave them zero.
+	 i is set to the number of bytes that can be handled
+	 along with the next address.  */
+
+      if (memaddr < text_start)
+	{
+	  i = min (len, text_start - memaddr);
+	}
+      else if (memaddr >= text_end && memaddr < data_start)
+	{
+	  i = min (len, data_start - memaddr);
+	}
+      else if (memaddr >= (corechan >= 0 ? data_end : exec_data_end)
+	       && memaddr < stack_start)
+	{
+	  i = min (len, stack_start - memaddr);
+	}
+      else if (memaddr >= stack_end && stack_end != 0)
+	{
+	  i = min (len, - memaddr);
+	}
+      /* Note that if there is no core file
+	 data_start and data_end are equal.  */
+      else if (memaddr >= data_start && memaddr < data_end)
+	{
+	  i = min (len, data_end - memaddr);
+	  fileptr = memaddr - data_start + data_offset;
+	  xferfile = &corefile;
+	  xferchan = corechan;
+	}
+      /* Note that if there is no core file
+	 stack_start and stack_end are equal.  */
+      else if (memaddr >= stack_start && memaddr < stack_end)
+	{
+	  i = min (len, stack_end - memaddr);
+	  fileptr = memaddr - stack_start + stack_offset;
+	  xferfile = &corefile;
+	  xferchan = corechan;
+	}
+      else if (corechan < 0
+	       && memaddr >= exec_data_start && memaddr < exec_data_end)
+	{
+	  i = min (len, exec_data_end - memaddr);
+	  fileptr = memaddr - exec_data_start + exec_data_offset;
+	  xferfile = &execfile;
+	  xferchan = execchan;
+	}
+      else if (memaddr >= text_start && memaddr < text_end)
+	{
+	  i = min (len, text_end - memaddr);
+	  fileptr = memaddr - text_start + text_offset;
+	  xferfile = &execfile;
+	  xferchan = execchan;
+	}
+
+      /* Now we know which file to use.
+	 Set up its pointer and transfer the data.  */
+      if (xferfile)
+	{
+	  if (*xferfile == 0)
+	    if (xferfile == &execfile)
+	      error ("No program file to examine.");
+	    else
+	      error ("No core dump file or running program to examine.");
+	  val = lseek (xferchan, fileptr, 0);
+	  if (val < 0)
+	    perror_with_name (*xferfile);
+	  val = myread (xferchan, myaddr, i);
+	  if (val < 0)
+	    perror_with_name (*xferfile);
+	}
+      /* If this address is for nonexistent memory,
+	 read zeros if reading, or do nothing if writing.  */
+      else
+	bzero (myaddr, i);
+
+      memaddr += i;
+      myaddr += i;
+      len -= i;
+    }
+}
+
+/* My replacement for the read system call.
+   Used like `read' but keeps going if `read' returns too soon.  */
+
+myread (desc, addr, len)
+     int desc;
+     char *addr;
+     int len;
+{
+  register int val;
+  int orglen = len;
+
+  while (len > 0)
+    {
+      val = read (desc, addr, len);
+      if (val < 0)
+	return val;
+      if (val == 0)
+	return orglen - len;
+      len -= val;
+      addr += val;
+    }
+}
+
+#ifndef NEW_SUN_CORE
+
+/* Return the address in the core dump or inferior of register REGNO.
+   BLOCKEND is the address of the end of the user structure.  */
+
+unsigned int
+register_addr (regno, blockend)
+     int regno;
+     int blockend;
+{
+  int addr;
+
+  if (regno < 0 || regno >= NUM_REGS)
+    error ("Invalid register number %d.", regno);
+
+#ifdef mac_aux
+/* FIXME, we don't know where the regs are.  Maybe the test command
+ * that tests what parts of the upage are writeable will find 'em for us.
+ */
+#define REGISTER_U_ADDR(addr, foo, bar)  addr = 0;
+#endif
+  REGISTER_U_ADDR (addr, blockend, regno);
+
+  return addr;
+}
+
+#endif /* not NEW_SUN_CORE */
+
+static
+initialize ()
+{
+  corechan = -1;
+  execchan = -1;
+  corefile = 0;
+  execfile = 0;
+  exec_file_display_hook = 0;
+
+  text_start = 0;
+  text_end = 0;
+  data_start = 0;
+  data_end = 0;
+  exec_data_start = 0;
+  exec_data_end = 0;
+  stack_start = STACK_END_ADDR;
+  stack_end = STACK_END_ADDR;
+
+  add_com ("core-file", class_files, core_file_command,
+	   "Use FILE as core dump for examining memory and registers.\n\
+No arg means have no core file.");
+  add_com ("exec-file", class_files, exec_file_command,
+	   "Use FILE as program for getting contents of pure memory.\n\
+If FILE cannot be found as specified, your execution directory path\n\
+is searched for a command of that name.\n\
+No arg means have no executable file.");
+  add_info ("files", files_info, "Names of files being debugged.");
+}
+
+END_FILE
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
new file mode 100644
index 0000000..007e768
--- /dev/null
+++ b/gdb/dbxread.c
@@ -0,0 +1,2183 @@
+/* Read dbx symbol tables and convert to internal format, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "param.h"
+
+#ifdef READ_DBX_FORMAT
+
+#include <a.out.h>
+#include <stab.h>
+#include <stdio.h>
+#include <obstack.h>
+#include <sys/param.h>
+#include <sys/file.h>
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+
+static void add_symbol_to_list ();
+static void read_dbx_symtab ();
+static void process_one_symbol ();
+static struct type *read_type ();
+static struct type *read_range_type ();
+static struct type *read_enum_type ();
+static struct type *read_struct_type ();
+static long read_number ();
+static void finish_block ();
+static struct blockvector *make_blockvector ();
+static struct symbol *define_symbol ();
+static void start_subfile ();
+static int hashname ();
+static void hash_symsegs ();
+extern struct symtab *read_symsegs ();
+
+START_FILE
+
+/* Chain of symtabs made from reading the file's symsegs.
+   These symtabs do not go into symtab_list themselves,
+   but the information is copied from them when appropriate
+   to make the symtabs that will exist permanently.  */
+
+static struct symtab *symseg_chain;
+
+/* Symseg symbol table for the file whose data we are now processing.
+   It is one of those in symseg_chain.  Or 0, for a compilation that
+   has no symseg.  */
+
+static struct symtab *current_symseg;
+
+/* Name of source file whose symbol data we are now processing.
+   This comes from a symbol of type N_SO.  */
+
+static char *last_source_file;
+
+/* Core address of start of text of current source file.
+   This too comes from the N_SO symbol.  */
+
+static CORE_ADDR last_source_start_addr;
+
+/* End of the text segment of the executable file,
+   as found in the symbol _etext.  */
+
+static CORE_ADDR end_of_text_addr;
+
+/* The list of sub-source-files within the current individual compilation.
+   Each file gets its own symtab with its own linetable and associated info,
+   but they all share one blockvector.  */
+
+struct subfile
+{
+  struct subfile *next;
+  char *name;
+  struct linetable *line_vector;
+  int line_vector_length;
+  int line_vector_index;
+  int prev_line_number;
+};
+
+static struct subfile *subfiles;
+
+static struct subfile *current_subfile;
+
+/* The addresses of the symbol table stream and the string table
+   of the object file we are reading (as copied into core).  */
+
+static FILE *nlist_stream_global;
+static int nlist_size_global;
+static char *stringtab_global;
+
+/* The index in nlist_global of the last dbx symbol to be processed.  */
+
+static int symnum;
+
+/* Vector of types defined so far, indexed by their dbx type numbers.
+   (In newer sun systems, dbx uses a pair of numbers in parens,
+    as in "(SUBFILENUM,NUMWITHINSUBFILE)".  Then these numbers must be
+    translated through the type_translations hash table to get
+    the index into the type vector.)  */
+
+static struct typevector *type_vector;
+
+/* Number of elements allocated for type_vector currently.  */
+
+static int type_vector_length;
+
+/* Vector of line number information.  */
+
+static struct linetable *line_vector;
+
+/* Index of next entry to go in line_vector_index.  */
+
+static int line_vector_index;
+
+/* Last line number recorded in the line vector.  */
+
+static int prev_line_number;
+
+/* Number of elements allocated for line_vector currently.  */
+
+static int line_vector_length;
+
+/* Chain of global symbols whose values are not known yet.
+   They are chained thru the SYMBOL_VALUE, since we don't
+   have the correct data for that slot yet.  */
+
+#define HASHSIZE 127
+static struct symbol *global_sym_chain[HASHSIZE];
+
+/* Record the symbols defined for each context in a list.
+   We don't create a struct block for the context until we
+   know how long to make it.  */
+
+struct pending
+{
+  struct pending *next;
+  struct symbol *symbol;
+};
+
+/* Here are the three lists that symbols are put on.  */
+
+struct pending *file_symbols;	/* static at top level, and types */
+
+struct pending *global_symbols;	/* global functions and variables */
+
+struct pending *local_symbols;	/* everything local to lexical context */
+
+/* List of unclosed lexical contexts
+   (that will become blocks, eventually).  */
+
+struct context_stack
+{
+  struct context_stack *next;
+  struct pending *locals;
+  struct pending_block *old_blocks;
+  struct symbol *name;
+  CORE_ADDR start_addr;
+  int depth;
+};
+
+struct context_stack *context_stack;
+
+/* Nonzero if within a function (so symbols should be local,
+   if nothing says specifically).  */
+
+int within_function;
+
+/* List of blocks already made (lexical contexts already closed).
+   This is used at the end to make the blockvector.  */
+
+struct pending_block
+{
+  struct pending_block *next;
+  struct block *block;
+};
+
+struct pending_block *pending_blocks;
+
+extern CORE_ADDR first_object_file_end;	/* From blockframe.c */
+
+/* File name symbols were loaded from.  */
+
+static char *symfile;
+
+/* Support for Sun changes to dbx symbol format */
+
+/* For each identified header file, we have a table of types defined
+   in that header file.
+
+   header_files maps header file names to their type tables.
+   It is a vector of n_header_files elements.
+   Each element describes one header file.
+   It contains a vector of types.
+
+   Sometimes it can happen that the same header file produces
+   different results when included in different places.
+   This can result from conditionals or from different
+   things done before including the file.
+   When this happens, there are multiple entries for the file in this table,
+   one entry for each distinct set of results.
+   The entries are distinguished by the INSTANCE field.
+   The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
+   used to match header-file references to their corresponding data.  */
+
+struct header_file
+{
+  char *name;			/* Name of header file */
+  int instance;			/* Numeric code distinguishing instances
+				   of one header file that produced
+				   different results when included.
+				   It comes from the N_BINCL or N_EXCL.  */
+  struct type **vector;		/* Pointer to vector of types */
+  int length;			/* Allocated length (# elts) of that vector */
+};
+
+static struct header_file *header_files;
+
+static int n_header_files;
+
+static int n_allocated_header_files;
+
+/* Within each object file, various header files are assigned numbers.
+   A type is defined or referred to with a pair of numbers
+   (FILENUM,TYPENUM) where FILENUM is the number of the header file
+   and TYPENUM is the number within that header file.
+   TYPENUM is the index within the vector of types for that header file.
+
+   FILENUM == 1 is special; it refers to the main source of the object file,
+   and not to any header file.  FILENUM != 1 is interpreted by looking it up
+   in the following table, which contains indices in header_files.  */
+
+static int *this_object_header_files;
+
+static int n_this_object_header_files;
+
+static int n_allocated_this_object_header_files;
+
+/* When a header file is getting special overriding definitions
+   for one source file, record here the header_files index
+   of its normal definition vector.
+   At other times, this is -1.  */
+
+static int header_file_prev_index;
+
+/* At the start of reading dbx symbols, allocate our tables.  */
+
+static void
+init_header_files ()
+{
+  n_allocated_header_files = 10;
+  header_files = (struct header_file *) xmalloc (10 * sizeof (struct header_file));
+  n_header_files = 0;
+
+  n_allocated_this_object_header_files = 10;
+  this_object_header_files = (int *) xmalloc (10 * sizeof (int));
+}
+
+/* At the end of reading dbx symbols, free our tables.  */
+
+static void
+free_header_files ()
+{
+  register int i;
+  for (i = 0; i < n_header_files; i++)
+    free (header_files[i].name);
+  free (header_files);
+  free (this_object_header_files);
+}
+
+/* Called at the start of each object file's symbols.
+   Clear out the mapping of header file numbers to header files.  */
+
+static void
+new_object_header_files ()
+{
+  /* Leave FILENUM of 0 free for builtin types and this file's types.  */
+  n_this_object_header_files = 1;
+  header_file_prev_index = -1;
+}
+
+/* Add header file number I for this object file
+   at the next successive FILENUM.  */
+
+static void
+add_this_object_header_file (i)
+     int i;
+{
+  if (n_this_object_header_files == n_allocated_this_object_header_files)
+    {
+      n_allocated_this_object_header_files *= 2;
+      this_object_header_files
+	= (int *) xrealloc (this_object_header_files,
+			    n_allocated_this_object_header_files * sizeof (int));
+    }
+
+  this_object_header_files[n_this_object_header_files++] = i;
+}
+
+/* Add to this file an "old" header file, one already seen in
+   a previous object file.  NAME is the header file's name.
+   INSTANCE is its instance code, to select among multiple
+   symbol tables for the same header file.  */
+
+static void
+add_old_header_file (name, instance)
+     char *name;
+     int instance;
+{
+  register struct header_file *p = header_files;
+  register int i;
+
+  for (i = 0; i < n_header_files; i++)
+    if (!strcmp (p[i].name, name) && instance == p[i].instance)
+      {
+	add_this_object_header_file (i);
+	return;
+      }
+  error ("Invalid symbol data: \"repeated\" header file that hasn't been seen before, at symtab pos %d.",
+	 symnum);
+}
+
+/* Add to this file a "new" header file: definitions for its types follow.
+   NAME is the header file's name.
+   Most often this happens only once for each distinct header file,
+   but not necessarily.  If it happens more than once, INSTANCE has
+   a different value each time, and references to the header file
+   use INSTANCE values to select among them.
+
+   dbx output contains "begin" and "end" markers for each new header file,
+   but at this level we just need to know which files there have been;
+   so we record the file when its "begin" is seen and ignore the "end".  */
+
+static void
+add_new_header_file (name, instance)
+     char *name;
+     int instance;
+{
+  register int i;
+  register struct header_file *p = header_files;
+  header_file_prev_index = -1;
+
+#if 0
+  /* This code was used before I knew about the instance codes.
+     My first hypothesis is that it is not necessary now
+     that instance codes are handled.  */
+
+  /* Has this header file a previous definition?
+     If so, make a new entry anyway so that this use in this source file
+     gets a separate entry.  Later source files get the old entry.
+     Record here the index of the old entry, so that any type indices
+     not previously defined can get defined in the old entry as
+     well as in the new one.  */
+
+  for (i = 0; i < n_header_files; i++)
+    if (!strcmp (p[i].name, name))
+      {
+	header_file_prev_index = i;
+      }
+
+#endif
+
+  /* Make sure there is room for one more header file.  */
+
+  if (n_header_files == n_allocated_header_files)
+    {
+      n_allocated_header_files *= 2;
+      header_files
+	= (struct header_file *) xrealloc (header_files, n_allocated_header_files * sizeof (struct header_file));
+    }
+
+  /* Create an entry for this header file.  */
+
+  i = n_header_files++;
+  header_files[i].name = name;
+  header_files[i].instance = instance;
+  header_files[i].length = 10;
+  header_files[i].vector
+    = (struct type **) xmalloc (10 * sizeof (struct type *));
+  bzero (header_files[i].vector, 10 * sizeof (struct type *));
+
+  add_this_object_header_file (i);
+}
+
+/* Look up a dbx type-number pair.  Return the address of the slot
+   where the type for that number-pair is stored.
+   The number-pair is in TYPENUMS.
+
+   This can be used for finding the type associated with that pair
+   or for associating a new type with the pair.  */
+
+static struct type **
+dbx_lookup_type (typenums)
+     int typenums[2];
+{
+  register int filenum = typenums[0], index = typenums[1];
+
+  if (filenum < 0 || filenum >= n_this_object_header_files)
+    error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
+	   filenum, index, symnum);
+
+  if (filenum == 0)
+    {
+      /* Type is defined outside of header files.
+	 Find it in this object file's type vector.  */
+      if (index >= type_vector_length)
+	{
+	  type_vector_length *= 2;
+	  type_vector = (struct typevector *)
+	    xrealloc (type_vector, sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
+	  bzero (&type_vector->type[type_vector_length / 2],
+		 type_vector_length * sizeof (struct type *) / 2);
+	}
+      return &type_vector->type[index];
+    }
+  else
+    {
+      register int real_filenum = this_object_header_files[filenum];
+      register struct header_file *f;
+
+      if (real_filenum >= n_header_files)
+	abort ();
+
+      f = &header_files[real_filenum];
+
+      if (index >= f->length)
+	{
+	  f->length *= 2;
+	  f->vector = (struct type **)
+	    xrealloc (f->vector, f->length * sizeof (struct type *));
+	  bzero (&f->vector[f->length / 2],
+		 f->length * sizeof (struct type *) / 2);
+	}
+      return &f->vector[index];
+    }
+}
+
+/* Make sure there is a type allocated for type numbers TYPENUMS
+   and return the type object.
+   This can create an empty (zeroed) type object.  */
+
+static struct type *
+dbx_alloc_type (typenums)
+     int typenums[2];
+{
+  register struct type **type_addr = dbx_lookup_type (typenums);
+  register struct type *type = *type_addr;
+
+  /* If we are referring to a type not known at all yet,
+     allocate an empty type for it.
+     We will fill it in later if we find out how.  */
+  if (type == 0)
+    {
+      type = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+      bzero (type, sizeof (struct type));
+      *type_addr = type;
+    }
+  return type;
+}
+
+#if 0
+static struct type **
+explicit_lookup_type (real_filenum, index)
+     int real_filenum, index;
+{
+  register struct header_file *f = &header_files[real_filenum];
+
+  if (index >= f->length)
+    {
+      f->length *= 2;
+      f->vector = (struct type **)
+	xrealloc (f->vector, f->length * sizeof (struct type *));
+      bzero (&f->vector[f->length / 2],
+	     f->length * sizeof (struct type *) / 2);
+    }
+  return &f->vector[index];
+}
+#endif
+
+/* maintain the lists of symbols and blocks */
+
+/* Add a symbol to one of the lists of symbols.  */
+static void
+add_symbol_to_list (symbol, listhead)
+     struct symbol *symbol;
+     struct pending **listhead;
+{
+  register struct pending *link
+    = (struct pending *) xmalloc (sizeof (struct pending));
+
+  link->next = *listhead;
+  link->symbol = symbol;
+  *listhead = link;
+}
+
+/* Take one of the lists of symbols and make a block from it.
+   Put the block on the list of pending blocks.  */
+
+static void
+finish_block (symbol, listhead, old_blocks, start, end)
+     struct symbol *symbol;
+     struct pending **listhead;
+     struct pending_block *old_blocks;
+     CORE_ADDR start, end;
+{
+  register struct pending *next, *next1;
+  register struct block *block;
+  register struct pending_block *pblock;
+  struct pending_block *opblock;
+  register int i;
+
+  /* Count the length of the list of symbols.  */
+
+  for (next = *listhead, i = 0; next; next = next->next, i++);
+
+  block = (struct block *) obstack_alloc (symbol_obstack,
+					  sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
+
+  /* Copy the symbols into the block.  */
+
+  BLOCK_NSYMS (block) = i;
+  for (next = *listhead; next; next = next->next)
+    BLOCK_SYM (block, --i) = next->symbol;
+
+  BLOCK_START (block) = start;
+  BLOCK_END (block) = end;
+  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
+
+  /* Put the block in as the value of the symbol that names it.  */
+
+  if (symbol)
+    {
+      SYMBOL_BLOCK_VALUE (symbol) = block;
+      BLOCK_FUNCTION (block) = symbol;
+    }
+  else
+    BLOCK_FUNCTION (block) = 0;
+
+  /* Now free the links of the list, and empty the list.  */
+
+  for (next = *listhead; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  *listhead = 0;
+
+  /* Install this block as the superblock
+     of all blocks made since the start of this scope
+     that don't have superblocks yet.  */
+
+  opblock = 0;
+  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
+    {
+      if (BLOCK_SUPERBLOCK (pblock->block) == 0)
+	BLOCK_SUPERBLOCK (pblock->block) = block;
+      opblock = pblock;
+    }
+
+  /* Record this block on the list of all blocks in the file.
+     Put it after opblock, or at the beginning if opblock is 0.
+     This puts the block in the list after all its subblocks.  */
+
+  pblock = (struct pending_block *) xmalloc (sizeof (struct pending_block));
+  pblock->block = block;
+  if (opblock)
+    {
+      pblock->next = opblock->next;
+      opblock->next = pblock;
+    }
+  else
+    {
+      pblock->next = pending_blocks;
+      pending_blocks = pblock;
+    }
+}
+
+static struct blockvector *
+make_blockvector ()
+{
+  register struct pending_block *next, *next1;
+  register struct blockvector *blockvector;
+  register int i;
+
+  /* Count the length of the list of blocks.  */
+
+  for (next = pending_blocks, i = 0; next; next = next->next, i++);
+
+  blockvector = (struct blockvector *) obstack_alloc (symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
+
+  /* Copy the blocks into the blockvector.
+     This is done in reverse order, which happens to put
+     the blocks into the proper order (ascending starting address).
+     finish_block has hair to insert each block into the list
+     after its subblocks in order to make sure this is true.  */
+
+  BLOCKVECTOR_NBLOCKS (blockvector) = i;
+  for (next = pending_blocks; next; next = next->next)
+    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
+
+  /* Now free the links of the list, and empty the list.  */
+
+  for (next = pending_blocks; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  pending_blocks = 0;
+
+  return blockvector;
+}
+
+/* Manage the vector of line numbers.  */
+
+static
+record_line (line, pc)
+     int line;
+     CORE_ADDR pc;
+{
+  /* Ignore the dummy line number in libg.o */
+
+  if (line == 0xffff)
+    return;
+
+  /* Make sure line vector is big enough.  */
+
+  if (line_vector_index + 1 >= line_vector_length)
+    {
+      line_vector_length *= 2;
+      line_vector = (struct linetable *)
+	xrealloc (line_vector,
+		  sizeof (struct linetable) + line_vector_length * sizeof (int));
+      current_subfile->line_vector = line_vector;
+    }
+
+  /* If this line is not continguous with previous one recorded,
+     record a line-number entry for it.  */
+  if (line != prev_line_number + 1)
+    line_vector->item[line_vector_index++] = - line;
+  prev_line_number = line;
+
+  /* Record the core address of the line.  */
+  line_vector->item[line_vector_index++] = pc;
+}
+
+/* Start a new symtab for a new source file.
+   This is called when a dbx symbol of type N_SO is seen;
+   it indicates the start of data for one original source file.  */
+
+static void
+start_symtab (name, start_addr)
+     char *name;
+     CORE_ADDR start_addr;
+{
+  register struct symtab *s;
+
+  last_source_file = name;
+  last_source_start_addr = start_addr;
+  file_symbols = 0;
+  global_symbols = 0;
+  context_stack = 0;
+  within_function = 0;
+
+  new_object_header_files ();
+
+  for (s = symseg_chain; s; s = s->next)
+    if (s->ldsymoff == symnum * sizeof (struct nlist))
+      break;
+  current_symseg = s;
+
+  type_vector_length = 160;
+  type_vector = (struct typevector *) xmalloc (sizeof (struct typevector) + type_vector_length * sizeof (struct type *));
+  bzero (type_vector->type, type_vector_length * sizeof (struct type *));
+
+  /* Initialize the list of sub source files with one entry
+     for this file (the top-level source file).  */
+
+  subfiles = 0;
+  current_subfile = 0;
+  start_subfile (name);
+}
+
+/* Handle an N_SOL symbol, which indicates the start of
+   code that came from an included (or otherwise merged-in)
+   source file with a different name.  */
+
+static void
+start_subfile (name)
+     char *name;
+{
+  register struct subfile *subfile;
+
+  /* Save the current subfile's line vector data.  */
+
+  if (current_subfile)
+    {
+      current_subfile->line_vector_index = line_vector_index;
+      current_subfile->line_vector_length = line_vector_length;
+      current_subfile->prev_line_number = prev_line_number;
+    }
+
+  /* See if this subfile is already known as a subfile of the
+     current main source file.  */
+
+  for (subfile = subfiles; subfile; subfile = subfile->next)
+    {
+      if (!strcmp (subfile->name, name))
+	{
+	  line_vector = subfile->line_vector;
+	  line_vector_index = subfile->line_vector_index;
+	  line_vector_length = subfile->line_vector_length;
+	  prev_line_number = subfile->prev_line_number;
+	  current_subfile = subfile;
+	  return;
+	}
+    }
+
+  /* This subfile is not known.  Add an entry for it.  */
+
+  line_vector_index = 0;
+  line_vector_length = 1000;
+  prev_line_number = -2;	/* Force first line number to be explicit */
+  line_vector = (struct linetable *)
+    xmalloc (sizeof (struct linetable) + line_vector_length * sizeof (int));
+
+  /* Make an entry for this subfile in the list of all subfiles
+     of the current main source file.  */
+
+  subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
+  subfile->next = subfiles;
+  subfile->name = savestring (name, strlen (name));
+  subfile->line_vector = line_vector;
+  subfiles = subfile;
+  current_subfile = subfile;
+}
+
+/* Finish the symbol definitions for one main source file,
+   close off all the lexical contexts for that file
+   (creating struct block's for them), then make the struct symtab
+   for that file and put it in the list of all such.
+
+   END_ADDR is the address of the end of the file's text.  */
+
+static void
+end_symtab (end_addr)
+     CORE_ADDR end_addr;
+{
+  register struct symtab *symtab;
+  register struct context_stack *cstk;
+  register struct blockvector *blockvector;
+  register struct subfile *subfile;
+  register struct linetable *lv;
+  struct subfile *nextsub;
+
+  /* Finish the lexical context of the last function in the file.  */
+
+  if (context_stack)
+    {
+      cstk = context_stack;
+      /* Make a block for the local symbols within.  */
+      finish_block (cstk->name, &local_symbols, cstk->old_blocks,
+		    cstk->start_addr, end_addr);
+      free (cstk);
+    }
+
+  /* Finish defining all the blocks of this symtab.  */
+  if (current_symseg == 0)
+    {
+      finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
+      finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
+      blockvector = make_blockvector ();
+    }
+  current_subfile->line_vector_index = line_vector_index;
+
+  /* Now create the symtab objects proper, one for each subfile.  */
+  /* (The main file is one of them.)  */
+
+  for (subfile = subfiles; subfile; subfile = nextsub)
+    {
+      symtab = (struct symtab *) xmalloc (sizeof (struct symtab));
+      /* Fill in its components.  */
+      if (current_symseg)
+	{
+	  bcopy (current_symseg, symtab, sizeof (struct symtab));
+	  symtab->free_code = free_linetable;
+	  symtab->free_ptr = 0;
+	}
+      else
+	{
+	  symtab->blockvector = blockvector;
+	  type_vector->length = type_vector_length;
+	  symtab->typevector = type_vector;
+	  symtab->free_code = free_linetable;
+	  if (subfile->next == 0)
+	    symtab->free_ptr = (char *) type_vector;
+	}
+      symtab->filename = subfile->name;
+      lv = subfile->line_vector;
+      lv->nitems = subfile->line_vector_index;
+      symtab->linetable = (struct linetable *)
+	xrealloc (lv, sizeof (struct linetable) + lv->nitems * sizeof (int));
+      symtab->nlines = 0;
+      symtab->line_charpos = 0;
+
+      /* Link the new symtab into the list of such.  */
+      symtab->next = symtab_list;
+      symtab_list = symtab;
+
+      nextsub = subfile->next;
+      free (subfile);
+    }
+
+  type_vector = 0;
+  type_vector_length = -1;
+  line_vector = 0;
+  line_vector_length = -1;
+  last_source_file = 0;
+}
+
+#ifdef N_BINCL
+
+/* Handle the N_BINCL and N_EINCL symbol types
+   that act like N_SOL for switching source files
+   (different subfiles, as we call them) within one object file,
+   but using a stack rather than in an arbitrary order.  */
+
+struct subfile_stack
+{
+  struct subfile_stack *next;
+  char *name;
+  int prev_index;
+};
+
+struct subfile_stack *subfile_stack;
+
+static void
+push_subfile ()
+{
+  register struct subfile_stack *tem
+    = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
+
+  tem->next = subfile_stack;
+  subfile_stack = tem;
+  if (current_subfile == 0 || current_subfile->name == 0)
+    abort ();
+  tem->name = current_subfile->name;
+  tem->prev_index = header_file_prev_index;
+}
+
+static char *
+pop_subfile ()
+{
+  register char *name;
+  register struct subfile_stack *link = subfile_stack;
+
+  if (link == 0)
+    abort ();
+
+  name = link->name;
+  subfile_stack = link->next;
+  header_file_prev_index = link->prev_index;
+  free (link);
+
+  return name;
+}
+#endif /* Have N_BINCL */
+
+/* Accumulate the misc functions in bunches of 127.
+   At the end, copy them all into one newly allocated structure.  */
+
+#define MISC_BUNCH_SIZE 127
+
+struct misc_bunch
+{
+  struct misc_bunch *next;
+  struct misc_function contents[MISC_BUNCH_SIZE];
+};
+
+/* Bunch currently being filled up.
+   The next field points to chain of filled bunches.  */
+
+static struct misc_bunch *misc_bunch;
+
+/* Number of slots filled in current bunch.  */
+
+static int misc_bunch_index;
+
+/* Total number of misc functions recorded so far.  */
+
+static int misc_count;
+
+static void
+init_misc_functions ()
+{
+  misc_count = 0;
+  misc_bunch = 0;
+  misc_bunch_index = MISC_BUNCH_SIZE;
+}
+
+static void
+record_misc_function (name, address)
+     char *name;
+     CORE_ADDR address;
+{
+  register struct misc_bunch *new;
+
+  if (misc_bunch_index == MISC_BUNCH_SIZE)
+    {
+      new = (struct misc_bunch *) xmalloc (sizeof (struct misc_bunch));
+      misc_bunch_index = 0;
+      new->next = misc_bunch;
+      misc_bunch = new;
+    }
+  misc_bunch->contents[misc_bunch_index].name = name;
+  misc_bunch->contents[misc_bunch_index].address = address;
+  misc_bunch_index++;
+  misc_count++;
+}
+
+static int
+compare_misc_functions (fn1, fn2)
+     struct misc_function *fn1, *fn2;
+{
+  /* Return a signed result based on unsigned comparisons
+     so that we sort into unsigned numeric order.  */
+  if (fn1->address < fn2->address)
+    return -1;
+  if (fn1->address > fn2->address)
+    return 1;
+  return 0;
+}
+
+static void
+discard_misc_bunches ()
+{
+  register struct misc_bunch *next;
+
+  while (misc_bunch)
+    {
+      next = misc_bunch->next;
+      free (misc_bunch);
+      misc_bunch = next;
+    }
+}
+
+static void
+condense_misc_bunches ()
+{
+  register int i, j;
+  register struct misc_bunch *bunch;
+#ifdef NAMES_HAVE_UNDERSCORE
+  int offset = 1;
+#else
+  int offset = 0;
+#endif
+
+  misc_function_vector
+    = (struct misc_function *)
+      xmalloc (misc_count * sizeof (struct misc_function));
+
+  j = 0;
+  bunch = misc_bunch;
+  while (bunch)
+    {
+      for (i = 0; i < misc_bunch_index; i++)
+	{
+	  misc_function_vector[j] = bunch->contents[i];
+	  misc_function_vector[j].name
+	    = concat (misc_function_vector[j].name
+		      + (misc_function_vector[j].name[0] == '_' ? offset : 0),
+		      "", "");
+	  j++;
+	}
+      bunch = bunch->next;
+      misc_bunch_index = MISC_BUNCH_SIZE;
+    }
+
+  misc_function_count = j;
+
+  /* Sort the misc functions by address.  */
+
+  qsort (misc_function_vector, j, sizeof (struct misc_function),
+	 compare_misc_functions);
+}
+
+/* Call sort_syms to sort alphabetically
+   the symbols of each block of each symtab.  */
+
+static int
+compare_symbols (s1, s2)
+     struct symbol **s1, **s2;
+{
+  /* Names that are less should come first.  */
+  register int namediff = strcmp (SYMBOL_NAME (*s1), SYMBOL_NAME (*s2));
+  if (namediff != 0) return namediff;
+  /* For symbols of the same name, registers should come first.  */
+  return ((SYMBOL_CLASS (*s2) == LOC_REGISTER)
+	  - (SYMBOL_CLASS (*s1) == LOC_REGISTER));
+}
+
+static void
+sort_syms ()
+{
+  register struct symtab *s;
+  register int i, nbl;
+  register struct blockvector *bv;
+  register struct block *b;
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      nbl = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < nbl; i++)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, i);
+	  qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
+		 sizeof (struct symbol *), compare_symbols);
+	}
+    }
+}
+
+/* This is the symbol-file command.  Read the file, analyze its symbols,
+   and add a struct symtab to symtab_list.  */
+
+void
+symbol_file_command (name)
+     char *name;
+{
+  register int desc;
+  struct exec hdr;
+  struct nlist *nlist;
+  char *stringtab;
+  long buffer;
+  register int val;
+  extern void close ();
+  struct cleanup *old_chain;
+
+  dont_repeat ();
+
+  if (name == 0)
+    {
+      if (symtab_list && !query ("Discard symbol table? ", 0))
+	error ("Not confirmed.");
+      free_all_symtabs ();
+      return;
+    }
+
+  if (symtab_list && !query ("Load new symbol table from \"%s\"? ", name))
+    error ("Not confirmed.");
+
+  if (symfile)
+    free (symfile);
+  symfile = 0;
+
+  {
+    char *absolute_name;
+    desc = openp (getenv ("PATH"), 1, name, O_RDONLY, 0, &absolute_name);
+    if (desc < 0)
+      perror_with_name (name);
+    else
+      name = absolute_name;
+  }
+
+  old_chain = make_cleanup (close, desc);
+  make_cleanup (free_current_contents, &name);
+
+  val = myread (desc, &hdr, sizeof hdr);
+  if (val < 0)
+    perror_with_name (name);
+
+  if (N_BADMAG (hdr))
+    error ("File \"%s\" not in executable format.", name);
+
+  if (hdr.a_syms == 0)
+    {
+      free_all_symtabs ();
+      printf ("%s does not have a symbol-table.\n", name);
+      fflush (stdout);
+      return;
+    }
+
+  /* Now read the string table, all at once.  */
+  val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
+  if (val < 0)
+    perror_with_name (name);
+  val = myread (desc, &buffer, sizeof buffer);
+  if (val < 0)
+    perror_with_name (name);
+  stringtab = (char *) alloca (buffer);
+  bcopy (&buffer, stringtab, sizeof buffer);
+  val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
+  if (val < 0)
+    perror_with_name (name);
+
+#ifdef READ_GDB_SYMSEGS
+  /* That puts us at the symsegs.  Read them.  */
+  symseg_chain = read_symsegs (desc, name);
+  hash_symsegs ();
+#else
+  /* Where people are using the 4.2 ld program, must not check for
+     symsegs, because that ld puts randonm garbage at the end of
+     the output file and that would trigger an error message.  */
+  symseg_chain = 0;
+#endif
+
+  /* Position to read the symbol table.  Do not read it all at once. */
+  val = lseek (desc, N_SYMOFF (hdr), 0);
+  if (val < 0)
+    perror_with_name (name);
+
+  printf ("Reading symbol data from %s...", name);
+  fflush (stdout);
+
+  /* Throw away the old symbol table.  */
+
+  free_all_symtabs ();
+
+  init_misc_functions ();
+  make_cleanup (discard_misc_bunches, 0);
+  init_header_files ();
+  make_cleanup (free_header_files, 0);
+
+  /* Now that the symbol table data of the executable file are all in core,
+     process them and define symbols accordingly.  Closes desc.  */
+
+  read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
+
+  /* Sort symbols alphabetically within each block.  */
+
+  sort_syms ();
+
+  /* Go over the misc functions and install them in vector.  */
+
+  condense_misc_bunches ();
+
+  /* Don't allow char * to have a typename (else would get caddr_t.)  */
+
+  TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
+
+  /* Make a default for file to list.  */
+
+  select_source_symtab (symtab_list);
+
+  symfile = savestring (name, strlen (name));
+
+  do_cleanups (old_chain);
+
+  /* Free the symtabs made by read_symsegs, but not their contents,
+     which have been copied into symtabs on symtab_list.  */
+  while (symseg_chain)
+    {
+      register struct symtab *s = symseg_chain->next;
+      free (symseg_chain);
+      symseg_chain = s;
+    }
+
+  printf ("done.\n");
+  fflush (stdout);
+}
+
+/* Return name of file symbols were loaded from, or 0 if none..  */
+
+char *
+get_sym_file ()
+{
+  return symfile;
+}
+
+/* Given pointers to a a.out symbol table in core containing  dbx style data,
+   analyze them and create struct symtab's describing the symbols.
+   NLISTLEN is the number of symbols in the symbol table.
+   We read them one at a time using stdio.
+   All symbol names are given as offsets relative to STRINGTAB.  */
+
+static void
+read_dbx_symtab (desc, stringtab, nlistlen)
+     int desc;
+     register char *stringtab;
+     register int nlistlen;
+{
+  FILE *stream = fdopen (desc, "r");
+  struct nlist buf;
+  register char *namestring;
+  register struct symbol *sym, *prev;
+  int hash;
+  int num_object_files = 0;
+
+#ifdef N_BINCL
+  subfile_stack = 0;
+#endif
+
+  nlist_stream_global = stream;
+  nlist_size_global = nlistlen;
+  stringtab_global = stringtab;
+  last_source_file = 0;
+  bzero (global_sym_chain, sizeof global_sym_chain);
+
+  for (symnum = 0; symnum < nlistlen; symnum++)
+    {
+      fread (&buf, sizeof buf, 1, stream);
+      namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : "";
+      if (buf.n_type & N_STAB)
+	process_one_symbol (buf.n_type, buf.n_desc,
+			    buf.n_value, namestring);
+      /* A static text symbol whose name ends in ".o"
+	 can only mean the start of another object file.
+	 So end the symtab of the source file we have been processing.
+	 This is how we avoid counting the libraries as part
+	 or the last source file.
+	 Also this way we find end of first object file (crt0).  */
+      else if (buf.n_type == N_TEXT
+	       && !strcmp (namestring + strlen (namestring) - 2, ".o"))
+	{
+	  if (num_object_files++ == 1)
+	    first_object_file_end = buf.n_value;
+	  if (last_source_file)
+	    end_symtab (buf.n_value);
+	}
+      else if (buf.n_type & N_EXT || buf.n_type == N_TEXT)
+	{
+	  int used_up = 0;
+
+	  /* Record the location of _etext.  */
+	  if (buf.n_type == (N_TEXT | N_EXT)
+	      && !strcmp (namestring, "_etext"))
+	    end_of_text_addr = buf.n_value;
+
+	  /* Global symbol: see if we came across a dbx definition
+	     for a corresponding symbol.  If so, store the value.
+	     Remove syms from the chain when their values are stored,
+	     but search the whole chain, as there may be several syms
+	     from different files with the same name.  */
+	  if (buf.n_type & N_EXT)
+	    {
+	      prev = 0;
+#ifdef NAMES_HAVE_UNDERSCORE
+	      hash = hashname (namestring + 1);
+#else /* not NAMES_HAVE_UNDERSCORE */
+	      hash = hashname (namestring);
+#endif /* not NAMES_HAVE_UNDERSCORE */
+	      for (sym = global_sym_chain[hash];
+		   sym;)
+		{
+		  if (
+#ifdef NAMES_HAVE_UNDERSCORE
+		      *namestring == '_'
+		      && namestring[1] == SYMBOL_NAME (sym)[0]
+		      &&
+		      !strcmp (namestring + 2, SYMBOL_NAME (sym) + 1)
+#else /* NAMES_HAVE_UNDERSCORE */
+		      namestring[0] == SYMBOL_NAME (sym)[0]
+		      &&
+		      !strcmp (namestring + 1, SYMBOL_NAME (sym) + 1)
+#endif /* NAMES_HAVE_UNDERSCORE */
+		      )
+		    {
+		      if (prev)
+			SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
+		      else
+			global_sym_chain[hash]
+			  = (struct symbol *) SYMBOL_VALUE (sym);
+		      SYMBOL_VALUE (sym) = buf.n_value;
+		      if (prev)
+			sym = (struct symbol *) SYMBOL_VALUE (prev);
+		      else
+			sym = global_sym_chain[hash];
+
+		      used_up = 1;
+		    }
+		  else
+		    {
+		      prev = sym;
+		      sym = (struct symbol *) SYMBOL_VALUE (sym);
+		    }
+		}
+	    }
+
+	  /* Defined global or text symbol: record as a misc function
+	     if it didn't give its address to a debugger symbol above.  */
+	  if (buf.n_type <= (N_TYPE | N_EXT)
+	      && buf.n_type != N_EXT
+	      && ! used_up)
+	    record_misc_function (namestring, buf.n_value);
+	}
+    }
+
+  if (last_source_file)
+    end_symtab (end_of_text_addr);
+
+  fclose (stream);
+}
+
+/* dbx allows the text of a symbol name to be continued into the
+   next symbol name!  When such a continuation is encountered
+   (a \ at the end of the text of a name)
+   call this function to get the continuation.  */
+
+static char *
+next_symbol_text ()
+{
+  struct nlist buf;
+  fread (&buf, sizeof buf, 1, nlist_stream_global);
+  symnum++;
+  return buf.n_un.n_strx + stringtab_global;
+}
+
+static int
+hashname (name)
+     char *name;
+{
+  register char *p = name;
+  register int total = p[0];
+  register int c;
+
+  c = p[1];
+  total += c << 2;
+  if (c)
+    {
+      c = p[2];
+      total += c << 4;
+      if (c)
+	total += p[3] << 6;
+    }
+  
+  return total % HASHSIZE;
+}
+
+/* Put all appropriate global symbols in the symseg data
+   onto the hash chains so that their addresses will be stored
+   when seen later in loader global symbols.  */
+
+static void
+hash_symsegs ()
+{
+  /* Look at each symbol in each block in each symseg symtab.  */
+  struct symtab *s;
+  for (s = symseg_chain; s; s = s->next)
+    {
+      register int n;
+      for (n = BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s)) - 1; n >= 0; n--)
+	{
+	  register struct block *b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), n);
+	  register int i;
+	  for (i = BLOCK_NSYMS (b) - 1; i >= 0; i--)
+	    {
+	      register struct symbol *sym = BLOCK_SYM (b, i);
+
+	      /* Put the symbol on a chain if its value is an address
+		 that is figured out by the loader.  */
+
+	      if (SYMBOL_CLASS (sym) == LOC_EXTERNAL)
+		{
+		  register int hash = hashname (SYMBOL_NAME (sym));
+		  SYMBOL_VALUE (sym) = (int) global_sym_chain[hash];
+		  global_sym_chain[hash] = sym;
+		  SYMBOL_CLASS (sym) = LOC_STATIC;
+		}
+	    }
+	}
+    }
+}
+
+static void
+process_one_symbol (type, desc, value, name)
+     int type, desc;
+     CORE_ADDR value;
+     char *name;
+{
+  register struct context_stack *new;
+  
+  /* Something is wrong if we see real data before
+     seeing a source file name.  */
+  
+#ifdef N_NSYMS
+  if (type == N_NSYMS) return;
+#endif
+
+  if (type != N_SO && last_source_file == 0)
+    error ("Invalid symbol data: does not start by identifying a source file.");
+
+  switch (type)
+    {
+    case N_FUN:
+    case N_FNAME:
+      /* Either of these types of symbols indicates the start of
+	 a new function.  We must process its "name" normally for dbx,
+	 but also record the start of a new lexical context, and possibly
+	 also the end of the lexical context for the previous function.  */
+      new = context_stack;
+      within_function = 1;
+      if (new)
+	{
+	  /* Make a block for the local symbols within.  */
+	  finish_block (new->name, &local_symbols, new->old_blocks,
+			new->start_addr, value);
+	}
+      else
+	{
+	  new = (struct context_stack *) xmalloc (sizeof (struct context_stack));
+	  new->next = 0;
+	  new->depth = -1;
+	  context_stack = new;
+	}
+      new->locals = 0;
+      new->old_blocks = pending_blocks;
+      new->start_addr = value;
+      new->name = define_symbol (value, name, desc);
+      local_symbols = 0;
+      break;
+
+    case N_LBRAC:
+      /* This "symbol" just indicates the start of an inner lexical
+	 context within a function.  */
+      new = (struct context_stack *) xmalloc (sizeof (struct context_stack));
+      new->depth = desc;
+      new->next = context_stack;
+      context_stack = new;
+      new->locals = local_symbols;
+      new->old_blocks = pending_blocks;
+      new->start_addr = value;
+      new->name = 0;
+      local_symbols = 0;
+      break;
+
+    case N_RBRAC:
+      /* This "symbol" just indicates the end of an inner lexical
+	 context that was started with N_RBRAC.  */
+      new = context_stack;
+      if (new == 0 || desc != new->depth)
+	error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
+      local_symbols = new->locals;
+      context_stack = new->next;
+      /* If this is not the outermost LBRAC...RBRAC pair in the
+	 function, its local symbols preceded it, and are the ones
+	 just recovered from the context stack.  Defined the block for them.
+
+	 If this is the outermost LBRAC...RBRAC pair, there is no
+	 need to do anything; leave the symbols that preceded it
+	 to be attached to the function's own block.  */
+      if (local_symbols && context_stack->next)
+	{
+	  /* Muzzle a compiler bug that makes end > start.  */
+	  if (new->start_addr > value)
+	    new->start_addr = value;
+	  /* Make a block for the local symbols within.  */
+	  finish_block (0, &local_symbols, new->old_blocks,
+			new->start_addr + last_source_start_addr,
+			value + last_source_start_addr);
+	}
+      free (new);
+      break;
+
+    case N_FN:
+      /* This kind of symbol supposedly indicates the start
+	 of an object file.  In fact this type does not appear.  */
+      break;
+
+    case N_SO:
+      /* This type of symbol indicates the start of data
+	 for one source file.
+	 Finish the symbol table of the previous source file
+	 (if any) and start accumulating a new symbol table.  */
+      if (last_source_file)
+	end_symtab (value);
+      start_symtab (name, value);
+      break;
+
+    case N_SOL:
+      /* This type of symbol indicates the start of data for
+	 a sub-source-file, one whose contents were copied or
+	 included in the compilation of the main source file
+	 (whose name was given in the N_SO symbol.)  */
+      start_subfile (name);
+      break;
+
+#ifdef N_BINCL
+    case N_BINCL:
+      push_subfile ();
+      add_new_header_file (name, value);
+      start_subfile (name);
+      break;
+
+    case N_EINCL:
+      start_subfile (pop_subfile ());
+      break;
+
+    case N_EXCL:
+      add_old_header_file (name, value);
+      break;
+#endif /* have N_BINCL */
+
+    case N_SLINE:
+      /* This type of "symbol" really just records
+	 one line-number -- core-address correspondence.
+	 Enter it in the line list for this symbol table.  */
+      record_line (desc, value);
+      break;
+
+    default:
+      if (name)
+	define_symbol (value, name, desc);
+    }
+}
+
+static struct symbol *
+define_symbol (value, string, desc)
+     int value;
+     char *string;
+     int desc;
+{
+  register struct symbol *sym
+    = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
+  char *p = (char *) index (string, ':');
+  int deftype;
+  register int i;
+
+  bzero (sym, sizeof (struct symbol));
+  SYMBOL_NAME (sym) = obstack_copy0 (symbol_obstack, string, p - string);
+  p++;
+  /* Determine the type of name being defined.  */
+  if ((*p >= '0' && *p <= '9') || *p == '(')
+    deftype = 'l';
+  else
+    deftype = *p++;
+
+  /* c is a special case, not followed by a type-number.
+     SYMBOL:c=iVALUE for an integer constant symbol.
+     SYMBOL:c=rVALUE for a floating constant symbol.  */
+  if (deftype == 'c')
+    {
+      if (*p++ != '=')
+	error ("Invalid symbol data at symtab pos %d.", symnum);
+      switch (*p++)
+	{
+	case 'r':
+	  {
+	    double d = atof (p);
+	    char *value;
+
+	    SYMBOL_TYPE (sym) = builtin_type_double;
+	    value = (char *) obstack_alloc (symbol_obstack, sizeof (double));
+	    bcopy (&d, value, sizeof (double));
+	    SYMBOL_VALUE_BYTES (sym) = value;
+	    SYMBOL_CLASS (sym) = LOC_CONST;
+	  }
+	  break;
+	case 'i':
+	  {
+	    SYMBOL_TYPE (sym) = builtin_type_int;
+	    SYMBOL_VALUE (sym) = atoi (p);
+	    SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
+	  }
+	  break;
+	default:
+	  error ("Invalid symbol data at symtab pos %d.", symnum);
+	}
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      return sym;
+    }
+
+  /* Now usually comes a number that says which data type,
+     and possibly more stuff to define the type
+     (all of which is handled by read_type)  */
+
+  if (deftype == 'p' && *p == 'F')
+    /* pF is a two-letter code that means a function parameter in Fortran.
+       The type-number specifies the type of the return value.
+       Translate it into a pointer-to-function type.  */
+    {
+      p++;
+      SYMBOL_TYPE (sym)
+	= lookup_pointer_type (lookup_function_type (read_type (&p)));
+    }
+  else
+    SYMBOL_TYPE (sym) = read_type (&p);
+
+  switch (deftype)
+    {
+    case 'f':
+      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 'F':
+      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &global_symbols);
+      break;
+
+    case 'G':
+      /* For a class G (global) symbol, it appears that the
+	 value is not correct.  It is necessary to search for the
+	 corresponding linker definition to find the value.
+	 These definitions appear at the end of the namelist.  */
+      i = hashname (SYMBOL_NAME (sym));
+      SYMBOL_VALUE (sym) = (int) global_sym_chain[i];
+      global_sym_chain[i] = sym;
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &global_symbols);
+      break;
+
+      /* This case is faked by a conditional above,
+	 when there is no code letter in the dbx data.
+	 Dbx data never actually contains 'l'.  */
+    case 'l':
+      SYMBOL_CLASS (sym) = LOC_LOCAL;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'p':
+      SYMBOL_CLASS (sym) = LOC_ARG;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      /* DESC == 0 implies compiled with GCC.
+	 In this case, if it says `short', believe it.  */
+      if (desc == 0)
+	break;
+      /* If PCC says a parameter is a short or a char,
+	 it is really an int.  */
+      if (SYMBOL_TYPE (sym) == builtin_type_char
+	  || SYMBOL_TYPE (sym) == builtin_type_short)
+	SYMBOL_TYPE (sym) = builtin_type_int;
+      else if (SYMBOL_TYPE (sym) == builtin_type_unsigned_char
+	       || SYMBOL_TYPE (sym) == builtin_type_unsigned_short)
+	SYMBOL_TYPE (sym) = builtin_type_unsigned_int;
+      break;
+
+    case 'r':
+      SYMBOL_CLASS (sym) = LOC_REGISTER;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'S':
+      /* Static symbol at top level of file */
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 't':
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
+	  && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	TYPE_NAME (SYMBOL_TYPE (sym)) = concat (SYMBOL_NAME (sym), "", "");
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 'T':
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
+	  && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	TYPE_NAME (SYMBOL_TYPE (sym))
+	  = concat ("",
+		    (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM
+		     ? "enum "
+		     : (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+			? "struct " : "union ")),
+		    SYMBOL_NAME (sym));
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 'V':
+    case 'v':
+      /* Static symbol of local scope */
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_VALUE (sym) = value;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    default:
+      error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
+    }
+  return sym;
+}
+
+/* Read a number by which a type is referred to in dbx data,
+   or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
+   Just a single number N is equivalent to (0,N).
+   Return the two numbers by storing them in the vector TYPENUMS.
+   TYPENUMS will then be used as an argument to dbx_lookup_type.  */
+
+static void
+read_type_number (pp, typenums)
+     register char **pp;
+     register int *typenums;
+{
+  if (**pp == '(')
+    {
+      (*pp)++;
+      typenums[0] = read_number (pp, ',');
+      typenums[1] = read_number (pp, ')');
+    }
+  else
+    {
+      typenums[0] = 0;
+      typenums[1] = read_number (pp, 0);
+    }
+}
+
+/* Read a dbx type reference or definition;
+   return the type that is meant.
+   This can be just a number, in which case it references
+   a type already defined and placed in type_vector.
+   Or the number can be followed by an =, in which case
+   it means to define a new type according to the text that
+   follows the =.  */
+
+static
+struct type *
+read_type (pp)
+     register char **pp;
+{
+  register struct type *type = 0;
+  register int n;
+  struct type *type1;
+  int typenums[2];
+  int xtypenums[2];
+
+  read_type_number (pp, typenums);
+
+  /* Detect random reference to type not yet defined.
+     Allocate a type object but leave it zeroed.  */
+  if (**pp != '=')
+    return dbx_alloc_type (typenums);
+
+  *pp += 2;
+  switch ((*pp)[-1])
+    {
+    case 'x':
+      type = dbx_alloc_type (typenums);
+      /* Set the type code according to the following letter.  */
+      switch ((*pp)[0])
+	{
+	case 's':
+	  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+	  break;
+	case 'u':
+	  TYPE_CODE (type) = TYPE_CODE_UNION;
+	  break;
+	case 'e':
+	  TYPE_CODE (type) = TYPE_CODE_ENUM;
+	  break;
+	}
+      /* Skip the name the cross-ref points to.  */
+      *pp = (char *) index (*pp, ',');
+      /* Just allocate the type and leave it zero if nothing known */
+      return dbx_alloc_type (typenums);
+
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '(':
+      (*pp)--;
+      read_type_number (pp, xtypenums);
+      type = *dbx_lookup_type (xtypenums);
+      if (type == 0)
+	type = builtin_type_void;
+      *dbx_lookup_type (typenums) = type;
+      break;
+      
+    case '*':
+      type = dbx_alloc_type (typenums);
+      smash_to_pointer_type (type, read_type (pp));
+      break;
+
+    case 'f':
+      type = dbx_alloc_type (typenums);
+      smash_to_function_type (type, read_type (pp));
+      break;
+
+    case 'r':
+      type = read_range_type (pp, typenums);
+      *dbx_lookup_type (typenums) = type;
+      break;
+
+    case 'e':
+      type = dbx_alloc_type (typenums);
+      type = read_enum_type (pp, type);
+      *dbx_lookup_type (typenums) = type;
+      break;
+
+    case 's':
+      type = dbx_alloc_type (typenums);
+      type = read_struct_type (pp, type);
+      break;
+
+    case 'u':
+      type = dbx_alloc_type (typenums);
+      type = read_struct_type (pp, type);
+      TYPE_CODE (type) = TYPE_CODE_UNION;
+      break;
+
+    case 'a':
+      /* Define an array type.  */
+      type = dbx_alloc_type (typenums);
+
+      /* dbx expresses array types in terms of a range type for the index,
+	 and that range type is specified right inside the array type spec
+	 making ar1;MIN;MAX;VALTYPE  */
+      if (!strncmp (*pp, "r1;0;", 5))
+	(*pp) += 5;
+      else if (!strncmp (*pp, "r(0,1);0;", 9))
+	(*pp) += 9;
+      else break;
+
+      TYPE_CODE (type) = TYPE_CODE_ARRAY;
+      /* In Fortran, an upper bound may be T... meaning a parameter specifies
+	 the length of the data.  In this case, just pretend the bound is 1.
+	 This happens only for array parameters, which are really passed
+	 as pointers anyway, and we will translate them into such.  */
+      if (**pp == 'T')
+	{
+	  n = 1;
+	  while (**pp != ';')
+	    (*pp)++;
+	}
+      else
+	n = read_number (pp, ';') + 1;
+      TYPE_TARGET_TYPE (type) = read_type (pp);
+      TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type)) * n;
+      break;
+
+    default:
+      error ("Invalid symbol data: unrecognized type-code `%c' at symtab pos %d.",
+	     (*pp)[-1], symnum);
+    }
+
+  if (type == 0)
+    abort ();
+
+#if 0
+  /* If this is an overriding temporary alteration for a header file's
+     contents, and this type number is unknown in the global definition,
+     put this type into the global definition at this type number.  */
+  if (header_file_prev_index >= 0)
+    {
+      register struct type **tp
+        = explicit_lookup_type (header_file_prev_index, typenums[1]);
+      if (*tp == 0)
+	*tp = type;
+    }
+#endif
+  return type;
+}
+
+/* This page contains subroutines of read_type.  */
+
+/* Read the description of a structure (or union type)
+   and return an object describing the type.  */
+
+static struct type *
+read_struct_type (pp, type)
+     char **pp;
+     register struct type *type;
+{
+  struct nextfield
+    {
+      struct nextfield *next;
+      struct field field;
+    };
+
+  register struct nextfield *list = 0;
+  struct nextfield *new;
+  int totalsize;
+  char *name;
+  register char *p;
+  int nfields = 0;
+  register int n;
+
+  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+
+  /* First comes the total size in bytes.  */
+
+  TYPE_LENGTH (type) = read_number (pp, 0);
+
+  /* Now come the fields, as NAME:TYPENUM,BITPOS,BITSIZE; for each one.
+     At the end, we see a semicolon instead of a field.  */
+
+  while (**pp != ';')
+    {
+      /* Check for and handle cretinous dbx symbol name continuation!  */
+      if (**pp == '\\')
+	*pp = next_symbol_text ();
+
+      /* Get space to record the next field's data.  */
+      new = (struct nextfield *) alloca (sizeof (struct nextfield));
+      new->next = list;
+      list = new;
+
+      /* Read the data.  */
+      p = *pp;
+      while (*p != ':') p++;
+      list->field.name = savestring (*pp, p - *pp);
+      *pp = p + 1;
+      list->field.type = read_type (pp);
+      if (**pp != ',')
+	error ("Invalid symbol data: bad structure-type format at symtab pos %d.",
+	       symnum);
+      (*pp)++;			/* Skip the comma.  */
+      list->field.bitpos = read_number (pp, ',');
+      list->field.bitsize = read_number (pp, ';');
+      /* Detect an unpacked field and mark it as such.
+	 dbx gives a bit size for all fields.
+	 Also detect forward refs to structures and unions,
+	 and treat enums as if they had the width of ints.  */
+      if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
+	   || TYPE_CODE (list->field.type) == TYPE_CODE_STRUCT
+	   || TYPE_CODE (list->field.type) == TYPE_CODE_UNION
+	   || (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
+	       && list->field.bitsize == 8 * TYPE_LENGTH (builtin_type_int)))
+	  &&
+	  list->field.bitpos % 8 == 0)
+	list->field.bitsize = 0;
+      nfields++;
+    }
+
+  (*pp)++;			/* Skip the terminating ';'.  */
+
+  /* Now create the vector of fields, and record how big it is.  */
+
+  TYPE_NFIELDS (type) = nfields;
+  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
+						       sizeof (struct field) * nfields);
+
+  /* Copy the saved-up fields into the field vector.  */
+
+  for (n = nfields; list; list = list->next)
+    TYPE_FIELD (type, --n) = list->field;
+
+  return type;
+}
+
+/* Read a definition of an enumeration type,
+   and create and return a suitable type object.
+   Also defines the symbols that represent the values of the type.  */
+
+static struct type *
+read_enum_type (pp, type)
+     register char **pp;
+     register struct type *type;
+{
+  register char *p;
+  char *name;
+  register long n;
+  register struct symbol *sym;
+  int nsyms = 0;
+  struct pending **symlist;
+  struct pending *osyms, *syms;
+
+  if (within_function)
+    symlist = &local_symbols;
+  else
+    symlist = &file_symbols;
+  osyms = *symlist;
+
+  /* Read the value-names and their values.
+     The input syntax is NAME:VALUE,NAME:VALUE, and so on.
+     A semicolon instead of a NAME means the end.  */
+  while (**pp && **pp != ';')
+    {
+      /* Check for and handle cretinous dbx symbol name continuation!  */
+      if (**pp == '\\')
+	*pp = next_symbol_text ();
+
+      p = *pp;
+      while (*p != ':') p++;
+      name = savestring (*pp, p - *pp);
+      *pp = p + 1;
+      n = read_number (pp, ',');
+      
+      sym = (struct symbol *) xmalloc (sizeof (struct symbol));
+      bzero (sym, sizeof (struct symbol));
+      SYMBOL_NAME (sym) = name;
+      SYMBOL_CLASS (sym) = LOC_CONST;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      SYMBOL_VALUE (sym) = n;
+      add_symbol_to_list (sym, symlist);
+      nsyms++;
+    }
+
+  (*pp)++;			/* Skip the semicolon.  */
+
+  /* Now fill in the fields of the type-structure.  */
+
+  TYPE_LENGTH (type) = sizeof (int);
+  TYPE_CODE (type) = TYPE_CODE_ENUM;
+  TYPE_NFIELDS (type) = nsyms;
+  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
+
+  /* Find the symbols for the values and put them into the type.
+     The symbols can be found in the symlist that we put them on
+     to cause them to be defined.  osyms contains the old value
+     of that symlist; everything up to there was defined by us.  */
+
+  for (syms = *symlist, n = nsyms; syms != osyms; syms = syms->next)
+    {
+      SYMBOL_TYPE (syms->symbol) = type;
+      TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (syms->symbol);
+      TYPE_FIELD_VALUE (type, n) = SYMBOL_VALUE (syms->symbol);
+      TYPE_FIELD_BITPOS (type, n) = 0;
+      TYPE_FIELD_BITSIZE (type, n) = 0;
+    }
+
+  return type;
+}
+  
+static struct type *
+read_range_type (pp, typenums)
+     char **pp;
+     int typenums[2];
+{
+  char *errp = *pp;
+  int rangenums[2];
+  int n1, n2, n3;
+
+  /* First comes a type we are a subrange of.
+     In practice it is usually 0, 1 or the type being defined.  */
+  read_type_number (pp, rangenums);
+  n1 = rangenums[1];
+
+  /* A semicolon should now follow; skip it.  */
+  if (**pp == ';')
+    (*pp)++;
+
+  /* The remaining two operands are usually lower and upper bounds
+     of the range.  But in some special cases they mean something else.  */
+  n2 = read_number (pp, ';');
+  n3 = read_number (pp, ';');
+
+  /* A type defined as a subrange of itself, with bounds both 0, is void.  */
+  if (rangenums[0] == typenums[0] && rangenums[1] == typenums[1]
+      && n2 == 0 && n3 == 0)
+    return builtin_type_void;
+
+  /* If n3 is zero and n2 is not, we want a floating type,
+     and n2 is the width in bytes.
+
+     Fortran programs appear to use this for complex types also,
+     and they give no way to distinguish between double and single-complex!
+     We don't have complex types, so we would lose on all fortran files!
+     So return type `double' for all of those.  It won't work right
+     for the complex values, but at least it makes the file loadable.  */
+
+  if (n3 == 0 && n2 > 0)
+    {
+      if (n2 == sizeof (float))
+	return builtin_type_float;
+      return builtin_type_double;
+    }
+
+  /* If the upper bound is -1, it must really be an unsigned int.  */
+
+  else if (n2 == 0 && n3 == -1)
+    {
+      if (sizeof (int) == sizeof (long))
+	return builtin_type_unsigned_int;
+      else
+	return builtin_type_unsigned_long;
+    }
+
+  /* Detect unsigned subranges of int.  Int is normally 1.
+     Note that `char' is usually given bounds of 0 to 127,
+     and would therefore appear unsigned; but it is described
+     as a subrange of itself, so we reject it here.  */
+
+  else if (n2 == 0 && n1 == 1)
+    {
+      /* an unsigned type */
+      if (n3 == (1 << (8 * sizeof (int))) - 1)
+	return builtin_type_unsigned_int;
+      if (n3 == (1 << (8 * sizeof (short))) - 1)
+	return builtin_type_unsigned_short;
+      if (n3 == (1 << (8 * sizeof (char))) - 1)
+	return builtin_type_unsigned_char;
+    }
+  else
+    {
+      /* a signed type */
+      if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
+	return builtin_type_int;
+      if (n3 == (1 << (8 * sizeof (long) - 1)) - 1)
+	 return builtin_type_long;
+      if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
+	return builtin_type_short;
+      if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
+	return builtin_type_char;
+    }
+  error ("Invalid symbol data: range type spec %s at symtab pos %d.",
+	 errp - 1, symnum);
+}
+
+/* Read a number from the string pointed to by *PP.
+   The value of *PP is advanced over the number.
+   If END is nonzero, the character that ends the
+   number must match END, or an error happens;
+   and that character is skipped if it does match.
+   If END is zero, *PP is left pointing to that character.  */
+
+static long
+read_number (pp, end)
+     char **pp;
+     int end;
+{
+  register char *p = *pp;
+  register long n = 0;
+  register int c;
+  int sign = 1;
+
+  /* Handle an optional leading minus sign.  */
+
+  if (*p == '-')
+    {
+      sign = -1;
+      p++;
+    }
+
+  /* Read the digits, as far as they go.  */
+
+  while ((c = *p++) >= '0' && c <= '9')
+    {
+      n *= 10;
+      n += c - '0';
+    }
+  if (end)
+    {
+      if (c != end)
+	error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
+    }
+  else
+    --p;
+
+  *pp = p;
+  return n * sign;
+}
+
+static
+initialize ()
+{
+  symfile = 0;
+
+  add_com ("symbol-file", class_files, symbol_file_command,
+	   "Load symbol table (in dbx format) from executable file FILE.");
+}
+
+END_FILE
+
+#endif /* READ_DBX_FORMAT */
diff --git a/gdb/defs.h b/gdb/defs.h
new file mode 100644
index 0000000..b232972
--- /dev/null
+++ b/gdb/defs.h
@@ -0,0 +1,75 @@
+/* Basic definitions for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#define CORE_ADDR unsigned int
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+extern char *savestring ();
+extern char *concat ();
+extern char *xmalloc (), *xrealloc ();
+extern int parse_escape ();
+extern char *reg_names[];
+
+extern int quit_flag;
+
+extern int immediate_quit;
+
+#define QUIT { if (quit_flag) quit (); }
+
+enum command_class
+{
+  class_run, class_vars, class_stack, class_files, class_support, class_info,
+  class_breakpoint, class_alias, class_obscure, class_user,
+};
+
+/* the cleanup list records things that have to be undone
+   if an error happens (descriptors to be closed, memory to be freed, etc.)
+   Each link in the chain records a function to call and an
+   argument to give it.
+
+   Use make_cleanup to add an element to the cleanup chain.
+   Use do_cleanups to do all cleanup actions back to a given
+   point in the chain.  Use discard_cleanups to remove cleanups
+   from the chain back to a given point, not doing them.  */
+
+struct cleanup
+{
+  struct cleanup *next;
+  void (*function) ();
+  int arg;
+};
+
+extern void do_cleanups ();
+extern void discard_cleanups ();
+extern struct cleanup *make_cleanup ();
+extern void free_current_contents ();
+
+/* Structure for saved commands lines
+   (for breakpoints, defined commands, etc).  */
+
+struct command_line
+{
+  struct command_line *next;
+  char *line;
+};
+
+struct command_line *read_command_lines ();
diff --git a/gdb/environ.c b/gdb/environ.c
new file mode 100644
index 0000000..0b9f913
--- /dev/null
+++ b/gdb/environ.c
@@ -0,0 +1,250 @@
+/* environ.c -- library for manipulating environments for GNU.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+		       NO WARRANTY
+
+  BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+		GENERAL PUBLIC LICENSE TO COPY
+
+  1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of this
+    program or any part thereof, to be licensed at no charge to all
+    third parties on terms identical to those contained in this
+    License Agreement (except that you may choose to grant more
+    extensive warranty protection to third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of this program in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+In other words, feel free to share this program, but don't try to
+stop anyone else from sharing it.  */
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+#include "environ.h"
+
+/* Return a new environment object.  */
+
+struct environ *
+make_environ ()
+{
+  register struct environ *e;
+
+  e = (struct environ *) xmalloc (sizeof (struct environ));
+
+  e->allocated = 10;
+  e->vector = (char **) xmalloc ((e->allocated + 1) * sizeof (char *));
+  e->vector[0] = 0;
+  return e;
+}
+
+/* Free an environment and all the strings in it.  */
+
+void
+free_environ (e)
+     register struct environ *e;
+{
+  register char **vector = e->vector;
+
+  while (*vector)
+    free (*vector++);
+
+  free (e);
+}
+
+/* Copy the environment given to this process into E.
+   Also copies all the strings in it, so we can be sure
+   that all strings in these environments are safe to free.  */
+
+void
+init_environ (e)
+     register struct environ *e;
+{
+  extern char **environ;
+  register int i;
+
+  for (i = 0; environ[i]; i++);
+
+  if (e->allocated < i)
+    {
+      e->allocated = max (i, e->allocated + 10);
+      e->vector = (char **) xrealloc (e->vector,
+				      (e->allocated + 1) * sizeof (char *));
+    }
+
+  bcopy (environ, e->vector, (i + 1) * sizeof (char *));
+
+  while (--i >= 0)
+    {
+      register int len = strlen (e->vector[i]);
+      register char *new = (char *) xmalloc (len + 1);
+      bcopy (e->vector[i], new, len);
+      e->vector[i] = new;
+    }
+}
+
+/* Return the vector of environment E.
+   This is used to get something to pass to execve.  */
+
+char **
+environ_vector (e)
+     struct environ *e;
+{
+  return e->vector;
+}
+
+/* Return the value in environment E of variable VAR.  */
+
+char *
+get_in_environ (e, var)
+     struct environ *e;
+     char *var;
+{
+  register int len = strlen (var);
+  register char **vector = e->vector;
+  register char *s;
+
+  for (; s = *vector; vector++)
+    if (!strncmp (s, var, len)
+	&& s[len] == '=')
+      return &s[len + 1];
+
+  return 0;
+}
+
+/* Store the value in E of VAR as VALUE.  */
+
+void
+set_in_environ (e, var, value)
+     struct environ *e;
+     char *var;
+     char *value;
+{
+  register int i;
+  register int len = strlen (var);
+  register char **vector = e->vector;
+  register char *s;
+
+  for (i = 0; s = vector[i]; i++)
+    if (!strncmp (s, var, len)
+	&& s[len] == '=')
+      break;
+
+  if (s == 0)
+    {
+      if (i == e->allocated)
+	{
+	  e->allocated += 10;
+	  vector = (char **) xrealloc (vector,
+				       (e->allocated + 1) * sizeof (char *));
+	  e->vector = vector;
+	}
+      vector[i + 1] = 0;
+    }
+  else
+    free (s);
+
+  s = (char *) xmalloc (len + strlen (value) + 2);
+  strcpy (s, var);
+  strcat (s, "=");
+  strcat (s, value);
+  vector[i] = s;
+  return;
+}
+
+/* Remove the setting for variable VAR from environment E.  */
+
+void
+unset_in_environ (e, var)
+     struct environ *e;
+     char *var;
+{
+  register int len = strlen (var);
+  register char **vector = e->vector;
+  register char *s;
+
+  for (; s = *vector; vector++)
+    if (!strncmp (s, var, len)
+	&& s[len] == '=')
+      {
+	free (s);
+	bcopy (vector + 1, vector,
+	       (e->allocated - (vector - e->vector)) * sizeof (char *));
+	e->vector[e->allocated - 1] = 0;
+	return;
+      }
+}
diff --git a/gdb/environ.h b/gdb/environ.h
new file mode 100644
index 0000000..5ebeaa2
--- /dev/null
+++ b/gdb/environ.h
@@ -0,0 +1,23 @@
+
+/* We manipulate environments represented as these structures.  */
+
+struct environ
+{
+  /* Number of usable slots allocated in VECTOR.
+     VECTOR always has one slot not counted here,
+     to hold the terminating zero.  */
+  int allocated;
+  /* A vector of slots, ALLOCATED + 1 of them.
+     The first few slots contain strings "VAR=VALUE"
+     and the next one contains zero.
+     Then come some unused slots.  */
+  char **vector;
+};
+
+struct environ *make_environ ();
+void free_environ ();
+void init_environ ();
+char *get_in_environ ();
+void set_in_environ ();
+void unset_in_environ ();
+char **environ_vector ();
diff --git a/gdb/eval.c b/gdb/eval.c
new file mode 100644
index 0000000..97f39c3
--- /dev/null
+++ b/gdb/eval.c
@@ -0,0 +1,556 @@
+/* Evaluate expressions for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "value.h"
+#include "expression.h"
+
+START_FILE
+
+/* Parse the string EXP as a C expression, evaluate it,
+   and return the result as a number.  */
+
+CORE_ADDR
+parse_and_eval_address (exp)
+     char *exp;
+{
+  struct expression *expr = parse_c_expression (exp);
+  register CORE_ADDR addr;
+  register struct cleanup *old_chain
+    = make_cleanup (free_current_contents, &expr);
+
+  addr = value_as_long (evaluate_expression (expr));
+  do_cleanups (old_chain);
+  return addr;
+}
+
+/* Like parse_and_eval_address but takes a pointer to a char * variable
+   and advanced that variable across the characters parsed.  */
+
+CORE_ADDR
+parse_and_eval_address_1 (expptr)
+     char **expptr;
+{
+  struct expression *expr = parse_c_1 (expptr, 0);
+  register CORE_ADDR addr;
+  register struct cleanup *old_chain
+    = make_cleanup (free_current_contents, &expr);
+
+  addr = value_as_long (evaluate_expression (expr));
+  do_cleanups (old_chain);
+  return addr;
+}
+
+value
+parse_and_eval (exp)
+     char *exp;
+{
+  struct expression *expr = parse_c_expression (exp);
+  register value val;
+  register struct cleanup *old_chain
+    = make_cleanup (free_current_contents, &expr);
+
+  val = evaluate_expression (expr);
+  do_cleanups (old_chain);
+  return val;
+}
+
+/* Evaluate an expression in internal prefix form
+   such as is constructed by expread.y.
+
+   See expression.h for info on the format of an expression.  */
+
+static value evaluate_subexp ();
+static value evaluate_subexp_for_address ();
+static value evaluate_subexp_for_sizeof ();
+static value evaluate_subexp_with_coercion ();
+
+/* Values of NOSIDE argument to eval_subexp.  */
+enum noside
+{ EVAL_NORMAL, 
+  EVAL_SKIP,
+  EVAL_AVOID_SIDE_EFFECTS,
+};
+
+value
+evaluate_expression (exp)
+     struct expression *exp;
+{
+  int pc = 0;
+  return evaluate_subexp (exp, &pc, EVAL_NORMAL);
+}
+
+/* Evaluate an expression, avoiding all memory references
+   and getting a value whose type alone is correct.  */
+
+value
+evaluate_type (exp)
+     struct expression *exp;
+{
+  int pc = 0;
+  return evaluate_subexp (exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
+}
+
+static value
+evaluate_subexp (exp, pos, noside)
+     register struct expression *exp;
+     register int *pos;
+     enum noside noside;
+{
+  enum exp_opcode op;
+  int tem;
+  register int pc;
+  register value arg1, arg2;
+  int nargs;
+  value *argvec;
+
+  pc = (*pos)++;
+  op = exp->elts[pc].opcode;
+
+  switch (op)
+    {
+    case OP_LONG:
+      (*pos) += 3;
+      return value_from_long (exp->elts[pc + 1].type,
+			      exp->elts[pc + 2].longconst);
+
+    case OP_DOUBLE:
+      (*pos) += 3;
+      return value_from_double (exp->elts[pc + 1].type,
+				exp->elts[pc + 2].doubleconst);
+
+    case OP_VAR_VALUE:
+      (*pos) += 2;
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_of_variable (exp->elts[pc + 1].symbol);
+
+    case OP_LAST:
+      (*pos) += 2;
+      return access_value_history (exp->elts[pc + 1].longconst);
+
+    case OP_REGISTER:
+      (*pos) += 2;
+      return value_of_register (exp->elts[pc + 1].longconst);
+
+    case OP_INTERNALVAR:
+      (*pos) += 2;
+      return value_of_internalvar (exp->elts[pc + 1].internalvar);
+
+    case OP_FUNCALL:
+      (*pos) += 2;
+      nargs = exp->elts[pc + 1].longconst;
+      argvec = (value *) alloca (sizeof (value) * (nargs + 1));
+      for (tem = 0; tem <= nargs; tem++)
+
+	/* Ensure that array expressions are coerced into pointer objects. */
+	argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+	return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
+      return call_function (argvec[0], nargs, argvec + 1);
+
+    case OP_STRING:
+      tem = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_string (&exp->elts[pc + 1].string, tem);
+
+    case TERNOP_COND:
+      /* Skip third and second args to evaluate the first one.  */
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (value_zerop (arg1))
+	{
+	  evaluate_subexp (exp, pos, EVAL_SKIP);
+	  return evaluate_subexp (exp, pos, noside);
+	}
+      else
+	{
+	  arg2 = evaluate_subexp (exp, pos, noside);
+	  evaluate_subexp (exp, pos, EVAL_SKIP);
+	  return arg2;
+	}
+
+    case STRUCTOP_STRUCT:
+      tem = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_struct_elt (arg1, &exp->elts[pc + 1].string,
+			       "structure");
+
+    case STRUCTOP_PTR:
+      tem = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_struct_elt (arg1, &exp->elts[pc + 1].string,
+			       "structure pointer");
+
+    case BINOP_ASSIGN:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      return value_assign (arg1, arg2);
+
+    case BINOP_ASSIGN_MODIFY:
+      (*pos) += 2;
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      op = exp->elts[pc + 1].opcode;
+      if (op == BINOP_ADD)
+	arg2 = value_add (arg1, arg2);
+      else if (op == BINOP_SUB)
+	arg2 = value_sub (arg1, arg2);
+      else
+	arg2 = value_binop (arg1, arg2, op);
+      return value_assign (arg1, arg2);
+
+    case BINOP_ADD:
+      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_add (arg1, arg2);
+
+    case BINOP_SUB:
+      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_sub (arg1, arg2);
+
+    case BINOP_MUL:
+    case BINOP_DIV:
+    case BINOP_REM:
+    case BINOP_LSH:
+    case BINOP_RSH:
+    case BINOP_LOGAND:
+    case BINOP_LOGIOR:
+    case BINOP_LOGXOR:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_binop (arg1, arg2, op);
+
+    case BINOP_SUBSCRIPT:
+      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_subscript (arg1, arg2, op);
+      
+    case BINOP_AND:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      tem = value_zerop (arg1);
+      arg2 = evaluate_subexp (exp, pos,
+			      (tem ? EVAL_SKIP : noside));
+      return value_from_long (builtin_type_int,
+			      !tem && !value_zerop (arg2));
+
+    case BINOP_OR:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      tem = value_zerop (arg1);
+      arg2 = evaluate_subexp (exp, pos,
+			      (!tem ? EVAL_SKIP : noside));
+      return value_from_long (builtin_type_int,
+			      !tem || !value_zerop (arg2));
+
+    case BINOP_EQUAL:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_equal (arg1, arg2);
+      return value_from_long (builtin_type_int, tem);
+
+    case BINOP_NOTEQUAL:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_equal (arg1, arg2);
+      return value_from_long (builtin_type_int, ! tem);
+
+    case BINOP_LESS:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_less (arg1, arg2);
+      return value_from_long (builtin_type_int, tem);
+
+    case BINOP_GTR:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_less (arg2, arg1);
+      return value_from_long (builtin_type_int, tem);
+
+    case BINOP_GEQ:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_less (arg1, arg2);
+      return value_from_long (builtin_type_int, ! tem);
+
+    case BINOP_LEQ:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      tem = value_less (arg2, arg1);
+      return value_from_long (builtin_type_int, ! tem);
+
+    case BINOP_REPEAT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_repeat (arg1, value_as_long (arg2));
+
+    case BINOP_COMMA:
+      evaluate_subexp (exp, pos, noside);
+      return evaluate_subexp (exp, pos, noside);
+
+    case UNOP_NEG:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_neg (arg1);
+
+    case UNOP_LOGNOT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_lognot (arg1);
+
+    case UNOP_ZEROP:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_from_long (builtin_type_int, value_zerop (arg1));
+
+    case UNOP_IND:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_ind (arg1);
+
+    case UNOP_ADDR:
+      if (noside == EVAL_SKIP)
+	{
+	  evaluate_subexp (exp, pos, EVAL_SKIP);
+	  goto nosideret;
+	}
+      return evaluate_subexp_for_address (exp, pos, noside);
+
+    case UNOP_SIZEOF:
+      if (noside == EVAL_SKIP)
+	{
+	  evaluate_subexp (exp, pos, EVAL_SKIP);
+	  goto nosideret;
+	}
+      return evaluate_subexp_for_sizeof (exp, pos);
+
+    case UNOP_CAST:
+      (*pos) += 2;
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_cast (exp->elts[pc + 1].type, arg1);
+
+    case UNOP_MEMVAL:
+      (*pos) += 2;
+      arg1 = evaluate_subexp (exp, pos, noside);
+      if (noside == EVAL_SKIP)
+	goto nosideret;
+      return value_at (exp->elts[pc + 1].type, value_as_long (arg1));
+
+    case UNOP_PREINCREMENT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      return value_assign (arg1, arg2);
+
+    case UNOP_PREDECREMENT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      return value_assign (arg1, arg2);
+
+    case UNOP_POSTINCREMENT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      value_assign (arg1, arg2);
+      return arg1;
+
+    case UNOP_POSTDECREMENT:
+      arg1 = evaluate_subexp (exp, pos, noside);
+      arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
+      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+	return arg1;
+      value_assign (arg1, arg2);
+      return arg1;
+    }
+
+ nosideret:
+  return value_from_long (builtin_type_long, 1);
+}
+
+/* Evaluate a subexpression of EXP, at index *POS,
+   and return the address of that subexpression.
+   Advance *POS over the subexpression.
+   If the subexpression isn't an lvalue, get an error.
+   NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
+   then only the type of the result need be correct.  */
+
+static value
+evaluate_subexp_for_address (exp, pos, noside)
+     register struct expression *exp;
+     register int *pos;
+     enum noside noside;
+{
+  enum exp_opcode op;
+  register int pc;
+
+  pc = (*pos);
+  op = exp->elts[pc].opcode;
+
+  switch (op)
+    {
+    case UNOP_IND:
+      (*pos)++;
+      return evaluate_subexp (exp, pos, noside);
+
+    case UNOP_MEMVAL:
+      (*pos) += 3;
+      return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
+			 evaluate_subexp (exp, pos, noside));
+
+    case OP_VAR_VALUE:
+      (*pos) += 3;
+      return locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
+
+    default:
+      return value_addr (evaluate_subexp (exp, pos, noside));
+    }
+}
+
+/* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
+   When used in contexts where arrays will be coerced anyway,
+   this is equivalent to `evaluate_subexp'
+   but much faster because it avoids actually fetching array contents.  */
+
+static value
+evaluate_subexp_with_coercion (exp, pos, noside)
+     register struct expression *exp;
+     register int *pos;
+     enum noside noside;
+{
+  register enum exp_opcode op;
+  register int pc;
+  register value val;
+
+  pc = (*pos);
+  op = exp->elts[pc].opcode;
+
+  switch (op)
+    {
+    case OP_VAR_VALUE:
+      if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
+	{
+	  (*pos) += 3;
+	  val = locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
+	  return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp->elts[pc + 1].symbol))),
+			     val);
+	}
+    }
+
+  return evaluate_subexp (exp, pos, noside);
+}
+
+/* Evaluate a subexpression of EXP, at index *POS,
+   and return a value for the size of that subexpression.
+   Advance *POS over the subexpression.  */
+
+static value
+evaluate_subexp_for_sizeof (exp, pos)
+     register struct expression *exp;
+     register int *pos;
+{
+  enum exp_opcode op;
+  register int pc;
+  value val;
+
+  pc = (*pos);
+  op = exp->elts[pc].opcode;
+
+  switch (op)
+    {
+      /* This case is handled specially
+	 so that we avoid creating a value for the result type.
+	 If the result type is very big, it's desirable not to
+	 create a value unnecessarily.  */
+    case UNOP_IND:
+      (*pos)++;
+      val = evaluate_subexp (exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      return value_from_long (builtin_type_int,
+			      TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
+
+    case UNOP_MEMVAL:
+      (*pos) += 3;
+      return value_from_long (builtin_type_int,
+			      TYPE_LENGTH (exp->elts[pc + 1].type));
+
+    case OP_VAR_VALUE:
+      (*pos) += 3;
+      return value_from_long (builtin_type_int,
+			      TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
+
+    default:
+      val = evaluate_subexp (exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      return value_from_long (builtin_type_int,
+			      TYPE_LENGTH (VALUE_TYPE (val)));
+    }
+}
+
+static
+initialize ()
+{ }
+
+END_FILE
diff --git a/gdb/expprint.c b/gdb/expprint.c
new file mode 100644
index 0000000..36b31c6
--- /dev/null
+++ b/gdb/expprint.c
@@ -0,0 +1,304 @@
+/* Print in infix form a struct expression.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "symtab.h"
+#include "expression.h"
+
+#include <stdio.h>
+
+/* These codes indicate operator precedences, least tightly binding first.  */
+/* Adding 1 to a precedence value is done for binary operators,
+   on the operand which is more tightly bound, so that operators
+   of equal precedence within that operand will get parentheses.  */
+/* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
+   they are used as the "surrounding precedence" to force
+   various kinds of things to be parenthesized.  */
+enum precedence
+{ PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_OR, PREC_AND,
+  PREC_LOGIOR, PREC_LOGAND, PREC_LOGXOR, PREC_EQUAL, PREC_ORDER,
+  PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
+  PREC_HYPER, PREC_PREFIX, PREC_SUFFIX };
+
+/* Table mapping opcodes into strings for printing operators
+   and precedences of the operators.  */
+
+struct op_print
+{
+  char *string;
+  enum exp_opcode opcode;
+  /* Precedence of operator.  These values are used only by comparisons.  */
+  enum precedence precedence;
+  int right_assoc;
+};
+
+static struct op_print op_print_tab[] =
+  {
+    {",", BINOP_COMMA, PREC_COMMA, 0},
+    {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
+    {"||", BINOP_OR, PREC_OR, 0},
+    {"&&", BINOP_AND, PREC_AND, 0},
+    {"|", BINOP_LOGIOR, PREC_LOGIOR, 0},
+    {"&", BINOP_LOGAND, PREC_LOGAND, 0},
+    {"^", BINOP_LOGXOR, PREC_LOGXOR, 0},
+    {"==", BINOP_EQUAL, PREC_EQUAL, 0},
+    {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
+    {"<=", BINOP_LEQ, PREC_ORDER, 0},
+    {">=", BINOP_GEQ, PREC_ORDER, 0},
+    {">", BINOP_GTR, PREC_ORDER, 0},
+    {"<", BINOP_LESS, PREC_ORDER, 0},
+    {">>", BINOP_RSH, PREC_SHIFT, 0},
+    {"<<", BINOP_LSH, PREC_SHIFT, 0},
+    {"+", BINOP_ADD, PREC_ADD, 0},
+    {"-", BINOP_SUB, PREC_ADD, 0},
+    {"*", BINOP_MUL, PREC_MUL, 0},
+    {"/", BINOP_DIV, PREC_MUL, 0},
+    {"%", BINOP_REM, PREC_MUL, 0},
+    {"@", BINOP_REPEAT, PREC_REPEAT, 0},
+    {"-", UNOP_NEG, PREC_PREFIX, 0},
+    {"!", UNOP_ZEROP, PREC_PREFIX, 0},
+    {"~", UNOP_LOGNOT, PREC_PREFIX, 0},
+    {"*", UNOP_IND, PREC_PREFIX, 0},
+    {"&", UNOP_ADDR, PREC_PREFIX, 0},
+    {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
+    {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
+    {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}
+  };
+
+static void print_subexp ();
+
+void
+print_expression (exp, stream)
+     struct expression *exp;
+     FILE *stream;
+{
+  int pc = 0;
+  print_subexp (exp, &pc, stream, PREC_NULL);
+}
+
+/* Print the subexpression of EXP that starts in position POS, on STREAM.
+   PREC is the precedence of the surrounding operator;
+   if the precedence of the main operator of this subexpression is less,
+   parentheses are needed here.  */
+
+static void
+print_subexp (exp, pos, stream, prec)
+     register struct expression *exp;
+     register int *pos;
+     FILE *stream;
+     enum precedence prec;
+{
+  register int tem;
+  register int pc;
+  int nargs;
+  register char *op_str;
+  int assign_modify = 0;
+  enum exp_opcode opcode;
+  enum precedence myprec;
+  /* Set to 1 for a right-associative operator.  */
+  int assoc;
+
+  pc = (*pos)++;
+  opcode = exp->elts[pc].opcode;
+  switch (opcode)
+    {
+    case OP_LONG:
+      (*pos) += 3;
+      value_print (value_from_long (exp->elts[pc + 1].type,
+				    exp->elts[pc + 2].longconst),
+		   stream);
+      return;
+
+    case OP_DOUBLE:
+      (*pos) += 3;
+      value_print (value_from_double (exp->elts[pc + 1].type,
+				      exp->elts[pc + 2].doubleconst),
+		   stream);
+      return;
+
+    case OP_VAR_VALUE:
+      (*pos) += 2;
+      fprintf (stream, "%s", SYMBOL_NAME (exp->elts[pc + 1].symbol));
+      return;
+
+    case OP_LAST:
+      (*pos) += 2;
+      fprintf (stream, "$%d", exp->elts[pc + 1].longconst);
+      return;
+
+    case OP_REGISTER:
+      (*pos) += 2;
+      fprintf (stream, "$%s", reg_names[exp->elts[pc + 1].longconst]);
+      return;
+
+    case OP_INTERNALVAR:
+      (*pos) += 2;
+      fprintf (stream, "$%s",
+	       internalvar_name (exp->elts[pc + 1].internalvar));
+      return;
+
+    case OP_FUNCALL:
+      (*pos) += 2;
+      nargs = exp->elts[pc + 1].longconst;
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, " (");
+      for (tem = 0; tem < nargs; tem++)
+	{
+	  if (tem > 0)
+	    fprintf (stream, ", ");
+	  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
+	}
+      fprintf (stream, ")");
+      return;
+
+    case OP_STRING:
+      nargs = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (nargs + sizeof (union exp_element)) / sizeof (union exp_element);
+      fprintf (stream, "\"");
+      for (tem = 0; tem < nargs; tem++)
+	printchar ((&exp->elts[pc + 1].string)[tem], stream);
+      fprintf (stream, "\"");
+      return;
+
+    case TERNOP_COND:
+      if ((int) prec > (int) PREC_COMMA)
+	fprintf (stream, "(");
+      /* Print the subexpressions, forcing parentheses
+	 around any binary operations within them.
+	 This is more parentheses than are strictly necessary,
+	 but it looks clearer.  */
+      print_subexp (exp, pos, stream, PREC_HYPER);
+      fprintf (stream, " ? ");
+      print_subexp (exp, pos, stream, PREC_HYPER);
+      fprintf (stream, " : ");
+      print_subexp (exp, pos, stream, PREC_HYPER);
+      if ((int) prec > (int) PREC_COMMA)
+	fprintf (stream, ")");
+      return;
+
+    case STRUCTOP_STRUCT:
+      tem = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, ".%s", &exp->elts[pc + 1].string);
+      return;
+
+    case STRUCTOP_PTR:
+      tem = strlen (&exp->elts[pc + 1].string);
+      (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, "->%s", &exp->elts[pc + 1].string);
+      return;
+
+    case BINOP_SUBSCRIPT:
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, "[");
+      print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
+      fprintf (stream, "]");
+      return;
+
+    case UNOP_POSTINCREMENT:
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, "++");
+      return;
+
+    case UNOP_POSTDECREMENT:
+      print_subexp (exp, pos, stream, PREC_SUFFIX);
+      fprintf (stream, "--");
+      return;
+
+    case UNOP_CAST:
+      (*pos) += 2;
+      if ((int) prec > (int) PREC_PREFIX)
+	fprintf (stream, "(");
+      fprintf (stream, "(");
+      type_print (exp->elts[pc + 1].type, "", stream, 0);
+      fprintf (stream, ") ");
+      print_subexp (exp, pos, stream, PREC_PREFIX);
+      if ((int) prec > (int) PREC_PREFIX)
+	fprintf (stream, ")");
+      return;
+
+    case UNOP_MEMVAL:
+      (*pos) += 2;
+      if ((int) prec > (int) PREC_PREFIX)
+	fprintf (stream, "(");
+      fprintf (stream, "{");
+      type_print (exp->elts[pc + 1].type, "", stream, 0);
+      fprintf (stream, "} ");
+      print_subexp (exp, pos, stream, PREC_PREFIX);
+      if ((int) prec > (int) PREC_PREFIX)
+	fprintf (stream, ")");
+      return;
+
+    case BINOP_ASSIGN_MODIFY:
+      opcode = exp->elts[pc + 1].opcode;
+      (*pos) += 2;
+      myprec = PREC_ASSIGN;
+      assoc = 1;
+      assign_modify = 1;
+      for (tem = 0; tem < sizeof op_print_tab / sizeof op_print_tab[0]; tem++)
+	if (op_print_tab[tem].opcode == opcode)
+	  {
+	    op_str = op_print_tab[tem].string;
+	    break;
+	  }
+
+    default:
+      for (tem = 0; tem < sizeof op_print_tab / sizeof op_print_tab[0]; tem++)
+	if (op_print_tab[tem].opcode == opcode)
+	  {
+	    op_str = op_print_tab[tem].string;
+	    myprec = op_print_tab[tem].precedence;
+	    assoc = op_print_tab[tem].right_assoc;
+	    break;
+	  }
+    }
+
+  if ((int) myprec < (int) prec)
+    fprintf (stream, "(");
+  if ((int) opcode > (int) BINOP_END)
+    {
+      /* Unary prefix operator.  */
+      fprintf (stream, "%s", op_str);
+      print_subexp (exp, pos, stream, PREC_PREFIX);
+    }
+  else
+    {
+      /* Binary operator.  */
+      /* Print left operand.
+	 If operator is right-associative,
+	 increment precedence for this operand.  */
+      print_subexp (exp, pos, stream, (int) myprec + assoc);
+      /* Print the operator itself.  */
+      if (assign_modify)
+	fprintf (stream, " %s= ", op_str);
+      else if (op_str[0] == ',')
+	fprintf (stream, "%s ", op_str);
+      else
+	fprintf (stream, " %s ", op_str);
+      /* Print right operand.
+	 If operator is left-associative,
+	 increment precedence for this operand.  */
+      print_subexp (exp, pos, stream, (int) myprec + !assoc);
+    }
+  if ((int) myprec < (int) prec)
+    fprintf (stream, ")");
+}
diff --git a/gdb/expread.y b/gdb/expread.y
new file mode 100644
index 0000000..468d409
--- /dev/null
+++ b/gdb/expread.y
@@ -0,0 +1,1189 @@
+/* Parse C expressions for GDB.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Parse a C expression from text in a string,
+   and return the result as a  struct expression  pointer.
+   That structure contains arithmetic operations in reverse polish,
+   with constants represented by operations that are followed by special data.
+   See expression.h for the details of the format.
+   What is important here is that it can be built up sequentially
+   during the process of parsing; the lower levels of the tree always
+   come first in the result.  */
+   
+%{
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+#include "expression.h"
+
+#include <stdio.h>
+
+static struct expression *expout;
+static int expout_size;
+static int expout_ptr;
+
+static int yylex ();
+static yyerror ();
+static void write_exp_elt ();
+static void write_exp_string ();
+static void start_arglist ();
+static int end_arglist ();
+static void free_funcalls ();
+static char *copy_name ();
+
+/* If this is nonzero, this block is used as the lexical context
+   for symbol names.  */
+
+static struct block *expression_context_block;
+
+/* Number of arguments seen so far in innermost function call.  */
+static int arglist_len;
+
+/* Data structure for saving values of arglist_len
+   for function calls whose arguments contain other function calls.  */
+
+struct funcall
+  {
+    struct funcall *next;
+    int arglist_len;
+  };
+
+struct funcall *funcall_chain;
+
+/* This kind of datum is used to represent the name
+   of a symbol token.  */
+
+struct stoken
+  {
+    char *ptr;
+    int length;
+  };
+%}
+
+/* Although the yacc "value" of an expression is not used,
+   since the result is stored in the structure being created,
+   other node types do have values.  */
+
+%union
+  {
+    long lval;
+    double dval;
+    struct symbol *sym;
+    struct type *tval;
+    struct stoken sval;
+    int voidval;
+    struct block *bval;
+    enum exp_opcode opcode;
+    struct internalvar *ivar;
+  }
+
+%type <voidval> exp exp1 start variable
+%type <tval> type typebase
+%type <bval> block
+
+%token <lval> INT CHAR
+%token <dval> FLOAT
+
+/* Both NAME and TYPENAME tokens represent symbols in the input,
+   and both convey their data as strings.
+   But a TYPENAME is a string that happens to be defined as a typedef
+   or builtin type name (such as int or char)
+   and a NAME is any other symbol.
+
+   Contexts where this distinction is not important can use the
+   nonterminal "name", which matches either NAME or TYPENAME.  */
+
+%token <sval> NAME TYPENAME STRING
+%type <sval> name
+
+%token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
+
+%token <lval> LAST REGNAME
+
+%token <ivar> VARIABLE
+
+%token <opcode> ASSIGN_MODIFY
+
+%left ','
+%left ABOVE_COMMA
+%right '=' ASSIGN_MODIFY
+%left OR
+%left AND
+%left '|'
+%left '^'
+%left '&'
+%left EQUAL NOTEQUAL
+%left '<' '>' LEQ GEQ
+%left LSH RSH
+%left '+' '-'
+%left '*' '/' '%'
+%left '@'
+%right UNARY INCREMENT DECREMENT
+%right ARROW '.' '['
+%left COLONCOLON
+
+%%
+
+start   :	exp1
+	;
+
+/* Expressions, including the comma operator.  */
+exp1	:	exp
+	|	exp1 ',' exp
+			{ write_exp_elt (BINOP_COMMA); }
+	;
+
+/* Expressions, not including the comma operator.  */
+exp	:	'*' exp    %prec UNARY
+			{ write_exp_elt (UNOP_IND); }
+
+exp	:	'&' exp    %prec UNARY
+			{ write_exp_elt (UNOP_ADDR); }
+
+exp	:	'-' exp    %prec UNARY
+			{ write_exp_elt (UNOP_NEG); }
+	;
+
+exp	:	'!' exp    %prec UNARY
+			{ write_exp_elt (UNOP_ZEROP); }
+	;
+
+exp	:	'~' exp    %prec UNARY
+			{ write_exp_elt (UNOP_LOGNOT); }
+	;
+
+exp	:	INCREMENT exp    %prec UNARY
+			{ write_exp_elt (UNOP_PREINCREMENT); }
+	;
+
+exp	:	DECREMENT exp    %prec UNARY
+			{ write_exp_elt (UNOP_PREDECREMENT); }
+	;
+
+exp	:	exp INCREMENT    %prec UNARY
+			{ write_exp_elt (UNOP_POSTINCREMENT); }
+	;
+
+exp	:	exp DECREMENT    %prec UNARY
+			{ write_exp_elt (UNOP_POSTDECREMENT); }
+	;
+
+exp	:	SIZEOF exp       %prec UNARY
+			{ write_exp_elt (UNOP_SIZEOF); }
+	;
+
+exp	:	exp ARROW name
+			{ write_exp_elt (STRUCTOP_PTR);
+			  write_exp_string ($3);
+			  write_exp_elt (STRUCTOP_PTR); }
+	;
+
+exp	:	exp '.' name
+			{ write_exp_elt (STRUCTOP_STRUCT);
+			  write_exp_string ($3);
+			  write_exp_elt (STRUCTOP_STRUCT); }
+	;
+
+exp	:	exp '[' exp1 ']'
+			{ write_exp_elt (BINOP_SUBSCRIPT); }
+	;
+
+exp	:	exp '(' 
+			/* This is to save the value of arglist_len
+			   being accumulated by an outer function call.  */
+			{ start_arglist (); }
+		arglist ')'
+			{ write_exp_elt (OP_FUNCALL);
+			  write_exp_elt (end_arglist ());
+			  write_exp_elt (OP_FUNCALL); }
+	;
+
+arglist	:
+	;
+
+arglist	:	exp
+			{ arglist_len = 1; }
+	;
+
+arglist	:	arglist ',' exp   %prec ABOVE_COMMA
+			{ arglist_len++; }
+	;
+
+exp	:	'{' type '}' exp  %prec UNARY
+			{ write_exp_elt (UNOP_MEMVAL);
+			  write_exp_elt ($2);
+			  write_exp_elt (UNOP_MEMVAL); }
+	;
+
+exp	:	'(' type ')' exp  %prec UNARY
+			{ write_exp_elt (UNOP_CAST);
+			  write_exp_elt ($2);
+			  write_exp_elt (UNOP_CAST); }
+	;
+
+exp	:	'(' exp1 ')'
+			{ }
+	;
+
+/* Binary operators in order of decreasing precedence.  */
+
+exp	:	exp '@' exp
+			{ write_exp_elt (BINOP_REPEAT); }
+	;
+
+exp	:	exp '*' exp
+			{ write_exp_elt (BINOP_MUL); }
+	;
+
+exp	:	exp '/' exp
+			{ write_exp_elt (BINOP_DIV); }
+	;
+
+exp	:	exp '%' exp
+			{ write_exp_elt (BINOP_REM); }
+	;
+
+exp	:	exp '+' exp
+			{ write_exp_elt (BINOP_ADD); }
+	;
+
+exp	:	exp '-' exp
+			{ write_exp_elt (BINOP_SUB); }
+	;
+
+exp	:	exp LSH exp
+			{ write_exp_elt (BINOP_LSH); }
+	;
+
+exp	:	exp RSH exp
+			{ write_exp_elt (BINOP_RSH); }
+	;
+
+exp	:	exp EQUAL exp
+			{ write_exp_elt (BINOP_EQUAL); }
+	;
+
+exp	:	exp NOTEQUAL exp
+			{ write_exp_elt (BINOP_NOTEQUAL); }
+	;
+
+exp	:	exp LEQ exp
+			{ write_exp_elt (BINOP_LEQ); }
+	;
+
+exp	:	exp GEQ exp
+			{ write_exp_elt (BINOP_GEQ); }
+	;
+
+exp	:	exp '<' exp
+			{ write_exp_elt (BINOP_LESS); }
+	;
+
+exp	:	exp '>' exp
+			{ write_exp_elt (BINOP_GTR); }
+	;
+
+exp	:	exp '&' exp
+			{ write_exp_elt (BINOP_LOGAND); }
+	;
+
+exp	:	exp '^' exp
+			{ write_exp_elt (BINOP_LOGXOR); }
+	;
+
+exp	:	exp '|' exp
+			{ write_exp_elt (BINOP_LOGIOR); }
+	;
+
+exp	:	exp AND exp
+			{ write_exp_elt (BINOP_AND); }
+	;
+
+exp	:	exp OR exp
+			{ write_exp_elt (BINOP_OR); }
+	;
+
+exp	:	exp '?' exp ':' exp
+			{ write_exp_elt (TERNOP_COND); }
+	;
+			  
+exp	:	exp '=' exp
+			{ write_exp_elt (BINOP_ASSIGN); }
+	;
+
+exp	:	exp ASSIGN_MODIFY exp
+			{ write_exp_elt (BINOP_ASSIGN_MODIFY);
+			  write_exp_elt ($2);
+			  write_exp_elt (BINOP_ASSIGN_MODIFY); }
+	;
+
+exp	:	INT
+			{ write_exp_elt (OP_LONG);
+			  write_exp_elt (builtin_type_long);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_LONG); }
+	;
+
+exp	:	CHAR
+			{ write_exp_elt (OP_LONG);
+			  write_exp_elt (builtin_type_char);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_LONG); }
+	;
+
+exp	:	FLOAT
+			{ write_exp_elt (OP_DOUBLE);
+			  write_exp_elt (builtin_type_double);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_DOUBLE); }
+	;
+
+exp	:	variable
+	;
+
+exp	:	LAST
+			{ write_exp_elt (OP_LAST);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_LAST); }
+	;
+
+exp	:	REGNAME
+			{ write_exp_elt (OP_REGISTER);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_REGISTER); }
+	;
+
+exp	:	VARIABLE
+			{ write_exp_elt (OP_INTERNALVAR);
+			  write_exp_elt ($1);
+			  write_exp_elt (OP_INTERNALVAR); }
+	;
+
+exp	:	SIZEOF '(' type ')'
+			{ write_exp_elt (OP_LONG);
+			  write_exp_elt (builtin_type_int);
+			  write_exp_elt ((long) TYPE_LENGTH ($3));
+			  write_exp_elt (OP_LONG); }
+	;
+
+exp	:	STRING
+			{ write_exp_elt (OP_STRING);
+			  write_exp_string ($1);
+			  write_exp_elt (OP_STRING); }
+	;
+
+block	:	name
+			{ struct symtab *tem = lookup_symtab (copy_name ($1));
+			  struct symbol *sym;
+			  
+			  if (tem)
+			    $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
+			  else
+			    {
+			      sym = lookup_symbol (copy_name ($1),
+						   expression_context_block,
+						   VAR_NAMESPACE);
+			      if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+				$$ = SYMBOL_BLOCK_VALUE (sym);
+			      else
+				error ("No file or function \"%s\".",
+				       copy_name ($1));
+			    }}
+	;
+
+block	:	block COLONCOLON name
+			{ struct symbol *tem
+			    = lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
+			  if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
+			    error ("No function \"%s\" in specified context.",
+				   copy_name ($3));
+			  $$ = SYMBOL_BLOCK_VALUE (tem); }
+	;
+
+variable:	block COLONCOLON name
+			{ struct symbol *sym;
+			  sym = lookup_symbol ($3, copy_name ($1), VAR_NAMESPACE);
+			  if (sym == 0)
+			    error ("No symbol \"%s\" in specified context.",
+				   copy_name ($3));
+			  write_exp_elt (OP_VAR_VALUE);
+			  write_exp_elt (sym);
+			  write_exp_elt (OP_VAR_VALUE); }
+	;
+
+variable:	NAME
+			{ struct symbol *sym;
+			  sym = lookup_symbol (copy_name ($1),
+					      expression_context_block,
+					      VAR_NAMESPACE);
+			  if (sym)
+			    {
+			      write_exp_elt (OP_VAR_VALUE);
+			      write_exp_elt (sym);
+			      write_exp_elt (OP_VAR_VALUE);
+			    }
+			  else
+			    {
+			      register char *arg = copy_name ($1);
+			      register int i;
+			      for (i = 0; i < misc_function_count; i++)
+				if (!strcmp (misc_function_vector[i].name, arg))
+				  break;
+
+			      if (i < misc_function_count)
+				{
+				  write_exp_elt (OP_LONG);
+				  write_exp_elt (builtin_type_int);
+				  write_exp_elt (misc_function_vector[i].address);
+				  write_exp_elt (OP_LONG);
+				  write_exp_elt (UNOP_MEMVAL);
+				  write_exp_elt (builtin_type_char);
+				  write_exp_elt (UNOP_MEMVAL);
+				}
+			      else
+				if (symtab_list == 0)
+				  error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+				else
+				  error ("No symbol \"%s\" in current context.",
+					 copy_name ($1));
+			    }
+			}
+	;
+
+type	:	typebase
+	|	type '*'
+			{ $$ = lookup_pointer_type ($1); }
+	;
+
+typebase
+	:	TYPENAME
+			{ $$ = lookup_typename (copy_name ($1),
+						expression_context_block, 0); }
+	|	STRUCT name
+			{ $$ = lookup_struct (copy_name ($2),
+					      expression_context_block); }
+	|	UNION name
+			{ $$ = lookup_union (copy_name ($2),
+					     expression_context_block); }
+	|	ENUM name
+			{ $$ = lookup_enum (copy_name ($2),
+					    expression_context_block); }
+	|	UNSIGNED name
+			{ $$ = lookup_unsigned_typename (copy_name ($2)); }
+	;
+
+name	:	NAME
+	|	TYPENAME
+	;
+%%
+
+/* Begin counting arguments for a function call,
+   saving the data about any containing call.  */
+
+static void
+start_arglist ()
+{
+  register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
+
+  new->next = funcall_chain;
+  new->arglist_len = arglist_len;
+  arglist_len = 0;
+  funcall_chain = new;
+}
+
+/* Return the number of arguments in a function call just terminated,
+   and restore the data for the containing function call.  */
+
+static int
+end_arglist ()
+{
+  register int val = arglist_len;
+  register struct funcall *call = funcall_chain;
+  funcall_chain = call->next;
+  arglist_len = call->arglist_len;
+  free (call);
+  return val;
+}
+
+/* Free everything in the funcall chain.
+   Used when there is an error inside parsing.  */
+
+static void
+free_funcalls ()
+{
+  register struct funcall *call, *next;
+
+  for (call = funcall_chain; call; call = next)
+    {
+      next = call->next;
+      free (call);
+    }
+}
+
+/* This page contains the functions for adding data to the  struct expression
+   being constructed.  */
+
+/* Add one element to the end of the expression.  */
+
+static void
+write_exp_elt (expelt)
+     union exp_element expelt;
+{
+  if (expout_ptr >= expout_size)
+    {
+      expout_size *= 2;
+      expout = (struct expression *) xrealloc (expout,
+					       sizeof (struct expression)
+					       + expout_size * sizeof (union exp_element));
+    }
+  expout->elts[expout_ptr++] = expelt;
+}
+
+/* Add a string constant to the end of the expression.
+   Follow it by its length in bytes, as a separate exp_element.  */
+
+static void
+write_exp_string (str)
+     struct stoken str;
+{
+  register int len = str.length;
+  register int lenelt
+    = (len + sizeof (union exp_element)) / sizeof (union exp_element);
+
+  expout_ptr += lenelt;
+
+  if (expout_ptr >= expout_size)
+    {
+      expout_size = max (expout_size * 2, expout_ptr + 10);
+      expout = (struct expression *) xrealloc (expout,
+					       sizeof (struct expression)
+					       + expout_size * sizeof (union exp_element));
+    }
+  bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
+  ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
+  write_exp_elt (len);
+}
+
+/* During parsing of a C expression, the pointer to the next character
+   is in this variable.  */
+
+static char *lexptr;
+
+/* Tokens that refer to names do so with explicit pointer and length,
+   so they can share the storage that lexptr is parsing.
+
+   When it is necessary to pass a name to a function that expects
+   a null-terminated string, the substring is copied out
+   into a block of storage that namecopy points to.
+
+   namecopy is allocated once, guaranteed big enough, for each parsing.  */
+
+static char *namecopy;
+
+/* Take care of parsing a number (anything that starts with a digit).
+   Set yylval and return the token type; update lexptr.
+   LEN is the number of characters in it.  */
+
+/*** Needs some error checking for the float case ***/
+
+static int
+parse_number (olen)
+     int olen;
+{
+  register char *p = lexptr;
+  register long n = 0;
+  register int c;
+  register int base = 10;
+  register int len = olen;
+  char *err_copy;
+
+  extern double atof ();
+
+  for (c = 0; c < len; c++)
+    if (p[c] == '.')
+      {
+	/* It's a float since it contains a point.  */
+	yylval.dval = atof (p);
+	lexptr += len;
+	return FLOAT;
+      }
+
+  if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2)))
+    {
+      p += 2;
+      base = 16;
+      len -= 2;
+    }
+  else if (*p == '0')
+    base = 8;
+
+  while (len-- > 0)
+    {
+      c = *p++;
+      n *= base;
+      if (c >= '0' && c <= '9')
+	n += c - '0';
+      else
+	{
+	  if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
+	  if (base == 16 && c >= 'a' && c <= 'f')
+	    n += c - 'a' + 10;
+	  else if (len == 0 && c == 'l')
+	    ;
+	  else
+	    {
+	      err_copy = (char *) alloca (olen + 1);
+	      bcopy (lexptr, err_copy, olen);
+	      err_copy[olen] = 0;
+	      error ("Invalid number \"%s\".", err_copy);
+	    }
+	}
+    }
+
+  lexptr = p;
+  yylval.lval = n;
+  return INT;
+}
+
+struct token
+{
+  char *operator;
+  int token;
+  enum exp_opcode opcode;
+};
+
+static struct token tokentab3[] =
+  {
+    {">>=", ASSIGN_MODIFY, BINOP_RSH},
+    {"<<=", ASSIGN_MODIFY, BINOP_LSH}
+  };
+
+static struct token tokentab2[] =
+  {
+    {"+=", ASSIGN_MODIFY, BINOP_ADD},
+    {"-=", ASSIGN_MODIFY, BINOP_SUB},
+    {"*=", ASSIGN_MODIFY, BINOP_MUL},
+    {"/=", ASSIGN_MODIFY, BINOP_DIV},
+    {"%=", ASSIGN_MODIFY, BINOP_REM},
+    {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
+    {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
+    {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
+    {"++", INCREMENT, BINOP_END},
+    {"--", DECREMENT, BINOP_END},
+    {"->", ARROW, BINOP_END},
+    {"&&", AND, BINOP_END},
+    {"||", OR, BINOP_END},
+    {"::", COLONCOLON, BINOP_END},
+    {"<<", LSH, BINOP_END},
+    {">>", RSH, BINOP_END},
+    {"==", EQUAL, BINOP_END},
+    {"!=", NOTEQUAL, BINOP_END},
+    {"<=", LEQ, BINOP_END},
+    {">=", GEQ, BINOP_END}
+  };
+
+/* Read one token, getting characters through lexptr.  */
+
+static int
+yylex ()
+{
+  register int c;
+  register int namelen;
+  register int i;
+  register char *tokstart;
+
+ retry:
+
+  tokstart = lexptr;
+  /* See if it is a special token of length 3.  */
+  for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
+    if (!strncmp (tokstart, tokentab3[i].operator, 3))
+      {
+	lexptr += 3;
+	yylval.opcode = tokentab3[i].opcode;
+	return tokentab3[i].token;
+      }
+
+  /* See if it is a special token of length 2.  */
+  for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
+    if (!strncmp (tokstart, tokentab2[i].operator, 2))
+      {
+	lexptr += 2;
+	yylval.opcode = tokentab2[i].opcode;
+	return tokentab2[i].token;
+      }
+
+  switch (c = *tokstart)
+    {
+    case 0:
+      return 0;
+
+    case ' ':
+    case '\t':
+    case '\n':
+      lexptr++;
+      goto retry;
+
+    case '\'':
+      lexptr++;
+      c = *lexptr++;
+      if (c == '\\')
+	c = parse_escape (&lexptr);
+      yylval.lval = c;
+      c = *lexptr++;
+      if (c != '\'')
+	error ("Invalid character constant.");
+      return CHAR;
+
+    case '+':
+    case '-':
+    case '*':
+    case '/':
+    case '%':
+    case '|':
+    case '&':
+    case '^':
+    case '~':
+    case '!':
+    case '@':
+    case '<':
+    case '>':
+    case '(':
+    case ')':
+    case '[':
+    case ']':
+    case '.':
+    case '?':
+    case ':':
+    case '=':
+    case '{':
+    case '}':
+    case ',':
+      lexptr++;
+      return c;
+
+    case '"':
+      for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
+	if (c == '\\')
+	  {
+	    c = tokstart[++namelen];
+	    if (c >= '0' && c <= '9')
+	      {
+		c = tokstart[++namelen];
+		if (c >= '0' && c <= '9')
+		  c = tokstart[++namelen];
+	      }
+	  }
+      yylval.sval.ptr = tokstart + 1;
+      yylval.sval.length = namelen - 1;
+      lexptr += namelen + 1;
+      return STRING;
+    }
+  if (c >= '0' && c <= '9')
+    {
+      /* It's a number */
+      for (namelen = 0;
+	   c = tokstart[namelen],
+	   (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
+	    || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
+	   namelen++)
+	;
+      return parse_number (namelen);
+    }
+
+  if (!(c == '_' || c == '$'
+	|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
+    error ("Invalid token in expression.");
+
+  /* It is a name.  See how long it is.  */
+
+  for (namelen = 0;
+       c = tokstart[namelen],
+       (c == '_' || c == '$' || (c >= '0' && c <= '9')
+	|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
+       namelen++)
+    ;
+
+  /* The token "if" terminates the expression and is NOT 
+     removed from the input stream.  */
+  if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
+    {
+      return 0;
+    }
+
+  lexptr += namelen;
+
+  /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
+     and $$digits (equivalent to $<-digits> if you could type that).
+     Make token type LAST, and put the number (the digits) in yylval.  */
+
+  if (*tokstart == '$')
+    {
+      register int negate = 0;
+      c = 1;
+      /* Double dollar means negate the number and add -1 as well.
+	 Thus $$ alone means -1.  */
+      if (namelen >= 2 && tokstart[1] == '$')
+	{
+	  negate = 1;
+	  c = 2;
+	}
+      if (c == namelen)
+	{
+	  /* Just dollars (one or two) */
+	  yylval.lval = - negate;
+	  return LAST;
+	}
+      /* Is the rest of the token digits?  */
+      for (; c < namelen; c++)
+	if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
+	  break;
+      if (c == namelen)
+	{
+	  yylval.lval = atoi (tokstart + 1 + negate);
+	  if (negate)
+	    yylval.lval = - yylval.lval;
+	  return LAST;
+	}
+    }
+
+  /* Handle tokens that refer to machine registers:
+     $ followed by a register name.  */
+
+  if (*tokstart == '$')
+    for (c = 0; c < NUM_REGS; c++)
+      if (namelen - 1 == strlen (reg_names[c])
+	  && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
+	{
+	  yylval.lval = c;
+	  return REGNAME;
+	}
+
+  if (namelen == 6 && !strncmp (tokstart, "struct", 6))
+    {
+      return STRUCT;
+    }
+  if (namelen == 5 && !strncmp (tokstart, "union", 5))
+    {
+      return UNION;
+    }
+  if (namelen == 4 && !strncmp (tokstart, "enum", 4))
+    {
+      return ENUM;
+    }
+  if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
+    {
+      return SIZEOF;
+    }
+  if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
+    {
+      return UNSIGNED;
+    }
+  yylval.sval.ptr = tokstart;
+  yylval.sval.length = namelen;
+
+  /* Any other names starting in $ are debugger internal variables.  */
+
+  if (*tokstart == '$')
+    {
+      yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
+      return VARIABLE;
+    }
+
+  /* Use token-type TYPENAME for symbols that happen to be defined
+     currently as names of types; NAME for other symbols.
+     The caller is not constrained to care about the distinction.  */
+  if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
+    return TYPENAME;
+  return NAME;
+}
+
+static
+yyerror ()
+{
+  error ("Invalid syntax in expression.");
+}
+
+/* Return a null-terminated temporary copy of the name
+   of a string token.  */
+
+static char *
+copy_name (token)
+     struct stoken token;
+{
+  bcopy (token.ptr, namecopy, token.length);
+  namecopy[token.length] = 0;
+  return namecopy;
+}
+
+/* Reverse an expression from suffix form (in which it is constructed)
+   to prefix form (in which we can conveniently print or execute it).  */
+
+static void prefixify_subexp ();
+
+static void
+prefixify_expression (expr)
+     register struct expression *expr;
+{
+  register int len = sizeof (struct expression) +
+				    expr->nelts * sizeof (union exp_element);
+  register struct expression *temp;
+  register int inpos = expr->nelts, outpos = 0;
+
+  temp = (struct expression *) alloca (len);
+
+  /* Copy the original expression into temp.  */
+  bcopy (expr, temp, len);
+
+  prefixify_subexp (temp, expr, inpos, outpos);
+}
+
+/* Return the number of exp_elements in the subexpression of EXPR
+   whose last exp_element is at index ENDPOS - 1 in EXPR.  */
+
+static int
+length_of_subexp (expr, endpos)
+     register struct expression *expr;
+     register int endpos;
+{
+  register int oplen = 1;
+  register int args = 0;
+  register int i;
+
+  i = (int) expr->elts[endpos - 1].opcode;
+
+  switch (i)
+    {
+    case OP_LONG:
+    case OP_DOUBLE:
+      oplen = 4;
+      break;
+
+    case OP_VAR_VALUE:
+    case OP_LAST:
+    case OP_REGISTER:
+    case OP_INTERNALVAR:
+      oplen = 3;
+      break;
+
+    case OP_FUNCALL:
+      oplen = 3;
+      args = 1 + expr->elts[endpos - 2].longconst;
+      break;
+
+    case UNOP_CAST:
+    case UNOP_MEMVAL:
+      oplen = 3;
+      args = 1;
+      break;
+
+    case STRUCTOP_STRUCT:
+    case STRUCTOP_PTR:
+      args = 1;
+    case OP_STRING:
+      oplen = 3 + ((expr->elts[endpos - 2].longconst
+		    + sizeof (union exp_element))
+		   / sizeof (union exp_element));
+		   
+      break;
+
+    case TERNOP_COND:
+      args = 3;
+      break;
+
+    case BINOP_ASSIGN_MODIFY:
+      oplen = 3;
+      args = 2;
+      break;
+
+    default:
+      args = 1 + (i < (int) BINOP_END);
+    }
+
+  while (args > 0)
+    {
+      oplen += length_of_subexp (expr, endpos - oplen);
+      args--;
+    }
+
+  return oplen;
+}
+
+/* Copy the subexpression ending just before index INEND in INEXPR
+   into OUTEXPR, starting at index OUTBEG.
+   In the process, convert it from suffix to prefix form.  */
+
+static void
+prefixify_subexp (inexpr, outexpr, inend, outbeg)
+     register struct expression *inexpr;
+     struct expression *outexpr;
+     register int inend;
+     int outbeg;
+{
+  register int oplen = 1;
+  register int args = 0;
+  register int i;
+  int *arglens;
+  enum exp_opcode opcode;
+
+  /* Compute how long the last operation is (in OPLEN),
+     and also how many preceding subexpressions serve as
+     arguments for it (in ARGS).  */
+
+  opcode = inexpr->elts[inend - 1].opcode;
+  switch (opcode)
+    {
+    case OP_LONG:
+    case OP_DOUBLE:
+      oplen = 4;
+      break;
+
+    case OP_VAR_VALUE:
+    case OP_LAST:
+    case OP_REGISTER:
+    case OP_INTERNALVAR:
+      oplen = 3;
+      break;
+
+    case OP_FUNCALL:
+      oplen = 3;
+      args = 1 + inexpr->elts[inend - 2].longconst;
+      break;
+
+    case UNOP_CAST:
+    case UNOP_MEMVAL:
+      oplen = 3;
+      args = 1;
+      break;
+
+    case STRUCTOP_STRUCT:
+    case STRUCTOP_PTR:
+      args = 1;
+    case OP_STRING:
+      oplen = 3 + ((inexpr->elts[inend - 2].longconst
+		    + sizeof (union exp_element))
+		   / sizeof (union exp_element));
+		   
+      break;
+
+    case TERNOP_COND:
+      args = 3;
+      break;
+
+    case BINOP_ASSIGN_MODIFY:
+      oplen = 3;
+      args = 2;
+      break;
+
+    default:
+      args = 1 + ((int) opcode < (int) BINOP_END);
+    }
+
+  /* Copy the final operator itself, from the end of the input
+     to the beginning of the output.  */
+  inend -= oplen;
+  bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
+	 oplen * sizeof (union exp_element));
+  outbeg += oplen;
+
+  /* Find the lengths of the arg subexpressions.  */
+  arglens = (int *) alloca (args * sizeof (int));
+  for (i = args - 1; i >= 0; i--)
+    {
+      oplen = length_of_subexp (inexpr, inend);
+      arglens[i] = oplen;
+      inend -= oplen;
+    }
+
+  /* Now copy each subexpression, preserving the order of
+     the subexpressions, but prefixifying each one.
+     In this loop, inend starts at the beginning of
+     the expression this level is working on
+     and marches forward over the arguments.
+     outbeg does similarly in the output.  */
+  for (i = 0; i < args; i++)
+    {
+      oplen = arglens[i];
+      inend += oplen;
+      prefixify_subexp (inexpr, outexpr, inend, outbeg);
+      outbeg += oplen;
+    }
+}
+
+/* This page contains the two entry points to this file.  */
+
+/* Read a C expression from the string *STRINGPTR points to,
+   parse it, and return a pointer to a  struct expression  that we malloc.
+   Use block BLOCK as the lexical context for variable names;
+   if BLOCK is zero, use the block of the selected stack frame.
+   Meanwhile, advance *STRINGPTR to point after the expression,
+   at the first nonwhite character that is not part of the expression
+   (possibly a null character).  */
+
+struct expression *
+parse_c_1 (stringptr, block)
+     char **stringptr;
+     struct block *block;
+{
+  struct cleanup *old_chain;
+
+  lexptr = *stringptr;
+
+  if (lexptr == 0 || *lexptr == 0)
+    error_no_arg ("expression to compute");
+
+  old_chain = make_cleanup (free_funcalls, 0);
+  funcall_chain = 0;
+
+  expression_context_block = block ? block : get_selected_block ();
+
+  namecopy = (char *) alloca (strlen (lexptr) + 1);
+  expout_size = 10;
+  expout_ptr = 0;
+  expout = (struct expression *) xmalloc (sizeof (struct expression)
+					  + expout_size * sizeof (union exp_element));
+  make_cleanup (free_current_contents, &expout);
+  if (yyparse ())
+    yyerror ();
+  discard_cleanups (old_chain);
+  expout->nelts = expout_ptr;
+  expout = (struct expression *)
+    xrealloc (expout,
+	      sizeof (struct expression)
+	      + expout_ptr * sizeof (union exp_element));
+  prefixify_expression (expout);
+  *stringptr = lexptr;
+  return expout;
+}
+
+/* Parse STRING as an expression, and complain if this fails
+   to use up all of the contents of STRING.  */
+
+struct expression *
+parse_c_expression (string)
+     char *string;
+{
+  register struct expression *exp;
+  exp = parse_c_1 (&string, 0);
+  if (*string)
+    error ("Junk after end of expression.");
+  return exp;
+}
diff --git a/gdb/expression.h b/gdb/expression.h
new file mode 100644
index 0000000..7a7bd83
--- /dev/null
+++ b/gdb/expression.h
@@ -0,0 +1,167 @@
+/* Definitions for expressions stored in reversed prefix form, for GDB.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Definitions for saved C expressions.  */
+
+/* An expression is represented as a vector of union exp_element's.
+   Each exp_element is an opcode, except that some opcodes cause
+   the following exp_element to be treated as a long or double constant
+   or as a variable.  The opcodes are obeyed, using a stack for temporaries.
+   The value is left on the temporary stack at the end.  */
+
+/* When it is necessary to include a string,
+   it can occupy as many exp_elements as it needs.
+   We find the length of the string using strlen,
+   divide to find out how many exp_elements are used up,
+   and skip that many.  Strings, like numbers, are indicated
+   by the preceding opcode.  */
+
+enum exp_opcode
+{
+/* BINOP_... operate on two values computed by following subexpressions,
+   replacing them by one result value.  They take no immediate arguments.  */
+  BINOP_ADD,		/* + */
+  BINOP_SUB,		/* - */
+  BINOP_MUL,		/* * */
+  BINOP_DIV,		/* / */
+  BINOP_REM,		/* % */
+  BINOP_LSH,		/* << */
+  BINOP_RSH,		/* >> */
+  BINOP_AND,		/* && */
+  BINOP_OR,		/* || */
+  BINOP_LOGAND,		/* & */
+  BINOP_LOGIOR,		/* | */
+  BINOP_LOGXOR,		/* ^ */
+  BINOP_EQUAL,		/* == */
+  BINOP_NOTEQUAL,	/* != */
+  BINOP_LESS,		/* < */
+  BINOP_GTR,		/* > */
+  BINOP_LEQ,		/* <= */
+  BINOP_GEQ,		/* >= */
+  BINOP_REPEAT,		/* @ */
+  BINOP_ASSIGN,		/* = */
+  BINOP_COMMA,		/* , */
+  BINOP_SUBSCRIPT,	/* x[y] */
+  BINOP_EXP,		/* Exponentiation */
+  BINOP_END,
+
+  BINOP_ASSIGN_MODIFY,	/* +=, -=, *=, and so on.
+			   The following exp_element is another opcode,
+			   a BINOP_, saying how to modify.
+			   Then comes another BINOP_ASSIGN_MODIFY,
+			   making three exp_elements in total.  */
+
+/* Operates on three values computed by following subexpressions.  */
+  TERNOP_COND,		/* ?: */
+
+/* The OP_... series take immediate following arguments.
+   After the arguments come another OP_... (the same one)
+   so that the grouping can be recognized from the end.  */
+
+/* OP_LONG is followed by a type pointer in the next exp_element
+   and the long constant value in the following exp_element.
+   Then comes another OP_LONG.
+   Thus, the operation occupies four exp_elements.  */
+
+  OP_LONG,
+/* OP_DOUBLE is similar but takes a double constant instead of a long one.  */
+  OP_DOUBLE,
+/* OP_VAR_VALUE takes one struct symbol * in the following exp_element,
+   followed by another OP_VAR_VALUE, making three exp_elements.  */
+  OP_VAR_VALUE,
+/* OP_LAST is followed by an integer in the next exp_element.
+   The integer is zero for the last value printed,
+   or it is the absolute number of a history element.
+   With another OP_LAST at the end, this makes three exp_elements.  */
+  OP_LAST,
+/* OP_REGISTER is followed by an integer in the next exp_element.
+   This is the number of a register to fetch (as an int).
+   With another OP_REGISTER at the end, this makes three exp_elements.  */
+  OP_REGISTER,
+/* OP_INTERNALVAR is followed by an internalvar ptr in the next exp_element.
+   With another OP_INTERNALVAR at the end, this makes three exp_elements.  */
+  OP_INTERNALVAR,
+/* OP_FUNCALL is followed by an integer in the next exp_element.
+   The integer is the number of args to the function call.
+   That many plus one values from following subexpressions
+   are used, the first one being the function.
+   The integer is followed by a repeat of OP_FUNCALL,
+   making three exp_elements.  */
+  OP_FUNCALL,
+/* OP_STRING represents a string constant.
+   Its format is the same as that of a STRUCTOP, but the string
+   data is just made into a string constant when the operation
+   is executed.  */
+  OP_STRING,
+
+/* UNOP_CAST is followed by a type pointer in the next exp_element.
+   With another UNOP_CAST at the end, this makes three exp_elements.
+   It casts the value of the following subexpression.  */
+  UNOP_CAST,
+/* UNOP_MEMVAL is followed by a type pointer in the next exp_element
+   With another UNOP_MEMVAL at the end, this makes three exp_elements.
+   It casts the contents of the word addressed by the value of the
+   following subexpression.  */
+  UNOP_MEMVAL,
+/* UNOP_... operate on one value from a following subexpression
+   and replace it with a result.  They take no immediate arguments.  */
+  UNOP_NEG,		/* Unary - */
+  UNOP_ZEROP,		/* Unary ! */
+  UNOP_LOGNOT,		/* Unary ~ */
+  UNOP_IND,		/* Unary * */
+  UNOP_ADDR,		/* Unary & */
+  UNOP_PREINCREMENT,	/* ++ before an expression */
+  UNOP_POSTINCREMENT,	/* ++ after an expression */
+  UNOP_PREDECREMENT,	/* -- before an expression */
+  UNOP_POSTDECREMENT,	/* -- after an expression */
+  UNOP_SIZEOF,		/* Unary sizeof (followed by expression) */
+
+/* STRUCTOP_... operate on a value from a following subexpression
+   by extracting a structure component specified by a string
+   that appears in the following exp_elements (as many as needed).
+   STRUCTOP_STRUCT is used for "." and STRUCTOP_PTR for "->".
+   They differ only in the error message given in case the value is
+   not suitable or the structure component specified is not found.
+
+   The length of the string follows in the next exp_element,
+   (after the string), followed by another STRUCTOP_... code.  */
+  STRUCTOP_STRUCT,
+  STRUCTOP_PTR,
+};
+
+union exp_element
+{
+  enum exp_opcode opcode;
+  struct symbol *symbol;
+  long longconst;
+  double doubleconst;
+  char string;
+  struct type *type;
+  struct internalvar *internalvar;
+};
+
+struct expression
+{
+  int nelts;
+  union exp_element elts[1];
+};
+
+struct expression *parse_c_expression ();
+struct expression *parse_c_1 ();
diff --git a/gdb/findvar.c b/gdb/findvar.c
new file mode 100644
index 0000000..1f92b16
--- /dev/null
+++ b/gdb/findvar.c
@@ -0,0 +1,409 @@
+/* Find a variable's value in memory, for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+#include "value.h"
+
+CORE_ADDR read_register ();
+
+START_FILE
+
+/* Return the address in which frame FRAME's value of register REGNUM
+   has been saved in memory.  Or return zero if it has not been saved.
+   If REGNUM specifies the SP, the value we return is actually
+   the SP value, not an address where it was saved.  */
+
+static CORE_ADDR
+find_saved_register (frame, regnum)
+     FRAME frame;
+     int regnum;
+{
+  struct frame_info fi;
+  struct frame_saved_regs saved_regs;
+
+  register FRAME frame1 = 0;
+  register CORE_ADDR addr = 0;
+
+  while (1)
+    {
+      QUIT;
+      fi = get_prev_frame_info (frame1);
+      if (fi.frame == 0 || fi.frame == frame)
+	break;
+      get_frame_saved_regs (&fi, &saved_regs);
+      if (saved_regs.regs[regnum])
+	addr = saved_regs.regs[regnum];
+      frame1 = fi.frame;
+    }
+
+  return addr;
+}
+
+/* Copy the bytes of register REGNUM, relative to the current stack frame,
+   into our memory at MYADDR.
+   The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).  */
+
+void
+read_relative_register_raw_bytes (regnum, myaddr)
+     int regnum;
+     char *myaddr;
+{
+  register CORE_ADDR addr;
+
+  if (regnum == FP_REGNUM)
+    {
+      bcopy (&selected_frame, myaddr, sizeof (CORE_ADDR));
+      return;
+    }
+
+  addr = find_saved_register (selected_frame, regnum);
+
+  if (addr)
+    {
+      if (regnum == SP_REGNUM)
+	{
+	  CORE_ADDR buffer = addr;
+	  bcopy (&buffer, myaddr, sizeof (CORE_ADDR));
+	}
+      else
+	read_memory (addr, myaddr, REGISTER_RAW_SIZE (regnum));
+      return;
+    }
+  read_register_bytes (REGISTER_BYTE (regnum),
+		       myaddr, REGISTER_RAW_SIZE (regnum));
+}
+
+/* Return a `value' with the contents of register REGNUM
+   in its virtual format, with the type specified by
+   REGISTER_VIRTUAL_TYPE.  */
+
+value
+value_of_register (regnum)
+     int regnum;
+{
+  register CORE_ADDR addr = find_saved_register (selected_frame, regnum);
+  register value val;
+  char raw_buffer[MAX_REGISTER_RAW_SIZE];
+  char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+
+  if (addr)
+    {
+      if (regnum == SP_REGNUM)
+	return value_from_long (builtin_type_int, addr);
+      read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+    }
+  else
+    read_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
+			 REGISTER_RAW_SIZE (regnum));
+
+  REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
+  val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
+  bcopy (virtual_buffer, VALUE_CONTENTS (val), REGISTER_VIRTUAL_SIZE (regnum));
+  VALUE_LVAL (val) = addr ? lval_memory : lval_register;
+  VALUE_ADDRESS (val) = addr ? addr : REGISTER_BYTE (regnum);
+  VALUE_REGNO (val) = regnum;
+  return val;
+}
+
+/* Low level examining and depositing of registers.
+
+   Note that you must call `fetch_registers' once
+   before examining or depositing any registers.  */
+
+char registers[REGISTER_BYTES];
+
+/* Copy LEN bytes of consecutive data from registers
+   starting with the REGBYTE'th byte of register data
+   into memory at MYADDR.  */
+
+read_register_bytes (regbyte, myaddr, len)
+     int regbyte;
+     char *myaddr;
+     int len;
+{
+  bcopy (&registers[regbyte], myaddr, len);
+}
+
+/* Copy LEN bytes of consecutive data from memory at MYADDR
+   into registers starting with the REGBYTE'th byte of register data.  */
+
+write_register_bytes (regbyte, myaddr, len)
+     int regbyte;
+     char *myaddr;
+     int len;
+{
+  bcopy (myaddr, &registers[regbyte], len);
+  if (have_inferior_p ())
+    store_inferior_registers (-1);
+}
+
+/* Return the contents of register REGNO,
+   regarding it as an integer.  */
+
+CORE_ADDR
+read_register (regno)
+     int regno;
+{
+  /* This loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
+  return *(int *) &registers[REGISTER_BYTE (regno)];
+}
+
+/* Store VALUE in the register number REGNO, regarded as an integer.  */
+
+void
+write_register (regno, val)
+     int regno, val;
+{
+  /* This loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
+  *(int *) &registers[REGISTER_BYTE (regno)] = val;
+
+  if (have_inferior_p ())
+    store_inferior_registers (regno);
+}
+
+/* Record that register REGNO contains VAL.
+   This is used when the value is obtained from the inferior or core dump,
+   so there is no need to store the value there.  */
+
+void
+supply_register (regno, val)
+     int regno;
+     char *val;
+{
+  bcopy (val, &registers[REGISTER_BYTE (regno)], REGISTER_RAW_SIZE (regno));
+}
+
+/* Given a struct symbol for a variable,
+   and a stack frame address, read the value of the variable
+   and return a (pointer to a) struct value containing the value.  */
+
+value
+read_var_value (var, frame)
+     register struct symbol *var;
+     FRAME frame;
+{
+  register value v;
+
+  struct frame_info fi;
+
+  struct type *type = SYMBOL_TYPE (var);
+  register CORE_ADDR addr = 0;
+  int val = SYMBOL_VALUE (var);
+  register int len;
+
+  if (SYMBOL_CLASS (var) == LOC_BLOCK)
+    type = lookup_function_type (type);
+
+  v = allocate_value (type);
+  VALUE_LVAL (v) = lval_memory;	/* The most likely possibility.  */
+  len = TYPE_LENGTH (type);
+
+  if (frame == 0) frame = selected_frame;
+
+  switch (SYMBOL_CLASS (var))
+    {
+    case LOC_CONST:
+    case LOC_LABEL:
+      bcopy (&val, VALUE_CONTENTS (v), len);
+      VALUE_LVAL (v) = not_lval;
+      return v;
+
+    case LOC_CONST_BYTES:
+      bcopy (val, VALUE_CONTENTS (v), len);
+      VALUE_LVAL (v) = not_lval;
+      return v;
+
+    case LOC_STATIC:
+      addr = val;
+      break;
+
+    case LOC_ARG:
+      fi = get_frame_info (frame);
+      addr = val + FRAME_ARGS_ADDRESS (fi);
+      break;
+
+    case LOC_LOCAL:
+      fi = get_frame_info (frame);
+      addr = val + FRAME_LOCALS_ADDRESS (fi);
+      break;
+
+    case LOC_TYPEDEF:
+      error ("Cannot look up value of a typedef");
+
+    case LOC_BLOCK:
+      VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
+      return v;
+
+    case LOC_REGISTER:
+      {
+	char raw_buffer[MAX_REGISTER_RAW_SIZE];
+	char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+
+	VALUE_REGNO (v) = val;
+
+	/* Locate the register's contents in a real register or in core;
+	   read the data in raw format.  */
+
+	addr = find_saved_register (frame, val);
+	if (addr == 0)
+	  {
+	    /* Value is really in a register.  */
+
+	    VALUE_LVAL (v) = lval_register;
+	    VALUE_ADDRESS (v) = REGISTER_BYTE (val);
+
+	    read_register_bytes (REGISTER_BYTE (val),
+				 raw_buffer, REGISTER_RAW_SIZE (val));
+	  }
+	else
+	  {
+	    /* Value was in a register that has been saved in memory.  */
+
+	    read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (val));
+	    VALUE_ADDRESS (v) = addr;
+	  }
+
+	/* Convert the raw contents to virtual contents.
+	   (Just copy them if the formats are the same.)  */
+
+	REGISTER_CONVERT_TO_VIRTUAL (val, raw_buffer, virtual_buffer);
+
+	if (REGISTER_CONVERTIBLE (val))
+	  {
+	    /* When the raw and virtual formats differ, the virtual format
+	       corresponds to a specific data type.  If we want that type,
+	       copy the data into the value.
+	       Otherwise, do a type-conversion.  */
+
+	    if (type != REGISTER_VIRTUAL_TYPE (val))
+	      {
+		/* eg a variable of type `float' in a 68881 register
+		   with raw type `extended' and virtual type `double'.
+		   Fetch it as a `double' and then convert to `float'.  */
+		v = allocate_value (REGISTER_VIRTUAL_TYPE (val));
+		bcopy (virtual_buffer, VALUE_CONTENTS (v), len);
+		v = value_cast (type, v);
+	      }
+	    else
+	      bcopy (virtual_buffer, VALUE_CONTENTS (v), len);
+	  }
+	else
+	  {
+	    /* Raw and virtual formats are the same for this register.  */
+
+	    union { int i; char c; } test;
+	    /* If we want less than the full size, we need to
+	       test for a big-endian or little-endian machine.  */
+	    test.i = 1;
+	    if (test.c != 1 && len < REGISTER_RAW_SIZE (val))
+	      {
+		/* Big-endian, and we want less than full size.  */
+		VALUE_OFFSET (v) = REGISTER_RAW_SIZE (val) - len;
+	      }
+
+	    bcopy (virtual_buffer + VALUE_OFFSET (v),
+		   VALUE_CONTENTS (v), len);
+	  }
+
+	return v;
+      }
+    }
+
+  read_memory (addr, VALUE_CONTENTS (v), len);
+  VALUE_ADDRESS (v) = addr;
+  return v;
+}
+
+/* Given a struct symbol for a variable,
+   and a stack frame address,
+   return a (pointer to a) struct value containing the variable's address.  */
+
+value
+locate_var_value (var, frame)
+     register struct symbol *var;
+     FRAME frame;
+{
+  register CORE_ADDR addr = 0;
+  int val = SYMBOL_VALUE (var);
+  struct frame_info fi;
+
+  if (frame == 0) frame = selected_frame;
+
+  switch (SYMBOL_CLASS (var))
+    {
+    case LOC_CONST:
+    case LOC_CONST_BYTES:
+      error ("Address requested for identifier \"%s\" which is a constant.",
+	     SYMBOL_NAME (var));
+
+    case LOC_REGISTER:
+      addr = find_saved_register (frame, val);
+      if (addr != 0)
+	{
+	  union { int i; char c; } test;
+	  int len = TYPE_LENGTH (SYMBOL_TYPE (var));
+	  /* If var is less than the full size of register, we need to
+	     test for a big-endian or little-endian machine.  */
+	  test.i = 1;
+	  if (test.c != 1 && len < REGISTER_RAW_SIZE (val))
+	    /* Big-endian, and we want less than full size.  */
+	    addr+ = REGISTER_RAW_SIZE (val) - len;
+	  break;
+	}
+      error ("Address requested for identifier \"%s\" which is in a register.",
+	     SYMBOL_NAME (var));
+
+    case LOC_STATIC:
+    case LOC_LABEL:
+      addr = val;
+      break;
+
+    case LOC_ARG:
+      fi = get_frame_info (frame);
+      addr = val + FRAME_ARGS_ADDRESS (fi);
+      break;
+
+    case LOC_LOCAL:
+      fi = get_frame_info (frame);
+      addr = val + FRAME_LOCALS_ADDRESS (fi);
+      break;
+
+    case LOC_TYPEDEF:
+      error ("Address requested for identifier \"%s\" which is a typedef.",
+	     SYMBOL_NAME (var));
+
+    case LOC_BLOCK:
+      addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
+      break;
+    }
+
+  return value_cast (lookup_pointer_type (SYMBOL_TYPE (var)),
+		     value_from_long (builtin_type_long, addr));
+}
+
+static
+initialize ()
+{}
+
+END_FILE
diff --git a/gdb/firstfile.c b/gdb/firstfile.c
new file mode 100644
index 0000000..60d6bf8
--- /dev/null
+++ b/gdb/firstfile.c
@@ -0,0 +1,154 @@
+/* Find the initialization functions of following files.
+   This goes with initialize.h and lastfile.c.
+
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+		       NO WARRANTY
+
+  BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+		GENERAL PUBLIC LICENSE TO COPY
+
+  1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of this
+    program or any part thereof, to be licensed at no charge to all
+    third parties on terms identical to those contained in this
+    License Agreement (except that you may choose to grant more
+    extensive warranty protection to third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of this program in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them.   Help stamp out software-hoarding!  */
+
+
+
+/* This is a magical hack for finding, automatically,
+   all the files that are linked together
+   and calling an initialization function in each one
+   without requiring the main file to know which other
+   files there are.
+
+   Call initialize_all_files to run the initialization functions
+   of all the files.  Each initialization function can enter
+   the commands of its file into a global data base so that the
+   contents of the file can be used.
+
+   The files to be found must follow this file.  Each of them
+   must start START_FILE, before any other functions,
+   and end with END_FILE, after any other functions.
+   These macros are defined in initialize.h.
+   In addition, each file must contain a function named
+   `initialize', which will be called with no arguments.
+
+   After the files to be found must come the file `lastfile'
+   which ends the chain of calls.  */
+
+#include "initialize.h"
+
+static initialize_next_file ();
+static initialize_dummy_1 ();
+static initialize_dummy_2 ();
+
+initialize_all_files ()
+{
+  initialize_next_file ((char *) initialize_dummy_2
+			- (char *) initialize_dummy_1);
+}
+
+/* The next two functions exist just so we can find
+   out how long the first of them is.
+   That tells us how long initialize_next_file is,
+   since that function has the same definition as this one.  */
+
+static
+initialize_dummy_1 (offset)
+     int offset;
+{
+  long addr = FILEADDR_ROUND ((int) initialize_next_file + offset);
+  (*(void (*) ()) addr) (offset);
+}
+
+static
+initialize_dummy_2 ()
+{
+}
+
+/* This makes the function initialize_next_file.  */
+
+END_FILE
diff --git a/gdb/foo.c b/gdb/foo.c
new file mode 100644
index 0000000..59e559f
--- /dev/null
+++ b/gdb/foo.c
@@ -0,0 +1,13 @@
+main() {
+	int i;
+
+	for (i = 0; i >= 0; i++)
+		bar();
+}
+
+bar()
+{
+	int i;
+
+	i = 10;
+}
diff --git a/gdb/foo.nm b/gdb/foo.nm
new file mode 100644
index 0000000..7a14364
--- /dev/null
+++ b/gdb/foo.nm
@@ -0,0 +1,39 @@
+
+
+Symbols from foo:
+
+Name                  Value   Class        Type         Size   Line  Section
+
+crt0.s              |        | file |                  |      |     |
+foo.c               |        | file |                  |      |     |
+main                |     228|extern|            int( )|    66|     |.text
+.bf                 |     228|fcn   |                  |      |    1|.text
+i                   |      -4|auto  |               int|      |     |
+.ef                 |     274|fcn   |                  |      |    6|.text
+bar                 |     294|extern|            int( )|    50|     |.text
+.bf                 |     294|fcn   |                  |      |    9|.text
+i                   |      -4|auto  |               int|      |     |
+.ef                 |     324|fcn   |                  |      |    5|.text
+dbxxx.s             |        | file |                  |      |     |
+initfpu.s           |        | file |                  |      |     |
+cuexit.s            |        | file |                  |      |     |
+fakcu.c             |        | file |                  |      |     |
+_cleanup            |     404|extern|               ( )|    42|     |.text
+.bf                 |     404|fcn   |                  |      |   23|.text
+.ef                 |     426|fcn   |                  |      |    2|.text
+_ac_r               | 4194760|static|             *char|      |     |.data
+copyright.c         |        | file |                  |      |     |
+_ac_r               | 4194764|static|             *char|      |     |.data
+_start              |     168|extern|                  |      |     |.text
+_dbargs             | 4195016|extern|                  |      |     |.bss
+exit                |     388|extern|                  |      |     |.text
+initfpu             |     380|extern|                  |      |     |.text
+environ             | 4194756|extern|                  |      |     |.data
+splimit%            | 4194752|extern|                  |      |     |.data
+_dbsubc             |     344|extern|                  |      |     |.text
+_dbsubn             |     376|extern|                  |      |     |.text
+_ac_s               | 4194768|extern|           char[0]|      |     |.data
+etext               |     448|extern|                  |      |     |
+edata               | 4195016|extern|                  |      |     |
+end                 | 4195528|extern|                  |      |     |
+_sorigin            | 4195528|extern|                  |      |     |
diff --git a/gdb/foo.od b/gdb/foo.od
new file mode 100644
index 0000000..ce2a186
--- /dev/null
+++ b/gdb/foo.od
@@ -0,0 +1,213 @@
+0000000    0150    0003    21fc    7629    0000    0310    0000    0032
+	001   P  \0 003   ! 374   v   )  \0  \0 003 020  \0  \0  \0   2
+0000020    001c    0103    010b    0000    0000    0118    0000    0108
+	 \0 034 001 003 001 013  \0  \0  \0  \0 001 030  \0  \0 001  \b
+0000040    0000    0200    0000    00a8    0000    00a8    0040    01c0
+	 \0  \0 002  \0  \0  \0  \0 250  \0  \0  \0 250  \0   @ 001 300
+0000060    2e74    6578    7400    0000    0000    00a8    0000    00a8
+	  .   t   e   x   t  \0  \0  \0  \0  \0  \0 250  \0  \0  \0 250
+0000100    0000    0118    0000    00a8    0000    0000    0000    02c8
+	 \0  \0 001 030  \0  \0  \0 250  \0  \0  \0  \0  \0  \0 002 310
+0000120    0000    000c    0000    0020    2e64    6174    6100    0000
+	 \0  \0  \0  \f  \0  \0  \0       .   d   a   t   a  \0  \0  \0
+0000140    0040    01c0    0040    01c0    0000    0108    0000    01c0
+	 \0   @ 001 300  \0   @ 001 300  \0  \0 001  \b  \0  \0 001 300
+0000160    0000    0000    0000    0000    0000    0000    0000    0040
+	 \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0   @
+0000200    2e62    7373    0000    0000    0040    02c8    0040    02c8
+	  .   b   s   s  \0  \0  \0  \0  \0   @ 002 310  \0   @ 002 310
+0000220    0000    0200    0000    0000    0000    0000    0000    0000
+	 \0  \0 002  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
+0000240    0000    0000    0000    0080    23c0    0040    01c0    518f
+	 \0  \0  \0  \0  \0  \0  \0 200   # 300  \0   @ 001 300   Q 217
+0000260    2eaf    0008    41ef    000c    2f48    0004    2248    4a98
+	  . 257  \0  \b   A 357  \0  \f   /   H  \0 004   "   H   J 230
+0000300    66fc    2f48    0008    23c8    0040    01c4    4eb9    0000
+	  f 374   /   H  \0  \b   # 310  \0   @ 001 304   N 271  \0  \0
+0000320    017c    4eb9    0000    00e4    2e80    4eb9    0000    0184
+	001   |   N 271  \0  \0  \0 344   . 200   N 271  \0  \0 001 204
+0000340    7001    4e40    480e    ffff    fff8    48ef    0000    0004
+	  p 001   N   @   H 016 377 377 377 370   H 357  \0  \0  \0 004
+0000360    f237    f000    0170    0000    0004    42ae    fffc    4aae
+	362   7 360  \0 001   p  \0  \0  \0 004   B 256 377 374   J 256
+0000400    fffc    6d00    000e    4eba    001e    52ae    fffc    6000
+	377 374   m  \0  \0 016   N 272  \0 036   R 256 377 374   `  \0
+0000420    ffee    4cef    0000    0004    f237    d000    0170    0000
+	377 356   L 357  \0  \0  \0 004 362   7 320  \0 001   p  \0  \0
+0000440    0004    4e5e    4e75    480e    ffff    fff8    48ef    0000
+	 \0 004   N   ^   N   u   H 016 377 377 377 370   H 357  \0  \0
+0000460    0004    f237    f000    0170    0000    0004    2d7c    0000
+	 \0 004 362   7 360  \0 001   p  \0  \0  \0 004   -   |  \0  \0
+0000500    000a    fffc    4cef    0000    0004    f237    d000    0170
+	 \0  \n 377 374   L 357  \0  \0  \0 004 362   7 320  \0 001   p
+0000520    0000    0004    4e5e    4e75    4e56    0000    207c    0040
+	 \0  \0  \0 004   N   ^   N   u   N   V  \0  \0       |  \0   @
+0000540    02c8    2258    2018    2200    e581    d1c1    6002    2f20
+	002 310   "   X     030   "  \0 345 201 321 301   ` 002   /    
+0000560    51c8    fffc    4e91    4e5e    4e41    4e71    4e56    fffc
+	  Q 310 377 374   N 221   N   ^   N   A   N   q   N   V 377 374
+0000600    4e5e    4e75    4eb9    0000    0194    7001    4e40    4e72
+	  N   ^   N   u   N 271  \0  \0 001 224   p 001   N   @   N   r
+0000620    0000    4e71    480e    ffff    fffc    48ef    0000    0004
+	 \0  \0   N   q   H 016 377 377 377 374   H 357  \0  \0  \0 004
+0000640    f237    f000    0170    0000    0004    4cef    0000    0004
+	362   7 360  \0 001   p  \0  \0  \0 004   L 357  \0  \0  \0 004
+0000660    f237    d000    0170    0000    0004    4e5e    4e75    4e71
+	362   7 320  \0 001   p  \0  \0  \0 004   N   ^   N   u   N   q
+0000700    0000    0000    0000    0000    0040    01d0    0040    01d0
+	 \0  \0  \0  \0  \0  \0  \0  \0  \0   @ 001 320  \0   @ 001 320
+0000720    436f    7079    7269    6768    7420    2863    2920    3139
+	  C   o   p   y   r   i   g   h   t       (   c   )       1   9
+0000740    3837    2041    7070    6c65    2043    6f6d    7075    7465
+	  8   7       A   p   p   l   e       C   o   m   p   u   t   e
+0000760    722c    2049    6e63    2e2c    2031    3938    3520    4164
+	  r   ,       I   n   c   .   ,       1   9   8   5       A   d
+0001000    6f62    6520    5379    7374    656d    7320    496e    636f
+	  o   b   e       S   y   s   t   e   m   s       I   n   c   o
+0001020    7270    6f72    6174    6564    2c20    3139    3833    2d38
+	  r   p   o   r   a   t   e   d   ,       1   9   8   3   -   8
+0001040    3720    4154    2654    2d49    532c    2031    3938    352d
+	  7       A   T   &   T   -   I   S   ,       1   9   8   5   -
+0001060    3837    204d    6f74    6f72    6f6c    6120    496e    632e
+	  8   7       M   o   t   o   r   o   l   a       I   n   c   .
+0001100    2c20    3139    3830    2d38    3720    5375    6e20    4d69
+	  ,       1   9   8   0   -   8   7       S   u   n       M   i
+0001120    6372    6f73    7973    7465    6d73    2049    6e63    2e2c
+	  c   r   o   s   y   s   t   e   m   s       I   n   c   .   ,
+0001140    2031    3938    302d    3837    2054    6865    2052    6567
+	      1   9   8   0   -   8   7       T   h   e       R   e   g
+0001160    656e    7473    206f    6620    7468    6520    556e    6976
+	  e   n   t   s       o   f       t   h   e       U   n   i   v
+0001200    6572    7369    7479    206f    6620    4361    6c69    666f
+	  e   r   s   i   t   y       o   f       C   a   l   i   f   o
+0001220    726e    6961    2c20    3139    3835    2d38    3720    556e
+	  r   n   i   a   ,       1   9   8   5   -   8   7       U   n
+0001240    6973    6f66    7420    436f    7270    6f72    6174    696f
+	  i   s   o   f   t       C   o   r   p   o   r   a   t   i   o
+0001260    6e2c    2041    6c6c    2052    6967    6874    7320    5265
+	  n   ,       A   l   l       R   i   g   h   t   s       R   e
+0001300    7365    7276    6564    2e00    0000    0004    0000    0000
+	  s   e   r   v   e   d   .  \0  \0  \0  \0 004  \0  \0  \0  \0
+0001320    00e4    0001    0000    00fa    0004    0000    0106    0005
+	 \0 344  \0 001  \0  \0  \0 372  \0 004  \0  \0 001 006  \0 005
+0001340    0000    0112    0006    0000    000b    0000    0000    0126
+	 \0  \0 001 022  \0 006  \0  \0  \0 013  \0  \0  \0  \0 001   &
+0001360    0001    0000    013c    0004    0000    0144    0005    0000
+	 \0 001  \0  \0 001   <  \0 004  \0  \0 001   D  \0 005  \0  \0
+0001400    001a    0000    0000    0194    0001    0000    01aa    0002
+	 \0 032  \0  \0  \0  \0 001 224  \0 001  \0  \0 001 252  \0 002
+0001420    2e66    696c    6500    0000    0000    0002    fffe    0000
+	  .   f   i   l   e  \0  \0  \0  \0  \0  \0 002 377 376  \0  \0
+0001440    6701    6372    7430    2e73    0000    0000    0000    0000
+	  g 001   c   r   t   0   .   s  \0  \0  \0  \0  \0  \0  \0  \0
+0001460    0000    0000    2e66    696c    6500    0000    0000    0012
+	 \0  \0  \0  \0   .   f   i   l   e  \0  \0  \0  \0  \0  \0 022
+0001500    fffe    0000    6701    666f    6f2e    6300    0000    0000
+	377 376  \0  \0   g 001   f   o   o   .   c  \0  \0  \0  \0  \0
+0001520    0000    0000    0000    0000    6d61    696e    0000    0000
+	 \0  \0  \0  \0  \0  \0  \0  \0   m   a   i   n  \0  \0  \0  \0
+0001540    0000    00e4    0001    0024    0201    0000    0000    0000
+	 \0  \0  \0 344  \0 001  \0   $ 002 001  \0  \0  \0  \0  \0  \0
+0001560    0042    0000    02c8    0000    000b    0000    2e62    6600
+	 \0   B  \0  \0 002 310  \0  \0  \0 013  \0  \0   .   b   f  \0
+0001600    0000    0000    0000    00e4    0001    0000    6501    0000
+	 \0  \0  \0  \0  \0  \0  \0 344  \0 001  \0  \0   e 001  \0  \0
+0001620    0000    0001    0000    0000    0000    0000    0000    0000
+	 \0  \0  \0 001  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
+0001640    6900    0000    0000    0000    ffff    fffc    ffff    0004
+	  i  \0  \0  \0  \0  \0  \0  \0 377 377 377 374 377 377  \0 004
+0001660    0100    2e65    6600    0000    0000    0000    0112    0001
+	001  \0   .   e   f  \0  \0  \0  \0  \0  \0  \0 001 022  \0 001
+0001700    0000    6501    0000    0000    0006    0000    0000    0000
+	 \0  \0   e 001  \0  \0  \0  \0  \0 006  \0  \0  \0  \0  \0  \0
+0001720    0000    0000    0000    6261    7200    0000    0000    0000
+	 \0  \0  \0  \0  \0  \0   b   a   r  \0  \0  \0  \0  \0  \0  \0
+0001740    0126    0001    0024    0201    0000    0000    0000    0032
+	001   &  \0 001  \0   $ 002 001  \0  \0  \0  \0  \0  \0  \0   2
+0001760    0000    02e6    0000    0012    0000    2e62    6600    0000
+	 \0  \0 002 346  \0  \0  \0 022  \0  \0   .   b   f  \0  \0  \0
+0002000    0000    0000    0126    0001    0000    6501    0000    0000
+	 \0  \0  \0  \0 001   &  \0 001  \0  \0   e 001  \0  \0  \0  \0
+0002020    0009    0000    0000    0000    0000    0000    0000    6900
+	 \0  \t  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0   i  \0
+0002040    0000    0000    0000    ffff    fffc    ffff    0004    0100
+	 \0  \0  \0  \0  \0  \0 377 377 377 374 377 377  \0 004 001  \0
+0002060    2e65    6600    0000    0000    0000    0144    0001    0000
+	  .   e   f  \0  \0  \0  \0  \0  \0  \0 001   D  \0 001  \0  \0
+0002100    6501    0000    0000    0005    0000    0000    0000    0000
+	  e 001  \0  \0  \0  \0  \0 005  \0  \0  \0  \0  \0  \0  \0  \0
+0002120    0000    0000    2e66    696c    6500    0000    0000    0014
+	 \0  \0  \0  \0   .   f   i   l   e  \0  \0  \0  \0  \0  \0 024
+0002140    fffe    0000    6701    6462    7878    782e    7300    0000
+	377 376  \0  \0   g 001   d   b   x   x   x   .   s  \0  \0  \0
+0002160    0000    0000    0000    0000    2e66    696c    6500    0000
+	 \0  \0  \0  \0  \0  \0  \0  \0   .   f   i   l   e  \0  \0  \0
+0002200    0000    0016    fffe    0000    6701    696e    6974    6670
+	 \0  \0  \0 026 377 376  \0  \0   g 001   i   n   i   t   f   p
+0002220    752e    7300    0000    0000    0000    0000    2e66    696c
+	  u   .   s  \0  \0  \0  \0  \0  \0  \0  \0  \0   .   f   i   l
+0002240    6500    0000    0000    0018    fffe    0000    6701    6375
+	  e  \0  \0  \0  \0  \0  \0 030 377 376  \0  \0   g 001   c   u
+0002260    6578    6974    2e73    0000    0000    0000    0000    0000
+	  e   x   i   t   .   s  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
+0002300    2e66    696c    6500    0000    0000    0021    fffe    0000
+	  .   f   i   l   e  \0  \0  \0  \0  \0  \0   ! 377 376  \0  \0
+0002320    6701    6661    6b63    752e    6300    0000    0000    0000
+	  g 001   f   a   k   c   u   .   c  \0  \0  \0  \0  \0  \0  \0
+0002340    0000    0000    5f63    6c65    616e    7570    0000    0194
+	 \0  \0  \0  \0   _   c   l   e   a   n   u   p  \0  \0 001 224
+0002360    0001    0020    0201    0000    0000    0000    002a    0000
+	 \0 001  \0     002 001  \0  \0  \0  \0  \0  \0  \0   *  \0  \0
+0002400    02fe    0000    0020    0000    2e62    6600    0000    0000
+	002 376  \0  \0  \0      \0  \0   .   b   f  \0  \0  \0  \0  \0
+0002420    0000    0194    0001    0000    6501    0000    0000    0017
+	 \0  \0 001 224  \0 001  \0  \0   e 001  \0  \0  \0  \0  \0 027
+0002440    0000    0000    0000    0000    0000    0000    2e65    6600
+	 \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0   .   e   f  \0
+0002460    0000    0000    0000    01aa    0001    0000    6501    0000
+	 \0  \0  \0  \0  \0  \0 001 252  \0 001  \0  \0   e 001  \0  \0
+0002500    0000    0002    0000    0000    0000    0000    0000    0000
+	 \0  \0  \0 002  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
+0002520    5f61    635f    7200    0000    0040    01c8    0002    0012
+	  _   a   c   _   r  \0  \0  \0  \0   @ 001 310  \0 002  \0 022
+0002540    0300    2e66    696c    6500    0000    0000    0024    fffe
+	003  \0   .   f   i   l   e  \0  \0  \0  \0  \0  \0   $ 377 376
+0002560    0000    6701    636f    7079    7269    6768    742e    6300
+	 \0  \0   g 001   c   o   p   y   r   i   g   h   t   .   c  \0
+0002600    0000    0000    0000    5f61    635f    7200    0000    0040
+	 \0  \0  \0  \0  \0  \0   _   a   c   _   r  \0  \0  \0  \0   @
+0002620    01cc    0002    0012    0300    5f73    7461    7274    0000
+	001 314  \0 002  \0 022 003  \0   _   s   t   a   r   t  \0  \0
+0002640    0000    00a8    0001    0000    0200    5f64    6261    7267
+	 \0  \0  \0 250  \0 001  \0  \0 002  \0   _   d   b   a   r   g
+0002660    7300    0040    02c8    0003    0000    0200    6578    6974
+	  s  \0  \0   @ 002 310  \0 003  \0  \0 002  \0   e   x   i   t
+0002700    0000    0000    0000    0184    0001    0000    0200    696e
+	 \0  \0  \0  \0  \0  \0 001 204  \0 001  \0  \0 002  \0   i   n
+0002720    6974    6670    7500    0000    017c    0001    0000    0200
+	  i   t   f   p   u  \0  \0  \0 001   |  \0 001  \0  \0 002  \0
+0002740    656e    7669    726f    6e00    0040    01c4    0002    0000
+	  e   n   v   i   r   o   n  \0  \0   @ 001 304  \0 002  \0  \0
+0002760    0200    7370    6c69    6d69    7425    0040    01c0    0002
+	002  \0   s   p   l   i   m   i   t   %  \0   @ 001 300  \0 002
+0003000    0000    0200    5f64    6273    7562    6300    0000    0158
+	 \0  \0 002  \0   _   d   b   s   u   b   c  \0  \0  \0 001   X
+0003020    0001    0000    0200    5f64    6273    7562    6e00    0000
+	 \0 001  \0  \0 002  \0   _   d   b   s   u   b   n  \0  \0  \0
+0003040    0178    0001    0000    0200    5f61    635f    7300    0000
+	001   x  \0 001  \0  \0 002  \0   _   a   c   _   s  \0  \0  \0
+0003060    0040    01d0    0002    0032    0201    0000    0000    0000
+	 \0   @ 001 320  \0 002  \0   2 002 001  \0  \0  \0  \0  \0  \0
+0003100    0000    0000    0000    0000    0000    0000    6574    6578
+	 \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0   e   t   e   x
+0003120    7400    0000    0000    01c0    ffff    0000    0200    6564
+	  t  \0  \0  \0  \0  \0 001 300 377 377  \0  \0 002  \0   e   d
+0003140    6174    6100    0000    0040    02c8    ffff    0000    0200
+	  a   t   a  \0  \0  \0  \0   @ 002 310 377 377  \0  \0 002  \0
+0003160    656e    6400    0000    0000    0040    04c8    ffff    0000
+	  e   n   d  \0  \0  \0  \0  \0  \0   @ 004 310 377 377  \0  \0
+0003200    0200    5f73    6f72    6967    696e    0040    04c8    ffff
+	002  \0   _   s   o   r   i   g   i   n  \0   @ 004 310 377 377
+0003220    0000    0200
+	 \0  \0 002  \0
+0003224
diff --git a/gdb/foo.s b/gdb/foo.s
new file mode 100644
index 0000000..a7079d5
--- /dev/null
+++ b/gdb/foo.s
@@ -0,0 +1,65 @@
+	file	"foo.c"
+	data	1
+	text
+	def	main;	val	main;	scl	2;	type	044;	endef
+	global	main
+main:
+	ln	1
+	def	~bf;	val	~;	scl	101;	line	1;	endef
+	link.l	%fp,&F%1
+	movm.l	&M%1,(4,%sp)
+	fmovm	&FPM%1,(FPO%1,%sp)
+	def	i;	val	-4+S%1;	scl	1;	type	04;	endef
+	ln	4
+	clr.l	((S%1-4).w,%fp)
+L%15:
+	tst.l	((S%1-4).w,%fp)
+	blt	L%14
+	ln	5
+	jsr	bar
+L%13:
+	add.l	&1,((S%1-4).w,%fp)
+	bra	L%15
+L%14:
+L%12:
+	def	~ef;	val	~;	scl	101;	line	6;	endef
+	ln	6
+	movm.l	(4,%sp),&M%1
+	fmovm	(FPO%1,%sp),&FPM%1
+	unlk	%fp
+	rts
+	def	main;	val	~;	scl	-1;	endef
+	set	S%1,0
+	set	T%1,0
+	set	F%1,-8
+	set	FPO%1,4
+	set	FPM%1,0x0000
+	set	M%1,0x0000
+	data	1
+	text
+	def	bar;	val	bar;	scl	2;	type	044;	endef
+	global	bar
+bar:
+	ln	1
+	def	~bf;	val	~;	scl	101;	line	9;	endef
+	link.l	%fp,&F%2
+	movm.l	&M%2,(4,%sp)
+	fmovm	&FPM%2,(FPO%2,%sp)
+	def	i;	val	-4+S%2;	scl	1;	type	04;	endef
+	ln	4
+	mov.l	&10,((S%2-4).w,%fp)
+L%17:
+	def	~ef;	val	~;	scl	101;	line	5;	endef
+	ln	5
+	movm.l	(4,%sp),&M%2
+	fmovm	(FPO%2,%sp),&FPM%2
+	unlk	%fp
+	rts
+	def	bar;	val	~;	scl	-1;	endef
+	set	S%2,0
+	set	T%2,0
+	set	F%2,-8
+	set	FPO%2,4
+	set	FPM%2,0x0000
+	set	M%2,0x0000
+	data	1
diff --git a/gdb/foo.sym b/gdb/foo.sym
new file mode 100644
index 0000000..4b6595a
--- /dev/null
+++ b/gdb/foo.sym
@@ -0,0 +1,114 @@
+Symtab for file _globals_
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41a5cc) [0x0..0x0]
+ char _ac_s[0]; static at 0x4001d0,
+ int _dbargs; static at 0x4002c8,
+ int environ; static at 0x4001c4,
+ int splimit%; static at 0x4001c0,
+  block #001 (object 0x41a5a8) [0x0..0x0] (under 0x41a5cc)
+
+
+Symtab for file copyright.c
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41a460) [0x0..0x0]
+  block #001 (object 0x41a444) [0x0..0x0] (under 0x41a460)
+   char *_ac_r; static at 0x4001cc,
+
+
+Symtab for file fakcu.c
+
+Line table:
+
+ line 23 at 194
+ line 24 at 1aa
+
+Blockvector:
+
+block #000 (object 0x41a3f0) [0x0..0x0]
+ void _cleanup; block (object 0x41a380) starting at 0x194,
+  block #001 (object 0x41a3d4) [0x0..0x0] (under 0x41a3f0)
+   char *_ac_r; static at 0x4001c8,
+    block #002 (object 0x41a380) [0x194..0x1b0] (under 0x41a3d4) _cleanup
+
+
+Symtab for file cuexit.s
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41f210) [0x0..0x0]
+  block #001 (object 0x41f1ec) [0x0..0x0] (under 0x41f210)
+
+
+Symtab for file initfpu.s
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41e1c4) [0x0..0x0]
+  block #001 (object 0x41e1a0) [0x0..0x0] (under 0x41e1c4)
+
+
+Symtab for file dbxxx.s
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41d178) [0x0..0x0]
+  block #001 (object 0x41d154) [0x0..0x0] (under 0x41d178)
+
+
+Symtab for file foo.c
+
+Line table:
+
+ line 1 at e4
+ line 2 at fa
+ line 4 at fa
+ line 5 at 106
+ line 6 at 112
+ line 7 at 126
+ line 9 at 126
+ line 10 at 13c
+ line 12 at 13c
+ line 13 at 144
+
+Blockvector:
+
+block #000 (object 0x41a2d8) [0x0..0x0]
+ int bar; block (object 0x41a2b0) starting at 0x126,
+ int main; block (object 0x41a220) starting at 0xe4,
+  block #001 (object 0x41a23c) [0x0..0x0] (under 0x41a2d8)
+    block #002 (object 0x41a220) [0xe4..0x120] (under 0x41a23c) main
+     int i; local at 0xfffffffc,
+    block #003 (object 0x41a2b0) [0x126..0x150] (under 0x41a23c) bar
+     int i; local at 0xfffffffc,
+
+
+Symtab for file crt0.s
+
+Line table:
+
+
+Blockvector:
+
+block #000 (object 0x41b178) [0x0..0x0]
+  block #001 (object 0x41b154) [0x0..0x0] (under 0x41b178)
+
+
diff --git a/gdb/frame.h b/gdb/frame.h
new file mode 100644
index 0000000..3f51c45
--- /dev/null
+++ b/gdb/frame.h
@@ -0,0 +1,64 @@
+/* Definitions for dealing with stack frames, for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Note that frame.h requires param.h! */
+
+#define FRAME CORE_ADDR
+
+struct frame_info
+  {
+    /* Nominal address of the frame described.  */
+    FRAME frame;
+    /* Address at which execution is occurring in this frame.
+       For the innermost frame, it's the current pc.
+       For other frames, it is a pc saved in the next frame.  */
+    CORE_ADDR pc;
+    /* The frame called by the frame we are describing, or 0.  */
+    FRAME next_frame;
+  };
+
+/* Describe the saved registers of a frame.  */
+
+struct frame_saved_regs
+  {
+    /* For each register, address of where it was saved on entry to the frame,
+       or zero if it was not saved on entry to this frame.  */
+    CORE_ADDR regs[NUM_REGS];
+  };
+
+/* The stack frame that the user has specified for commands to act on.
+   Note that one cannot assume this is the address of valid data.  */
+
+extern FRAME selected_frame;
+
+extern struct frame_info get_frame_info ();
+extern struct frame_info get_prev_frame_info ();
+
+extern void get_frame_saved_regs ();
+
+extern FRAME get_prev_frame ();
+
+extern FRAME get_current_frame ();
+
+extern struct block *get_frame_block ();
+extern struct block *get_current_block ();
+extern struct block *get_selected_block ();
+extern struct symbol *get_frame_function ();
+extern struct symbol *get_pc_function ();
diff --git a/gdb/gdb.1 b/gdb/gdb.1
new file mode 100644
index 0000000..11a42a6
--- /dev/null
+++ b/gdb/gdb.1
@@ -0,0 +1,91 @@
+.TH GDB 1 "13 April 1987"
+.UC 4
+.SH NAME
+gdb \- Project GNU's DeBugger
+.SH SYNOPSIS
+\fBgdb\fP [ \fBoptions\fP ]   See documentation mentioned below.
+.SH DESCRIPTION
+\fIgdb\fP is a source level symbolic debugger for C programs, created by
+Richard M. Stallman (rms) for the GNU Project, and distributed by the
+Free Software Foundation.  Eventually GNU (Gnu's Not Unix) will be a
+complete replacement for Berkeley Unix, all of which everyone will be
+able to use freely.  See the \fIGNU Emacs\fP man page for pointers to more
+information.
+.PP
+\fIgdb\fP has something of the flavor of \fIdbx\fP,
+but has more features and power.  It can also be used to debug o/s
+kernels, but needs to be configured differently for that task.
+.PP
+Project GNU isn't using Unix man pages.  Its style of complete
+documentation can be found by:
+.PP
+The help and info commands inside \fIgdb\fP.
+.PP
+In the Info system in \fIGNU Emacs\fP.  Type C-h i, and follow the
+directions.  This is equivalent to the reference manual for 
+\fIgdb\fP, and has about 55 pages of text.
+.PP
+\fIgdb\fP could be extended to work with other languages (e.g. Pascal) and
+machines (e.g. encores).  If you like, copy the sources and give it a
+try.  When you have it working send \fIdiff -c\fP's of the changed files to
+bug-gdb@prep.ai.mit.edu (fuller details below), so they can benefit everyone.
+.SH DISTRIBUTION
+\fIgdb\fP is free; anyone may redistribute copies of
+\fIgdb\fP to anyone under the terms stated in the
+\fIgdb\fP General Public License, a copy of which accompanies each copy of
+\fIgdb\fP, is readable with the info command inside \fIgdb\fP,
+and which also appears in the \fIgdb\fP reference manual.
+.PP
+Copies of \fIgdb\fP may sometimes be received packaged with
+distributions of Unix systems, but it is never included in the scope
+of any license covering those systems.  Such inclusion would violate
+the terms on which distribution is permitted.  In fact, the primary
+purpose of the General Public License is to prohibit anyone from
+attaching any other restrictions to redistribution of \fIgdb\fP.
+.PP
+You can order printed copies of the \fIgdb\fP reference manual for $10.00/copy
+postpaid from the Free Software Foundation, which develops GNU software
+(contact them for quantity prices on the manual).  Their address is:
+.nf
+    Free Software Foundation
+    1000 Mass Ave.
+    Cambridge, MA  02138
+.fi
+As with all software and publications from FSF, everyone is permitted to
+make and distribute copies of the \fIgdb\fP reference manual.
+The TeX source to the \fIgdb\fP reference
+manual is also included in the \fIGNU Emacs\fP source distribution.
+.PP
+.SH OPTIONS
+See documentation.
+.SH EXAMPLES
+See documentation.
+.SH "SEE ALSO"
+adb(1), sdb(1), dbx(1)
+.SH BUGS
+There is a mailing list, bug-gdb@prep.ai.mit.edu on the internet
+(ucbvax!prep.ai.mit.edu!bug-gdb on UUCPnet), for reporting \fIgdb\fP
+bugs and fixes.  But before reporting something as a bug, please try
+to be sure that it really is a bug, not a misunderstanding or a
+deliberate feature.  We ask you to read the section ``Reporting Emacs
+Bugs'' near the end of the \fIGNU Emacs\fP reference manual
+(or Info system) for hints
+on how and when to report bugs.  Also, include the version number of
+the \fIgdb\fP you are running in \fIevery\fR bug report that you send in.
+.PP
+Do not expect a personal answer to a bug report.  The purpose of reporting
+bugs is to get them fixed for everyone in the next release, if possible.
+For personal assistance, look in the SERVICE file
+(see the \fIGNU Emacs\fP man page) for
+a list of people who offer it.
+.PP
+Please do not send anything but bug reports to this mailing list.
+Send other stuff to gnu@prep.ai.mit.edu (or the
+corresponding UUCP address).  For more information about GNU mailing
+lists, see the file MAILINGLISTS (see the \fIGNU Emacs\fP man page).  Bugs tend
+actually to be fixed if they can be isolated, so it is in your
+interest to report them in such a way that they can be easily
+reproduced.
+.PP
+No bugs are known at this time.
+
diff --git a/gdb/gdb.ideas b/gdb/gdb.ideas
new file mode 100644
index 0000000..7b9e976
--- /dev/null
+++ b/gdb/gdb.ideas
@@ -0,0 +1,694 @@
+BABYL OPTIONS:
+Version: 5
+Labels:
+Note:   This is the header of an rmail file.
+Note:   If you are seeing it in rmail,
+Note:    it means the file has no messages in it.
+
+From: mly@MICHAEL.AI.MIT.EDU (Richard Mlynarik)
+To: rms@prep.ai.mit.edu
+Subject: gdb suggestions (from hpux cdb)
+Reply-To: mly-prep@prep.ai.mit.edu
+
+"find-bug" command says "I can see the problem, but it will do you
+good to find it yourself"
+
+The gdb manual should explicitly state that gdb has no control over
+forked (or execed or whatever) subprocesses.
+
+I'd still like it if "delete" said what it had done.
+
+
+Date: Tuesday, 13 May 1986, 00:40-EDT
+From: <rms@LMI-ANGEL>
+Sender: JC@LMI-ANGEL
+Subject: interesting sdb features
+To: rms@angel
+
+output format p = pointer to procedure.
+
+foo/x or foo/4x uses size of foo as size to print.
+
+foo[1;4] to get elements 1 thru 4.
+
+Continue to specified line number.
+
+Interactively delete all breakpoints (asking about each one).
+
+
+
+Command to write backtrace into a file, or even better to duplicate all
+output to a file.  This could work by playing with descriptor 1,
+making it a pipe to `tee'.  The original descriptor 1 is saved and
+this mode can be turned off by putting it back.
+  Date: Wed, 18 Feb 87 15:37:14 EST
+  From: rms (Richard M. Stallman)
+  Message-Id: <8702182037.AA16492@prep.ai.mit.edu>
+  To: mly-prep@prep.ai.mit.edu
+  In-Reply-To: <8702181913.AA16118@prep.ai.mit.edu>
+  Subject: gdb "photo" command
+
+  I don't think all this is worth the trouble to do now,
+  because the right way to do it on TRIX is totally different
+  and much easier.
+
+
+Commands to enable and disable the autodisplays.  Associate
+autodisplays with breakpoints perhaps, so they only display
+at those breakpoints; this is easier than using breakpoint commands.
+
+Remember how each breakpoint's position was specified.
+Have command to reread symbol table and respecify each
+breakpoint using same args (line number or function name) as before.
+
+Have way to proceed process in background so that can then suspend
+gdb but have subprocess continue
+
+
+Date: Fri, 24 Jul 87 21:30:25 EDT
+From: phr@PREP.AI.MIT.EDU (Paul Rubin)
+To: bug-gdb@PREP.AI.MIT.EDU
+
+After rereading the symbol table when user runs the "symbol-file"
+command, when GDB notices that some of the source files are newer
+it should reload them rather than just printing a message saying
+they are newer.
+
+
+
+Message-Id: <8704171941.AA05045@orville.arpa>
+To: mly@prep.ai.mit.edu
+Cc: raible@orville.arpa, fouts@orville.arpa, creon@orville.arpa
+Subject: gdb hack/questions, etc
+Date: 17 Apr 87 11:41:42 PST (Fri)
+From: raible@orville.arpa
+
+
+A couple of things:
+
+1) Will gdb ever get dbx-sytly tracing?  Wouldn't it be fairly easy to add?
+
+2) How about an xemacs gdb mode which has various windows, perhaps using
+   terminal.el for generality?
+
+3) Any word about that stupid IRIS SIGIOT problem?  Do you know of anyone
+   else who has gotten IRIS subprocesses to work more reliably?
+
+4) Below is a hack adapted from ramsdell@linus.uucp which can be pretty
+   useful in gdb.  Instead of using gdb to patch extensive changes to a
+   particular function, you can do the following (assuming the 50 lines
+   of code below is part of your executable):
+	1) create a new file (foo.c) containing the new function
+	2) run cc -c foo.c
+	3) in gdb, and patch in the new function as follows:
+
+(gdb) info breakpoints
+/* Load in the new object code... */
+#1   y  0x00000125  in main (dyn.c line 46)
+	break only if $function = funload ("foo"), 1
+	silent
+	echo new code for func ($function) initialized\n
+	cont
+
+/* ...and use it instead of the old code. */
+#2   y  0x000001c2  in func (dyn.c line 59)
+	break only if $ret = $function (a), 1
+	silent
+	set a = $ret
+	j 60		/* func has a return on line 60 */
+
+	This is more complicated than it has to be because of 2 bugs in v2.1:
+	1) function calls in a breakpoint command list seem to abort
+	   the execution of the rest of the command list.  This is
+	   why all function calls are in the conditional part.
+	   (gdb reference manual section 5.5).
+
+	2) A 'return' in a command list also aborts the execution, and
+	   in addition, prompts you for a y/n.
+	   (gdb reference manual section 11.1).
+
+	On the other hand, after doing 'cc -c foo.c' (which is pretty fast),
+	you can simply rerun your program to check out the changes.
+	This can be a big win!
+
+The code for this is included below (compile with cc -g):
+========================================================
+
+#include <stdio.h>
+#include <a.out.h>
+
+typedef int (*intfun)();
+char *myname;
+
+intfun funload (filename)	/* Dynamically load 1st function from a .o */
+     char *filename;
+{
+  int fd, size;
+  struct exec hdr;
+  char buf[100];
+  intfun fun;
+
+  /* -A => incremental loading - use dyn as the base symbol table
+     -T => set the text segment origin to the following hex address
+     -N => magic number 407 (text not read-only)
+  */
+  sprintf (buf, "ld -A %s -T %x -N %s.o -o %s -lc",
+	   myname, sbrk (0), filename, filename);
+
+  /* NOTE: if anything mallocs space between here and below, this will fail */
+  system (buf);
+
+  fd = open (filename, 0);
+  read (fd, &hdr, sizeof(hdr));
+  size = hdr.a_text + hdr.a_data + hdr.a_bss;
+
+  if ((fun = (intfun) sbrk (size)) < 0)
+    printf ("Couldn't find the space"), exit();
+
+  read (fd, fun, size);		/* Load code. */
+  /* NOTE: if anything mallocs space between here and above, this will fail */
+
+  close (fd);
+  return ((intfun) fun);
+}
+  
+main (argc, argv)
+     char **argv;
+{
+  intfun fun1, fun2;
+
+  myname = *argv;
+
+  fun1 = funload("fun1");
+  printf ("The answer is %d.\n", (*fun1)(11) );
+
+  fun2 = funload("fun2");
+  printf ("The answer is %d.\n", (*fun2)() );
+}
+1,edited,,
+Received: by PREP.AI.MIT.EDU; Tue, 16 Jun 87 03:12:54 EDT
+Date: Tue, 16 Jun 87 03:12:54 EDT
+From: rms (Richard M. Stallman)
+Message-Id: <8706160712.AA07910@prep.ai.mit.edu>
+To: rms
+Subject: GDB ideas
+
+*** EOOH ***
+Date: Tue, 16 Jun 87 03:12:54 EDT
+From: rms (Richard M. Stallman)
+To: rms
+Subject: GDB ideas
+
+* Within a user-defined command, have local convenience variables,
+local functions, local defined commands.
+
+** Optionally echo commands within a user-defined command.
+
+** Optionally record all user-typed commands in a log file.
+Optionally record GDB output there too, marked as output so it
+will not be executed if replayed.
+
+* Execution commands
+
+** Step until next branch, or next call.
+(finish is step until next return).
+
+step branch
+or should it be
+continue branch
+
+** Stop on any branch, call or return
+affecting ordinary step and continue commands.
+
+stop branch
+
+** Trace all branches, calls, returns.
+This could be done by stopping on those events
+and having a continue command to be executed after.
+
+stop branch
+commands branch
+continue
+end
+
+** Commands to continue or step without any display after stop.
+These may be useful in user-defined commands.
+
+Have one prefix command that does this, modifying whatever other
+command you might use.  For example,
+
+silent step 5
+silent cont
+
+** Clear all breakpoint ignore-counts when inferior exits or is killed.
+
+** Trace changes to a location (watchpoint).
+Enable and disable them.
+
+** Info command to show command-line for running the program.
+
+* Auto-display
+
+** Enable and disable display expressions.
+Allow syntax 1d, 2d, etc. in enable, disable and delete commands.
+Then there is no more need for an undisplay command.
+
+** Displaying an auto variable should not do it in the wrong stack frame.
+Either it should search for the proper stack frame to apply to
+or it should deactivate itself when in the wrong frame.
+
+* Printing
+
+** Print an address as <file:line>+offset.
+
+** Abbreviate initial whitespace modulo 16.
+
+** p/x of an array should print each element with /x.
+
+** Change the stack scan so that it has a more general idea
+of what info is needed to describe a frame fully.
+
+* Expressions
+
+** Array slices.  Can replace @.
+
+** %name for use of symbol names containing funny characters.
+
+** User-defined convenience functions that can appear in expressions.
+
+** Expression syntax to convert line number to address.
+
+** Expression syntax to specify a name scope with an address, line number
+or frame number.
+
+Use the line number by itself, or an address with *, just as in b or l cmd:
+38:foo or *0x40a:foo.  No good; the latter would be parsed as
+*(0x40a:foo).
+
+** Expression syntax to convert a frame number to its pc.
+Perhaps unary %.
+
+* Possible bugs
+
+** Does set $pc= cause the current scope to be recalculated?
+It should.
+
+1,,
+Received: by PREP.AI.MIT.EDU; Wed, 17 Jun 87 09:59:37 EDT
+From: phr@ATHENA.MIT.EDU
+Received: by ATHENA (5.45/4.7)
+	id AA09084; Wed, 17 Jun 87 08:54:36 EDT
+Received: by ORPHEUS.MIT.EDU (5.45/4.7) id AA02565; Wed, 17 Jun 87 08:54:29 EDT
+Date: Wed, 17 Jun 87 08:54:29 EDT
+Message-Id: <8706171254.AA02565@ORPHEUS.MIT.EDU>
+To: rms@prep.ai.mit.edu
+Subject: gdb suggestion
+Status: RO
+
+*** EOOH ***
+From: phr@ATHENA.MIT.EDU
+Date: Wed, 17 Jun 87 08:54:29 EDT
+To: rms@prep.ai.mit.edu
+Subject: gdb suggestion
+
+Completion of file and function names; e.g. typing
+	break XWriteBi
+prints
+	No such symbol: XWriteBi.
+	Setting default command to "break XWriteBitmapFile"
+so you can set a break at XWriteBitmapFile by hitting return a second
+time.  Other interfaces ("complete to XWriteBitmapFile? (y/n)")
+are also possible.
+
+
+1,edited,,
+Received: by PREP.AI.MIT.EDU; Wed, 24 Sep 86 16:33:11 EDT
+Date: Wed, 24 Sep 86 16:33:11 EDT
+From: mly (Richard Mlynarik)
+Message-Id: <8609242033.AA11520@prep.ai.mit.edu>
+To: rms
+Cc: mly-prep
+Subject: gdb gripes/suggestions/requests
+
+*** EOOH ***
+Date: Wed, 24 Sep 86 16:33:11 EDT
+From: mly (Richard Mlynarik)
+To: rms
+Cc: mly-prep
+Subject: gdb gripes/suggestions/requests
+
+If would be really nice to have some way to do conditionals in user
+  commands -- though this is really stretching the functionality of
+  gdb a little too much, perhaps.  (see ~mly/e/.gdbint for some of
+  the contortions I go through with || to get conditional
+  evaluation...)
+
+A -real- win wuold be some way to execute until he next function-call
+  (like c-d in the cadr debugger)  This would even be useful if it
+  were rather slow -- it would probably be faster than setting
+  temporary breakpoints in all the functions which might be called,
+  and would certainly be faster than "step"ping one's way until a
+  funcall happened.
+
+"info source" should mention what the directory search-path is (ie
+  what "info dir" says) and in which directory it found each of the
+  source files (and which source files it cannot locate in the
+  search-path)
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA22869; Thu, 22 Oct 87 09:50:30 PDT
+Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Thu, 22 Oct 87 12:17:59 EDT
+Received: by PREP.AI.MIT.EDU; Thu, 22 Oct 87 12:21:00 EDT
+Received: from pp.mcc.com by MCC.COM with TCP; Thu 22 Oct 87 10:54:41-CDT
+Posted-Date: Thu, 22 Oct 87 10:55:13 CDT
+Received: from big-d.aca.mcc.com by pp.mcc.com (4.12/KA70822) 
+	id AA16571; Thu, 22 Oct 87 10:55:19 cdt
+Return-Path: <tiemann@big-d.aca.mcc.com>
+Received: by big-d.aca.mcc.com (3.2/KA70106)
+	id AA04247; Thu, 22 Oct 87 10:55:13 CDT
+Date: Thu, 22 Oct 87 10:55:13 CDT
+From: tiemann%pp.mcc.com@mcc.com (Michael Tiemann)
+Message-Id: <8710221555.AA04247@big-d.aca.mcc.com>
+To: bug-gdb@prep.ai.mit.edu
+Subject: expanding file names
+
+*** EOOH ***
+Posted-Date: Thu, 22 Oct 87 10:55:13 CDT
+Return-Path: <tiemann@big-d.aca.mcc.com>
+Date: Thu, 22 Oct 87 10:55:13 CDT
+From: tiemann%pp.mcc.com@mcc.com (Michael Tiemann)
+To: bug-gdb@prep.ai.mit.edu
+Subject: expanding file names
+
+When running a program, gdb thoughtfully passes the argument list
+through the shell, expanding files and environment variables as
+needed.  It would be nice if the same facility were added to the
+command which adds directories to search paths.  For example, it would
+be nice to say "dir ~/foo" .
+
+Michael
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA25075; Fri, 23 Oct 87 10:42:52 PDT
+Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Fri, 23 Oct 87 13:39:37 EDT
+Received: by PREP.AI.MIT.EDU; Fri, 23 Oct 87 13:42:53 EDT
+Received: from relay2.cs.net by RELAY.CS.NET id ac11193; 23 Oct 87 13:03 EDT
+Received: from umb.edu by RELAY.CS.NET id ac05949; 23 Oct 87 13:01 EDT
+Received: by umb.umb.edu; Fri, 23 Oct 87 10:18:40 EDT
+Received: by ileaf.uucp (1.1/SMI-3.0DEV3)
+	id AA00599; Wed, 21 Oct 87 10:56:52 EDT
+Received: from marvin.io.uucp by io.uucp (1.1/SMI-3.0DEV3)
+	id AA01359; Wed, 21 Oct 87 10:58:45 EDT
+Received: by marvin.io.uucp (3.2/SMI-3.2)
+	id AA00334; Wed, 21 Oct 87 11:02:20 EDT
+Date: Wed, 21 Oct 87 11:02:20 EDT
+From: Mark Dionne <io!marvin!md%ileaf.uucp%umb.umb.edu@relay.cs.net>
+Message-Id: <8710211502.AA00334@marvin.io.uucp>
+To: ileaf!umb!bug-gdb@prep.ai.mit.edu
+Subject: gdb bug
+
+*** EOOH ***
+Date: Wed, 21 Oct 87 11:02:20 EDT
+From: Mark Dionne <io!marvin!md%ileaf.uucp%umb.umb.edu@relay.cs.net>
+To: ileaf!umb!bug-gdb@prep.ai.mit.edu
+Subject: gdb bug
+
+The /FMT and @ options of the "print" command seem to interact
+in GDB 2.1. For example:
+
+(gdb) p ($cmpn.buf[-1])@($cmpn.gapb - $cmpn.buf + 1)
+$17 = {-16383, -24285, 55, 27944, -24285, -24285, 55, 28010, -24285,
+-24285, 55, 28076, -24285, -24285, 55, 28142, -24285}
+(gdb) p/x ($cmpn.buf[-1])@($cmpn.gapb - $cmpn.buf + 1)
+$18 = 0xc001
+
+I guess I see what's happening: the /x is applying to the whole
+array rather than to the individual elements. Feature or bug?
+
+	...!harvard!umb!ileaf!md	Mark Dionne, Interleaf
+	  ...!sun!sunne!ileaf!md	Ten Canal Park, Cambridge, MA 02141
+					(617) 577-9813 x5551
+
+
+
+1,,
+Received: by PREP.AI.MIT.EDU; Sun, 6 Sep 87 14:27:19 EDT
+Message-Id: <8709061827.AA18170@prep.ai.mit.edu>
+Received: from relay2.cs.net by RELAY.CS.NET id af03990; 6 Sep 87 14:22 EDT
+Received: from umb.edu by RELAY.CS.NET id ab03029; 6 Sep 87 14:16 EDT
+Received: by umb.umb.edu; Sun, 6 Sep 87 12:10:34 EDT
+Date: Sun, 6 Sep 87 12:10:34 EDT
+Received: by typo.umb.edu; Sun, 6 Sep 87 12:04:21 EDT
+From: Robert Morris <ram%typo.umb.edu@RELAY.CS.NET>
+To: bug-gdb@PREP.AI.MIT.EDU
+Subject: convenient script
+
+*** EOOH ***
+Date: Sun, 6 Sep 87 12:10:34 EDT
+From: Robert Morris <ram%typo.umb.edu@RELAY.CS.NET>
+To: bug-gdb@PREP.AI.MIT.EDU
+Subject: convenient script
+
+I find it easier to maintain binaries on our heterogenous
+network if I keep this trivial script in gdb source directory. Use it
+if you want.
+
+
+------------
+
+#! /bin/csh -f
+#	SETUP
+#	setup gdb files for presently known machines
+#	ram@umb.edu 
+#		(ram%umb.edu@relay.cs.net if you have an incomplete mailer)
+#	or ...!harvard!umb!ram
+#
+#	e.g.     SETUP sun3
+#	note that sunX means major release X of sun software, generally
+#	sun3 at this writing (gnu 18.41)
+#
+#	note GDB with gnuemacs 18.41 is already configured for vaxen
+
+#		Bob Morris, UMASS-Boston 9/6/87
+switch ($1)
+	case "sun2":
+		;
+	case "sun3" : 
+		set cputype="m68k";
+		set inittype="suninit";
+		breaksw;
+	default : 
+		set cputype=$1;
+		set inittype=$1init;
+		breaksw;
+endsw
+echo \#include \"m-$1.h\" > param.h
+echo \#include \"$cputype-pinsn.c\" > pinsn.c
+ed initialize.h <<! >& /dev/null
+/init.h/
+c
+#include "m-$inittype.h"
+.
+w
+q
+!
+
+
+
+
+1,answered,,
+Received: from prep.ai.mit.edu by wheaties.ai.mit.edu; Sat, 19 Dec 87 18:18:50 EST
+Received: by PREP.AI.MIT.EDU; Sat, 19 Dec 87 18:24:38 EST
+Received: from big-d.aca.mcc.com by MCC.COM with TCP; Sat 19 Dec 87 17:19:48-CST
+Date: Sat, 19 Dec 87 17:19:41 CST
+From: tiemann@mcc.com (Michael Tiemann)
+Posted-Date: Sat, 19 Dec 87 17:19:41 CST
+Message-Id: <8712192319.AA26775@big-d.aca.mcc.com>
+Received: by big-d.aca.mcc.com (3.2/ACA-V2.1) 
+	id AA26775; Sat, 19 Dec 87 17:19:41 CST
+To: rms@prep.ai.mit.edu
+Subject: gdb
+
+*** EOOH ***
+Date: Sat, 19 Dec 87 17:19:41 CST
+From: tiemann@mcc.com (Michael Tiemann)
+Posted-Date: Sat, 19 Dec 87 17:19:41 CST
+To: rms@prep.ai.mit.edu
+Subject: gdb
+
+file values.c, function unpack_field_as_long:
+
+  val &= (1 << bitsize) - 1;
+
+This is not as machine independent as it could be.  If you feel like
+fixing this potential problem, there are many other instances to worry
+about.
+
+Michael
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA04771; Thu, 20 Aug 87 22:33:25 PDT
+Received: from [128.52.22.14] by ucbvax.Berkeley.EDU (5.58/1.27)
+	id AA07119; Thu, 20 Aug 87 00:37:04 PDT
+Received: by PREP.AI.MIT.EDU; Thu, 20 Aug 87 03:37:35 EDT
+Date: Thu, 20 Aug 87 03:37:35 EDT
+From: rms@prep.ai.mit.edu (Richard M. Stallman)
+Message-Id: <8708200737.AA15589@prep.ai.mit.edu>
+To: rms@prep.ai.mit.edu
+Subject: GDB changes for next version
+
+*** EOOH ***
+Date: Thu, 20 Aug 87 03:37:35 EDT
+From: rms@prep.ai.mit.edu (Richard M. Stallman)
+To: rms@prep.ai.mit.edu
+Subject: GDB changes for next version
+
+1. Use links, rather than editing some files, to configure it.
+
+2. Can misc functions eval as their addresses rather than as
+ a char in that address?  Is this reasonable in all cases
+ given that non-functions cannot be distinguished
+ and that you might use the result in various ways (arithmetic, etc.).
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA09136; Sat, 29 Aug 87 02:20:15 PDT
+Received: from PREP.AI.MIT.EDU by ucbvax.Berkeley.EDU (5.58/1.27)
+	id AA26072; Sat, 29 Aug 87 02:21:51 PDT
+Received: by PREP.AI.MIT.EDU; Sat, 29 Aug 87 05:22:30 EDT
+Received: by RUTGERS.EDU (5.54/1.14) with UUCP 
+	id AA22247; Sat, 29 Aug 87 05:21:13 EDT
+Received: from sequent.UUCP by spool.wisc.edu; Sat, 29 Aug 87 04:18:41 CDT
+Received: from reed.UUCP by ogcvax.OGC.EDU (5.51/OGC_4.8)
+		id AA08044; Fri, 28 Aug 87 20:06:41 PDT
+Received: by reed.UUCP (5.51/5.17)
+	id AA05059; Fri, 28 Aug 87 19:19:15 PDT
+From: uwvax!sequent!ogcvax!reed!keith@rutgers.edu (Keith Packard)
+Message-Id: <8708290219.AA05059@reed.UUCP>
+To: rms@prep.ai.mit.edu
+Subject: Re: GDB 
+In-Reply-To: Your message of Thu, 20 Aug 87 03:39:37 EDT.
+             <8708200735.AA26546@EDDIE.MIT.EDU> 
+Date: Fri, 28 Aug 87 19:19:13 PDT
+
+*** EOOH ***
+From: uwvax!sequent!ogcvax!reed!keith@rutgers.edu (Keith Packard)
+To: rms@prep.ai.mit.edu
+Subject: Re: GDB 
+In-Reply-To: Your message of Thu, 20 Aug 87 03:39:37 EDT.
+             <8708200735.AA26546@EDDIE.MIT.EDU> 
+Date: Fri, 28 Aug 87 19:19:13 PDT
+
+
+Here is a simple test program for exibiting the trouble with signals:
+
+-----
+# include	<signal.h>
+
+main ()
+{
+	int	handle ();
+	int	i;
+	signal (SIGALRM, handle);
+	alarm (5);
+	for (i = 0; i < 100000; i++)
+		printf ("%d\n", i);
+}
+
+handle ()
+{
+	printf ("signal!\n");
+	alarm (5);
+}
+-----
+
+To demonstrate the problem, simply place a breakpoint before the call to
+alarm and then start stepping through the program:
+
+(gdb) break 7
+(gdb) step
+...
+...
+
+Eventually, the alarm call occurs and the program ends up in some
+signal handling code -- unfortuantely a machine dependent location.  At this
+point, because the fp has moved out of the current function (in fact on
+many machines the frame is not in a consistent state at this point) gdb
+assumes that a new function has started and suspends execution with another
+prompt.
+
+A reasonable solution would be to have gdb insert a breakpoint at the
+expected signal return address and continue to that breakpoint -- I've
+implemented this and found that it works.  There is, however, one nasty
+problem -- longjmp around the suspended frame and the breakpoint is not hit
+at the expected time.
+
+Have fun...
+
+keith packard
+
+tektronix!reed!keith
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA09143; Sat, 29 Aug 87 02:24:58 PDT
+Received: by neptune.Berkeley.EDU (5.57/1.25)
+	id AA03738; Sat, 29 Aug 87 02:24:50 PDT
+Date: Sat, 29 Aug 87 02:24:50 PDT
+From: rms@neptune.berkeley.edu (Richard Stallman)
+Message-Id: <8708290924.AA03738@neptune.Berkeley.EDU>
+To: rms@neptune.Berkeley.EDU
+Subject: GDB bug
+Reply-To: rms@prep.ai.mit.edu
+
+*** EOOH ***
+Date: Sat, 29 Aug 87 02:24:50 PDT
+From: rms@neptune.berkeley.edu (Richard Stallman)
+To: rms@neptune.Berkeley.EDU
+Subject: GDB bug
+Reply-To: rms@prep.ai.mit.edu
+
+Is there any way to make GDB, when stepping across a function call,
+notice any attempt to longjump out of that call?
+Perhaps an implicit breakpoint at longjump.
+If longjump is called, find the pc in the jmp_buf and put
+a self-deleting breakpoint there.
+
+
+1,,
+Received: by xcssun.Berkeley.EDU (5.57/1.25)
+	id AA07976; Fri, 28 Aug 87 09:26:12 PDT
+Received: from PREP.AI.MIT.EDU by ucbvax.Berkeley.EDU (5.58/1.27)
+	id AA03230; Fri, 28 Aug 87 09:28:04 PDT
+Received: by PREP.AI.MIT.EDU; Fri, 28 Aug 87 12:28:43 EDT
+Date: Fri, 28 Aug 87 12:28:43 EDT
+From: phr@prep.ai.mit.edu (Paul Rubin)
+Message-Id: <8708281628.AA09926@prep.ai.mit.edu>
+To: rms@prep.ai.mit.edu
+Subject: gdb suggestions
+
+*** EOOH ***
+Date: Fri, 28 Aug 87 12:28:43 EDT
+From: phr@prep.ai.mit.edu (Paul Rubin)
+To: rms@prep.ai.mit.edu
+Subject: gdb suggestions
+
+1. I wish gdb had a command to re-read the sources so that I can edit
+the program and recompile it without having to kill and restart gdb.
+
+2. Would be nice if gdb could somehow connect the subprocess's tty channels
+to a pty, so I can run gdb in an X window and the subprocess in a different
+(xterm) window.
+
+This might need hair to detect if the subprocess is running when you try
+to examine variables, etc. and stop the subproc or report an error if it is.
+
+
\ No newline at end of file
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
new file mode 100644
index 0000000..f2a9944
--- /dev/null
+++ b/gdb/infcmd.c
@@ -0,0 +1,927 @@
+/* Memory-access and commands for inferior process, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "param.h"
+#include "frame.h"
+#include "inferior.h"
+#include "environ.h"
+#include "value.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <sys/param.h>
+
+#ifdef mac_aux
+/* Warning!  This table is positional and highly dependent on the local
+   system.  Check it closely against <sys/signal.h> when porting. */
+char *sys_siglist[] = {
+	"Signal 0",
+	"Hangup",
+	"Interrupt",
+	"Quit",
+	"Invalid instruction",
+	"Trace/breakpoint trap",
+	"IOT trap",
+	"EMT trap",
+	"Floating point exception",
+	"Killed",
+	"Bus error",
+	"Segmentation fault",
+	"Bad system call",
+	"Broken pipe",
+	"Alarm clock",
+	"Terminated",
+	"User signal 1",
+	"User signal 2",
+	"Child exited",
+	"Power-fail restart",
+	"Stopped",
+	"Stopped (tty input)",
+	"Stopped (tty output)",
+	"Stopped (signal)",
+	"Cputime limit exceeded",
+	"File size limit exceeded",
+	"Virtual timer expired",
+	"Profiling timer expired",
+	"Window changed",
+	"Continued",
+	"Urgent I/O condition",
+	"I/O possible",
+};
+#else
+/* More portable systems do it for you */
+extern char *sys_siglist[];
+#endif
+
+#define ERROR_NO_INFERIOR \
+   if (inferior_pid == 0) error ("The program is not being run.");
+
+/* String containing arguments to give to the program,
+   with a space added at the front.  Just a space means no args.  */
+
+static char *inferior_args;
+
+/* File name for default use for standard in/out in the inferior.  */
+
+char *inferior_io_terminal;
+
+/* Pid of our debugged inferior, or 0 if no inferior now.  */
+
+int inferior_pid;
+
+/* Last signal that the inferior received (why it stopped).  */
+
+int stop_signal;
+
+/* Address at which inferior stopped.  */
+
+CORE_ADDR stop_pc;
+
+/* Stack frame when program stopped.  */
+
+FRAME stop_frame;
+
+/* Number of breakpoint it stopped at, or 0 if none.  */
+
+int stop_breakpoint;
+
+/* Nonzero if stopped due to a step command.  */
+
+int stop_step;
+
+/* Nonzero if stopped due to completion of a stack dummy routine.  */
+
+int stop_stack_dummy;
+
+/* Range to single step within.
+   If this is nonzero, respond to a single-step signal
+   by continuing to step if the pc is in this range.  */
+
+CORE_ADDR step_range_start; /* Inclusive */
+CORE_ADDR step_range_end; /* Exclusive */
+
+/* Stack frame address as of when stepping command was issued.
+   This is how we know when we step into a subroutine call,
+   and how to set the frame for the breakpoint used to step out.  */
+
+CORE_ADDR step_frame;
+
+/* 1 means step over all subroutine calls.
+   -1 means step over calls to undebuggable functions.  */
+
+int step_over_calls;
+
+/* If stepping, nonzero means step count is > 1
+   so don't print frame next time inferior stops
+   if it stops due to stepping.  */
+
+int step_multi;
+
+/* Environment to use for running inferior,
+   in format described in environ.h.  */
+
+struct environ *inferior_environ;
+
+CORE_ADDR read_pc ();
+struct command_line *get_breakpoint_commands ();
+
+START_FILE
+
+int
+have_inferior_p ()
+{
+  return inferior_pid != 0;
+}
+
+static void 
+set_args_command (args)
+     char *args;
+{
+  free (inferior_args);
+  if (!args) args = "";
+  inferior_args = concat (" ", args, "");
+}
+  
+void
+tty_command (file)
+     char *file;
+{
+  if (file == 0)
+    error_no_arg ("terminal name for running target process");
+
+  inferior_io_terminal = savestring (file, strlen (file));
+}
+
+static void
+run_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  extern char **environ;
+  register int i;
+  char *exec_file;
+  char *allargs;
+
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+
+  dont_repeat ();
+
+  if (inferior_pid)
+    {
+      if (query ("The program being debugged has been started already.\n\
+Start it from the beginning? "))
+	kill_inferior ();
+      else
+	error ("Program already started.");
+    }
+
+  if (args)
+    set_args_command (args);
+
+  exec_file = (char *) get_exec_file ();
+  if (from_tty)
+    {
+      printf ("Starting program: %s%s\n",
+	      exec_file, inferior_args);
+      fflush (stdout);
+    }
+
+  allargs = concat ("exec ", exec_file, inferior_args);
+  inferior_pid = create_inferior (allargs, environ_vector (inferior_environ));
+
+  clear_proceed_status ();
+
+  start_inferior ();
+}
+
+void
+cont_command (proc_count_exp, from_tty)
+     char *proc_count_exp;
+     int from_tty;
+{
+  ERROR_NO_INFERIOR;
+
+  clear_proceed_status ();
+
+  /* If have argument, set proceed count of breakpoint we stopped at.  */
+
+  if (stop_breakpoint && proc_count_exp)
+    {
+      set_ignore_count (stop_breakpoint,
+			parse_and_eval_address (proc_count_exp) - 1,
+			from_tty);
+      if (from_tty)
+	printf ("  ");
+    }
+
+  if (from_tty)
+    printf ("Continuing.\n");
+
+  proceed (-1, -1, 0);
+}
+
+/* Step until outside of current statement.  */
+static void step_1 ();
+
+static void
+step_command (count_string)
+{
+  step_1 (0, 0, count_string);
+}
+
+/* Likewise, but skip over subroutine calls as if single instructions.  */
+
+static void
+next_command (count_string)
+{
+  step_1 (1, 0, count_string);
+}
+
+/* Likewise, but step only one instruction.  */
+
+static void
+stepi_command (count_string)
+{
+  step_1 (0, 1, count_string);
+}
+
+static void
+nexti_command (count_string)
+{
+  step_1 (1, 1, count_string);
+}
+
+static void
+step_1 (skip_subroutines, single_inst, count_string)
+     int skip_subroutines;
+     int single_inst;
+     char *count_string;
+{
+  register int count = 1;
+
+  ERROR_NO_INFERIOR;
+  count = count_string ? parse_and_eval_address (count_string) : 1;
+
+  for (; count > 0; count--)
+    {
+      clear_proceed_status ();
+
+      step_frame = get_current_frame ();
+
+      if (! single_inst)
+	{
+	  find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
+	  if (step_range_end == 0)
+	    {
+	      terminal_ours ();
+	      error ("Current function has no line number information.");
+	    }
+	}
+      else
+	{
+	  /* Say we are stepping, but stop after one insn whatever it does.
+	     Don't step through subroutine calls even to undebuggable functions.  */
+	  step_range_start = step_range_end = 1;
+	  if (!skip_subroutines)
+	    step_over_calls = 0;
+	}
+
+      if (skip_subroutines)
+	step_over_calls = 1;
+
+      step_multi = (count > 1);
+      proceed (-1, -1, 1);
+      if (! stop_step)
+	break;
+    }
+}
+
+/* Continue program at specified address.  */
+
+static void
+jump_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  register CORE_ADDR addr;
+  struct symtab_and_line sal;
+
+  ERROR_NO_INFERIOR;
+
+  if (!arg)
+    error_no_arg ("starting address");
+
+  sal = decode_line_spec (arg, 1);
+
+  if (sal.symtab == 0 && sal.pc == 0)
+    error ("No source file has been specified.");
+
+  if (sal.pc == 0)
+    sal.pc = find_line_pc (sal.symtab, sal.line);
+
+  {
+    struct symbol *fn = get_frame_function (get_current_frame ());
+    struct symbol *sfn = find_pc_function (sal.pc);
+    if (fn != 0 && sfn != fn
+	&& ! query ("That is not in function %s.  Continue there? ",
+		    sal.line, SYMBOL_NAME (fn)))
+      error ("Not confirmed.");
+  }
+
+  if (sal.pc == 0)
+    error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
+
+  addr = sal.pc;
+
+  clear_proceed_status ();
+
+  if (from_tty)
+    printf ("Continuing at 0x%x.\n", addr);
+
+  proceed (addr, 0, 0);
+}
+
+/* Continue program giving it specified signal.  */
+
+static void
+signal_command (signum_exp, from_tty)
+     char *signum_exp;
+     int from_tty;
+{
+  register int signum;
+
+  dont_repeat ();		/* Too dangerous.  */
+  ERROR_NO_INFERIOR;
+
+  if (!signum_exp)
+    error_no_arg ("signal number");
+
+  signum = parse_and_eval_address (signum_exp);
+
+  clear_proceed_status ();
+
+  if (from_tty)
+    printf ("Continuing with signal %d.\n", signum);
+
+  proceed (stop_pc, signum, 0);
+}
+
+/* Execute a "stack dummy", a piece of code stored in the stack
+   by the debugger to be executed in the inferior.
+
+   To call: first, do PUSH_DUMMY_FRAME.
+   Then push the contents of the dummy.  It should end with a breakpoint insn.
+   Then call here, passing address at which to start the dummy.
+
+   The contents of all registers are saved before the dummy frame is popped
+   and copied into the buffer BUFFER.
+
+   The dummy's frame is automatically popped whenever that break is hit.
+   If that is the first time the program stops, run_stack_dummy
+   returns to its caller with that frame already gone.
+   Otherwise, the caller never gets returned to.  */
+
+/* 4 => return instead of letting the stack dummy run.  */
+
+static int stack_dummy_testing = 0;
+
+void
+run_stack_dummy (addr, buffer)
+     CORE_ADDR addr;
+     REGISTER_TYPE *buffer;
+{
+  int saved_pc_changed = pc_changed;
+  int saved_stop_signal = stop_signal;
+  int saved_stop_pc = stop_pc;
+  int saved_stop_frame = stop_frame;
+  int saved_stop_breakpoint = stop_breakpoint;
+  int saved_stop_step = stop_step;
+  int saved_stop_stack_dummy = stop_stack_dummy;
+  FRAME saved_selected_frame;
+  int saved_selected_level;
+  struct command_line *saved_breakpoint_commands
+    = get_breakpoint_commands ();
+
+  record_selected_frame (&saved_selected_frame, &saved_selected_level);
+
+  /* Now proceed, having reached the desired place.  */
+  clear_proceed_status ();
+  if (stack_dummy_testing & 4)
+    {
+      POP_FRAME;
+      return;
+    }
+  proceed (addr, 0, 0);
+
+  if (!stop_stack_dummy)
+    error ("Cannot continue previously requested operation.");
+
+  set_breakpoint_commands (saved_breakpoint_commands);
+  select_frame (saved_selected_frame, saved_selected_level);
+  stop_signal = saved_stop_signal;
+  stop_pc = saved_stop_pc;
+  stop_frame = saved_stop_frame;
+  stop_breakpoint = saved_stop_breakpoint;
+  stop_step = saved_stop_step;
+  stop_stack_dummy = saved_stop_stack_dummy;
+  pc_changed = saved_pc_changed;
+
+  /* On return, the stack dummy has been popped already.  */
+
+  bcopy (stop_registers, buffer, sizeof stop_registers);
+}
+
+/* "finish": Set a temporary breakpoint at the place
+   the selected frame will return to, then continue.  */
+
+static void
+finish_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal;
+  register FRAME frame;
+  struct frame_info fi;
+
+  register struct symbol *function;
+
+  if (!have_inferior_p ())
+    error ("The program is not being run.");
+  if (arg)
+    error ("The \"finish\" command does not take any arguments.");
+
+  frame = get_prev_frame (selected_frame);
+  if (frame == 0)
+    error ("\"finish\" not meaningful in the outermost frame.");
+
+  clear_proceed_status ();
+
+  fi = get_frame_info (frame);
+  sal = find_pc_line (fi.pc, 0);
+  sal.pc = fi.pc;
+  set_momentary_breakpoint (sal, frame);
+
+  /* Find the function we will return from.  */
+
+  fi = get_frame_info (fi.next_frame);
+  function = find_pc_function (fi.pc);
+
+  if (from_tty)
+    {
+      printf ("Run till exit from ");
+      print_selected_frame ();
+    }
+
+  proceed (-1, -1, 0);
+
+  if (stop_breakpoint == -3 && function != 0)
+    {
+      struct type *value_type;
+      register value val;
+
+      if (TYPE_CODE (SYMBOL_TYPE (function)) != TYPE_CODE_VOID)
+	value_type = SYMBOL_TYPE (function);
+      else
+	return;
+
+      val = value_being_returned (value_type, stop_registers);
+      printf ("Value returned is $%d = ", record_latest_value (val));
+      value_print (val, stdout);
+      putchar ('\n');
+    }
+}
+
+static void
+program_info ()
+{
+  if (inferior_pid == 0)
+    {
+      printf ("The program being debugged is not being run.\n");
+      return;
+    }
+
+  printf ("Program being debugged is in process %d, stopped at 0x%x.\n",
+	  inferior_pid, stop_pc);
+  if (stop_step)
+    printf ("It stopped after being stepped.\n");
+  else if (stop_breakpoint)
+    printf ("It stopped at breakpoint %d.\n", stop_breakpoint);
+  else if (stop_signal)
+    printf ("It stopped with signal %d (%s).\n",
+	    stop_signal, sys_siglist[stop_signal]);
+
+  printf ("\nType \"info stack\" or \"info reg\" for more information.\n");
+}
+
+static void
+environment_info (var)
+     char *var;
+{
+  if (var)
+    {
+      register char *val = get_in_environ (inferior_environ, var);
+      if (val)
+	printf ("%s = %s\n", var, val);
+      else
+	printf ("Environment variable \"%s\" not defined.\n", var);
+    }
+  else
+    {
+      register char **vector = environ_vector (inferior_environ);
+      while (*vector)
+	printf ("%s\n", *vector++);
+    }
+}
+
+static void
+set_environment_command (arg)
+     char *arg;
+{
+  register char *p, *val, *var;
+
+  if (arg == 0)
+    error_no_arg ("environment variable and value");
+
+  p = (char *) index (arg, '=');
+  val = (char *) index (arg, ' ');
+  if (p != 0 && val != 0)
+    p = arg + min (p - arg, val - arg);
+  else if (val != 0 && p == 0)
+    p = val;
+
+  if (p == 0)
+    error ("Space or \"=\" must separate variable name and its value");
+  if (p[1] == 0)
+    error_no_arg ("value for the variable");
+  if (p == arg)
+    error_no_arg ("environment variable to set");
+
+  val = p + 1;
+  while (*val == ' ' || *val == '\t') val++;
+  while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) p--;
+
+  var = savestring (arg, p - arg);
+  set_in_environ (inferior_environ, var, val);
+  free (var);
+}
+
+static void
+unset_environment_command (var)
+     char *var;
+{
+  if (var == 0)
+    error_no_arg ("environment variable");
+
+  unset_in_environ (inferior_environ, var);
+}
+
+/* Read an integer from debugged memory, given address and number of bytes.  */
+
+read_memory_integer (memaddr, len)
+     CORE_ADDR memaddr;
+     int len;
+{
+  char cbuf;
+  short sbuf;
+  int ibuf;
+  long lbuf;
+
+  if (len == sizeof (char))
+    {
+      read_memory (memaddr, &cbuf, len);
+      return cbuf;
+    }
+  if (len == sizeof (short))
+    {
+      read_memory (memaddr, &sbuf, len);
+      return sbuf;
+    }
+  if (len == sizeof (int))
+    {
+      read_memory (memaddr, &ibuf, len);
+      return ibuf;
+    }
+  if (len == sizeof (lbuf))
+    {
+      read_memory (memaddr, &lbuf, len);
+      return lbuf;
+    }
+  error ("Cannot handle integers of %d bytes.", len);
+}
+
+CORE_ADDR
+read_pc ()
+{
+  return (CORE_ADDR) read_register (PC_REGNUM);
+}
+
+write_pc (val)
+     CORE_ADDR val;
+{
+  write_register (PC_REGNUM, (long) val);
+}
+
+char *reg_names[] = REGISTER_NAMES;
+
+static void
+registers_info (addr_exp)
+     char *addr_exp;
+{
+  register int i;
+  int regnum;
+
+  if (addr_exp)
+    {
+      if (*addr_exp >= '0' && *addr_exp <= '9')
+	regnum = atoi (addr_exp);
+      else
+	{
+	  register char *p = addr_exp;
+	  if (p[0] == '$')
+	    p++;
+	  for (regnum = 0; regnum < NUM_REGS; regnum++)
+	    if (!strcmp (p, reg_names[regnum]))
+	      break;
+	  if (regnum == NUM_REGS)
+	    error ("%s: invalid register name.", addr_exp);
+	}
+    }
+  else
+    printf ("Reg\tContents\n\n");
+
+  for (i = 0; i < NUM_REGS; i++)
+    {
+      unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
+      unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+      REGISTER_TYPE val;
+
+      if (addr_exp != 0 && i != regnum)
+	continue;
+
+      /* On machines with lots of registers, pause every 16 lines
+	 so user can read the output.  */
+      if (addr_exp == 0 && i > 0 && i % 16 == 0)
+	{
+	  printf ("--Type Return to print more--");
+	  fflush (stdout);
+	  read_line ();
+	}
+
+      /* Get the data in raw format, then convert also to virtual format.  */
+      read_relative_register_raw_bytes (i, raw_buffer);
+      REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
+
+      printf ("%s\t", reg_names[i]);
+
+      /* If virtual format is floating, print it that way.  */
+      if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
+	  && ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
+	val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout);
+      /* Else if virtual format is too long for printf,
+	 print in hex a byte at a time.  */
+      else if (REGISTER_VIRTUAL_SIZE (i) > sizeof (long))
+	{
+	  register int j;
+	  printf ("0x");
+	  for (j = 0; j < REGISTER_VIRTUAL_SIZE (i); j++)
+	    printf ("%02x", virtual_buffer[j]);
+	}
+      /* Else print as integer in hex and in decimal.  */
+      else
+	{
+	  long val;
+
+	  bcopy (virtual_buffer, &val, sizeof (long));
+	  if (val == 0)
+	    printf ("0");
+	  else
+	    printf ("0x%08x  %d", val, val);
+	}
+
+      /* If register has different raw and virtual formats,
+	 print the raw format in hex now.  */
+
+      if (REGISTER_CONVERTIBLE (i))
+	{
+	  register int j;
+
+	  printf ("  (raw 0x");
+	  for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+	    printf ("%02x", raw_buffer[j]);
+	  printf (")");
+	}
+      printf ("\n");
+    }
+
+  printf ("Contents are relative to selected stack frame.\n");
+}
+
+#ifdef ATTACH_DETACH
+/*
+ * TODO:
+ * Should save/restore the tty state since it might be that the
+ * program to be debugged was started on this tty and it wants
+ * the tty in some state other than what we want.  If it's running
+ * on another terminal or without a terminal, then saving and
+ * restoring the tty state is a harmless no-op.
+ */
+
+/*
+ * attach_command --
+ * takes a program started up outside of gdb and ``attaches'' to it.
+ * This stops it cold in it's tracks and allows us to start tracing
+ * it.  For this to work, we must be able to send the process a
+ * signal and we must have the same effective uid as the program.
+ */
+static void
+attach_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  char *exec_file;
+  int pid;
+
+  dont_repeat();
+
+  if (!args)
+    error_no_arg ("process-id to attach");
+  else
+    pid = atoi (args);
+
+  if (inferior_pid)
+    {
+      if (query ("A program is being debugged already.  Kill it? "))
+	kill_inferior ();
+      else
+	error ("Inferior not killed.");
+    }
+
+  exec_file = (char *) get_exec_file ();
+
+  if (from_tty)
+    {
+      printf ("Attaching program: %s pid %d\n",
+	      exec_file, pid);
+      fflush (stdout);
+    }
+
+  attach_program (pid);
+}
+
+/*
+ * detach_command --
+ * takes a program previously attached to and detaches it.
+ * The program resumes execution and will no longer stop
+ * on signals, etc.  We better not have left any breakpoints
+ * in the program or it'll die when it hits one.  For this
+ * to work, it may be necessary for the process to have been
+ * previously attached.  It *might* work if the program was
+ * started via the normal ptrace (PTRACE_TRACEME).
+ */
+
+static void
+detach_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  char *exec_file = (char *)get_exec_file ();
+  int signal = 0;
+
+  if (!inferior_pid)
+    error ("Not currently tracing a program\n");
+  if (from_tty)
+    {
+      printf ("Detaching program: %s pid %d\n",
+	      exec_file, inferior_pid);
+      fflush (stdout);
+    }
+  if (args)
+    signal = atoi (args);
+
+  detach (signal);
+  inferior_pid = 0;
+}
+#endif /* ATTACH_DETACH */
+
+static
+initialize ()
+{
+  add_com ("tty", class_run, tty_command,
+	   "Set terminal for future runs of program being debugged.");
+
+  add_com ("set-args", class_run, set_args_command,
+	   "Specify arguments to give program being debugged when it is started.\n\
+Follow this command with any number of args, to be passed to the program.");
+
+  add_info ("environment", environment_info,
+	    "The environment to give the program, or one variable's value.\n\
+With an argument VAR, prints the value of environment variable VAR to\n\
+give the program being debugged.  With no arguments, prints the entire\n\
+environment to be given to the program.");
+
+  add_com ("unset-environment", class_run, unset_environment_command,
+	   "Cancel environment variable VAR for the program.\n\
+This does not affect the program until the next \"run\" command.");
+  add_com ("set-environment", class_run, set_environment_command,
+	   "Set environment variable value to give the program.\n\
+Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
+VALUES of environment variables are uninterpreted strings.\n\
+This does not affect the program until the next \"run\" command.");
+ 
+#ifdef ATTACH_DETACH
+ add_com ("attach", class_run, attach_command,
+ 	   "Attach to a process that was started up outside of GDB.\n\
+To do this, you must have permission to send the process a signal.\n\
+And it must have the same effective uid as the debugger.\n\n\
+Before using \"attach\", you must use the \"exec-file\" command\n\
+to specify the program running in the process,\n\
+and the \"symbol-file\" command to load its symbol table.");
+  add_com ("detach", class_run, detach_command,
+	   "Detach the process previously attached.\n\
+The process is no longer traced and continues its execution.");
+#endif /* ATTACH_DETACH */
+
+  add_com ("signal", class_run, signal_command,
+	   "Continue program giving it signal number SIGNUMBER.");
+
+  add_com ("stepi", class_run, stepi_command,
+	   "Step one instruction exactly.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("si", "stepi", class_alias, 0);
+
+  add_com ("nexti", class_run, nexti_command,
+	   "Step one instruction, but proceed through subroutine calls.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("ni", "nexti", class_alias, 0);
+
+  add_com ("finish", class_run, finish_command,
+	   "Execute until selected stack frame returns.\n\
+Upon return, the value returned is printed and put in the value history.");
+
+  add_com ("next", class_run, next_command,
+	   "Step program, proceeding through subroutine calls.\n\
+Like the \"step\" command as long as subroutine calls do not happen;\n\
+when they do, the call is treated as one instruction.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("n", "next", class_run, 1);
+
+  add_com ("step", class_run, step_command,
+	   "Step program until it reaches a different source line.\n\
+Argument N means do this N times (or till program stops for another reason).");
+  add_com_alias ("s", "step", class_run, 1);
+
+  add_com ("jump", class_run, jump_command,
+	   "Continue program being debugged at specified line or address.\n\
+Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
+for an address to start at.");
+
+  add_com ("cont", class_run, cont_command,
+	   "Continue program being debugged, after signal or breakpoint.\n\
+If proceeding from breakpoint, a number N may be used as an argument:\n\
+then the same breakpoint won't break until the Nth time it is reached.");
+  add_com_alias ("c", "cont", class_run, 1);
+
+  add_com ("run", class_run, run_command,
+	   "Start debugged program.  You may specify arguments to give it.\n\
+Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
+Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
+With no arguments, uses arguments last specified (with \"run\" or \"set-args\".\n\
+To cancel previous arguments and run with no arguments,\n\
+use \"set-args\" without arguments.");
+  add_com_alias ("r", "run", class_run, 1);
+
+  add_info ("registers", registers_info,
+	    "List of registers and their contents, for selected stack frame.\n\
+Register name as argument means describe only that register.");
+
+  add_info ("program", program_info,
+	    "Execution status of the program.");
+
+  inferior_args = savestring (" ", 1); /* By default, no args.  */
+  inferior_environ = make_environ ();
+  init_environ (inferior_environ);
+}
+
+END_FILE
diff --git a/gdb/inferior.h b/gdb/inferior.h
new file mode 100644
index 0000000..21c937c
--- /dev/null
+++ b/gdb/inferior.h
@@ -0,0 +1,85 @@
+/* Variables that describe the inferior process running under GDB:
+   Where it is, why it stopped, and how to step it.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* File name for default use for standard in/out in the inferior.  */
+
+extern char *inferior_io_terminal;
+
+/* Pid of our debugged inferior, or 0 if no inferior now.  */
+
+extern int inferior_pid;
+
+/* Last signal that the inferior received (why it stopped).  */
+
+extern int stop_signal;
+
+/* Address at which inferior stopped.  */
+
+extern CORE_ADDR stop_pc;
+
+/* Stack frame when program stopped.  */
+
+extern FRAME stop_frame;
+
+/* Number of breakpoint it stopped at, or 0 if none.  */
+
+extern int stop_breakpoint;
+
+/* Nonzero if stopped due to a step command.  */
+
+extern int stop_step;
+
+/* Nonzero if stopped due to completion of a stack dummy routine.  */
+
+extern int stop_stack_dummy;
+
+/* Range to single step within.
+   If this is nonzero, respond to a single-step signal
+   by continuing to step if the pc is in this range.  */
+
+extern CORE_ADDR step_range_start; /* Inclusive */
+extern CORE_ADDR step_range_end; /* Exclusive */
+
+/* Stack frame address as of when stepping command was issued.
+   This is how we know when we step into a subroutine call,
+   and how to set the frame for the breakpoint used to step out.  */
+
+extern CORE_ADDR step_frame;
+
+/* 1 means step over all subroutine calls.
+   -1 means step over calls to undebuggable functions.  */
+
+extern int step_over_calls;
+
+/* If stepping, nonzero means step count is > 1
+   so don't print frame next time inferior stops
+   if it stops due to stepping.  */
+
+extern int step_multi;
+
+/* Save register contents here when about to pop a stack dummy frame.  */
+
+extern char stop_registers[REGISTER_BYTES];
+
+/* Nonzero if pc has been changed by the debugger
+   since the inferior stopped.  */
+
+extern int pc_changed;
diff --git a/gdb/inflow.c b/gdb/inflow.c
new file mode 100644
index 0000000..7bed594
--- /dev/null
+++ b/gdb/inflow.c
@@ -0,0 +1,661 @@
+/* Low level interface to ptrace, for GDB when running under Unix.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "frame.h"
+#include "inferior.h"
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/dir.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sgtty.h>
+#include <fcntl.h>
+
+#ifdef mac_aux
+#include <sys/seg.h>
+#include <sys/mmu.h>
+#include <sys/signal.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#else
+#include <sys/user.h>
+#endif /* mac_aux */
+
+
+#ifdef UMAX_PTRACE
+#include <a.out.h>
+#endif
+
+#ifdef NEW_SUN_PTRACE
+#include <sys/ptrace.h>
+#include <machine/reg.h>
+#endif
+
+#ifdef SYSV_TTYS
+#include <termio.h>
+#endif
+
+extern int errno;
+
+/* Nonzero if we are debugging an attached outside process
+   rather than an inferior.  */
+
+static int attach_flag;
+
+#define	UPAGE_MASK	0x00003FFF
+
+START_FILE
+
+/* Record terminal status separately for debugger and inferior.  */
+
+#ifdef SYSV_TTYS
+static struct termio ti_inferior;
+#else
+static struct sgttyb sg_inferior;
+static struct tchars tc_inferior;
+static struct ltchars ltc_inferior;
+static int lmode_inferior;
+#endif
+static int tflags_inferior;
+static int pgrp_inferior;
+
+#ifdef SYSV_TTYS
+static struct termio ti_ours;
+#else
+static struct sgttyb sg_ours;
+static struct tchars tc_ours;
+static struct ltchars ltc_ours;
+static int lmode_ours;
+#endif
+static int tflags_ours;
+static int pgrp_ours;
+
+/* Copy of inferior_io_terminal when inferior was last started.  */
+static char *inferior_thisrun_terminal;
+
+static void terminal_ours_1 ();
+
+/* Nonzero if our terminal settings are in effect.
+   Zero if the inferior's settings are in effect.  */
+static int terminal_is_ours;
+
+/* Initialize the terminal settings we record for the inferior,
+   before we actually run the inferior.  */
+
+void
+terminal_init_inferior ()
+{
+
+#ifdef SYSV_TTYS
+  ti_inferior = ti_ours;
+#else
+  sg_inferior = sg_ours;
+  tc_inferior = tc_ours;
+  ltc_inferior = ltc_ours;
+  lmode_inferior = lmode_ours;
+#endif
+  tflags_inferior = tflags_ours;
+  pgrp_inferior = inferior_pid;
+
+  terminal_is_ours = 1;
+}
+
+/* Put the inferior's terminal settings into effect.
+   This is preparation for starting or resuming the inferior.  */
+
+void
+terminal_inferior ()
+{
+  if (terminal_is_ours)   /*  && inferior_thisrun_terminal == 0) */
+    {
+      fcntl (0, F_SETFL, tflags_inferior);
+      fcntl (0, F_SETFL, tflags_inferior);
+#ifdef SYSV_TTYS
+      ioctl (0, TCSETA, &ti_inferior);
+#else
+      ioctl (0, TIOCSETN, &sg_inferior);
+      ioctl (0, TIOCSETC, &tc_inferior);
+      ioctl (0, TIOCSLTC, &ltc_inferior);
+      ioctl (0, TIOCLSET, &lmode_inferior);
+#endif
+      ioctl (0, TIOCSPGRP, &pgrp_inferior);
+    }
+  terminal_is_ours = 0;
+}
+
+/* Put some of our terminal settings into effect,
+   enough to get proper results from our output,
+   but do not change into or out of RAW mode
+   so that no input is discarded.
+
+   After doing this, either terminal_ours or terminal_inferior
+   should be called to get back to a normal state of affairs.  */
+
+void
+terminal_ours_for_output ()
+{
+  terminal_ours_1 (1);
+}
+
+/* Put our terminal settings into effect.
+   First record the inferior's terminal settings
+   so they can be restored properly later.  */
+
+void
+terminal_ours ()
+{
+  terminal_ours_1 (0);
+}
+
+static void
+terminal_ours_1 (output_only)
+     int output_only;
+{
+  /* Ignore this signal since it will happen when we try to set the pgrp.  */
+  int (*osigttou) ();
+
+  if (!terminal_is_ours)  /*   && inferior_thisrun_terminal == 0)  */
+    {
+      terminal_is_ours = 1;
+
+      osigttou = signal (SIGTTOU, SIG_IGN);
+
+      ioctl (0, TIOCGPGRP, &pgrp_inferior);
+      ioctl (0, TIOCSPGRP, &pgrp_ours);
+
+      signal (SIGTTOU, osigttou);
+
+      tflags_inferior = fcntl (0, F_GETFL, 0);
+#ifdef SYSV_TTYS
+      ioctl (0, TCGETA, &ti_inferior);
+#else
+      ioctl (0, TIOCGETP, &sg_inferior);
+      ioctl (0, TIOCGETC, &tc_inferior);
+      ioctl (0, TIOCGLTC, &ltc_inferior);
+      ioctl (0, TIOCLGET, &lmode_inferior);
+#endif
+    }
+
+  fcntl (0, F_SETFL, tflags_ours);
+  fcntl (0, F_SETFL, tflags_ours);
+
+
+#ifdef SYSV_TTYS
+  ti_ours.c_lflag |= ICANON | ISIG;
+  if (output_only)
+    ti_ours.c_lflag &= ~((ICANON|ISIG)&ti_inferior.c_lflag);
+  ioctl (0, TCSETA, &ti_ours);
+  ti_ours.c_lflag |= ICANON | ISIG;
+#else
+  sg_ours.sg_flags &= ~RAW & ~CBREAK;
+  if (output_only)
+    sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags;
+  ioctl (0, TIOCSETN, &sg_ours);
+  ioctl (0, TIOCSETC, &tc_ours);
+  ioctl (0, TIOCSLTC, &ltc_ours);
+  ioctl (0, TIOCLSET, &lmode_ours);
+  sg_ours.sg_flags &= ~RAW & ~CBREAK;
+#endif
+}
+
+static void
+term_status_command ()
+{
+  register int i;
+  printf ("Inferior's terminal status (currently saved by GDB):\n");
+#ifdef SYSV_TTYS
+  printf ("fcntl flags = 0x%x, owner pid = %d.\n",
+	  tflags_inferior, pgrp_inferior);
+  printf ("iflag = 0x%04x, oflag = 0x%04x, cflag = 0x%04x, lflag = 0x%04x\n",
+	  ti_inferior.c_iflag, ti_inferior.c_oflag,
+	  ti_inferior.c_cflag, ti_inferior.c_lflag);
+  printf ("line discipline = %d\n", ti_inferior.c_line);
+  printf ("control chars: ");
+  for (i = 0; i < NCC; i++)
+    printf ("0x%x ", ti_inferior.c_cc[i]);
+  printf ("\n");
+#else
+  printf ("fcntl flags = 0x%x, lmode = 0x%x,\nsgttyb.sg_flags = 0x%x, owner pid = %d.\n",
+	  tflags_inferior, lmode_inferior,
+	  sg_inferior.sg_flags, pgrp_inferior);
+  printf ("tchars: ");
+  for (i = 0; i < sizeof (struct tchars); i++)
+    printf ("0x%x ", ((char *)&tc_inferior)[i]);
+  printf ("\n");
+  printf ("ltchars: ");
+  for (i = 0; i < sizeof (struct ltchars); i++)
+    printf ("0x%x ", ((char *)&ltc_inferior)[i]);
+  printf ("\n");
+#endif
+}
+
+static void
+new_tty (ttyname)
+     char *ttyname;
+{
+  register int tty;
+  register int fd;
+
+#if 0
+  /* I think it is better not to do this.  Then C-z on the GDB terminal
+     will still stop the program, while C-z on the data terminal
+     will be input.  */
+
+  /* Disconnect the child process from our controlling terminal.  */
+  tty = open("/dev/tty", O_RDWR);
+  if (tty > 0)
+    {
+      ioctl(tty, TIOCNOTTY, 0);
+      close(tty);
+    }
+#endif
+  /* Now open the specified new terminal.  */
+
+  tty = open(ttyname, O_RDWR);
+  if (tty == -1)
+    _exit(1);
+
+  dup2(tty, 0);
+  dup2(tty, 1);
+  dup2(tty, 2);
+  close(tty);
+}
+
+/* Start an inferior process and returns its pid.
+   ALLARGS is a vector of program-name and args.
+   ENV is the environment vector to pass.  */
+
+int
+create_inferior (allargs, env)
+     char **allargs;
+     char **env;
+{
+  int pid;
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+
+  /* exec is said to fail if the executable is open.  */
+  close_exec_file ();
+
+  pid = vfork ();
+  if (pid < 0)
+    perror_with_name ("vfork");
+
+  if (pid == 0)
+    {
+      /* Run inferior in a separate process group.  */
+      setpgrp (getpid (), getpid ());
+
+      inferior_thisrun_terminal = inferior_io_terminal;
+      if (inferior_io_terminal != 0)
+	new_tty (inferior_io_terminal);
+
+/* Not needed on Sun, at least, and loses there
+   because it clobbers the superior.  */
+/*???      signal (SIGQUIT, SIG_DFL);
+      signal (SIGINT, SIG_DFL);  */
+
+      ptrace (0);
+      execle ("/bin/sh", "sh", "-c", allargs, 0, env);
+
+      fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
+	       errno < sys_nerr ? sys_errlist[errno] : "unknown error");
+      fflush (stderr);
+      _exit (0177);
+    }
+  return pid;
+}
+
+/* Kill the inferior process.  Make us have no inferior.  */
+
+static void
+kill_command ()
+{
+  if (inferior_pid == 0)
+    error ("The program is not being run.");
+  if (!query ("Kill the inferior process? "))
+    error ("Not confirmed.");
+  kill_inferior ();
+}
+
+kill_inferior ()
+{
+  if (inferior_pid == 0)
+    return;
+  ptrace (8, inferior_pid, 0, 0);
+  wait (0);
+  inferior_died ();
+}
+
+inferior_died ()
+{
+  inferior_pid = 0;
+  attach_flag = 0;
+  mark_breakpoints_out ();
+  reopen_exec_file ();
+  if (have_core_file_p ())
+    set_current_frame (read_register (FP_REGNUM));
+}
+
+/* Resume execution of the inferior process.
+   If STEP is nonzero, single-step it.
+   If SIGNAL is nonzero, give it that signal.  */
+
+void
+resume (step, signal)
+     int step;
+     int signal;
+{
+  errno = 0;
+  ptrace (step ? 9 : 7, inferior_pid, 1, signal);
+  if (errno)
+    perror_with_name ("ptrace");
+}
+
+#ifdef NEW_SUN_PTRACE
+
+/* Start debugging the process whose number is PID.  */
+
+attach (pid)
+     int pid;
+{
+  errno = 0;
+  ptrace (PTRACE_ATTACH, pid, 0, 0);
+  if (errno)
+    perror_with_name ("ptrace");
+  attach_flag = 1;
+  return pid;
+}
+
+/* Stop debugging the process whose number is PID
+   and continue it with signal number SIGNAL.
+   SIGNAL = 0 means just continue it.  */
+
+void
+detach (signal)
+     int signal;
+{
+  errno = 0;
+  ptrace (PTRACE_DETACH, inferior_pid, 1, signal);
+  if (errno)
+    perror_with_name ("ptrace");
+  attach_flag = 0;
+}
+#endif
+
+#ifdef NEW_SUN_PTRACE
+
+void
+fetch_inferior_registers ()
+{
+  struct regs inferior_registers;
+  struct fp_status inferior_fp_registers;
+  extern char registers[];
+
+  ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
+  ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
+
+  bcopy (&inferior_registers, registers, 16 * 4);
+  bcopy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
+	 sizeof inferior_fp_registers.fps_regs);
+  *(int *)&registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
+  *(int *)&registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+  bcopy (&inferior_fp_registers.fps_control,
+	 &registers[REGISTER_BYTE (FPC_REGNUM)],
+	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+}
+
+/* Store our register values back into the inferior.
+   If REGNO is -1, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+
+store_inferior_registers (regno)
+     int regno;
+{
+  struct regs inferior_registers;
+  struct fp_status inferior_fp_registers;
+  extern char registers[];
+
+  bcopy (registers, &inferior_registers, 16 * 4);
+  bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
+	 sizeof inferior_fp_registers.fps_regs);
+  inferior_registers.r_ps = *(int *)&registers[REGISTER_BYTE (PS_REGNUM)];
+  inferior_registers.r_pc = *(int *)&registers[REGISTER_BYTE (PC_REGNUM)];
+  bcopy (&registers[REGISTER_BYTE (FPC_REGNUM)],
+	 &inferior_fp_registers.fps_control,
+	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+
+  ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
+  ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
+}
+
+#else
+
+void
+fetch_inferior_registers ()
+{
+  register int regno;
+  register unsigned int regaddr;
+  char buf[MAX_REGISTER_RAW_SIZE];
+  register int i;
+
+#ifdef UMAX_PTRACE
+  unsigned int offset = 0;
+#else
+  struct user u;
+  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
+  offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+#endif
+
+  for (regno = 0; regno < NUM_REGS; regno++)
+    {
+      regaddr = register_addr (regno, offset);
+      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+ 	{
+ 	  *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0);
+ 	  regaddr += sizeof (int);
+ 	}
+      supply_register (regno, buf);
+    }
+}
+
+/* Store our register values back into the inferior.
+   If REGNO is -1, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+
+store_inferior_registers (regno)
+     int regno;
+{
+  register unsigned int regaddr;
+  char buf[80];
+
+#ifdef UMAX_PTRACE
+  unsigned int offset = 0;
+#else
+  struct user u;
+  unsigned int offset = (char *) &u.u_ar0 - (char *) &u;
+  offset = ptrace (3, inferior_pid, offset, 0) & UPAGE_MASK;
+#endif
+
+  if (regno >= 0)
+    {
+      regaddr = register_addr (regno, offset);
+      errno = 0;
+      ptrace (6, inferior_pid, regaddr, read_register (regno));
+      if (errno != 0)
+	{
+	  sprintf (buf, "writing register number %d", regno);
+	  perror_with_name (buf);
+	}
+    }
+  else for (regno = 0; regno < NUM_REGS; regno++)
+    {
+      regaddr = register_addr (regno, offset);
+      errno = 0;
+      ptrace (6, inferior_pid, regaddr, read_register (regno));
+      if (errno != 0)
+	{
+	  sprintf (buf, "writing register number %d", regno);
+	  perror_with_name (buf);
+	}
+    }
+}
+
+#endif /* not NEW_SUN_PTRACE */
+
+/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
+   in the NEW_SUN_PTRACE case.
+   It ought to be straightforward.  But it appears that writing did
+   not write the data that I specified.  I cannot understand where
+   it got the data that it actually did write.  */
+
+/* Copy LEN bytes from inferior's memory starting at MEMADDR
+   to debugger memory starting at MYADDR.  */
+
+read_inferior_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  /* Round starting address down to longword boundary.  */
+  register CORE_ADDR addr = memaddr & - sizeof (int);
+  /* Round ending address up; get number of longwords that makes.  */
+  register int count
+    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  /* Allocate buffer of that many longwords.  */
+  register int *buffer = (int *) alloca (count * sizeof (int));
+
+  /* Read all the longwords */
+  for (i = 0; i < count; i++, addr += sizeof (int))
+    buffer[i] = ptrace (1, inferior_pid, addr, 0);
+
+  /* Copy appropriate bytes out of the buffer.  */
+  bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+}
+
+/* Copy LEN bytes of data from debugger memnory at MYADDR
+   to inferior's memory at MEMADDR.
+   On failure (cannot write the inferior)
+   returns the value of errno.  */
+
+int
+write_inferior_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  register int i;
+  /* Round starting address down to longword boundary.  */
+  register CORE_ADDR addr = memaddr & - sizeof (int);
+  /* Round ending address up; get number of longwords that makes.  */
+  register int count
+    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  /* Allocate buffer of that many longwords.  */
+  register int *buffer = (int *) alloca (count * sizeof (int));
+  extern int errno;
+
+  /* Fill start and end extra bytes of buffer with existing memory data.  */
+
+  buffer[0] = ptrace (1, inferior_pid, addr, 0);
+  if (count > 1)
+    buffer[count - 1]
+      = ptrace (1, inferior_pid,
+		addr + (count - 1) * sizeof (int), 0);
+
+  /* Copy data to be written over corresponding part of buffer */
+
+  bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+
+  /* Write the entire buffer.  */
+
+  for (i = 0; i < count; i++, addr += sizeof (int))
+    {
+      errno = 0;
+      ptrace (4, inferior_pid, addr, buffer[i]);
+      if (errno)
+	return errno;
+    }
+
+  return 0;
+}
+
+static void
+try_writing_regs_command ()
+{
+  register int i;
+  register int value;
+  extern int errno;
+
+  if (inferior_pid == 0)
+    error ("The program is not being run.");
+
+  for (i = 0; ; i += 2)
+    {
+      QUIT;
+      errno = 0;
+      value = ptrace (3, inferior_pid, i, 0);
+      ptrace (6, inferior_pid, i, value);
+      if (errno == 0)
+	{
+	  printf (" Succeeded with address 0x%x; value 0x%x (%d).\n",
+		  i, value, value);
+	}
+      else if ((i & 0377) == 0)
+	printf (" Failed at 0x%x.\n", i);
+    }
+}
+
+static
+initialize ()
+{
+  add_com ("term-status", class_obscure, term_status_command,
+	   "Print info on inferior's saved terminal status.");
+
+  add_com ("try-writing-regs", class_obscure, try_writing_regs_command,
+	   "Try writing all locations in inferior's system block.\n\
+Report which ones can be written.");
+
+  add_com ("kill", class_run, kill_command,
+	   "Kill execution of program being debugged.");
+
+  inferior_pid = 0;
+
+#ifdef SYSV_TTYS
+  ioctl (0, TCGETA, &ti_ours);
+#else
+  ioctl (0, TIOCGETP, &sg_ours);
+  ioctl (0, TIOCGETC, &tc_ours);
+  ioctl (0, TIOCGLTC, &ltc_ours);
+  ioctl (0, TIOCLGET, &lmode_ours);
+#endif
+  fcntl (0, F_GETFL, tflags_ours);
+  ioctl (0, TIOCGPGRP, &pgrp_ours);
+
+  terminal_is_ours = 1;
+}
+
+END_FILE
diff --git a/gdb/infrun.c b/gdb/infrun.c
new file mode 100644
index 0000000..e980cec
--- /dev/null
+++ b/gdb/infrun.c
@@ -0,0 +1,943 @@
+/* Start and stop the inferior process, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+#include "inferior.h"
+#include "wait.h"
+
+#include <stdio.h>
+#include <signal.h>
+#include <a.out.h>
+
+#ifdef UMAX_PTRACE
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#endif UMAX_PTRACE
+
+extern char *sys_siglist[];
+extern int errno;
+
+/* Tables of how to react to signals; the user sets them.  */
+
+static char signal_stop[NSIG];
+static char signal_print[NSIG];
+static char signal_program[NSIG];
+
+/* Nonzero if breakpoints are now inserted in the inferior.  */
+
+static int breakpoints_inserted;
+
+/* Function inferior was in as of last step command.  */
+
+static struct symbol *step_start_function;
+
+/* This is the sequence of bytes we insert for a breakpoint.  */
+
+static char break_insn[] = BREAKPOINT;
+
+/* Nonzero => address for special breakpoint for resuming stepping.  */ 
+
+static CORE_ADDR step_resume_break_address;
+
+/* Original contents of the byte where the special breakpoint is.  */
+
+static char step_resume_break_shadow[sizeof break_insn];
+
+/* Nonzero means the special breakpoint is a duplicate
+   so it has not itself been inserted.  */
+
+static int step_resume_break_duplicate;
+
+/* Nonzero if we are expecting a trace trap and should proceed from it.
+   2 means expecting 2 trace traps and should continue both times.
+   That occurs when we tell sh to exec the program: we will get
+   a trap after the exec of sh and a second when the program is exec'd.  */
+
+static int trap_expected;
+
+/* Nonzero means expecting a trace trap
+   and should stop the inferior and return silently when it happens.  */
+
+static int stop_after_trap;
+
+/* Nonzero means expecting a trace trap due to attaching to a process.  */
+
+static int stop_after_attach;
+
+/* Nonzero if pc has been changed by the debugger
+   since the inferior stopped.  */
+
+int pc_changed;
+
+/* Save register contents here when about to pop a stack dummy frame.  */
+
+char stop_registers[REGISTER_BYTES];
+
+/* Nonzero if program stopped due to error trying to insert breakpoints.  */
+
+static int breakpoints_failed;
+
+/* Nonzero if inferior is in sh before our program got exec'd.  */
+
+static int running_in_shell;
+
+/* Nonzero after stop if current stack frame should be printed.  */
+
+static int stop_print_frame;
+
+static void insert_step_breakpoint ();
+static void remove_step_breakpoint ();
+static void wait_for_inferior ();
+static void normal_stop ();
+
+START_FILE
+
+/* Clear out all variables saying what to do when inferior is continued.
+   First do this, then set the ones you want, then call `proceed'.  */
+
+void
+clear_proceed_status ()
+{
+  trap_expected = 0;
+  step_range_start = 0;
+  step_range_end = 0;
+  step_frame = 0;
+  step_over_calls = -1;
+  step_resume_break_address = 0;
+  stop_after_trap = 0;
+  stop_after_attach = 0;
+
+  /* Discard any remaining commands left by breakpoint we had stopped at.  */
+  clear_breakpoint_commands ();
+}
+
+/* Basic routine for continuing the program in various fashions.
+
+   ADDR is the address to resume at, or -1 for resume where stopped.
+   SIGNAL is the signal to give it, or 0 for none,
+     or -1 for act according to how it stopped.
+   STEP is nonzero if should trap after one instruction.
+     -1 means return after that and print nothing.
+     You should probably set various step_... variables
+     before calling here, if you are stepping.
+
+   You should call clear_proceed_status before calling proceed.  */
+
+void
+proceed (addr, signal, step)
+     CORE_ADDR addr;
+     int signal;
+     int step;
+{
+  int oneproc = 0;
+
+  if (step > 0)
+    step_start_function = find_pc_function (read_pc ());
+  if (step < 0)
+    stop_after_trap = 1;
+
+  if (addr == -1)
+    {
+      /* If there is a breakpoint at the address we will resume at,
+	 step one instruction before inserting breakpoints
+	 so that we do not stop right away.  */
+
+      if (!pc_changed && breakpoint_here_p (read_pc ()))
+	{
+	  oneproc = 1;
+	  /* We will get a trace trap after one instruction.
+	     Continue it automatically and insert breakpoints then.  */
+	  trap_expected = 1;
+	}
+    }
+  else
+    write_register (PC_REGNUM, addr);
+
+  if (!oneproc)
+    {
+      int temp = insert_breakpoints ();
+      if (temp)
+	{
+	  print_sys_errmsg ("ptrace", temp);
+	  error ("Cannot insert breakpoints.\n\
+The same program may be running in another process.");
+	}
+      breakpoints_inserted = 1;
+    }
+
+  /* Install inferior's terminal modes.  */
+  terminal_inferior ();
+
+  if (signal >= 0)
+    stop_signal = signal;
+  /* If this signal should not be seen by program,
+     give it zero.  Used for debugging signals.  */
+  else if (stop_signal < NSIG && !signal_program[stop_signal])
+    stop_signal= 0;
+
+  /* Resume inferior.  */
+  resume (oneproc || step, stop_signal);
+
+  /* Wait for it to stop (if not standalone)
+     and in any case decode why it stopped, and act accordingly.  */
+
+  wait_for_inferior ();
+  normal_stop ();
+}
+
+/* Writing the inferior pc as a register calls this function
+   to inform infrun that the pc has been set in the debugger.  */
+
+writing_pc (val)
+     CORE_ADDR val;
+{
+  stop_pc = val;
+  pc_changed = 1;
+}
+
+/* Start an inferior process for the first time.
+   Actually it was started by the fork that created it,
+   but it will have stopped one instruction after execing sh.
+   Here we must get it up to actual execution of the real program.  */
+
+start_inferior ()
+{
+  /* We will get a trace trap after one instruction.
+     Continue it automatically.  Eventually (after shell does an exec)
+     it will get another trace trap.  Then insert breakpoints and continue.  */
+  trap_expected = 2;
+  running_in_shell = 0;		/* Set to 1 at first SIGTRAP, 0 at second.  */
+  breakpoints_inserted = 0;
+  mark_breakpoints_out ();
+
+  /* Set up the "saved terminal modes" of the inferior
+     based on what modes we are starting it with.  */
+  terminal_init_inferior ();
+
+  /* Install inferior's terminal modes.  */
+  terminal_inferior ();
+
+  wait_for_inferior ();
+  normal_stop ();
+}
+
+#ifdef ATTACH_DETACH
+
+/* Attach to process PID, then initialize for debugging it
+   and wait for the trace-trap that results from attaching.  */
+
+void
+attach_program (pid)
+     int pid;
+{
+  attach (pid);
+  inferior_pid = pid;
+
+  mark_breakpoints_out ();
+  terminal_init_inferior ();
+  clear_proceed_status ();
+  stop_after_attach = 1;
+  /*proceed (-1, 0, -2);*/
+  wait_for_inferior ();
+  normal_stop ();
+}
+#endif /* ATTACH_DETACH */
+
+/* Wait for control to return from inferior to debugger.
+   If inferior gets a signal, we may decide to start it up again
+   instead of returning.  That is why there is a loop in this function.
+   When this function actually returns it means the inferior
+   should be left stopped and GDB should read more commands.  */
+
+static void
+wait_for_inferior ()
+{
+  register int pid;
+  WAITTYPE w;
+  CORE_ADDR pc;
+  int tem;
+  int another_trap;
+  int random_signal;
+  CORE_ADDR stop_sp;
+  int stop_step_resume_break;
+  int newmisc;
+  int newfun_pc;
+  struct symbol *newfun;
+  struct symtab_and_line sal;
+  int prev_pc;
+
+  while (1)
+    {
+      prev_pc = read_pc ();
+      pid = wait (&w);
+      pc_changed = 0;
+      fetch_inferior_registers ();
+      stop_pc = read_pc ();
+      set_current_frame (read_register (FP_REGNUM));
+      stop_frame = get_current_frame ();
+      stop_sp = read_register (SP_REGNUM);
+      another_trap = 0;
+      stop_breakpoint = 0;
+      stop_step = 0;
+      stop_stack_dummy = 0;
+      stop_print_frame = 1;
+      stop_step_resume_break = 0;
+      random_signal = 0;
+      breakpoints_failed = 0;
+
+      /* Look at the cause of the stop, and decide what to do.
+	 The alternatives are:
+	 1) break; to really stop and return to the debugger,
+	 2) drop through to start up again
+	   (set another_trap to 1 to single step once)
+	 3) set random_signal to 1, and the decision between 1 and 2 
+	   will be made according to the signal handling tables.  */
+
+      if (WIFEXITED (w))
+	{
+	  terminal_ours_for_output ();
+	  if (WRETCODE (w))
+	    printf ("\nProgram exited with code 0%o.\n", WRETCODE (w));
+	  else
+	    printf ("\nProgram exited normally.\n");
+	  fflush (stdout);
+	  inferior_died ();
+	  stop_print_frame = 0;
+	  break;
+	}
+      else if (!WIFSTOPPED (w))
+	{
+	  kill_inferior ();
+	  stop_print_frame = 0;
+	  stop_signal = WTERMSIG (w);
+	  terminal_ours_for_output ();
+	  printf ("\nProgram terminated with signal %d, %s\n",
+		  stop_signal,
+		  stop_signal < NSIG
+		  ? sys_siglist[stop_signal]
+		  : "(undocumented)");
+	  printf ("The inferior process no longer exists.\n");
+	  fflush (stdout);
+	  break;
+	}
+      else
+	{
+	  stop_signal = WSTOPSIG (w);
+
+	  /* First, distinguish signals caused by the debugger from signals
+	     that have to do with the program's own actions.
+	     Note that breakpoint insns may cause SIGTRAP or SIGILL
+	     or SIGEMT, depending on the operating system version.
+	     Here we detect when a SIGILL or SIGEMT is really a breakpoint
+	     and change it to SIGTRAP.  */
+
+	  if (stop_signal == SIGTRAP
+	      || (breakpoints_inserted &&
+		  (stop_signal == SIGILL
+		   || stop_signal == SIGEMT))
+	      || stop_after_attach)
+	    {
+	      if (stop_signal == SIGTRAP && stop_after_trap)
+		{
+		  stop_print_frame = 0;
+		  break;
+		}
+	      if (stop_after_attach)
+		break;
+	      /* Don't even think about breakpoints
+		 if still running the shell that will exec the program
+		 or if just proceeded over a breakpoint.  */
+	      if (stop_signal == SIGTRAP && trap_expected)
+		stop_breakpoint = 0;
+	      else
+		/* See if there is a breakpoint at the current PC.  */
+#if DECR_PC_AFTER_BREAK
+		/* Notice the case of stepping through a jump
+		   that leads just after a breakpoint.
+		   Don't confuse that with hitting the breakpoint.
+		   What we check for is that 1) stepping is going on
+		   and 2) the pc before the last insn does not match
+		   the address of the breakpoint before the current pc.  */
+		if (!(prev_pc != stop_pc - DECR_PC_AFTER_BREAK
+		      && step_range_end && !step_resume_break_address))
+#endif /* DECR_PC_AFTER_BREAK not zero */
+		  {
+		    select_frame (stop_frame, 0); /* For condition exprs. */
+		    stop_breakpoint = breakpoint_stop_status (stop_pc, stop_frame);
+		    /* Following in case break condition called a function.  */
+		    stop_print_frame = 1;
+		    if (stop_breakpoint && DECR_PC_AFTER_BREAK)
+		      {
+			stop_pc -= DECR_PC_AFTER_BREAK;
+			write_register (PC_REGNUM, stop_pc);
+			pc_changed = 0;
+		      }
+		  }
+	      /* See if we stopped at the special breakpoint for
+		 stepping over a subroutine call.  */
+	      if (stop_pc - DECR_PC_AFTER_BREAK == step_resume_break_address)
+		{
+		  stop_step_resume_break = 1;
+		  if (DECR_PC_AFTER_BREAK)
+		    {
+		      stop_pc -= DECR_PC_AFTER_BREAK;
+		      write_register (PC_REGNUM, stop_pc);
+		      pc_changed = 0;
+		    }
+		}
+
+	      if (stop_signal == SIGTRAP)
+		random_signal
+		  = !(stop_breakpoint || trap_expected
+		      || stop_step_resume_break
+		      || (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame)
+		      || (step_range_end && !step_resume_break_address));
+	      else
+		{
+		  random_signal
+		    = !(stop_breakpoint || stop_step_resume_break);
+		  if (!random_signal)
+		    stop_signal = SIGTRAP;
+		}
+	    }
+	  else
+	    random_signal = 1;
+
+	  /* For the program's own signals, act according to
+	     the signal handling tables.  */
+
+	  if (random_signal
+	      && !(running_in_shell && stop_signal == SIGSEGV))
+	    {
+	      /* Signal not for debugging purposes.  */
+	      int printed = 0;
+
+	      if (stop_signal >= NSIG
+		  || signal_print[stop_signal])
+		{
+		  printed = 1;
+		  terminal_ours_for_output ();
+		  printf ("\nProgram received signal %d, %s\n",
+			  stop_signal,
+			  stop_signal < NSIG
+			   ? sys_siglist[stop_signal]
+			   : "(undocumented)");
+		  fflush (stdout);
+		}
+	      if (stop_signal >= NSIG
+		  || signal_stop[stop_signal])
+		break;
+	      /* If not going to stop, give terminal back
+		 if we took it away.  */
+	      else if (printed)
+		terminal_inferior ();
+	    }
+
+	  /* Handle cases caused by hitting a breakpoint.  */
+
+	  if (!random_signal
+	      && (stop_breakpoint || stop_step_resume_break))
+	    {
+	      /* Does a breakpoint want us to stop?  */
+	      if (stop_breakpoint && stop_breakpoint != -1)
+		{
+		  /* 0x1000000 is set in stop_breakpoint as returned by
+		     breakpoint_status_p to indicate a silent breakpoint.  */
+		  if (stop_breakpoint > 0 && stop_breakpoint & 0x1000000)
+		    {
+		      stop_breakpoint &= ~0x1000000;
+		      stop_print_frame = 0;
+		    }
+		  break;
+		}
+	      /* But if we have hit the step-resumption breakpoint,
+		 remove it.  It has done its job getting us here.  */
+	      if (stop_step_resume_break
+		  && (step_frame == 0 || stop_frame == step_frame))
+		{
+		  remove_step_breakpoint ();
+		  step_resume_break_address = 0;
+		}
+	      /* Otherwise, must remove breakpoints and single-step
+		 to get us past the one we hit.  */
+	      else
+		{
+		  remove_breakpoints ();
+		  remove_step_breakpoint ();
+		  breakpoints_inserted = 0;
+		  another_trap = 1;
+		}
+
+	      /* We come here if we hit a breakpoint but should not
+		 stop for it.  Possibly we also were stepping
+		 and should stop for that.  So fall through and
+		 test for stepping.  But, if not stepping,
+		 do not stop.  */
+	    }
+
+	  /* If this is the breakpoint at the end of a stack dummy,
+	     just stop silently.  */
+	  if (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame)
+	    {
+	      stop_print_frame = 0;
+	      stop_stack_dummy = 1;
+	      break;
+	    }
+
+	  if (step_resume_break_address)
+	    /* Having a step-resume breakpoint overrides anything
+	       else having to do with stepping commands until
+	       that breakpoint is reached.  */
+	    ;
+	  /* If stepping through a line, keep going if still within it.  */
+	  else if (!random_signal
+		   && step_range_end
+		   && stop_pc >= step_range_start
+		   && stop_pc < step_range_end)
+	    {
+	      /* Don't step through the return from a function
+		 unless that is the first instruction stepped through.  */
+	      if (ABOUT_TO_RETURN (stop_pc))
+		{
+		  stop_step = 1;
+		  break;
+		}
+	    }
+
+	  /* We stepped out of the stepping range.  See if that was due
+	     to a subroutine call that we should proceed to the end of.  */
+	  else if (!random_signal && step_range_end)
+	    {
+	      newfun = find_pc_function (stop_pc);
+	      if (newfun)
+		{
+		  newfun_pc = BLOCK_START (SYMBOL_BLOCK_VALUE (newfun))
+		    + FUNCTION_START_OFFSET;
+		}
+	      else
+		{
+		  newmisc = find_pc_misc_function (stop_pc);
+		  if (newmisc >= 0)
+		    newfun_pc = misc_function_vector[newmisc].address
+		      + FUNCTION_START_OFFSET;
+		  else newfun_pc = 0;
+		}
+	      if (stop_pc == newfun_pc
+		  && (step_over_calls > 0 || (step_over_calls && newfun == 0)))
+		{
+		  /* A subroutine call has happened.  */
+		  /* Set a special breakpoint after the return */
+		  step_resume_break_address = SAVED_PC_AFTER_CALL (stop_frame);
+		  step_resume_break_duplicate
+		    = breakpoint_here_p (step_resume_break_address);
+		  if (breakpoints_inserted)
+		    insert_step_breakpoint ();
+		}
+	      /* Subroutine call with source code we should not step over.
+		 Do step to the first line of code in it.  */
+	      else if (stop_pc == newfun_pc && step_over_calls)
+		{
+		  SKIP_PROLOGUE (newfun_pc);
+		  sal = find_pc_line (newfun_pc, 0);
+		  /* Use the step_resume_break to step until
+		     the end of the prologue, even if that involves jumps
+		     (as it seems to on the vax under 4.2).  */
+		  /* If the prologue ends in the middle of a source line,
+		     continue to the end of that source line.
+		     Otherwise, just go to end of prologue.  */
+		  if (sal.end && sal.pc != newfun_pc)
+		    step_resume_break_address = sal.end;
+		  else
+		    step_resume_break_address = newfun_pc;
+
+		  step_resume_break_duplicate
+		    = breakpoint_here_p (step_resume_break_address);
+		  if (breakpoints_inserted)
+		    insert_step_breakpoint ();
+		  /* Do not specify what the fp should be when we stop
+		     since on some machines the prologue
+		     is where the new fp value is established.  */
+		  step_frame = 0;
+		  /* And make sure stepping stops right away then.  */
+		  step_range_end = step_range_start;
+		}
+	      /* No subroutince call; stop now.  */
+	      else
+		{
+		  stop_step = 1;
+		  break;
+		}
+	    }
+	}
+
+      /* If we did not do break;, it means we should keep
+	 running the inferior and not return to debugger.  */
+
+      /* If trap_expected is 2, it means continue once more
+	 and insert breakpoints at the next trap.
+	 If trap_expected is 1 and the signal was SIGSEGV, it means
+	 the shell is doing some memory allocation--just resume it
+	 with SIGSEGV.
+	 Otherwise insert breakpoints now, and possibly single step.  */
+
+      if (trap_expected > 1)
+	{
+	  trap_expected--;
+	  running_in_shell = 1;
+	  resume (0, 0);
+	}
+      else if (running_in_shell && stop_signal == SIGSEGV)
+	{
+	  resume (0, SIGSEGV);
+	}
+      else
+	{
+	  /* Here, we are not awaiting another exec to get
+	     the program we really want to debug.
+	     Insert breakpoints now, unless we are trying
+	     to one-proceed past a breakpoint.  */
+	  running_in_shell = 0;
+	  if (!breakpoints_inserted && !another_trap)
+	    {
+	      insert_step_breakpoint ();
+	      breakpoints_failed = insert_breakpoints ();
+	      if (breakpoints_failed)
+		break;
+	      breakpoints_inserted = 1;
+	    }
+
+	  trap_expected = another_trap;
+
+	  if (stop_signal == SIGTRAP)
+	    stop_signal = 0;
+
+	  resume ((step_range_end && !step_resume_break_address)
+		  || trap_expected,
+		  stop_signal);
+	}
+    }
+}
+
+/* Here to return control to GDB when the inferior stops for real.
+   Print appropriate messages, remove breakpoints, give terminal our modes.
+
+   RUNNING_IN_SHELL nonzero means the shell got a signal before
+   exec'ing the program we wanted to run.
+   STOP_PRINT_FRAME nonzero means print the executing frame
+   (pc, function, args, file, line number and line text).
+   BREAKPOINTS_FAILED nonzero means stop was due to error
+   attempting to insert breakpoints.  */
+
+static void
+normal_stop ()
+{
+  if (breakpoints_failed)
+    {
+      terminal_ours_for_output ();
+      print_sys_errmsg ("ptrace", breakpoints_failed);
+      printf ("Stopped; cannot insert breakpoints.\n\
+The same program may be running in another process.\n");
+    }
+
+  if (inferior_pid)
+    remove_step_breakpoint ();
+
+  if (inferior_pid && breakpoints_inserted)
+    if (remove_breakpoints ())
+      {
+	terminal_ours_for_output ();
+	printf ("Cannot remove breakpoints because program is no longer writable.\n\
+It must be running in another process.\n\
+Further execution is probably impossible.\n");
+      }
+
+  breakpoints_inserted = 0;
+
+  /* Delete the breakpoint we stopped at, if it wants to be deleted.
+     Delete any breakpoint that is to be deleted at the next stop.  */
+
+  breakpoint_auto_delete (stop_breakpoint);
+
+  if (step_multi && stop_step)
+    return;
+
+  terminal_ours ();
+
+  if (running_in_shell)
+    {
+      if (stop_signal == SIGSEGV)
+	printf ("\
+You have just encountered a bug in \"sh\".  GDB starts your program\n\
+by running \"sh\" with a command to exec your program.\n\
+This is so that \"sh\" will process wildcards and I/O redirection.\n\
+This time, \"sh\" crashed.\n\
+\n\
+One known bug in \"sh\" bites when the environment takes up a lot of space.\n\
+Try \"info env\" to see the environment; then use \"unset-env\" to kill\n\
+some variables whose values are large; then do \"run\" again.\n\
+\n\
+If that works, you might want to put those \"unset-env\" commands\n\
+into a \".gdbinit\" file in this directory so they will happen every time.\n");
+      /* Don't confuse user with his program's symbols on sh's data.  */
+      stop_print_frame = 0;
+    }
+
+  if (inferior_pid == 0)
+    return;
+
+  /* Select innermost stack frame except on return from a stack dummy routine,
+     or if the program has exited.  */
+  if (!stop_stack_dummy)
+    {
+      select_frame (stop_frame, 0);
+
+      if (stop_print_frame)
+	{
+	  if (stop_breakpoint > 0)
+	    printf ("\nBpt %d, ", stop_breakpoint);
+	  print_sel_frame (stop_step
+			   && step_frame == stop_frame
+			   && step_start_function == find_pc_function (stop_pc));
+	  /* Display the auto-display expressions.  */
+	  do_displays ();
+	}
+    }
+
+  /* Save the function value return registers
+     We might be about to restore their previous contents.  */
+  read_register_bytes (0, stop_registers, REGISTER_BYTES);
+
+  if (stop_stack_dummy)
+    {
+      /* Pop the empty frame that contains the stack dummy.  */
+      POP_FRAME;
+      select_frame (read_register (FP_REGNUM), 0);
+    }
+}
+
+static void
+insert_step_breakpoint ()
+{
+  if (step_resume_break_address && !step_resume_break_duplicate)
+    {
+      read_memory (step_resume_break_address,
+		   step_resume_break_shadow, sizeof break_insn);
+      write_memory (step_resume_break_address,
+		    break_insn, sizeof break_insn);
+    }
+}
+
+static void
+remove_step_breakpoint ()
+{
+  if (step_resume_break_address && !step_resume_break_duplicate)
+    write_memory (step_resume_break_address, step_resume_break_shadow,
+		  sizeof break_insn);
+}
+
+/* Specify how various signals in the inferior should be handled.  */
+
+static void
+handle_command (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  register char *p = args;
+  int signum;
+  register int digits, wordlen;
+
+  if (!args)
+    error_no_arg ("signal to handle");
+
+  while (*p)
+    {
+      /* Find the end of the next word in the args.  */
+      for (wordlen = 0; p[wordlen] && p[wordlen] != ' ' && p[wordlen] != '\t';
+	   wordlen++);
+      for (digits = 0; p[digits] >= '0' && p[digits] <= '9'; digits++);
+
+      /* If it is all digits, it is signal number to operate on.  */
+      if (digits == wordlen)
+	{
+	  signum = atoi (p);
+	  if (signum == SIGTRAP || signum == SIGINT)
+	    {
+	      if (!query ("Signal %d is used by the debugger.\nAre you sure you want to change it? ", signum))
+		error ("Not confirmed.");
+	    }
+	}
+      else if (signum == 0)
+	error ("First argument is not a signal number.");
+
+      /* Else, if already got a signal number, look for flag words
+	 saying what to do for it.  */
+      else if (!strncmp (p, "stop", wordlen))
+	{
+	  signal_stop[signum] = 1;
+	  signal_print[signum] = 1;
+	}
+      else if (wordlen >= 2 && !strncmp (p, "print", wordlen))
+	signal_print[signum] = 1;
+      else if (wordlen >= 2 && !strncmp (p, "pass", wordlen))
+	signal_program[signum] = 1;
+      else if (!strncmp (p, "ignore", wordlen))
+	signal_program[signum] = 0;
+      else if (wordlen >= 3 && !strncmp (p, "nostop", wordlen))
+	signal_stop[signum] = 0;
+      else if (wordlen >= 4 && !strncmp (p, "noprint", wordlen))
+	{
+	  signal_print[signum] = 0;
+	  signal_stop[signum] = 0;
+	}
+      else if (wordlen >= 4 && !strncmp (p, "nopass", wordlen))
+	signal_program[signum] = 0;
+      else if (wordlen >= 3 && !strncmp (p, "noignore", wordlen))
+	signal_program[signum] = 1;
+      /* Not a number and not a recognized flag word => complain.  */
+      else
+	{
+	  p[wordlen] = 0;
+	  error ("Unrecognized flag word: \"%s\".", p);
+	}
+
+      /* Find start of next word.  */
+      p += wordlen;
+      while (*p == ' ' || *p == '\t') p++;
+    }
+
+  if (from_tty)
+    {
+      /* Show the results.  */
+      printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
+      printf ("%d\t", signum);
+      printf ("%s\t", signal_stop[signum] ? "Yes" : "No");
+      printf ("%s\t", signal_print[signum] ? "Yes" : "No");
+      printf ("%s\t\t", signal_program[signum] ? "Yes" : "No");
+      printf ("%s\n", sys_siglist[signum]);
+    }
+}
+
+/* Print current contents of the tables set by the handle command.  */
+
+static void
+signals_info (signum_exp)
+     char *signum_exp;
+{
+  register int i;
+  printf ("Number\tStop\tPrint\tPass to program\tDescription\n");
+
+  if (signum_exp)
+    {
+      i = parse_and_eval_address (signum_exp);
+      printf ("%d\t", i);
+      printf ("%s\t", signal_stop[i] ? "Yes" : "No");
+      printf ("%s\t", signal_print[i] ? "Yes" : "No");
+      printf ("%s\t\t", signal_program[i] ? "Yes" : "No");
+      printf ("%s\n", sys_siglist[i]);
+      return;
+    }
+
+  printf ("\n");
+  for (i = 0; i < NSIG; i++)
+    {
+      QUIT;
+      if (i > 0 && i % 16 == 0)
+	{
+	  printf ("[Type Return to see more]");
+	  fflush (stdout);
+	  read_line ();
+	}
+      printf ("%d\t", i);
+      printf ("%s\t", signal_stop[i] ? "Yes" : "No");
+      printf ("%s\t", signal_print[i] ? "Yes" : "No");
+      printf ("%s\t\t", signal_program[i] ? "Yes" : "No");
+      printf ("%s\n", sys_siglist[i]);
+    }
+
+  printf ("\nUse the \"handle\" command to change these tables.\n");
+}
+
+static
+initialize ()
+{
+  register int i;
+
+  add_info ("signals", signals_info,
+	    "What debugger does when program gets various signals.\n\
+Specify a signal number as argument to print info on that signal only.");
+
+  add_com ("handle", class_run, handle_command,
+	   "Specify how to handle a signal.\n\
+Args are signal number followed by flags.\n\
+Flags allowed are \"stop\", \"print\", \"pass\",\n\
+ \"nostop\", \"noprint\" or \"nopass\".\n\
+Print means print a message if this signal happens.\n\
+Stop means reenter debugger if this signal happens (implies print).\n\
+Pass means let program see this signal; otherwise program doesn't know.\n\
+Pass and Stop may be combined.");
+
+  for (i = 0; i < NSIG; i++)
+    {
+      signal_stop[i] = 1;
+      signal_print[i] = 1;
+      signal_program[i] = 1;
+    }
+
+  /* Signals caused by debugger's own actions
+     should not be given to the program afterwards.  */
+  signal_program[SIGTRAP] = 0;
+  signal_program[SIGINT] = 0;
+
+  /* Signals that are not errors should not normally enter the debugger.  */
+#ifdef SIGALRM
+  signal_stop[SIGALRM] = 0;
+  signal_print[SIGALRM] = 0;
+#endif /* SIGALRM */
+#ifdef SIGVTALRM
+  signal_stop[SIGVTALRM] = 0;
+  signal_print[SIGVTALRM] = 0;
+#endif /* SIGVTALRM */
+#ifdef SIGPROF
+  signal_stop[SIGPROF] = 0;
+  signal_print[SIGPROF] = 0;
+#endif /* SIGPROF */
+#ifdef SIGCHLD
+  signal_stop[SIGCHLD] = 0;
+  signal_print[SIGCHLD] = 0;
+#endif /* SIGCHLD */
+#ifdef SIGCLD
+  signal_stop[SIGCLD] = 0;
+  signal_print[SIGCLD] = 0;
+#endif /* SIGCLD */
+#ifdef SIGIO
+  signal_stop[SIGIO] = 0;
+  signal_print[SIGIO] = 0;
+#endif /* SIGIO */
+#ifdef SIGURG
+  signal_stop[SIGURG] = 0;
+  signal_print[SIGURG] = 0;
+#endif /* SIGURG */
+}
+
+END_FILE
diff --git a/gdb/initialize.h b/gdb/initialize.h
new file mode 100644
index 0000000..e727c80
--- /dev/null
+++ b/gdb/initialize.h
@@ -0,0 +1,126 @@
+/* Macros to enable automatic execution of an initialization function
+   in each object file without having to include a list of all object files
+   anywhere in the source code.  This goes with firstfile.c and lastfile.c.
+
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+		       NO WARRANTY
+
+  BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
+NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
+WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
+LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
+OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
+DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
+A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
+PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
+
+		GENERAL PUBLIC LICENSE TO COPY
+
+  1. You may copy and distribute verbatim copies of this source file
+as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy a valid copyright notice "Copyright
+(C) 1986 Free Software Foundation, Inc."; and include following the
+copyright notice a verbatim copy of the above disclaimer of warranty
+and of this License.  You may charge a distribution fee for the
+physical act of transferring a copy.
+
+  2. You may modify your copy or copies of this source file or
+any portion of it, and copy and distribute such modifications under
+the terms of Paragraph 1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish,
+    that in whole or in part contains or is a derivative of this
+    program or any part thereof, to be licensed at no charge to all
+    third parties on terms identical to those contained in this
+    License Agreement (except that you may choose to grant more
+    extensive warranty protection to third parties, at your option).
+
+    c) You may charge a distribution fee for the physical act of
+    transferring a copy, and you may at your option offer warranty
+    protection in exchange for a fee.
+
+  3. You may copy and distribute this program or any portion of it in
+compiled, executable or object code form under the terms of Paragraphs
+1 and 2 above provided that you do the following:
+
+    a) cause each such copy to be accompanied by the
+    corresponding machine-readable source code, which must
+    be distributed under the terms of Paragraphs 1 and 2 above; or,
+
+    b) cause each such copy to be accompanied by a
+    written offer, with no time limit, to give any third party
+    free (except for a nominal shipping charge) a machine readable
+    copy of the corresponding source code, to be distributed
+    under the terms of Paragraphs 1 and 2 above; or,
+
+    c) in the case of a recipient of this program in compiled, executable
+    or object code form (without the corresponding source code) you
+    shall cause copies you distribute to be accompanied by a copy
+    of the written offer of source code which you received along
+    with the copy you received.
+
+  4. You may not copy, sublicense, distribute or transfer this program
+except as expressly provided under this License Agreement.  Any attempt
+otherwise to copy, sublicense, distribute or transfer this program is void and
+your rights to use the program under this License agreement shall be
+automatically terminated.  However, parties who have received computer
+software programs from you with this License Agreement will not have
+their licenses terminated so long as such parties remain in full compliance.
+
+  5. If you wish to incorporate parts of this program into other free
+programs whose distribution conditions are different, write to the Free
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet
+worked out a simple rule that can be stated here, but we will often permit
+this.  We will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software.
+
+
+In other words, you are welcome to use, share and improve this program.
+You are forbidden to forbid anyone else to use, share and improve
+what you give them.   Help stamp out software-hoarding!  */
+
+
+/* Here a machine-specific header file must be included to define
+   the macro FILEADDR_ROUND which we use to round up from the address
+   of the end of one object file's text to the start of the next
+   object file's text.  */
+
+#include "m-suninit.h"
+
+/* This is used to make a file's initialization function.
+   It calls another function named `initialize', which must
+   appear later in the file.  */
+
+#define START_FILE   \
+  static initialize (), initialize_next_file ();   \
+  static initialize_1 (offset)  \
+  { initialize (); initialize_next_file (offset); }
+
+/* The argument OFFSET is the size of this function.
+   By adding it to the address of this function,
+   we find the next function, which is the next file's
+   initialization function.  */
+
+#define END_FILE    \
+  static initialize_next_file (offset)   \
+     int offset;   \
+  { long addr = FILEADDR_ROUND ((int) initialize_next_file + offset);   \
+    (*(void (*) ()) addr) (offset);  }
diff --git a/gdb/kdb-start.c b/gdb/kdb-start.c
new file mode 100644
index 0000000..bdbc272
--- /dev/null
+++ b/gdb/kdb-start.c
@@ -0,0 +1,21 @@
+#include "defs.h"
+#include "param.h"
+
+static char *args[] = {"kdb", "kdb-symbols", 0};
+
+static char *environment[] = {0};
+
+char **environ;
+
+start ()
+{
+#ifdef NAMES_HAVE_UNDERSCORE
+  INIT_STACK (_kdb_stack_beg, _kdb_stack_end);
+#else /* not NAMES_HAVE_UNDERSCORE */
+  INIT_STACK (kdb_stack_beg, kdb_stack_end);
+#endif /* not NAMES_HAVE_UNDERSCORE */
+
+  environ = environment;
+
+  main (2, args, environment);
+}
diff --git a/gdb/lastfile.c b/gdb/lastfile.c
new file mode 100644
index 0000000..2ac8cb7
--- /dev/null
+++ b/gdb/lastfile.c
@@ -0,0 +1,6 @@
+/* This ends the chain of files for the purpose of initialization,
+   because it does not attempt to find the start of the following file.  */
+
+initialize_last_file ()
+{
+}
diff --git a/gdb/m-isi-ov.h b/gdb/m-isi-ov.h
new file mode 100644
index 0000000..46c1816
--- /dev/null
+++ b/gdb/m-isi-ov.h
@@ -0,0 +1,524 @@
+/*
+Date: Thu, 2 Apr 87 00:02:42 EST
+From: crl@maxwell.physics.purdue.edu (Charles R. LaBrec)
+Message-Id: <8704020502.AA01744@maxwell.physics.purdue.edu>
+To: bug-gdb@prep.ai.mit.edu
+Subject: gdb for ISI Optimum V
+
+Here is an m-isi-ov.h file for gdb version 2.1.  It supports the 68881
+registers, and tracks down the function prologue (since the ISI cc
+puts it at the end of the function and branches to it if not
+optimizing).  Also included are diffs to core.c, findvar.c, and
+inflow.c, since the original code assumed that registers are an int in
+the user struct, which isn't the case for 68020's with 68881's (and
+not using the NEW_SUN_PTRACE).  I have not fixed the bugs associated
+with the other direction (writing registers back to the user struct).
+I have also included a diff that turns m68k-pinsn.c into isi-pinsn.c,
+which is needed since the 3.05 release of as does not understand
+floating point ops, and it compiles incorrectly under "cc -20"
+
+I have used gdb for a while now, and it seems to work relatively well,
+but I do not guarantee that it is perfect.  The more that use it, the
+faster the bugs will get shaken out.  One bug I know of is not in gdb,
+but in the assembler.  It seems to screw up the .stabs of variables.
+For externs, this is not important since gdb uses the global symbol
+value, but for statics, this makes gdb unable to find them.  I am
+currently trying to track it down.
+
+As an aside, I notice that only global functions are used as symbols
+to print as relative addresses, i.e. "<function + offset>", and not
+static functions, which end up printing as large offsets from the last
+global one.  Would there be a problem if static functions were also
+recorded as misc functions in read_dbx_symtab?
+
+Charles LaBrec
+crl @ maxwell.physics.purdue.edu
+
+  Definitions to make GDB run on a ISI Optimum V (3.05) under 4.2bsd.
+
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+
+/* Identify this machine */
+#ifndef ISI68K
+#define ISI68K
+#endif
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Debugger information will be in DBX format.  */
+
+#define READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)					\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)				\
+    pc += 6;   /* Skip link #long */			\
+  else if (op == 0060000)				\
+    pc += 4;   /* Skip bra #word */			\
+  else if (op == 00600377)				\
+    pc += 6;   /* skip bra #long */			\
+  else if ((op & 0177400) == 0060000)			\
+    pc += 2;   /* skip bra #char */			\
+}
+
+
+/* Immediately after a function call, return the saved pc.
+   Can't always go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* This is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values.  */
+
+#define KERNEL_U_ADDR 0x10800000
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR 0x10000000
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Data segment starts at etext rounded up to DATAROUND in {N,Z}MAGIC files */
+
+#define DATAROUND	0x20000
+#define N_DATADDR(hdr)	(hdr.a_magic != OMAGIC ? \
+	(hdr.a_text + DATAROUND) & ~(DATAROUND-1) : hdr.a_text)
+
+/* Text segment starts at sizeof (struct exec) in {N,Z}MAGIC files */
+
+#define N_TXTADDR(hdr)	(hdr.a_magic != OMAGIC ? sizeof (struct exec) : 0)
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  
+   On the ISI, the kernel resets the pc to the trap instr */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
+
+/* Say how long registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 29
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES  \
+ {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
+  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
+  "ps", "pc",  \
+  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
+  "fpcontrol", "fpstatus", "fpiaddr" }
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PS_REGNUM 16		/* Contains processor status */
+#define PC_REGNUM 17		/* Contains program counter */
+#define FP0_REGNUM 18		/* Floating point register 0 */
+#define FPC_REGNUM 26		/* 68881 control register */
+
+#define REGISTER_U_ADDR(addr, blockend, regno)		\
+{	if (regno < 2) addr = blockend - 0x18 + regno * 4;	\
+	else if (regno < 8) addr = blockend - 0x54 + regno * 4;	\
+	else if (regno < 10) addr = blockend - 0x30 + regno * 4;\
+	else if (regno < 15) addr = blockend - 0x5c + regno * 4;\
+	else if (regno < 16) addr = blockend - 0x1c;		\
+	else if (regno < 18) addr = blockend - 0x44 + regno * 4;\
+	else if (regno < 26) addr = (int) ((struct user *)0)->u_68881_regs \
+	    + (regno - 18) * 12;				\
+	else if (regno < 29) addr = (int) ((struct user *)0)->u_68881_regs \
+	    + 8 * 12 + (regno - 26) * 4;			\
+}
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8*12+8+20)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  \
+ ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168	\
+  : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72	\
+  : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 12 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 8-byte doubles.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_from_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_to_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the ISI, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.  */
+
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  register int insn;							\
+  register int offset;							\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next,			\
+	 or a branch followed by a link a6 instruction;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+retry:									\
+      insn = read_memory_integer (pc, 2);				\
+      if (insn == 044016)						\
+	next_addr = (frame_info).frame - read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (insn == 047126)						\
+	next_addr = (frame_info).frame - read_memory_integer (pc += 2, 2), pc+=2; \
+      else if ((insn & 0177400) == 060000)	/* bra insn */		\
+	{ offset = insn & 0377;						\
+          pc += 2;				/* advance past bra */	\
+	  if (offset == 0)			/* bra #word */		\
+	    offset = read_memory_integer (pc, 2), pc += 2;		\
+	  else if (offset == 0377)		/* bra #long */		\
+	    offset = read_memory_integer (pc, 4), pc += 4;		\
+	  pc += offset;							\
+	  goto retry;							\
+      } else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  insn = read_memory_integer (pc, 2), pc += 2;				\
+  regmask = read_memory_integer (pc, 2);				\
+  if ((insn & 0177760) == 022700)	/* movl rn, (sp) */		\
+    (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr;	\
+  else if ((insn & 0177760) == 024700)	/* movl rn, -(sp) */		\
+    (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr-=4; \
+  else if (insn == 0044327)		/* moveml mask, (sp) */		\
+    { pc += 2;								\
+      /* Regmask's low bit is for register 0, the first written */	\
+      next_addr -= 4;							\
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4);		\
+  } else if (insn == 0044347)		/* moveml mask, -(sp) */	\
+    { pc += 2;								\
+      /* Regmask's low bit is for register 15, the first pushed */	\
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (read_memory_integer (pc, 2) == 041147 				\
+      && read_memory_integer (pc+2, 2) == 042347)			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
+  register int regnum;							\
+  char raw_buffer[12];							\
+  sp = push_word (sp, read_register (PC_REGNUM));			\
+  sp = push_word (sp, read_register (FP_REGNUM));			\
+  write_register (FP_REGNUM, sp);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);	\
+      sp = push_bytes (sp, raw_buffer, 12); }				\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    sp = push_word (sp, read_register (regnum));			\
+  sp = push_word (sp, read_register (PS_REGNUM));			\
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);			\
+  register int regnum;							\
+  struct frame_saved_regs fsr;						\
+  struct frame_info fi;							\
+  char raw_buffer[12];							\
+  fi = get_frame_info (fp);						\
+  get_frame_saved_regs (&fi, &fsr);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    if (fsr.regs[regnum])						\
+      { read_memory (fsr.regs[regnum], raw_buffer, 12);			\
+        write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    if (fsr.regs[regnum])						\
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])						\
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));		\
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));  	\
+  write_register (SP_REGNUM, fp + 8);					\
+}
+
+/* This sequence of words is the instructions
+     fmovem #<f0-f7>,-(sp)
+     moveml 0xfffc,-(sp)
+     clrw -(sp)
+     movew ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jsr @#32323232
+     addl #69696969,sp
+     bpt
+     nop
+Note this is 24 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 28
+
+#define CALL_DUMMY_START_OFFSET 12
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 20) = nargs * 4;  \
+  *(int *)((char *) dummyname + 14) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movl $ end, sp");      \
+  asm ("clrl fp"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("movel fp, -(sp)");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl (sp), fp");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea 10(sp)");	      \
+  asm ("movem $ 0xfffe,-(sp)"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ asm ("subil $8,28(sp)");     \
+  asm ("movem (sp),$ 0xffff"); \
+  asm ("rte"); }
diff --git a/gdb/m-mac-aux.h b/gdb/m-mac-aux.h
new file mode 100644
index 0000000..2f1f84d
--- /dev/null
+++ b/gdb/m-mac-aux.h
@@ -0,0 +1,485 @@
+/* Parameters for execution on Macintosh under A/UX, for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef mac_aux
+#define mac_aux
+#endif
+
+/* Get rid of any system-imposed stack limit if possible.  */
+
+#undef SET_STACK_LIMIT_HUGE
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#undef NAMES_HAVE_UNDERSCORE
+
+/* COFF format object files */
+
+#define COFF_FORMAT
+
+/* System eVil ttys */
+
+#define SYSV_TTYS
+
+/* Debugger information will not be in DBX format.  */
+
+#undef READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)				\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)			\
+    pc += 6;   /* Skip link #long */			\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR 0x20000000
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 2
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 31
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES  \
+ {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
+  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
+  "ps", "pc",  \
+  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
+  "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" }
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PS_REGNUM 16		/* Contains processor status */
+#define PC_REGNUM 17		/* Contains program counter */
+#define FP0_REGNUM 18		/* Floating point register 0 */
+#define FPC_REGNUM 26		/* 68881 control register */
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8*12+8+20)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  \
+ ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168	\
+  : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72	\
+  : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 12 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 8-byte doubles.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_from_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_to_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Enable use of alternate code to read and write registers.  */
+
+#undef NEW_SUN_PTRACE
+
+/* Enable use of alternate code for Sun's format of core dump file.  */
+
+#undef NEW_SUN_CORE
+
+/* Do implement the attach and detach commands.  */
+
+#undef ATTACH_DETACH
+
+/* It is safe to look for symsegs on a Sun, because Sun's ld
+   does not screw up with random garbage at end of file.  */
+
+#define READ_GDB_SYMSEGS
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Sun, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Set VAL to the number of args passed to frame described by FI.
+   Can set VAL to -1, meaning no way to tell.  */
+
+/* We can't tell how many args there are
+   now that the C compiler delays popping them.  */
+#define FRAME_NUM_ARGS(val,fi) (val = -1)
+
+#if 0
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+#endif
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  int nextinsn;								\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+      if (044016 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (047126 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
+      else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  /* But before that can come an fmovem.  Check for it.  */		\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf227 == nextinsn						\
+      && (regmask & 0xff00) == 0xe000)					\
+    { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 12);		\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  if (0044327 == read_memory_integer (pc, 2))				\
+    { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; }	\
+  else if (0044347 == read_memory_integer (pc, 2))			\
+    { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2))		\
+    { regnum = 0xf & read_memory_integer (pc, 2); pc += 2;		\
+      (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* fmovemx to index of sp may follow.  */				\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf236 == nextinsn						\
+      && (regmask & 0xff00) == 0xf000)					\
+    { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12;	\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (0x426742e7 == read_memory_integer (pc, 4))			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
+  register int regnum;							\
+  char raw_buffer[12];							\
+  sp = push_word (sp, read_register (PC_REGNUM));			\
+  sp = push_word (sp, read_register (FP_REGNUM));			\
+  write_register (FP_REGNUM, sp);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);	\
+      sp = push_bytes (sp, raw_buffer, 12); }				\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    sp = push_word (sp, read_register (regnum));			\
+  sp = push_word (sp, read_register (PS_REGNUM));			\
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, 
+   restoring all saved registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  char raw_buffer[12];						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)	 \
+    if (fsr.regs[regnum])					 \
+      { read_memory (fsr.regs[regnum], raw_buffer, 12);		 \
+        write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)		 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])					 \
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+  set_current_frame (read_register (FP_REGNUM)); }
+
+/* This sequence of words is the instructions
+     fmovem 0xff,-(sp)
+     moveml 0xfffc,-(sp)
+     clrw -(sp)
+     movew ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jsr @#32323232
+     addl #69696969,sp
+     bpt
+     nop
+Note this is 28 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 28
+
+#define CALL_DUMMY_START_OFFSET 12
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 20) = nargs * 4;  \
+  *(int *)((char *) dummyname + 14) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movel #end, sp");      \
+  asm ("movel #0,a6"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("movel a6,sp@-");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl sp@,a6");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea sp@(10)");	      \
+  asm ("movem #0xfffe,sp@-"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ asm ("subil #8,sp@(28)");     \
+  asm ("movem sp@,#0xffff"); \
+  asm ("rte"); }
diff --git a/gdb/m-mac-auxinit.h b/gdb/m-mac-auxinit.h
new file mode 100644
index 0000000..bd420ef
--- /dev/null
+++ b/gdb/m-mac-auxinit.h
@@ -0,0 +1,5 @@
+
+/* This is how the size of an individual .o file's text segment
+   is rounded on a mac under a/ux.  */
+
+#define FILEADDR_ROUND(addr) (addr)
diff --git a/gdb/m-merlin.h b/gdb/m-merlin.h
new file mode 100644
index 0000000..7f87979
--- /dev/null
+++ b/gdb/m-merlin.h
@@ -0,0 +1,437 @@
+/* Definitions to make GDB run on a merlin under utek 2.1
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef ns16000
+#define ns16000
+#endif
+
+# include	<machine/reg.h>
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Debugger information will be in DBX format.  */
+
+#define READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   				\
+{ register int op = read_memory_integer (pc, 1);	\
+  if (op == 0x82)					\
+    { op = read_memory_integer (pc+2,1);		\
+      if ((op & 0x80) == 0) pc += 3;			\
+      else if ((op & 0xc0) == 0x80) pc += 4;		\
+      else pc += 6;					\
+    }}
+
+/* Immediately after a function call, return the saved pc.
+   Can't always go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+	read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* This is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values.  */
+
+#define KERNEL_U_ADDR (0xfef000)
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR (0x800000)
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0xf2}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0
+
+/* Define this to say that the "svc" insn is followed by
+   codes in memory saying which kind of system call it is.  */
+
+#define NS32K_SVC_IMMED_OPERANDS
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS		25
+
+#define NUM_GENERAL_REGS	8
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",	\
+			"pc", "sp", "fp", "ps",				\
+ 			"fsr",						\
+ 			"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",	\
+			"l0", "l1", "l2", "l3", "l4",			\
+ 			}
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define AP_REGNUM FP_REGNUM
+#define FP_REGNUM 10		/* Contains address of executing stack frame */
+#define SP_REGNUM 9		/* Contains address of top of stack */
+#define PC_REGNUM 8		/* Contains program counter */
+#define PS_REGNUM 11		/* Contains processor status */
+#define FPS_REGNUM 12		/* Floating point status register */
+#define FP0_REGNUM 13		/* Floating point register 0 */
+#define LP0_REGNUM 21		/* Double register 0 (same as FP0) */
+
+#define REGISTER_U_ADDR(addr, blockend, regno) \
+{ 									\
+  switch (regno) {							\
+  case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:	\
+	addr = blockend + (R0 - regno) * sizeof (int); break;		\
+  case PC_REGNUM:							\
+  	addr = blockend + PC * sizeof (int); break;			\
+  case SP_REGNUM:							\
+  	addr = blockend + SP * sizeof (int); break;			\
+  case FP_REGNUM:							\
+  	addr = blockend + FP * sizeof (int); break;			\
+  case PS_REGNUM:							\
+  	addr = blockend + 12 * sizeof (int); break;			\
+  case FPS_REGNUM:							\
+  	addr = 108; break;						\
+  case FP0_REGNUM + 0: case FP0_REGNUM + 1:				\
+  case FP0_REGNUM + 2: case FP0_REGNUM + 3: 				\
+  case FP0_REGNUM + 4: case FP0_REGNUM + 5: 				\
+  case FP0_REGNUM + 6: case FP0_REGNUM + 7: 				\
+  	addr = 76 + (regno - FP0_REGNUM) * sizeof (float); break;	\
+  case LP0_REGNUM + 0: case LP0_REGNUM + 1:				\
+  case LP0_REGNUM + 2: case LP0_REGNUM + 3:				\
+  	addr = 76 + (regno - LP0_REGNUM) * sizeof (double); break;	\
+  default:								\
+  	printf ("bad argument to REGISTER_U_ADDR %d\n", regno);		\
+	abort ();							\
+  }									\
+}
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
+	LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 32000, all regs are 4 bytes
+   except for the doubled floating registers. */
+
+#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 32000, all regs are 4 bytes
+   except for the doubled floating registers. */
+
+#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 8
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) 0
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+  ((N) >= FP0_REGNUM ?		\
+    ((N) >= LP0_REGNUM ?	\
+     builtin_type_double	\
+     : builtin_type_float)	\
+   : builtin_type_int)	
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Merlin, the frame's nominal address is the FP value,
+   and at that address is saved previous FP value as a 4-byte word.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+/* compute base of arguments */
+#define FRAME_ARGS_ADDRESS(fi) ((fi).frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.  */
+
+#define FRAME_NUM_ARGS(numargs, fi)			\
+{ CORE_ADDR pc;						\
+  int insn;						\
+  int addr_mode;					\
+  int width;						\
+							\
+  pc = FRAME_SAVED_PC (fi.frame);			\
+  insn = read_memory_integer (pc,2);			\
+  addr_mode = (insn >> 11) & 0x1f;			\
+  insn = insn & 0x7ff;					\
+  if ((insn & 0x7fc) == 0x57c				\
+      && addr_mode == 0x14) /* immediate */		\
+    { if (insn == 0x57c) /* adjspb */			\
+	width = 1;					\
+      else if (insn == 0x57d) /* adjspw */		\
+	width = 2;					\
+      else if (insn == 0x57f) /* adjspd */		\
+	width = 4;					\
+      numargs = read_memory_integer (pc+2,width);	\
+      if (width > 1)					\
+	flip_bytes (&numargs, width);			\
+      numargs = - sign_extend (numargs, width*8) / 4; }	\
+  else numargs = -1;					\
+}
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+{ int regmask,regnum;						\
+  int localcount;						\
+  CORE_ADDR enter_addr;						\
+  CORE_ADDR next_addr;						\
+								\
+  enter_addr = get_pc_function_start ((frame_info).pc);		\
+  regmask = read_memory_integer (enter_addr+1, 1);		\
+  localcount = ns32k_localcount (enter_addr);			\
+  next_addr = (frame_info).frame + localcount;			\
+  for (regnum = 0; regnum < 8; regnum++, regmask >>= 1)		\
+    (frame_saved_regs).regs[regnum]				\
+      = (regmask & 1) ? (next_addr -= 4) : 0;			\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4;	\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;	\
+  (frame_saved_regs).regs[FP_REGNUM]				\
+     = read_memory_integer ((frame_info).frame, 4); }
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);	\
+  register int regnum;					\
+  sp = push_word (sp, read_register (PC_REGNUM));	\
+  sp = push_word (sp, read_register (FP_REGNUM));	\
+  write_register (FP_REGNUM, sp);			\
+  for (regnum = 0; regnum < 8; regnum++)  		\
+    sp = push_word (sp, read_register (regnum));	\
+  write_register (SP_REGNUM, sp);  			\
+}
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = 0; regnum < 8; regnum++)			 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+}
+
+/* This sequence of words is the instructions
+     enter	0xff,0		82 ff 00
+     jsr	@0x00010203	7f ae c0 01 02 03
+     adjspd	0x69696969	7f a5 01 02 03 04
+     bpt			f2
+   Note this is 16 bytes.  */
+
+#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
+
+#define CALL_DUMMY_START_OFFSET	3
+#define CALL_DUMMY_LENGTH	16
+#define CALL_DUMMY_ADDR		5
+#define CALL_DUMMY_NARGS	11
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)   		\
+{ int flipped = fun | 0xc0000000;				\
+  flip_bytes (&flipped, 4);					\
+  *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped;	\
+  flipped = - nargs * 4;					\
+  flip_bytes (&flipped, 4);					\
+  *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped;	\
+}
+
+#ifdef notdef
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \
+  0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \
+  0, 0, 0, 0, 0, 0, 0, 0}
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movl $ end, sp");      \
+  asm ("clrl fp"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("pushl fp");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl (sp), fp");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("pushl 8(sp)");        \
+  asm ("pushl 8(sp)");        \
+  asm ("pushal 0x14(sp)");    \
+  asm ("pushr $037777"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS      \
+{ asm ("popr $037777");    \
+  asm ("subl2 $8,(sp)");   \
+  asm ("movl (sp),sp");    \
+  asm ("rei"); }
+#endif
diff --git a/gdb/m-news800.h b/gdb/m-news800.h
new file mode 100644
index 0000000..44583e3
--- /dev/null
+++ b/gdb/m-news800.h
@@ -0,0 +1,566 @@
+/* Parameters for execution on a Sony/NEWS, for GDB, the GNU debugger.
+
+Here is an m-news800.h file for gdb version 2.1.  It supports the 68881
+registers.
+
+Now(9/2 '87) NEWS's printf has a bug. 
+And support Sun assembly format instead of Motorola one.
+Probably not well support floating registers from core file rarely that
+I do not know detail.
+(hikichi@srava.sra.junet or hikichi%srava.sra.junet%kddlabs%seismo.CSS.GOV) 
+
+Here is IEEE nan routine to use such bug fixed.
+
+	printf("%g\n", Nan);
+
+> struct ieee {                         |* IEEE floating format *|
+>   unsigned int s:1;
+>   unsigned int e:11;
+>   unsigned int f1:20;
+>   unsigned int f2;
+> };
+> 
+> #define ZERO_F(x)  ((x.f1 == 0) && (x.f2 == 0))     |* zero fraction ? *|
+> #define ZERO_E(x)  (x.e == 0)                       |* zero exponential ? *|
+> #define MAX_E(x)   (x.e == 0x7ff)                   |* max exponential ? *|
+> #define MINUS_S(x) (x.s == 1)                       |* minus ? *|
+> 
+> int
+> is_nan(arg)                            |* Not a Number ? *|
+> struct ieee arg;
+> {
+>   if (MAX_E(arg) && !ZERO_F(arg))
+>     return (1);
+>   else
+>     return (0);
+> }
+> 
+> int
+> is_plus_infinity(arg)
+> struct ieee arg;
+> {
+>   if (!MINUS_S(arg) && MAX_E(arg) && ZERO_F(arg))
+>     return (1);
+>   else
+>     return (0);
+> }
+> 
+> int
+> is_minus_infinity(arg)
+> struct ieee arg;
+> {
+>   if (MINUS_S(arg) && MAX_E(arg) && ZERO_F(arg))
+>     return (1);
+>   else
+>     return (0);
+> }
+> 
+> int
+> is_denormal(arg)
+> struct ieee arg;
+> {
+>   if (ZERO_E(arg))
+>     return (1);
+>   else
+>     return (0);
+> }
+
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifdef 0  /* cannot use RCS id since initialize routine fails. */
+static char *RCSid =
+"$Header: m-news800.h,v 1.1 87/09/21 21:27:52 hikichi Exp $";
+#endif  lint
+
+/*
+ * $Log:	m-news800.h,v $
+ * Revision 1.1  87/09/21  21:27:52  hikichi
+ * Initial revision
+ * 
+ */
+
+/* Identify this machine */
+#ifndef news800
+#define news800
+#endif
+
+/* #define USE_GAS */
+
+/* Motorola assembly format */
+#ifndef USE_GAS
+#define MOTOROLA
+#endif
+
+/* bug when printf special number; NAN */
+#define PRINTF_BUG
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)					\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)				\
+    pc += 6;   /* Skip link #long */                    \
+}
+
+
+/* Immediately after a function call, return the saved pc.
+   Can't always go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* THis is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values. */
+
+#define KERNEL_U_ADDR UADDR
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR	(0x80000000 - ctob(UPAGES + 1))
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 2
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p) 0   /* Just a first guess; not checked */
+
+/* Say how long registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 29
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES  \
+ {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
+  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
+  "pc", "ps",  \
+  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
+  "fpcontrol", "fpstatus", "fpiaddr" }
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PC_REGNUM 16		/* Contains program counter */
+#define PS_REGNUM 17		/* Contains processor status */
+#define FP0_REGNUM 18		/* Floating point register 0 */
+#define FPC_REGNUM 26		/* 68881 control register */
+
+#define REGISTER_U_ADDR(addr, blockend, regno)		\
+{	if (regno <= FP_REGNUM) \
+	  addr = blockend + 4 + regno * 4; \
+	else if (regno == SP_REGNUM) \
+	  addr = blockend - 4 * 4; \
+	else if (regno <= PS_REGNUM) \
+	  addr = blockend + (regno - PS_REGNUM) * 4; \
+	else if (regno < FPC_REGNUM) \
+	  addr = blockend + 4 + 4 * 14 + 4 * 5 + (regno - FP0_REGNUM) * 12; \
+	else \
+	  addr = blockend + 4 + 4 * 16 + (regno - FPC_REGNUM) * 4; \
+}
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8*12+8+12)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  \
+ ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168	\
+  : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72	\
+  : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 12 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 8-byte doubles.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_from_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_to_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the NEWS, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.  */
+
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  register int insn;							\
+  register int offset;							\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next,			\
+	 or a branch followed by a link a6 instruction;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+retry:									\
+      insn = read_memory_integer (pc, 2);				\
+      if (insn == 044016)						\
+	next_addr = (frame_info).frame - read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (insn == 047126)						\
+	next_addr = (frame_info).frame - read_memory_integer (pc += 2, 2), pc+=2; \
+      else if ((insn & 0177400) == 060000)	/* bra insn */		\
+	{ offset = insn & 0377;						\
+          pc += 2;				/* advance past bra */	\
+	  if (offset == 0)			/* bra #word */		\
+	    offset = read_memory_integer (pc, 2), pc += 2;		\
+	  else if (offset == 0377)		/* bra #long */		\
+	    offset = read_memory_integer (pc, 4), pc += 4;		\
+	  pc += offset;							\
+	  goto retry;							\
+      } else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  insn = read_memory_integer (pc, 2), pc += 2;				\
+  regmask = read_memory_integer (pc, 2);				\
+  if ((insn & 0177760) == 022700)	/* movl rn, (sp) */		\
+    (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr;	\
+  else if ((insn & 0177760) == 024700)	/* movl rn, -(sp) */		\
+    (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr-=4; \
+  else if (insn == 0044327)		/* moveml mask, (sp) */		\
+    { pc += 2;								\
+      /* Regmask's low bit is for register 0, the first written */	\
+      next_addr -= 4;							\
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4);		\
+  } else if (insn == 0044347)		/* moveml mask, -(sp) */	\
+    { pc += 2;								\
+      /* Regmask's low bit is for register 15, the first pushed */	\
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (read_memory_integer (pc, 2) == 041147 				\
+      && read_memory_integer (pc+2, 2) == 042347)			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
+  register int regnum;							\
+  char raw_buffer[12];							\
+  sp = push_word (sp, read_register (PC_REGNUM));			\
+  sp = push_word (sp, read_register (FP_REGNUM));			\
+  write_register (FP_REGNUM, sp);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);	\
+      sp = push_bytes (sp, raw_buffer, 12); }				\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    sp = push_word (sp, read_register (regnum));			\
+  sp = push_word (sp, read_register (PS_REGNUM));			\
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);			\
+  register int regnum;							\
+  struct frame_saved_regs fsr;						\
+  struct frame_info fi;							\
+  char raw_buffer[12];							\
+  fi = get_frame_info (fp);						\
+  get_frame_saved_regs (&fi, &fsr);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    if (fsr.regs[regnum])						\
+      { read_memory (fsr.regs[regnum], raw_buffer, 12);			\
+        write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    if (fsr.regs[regnum])						\
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])						\
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));		\
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));  	\
+  write_register (SP_REGNUM, fp + 8);					\
+}
+
+/* This sequence of words is the instructions
+     fmove.m #<f0-f7>,-(sp)
+     movem.l 0xfffc,-(sp)
+     clr.w -(sp)
+     move.w ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jbsr (#32323232)
+     add.l #69696969,sp
+     bpt
+     nop
+Note this is 24 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 28
+
+#define CALL_DUMMY_START_OFFSET 12
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 20) = nargs * 4;  \
+  *(int *)((char *) dummyname + 14) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#ifdef MOTOROLA
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("move.l $ end, sp");      \
+  asm ("clr.l fp"); }
+#else
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movel $ end, sp");      \
+  asm ("clrl fp"); }
+#endif
+
+/* Push the frame pointer register on the stack.  */
+#ifdef MOTOROLA
+#define PUSH_FRAME_PTR        \
+  asm ("move.l fp, -(sp)");
+#else
+#define PUSH_FRAME_PTR        \
+  asm ("movel fp, -(sp)");
+#endif
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#ifdef MOTOROLA
+#define POP_FRAME_PTR  \
+  asm ("move.l (sp), fp");
+#else
+#define POP_FRAME_PTR  \
+  asm ("movl (sp), fp");
+#endif
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#ifdef MOTOROLA
+#define PUSH_REGISTERS        \
+{ asm ("clr.w -(sp)");	      \
+  asm ("pea (10,sp)");	      \
+  asm ("movem $ 0xfffe,-(sp)"); }
+#else
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea 10(sp)");	      \
+  asm ("movem $ 0xfffe,-(sp)"); }
+#endif
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#ifdef MOTOROLA
+#define POP_REGISTERS          \
+{ asm ("subi.l $8,28(sp)");     \
+  asm ("movem (sp),$ 0xffff"); \
+  asm ("rte"); }
+#else
+#define POP_REGISTERS          \
+{ asm ("subil $8,28(sp)");     \
+  asm ("movem (sp),$ 0xffff"); \
+  asm ("rte"); }
+#endif
+
diff --git a/gdb/m-newsinit.h b/gdb/m-newsinit.h
new file mode 100644
index 0000000..d902edf
--- /dev/null
+++ b/gdb/m-newsinit.h
@@ -0,0 +1,4 @@
+/* This is how the size of an individual .o file's text segment
+   is rounded on a SONY NEWS.  */
+
+#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
diff --git a/gdb/m-sun2.h b/gdb/m-sun2.h
new file mode 100644
index 0000000..833c923
--- /dev/null
+++ b/gdb/m-sun2.h
@@ -0,0 +1,421 @@
+/* Parameters for execution on a Sun, for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef sun2
+#define sun2
+#endif
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Debugger information will be in DBX format.  */
+
+#define READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)				\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)			\
+    pc += 6;   /* Skip link #long */			\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* This is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values.  */
+
+#define KERNEL_U_ADDR 0x2800
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR 0x1000000
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 2
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
+
+/* Say how long registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 18
+
+/* Number that are really general registers */
+
+#define NUM_GENERAL_REGS 16
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", "ps", "pc"}
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PS_REGNUM 16		/* Contains processor status */
+#define PC_REGNUM 17		/* Contains program counter */
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  ((N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) 4
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) 4
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 4
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 4
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) 0
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)  bcopy ((FROM), (TO), 4);
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)  bcopy ((FROM), (TO), 4);
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N)  builtin_type_int
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* This is a piece of magic that is given a register number REGNO
+   and as BLOCKEND the address in the system of the end of the user structure
+   and stores in ADDR the address in the kernel or core dump
+   of that register.  */
+
+#define REGISTER_U_ADDR(addr, blockend, regno)		\
+{ addr = blockend + regno * 4; }
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Sun, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Set VAL to the number of args passed to frame described by FI.
+   Can set VAL to -1, meaning no way to tell.  */
+
+/* We can't tell how many args there are
+   now that the C compiler delays popping them.  */
+#define FRAME_NUM_ARGS(val,fi) (val = -1)
+
+#if 0
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+#endif
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+      if (044016 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (047126 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
+      else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  if (0044327 == read_memory_integer (pc, 2))				\
+    { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; }	\
+  else if (0044347 == read_memory_integer (pc, 2))			\
+    { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2))		\
+    { regnum = 0xf & read_memory_integer (pc, 2); pc += 2;		\
+      (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (0x426742e7 == read_memory_integer (pc, 4))			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);\
+  register int regnum;				    \
+  sp = push_word (sp, read_register (PC_REGNUM));   \
+  sp = push_word (sp, read_register (FP_REGNUM));   \
+  write_register (FP_REGNUM, sp);		    \
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)  \
+    sp = push_word (sp, read_register (regnum));    \
+  sp = push_word (sp, read_register (PS_REGNUM));   \
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)		 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])					 \
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+}
+
+/* This sequence of words is the instructions
+     moveml 0xfffc,-(sp)
+     clrw -(sp)
+     movew ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jsr @#32323232
+     addl #69696969,sp
+     bpt
+     nop
+Note this is 24 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 24
+
+#define CALL_DUMMY_START_OFFSET 8
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 16) = nargs * 4;  \
+  *(int *)((char *) dummyname + 10) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movel $ end, sp");      \
+  asm ("clrl fp"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("movel fp, -(sp)");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl (sp), fp");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea 10(sp)");	      \
+  asm ("movem $ 0xfffe,-(sp)"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ asm ("subil $8,28(sp)");     \
+  asm ("movem (sp),$ 0xffff"); \
+  asm ("rte"); }
diff --git a/gdb/m-sun3.h b/gdb/m-sun3.h
new file mode 100644
index 0000000..9d703aa
--- /dev/null
+++ b/gdb/m-sun3.h
@@ -0,0 +1,477 @@
+/* Parameters for execution on a Sun, for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef sun3
+#define sun3
+#endif
+
+/* Get rid of any system-imposed stack limit if possible.  */
+
+#define SET_STACK_LIMIT_HUGE
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Debugger information will be in DBX format.  */
+
+#define READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 2);	\
+  if (op == 0047126)				\
+    pc += 4;   /* Skip link #word */			\
+  else if (op == 0044016)			\
+    pc += 6;   /* Skip link #long */			\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR 0xf000000
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0x4e, 0x4f}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 2
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0x4e76)
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 31
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES  \
+ {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \
+  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \
+  "ps", "pc",  \
+  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \
+  "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" }
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP_REGNUM 14		/* Contains address of executing stack frame */
+#define SP_REGNUM 15		/* Contains address of top of stack */
+#define PS_REGNUM 16		/* Contains processor status */
+#define PC_REGNUM 17		/* Contains program counter */
+#define FP0_REGNUM 18		/* Floating point register 0 */
+#define FPC_REGNUM 26		/* 68881 control register */
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (16*4+8*12+8+20)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N)  \
+ ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168	\
+  : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72	\
+  : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 12 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 68000, all regs are 4 bytes
+   except the floating point regs which are 8-byte doubles.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 12
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8)
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_from_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM)	\
+    convert_to_68881 ((FROM), (TO));	\
+  else					\
+    bcopy ((FROM), (TO), 4); }
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+ (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : builtin_type_int)
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Enable use of alternate code to read and write registers.  */
+
+#define NEW_SUN_PTRACE
+
+/* Enable use of alternate code for Sun's format of core dump file.  */
+
+#define NEW_SUN_CORE
+
+/* Do implement the attach and detach commands.  */
+
+#define ATTACH_DETACH
+
+/* It is safe to look for symsegs on a Sun, because Sun's ld
+   does not screw up with random garbage at end of file.  */
+
+#define READ_GDB_SYMSEGS
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Sun, the frame's nominal address
+   is the address of a 4-byte word containing the calling frame's address.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+#define FRAME_ARGS_ADDRESS(fi) (fi.frame)
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
+
+/* Set VAL to the number of args passed to frame described by FI.
+   Can set VAL to -1, meaning no way to tell.  */
+
+/* We can't tell how many args there are
+   now that the C compiler delays popping them.  */
+#define FRAME_NUM_ARGS(val,fi) (val = -1)
+
+#if 0
+#define FRAME_NUM_ARGS(val, fi)  \
+{ register CORE_ADDR pc = FRAME_SAVED_PC (fi.frame);		\
+  register int insn = 0177777 & read_memory_integer (pc, 2);	\
+  val = 0;							\
+  if (insn == 0047757 || insn == 0157374)  /* lea W(sp),sp or addaw #W,sp */ \
+    val = read_memory_integer (pc + 2, 2);			\
+  else if ((insn & 0170777) == 0050217 /* addql #N, sp */	\
+	   || (insn & 0170777) == 0050117)  /* addqw */		\
+    { val = (insn >> 9) & 7; if (val == 0) val = 8; }		\
+  else if (insn == 0157774) /* addal #WW, sp */			\
+    val = read_memory_integer (pc + 2, 4);			\
+  val >>= 2; }
+#endif
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
+{ register int regnum;							\
+  register int regmask;							\
+  register CORE_ADDR next_addr;						\
+  register CORE_ADDR pc;						\
+  int nextinsn;								\
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
+  if ((frame_info).pc >= (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \
+      && (frame_info).pc <= (frame_info).frame)				\
+    { next_addr = (frame_info).frame;					\
+      pc = (frame_info).frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\
+  else   								\
+    { pc = get_pc_function_start ((frame_info).pc); 			\
+      /* Verify we have a link a6 instruction next;			\
+	 if not we lose.  If we win, find the address above the saved   \
+	 regs using the amount of storage from the link instruction.  */\
+      if (044016 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 4), pc+=4; \
+      else if (047126 == read_memory_integer (pc, 2))			\
+	next_addr = (frame_info).frame + read_memory_integer (pc += 2, 2), pc+=2; \
+      else goto lose;							\
+      /* If have an addal #-n, sp next, adjust next_addr.  */		\
+      if ((0177777 & read_memory_integer (pc, 2)) == 0157774)		\
+	next_addr += read_memory_integer (pc += 2, 4), pc += 4;		\
+    }									\
+  /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */	\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  /* But before that can come an fmovem.  Check for it.  */		\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf227 == nextinsn						\
+      && (regmask & 0xff00) == 0xe000)					\
+    { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 12);		\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  if (0044327 == read_memory_integer (pc, 2))				\
+    { pc += 4; /* Regmask's low bit is for register 0, the first written */ \
+      for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; }	\
+  else if (0044347 == read_memory_integer (pc, 2))			\
+    { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \
+      for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2))		\
+    { regnum = 0xf & read_memory_integer (pc, 2); pc += 2;		\
+      (frame_saved_regs).regs[regnum] = (next_addr -= 4); }		\
+  /* fmovemx to index of sp may follow.  */				\
+  regmask = read_memory_integer (pc + 2, 2);				\
+  nextinsn = 0xffff & read_memory_integer (pc, 2);			\
+  if (0xf236 == nextinsn						\
+      && (regmask & 0xff00) == 0xf000)					\
+    { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \
+      for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1)		\
+	if (regmask & 1)						\
+          (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12;	\
+      regmask = read_memory_integer (pc + 2, 2); }			\
+  /* clrw -(sp); movw ccr,-(sp) may follow.  */				\
+  if (0x426742e7 == read_memory_integer (pc, 4))			\
+    (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4);		\
+  lose: ;								\
+  (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 8;		\
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame;		\
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;		\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
+  register int regnum;							\
+  char raw_buffer[12];							\
+  sp = push_word (sp, read_register (PC_REGNUM));			\
+  sp = push_word (sp, read_register (FP_REGNUM));			\
+  write_register (FP_REGNUM, sp);					\
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)		\
+    { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);	\
+      sp = push_bytes (sp, raw_buffer, 12); }				\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)			\
+    sp = push_word (sp, read_register (regnum));			\
+  sp = push_word (sp, read_register (PS_REGNUM));			\
+  write_register (SP_REGNUM, sp);  }
+
+/* Discard from the stack the innermost frame, 
+   restoring all saved registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  char raw_buffer[12];						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)	 \
+    if (fsr.regs[regnum])					 \
+      { read_memory (fsr.regs[regnum], raw_buffer, 12);		 \
+        write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\
+  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)		 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  if (fsr.regs[PS_REGNUM])					 \
+    write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+  set_current_frame (read_register (FP_REGNUM)); }
+
+/* This sequence of words is the instructions
+     fmovem 0xff,-(sp)
+     moveml 0xfffc,-(sp)
+     clrw -(sp)
+     movew ccr,-(sp)
+     /..* The arguments are pushed at this point by GDB;
+	no code is needed in the dummy for this.
+	The CALL_DUMMY_START_OFFSET gives the position of 
+	the following jsr instruction.  *../
+     jsr @#32323232
+     addl #69696969,sp
+     bpt
+     nop
+Note this is 28 bytes.
+We actually start executing at the jsr, since the pushing of the
+registers is done by PUSH_DUMMY_FRAME.  If this were real code,
+the arguments for the function called by the jsr would be pushed
+between the moveml and the jsr, and we could allow it to execute through.
+But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
+and we cannot allow the moveml to push the registers again lest they be
+taken for the arguments.  */
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71}
+
+#define CALL_DUMMY_LENGTH 28
+
+#define CALL_DUMMY_START_OFFSET 12
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)     \
+{ *(int *)((char *) dummyname + 20) = nargs * 4;  \
+  *(int *)((char *) dummyname + 14) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
+  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
+  0, 0, 0, 0, 0, 0, 0, 0, \
+  SIGILL }
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movel #end, sp");      \
+  asm ("movel #0,a6"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("movel a6,sp@-");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl sp@,a6");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("clrw -(sp)");	      \
+  asm ("pea sp@(10)");	      \
+  asm ("movem #0xfffe,sp@-"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS          \
+{ asm ("subil #8,sp@(28)");     \
+  asm ("movem sp@,#0xffff"); \
+  asm ("rte"); }
diff --git a/gdb/m-suninit.h b/gdb/m-suninit.h
new file mode 100644
index 0000000..2e2f08c
--- /dev/null
+++ b/gdb/m-suninit.h
@@ -0,0 +1,5 @@
+
+/* This is how the size of an individual .o file's text segment
+   is rounded on a sun.  */
+
+#define FILEADDR_ROUND(addr) (addr)
diff --git a/gdb/m-umax.h b/gdb/m-umax.h
new file mode 100644
index 0000000..d894b56
--- /dev/null
+++ b/gdb/m-umax.h
@@ -0,0 +1,425 @@
+/* Definitions to make GDB run on an encore under umax 4.2
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef ns16000
+#define ns16000
+#endif
+
+#define HAVE_WAIT_STRUCT
+
+/* Encore's modifications to ptrace format */
+
+#define UMAX_PTRACE
+
+/* Encore's modifications to core-file format */
+
+#define UMAX_CORE
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Exec files and symbol tables are in COFF format */
+
+#define COFF_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 0
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   				\
+{ register unsigned char op = read_memory_integer (pc, 1);	\
+  if (op == 0x82) { op = read_memory_integer (pc+2,1);  \
+  		    if ((op & 0x80) == 0) pc += 3;	\
+		    else if ((op & 0xc0) == 0x80) pc += 4;	\
+		    else pc += 6;			\
+		   }					\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't always go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) \
+	read_memory_integer (read_register (SP_REGNUM), 4)
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR (0xfffff000)
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {0xf2}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12)
+
+#ifndef NaN
+#include <nan.h>
+#endif NaN
+
+/* Return 1 if P points to an invalid floating point value.  */
+
+#define INVALID_FLOAT(p, s) \
+	 ((s == sizeof (float))?	\
+		NaF (*(float *) p) :	\
+		NaD (*(double *) p))
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS		25
+
+#define NUM_GENERAL_REGS	8
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",	\
+ 			"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",	\
+			"sp", "fp", "pc", "ps",				\
+ 			"fsr",						\
+			"l0", "l1", "l2", "l3", "xx",			\
+ 			}
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define FP0_REGNUM 8		/* Floating point register 0 */
+#define SP_REGNUM 16		/* Contains address of top of stack */
+#define AP_REGNUM FP_REGNUM
+#define FP_REGNUM 17		/* Contains address of executing stack frame */
+#define PC_REGNUM 18		/* Contains program counter */
+#define PS_REGNUM 19		/* Contains processor status */
+#define FPS_REGNUM 20		/* Floating point status register */
+#define LP0_REGNUM 21		/* Double register 0 (same as FP0) */
+
+/* called from register_addr() -- blockend not used for now */
+#define REGISTER_U_ADDR(addr, blockend, regno) \
+{ 									\
+  switch (regno) {							\
+  case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:	\
+	addr = PU_R0 - (regno * sizeof (int)); break;			\
+  case SP_REGNUM:							\
+  	addr = PU_SP; break;						\
+  case PC_REGNUM:							\
+  	addr = PU_PC; break;						\
+  case FP_REGNUM:							\
+  	addr = PU_FP; break;						\
+  case PS_REGNUM:							\
+  	addr = PU_PSL; break;						\
+  case FPS_REGNUM:							\
+  	addr = PU_FSR; break;						\
+  case FP0_REGNUM + 0: case FP0_REGNUM + 1:				\
+  case FP0_REGNUM + 2: case FP0_REGNUM + 3: 				\
+  case FP0_REGNUM + 4: case FP0_REGNUM + 5: 				\
+  case FP0_REGNUM + 6: case FP0_REGNUM + 7: 				\
+  	addr = PU_F0 + (regno - FP0_REGNUM) * sizeof (float); break;	\
+  case LP0_REGNUM + 0: case LP0_REGNUM + 1:				\
+  case LP0_REGNUM + 2: case LP0_REGNUM + 3:				\
+  	addr = PU_F0 + (regno - LP0_REGNUM) * sizeof (double); break;	\
+  default:								\
+  	printf ("bad argument to REGISTER_U_ADDR %d\n", regno);		\
+	abort ();							\
+  }									\
+}
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double))
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \
+	LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the 32000, all regs are 4 bytes
+   except for the doubled floating registers. */
+
+#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the 32000, all regs are 4 bytes
+   except for the doubled floating registers. */
+
+#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 8
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) 0
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM));
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) \
+	(((N) < FP0_REGNUM) ?				\
+		builtin_type_int :			\
+		((N) < FP0_REGNUM + 8) ?		\
+			builtin_type_float :		\
+			((N) < LP0_REGNUM) ?		\
+				builtin_type_int :	\
+				builtin_type_double)
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the ns32000 series, the frame's nominal address is the FP
+   value, and at that address is saved previous FP value as a 4-byte word.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 4, 4))
+
+/* Compute base of arguments. */
+
+#define FRAME_ARGS_ADDRESS(fi)	\
+  ((n32k_get_enter_addr (fi.pc) > 1) ? \
+	((fi).frame) : (read_register (SP_REGNUM) - 4))
+
+#define FRAME_LOCALS_ADDRESS(fi) ((fi).frame)
+
+/* Get the address of the enter opcode for this function, if it is active.
+   Returns positive address > 1 if pc is between enter/exit,
+   1 if pc before enter or after exit, 0 otherwise. */
+
+extern CORE_ADDR n32k_get_enter_addr ();
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.
+   Encore's C compiler often reuses same area on stack for args,
+   so this will often not work properly.  If the arg names
+   are known, it's likely most of them will be printed. */
+
+#define FRAME_NUM_ARGS(numargs, fi)			\
+{ CORE_ADDR	pc;					\
+  CORE_ADDR	enter_addr;				\
+  unsigned int	insn;					\
+  unsigned int	addr_mode;				\
+  int width;						\
+							\
+  numargs = -1;						\
+  enter_addr = n32k_get_enter_addr (fi.pc);		\
+  if (enter_addr > 0)					\
+    {							\
+      pc = (enter_addr == 1) ?				\
+	SAVED_PC_AFTER_CALL () :			\
+	FRAME_SAVED_PC (fi.frame);			\
+      insn = read_memory_integer (pc,2);		\
+      addr_mode = (insn >> 11) & 0x1f;			\
+      insn = insn & 0x7ff;				\
+      if ((insn & 0x7fc) == 0x57c &&			\
+		addr_mode == 0x14) /* immediate */	\
+	{						\
+	  if (insn == 0x57c) /* adjspb */		\
+  		width = 1;				\
+	  else if (insn == 0x57d) /* adjspw */		\
+  		width = 2;				\
+	  else if (insn == 0x57f) /* adjspd */		\
+  		width = 4;				\
+	  numargs = read_memory_integer (pc+2,width);	\
+	  if (width > 1)				\
+	    flip_bytes (&numargs, width);		\
+	  numargs = - sign_extend (numargs, width*8) / 4;\
+	}						\
+    }							\
+}
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 8
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)	\
+{ 								\
+  register int	regmask, regnum;				\
+  int		localcount;					\
+  register CORE_ADDR	enter_addr;				\
+  register CORE_ADDR	next_addr;				\
+								\
+  bzero (&(frame_saved_regs), sizeof (frame_saved_regs));	\
+  enter_addr = n32k_get_enter_addr ((frame_info).pc);		\
+  if (enter_addr > 1)						\
+    {								\
+      regmask = read_memory_integer (enter_addr+1, 1) & 0xff;	\
+      localcount = n32k_localcount (enter_addr);		\
+      next_addr = (frame_info).frame + localcount;		\
+      for (regnum = 0; regnum < 8; regnum++, regmask >>= 1)	\
+	(frame_saved_regs).regs[regnum] = (regmask & 1) ?	\
+					  (next_addr -= 4) : 0;	\
+      (frame_saved_regs).regs[SP_REGNUM] = (frame_info).frame + 4;\
+      (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 4;\
+      (frame_saved_regs).regs[FP_REGNUM] =			\
+		  (read_memory_integer ((frame_info).frame, 4));\
+    }								\
+  else if (enter_addr == 1)					\
+    {								\
+      CORE_ADDR sp = read_register (SP_REGNUM);			\
+      (frame_saved_regs).regs[PC_REGNUM] = sp;			\
+      (frame_saved_regs).regs[SP_REGNUM] = sp + 4;		\
+    }								\
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);\
+  register int regnum;				    \
+  sp = push_word (sp, read_register (PC_REGNUM));   \
+  sp = push_word (sp, read_register (FP_REGNUM));   \
+  write_register (FP_REGNUM, sp);		    \
+  for (regnum = 0; regnum < 8; regnum++)  \
+    sp = push_word (sp, read_register (regnum));    \
+  write_register (SP_REGNUM, sp);  			\
+}
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  struct frame_saved_regs fsr;					 \
+  struct frame_info fi;						 \
+  fi = get_frame_info (fp);					 \
+  get_frame_saved_regs (&fi, &fsr);				 \
+  for (regnum = 0; regnum < 8; regnum++)			 \
+    if (fsr.regs[regnum])					 \
+      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
+  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));   \
+  write_register (SP_REGNUM, fp + 8);				 \
+}
+
+/* This sequence of words is the instructions
+     enter	0xff,0		82 ff 00
+     jsr	@0x00010203	7f ae c0 01 02 03
+     adjspd	0x69696969	7f a5 01 02 03 04
+     bpt			f2
+   Note this is 16 bytes.  */
+
+#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 }
+
+#define CALL_DUMMY_START_OFFSET	3
+#define CALL_DUMMY_LENGTH	16
+#define CALL_DUMMY_ADDR		5
+#define CALL_DUMMY_NARGS	11
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)   		\
+{								\
+	int	flipped;					\
+	flipped = fun | 0xc0000000;				\
+	flip_bytes (&flipped, 4);				\
+	*((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped;	\
+	flipped = - nargs * 4;					\
+	flip_bytes (&flipped, 4);				\
+	*((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped;	\
+}
diff --git a/gdb/m-vax.h b/gdb/m-vax.h
new file mode 100644
index 0000000..578af44
--- /dev/null
+++ b/gdb/m-vax.h
@@ -0,0 +1,375 @@
+/* Definitions to make GDB run on a vax under 4.2bsd.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#ifndef vax
+#define vax
+#endif
+
+/* Get rid of any system-imposed stack limit if possible.  */
+
+#define SET_STACK_LIMIT_HUGE
+
+/* Define this if the C compiler puts an underscore at the front
+   of external names before giving them to the linker.  */
+
+#define NAMES_HAVE_UNDERSCORE
+
+/* Debugger information will be in DBX format.  */
+
+#define READ_DBX_FORMAT
+
+/* Offset from address of function to start of its code.
+   Zero on most machines.  */
+
+#define FUNCTION_START_OFFSET 2
+
+/* Advance PC across any function entry prologue instructions
+   to reach some "real" code.  */
+
+#define SKIP_PROLOGUE(pc)   \
+{ register int op = read_memory_integer (pc, 1);	\
+  if (op == 0x11) pc += 2;  /* skip brb */		\
+  if (op == 0x31) pc += 3;  /* skip brw */		\
+}
+
+/* Immediately after a function call, return the saved pc.
+   Can't always go through the frames for this because on some machines
+   the new frame is not set up until the new function executes
+   some instructions.  */
+
+#define SAVED_PC_AFTER_CALL(frame) FRAME_SAVED_PC(frame)
+
+/* This is the amount to subtract from u.u_ar0
+   to get the offset in the core file of the register values.  */
+
+#define KERNEL_U_ADDR (0x80000000 - (UPAGES * NBPG))
+
+/* Address of end of stack space.  */
+
+#define STACK_END_ADDR (0x80000000 - (UPAGES * NBPG))
+
+/* Stack grows downward.  */
+
+#define INNER_THAN <
+
+/* Sequence of bytes for breakpoint instruction.  */
+
+#define BREAKPOINT {3}
+
+/* Amount PC must be decremented by after a breakpoint.
+   This is often the number of bytes in BREAKPOINT
+   but not always.  */
+
+#define DECR_PC_AFTER_BREAK 0
+
+/* Nonzero if instruction at PC is a return instruction.  */
+
+#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 04)
+
+/* Return 1 if P points to an invalid floating point value.
+   LEN is the length in bytes -- not relevant on the Vax.  */
+
+#define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000)
+
+/* Say how long (ordinary) registers are.  */
+
+#define REGISTER_TYPE long
+
+/* Number of machine registers */
+
+#define NUM_REGS 17
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.  */
+
+#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc", "ps"}
+
+/* Register numbers of various important registers.
+   Note that some of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and some are "phony" register numbers which are too large
+   to be actual register numbers as far as the user is concerned
+   but do serve to get the desired values when passed to read_register.  */
+
+#define AP_REGNUM 12
+#define FP_REGNUM 13		/* Contains address of executing stack frame */
+#define SP_REGNUM 14		/* Contains address of top of stack */
+#define PC_REGNUM 15		/* Contains program counter */
+#define PS_REGNUM 16		/* Contains processor status */
+
+#define REGISTER_U_ADDR(addr, blockend, regno)		\
+{ addr = blockend - 0110 + regno * 4;			\
+  if (regno == PC_REGNUM) addr = blockend - 8;		\
+  if (regno == PS_REGNUM) addr = blockend - 4;		\
+  if (regno == FP_REGNUM) addr = blockend - 0120;	\
+  if (regno == AP_REGNUM) addr = blockend - 0124;	\
+  if (regno == SP_REGNUM) addr = blockend - 20; }
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+#define REGISTER_BYTES (17*4)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#define REGISTER_BYTE(N) ((N) * 4)
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the vax, all regs are 4 bytes.  */
+
+#define REGISTER_RAW_SIZE(N) 4
+
+/* Number of bytes of storage in the program's representation
+   for register N.  On the vax, all regs are 4 bytes.  */
+
+#define REGISTER_VIRTUAL_SIZE(N) 4
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#define MAX_REGISTER_RAW_SIZE 4
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+
+#define MAX_REGISTER_VIRTUAL_SIZE 4
+
+/* Nonzero if register N requires conversion
+   from raw format to virtual format.  */
+
+#define REGISTER_CONVERTIBLE(N) 0
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), 4);
+
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)	\
+  bcopy ((FROM), (TO), 4);
+
+/* Return the GDB type object for the "standard" data type
+   of data in register N.  */
+
+#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int
+
+/* Extract from an array REGBUF containing the (raw) register state
+   a function return value of type TYPE, and copy that, in virtual format,
+   into VALBUF.  */
+
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Write into appropriate registers a function return value
+   of type TYPE, given in virtual format.  */
+
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+
+/* Extract from an array REGBUF containing the (raw) register state
+   the address in which a function should return its structure value,
+   as a CORE_ADDR (or an expression that can be used as one).  */
+
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+
+/* Describe the pointer in each stack frame to the previous stack frame
+   (its caller).  */
+
+/* FRAME_CHAIN takes a frame's nominal address
+   and produces the frame's chain-pointer.
+
+   FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
+   and produces the nominal address of the caller frame.
+
+   However, if FRAME_CHAIN_VALID returns zero,
+   it means the given frame is the outermost one and has no caller.
+   In that case, FRAME_CHAIN_COMBINE is not used.  */
+
+/* In the case of the Vax, the frame's nominal address is the FP value,
+   and 12 bytes later comes the saved previous FP value as a 4-byte word.  */
+
+#define FRAME_CHAIN(thisframe)  (read_memory_integer (thisframe + 12, 4))
+
+#define FRAME_CHAIN_VALID(chain, thisframe) \
+  (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end))
+
+#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+
+/* Define other aspects of the stack frame.  */
+
+#define FRAME_SAVED_PC(frame) (read_memory_integer (frame + 16, 4))
+
+/* Cannot find the AP register value directly from the FP value.
+   Must find it saved in the frame called by this one, or in the AP register
+   for the innermost frame.  */
+#define FRAME_ARGS_ADDRESS(fi) \
+ (((fi).next_frame                                  \
+   ? read_memory_integer ((fi).next_frame + 8, 4)   \
+   : read_register (AP_REGNUM)))
+
+#define FRAME_LOCALS_ADDRESS(fi) (fi).frame
+
+/* Return number of args passed to a frame.
+   Can return -1, meaning no way to tell.  */
+
+#define FRAME_NUM_ARGS(numargs, fi)  \
+{ numargs = (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1)); }
+
+/* Return number of bytes at start of arglist that are not really args.  */
+
+#define FRAME_ARGS_SKIP 4
+
+/* Put here the code to store, into a struct frame_saved_regs,
+   the addresses of the saved registers of frame described by FRAME_INFO.
+   This includes special registers such as pc and fp saved in special
+   ways in the stack frame.  sp is even more special:
+   the address we return for it IS the sp for the next frame.  */
+
+#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+{ register int regnum;     \
+  register int regmask = read_memory_integer ((frame_info).frame+4, 4) >> 16; \
+  register CORE_ADDR next_addr;     \
+  bzero (&frame_saved_regs, sizeof frame_saved_regs);     \
+  next_addr = (frame_info).frame + 16;     \
+  /* Regmask's low bit is for register 0,     \
+     which is the first one that would be pushed.  */     \
+  for (regnum = 0; regnum < 12; regnum++, regmask >>= 1)  \
+    (frame_saved_regs).regs[regnum] = (regmask & 1) ? (next_addr += 4) : 0;  \
+  (frame_saved_regs).regs[SP_REGNUM] = next_addr + 4;  \
+  if (read_memory_integer ((frame_info).frame + 4, 4) & 0x20000000)   \
+    (frame_saved_regs).regs[SP_REGNUM] += 4 + 4 * read_memory_integer (next_addr + 4, 4);  \
+  (frame_saved_regs).regs[PC_REGNUM] = (frame_info).frame + 16;  \
+  (frame_saved_regs).regs[FP_REGNUM] = (frame_info).frame + 12;  \
+  (frame_saved_regs).regs[AP_REGNUM] = (frame_info).frame + 8;  \
+  (frame_saved_regs).regs[PS_REGNUM] = (frame_info).frame + 4;  \
+}
+
+/* Things needed for making the inferior call functions.  */
+
+/* Push an empty stack frame, to record the current PC, etc.  */
+
+#define PUSH_DUMMY_FRAME \
+{ register CORE_ADDR sp = read_register (SP_REGNUM);\
+  register int regnum;				    \
+  sp = push_word (sp, 0); /* arglist */		    \
+  for (regnum = 11; regnum >= 0; regnum--)	    \
+    sp = push_word (sp, read_register (regnum));    \
+  sp = push_word (sp, read_register (PC_REGNUM));   \
+  sp = push_word (sp, read_register (FP_REGNUM));   \
+  sp = push_word (sp, read_register (AP_REGNUM));   \
+  sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef)   \
+		      + 0x2fff0000);		    \
+  sp = push_word (sp, 0); 			    \
+  write_register (SP_REGNUM, sp);		    \
+  write_register (FP_REGNUM, sp);		    \
+  write_register (AP_REGNUM, sp + 17 * sizeof (int)); }
+
+/* Discard from the stack the innermost frame, restoring all registers.  */
+
+#define POP_FRAME  \
+{ register CORE_ADDR fp = read_register (FP_REGNUM);		 \
+  register int regnum;						 \
+  register int regmask = read_memory_integer (fp + 4, 4);	 \
+  write_register (PS_REGNUM, 					 \
+		  (regmask & 0xffff)				 \
+		  | (read_register (PS_REGNUM) & 0xffff0000));	 \
+  write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));  \
+  write_register (FP_REGNUM, read_memory_integer (fp + 12, 4));  \
+  write_register (AP_REGNUM, read_memory_integer (fp + 8, 4));   \
+  fp += 16;							 \
+  for (regnum = 0; regnum < 12; regnum++)			 \
+    if (regmask & (0x10000 << regnum))				 \
+      write_register (regnum, read_memory_integer (fp += 4, 4)); \
+  fp = fp + 4 + ((regmask >> 30) & 3);				 \
+  if (regmask & 0x20000000)					 \
+    { regnum = read_memory_integer (fp, 4);			 \
+      fp += (regnum + 1) * 4; }					 \
+  write_register (SP_REGNUM, fp);				 \
+  set_current_frame (read_register (FP_REGNUM)); }
+
+/* This sequence of words is the instructions
+     calls #69, @#32323232
+     bpt
+   Note this is 8 bytes.  */
+
+#define CALL_DUMMY {0x329f69fb, 0x03323232}
+
+#define CALL_DUMMY_START_OFFSET 0  /* Start execution at beginning of dummy */
+
+/* Insert the specified number of args and function address
+   into a call sequence of the above form stored at DUMMYNAME.  */
+
+#define FIX_CALL_DUMMY(dummyname, fun, nargs)   \
+{ *((char *) dummyname + 1) = nargs;		\
+  *(int *)((char *) dummyname + 3) = fun; }
+
+/* Interface definitions for kernel debugger KDB.  */
+
+/* Map machine fault codes into signal numbers.
+   First subtract 0, divide by 4, then index in a table.
+   Faults for which the entry in this table is 0
+   are not handled by KDB; the program's own trap handler
+   gets to handle then.  */
+
+#define FAULT_CODE_ORIGIN 0
+#define FAULT_CODE_UNITS 4
+#define FAULT_TABLE    \
+{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \
+  0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \
+  0, 0, 0, 0, 0, 0, 0, 0}
+
+/* Start running with a stack stretching from BEG to END.
+   BEG and END should be symbols meaningful to the assembler.
+   This is used only for kdb.  */
+
+#define INIT_STACK(beg, end)  \
+{ asm (".globl end");         \
+  asm ("movl $ end, sp");      \
+  asm ("clrl fp"); }
+
+/* Push the frame pointer register on the stack.  */
+#define PUSH_FRAME_PTR        \
+  asm ("pushl fp");
+
+/* Copy the top-of-stack to the frame pointer register.  */
+#define POP_FRAME_PTR  \
+  asm ("movl (sp), fp");
+
+/* After KDB is entered by a fault, push all registers
+   that GDB thinks about (all NUM_REGS of them),
+   so that they appear in order of ascending GDB register number.
+   The fault code will be on the stack beyond the last register.  */
+
+#define PUSH_REGISTERS        \
+{ asm ("pushl 8(sp)");        \
+  asm ("pushl 8(sp)");        \
+  asm ("pushal 0x14(sp)");    \
+  asm ("pushr $037777"); }
+
+/* Assuming the registers (including processor status) have been
+   pushed on the stack in order of ascending GDB register number,
+   restore them and return to the address in the saved PC register.  */
+
+#define POP_REGISTERS      \
+{ asm ("popr $037777");    \
+  asm ("subl2 $8,(sp)");   \
+  asm ("movl (sp),sp");    \
+  asm ("rei"); }
diff --git a/gdb/m-vaxinit.h b/gdb/m-vaxinit.h
new file mode 100644
index 0000000..6044867
--- /dev/null
+++ b/gdb/m-vaxinit.h
@@ -0,0 +1,5 @@
+
+/* This is how the size of an individual .o file's text segment
+   is rounded on a vax.  */
+
+#define FILEADDR_ROUND(addr) ((addr + 3) & -4)
diff --git a/gdb/m68k-opcode.h b/gdb/m68k-opcode.h
new file mode 100644
index 0000000..111fd84
--- /dev/null
+++ b/gdb/m68k-opcode.h
@@ -0,0 +1,1272 @@
+/* Opcode table for m68000/m68020 and m68881.  */
+
+struct m68k_opcode
+{
+  char *name;
+  unsigned long opcode;
+  unsigned long  match;
+  char *args;
+};
+
+/* We store four bytes of opcode for all opcodes because that
+   is the most any of them need.  The actual length of an instruction
+   is always at least 2 bytes, and is as much longer as necessary to
+   hold the operands it has.
+
+   The match component is a mask saying which bits must match
+   particular opcode in order for an instruction to be an instance
+   of that opcode.
+
+   The args component is a string containing two characters
+   for each operand of the instruction.  The first specifies
+   the kind of operand; the second, the place it is stored.  */
+
+/* Kinds of operands:
+   D  data register only.  Stored as 3 bits.
+   A  address register only.  Stored as 3 bits.
+   R  either kind of register.  Stored as 4 bits.
+   F  floating point coprocessor register only.   Stored as 3 bits.
+   O  an offset (or width): immediate data 0-31 or data register.
+      Stored as 6 bits in special format for BF... insns.
+   +  autoincrement only.  Stored as 3 bits (number of the address register).
+   -  autodecrement only.  Stored as 3 bits (number of the address register).
+   Q  quick immediate data.  Stored as 3 bits.
+      This matches an immediate operand only when value is in range 1 .. 8.
+   M  moveq immediate data.  Stored as 8 bits.
+      This matches an immediate operand only when value is in range -128..127
+   T  trap vector immediate data.  Stored as 4 bits.
+
+   k  K-factor for fmove.p instruction.   Stored as a 7-bit constant or
+      a three bit register offset, depending on the field type.
+
+   #  immediate data.  Stored in special places (b, w or l)
+      which say how many bits to store.
+   ^  immediate data for floating point instructions.   Special places
+      are offset by 2 bytes from '#'...
+   B  pc-relative address, converted to an offset
+      that is treated as immediate data.
+   d  displacement and register.  Stores the register as 3 bits
+      and stores the displacement in the entire second word.
+
+   C  the CCR.  No need to store it; this is just for filtering validity.
+   S  the SR.  No need to store, just as with CCR.
+   U  the USP.  No need to store, just as with CCR.
+
+   I  Coprocessor ID.   Not printed if 1.   The Coprocessor ID is always
+      extracted from the 'd' field of word one, which means that an extended
+      coprocessor opcode can be skipped using the 'i' place, if needed.
+
+   s  System Control register for the floating point coprocessor.
+
+   J  Misc register for movec instruction, stored in 'j' format.
+	Possible values:
+	000	SFC	Source Function Code reg
+	001	DFC	Data Function Code reg
+	002	CACR	Cache Control Register
+	800	USP	User Stack Pointer
+	801	VBR	Vector Base reg
+	802	CAAR	Cache Address Register
+	803	MSP	Master Stack Pointer
+	804	ISP	Interrupt Stack Pointer
+
+ These specify various classes of addressing modes.
+ They are all stored as 6 bits using an address mode and a register number;
+ they differ in which addressing modes they match.
+
+   *  all					(modes 0-6,7.*)
+   ~  alterable memory				(modes 2-6,7.0,7.1)(not 0,1,7.~)
+   %  alterable					(modes 0-6,7.0,7.1)(not 7.~)
+   ;  data					(modes 0,2-6,7.*)(not 1)
+   @  data, but not immediate			(modes 0,2-6,7.???)(not 1,7.?)  This may really be ;, the 68020 book says it is
+   !  control					(modes 2,5,6,7.*-)(not 0,1,3,4,7.4)
+   &  alterable control				(modes 2,5,6,7.0,7.1)(not 0,1,7.???)
+   $  alterable data				(modes 0,2-6,7.0,7.1)(not 1,7.~)
+   ?  alterable control, or data register	(modes 0,2,5,6,7.0,7.1)(not 1,3,4,7.~)
+   /  control, or data register			(modes 0,2,5,6,7.0,7.1,7.2,7.3)(not 1,3,4,7.4)
+*/
+
+/* Places to put an operand, for non-general operands:
+   s  source, low bits of first word.
+   d  dest, shifted 9 in first word
+   1  second word, shifted 12
+   2  second word, shifted 6
+   3  second word, shifted 0
+   4  third word, shifted 12
+   5  third word, shifted 6
+   6  third word, shifted 0
+   7  second word, shifted 7
+   8  second word, shifted 10
+   D  store in both place 1 and place 3; for divul and divsl.
+   b  second word, low byte
+   w  second word (entire)
+   l  second and third word (entire)
+   g  branch offset for bra and similar instructions.
+      The place to store depends on the magnitude of offset.
+   t  store in both place 7 and place 8; for floating point operations
+   c  branch offset for cpBcc operations.
+      The place to store is word two if bit six of word one is zero,
+      and words two and three if bit six of word one is one.
+   i  Increment by two, to skip over coprocessor extended operands.   Only
+      works with the 'I' format.
+   k  Dynamic K-factor field.   Bits 6-4 of word 2, used as a register number.
+      Also used for dynamic fmovem instruction.
+   C  floating point coprocessor constant - 7 bits.  Also used for static
+      K-factors...
+   j  Movec register #, stored in 12 low bits of second word.
+
+ Places to put operand, for general operands:
+   d  destination, shifted 6 bits in first word
+   b  source, at low bit of first word, and immediate uses one byte
+   w  source, at low bit of first word, and immediate uses two bytes
+   l  source, at low bit of first word, and immediate uses four bytes
+   s  source, at low bit of first word.
+      Used sometimes in contexts where immediate is not allowed anyway.
+   f  single precision float, low bit of 1st word, immediate uses 4 bytes
+   F  double precision float, low bit of 1st word, immediate uses 8 bytes
+   x  extended precision float, low bit of 1st word, immediate uses 12 bytes
+   p  packed float, low bit of 1st word, immediate uses 12 bytes
+*/
+
+#define one(x) ((x) << 16)
+#define two(x, y) (((x) << 16) + y)
+
+/* The assembler requires that this array be sorted as follows:
+   all instances of the same mnemonic must be consecutive.
+   All instances of the same mnemonic with the same number of operands
+   must be consecutive.
+ */
+struct m68k_opcode m68k_opcodes[] =
+{
+{"abcd",	one(0140400),		one(0170770),		"DsDd"},
+{"abcd",	one(0140410),		one(0170770),		"-s-d"},
+
+		/* Add instructions */
+{"addal",	one(0150700),		one(0170700),		"*lAd"},
+{"addaw",	one(0150300),		one(0170700),		"*wAd"},
+{"addib",	one(0003000),		one(0177700),		"#b$b"},
+{"addil",	one(0003200),		one(0177700),		"#l$l"},
+{"addiw",	one(0003100),		one(0177700),		"#w$w"},
+{"addqb",	one(0050000),		one(0170700),		"Qd$b"},
+{"addql",	one(0050200),		one(0170700),		"Qd%l"},
+{"addqw",	one(0050100),		one(0170700),		"Qd%w"},
+
+{"addb",	one(0003000),		one(0177700),		"#b$b"},	/* addi written as add */
+{"addb",	one(0050000),		one(0170700),		"Qd$b"},	/* addq written as add */
+{"addb",	one(0150000),		one(0170700),		";bDd"},	/* addb <ea>,	Dd */
+{"addb",	one(0150400),		one(0170700),		"Dd~b"},	/* addb Dd,	<ea> */
+
+{"addw",	one(0003100),		one(0177700),		"#w$w"},	/* addi written as add */
+{"addw",	one(0150300),		one(0170700),		"*wAd"},	/* adda written as add */
+{"addw",	one(0050100),		one(0170700),		"Qd%w"},	/* addq written as add */
+{"addw",	one(0150100),		one(0170700),		"*wDd"},	/* addw <ea>,	Dd */
+{"addw",	one(0150500),		one(0170700),		"Dd~w"},	/* addw Dd,	<ea> */
+
+{"addl",	one(0003200),		one(0177700),		"#l$l"},	/* addi written as add */
+{"addl",	one(0150700),		one(0170700),		"*lAd"},	/* adda written as add */
+{"addl",	one(0050200),		one(0170700),		"Qd%l"},	/* addq written as add */
+{"addl",	one(0150200),		one(0170700),		"*lDd"},	/* addl <ea>,	Dd */
+{"addl",	one(0150600),		one(0170700),		"Dd~l"},	/* addl Dd,	<ea> */
+
+{"addxb",	one(0150400),		one(0170770),		"DsDd"},
+{"addxb",	one(0150410),		one(0170770),		"-s-d"},
+{"addxl",	one(0150600),		one(0170770),		"DsDd"},
+{"addxl",	one(0150610),		one(0170770),		"-s-d"},
+{"addxw",	one(0150500),		one(0170770),		"DsDd"},
+{"addxw",	one(0150510),		one(0170770),		"-s-d"},
+
+{"andib",	one(0001000),		one(0177700),		"#b$b"},
+{"andib",	one(0001074),		one(0177777),		"#bCb"},	/* andi to ccr */
+{"andiw",	one(0001100),		one(0177700),		"#w$w"},
+{"andiw",	one(0001174),		one(0177777),		"#wSw"},	/* andi to sr */
+{"andil",	one(0001200),		one(0177700),		"#l$l"},
+
+{"andb",	one(0001000),		one(0177700),		"#b$b"},	/* andi written as or */
+{"andb",	one(0001074),		one(0177777),		"#bCb"},	/* andi to ccr */
+{"andb",	one(0140000),		one(0170700),		";bDd"},	/* memory to register */
+{"andb",	one(0140400),		one(0170700),		"Dd~b"},	/* register to memory */
+{"andw",	one(0001100),		one(0177700),		"#w$w"},	/* andi written as or */
+{"andw",	one(0001174),		one(0177777),		"#wSw"},	/* andi to sr */
+{"andw",	one(0140100),		one(0170700),		";wDd"},	/* memory to register */
+{"andw",	one(0140500),		one(0170700),		"Dd~w"},	/* register to memory */
+{"andl",	one(0001200),		one(0177700),		"#l$l"},	/* andi written as or */
+{"andl",	one(0140200),		one(0170700),		";lDd"},	/* memory to register */
+{"andl",	one(0140600),		one(0170700),		"Dd~l"},	/* register to memory */
+
+{"aslb",	one(0160400),		one(0170770),		"QdDs"},
+{"aslb",	one(0160440),		one(0170770),		"DdDs"},
+{"asll",	one(0160600),		one(0170770),		"QdDs"},
+{"asll",	one(0160640),		one(0170770),		"DdDs"},
+{"aslw",	one(0160500),		one(0170770),		"QdDs"},
+{"aslw",	one(0160540),		one(0170770),		"DdDs"},
+{"aslw",	one(0160700),		one(0177700),		"~s"},	/* Shift memory */
+{"asrb",	one(0160000),		one(0170770),		"QdDs"},
+{"asrb",	one(0160040),		one(0170770),		"DdDs"},
+{"asrl",	one(0160200),		one(0170770),		"QdDs"},
+{"asrl",	one(0160240),		one(0170770),		"DdDs"},
+{"asrw",	one(0160100),		one(0170770),		"QdDs"},
+{"asrw",	one(0160140),		one(0170770),		"DdDs"},
+{"asrw",	one(0160300),		one(0177700),		"~s"},	/* Shift memory */
+
+{"bhi",		one(0061000),		one(0177400),		"Bg"},
+{"bls",		one(0061400),		one(0177400),		"Bg"},
+{"bcc",		one(0062000),		one(0177400),		"Bg"},
+{"bcs",		one(0062400),		one(0177400),		"Bg"},
+{"bne",		one(0063000),		one(0177400),		"Bg"},
+{"beq",		one(0063400),		one(0177400),		"Bg"},
+{"bvc",		one(0064000),		one(0177400),		"Bg"},
+{"bvs",		one(0064400),		one(0177400),		"Bg"},
+{"bpl",		one(0065000),		one(0177400),		"Bg"},
+{"bmi",		one(0065400),		one(0177400),		"Bg"},
+{"bge",		one(0066000),		one(0177400),		"Bg"},
+{"blt",		one(0066400),		one(0177400),		"Bg"},
+{"bgt",		one(0067000),		one(0177400),		"Bg"},
+{"ble",		one(0067400),		one(0177400),		"Bg"},
+
+{"bchg",	one(0000500),		one(0170700),		"Dd$s"},
+{"bchg",	one(0004100),		one(0177700),		"#b$s"},
+{"bclr",	one(0000600),		one(0170700),		"Dd$s"},
+{"bclr",	one(0004200),		one(0177700),		"#b$s"},
+{"bfchg",	two(0165300, 0),	two(0177700, 0170000),	"?sO2O3"},
+{"bfclr",	two(0166300, 0),	two(0177700, 0170000),	"?sO2O3"},
+{"bfexts",	two(0165700, 0),	two(0177700, 0100000),	"/sO2O3D1"},
+{"bfextu",	two(0164700, 0),	two(0177700, 0100000),	"/sO2O3D1"},
+{"bfffo",	two(0166700, 0),	two(0177700, 0100000),	"/sO2O3D1"},
+{"bfins",	two(0167700, 0),	two(0177700, 0100000),	"D1?sO2O3"},
+{"bfset",	two(0167300, 0),	two(0177700, 0170000),	"?sO2O3"},
+{"bftst",	two(0164300, 0),	two(0177700, 0170000),	"/sO2O3"},
+{"bset",	one(0000700),		one(0170700),		"Dd$s"},
+{"bset",	one(0004300),		one(0177700),		"#b$s"},
+{"btst",	one(0000400),		one(0170700),		"Dd@s"},
+{"btst",	one(0004000),		one(0177700),		"#b@s"},
+
+{"bkpt",	one(0044110),		one(0177770),		"Qs"},
+{"bra",		one(0060000),		one(0177400),		"Bg"},
+{"bsr",		one(0060400),		one(0177400),		"Bg"},
+{"callm",	one(0003300),		one(0177700),		"#b!s"},
+{"cas2l",	two(0007374, 0),	two(0177777, 0107070),	"D3D6D2D5R1R4"}, /* JF FOO this is really a 3 word ins */
+{"cas2w",	two(0006374, 0),	two(0177777, 0107070),	"D3D6D2D5R1R4"}, /* JF ditto */
+{"casb",	two(0005300, 0),	two(0177700, 0177070),	"D3D2~s"},
+{"casl",	two(0007300, 0),	two(0177700, 0177070),	"D3D2~s"},
+{"casw",	two(0006300, 0),	two(0177700, 0177070),	"D3D2~s"},
+
+/*  {"chk",	one(0040600),		one(0170700),		";wDd"}, JF FOO this looks wrong */
+{"chk2b",	two(0000300, 0004000),	two(0177700, 07777),	"!sR1"},
+{"chk2l",	two(0002300, 0004000),	two(0177700, 07777),	"!sR1"},
+{"chk2w",	two(0001300, 0004000),	two(0177700, 07777),	"!sR1"},
+{"chkl",	one(0040400),		one(0170700),		";lDd"},
+{"chkw",	one(0040600),		one(0170700),		";wDd"},
+{"clrb",	one(0041000),		one(0177700),		"$s"},
+{"clrl",	one(0041200),		one(0177700),		"$s"},
+{"clrw",	one(0041100),		one(0177700),		"$s"},
+
+{"cmp2b",	two(0000300, 0),	two(0177700, 07777),	"!sR1"},
+{"cmp2l",	two(0002300, 0),	two(0177700, 07777),	"!sR1"},
+{"cmp2w",	two(0001300, 0),	two(0177700, 07777),	"!sR1"},
+{"cmpal",	one(0130700),		one(0170700),		"*lAd"},
+{"cmpaw",	one(0130300),		one(0170700),		"*wAd"},
+{"cmpib",	one(0006000),		one(0177700),		"#b;b"},
+{"cmpil",	one(0006200),		one(0177700),		"#l;l"},
+{"cmpiw",	one(0006100),		one(0177700),		"#w;w"},
+{"cmpb",	one(0006000),		one(0177700),		"#b;b"},	/* cmpi written as cmp */
+{"cmpb",	one(0130000),		one(0170700),		";bDd"},
+{"cmpw",	one(0006100),		one(0177700),		"#w;w"},
+{"cmpw",	one(0130100),		one(0170700),		"*wDd"},
+{"cmpw",	one(0130300),		one(0170700),		"*wAd"},	/* cmpa written as cmp */
+{"cmpl",	one(0006200),		one(0177700),		"#l;l"},
+{"cmpl",	one(0130200),		one(0170700),		"*lDd"},
+{"cmpl",	one(0130700),		one(0170700),		"*lAd"},
+{"cmpmb",	one(0130410),		one(0170770),		"+s+d"},
+{"cmpml",	one(0130610),		one(0170770),		"+s+d"},
+{"cmpmw",	one(0130510),		one(0170770),		"+s+d"},
+
+{"dbcc",	one(0052310),		one(0177770),		"DsBw"},
+{"dbcs",	one(0052710),		one(0177770),		"DsBw"},
+{"dbeq",	one(0053710),		one(0177770),		"DsBw"},
+{"dbf",		one(0050710),		one(0177770),		"DsBw"},
+{"dbge",	one(0056310),		one(0177770),		"DsBw"},
+{"dbgt",	one(0057310),		one(0177770),		"DsBw"},
+{"dbhi",	one(0051310),		one(0177770),		"DsBw"},
+{"dble",	one(0057710),		one(0177770),		"DsBw"},
+{"dbls",	one(0051710),		one(0177770),		"DsBw"},
+{"dblt",	one(0056710),		one(0177770),		"DsBw"},
+{"dbmi",	one(0055710),		one(0177770),		"DsBw"},
+{"dbne",	one(0053310),		one(0177770),		"DsBw"},
+{"dbpl",	one(0055310),		one(0177770),		"DsBw"},
+{"dbra",	one(0050710),		one(0177770),		"DsBw"},
+{"dbt",		one(0050310),		one(0177770),		"DsBw"},
+{"dbvc",	one(0054310),		one(0177770),		"DsBw"},
+{"dbvs",	one(0054710),		one(0177770),		"DsBw"},
+
+{"divsl",	two(0046100, 0006000),	two(0177700, 0107770),	";lD3D1"},
+{"divsl",	two(0046100, 0004000),	two(0177700, 0107770),	";lDD"},
+{"divsll",	two(0046100, 0004000),	two(0177700, 0107770),	";lD3D1"},
+{"divsw",	one(0100700),		one(0170700),		";wDd"},
+{"divs",	one(0100700),		one(0170700),		";wDd"},
+{"divul",	two(0046100, 0002000),	two(0177700, 0107770),	";lD3D1"},
+{"divul",	two(0046100, 0000000),	two(0177700, 0107770),	";lDD"},
+{"divull",	two(0046100, 0000000),	two(0177700, 0107770),	";lD3D1"},
+{"divuw",	one(0100300),		one(0170700),		";wDd"},
+{"divu",	one(0100300),		one(0170700),		";wDd"},
+{"eorb",	one(0005000),		one(0177700),		"#b$s"},	/* eori written as or */
+{"eorb",	one(0005074),		one(0177777),		"#bCs"},	/* eori to ccr */
+{"eorb",	one(0130400),		one(0170700),		"Dd$s"},	/* register to memory */
+{"eorib",	one(0005000),		one(0177700),		"#b$s"},
+{"eorib",	one(0005074),		one(0177777),		"#bCs"},	/* eori to ccr */
+{"eoril",	one(0005200),		one(0177700),		"#l$s"},
+{"eoriw",	one(0005100),		one(0177700),		"#w$s"},
+{"eoriw",	one(0005174),		one(0177777),		"#wSs"},	/* eori to sr */
+{"eorl",	one(0005200),		one(0177700),		"#l$s"},
+{"eorl",	one(0130600),		one(0170700),		"Dd$s"},
+{"eorw",	one(0005100),		one(0177700),		"#w$s"},
+{"eorw",	one(0005174),		one(0177777),		"#wSs"},	/* eori to sr */
+{"eorw",	one(0130500),		one(0170700),		"Dd$s"},
+
+{"exg",		one(0140500),		one(0170770),		"DdDs"},
+{"exg",		one(0140510),		one(0170770),		"AdAs"},
+{"exg",		one(0140610),		one(0170770),		"DdAs"},
+{"exg",		one(0140610),		one(0170770),		"AsDd"},
+
+{"extw",	one(0044200),		one(0177770),		"Ds"},
+{"extl",	one(0044300),		one(0177770),		"Ds"},
+{"extbl",	one(0044700),		one(0177770),		"Ds"},
+{"extb.l",	one(0044700),		one(0177770),		"Ds"},	/* Not sure we should support this one*/
+
+{"illegal",	one(0045374),		one(0177777),		""},
+{"jmp",		one(0047300),		one(0177700),		"!s"},
+{"jsr",		one(0047200),		one(0177700),		"!s"},
+{"lea",		one(0040700),		one(0170700),		"!sAd"},
+{"linkw",	one(0047120),		one(0177770),		"As#w"},
+{"linkl",	one(0044010),		one(0177770),		"As#l"},
+{"link",	one(0047120),		one(0177770),		"As#w"},
+{"link",	one(0044010),		one(0177770),		"As#l"},
+
+{"lslb",	one(0160410),		one(0170770),		"QdDs"},	/* lsrb #Q,	Ds */
+{"lslb",	one(0160450),		one(0170770),		"DdDs"},	/* lsrb Dd,	Ds */
+{"lslw",	one(0160510),		one(0170770),		"QdDs"},	/* lsrb #Q,	Ds */
+{"lslw",	one(0160550),		one(0170770),		"DdDs"},	/* lsrb Dd,	Ds */
+{"lslw",	one(0161700),		one(0177700),		"~s"},	/* Shift memory */
+{"lsll",	one(0160610),		one(0170770),		"QdDs"},	/* lsrb #Q,	Ds */
+{"lsll",	one(0160650),		one(0170770),		"DdDs"},	/* lsrb Dd,	Ds */
+
+{"lsrb",	one(0160010),		one(0170770),		"QdDs"} /* lsrb #Q,	Ds */,
+{"lsrb",	one(0160050),		one(0170770),		"DdDs"},	/* lsrb Dd,	Ds */
+{"lsrl",	one(0160210),		one(0170770),		"QdDs"},	/* lsrb #Q,	Ds */
+{"lsrl",	one(0160250),		one(0170770),		"DdDs"},	/* lsrb #Q,	Ds */
+{"lsrw",	one(0160110),		one(0170770),		"QdDs"},	/* lsrb #Q,	Ds */
+{"lsrw",	one(0160150),		one(0170770),		"DdDs"},	/* lsrb #Q,	Ds */
+{"lsrw",	one(0161300),		one(0177700),		"~s"},	/* Shift memory */
+
+{"moveal",	one(0020100),		one(0170700),		"*lAd"},
+{"moveaw",	one(0030100),		one(0170700),		"*wAd"},
+{"moveb",	one(0010000),		one(0170000),		";b$d"},	/* move */
+
+{"movec",	one(0047173),		one(0177777),		"R1Jj"},
+{"movec",	one(0047173),		one(0177777),		"R1#j"},
+{"movec",	one(0047172),		one(0177777),		"JjR1"},
+{"movec",	one(0047172),		one(0177777),		"#jR1"},
+
+{"movel",	one(0020000),		one(0170000),		"*l$d"},
+{"movel",	one(0020100),		one(0170700),		"*lAd"},
+{"movel",	one(0047140),		one(0177770),		"AsUd"},	/* move to USP */
+{"movel",	one(0047150),		one(0177770),		"UdAs"},	/* move from USP */
+{"movel",	one(0070000),		one(0170400),		"MsDd"},	/* moveq written as move */
+
+{"moveml",	one(0044300),		one(0177700),		"#w&s"},	/* movem reg to mem. */
+{"moveml",	one(0044340),		one(0177770),		"#w-s"},	/* movem reg to autodecrement. */
+{"moveml",	one(0046300),		one(0177700),		"!s#w"},	/* movem mem to reg. */
+{"moveml",	one(0046330),		one(0177770),		"+s#w"},	/* movem autoinc to reg. */
+
+{"movemw",	one(0044200),		one(0177700),		"#w&s"},	/* movem reg to mem. */
+{"movemw",	one(0044240),		one(0177770),		"#w-s"},	/* movem reg to autodecrement. */
+{"movemw",	one(0046200),		one(0177700),		"!s#w"},	/* movem mem to reg. */
+{"movemw",	one(0046230),		one(0177770),		"+s#w"},	/* movem autoinc to reg. */
+
+{"movepl",	one(0000510),		one(0170770),		"dsDd"},	/* memory to register */
+{"movepl",	one(0000710),		one(0170770),		"Ddds"},	/* register to memory */
+{"movepw",	one(0000410),		one(0170770),		"dsDd"},	/* memory to register */
+{"movepw",	one(0000610),		one(0170770),		"Ddds"},	/* register to memory */
+{"moveq",	one(0070000),		one(0170400),		"MsDd"},
+{"movew",	one(0030000),		one(0170000),		"*w$d"},
+{"movew",	one(0030100),		one(0170700),		"*wAd"},	/* movea,	written as move */
+{"movew",	one(0040300),		one(0177700),		"Ss$s"},	/* Move from sr */
+{"movew",	one(0041300),		one(0177700),		"Cs$s"},	/* Move from ccr */
+{"movew",	one(0042300),		one(0177700),		";wCd"},	/* move to ccr */
+{"movew",	one(0043300),		one(0177700),		";wSd"},	/* move to sr */
+
+{"movesb",	two(0007000, 0),	two(0177700, 07777),	"~sR1"},	 /* moves from memory */
+{"movesb",	two(0007000, 04000),	two(0177700, 07777),	"R1~s"},	 /* moves to memory */
+{"movesl",	two(0007200, 0),	two(0177700, 07777),	"~sR1"},	 /* moves from memory */
+{"movesl",	two(0007200, 04000),	two(0177700, 07777),	"R1~s"},	 /* moves to memory */
+{"movesw",	two(0007100, 0),	two(0177700, 07777),	"~sR1"},	 /* moves from memory */
+{"movesw",	two(0007100, 04000),	two(0177700, 07777),	"R1~s"},	 /* moves to memory */
+
+{"mulsl",	two(0046000, 004000),	two(0177700, 0107770),	";lD1"},
+{"mulsl",	two(0046000, 006000),	two(0177700, 0107770),	";lD3D1"},
+{"mulsw",	one(0140700),		one(0170700),		";wDd"},
+{"muls",	one(0140700),		one(0170700),		";wDd"},
+{"mulul",	two(0046000, 000000),	two(0177700, 0107770),	";lD1"},
+{"mulul",	two(0046000, 002000),	two(0177700, 0107770),	";lD3D1"},
+{"muluw",	one(0140300),		one(0170700),		";lDd"},
+{"mulu",	one(0140300),		one(0170700),		";lDd"},
+{"nbcd",	one(0044000),		one(0177700),		"$s"},
+{"negb",	one(0042000),		one(0177700),		"$s"},
+{"negl",	one(0042200),		one(0177700),		"$s"},
+{"negw",	one(0042100),		one(0177700),		"$s"},
+{"negxb",	one(0040000),		one(0177700),		"$s"},
+{"negxl",	one(0040200),		one(0177700),		"$s"},
+{"negxw",	one(0040100),		one(0177700),		"$s"},
+{"nop",		one(0047161),		one(0177777),		""},
+{"notb",	one(0043000),		one(0177700),		"$s"},
+{"notl",	one(0043200),		one(0177700),		"$s"},
+{"notw",	one(0043100),		one(0177700),		"$s"},
+
+{"orb",		one(0000000),		one(0177700),		"#b$s"},	/* ori written as or */
+{"orb",		one(0000074),		one(0177777),		"#bCs"},	/* ori to ccr */
+{"orb",		one(0100000),		one(0170700),		";bDd"},	/* memory to register */
+{"orb",		one(0100400),		one(0170700),		"Dd~s"},	/* register to memory */
+{"orib",	one(0000000),		one(0177700),		"#b$s"},
+{"orib",	one(0000074),		one(0177777),		"#bCs"},	/* ori to ccr */
+{"oril",	one(0000200),		one(0177700),		"#l$s"},
+{"oriw",	one(0000100),		one(0177700),		"#w$s"},
+{"oriw",	one(0000174),		one(0177777),		"#wSs"},	/* ori to sr */
+{"orl",		one(0000200),		one(0177700),		"#l$s"},
+{"orl",		one(0100200),		one(0170700),		";lDd"},	/* memory to register */
+{"orl",		one(0100600),		one(0170700),		"Dd~s"},	/* register to memory */
+{"orw",		one(0000100),		one(0177700),		"#w$s"},
+{"orw",		one(0000174),		one(0177777),		"#wSs"},	/* ori to sr */
+{"orw",		one(0100100),		one(0170700),		";wDd"},	/* memory to register */
+{"orw",		one(0100500),		one(0170700),		"Dd~s"},	/* register to memory */
+
+{"pack",	one(0100500),		one(0170770),		"DsDd#w"},	/* pack Ds,	Dd,	#w */
+{"pack",	one(0100510),		one(0170770),		"-s-d#w"},	/* pack -(As),	-(Ad),	#w */
+{"pea",		one(0044100),		one(0177700),		"!s"},
+{"reset",	one(0047160),		one(0177777),		""},
+
+{"rolb",	one(0160430),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"rolb",	one(0160470),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"roll",	one(0160630),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"roll",	one(0160670),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"rolw",	one(0160530),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"rolw",	one(0160570),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"rolw",	one(0163700),		one(0177700),		"~s"},	/* Rotate memory */
+{"rorb",	one(0160030),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"rorb",	one(0160070),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"rorl",	one(0160230),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"rorl",	one(0160270),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"rorw",	one(0160130),		one(0170770),		"QdDs"},	/* rorb #Q,	Ds */
+{"rorw",	one(0160170),		one(0170770),		"DdDs"},	/* rorb Dd,	Ds */
+{"rorw",	one(0163300),		one(0177700),		"~s"},	/* Rotate memory */
+
+{"roxlb",	one(0160420),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxlb",	one(0160460),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxll",	one(0160620),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxll",	one(0160660),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxlw",	one(0160520),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxlw",	one(0160560),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxlw",	one(0162700),		one(0177700),		"~s"},	/* Rotate memory */
+{"roxrb",	one(0160020),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxrb",	one(0160060),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxrl",	one(0160220),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxrl",	one(0160260),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxrw",	one(0160120),		one(0170770),		"QdDs"},	/* roxrb #Q,	Ds */
+{"roxrw",	one(0160160),		one(0170770),		"DdDs"},	/* roxrb Dd,	Ds */
+{"roxrw",	one(0162300),		one(0177700),		"~s"},	/* Rotate memory */
+
+{"rtd",		one(0047164),		one(0177777),		"#w"},
+{"rte",		one(0047163),		one(0177777),		""},
+{"rtm",		one(0003300),		one(0177760),		"Rs"},
+{"rtr",		one(0047167),		one(0177777),		""},
+{"rts",		one(0047165),		one(0177777),		""},
+
+{"scc",		one(0052300),		one(0177700),		"$s"},
+{"scs",		one(0052700),		one(0177700),		"$s"},
+{"seq",		one(0053700),		one(0177700),		"$s"},
+{"sf",		one(0050700),		one(0177700),		"$s"},
+{"sge",		one(0056300),		one(0177700),		"$s"},
+{"sgt",		one(0057300),		one(0177700),		"$s"},
+{"shi",		one(0051300),		one(0177700),		"$s"},
+{"sle",		one(0057700),		one(0177700),		"$s"},
+{"sls",		one(0051700),		one(0177700),		"$s"},
+{"slt",		one(0056700),		one(0177700),		"$s"},
+{"smi",		one(0055700),		one(0177700),		"$s"},
+{"sne",		one(0053300),		one(0177700),		"$s"},
+{"spl",		one(0055300),		one(0177700),		"$s"},
+{"st",		one(0050300),		one(0177700),		"$s"},
+{"svc",		one(0054300),		one(0177700),		"$s"},
+{"svs",		one(0054700),		one(0177700),		"$s"},
+
+{"sbcd",	one(0100400),		one(0170770),		"DsDd"},
+{"sbcd",	one(0100410),		one(0170770),		"-s-d"},
+{"stop",	one(0047162),		one(0177777),		"#w"},
+
+{"subal",	one(0110700),		one(0170700),		"*lAd"},
+{"subaw",	one(0110300),		one(0170700),		"*wAd"},
+{"subb",	one(0002000),		one(0177700),		"#b$s"},	/* subi written as sub */
+{"subb",	one(0050400),		one(0170700),		"Qd%s"},	/* subq written as sub */
+{"subb",	one(0110000),		one(0170700),		";bDd"},	/* subb ??,	Dd */
+{"subb",	one(0110400),		one(0170700),		"Dd~s"},	/* subb Dd,	?? */
+{"subib",	one(0002000),		one(0177700),		"#b$s"},
+{"subil",	one(0002200),		one(0177700),		"#l$s"},
+{"subiw",	one(0002100),		one(0177700),		"#w$s"},
+{"subl",	one(0002200),		one(0177700),		"#l$s"},
+{"subl",	one(0050600),		one(0170700),		"Qd%s"},
+{"subl",	one(0110200),		one(0170700),		"*lDd"},
+{"subl",	one(0110600),		one(0170700),		"Dd~s"},
+{"subl",	one(0110700),		one(0170700),		"*lAd"},
+{"subqb",	one(0050400),		one(0170700),		"Qd%s"},
+{"subql",	one(0050600),		one(0170700),		"Qd%s"},
+{"subqw",	one(0050500),		one(0170700),		"Qd%s"},
+{"subw",	one(0002100),		one(0177700),		"#w$s"},
+{"subw",	one(0050500),		one(0170700),		"Qd%s"},
+{"subw",	one(0110100),		one(0170700),		"*wDd"},
+{"subw",	one(0110300),		one(0170700),		"*wAd"},	/* suba written as sub */
+{"subw",	one(0110500),		one(0170700),		"Dd~s"},
+
+{"subxb",	one(0110400),		one(0170770),		"DsDd"},	/* subxb Ds,	Dd */
+{"subxb",	one(0110410),		one(0170770),		"-s-d"},	/* subxb -(As),	-(Ad) */
+{"subxl",	one(0110600),		one(0170770),		"DsDd"},
+{"subxl",	one(0110610),		one(0170770),		"-s-d"},
+{"subxw",	one(0110500),		one(0170770),		"DsDd"},
+{"subxw",	one(0110510),		one(0170770),		"-s-d"},
+
+{"swap",	one(0044100),		one(0177770),		"Ds"},
+	
+{"tas",		one(0045300),		one(0177700),		"$s"},
+{"trap",	one(0047100),		one(0177760),		"Ts"},
+
+{"trapcc",	one(0052374),		one(0177777),		""},
+{"trapcs",	one(0052774),		one(0177777),		""},
+{"trapeq",	one(0053774),		one(0177777),		""},
+{"trapf",	one(0050774),		one(0177777),		""},
+{"trapge",	one(0056374),		one(0177777),		""},
+{"trapgt",	one(0057374),		one(0177777),		""},
+{"traphi",	one(0051374),		one(0177777),		""},
+{"traple",	one(0057774),		one(0177777),		""},
+{"trapls",	one(0051774),		one(0177777),		""},
+{"traplt",	one(0056774),		one(0177777),		""},
+{"trapmi",	one(0055774),		one(0177777),		""},
+{"trapne",	one(0053374),		one(0177777),		""},
+{"trappl",	one(0055374),		one(0177777),		""},
+{"trapt",	one(0050374),		one(0177777),		""},
+{"trapvc",	one(0054374),		one(0177777),		""},
+{"trapvs",	one(0054774),		one(0177777),		""},
+
+{"trapcc.w",	one(0052372),		one(0177777),		""},
+{"trapcs.w",	one(0052772),		one(0177777),		""},
+{"trapeq.w",	one(0053772),		one(0177777),		""},
+{"trapf.w",	one(0050772),		one(0177777),		""},
+{"trapge.w",	one(0056372),		one(0177777),		""},
+{"trapgt.w",	one(0057372),		one(0177777),		""},
+{"traphi.w",	one(0051372),		one(0177777),		""},
+{"traple.w",	one(0057772),		one(0177777),		""},
+{"trapls.w",	one(0051772),		one(0177777),		""},
+{"traplt.w",	one(0056772),		one(0177777),		""},
+{"trapmi.w",	one(0055772),		one(0177777),		""},
+{"trapne.w",	one(0053372),		one(0177777),		""},
+{"trappl.w",	one(0055372),		one(0177777),		""},
+{"trapt.w",	one(0050372),		one(0177777),		""},
+{"trapvc.w",	one(0054372),		one(0177777),		""},
+{"trapvs.w",	one(0054772),		one(0177777),		""},
+
+{"trapcc.l",	one(0052373),		one(0177777),		""},
+{"trapcs.l",	one(0052773),		one(0177777),		""},
+{"trapeq.l",	one(0053773),		one(0177777),		""},
+{"trapf.l",	one(0050773),		one(0177777),		""},
+{"trapge.l",	one(0056373),		one(0177777),		""},
+{"trapgt.l",	one(0057373),		one(0177777),		""},
+{"traphi.l",	one(0051373),		one(0177777),		""},
+{"traple.l",	one(0057773),		one(0177777),		""},
+{"trapls.l",	one(0051773),		one(0177777),		""},
+{"traplt.l",	one(0056773),		one(0177777),		""},
+{"trapmi.l",	one(0055773),		one(0177777),		""},
+{"trapne.l",	one(0053373),		one(0177777),		""},
+{"trappl.l",	one(0055373),		one(0177777),		""},
+{"trapt.l",	one(0050373),		one(0177777),		""},
+{"trapvc.l",	one(0054373),		one(0177777),		""},
+{"trapvs.l",	one(0054773),		one(0177777),		""},
+
+{"trapv",	one(0047166),		one(0177777),		""},
+
+{"tstb",	one(0045000),		one(0177700),		";b"},
+{"tstw",	one(0045100),		one(0177700),		"*w"},
+{"tstl",	one(0045200),		one(0177700),		"*l"},
+
+{"unlk",	one(0047130),		one(0177770),		"As"},
+{"unpk",	one(0100600),		one(0170770),		"DsDd#w"},
+{"unpk",	one(0100610),		one(0170770),		"-s-d#w"},
+	/* JF floating pt stuff moved down here */
+
+{"fabsb",	two(0xF000, 0x5818),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fabsd",	two(0xF000, 0x5418),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fabsl",	two(0xF000, 0x4018),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fabsp",	two(0xF000, 0x4C18),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fabss",	two(0xF000, 0x4418),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fabsw",	two(0xF000, 0x5018),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fabsx",	two(0xF000, 0x0018),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fabsx",	two(0xF000, 0x4818),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fabsx",	two(0xF000, 0x0018),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"facosb",	two(0xF000, 0x581C),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"facosd",	two(0xF000, 0x541C),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"facosl",	two(0xF000, 0x401C),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"facosp",	two(0xF000, 0x4C1C),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"facoss",	two(0xF000, 0x441C),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"facosw",	two(0xF000, 0x501C),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"facosx",	two(0xF000, 0x001C),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"facosx",	two(0xF000, 0x481C),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"facosx",	two(0xF000, 0x001C),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"faddb",	two(0xF000, 0x5822),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"faddd",	two(0xF000, 0x5422),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"faddl",	two(0xF000, 0x4022),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"faddp",	two(0xF000, 0x4C22),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fadds",	two(0xF000, 0x4422),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"faddw",	two(0xF000, 0x5022),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"faddx",	two(0xF000, 0x0022),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"faddx",	two(0xF000, 0x4822),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fasinb",	two(0xF000, 0x580C),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fasind",	two(0xF000, 0x540C),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fasinl",	two(0xF000, 0x400C),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fasinp",	two(0xF000, 0x4C0C),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fasins",	two(0xF000, 0x440C),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fasinw",	two(0xF000, 0x500C),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fasinx",	two(0xF000, 0x000C),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fasinx",	two(0xF000, 0x480C),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fasinx",	two(0xF000, 0x000C),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fatanb",	two(0xF000, 0x580A),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fatand",	two(0xF000, 0x540A),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fatanl",	two(0xF000, 0x400A),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fatanp",	two(0xF000, 0x4C0A),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fatans",	two(0xF000, 0x440A),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fatanw",	two(0xF000, 0x500A),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fatanx",	two(0xF000, 0x000A),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fatanx",	two(0xF000, 0x480A),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fatanx",	two(0xF000, 0x000A),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fatanhb",	two(0xF000, 0x580D),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fatanhd",	two(0xF000, 0x540D),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fatanhl",	two(0xF000, 0x400D),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fatanhp",	two(0xF000, 0x4C0D),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fatanhs",	two(0xF000, 0x440D),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fatanhw",	two(0xF000, 0x500D),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fatanhx",	two(0xF000, 0x000D),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fatanhx",	two(0xF000, 0x480D),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fatanhx",	two(0xF000, 0x000D),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fbeq",	one(0xF081),		one(0xF1FF),		"IdBc"},
+{"fbf",		one(0xF080),		one(0xF1FF),		"IdBc"},
+{"fbge",	one(0xF093),		one(0xF1FF),		"IdBc"},
+{"fbgl",	one(0xF096),		one(0xF1FF),		"IdBc"},
+{"fbgle",	one(0xF097),		one(0xF1FF),		"IdBc"},
+{"fbgt",	one(0xF092),		one(0xF1FF),		"IdBc"},
+{"fble",	one(0xF095),		one(0xF1FF),		"IdBc"},
+{"fblt",	one(0xF094),		one(0xF1FF),		"IdBc"},
+{"fbne",	one(0xF08E),		one(0xF1FF),		"IdBc"},
+{"fbnge",	one(0xF09C),		one(0xF1FF),		"IdBc"},
+{"fbngl",	one(0xF099),		one(0xF1FF),		"IdBc"},
+{"fbngle",	one(0xF098),		one(0xF1FF),		"IdBc"},
+{"fbngt",	one(0xF09D),		one(0xF1FF),		"IdBc"},
+{"fbnle",	one(0xF09A),		one(0xF1FF),		"IdBc"},
+{"fbnlt",	one(0xF09B),		one(0xF1FF),		"IdBc"},
+{"fboge",	one(0xF083),		one(0xF1FF),		"IdBc"},
+{"fbogl",	one(0xF086),		one(0xF1FF),		"IdBc"},
+{"fbogt",	one(0xF082),		one(0xF1FF),		"IdBc"},
+{"fbole",	one(0xF085),		one(0xF1FF),		"IdBc"},
+{"fbolt",	one(0xF084),		one(0xF1FF),		"IdBc"},
+{"fbor",	one(0xF087),		one(0xF1FF),		"IdBc"},
+{"fbseq",	one(0xF091),		one(0xF1FF),		"IdBc"},
+{"fbsf",	one(0xF090),		one(0xF1FF),		"IdBc"},
+{"fbsne",	one(0xF09E),		one(0xF1FF),		"IdBc"},
+{"fbst",	one(0xF09F),		one(0xF1FF),		"IdBc"},
+{"fbt",		one(0xF08F),		one(0xF1FF),		"IdBc"},
+{"fbueq",	one(0xF089),		one(0xF1FF),		"IdBc"},
+{"fbuge",	one(0xF08B),		one(0xF1FF),		"IdBc"},
+{"fbugt",	one(0xF08A),		one(0xF1FF),		"IdBc"},
+{"fbule",	one(0xF08D),		one(0xF1FF),		"IdBc"},
+{"fbult",	one(0xF08C),		one(0xF1FF),		"IdBc"},
+{"fbun",	one(0xF088),		one(0xF1FF),		"IdBc"},
+
+{"fcmpb",	two(0xF000, 0x5838),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fcmpd",	two(0xF000, 0x5438),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fcmpl",	two(0xF000, 0x4038),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fcmpp",	two(0xF000, 0x4C38),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fcmps",	two(0xF000, 0x4438),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fcmpw",	two(0xF000, 0x5038),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fcmpx",	two(0xF000, 0x0038),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fcmpx",	two(0xF000, 0x4838),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fcosb",	two(0xF000, 0x581D),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fcosd",	two(0xF000, 0x541D),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fcosl",	two(0xF000, 0x401D),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fcosp",	two(0xF000, 0x4C1D),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fcoss",	two(0xF000, 0x441D),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fcosw",	two(0xF000, 0x501D),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fcosx",	two(0xF000, 0x001D),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fcosx",	two(0xF000, 0x481D),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fcosx",	two(0xF000, 0x001D),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fcoshb",	two(0xF000, 0x5819),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fcoshd",	two(0xF000, 0x5419),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fcoshl",	two(0xF000, 0x4019),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fcoshp",	two(0xF000, 0x4C19),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fcoshs",	two(0xF000, 0x4419),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fcoshw",	two(0xF000, 0x5019),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fcoshx",	two(0xF000, 0x0019),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fcoshx",	two(0xF000, 0x4819),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fcoshx",	two(0xF000, 0x0019),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fdbeq",	two(0xF048, 0x0001),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbf",	two(0xF048, 0x0000),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbge",	two(0xF048, 0x0013),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbgl",	two(0xF048, 0x0016),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbgle",	two(0xF048, 0x0017),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbgt",	two(0xF048, 0x0012),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdble",	two(0xF048, 0x0015),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdblt",	two(0xF048, 0x0014),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbne",	two(0xF048, 0x000E),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbnge",	two(0xF048, 0x001C),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbngl",	two(0xF048, 0x0019),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbngle",	two(0xF048, 0x0018),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbngt",	two(0xF048, 0x001D),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbnle",	two(0xF048, 0x001A),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbnlt",	two(0xF048, 0x001B),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdboge",	two(0xF048, 0x0003),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbogl",	two(0xF048, 0x0006),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbogt",	two(0xF048, 0x0002),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbole",	two(0xF048, 0x0005),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbolt",	two(0xF048, 0x0004),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbor",	two(0xF048, 0x0007),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbseq",	two(0xF048, 0x0011),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbsf",	two(0xF048, 0x0010),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbsne",	two(0xF048, 0x001E),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbst",	two(0xF048, 0x001F),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbt",	two(0xF048, 0x000F),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbueq",	two(0xF048, 0x0009),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbuge",	two(0xF048, 0x000B),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbugt",	two(0xF048, 0x000A),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbule",	two(0xF048, 0x000D),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbult",	two(0xF048, 0x000C),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+{"fdbun",	two(0xF048, 0x0008),	two(0xF1F8, 0xFFFF),	"IiDsBw"},
+
+{"fdivb",	two(0xF000, 0x5820),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fdivd",	two(0xF000, 0x5420),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fdivl",	two(0xF000, 0x4020),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fdivp",	two(0xF000, 0x4C20),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fdivs",	two(0xF000, 0x4420),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fdivw",	two(0xF000, 0x5020),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fdivx",	two(0xF000, 0x0020),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fdivx",	two(0xF000, 0x4820),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fetoxb",	two(0xF000, 0x5810),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fetoxd",	two(0xF000, 0x5410),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fetoxl",	two(0xF000, 0x4010),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fetoxp",	two(0xF000, 0x4C10),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fetoxs",	two(0xF000, 0x4410),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fetoxw",	two(0xF000, 0x5010),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fetoxx",	two(0xF000, 0x0010),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fetoxx",	two(0xF000, 0x4810),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fetoxx",	two(0xF000, 0x0010),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fetoxm1b",	two(0xF000, 0x5808),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fetoxm1d",	two(0xF000, 0x5408),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fetoxm1l",	two(0xF000, 0x4008),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fetoxm1p",	two(0xF000, 0x4C08),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fetoxm1s",	two(0xF000, 0x4408),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fetoxm1w",	two(0xF000, 0x5008),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fetoxm1x",	two(0xF000, 0x0008),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fetoxm1x",	two(0xF000, 0x4808),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fetoxm1x",	two(0xF000, 0x0008),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fgetexpb",	two(0xF000, 0x581E),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fgetexpd",	two(0xF000, 0x541E),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fgetexpl",	two(0xF000, 0x401E),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fgetexpp",	two(0xF000, 0x4C1E),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fgetexps",	two(0xF000, 0x441E),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fgetexpw",	two(0xF000, 0x501E),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fgetexpx",	two(0xF000, 0x001E),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fgetexpx",	two(0xF000, 0x481E),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fgetexpx",	two(0xF000, 0x001E),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fgetmanb",	two(0xF000, 0x581F),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fgetmand",	two(0xF000, 0x541F),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fgetmanl",	two(0xF000, 0x401F),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fgetmanp",	two(0xF000, 0x4C1F),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fgetmans",	two(0xF000, 0x441F),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fgetmanw",	two(0xF000, 0x501F),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fgetmanx",	two(0xF000, 0x001F),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fgetmanx",	two(0xF000, 0x481F),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fgetmanx",	two(0xF000, 0x001F),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fintb",	two(0xF000, 0x5801),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fintd",	two(0xF000, 0x5401),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fintl",	two(0xF000, 0x4001),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fintp",	two(0xF000, 0x4C01),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fints",	two(0xF000, 0x4401),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fintw",	two(0xF000, 0x5001),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fintx",	two(0xF000, 0x0001),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fintx",	two(0xF000, 0x4801),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fintx",	two(0xF000, 0x0001),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fintrzb",	two(0xF000, 0x5803),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fintrzd",	two(0xF000, 0x5403),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fintrzl",	two(0xF000, 0x4003),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fintrzp",	two(0xF000, 0x4C03),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fintrzs",	two(0xF000, 0x4403),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fintrzw",	two(0xF000, 0x5003),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fintrzx",	two(0xF000, 0x0003),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fintrzx",	two(0xF000, 0x4803),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fintrzx",	two(0xF000, 0x0003),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"flog10b",	two(0xF000, 0x5815),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"flog10d",	two(0xF000, 0x5415),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"flog10l",	two(0xF000, 0x4015),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"flog10p",	two(0xF000, 0x4C15),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"flog10s",	two(0xF000, 0x4415),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"flog10w",	two(0xF000, 0x5015),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"flog10x",	two(0xF000, 0x0015),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"flog10x",	two(0xF000, 0x4815),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"flog10x",	two(0xF000, 0x0015),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"flog2b",	two(0xF000, 0x5816),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"flog2d",	two(0xF000, 0x5416),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"flog2l",	two(0xF000, 0x4016),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"flog2p",	two(0xF000, 0x4C16),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"flog2s",	two(0xF000, 0x4416),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"flog2w",	two(0xF000, 0x5016),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"flog2x",	two(0xF000, 0x0016),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"flog2x",	two(0xF000, 0x4816),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"flog2x",	two(0xF000, 0x0016),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"flognb",	two(0xF000, 0x5814),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"flognd",	two(0xF000, 0x5414),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"flognl",	two(0xF000, 0x4014),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"flognp",	two(0xF000, 0x4C14),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"flogns",	two(0xF000, 0x4414),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"flognw",	two(0xF000, 0x5014),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"flognx",	two(0xF000, 0x0014),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"flognx",	two(0xF000, 0x4814),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"flognx",	two(0xF000, 0x0014),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"flognp1b",	two(0xF000, 0x5806),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"flognp1d",	two(0xF000, 0x5406),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"flognp1l",	two(0xF000, 0x4006),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"flognp1p",	two(0xF000, 0x4C06),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"flognp1s",	two(0xF000, 0x4406),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"flognp1w",	two(0xF000, 0x5006),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"flognp1x",	two(0xF000, 0x0006),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"flognp1x",	two(0xF000, 0x4806),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"flognp1x",	two(0xF000, 0x0006),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fmodb",	two(0xF000, 0x5821),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fmodd",	two(0xF000, 0x5421),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fmodl",	two(0xF000, 0x4021),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fmodp",	two(0xF000, 0x4C21),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fmods",	two(0xF000, 0x4421),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fmodw",	two(0xF000, 0x5021),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fmodx",	two(0xF000, 0x0021),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fmodx",	two(0xF000, 0x4821),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fmoveb",	two(0xF000, 0x5800),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},		/* fmove from <ea> to fp<n> */
+{"fmoveb",	two(0xF000, 0x7800),	two(0xF1C0, 0xFC7F),	"IiF7@b"},		/* fmove from fp<n> to <ea> */
+{"fmoved",	two(0xF000, 0x5400),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},		/* fmove from <ea> to fp<n> */
+{"fmoved",	two(0xF000, 0x7400),	two(0xF1C0, 0xFC7F),	"IiF7@F"},		/* fmove from fp<n> to <ea> */
+{"fmovel",	two(0xF000, 0x4000),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},		/* fmove from <ea> to fp<n> */
+{"fmovel",	two(0xF000, 0x6000),	two(0xF1C0, 0xFC7F),	"IiF7@l"},		/* fmove from fp<n> to <ea> */
+	/* JF for the assembler */
+{"fmovel",	two(0xF000, 0xA000),	two(0xF1C0, 0xE3FF),	"Iis8@s"},
+{"fmovel",	two(0xF000, 0x8000),	two(0xF1C0, 0xE3FF),	"Ii@ss8"},
+/* JF {"fmovep",	two(0xF000, 0x4C00),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},		/* fmove from <ea> to fp<n> */
+{"fmovep",	two(0xF000, 0x6C00),	two(0xF1C0, 0xFC00),	"IiF7@pkC"},		/* fmove.p with k-factors: */
+{"fmovep",	two(0xF000, 0x7C00),	two(0xF1C0, 0xFC0F),	"IiF7@pDk"},		/* fmove.p with k-factors: */
+{"fmoves",	two(0xF000, 0x4400),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},		/* fmove from <ea> to fp<n> */
+{"fmoves",	two(0xF000, 0x6400),	two(0xF1C0, 0xFC7F),	"IiF7@f"},		/* fmove from fp<n> to <ea> */
+{"fmovew",	two(0xF000, 0x5000),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},		/* fmove from <ea> to fp<n> */
+{"fmovew",	two(0xF000, 0x7000),	two(0xF1C0, 0xFC7F),	"IiF7@w"},		/* fmove from fp<n> to <ea> */
+{"fmovex",	two(0xF000, 0x0000),	two(0xF1C0, 0xE07F),	"IiF8F7"},		/* fmove from <ea> to fp<n> */
+{"fmovex",	two(0xF000, 0x4800),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},		/* fmove from <ea> to fp<n> */
+{"fmovex",	two(0xF000, 0x6800),	two(0xF1C0, 0xFC7F),	"IiF7@x"},		/* fmove from fp<n> to <ea> */
+
+		/* fmove.l from/to system control registers: */
+
+/* fmove.l and fmovem.l are the same instruction.   fmovem.l makes sense in
+   more cases,	so I've dumped fmove.l pro tem,	but this is the wrong
+   way to solve the problem in the long run.   Hmmm. */
+/*  {"fmovel",	two(0xF000, 0xA000),	two(0xF1C0, 0xE3FF),	"Iis8@s"},	*/
+/*  {"fmovel",	two(0xF000, 0x8000),	two(0xF1C0, 0xE3FF),	"Ii@ss8"},	*/
+
+{"fmovecrx",	two(0xF000, 0x5C00),	two(0xF1FF, 0xFC00),	"Ii#CF7"},		/* fmovecr.x #ccc,	FPn */
+{"fmovecr",	two(0xF000, 0x5C00),	two(0xF1FF, 0xFC00),	"Ii#CF7"},
+
+{"fmovemx",	two(0xF020, 0xE000),	two(0xF1F8, 0xFF00),	"Id#3-s"},		/* fmovem.x to autodecrement,	static and dynamic */
+{"fmovemx",	two(0xF020, 0xE800),	two(0xF1F8, 0xFF8F),	"IiDk-s"},		/* fmovem.x to autodecrement,	static and dynamic */
+
+{"fmovemx",	two(0xF000, 0xF000),	two(0xF1C0, 0xFF00),	"Id#3&s"},		/* fmovem.x to control,	static and dynamic: */
+{"fmovemx",	two(0xF000, 0xF800),	two(0xF1C0, 0xFF8F),	"IiDk&s"},		/* fmovem.x to control,	static and dynamic: */
+
+{"fmovemx",	two(0xF018, 0xD000),	two(0xF1F8, 0xFF00),	"Id#3+s"},		/* fmovem.x from autoincrement,	static and dynamic: */
+{"fmovemx",	two(0xF018, 0xD800),	two(0xF1F8, 0xFF8F),	"IiDk+s"},		/* fmovem.x from autoincrement,	static and dynamic: */
+  
+{"fmovemx",	two(0xF000, 0xD000),	two(0xF1C0, 0xFF00),	"Id#3&s"},		/* fmovem.x from control,	static and dynamic: */
+{"fmovemx",	two(0xF000, 0xD800),	two(0xF1C0, 0xFF8F),	"IiDk&s"},		/* fmovem.x from control,	static and dynamic: */
+
+/* fmoveml and fmovel are the same instruction.   This may cause some
+   confusion in the assembler. */
+
+{"fmoveml",	two(0xF000, 0xA000),	two(0xF1C0, 0xE3FF),	"Ii#8%s"},		/* fmovem.l to/from system control register(s): */
+{"fmoveml",	two(0xF000, 0x8000),	two(0xF1C0, 0xE3FF),	"Ii%s#8"},		/* fmovem.l to/from system control register(s): */
+
+{"fmulb",	two(0xF000, 0x5823),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fmuld",	two(0xF000, 0x5423),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fmull",	two(0xF000, 0x4023),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fmulp",	two(0xF000, 0x4C23),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fmuls",	two(0xF000, 0x4423),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fmulw",	two(0xF000, 0x5023),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fmulx",	two(0xF000, 0x0023),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fmulx",	two(0xF000, 0x4823),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fnegb",	two(0xF000, 0x581A),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fnegd",	two(0xF000, 0x541A),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fnegl",	two(0xF000, 0x401A),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fnegp",	two(0xF000, 0x4C1A),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fnegs",	two(0xF000, 0x441A),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fnegw",	two(0xF000, 0x501A),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fnegx",	two(0xF000, 0x001A),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fnegx",	two(0xF000, 0x481A),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fnegx",	two(0xF000, 0x001A),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fremb",	two(0xF000, 0x5825),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fremd",	two(0xF000, 0x5425),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"freml",	two(0xF000, 0x4025),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fremp",	two(0xF000, 0x4C25),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"frems",	two(0xF000, 0x4425),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fremw",	two(0xF000, 0x5025),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fremx",	two(0xF000, 0x0025),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fremx",	two(0xF000, 0x4825),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"frestore",	one(0xF140),		one(0xF1C0),		"Id&s"},
+{"frestore",	one(0xF158),		one(0xF1F8),		"Id+s"},
+{"fsave",	one(0xF100),		one(0xF1C0),		"Id&s"},
+{"fsave",	one(0xF120),		one(0xF1F8),		"Id-s"},
+
+{"fsincosb",	two(0xF000, 0x5830),	two(0xF1C0, 0xFC78),	"Ii;bF7FC"},
+{"fsincosd",	two(0xF000, 0x5430),	two(0xF1C0, 0xFC78),	"Ii;FF7FC"},
+{"fsincosl",	two(0xF000, 0x4030),	two(0xF1C0, 0xFC78),	"Ii;lF7FC"},
+{"fsincosp",	two(0xF000, 0x4C30),	two(0xF1C0, 0xFC78),	"Ii;pF7FC"},
+{"fsincoss",	two(0xF000, 0x4430),	two(0xF1C0, 0xFC78),	"Ii;fF7FC"},
+{"fsincosw",	two(0xF000, 0x5030),	two(0xF1C0, 0xFC78),	"Ii;wF7FC"},
+{"fsincosx",	two(0xF000, 0x0030),	two(0xF1C0, 0xE078),	"IiF8F7FC"},
+{"fsincosx",	two(0xF000, 0x4830),	two(0xF1C0, 0xFC78),	"Ii;xF7FC"},
+
+{"fscaleb",	two(0xF000, 0x5826),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fscaled",	two(0xF000, 0x5426),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fscalel",	two(0xF000, 0x4026),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fscalep",	two(0xF000, 0x4C26),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fscales",	two(0xF000, 0x4426),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fscalew",	two(0xF000, 0x5026),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fscalex",	two(0xF000, 0x0026),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fscalex",	two(0xF000, 0x4826),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fseq",	two(0xF040, 0x0001),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsf",		two(0xF040, 0x0000),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsge",	two(0xF040, 0x0013),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsgl",	two(0xF040, 0x0016),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsgle",	two(0xF040, 0x0017),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsgt",	two(0xF040, 0x0012),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsle",	two(0xF040, 0x0015),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fslt",	two(0xF040, 0x0014),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsne",	two(0xF040, 0x000E),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsnge",	two(0xF040, 0x001C),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsngl",	two(0xF040, 0x0019),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsngle",	two(0xF040, 0x0018),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsngt",	two(0xF040, 0x001D),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsnle",	two(0xF040, 0x001A),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsnlt",	two(0xF040, 0x001B),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsoge",	two(0xF040, 0x0003),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsogl",	two(0xF040, 0x0006),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsogt",	two(0xF040, 0x0002),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsole",	two(0xF040, 0x0005),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsolt",	two(0xF040, 0x0004),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsor",	two(0xF040, 0x0007),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsseq",	two(0xF040, 0x0011),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fssf",	two(0xF040, 0x0010),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fssne",	two(0xF040, 0x001E),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsst",	two(0xF040, 0x001F),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fst",		two(0xF040, 0x000F),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsueq",	two(0xF040, 0x0009),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsuge",	two(0xF040, 0x000B),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsugt",	two(0xF040, 0x000A),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsule",	two(0xF040, 0x000D),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsult",	two(0xF040, 0x000C),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+{"fsun",	two(0xF040, 0x0008),	two(0xF1C0, 0xFFFF),	"Ii@s"},
+
+{"fsgldivb",	two(0xF000, 0x5824),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsgldivd",	two(0xF000, 0x5424),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsgldivl",	two(0xF000, 0x4024),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsgldivp",	two(0xF000, 0x4C24),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsgldivs",	two(0xF000, 0x4424),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsgldivw",	two(0xF000, 0x5024),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsgldivx",	two(0xF000, 0x0024),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsgldivx",	two(0xF000, 0x4824),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fsglmulb",	two(0xF000, 0x5827),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsglmuld",	two(0xF000, 0x5427),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsglmull",	two(0xF000, 0x4027),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsglmulp",	two(0xF000, 0x4C27),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsglmuls",	two(0xF000, 0x4427),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsglmulw",	two(0xF000, 0x5027),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsglmulx",	two(0xF000, 0x0027),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsglmulx",	two(0xF000, 0x4827),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"fsinb",	two(0xF000, 0x580E),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsind",	two(0xF000, 0x540E),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsinl",	two(0xF000, 0x400E),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsinp",	two(0xF000, 0x4C0E),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsins",	two(0xF000, 0x440E),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsinw",	two(0xF000, 0x500E),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsinx",	two(0xF000, 0x000E),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsinx",	two(0xF000, 0x480E),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fsinx",	two(0xF000, 0x000E),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fsinhb",	two(0xF000, 0x5802),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsinhd",	two(0xF000, 0x5402),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsinhl",	two(0xF000, 0x4002),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsinhp",	two(0xF000, 0x4C02),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsinhs",	two(0xF000, 0x4402),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsinhw",	two(0xF000, 0x5002),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsinhx",	two(0xF000, 0x0002),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsinhx",	two(0xF000, 0x4802),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fsinhx",	two(0xF000, 0x0002),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fsqrtb",	two(0xF000, 0x5804),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsqrtd",	two(0xF000, 0x5404),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsqrtl",	two(0xF000, 0x4004),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsqrtp",	two(0xF000, 0x4C04),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsqrts",	two(0xF000, 0x4404),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsqrtw",	two(0xF000, 0x5004),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsqrtx",	two(0xF000, 0x0004),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsqrtx",	two(0xF000, 0x4804),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"fsqrtx",	two(0xF000, 0x0004),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"fsubb",	two(0xF000, 0x5828),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"fsubd",	two(0xF000, 0x5428),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"fsubl",	two(0xF000, 0x4028),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"fsubp",	two(0xF000, 0x4C28),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"fsubs",	two(0xF000, 0x4428),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"fsubw",	two(0xF000, 0x5028),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"fsubx",	two(0xF000, 0x0028),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"fsubx",	two(0xF000, 0x4828),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+
+{"ftanb",	two(0xF000, 0x580F),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"ftand",	two(0xF000, 0x540F),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"ftanl",	two(0xF000, 0x400F),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"ftanp",	two(0xF000, 0x4C0F),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"ftans",	two(0xF000, 0x440F),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"ftanw",	two(0xF000, 0x500F),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"ftanx",	two(0xF000, 0x000F),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"ftanx",	two(0xF000, 0x480F),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"ftanx",	two(0xF000, 0x000F),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"ftanhb",	two(0xF000, 0x5809),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"ftanhd",	two(0xF000, 0x5409),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"ftanhl",	two(0xF000, 0x4009),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"ftanhp",	two(0xF000, 0x4C09),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"ftanhs",	two(0xF000, 0x4409),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"ftanhw",	two(0xF000, 0x5009),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"ftanhx",	two(0xF000, 0x0009),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"ftanhx",	two(0xF000, 0x4809),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"ftanhx",	two(0xF000, 0x0009),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"ftentoxb",	two(0xF000, 0x5812),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"ftentoxd",	two(0xF000, 0x5412),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"ftentoxl",	two(0xF000, 0x4012),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"ftentoxp",	two(0xF000, 0x4C12),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"ftentoxs",	two(0xF000, 0x4412),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"ftentoxw",	two(0xF000, 0x5012),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"ftentoxx",	two(0xF000, 0x0012),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"ftentoxx",	two(0xF000, 0x4812),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"ftentoxx",	two(0xF000, 0x0012),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+{"ftrapeq",	two(0xF07C, 0x0001),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapf",	two(0xF07C, 0x0000),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapge",	two(0xF07C, 0x0013),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapgl",	two(0xF07C, 0x0016),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapgle",	two(0xF07C, 0x0017),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapgt",	two(0xF07C, 0x0012),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftraple",	two(0xF07C, 0x0015),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftraplt",	two(0xF07C, 0x0014),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapne",	two(0xF07C, 0x000E),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapnge",	two(0xF07C, 0x001C),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapngl",	two(0xF07C, 0x0019),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapngle",	two(0xF07C, 0x0018),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapngt",	two(0xF07C, 0x001D),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapnle",	two(0xF07C, 0x001A),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapnlt",	two(0xF07C, 0x001B),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapoge",	two(0xF07C, 0x0003),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapogl",	two(0xF07C, 0x0006),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapogt",	two(0xF07C, 0x0002),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapole",	two(0xF07C, 0x0005),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapolt",	two(0xF07C, 0x0004),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapor",	two(0xF07C, 0x0007),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapseq",	two(0xF07C, 0x0011),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapsf",	two(0xF07C, 0x0010),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapsne",	two(0xF07C, 0x001E),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapst",	two(0xF07C, 0x001F),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapt",	two(0xF07C, 0x000F),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapueq",	two(0xF07C, 0x0009),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapuge",	two(0xF07C, 0x000B),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapugt",	two(0xF07C, 0x000A),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapule",	two(0xF07C, 0x000D),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapult",	two(0xF07C, 0x000C),	two(0xF1FF, 0xFFFF),	"Ii"},
+{"ftrapun",	two(0xF07C, 0x0008),	two(0xF1FF, 0xFFFF),	"Ii"},
+        
+{"ftrapeqw",	two(0xF07A, 0x0001),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapfw",	two(0xF07A, 0x0000),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapgew",	two(0xF07A, 0x0013),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapglw",	two(0xF07A, 0x0016),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapglew",	two(0xF07A, 0x0017),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapgtw",	two(0xF07A, 0x0012),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftraplew",	two(0xF07A, 0x0015),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapltw",	two(0xF07A, 0x0014),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapnew",	two(0xF07A, 0x000E),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapngew",	two(0xF07A, 0x001C),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapnglw",	two(0xF07A, 0x0019),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapnglew",	two(0xF07A, 0x0018),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapngtw",	two(0xF07A, 0x001D),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapnlew",	two(0xF07A, 0x001A),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapnltw",	two(0xF07A, 0x001B),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapogew",	two(0xF07A, 0x0003),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapoglw",	two(0xF07A, 0x0006),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapogtw",	two(0xF07A, 0x0002),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapolew",	two(0xF07A, 0x0005),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapoltw",	two(0xF07A, 0x0004),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftraporw",	two(0xF07A, 0x0007),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapseqw",	two(0xF07A, 0x0011),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapsfw",	two(0xF07A, 0x0010),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapsnew",	two(0xF07A, 0x001E),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapstw",	two(0xF07A, 0x001F),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftraptw",	two(0xF07A, 0x000F),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapueqw",	two(0xF07A, 0x0009),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapugew",	two(0xF07A, 0x000B),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapugtw",	two(0xF07A, 0x000A),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapulew",	two(0xF07A, 0x000D),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapultw",	two(0xF07A, 0x000C),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+{"ftrapunw",	two(0xF07A, 0x0008),	two(0xF1FF, 0xFFFF),	"Ii^w"},
+
+{"ftrapeql",	two(0xF07B, 0x0001),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapfl",	two(0xF07B, 0x0000),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapgel",	two(0xF07B, 0x0013),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapgll",	two(0xF07B, 0x0016),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapglel",	two(0xF07B, 0x0017),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapgtl",	two(0xF07B, 0x0012),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftraplel",	two(0xF07B, 0x0015),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapltl",	two(0xF07B, 0x0014),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapnel",	two(0xF07B, 0x000E),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapngel",	two(0xF07B, 0x001C),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapngll",	two(0xF07B, 0x0019),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapnglel",	two(0xF07B, 0x0018),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapngtl",	two(0xF07B, 0x001D),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapnlel",	two(0xF07B, 0x001A),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapnltl",	two(0xF07B, 0x001B),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapogel",	two(0xF07B, 0x0003),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapogll",	two(0xF07B, 0x0006),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapogtl",	two(0xF07B, 0x0002),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapolel",	two(0xF07B, 0x0005),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapoltl",	two(0xF07B, 0x0004),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftraporl",	two(0xF07B, 0x0007),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapseql",	two(0xF07B, 0x0011),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapsfl",	two(0xF07B, 0x0010),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapsnel",	two(0xF07B, 0x001E),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapstl",	two(0xF07B, 0x001F),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftraptl",	two(0xF07B, 0x000F),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapueql",	two(0xF07B, 0x0009),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapugel",	two(0xF07B, 0x000B),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapugtl",	two(0xF07B, 0x000A),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapulel",	two(0xF07B, 0x000D),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapultl",	two(0xF07B, 0x000C),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+{"ftrapunl",	two(0xF07B, 0x0008),	two(0xF1FF, 0xFFFF),	"Ii^l"},
+
+{"ftstb",	two(0xF000, 0x583A),	two(0xF1C0, 0xFC7F),	"Ii;b"},
+{"ftstd",	two(0xF000, 0x543A),	two(0xF1C0, 0xFC7F),	"Ii;F"},
+{"ftstl",	two(0xF000, 0x403A),	two(0xF1C0, 0xFC7F),	"Ii;l"},
+{"ftstp",	two(0xF000, 0x4C3A),	two(0xF1C0, 0xFC7F),	"Ii;p"},
+{"ftsts",	two(0xF000, 0x443A),	two(0xF1C0, 0xFC7F),	"Ii;f"},
+{"ftstw",	two(0xF000, 0x503A),	two(0xF1C0, 0xFC7F),	"Ii;w"},
+{"ftstx",	two(0xF000, 0x003A),	two(0xF1C0, 0xE07F),	"IiF8"},
+{"ftstx",	two(0xF000, 0x483A),	two(0xF1C0, 0xFC7F),	"Ii;x"},
+
+{"ftwotoxb",	two(0xF000, 0x5811),	two(0xF1C0, 0xFC7F),	"Ii;bF7"},
+{"ftwotoxd",	two(0xF000, 0x5411),	two(0xF1C0, 0xFC7F),	"Ii;FF7"},
+{"ftwotoxl",	two(0xF000, 0x4011),	two(0xF1C0, 0xFC7F),	"Ii;lF7"},
+{"ftwotoxp",	two(0xF000, 0x4C11),	two(0xF1C0, 0xFC7F),	"Ii;pF7"},
+{"ftwotoxs",	two(0xF000, 0x4411),	two(0xF1C0, 0xFC7F),	"Ii;fF7"},
+{"ftwotoxw",	two(0xF000, 0x5011),	two(0xF1C0, 0xFC7F),	"Ii;wF7"},
+{"ftwotoxx",	two(0xF000, 0x0011),	two(0xF1C0, 0xE07F),	"IiF8F7"},
+{"ftwotoxx",	two(0xF000, 0x4811),	two(0xF1C0, 0xFC7F),	"Ii;xF7"},
+{"ftwotoxx",	two(0xF000, 0x0011),	two(0xF1C0, 0xE07F),	"IiFt"},
+
+/* Alternate mnemonics for SUN */
+
+{"jbsr",	one(0060400),		one(0177400),		"Bg"},
+{"jbsr",	one(0047200),		one(0177700),		"!s"},
+{"jra",		one(0060000),		one(0177400),		"Bg"},
+{"jra",		one(0047300),		one(0177700),		"!s"},
+  
+{"jhi",		one(0061000),		one(0177400),		"Bg"},
+{"jls",		one(0061400),		one(0177400),		"Bg"},
+{"jcc",		one(0062000),		one(0177400),		"Bg"},
+{"jcs",		one(0062400),		one(0177400),		"Bg"},
+{"jne",		one(0063000),		one(0177400),		"Bg"},
+{"jeq",		one(0063400),		one(0177400),		"Bg"},
+{"jvc",		one(0064000),		one(0177400),		"Bg"},
+{"jvs",		one(0064400),		one(0177400),		"Bg"},
+{"jpl",		one(0065000),		one(0177400),		"Bg"},
+{"jmi",		one(0065400),		one(0177400),		"Bg"},
+{"jge",		one(0066000),		one(0177400),		"Bg"},
+{"jlt",		one(0066400),		one(0177400),		"Bg"},
+{"jgt",		one(0067000),		one(0177400),		"Bg"},
+{"jle",		one(0067400),		one(0177400),		"Bg"},
+
+{"movql",	one(0070000),		one(0170400),		"MsDd"},
+{"moveql",	one(0070000),		one(0170400),		"MsDd"},
+{"moval",	one(0020100),		one(0170700),		"*lAd"},
+{"movaw",	one(0030100),		one(0170700),		"*wAd"},
+{"movb",	one(0010000),		one(0170000),		";b$d"},	/* mov */
+{"movl",	one(0020000),		one(0170000),		"*l$d"},
+{"movl",	one(0020100),		one(0170700),		"*lAd"},
+{"movl",	one(0047140),		one(0177770),		"AsUd"},	/* mov to USP */
+{"movl",	one(0047150),		one(0177770),		"UdAs"},	/* mov from USP */
+{"movl",	one(0070000),		one(0170400),		"MsDd"},	/* movq written as mov */
+{"movml",	one(0044300),		one(0177700),		"#w&s"},	/* movm reg to mem. */
+{"movml",	one(0044340),		one(0177770),		"#w-s"},	/* movm reg to autodecrement. */
+{"movml",	one(0046300),		one(0177700),		"!s#w"},	/* movm mem to reg. */
+{"movml",	one(0046330),		one(0177770),		"+s#w"},	/* movm autoinc to reg. */
+{"movmw",	one(0044200),		one(0177700),		"#w&s"},	/* movm reg to mem. */
+{"movmw",	one(0044240),		one(0177770),		"#w-s"},	/* movm reg to autodecrement. */
+{"movmw",	one(0046200),		one(0177700),		"!s#w"},	/* movm mem to reg. */
+{"movmw",	one(0046230),		one(0177770),		"+s#w"},	/* movm autoinc to reg. */
+{"movpl",	one(0000510),		one(0170770),		"dsDd"},	/* memory to register */
+{"movpl",	one(0000710),		one(0170770),		"Ddds"},	/* register to memory */
+{"movpw",	one(0000410),		one(0170770),		"dsDd"},	/* memory to register */
+{"movpw",	one(0000610),		one(0170770),		"Ddds"},	/* register to memory */
+{"movq",	one(0070000),		one(0170400),		"MsDd"},
+{"movw",	one(0030000),		one(0170000),		"*w$d"},
+{"movw",	one(0030100),		one(0170700),		"*wAd"},	/* mova,	written as mov */
+{"movw",	one(0040300),		one(0177700),		"Ss$s"},	/* Move from sr */
+{"movw",	one(0041300),		one(0177700),		"Cs$s"},	/* Move from ccr */
+{"movw",	one(0042300),		one(0177700),		";wCd"},	/* mov to ccr */
+{"movw",	one(0043300),		one(0177700),		";wSd"},	/* mov to sr */
+/* movc not done*/
+
+{"movsb",	two(0007000, 0),	two(0177700, 07777),	"~sR1"},
+{"movsb",	two(0007000, 04000),	two(0177700, 07777),	"R1~s"},
+{"movsl",	two(0007200, 0),	two(0177700, 07777),	"~sR1"},
+{"movsl",	two(0007200, 04000),	two(0177700, 07777),	"R1~s"},
+{"movsw",	two(0007100, 0),	two(0177700, 07777),	"~sR1"},
+{"movsw",	two(0007100, 04000),	two(0177700, 07777),	"R1~s"},
+};
+
+int numopcodes=sizeof(m68k_opcodes)/sizeof(m68k_opcodes[0]);
+
+struct m68k_opcode *endop = m68k_opcodes+sizeof(m68k_opcodes)/sizeof(m68k_opcodes[0]);;
diff --git a/gdb/m68k-pinsn.c b/gdb/m68k-pinsn.c
new file mode 100644
index 0000000..a22a36a
--- /dev/null
+++ b/gdb/m68k-pinsn.c
@@ -0,0 +1,773 @@
+/* Print m68k instructions for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "m68k-opcode.h"
+
+/* 68k instructions are never longer than this many bytes.  */
+#define MAXLEN 22
+
+/* Number of elements in the opcode table.  */
+#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
+
+extern char *reg_names[];
+char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
+		     "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
+
+static unsigned char *print_insn_arg ();
+static unsigned char *print_indexed ();
+static void print_base ();
+static int fetch_arg ();
+
+#define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
+
+#define NEXTWORD(p)  \
+  (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
+
+#define NEXTLONG(p)  \
+  (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
+
+#define NEXTSINGLE(p) \
+  (p += 4, *((float *)(p - 4)))
+
+#define NEXTDOUBLE(p) \
+  (p += 8, *((double *)(p - 8)))
+
+#define NEXTEXTEND(p) \
+  (p += 12, 0.0)	/* Need a function to convert from extended to double
+			   precision... */
+
+#define NEXTPACKED(p) \
+  (p += 12, 0.0)	/* Need a function to convert from packed to double
+			   precision.   Actually, it's easier to print a
+			   packed number than a double anyway, so maybe
+			   there should be a special case to handle this... */
+
+/* Print the m68k instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  register int i;
+  register unsigned char *p;
+  register char *d;
+  register int bestmask;
+  int best;
+
+  read_memory (memaddr, buffer, MAXLEN);
+
+  bestmask = 0;
+  best = -1;
+  for (i = 0; i < NOPCODES; i++)
+    {
+      register unsigned int opcode = m68k_opcodes[i].opcode;
+      register unsigned int match = m68k_opcodes[i].match;
+      if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
+	  && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
+	  && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
+	  && ((0xff & buffer[3] & match) == (0xff & opcode)))
+	{
+	  /* Don't use for printout the variants of divul and divsl
+	     that have the same register number in two places.
+	     The more general variants will match instead.  */
+	  for (d = m68k_opcodes[i].args; *d; d += 2)
+	    if (d[1] == 'D')
+	      break;
+
+	  /* Don't use for printout the variants of most floating
+	     point coprocessor instructions which use the same
+	     register number in two places, as above. */
+	  if (*d == 0)
+	    for (d = m68k_opcodes[i].args; *d; d += 2)
+	      if (d[1] == 't')
+		break;
+
+	  if (*d == 0 && match > bestmask)
+	    {
+	      best = i;
+	      bestmask = match;
+	    }
+	}
+    }
+
+  /* Handle undefined instructions.  */
+  if (best < 0)
+    {
+      fprintf (stream, "0%o", (buffer[0] << 8) + buffer[1]);
+      return 2;
+    }
+
+  fprintf (stream, "%s", m68k_opcodes[best].name);
+
+  /* Point at first word of argument data,
+     and at descriptor for first argument.  */
+  p = buffer + 2;
+  
+  /* Why do this this way? -MelloN */
+  for (d = m68k_opcodes[best].args; *d; d += 2)
+    {
+      if (d[0] == '#')
+	{
+	  if (d[1] == 'l' && p - buffer < 6)
+	    p = buffer + 6;
+	  else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
+	    p = buffer + 4;
+	}
+      if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
+	p = buffer + 4;
+      if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
+	p = buffer + 6;
+    }
+
+  d = m68k_opcodes[best].args;
+
+  if (*d)
+    fputc (' ', stream);
+
+  while (*d)
+    {
+      p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
+      d += 2;
+      if (*d && *(d - 2) != 'I' && *d != 'k')
+	fprintf (stream, ",");
+    }
+  return p - buffer;
+}
+
+static unsigned char *
+print_insn_arg (d, buffer, p, addr, stream)
+     char *d;
+     unsigned char *buffer;
+     register unsigned char *p;
+     CORE_ADDR addr;		/* PC for this arg to be relative to */
+     FILE *stream;
+{
+  register int val;
+  register int place = d[1];
+  int regno;
+  register char *regname;
+  register unsigned char *p1;
+  register double flval;
+  int flt_p;
+
+  switch (*d)
+    {
+    case 'C':
+      fprintf (stream, "ccr");
+      break;
+
+    case 'S':
+      fprintf (stream, "sr");
+      break;
+
+    case 'U':
+      fprintf (stream, "usp");
+      break;
+
+    case 'J':
+      {
+	static struct { char *name; int value; } names[]
+	  = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
+	     {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
+	     {"msp", 0x803}, {"isp", 0x804}};
+
+	val = fetch_arg (buffer, place, 12);
+	for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
+	  if (names[regno].value == val)
+	    {
+	      fprintf (stream, names[regno].name);
+	      break;
+	    }
+	if (regno < 0)
+	  fprintf (stream, "%d", val);
+      }
+      break;
+
+    case 'Q':
+      val = fetch_arg (buffer, place, 3);
+      if (val == 0) val = 8;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'M':
+      val = fetch_arg (buffer, place, 8);
+      if (val & 0x80)
+	val = val - 0x100;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'T':
+      val = fetch_arg (buffer, place, 4);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'D':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'A':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3) + 010]);
+      break;
+
+    case 'R':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
+      break;
+
+    case 'F':
+      fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
+      break;
+
+    case 'O':
+      val = fetch_arg (buffer, place, 6);
+      if (val & 0x20)
+	fprintf (stream, "%s", reg_names [val & 7]);
+      else
+	fprintf (stream, "%d", val);
+      break;
+
+    case '+':
+      fprintf (stream, "(%s)+", reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case '-':
+      fprintf (stream, "-(%s)", reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case 'k':
+      if (place == 'k')
+	fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
+      else if (place == 'C')
+	{
+	  val = fetch_arg (buffer, place, 7);
+	  if ( val > 63 )		/* This is a signed constant. */
+	    val -= 128;
+	  fprintf (stream, "{#%d}", val);
+	}
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      break;
+
+    case '#':
+      p1 = buffer + 2;
+      if (place == 's')
+	val = fetch_arg (buffer, place, 4);
+      else if (place == 'C')
+	val = fetch_arg (buffer, place, 7);
+      else if (place == '8')
+	val = fetch_arg (buffer, place, 3);
+      else if (place == '3')
+	val = fetch_arg (buffer, place, 8);
+      else if (place == 'b')
+	val = NEXTBYTE (p1);
+      else if (place == 'w')
+	val = NEXTWORD (p1);
+      else if (place == 'l')
+	val = NEXTLONG (p1);
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case '^':
+      if (place == 's')
+	val = fetch_arg (buffer, place, 4);
+      else if (place == 'C')
+	val = fetch_arg (buffer, place, 7);
+      else if (place == '8')
+	val = fetch_arg (buffer, place, 3);
+      else if (place == 'b')
+	val = NEXTBYTE (p);
+      else if (place == 'w')
+	val = NEXTWORD (p);
+      else if (place == 'l')
+	val = NEXTLONG (p);
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'B':
+      if (place == 'b')
+	val = NEXTBYTE (p);
+      else if (place == 'w')
+	val = NEXTWORD (p);
+      else if (place == 'l')
+	val = NEXTLONG (p);
+      else if (place == 'g')
+	{
+	  val = ((char *)buffer)[1];
+	  if (val == 0)
+	    val = NEXTWORD (p);
+	  else if (val == -1)
+	    val = NEXTLONG (p);
+	}
+      else if (place == 'c')
+	{
+	  if (buffer[1] & 0x40)		/* If bit six is one, long offset */
+	    val = NEXTLONG (p);
+	  else
+	    val = NEXTWORD (p);
+	}
+      else
+	error ("Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+
+      print_address (addr + val, stream);
+      break;
+
+    case 'd':
+      val = NEXTWORD (p);
+      fprintf (stream, "%d(%s)", val, fetch_arg (buffer, place, 3));
+      break;
+
+    case 's':
+      fprintf (stream, "%s", fpcr_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'I':
+      val = fetch_arg (buffer, 'd', 3);		  /* Get coprocessor ID... */
+      if (val != 1)				/* Unusual coprocessor ID? */
+	fprintf (stream, "(cpid=%d) ", val);
+      if (place == 'i')
+	p += 2;			     /* Skip coprocessor extended operands */
+      break;
+
+    case '*':
+    case '~':
+    case '%':
+    case ';':
+    case '@':
+    case '!':
+    case '$':
+    case '?':
+    case '/':
+    case '&':
+
+      if (place == 'd')
+	{
+	  val = fetch_arg (buffer, 'x', 6);
+	  val = ((val & 7) << 3) + ((val >> 3) & 7);
+	}
+      else
+	val = fetch_arg (buffer, 's', 6);
+
+      /* Get register number assuming address register.  */
+      regno = (val & 7) + 8;
+      regname = reg_names[regno];
+      switch (val >> 3)
+	{
+	case 0:
+	  fprintf (stream, "%s", reg_names[val]);
+	  break;
+
+	case 1:
+	  fprintf (stream, "%s", regname);
+	  break;
+
+	case 2:
+	  fprintf (stream, "(%s)", regname);
+	  break;
+
+	case 3:
+	  fprintf (stream, "(%s)+", regname);
+	  break;
+
+	case 4:
+	  fprintf (stream, "-(%s)", regname);
+	  break;
+
+	case 5:
+	  val = NEXTWORD (p);
+	  fprintf (stream, "%d(%s)", val, regname);
+	  break;
+
+	case 6:
+	  p = print_indexed (regno, p, addr, stream);
+	  break;
+
+	case 7:
+	  switch (val & 7)
+	    {
+	    case 0:
+	      val = NEXTWORD (p);
+	      fprintf (stream, "@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 1:
+	      val = NEXTLONG (p);
+	      fprintf (stream, "@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 2:
+	      val = NEXTWORD (p);
+	      print_address (addr + val, stream);
+	      break;
+
+	    case 3:
+	      p = print_indexed (-1, p, addr, stream);
+	      break;
+
+	    case 4:
+	      flt_p = 1;	/* Assume it's a float... */
+	      switch( place )
+	      {
+		case 'b':
+		  val = NEXTBYTE (p);
+		  flt_p = 0;
+		  break;
+
+		case 'w':
+		  val = NEXTWORD (p);
+		  flt_p = 0;
+		  break;
+
+		case 'l':
+		  val = NEXTLONG (p);
+		  flt_p = 0;
+		  break;
+
+		case 'f':
+		  flval = NEXTSINGLE(p);
+		  break;
+
+		case 'F':
+		  flval = NEXTDOUBLE(p);
+		  break;
+
+		case 'x':
+		  flval = NEXTEXTEND(p);
+		  break;
+
+		case 'p':
+		  flval = NEXTPACKED(p);
+		  break;
+
+		default:
+		  error ("Invalid arg format in opcode table: \"%c%c\".",
+		       *d, place);
+	      }
+	      if ( flt_p )	/* Print a float? */
+		fprintf (stream, "#%g", flval);
+	      else
+		fprintf (stream, "#%d", val);
+	      break;
+
+	    default:
+	      fprintf (stream, "<invalid address mode 0%o>", val);
+	    }
+	}
+      break;
+
+    default:
+      error ("Invalid arg format in opcode table: \"%c\".", *d);
+    }
+
+  return (unsigned char *) p;
+}
+
+/* Fetch BITS bits from a position in the instruction specified by CODE.
+   CODE is a "place to put an argument", or 'x' for a destination
+   that is a general address (mode and register).
+   BUFFER contains the instruction.  */
+
+static int
+fetch_arg (buffer, code, bits)
+     unsigned char *buffer;
+     char code;
+     int bits;
+{
+  register int val;
+  switch (code)
+    {
+    case 's':
+      val = buffer[1];
+      break;
+
+    case 'd':			/* Destination, for register or quick.  */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 9;
+      break;
+
+    case 'x':			/* Destination, for general arg */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 6;
+      break;
+
+    case 'k':
+      val = (buffer[3] >> 4);
+      break;
+
+    case 'C':
+      val = buffer[3];
+      break;
+
+    case '1':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 12;
+      break;
+
+    case '2':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 6;
+      break;
+
+    case '3':
+    case 'j':
+      val = (buffer[2] << 8) + buffer[3];
+      break;
+
+    case '4':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 12;
+      break;
+
+    case '5':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 6;
+      break;
+
+    case '6':
+      val = (buffer[4] << 8) + buffer[5];
+      break;
+
+    case '7':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 7;
+      break;
+      
+    case '8':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 10;
+      break;
+
+    default:
+      abort ();
+    }
+
+  switch (bits)
+    {
+    case 3:
+      return val & 7;
+    case 4:
+      return val & 017;
+    case 5:
+      return val & 037;
+    case 6:
+      return val & 077;
+    case 7:
+      return val & 0177;
+    case 8:
+      return val & 0377;
+    case 12:
+      return val & 07777;
+    default:
+      abort ();
+    }
+}
+
+/* Print an indexed argument.  The base register is BASEREG (-1 for pc).
+   P points to extension word, in buffer.
+   ADDR is the nominal core address of that extension word.  */
+
+static unsigned char *
+print_indexed (basereg, p, addr, stream)
+     int basereg;
+     unsigned char *p;
+     FILE *stream;
+     CORE_ADDR addr;
+{
+  register int word;
+  static char *scales[] = {"", "*2", "*4", "*8"};
+  register int base_disp;
+  register int outer_disp;
+  char buf[40];
+
+  word = NEXTWORD (p);
+
+  /* Generate the text for the index register.
+     Where this will be output is not yet determined.  */
+  sprintf (buf, "[%s.%c%s]",
+	   reg_names[(word >> 12) & 0xf],
+	   (word & 0x800) ? 'l' : 'w',
+	   scales[(word >> 9) & 3]);
+
+  /* Handle the 68000 style of indexing.  */
+
+  if ((word & 0x100) == 0)
+    {
+      print_base (basereg,
+		  ((word & 0x80) ? word | 0xff00 : word & 0xff)
+		  + ((basereg == -1) ? addr : 0),
+		  stream);
+      fprintf (stream, "%s", buf);
+      return p;
+    }
+
+  /* Handle the generalized kind.  */
+  /* First, compute the displacement to add to the base register.  */
+
+  if (word & 0200)
+    basereg = -2;
+  if (word & 0100)
+    buf[0] = 0;
+  base_disp = 0;
+  switch ((word >> 4) & 3)
+    {
+    case 2:
+      base_disp = NEXTWORD (p);
+      break;
+    case 3:
+      base_disp = NEXTLONG (p);
+    }
+  if (basereg == -1)
+    base_disp += addr;
+
+  /* Handle single-level case (not indirect) */
+
+  if ((word & 7) == 0)
+    {
+      print_base (basereg, base_disp, stream);
+      fprintf (stream, "%s", buf);
+      return p;
+    }
+
+  /* Two level.  Compute displacement to add after indirection.  */
+
+  outer_disp = 0;
+  switch (word & 3)
+    {
+    case 2:
+      outer_disp = NEXTWORD (p);
+      break;
+    case 3:
+      outer_disp = NEXTLONG (p);
+    }
+
+  fprintf (stream, "%d(", outer_disp);
+  print_base (basereg, base_disp, stream);
+
+  /* If postindexed, print the closeparen before the index.  */
+  if (word & 4)
+    fprintf (stream, ")%s", buf);
+  /* If preindexed, print the closeparen after the index.  */
+  else
+    fprintf (stream, "%s)", buf);
+
+  return p;
+}
+
+/* Print a base register REGNO and displacement DISP, on STREAM.
+   REGNO = -1 for pc, -2 for none (suppressed).  */
+
+static void
+print_base (regno, disp, stream)
+     int regno;
+     int disp;
+     FILE *stream;
+{
+  if (regno == -2)
+    fprintf (stream, "%d", disp);
+  else if (regno == -1)
+    fprintf (stream, "0x%x", disp);
+  else
+    fprintf (stream, "%d(%s)", disp, reg_names[regno]);
+}
+
+/* This is not part of insn printing, but it is machine-specific,
+   so this is a convenient place to put it.
+
+   Convert a 68881 extended float to a double.
+   FROM is the address of the extended float.
+   Store the double in *TO.  */
+
+#ifdef mac_aux
+#ifdef __STDC__
+#define	asm16(str)	asm ("short	" str#)
+#else
+#define	asm16(str)	asm ("short	str")
+#endif
+#else
+#ifdef __STDC__
+#define	asm16(str)	asm (".word	" str#)
+#else
+#define	asm16(str)	asm (".word	str")
+#endif
+#endif
+
+convert_from_68881 (from, to)
+     char *from;
+     double *to;
+{
+#if 0
+  asm ("movl a6@(8),a0");
+  asm ("movl a6@(12),a1");
+  asm ("fmovex a0@,fp0");
+  asm ("fmoved fp0,a1@");
+#else
+  /* Hand-assemble those insns since some assemblers lose
+     and some have different syntax.  */
+  asm16 (020156);
+  asm16 (8);
+  asm16 (021156);
+  asm16 (12);
+  asm16 (0xf210);
+  asm16 (0x4800);
+  asm16 (0xf211);
+  asm16 (0x7400);
+#endif
+}
+
+/* The converse: convert the double *FROM to an extended float
+   and store where TO points.  */
+
+convert_to_68881 (from, to)
+     double *from;
+     char *to;
+{
+#if 0
+  asm ("movl a6@(8),a0");
+  asm ("movl a6@(12),a1");
+  asm ("fmoved a0@,fp0");
+  asm ("fmovex fp0,a1@");
+#else
+  /* Hand-assemble those insns since some assemblers lose.  */
+  asm16 (020156);
+  asm16 (8);
+  asm16 (021156);
+  asm16 (12);
+  asm16 (0xf210);
+  asm16 (0x5400);
+  asm16 (0xf211);
+  asm16 (0x6800);
+#endif
+}
diff --git a/gdb/main.c b/gdb/main.c
new file mode 100644
index 0000000..d6e993e
--- /dev/null
+++ b/gdb/main.c
@@ -0,0 +1,1072 @@
+/* Top level for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <sys/param.h>
+#include "defs.h"
+#include "command.h"
+#include "param.h"
+
+#ifdef SET_STACK_LIMIT_HUGE
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
+/* Version number of GDB, as a string.  */
+
+extern char *version;
+
+/* Chain containing all defined commands.  */
+
+struct cmd_list_element *cmdlist;
+
+/* Chain containing all defined info subcommands.  */
+
+struct cmd_list_element *infolist;
+
+/* stdio stream that command input is being read from.  */
+
+FILE *instream;
+
+/* Nonzero if we should refrain from using an X window.  */
+
+int inhibit_windows = 0;
+
+/* Function to call before reading a command, if nonzero.
+   The function receives two args: an input stream,
+   and a prompt string.  */
+   
+void (*window_hook) ();
+
+void free_command_lines ();
+char *read_line ();
+static void initialize_main ();
+void command_loop ();
+static void source_command ();
+void print_gdb_version ();
+
+/* gdb prints this when reading a command interactively */
+static char *prompt;
+
+/* Buffer used for reading command lines, and the size
+   allocated for it so far.  */
+
+char *line;
+int linesize;
+
+/* This is how `error' returns to command level.  */
+
+jmp_buf to_top_level;
+
+return_to_top_level ()
+{
+  quit_flag = 0;
+  immediate_quit = 0;
+  clear_breakpoint_commands ();
+  clear_momentary_breakpoints ();
+  do_cleanups (0);
+  longjmp (to_top_level, 1);
+}
+
+main (argc, argv, envp)
+     int argc;
+     char **argv;
+     char **envp;
+{
+  extern void request_quit ();
+  int count;
+  int inhibit_gdbinit = 0;
+  int quiet = 0;
+  int batch = 0;
+  register int i;
+
+  quit_flag = 0;
+  linesize = 100;
+  line = (char *) xmalloc (linesize);
+  instream = stdin;
+
+#ifdef SET_STACK_LIMIT_HUGE
+  {
+    struct rlimit rlim;
+
+    /* Set the stack limit huge so that alloca (particularly stringtab
+     * in dbxread.c) does not fail. */
+    getrlimit (RLIMIT_STACK, &rlim);
+    rlim.rlim_cur = rlim.rlim_max;
+    setrlimit (RLIMIT_STACK, &rlim);
+  }
+#endif /* SET_STACK_LIMIT_HUGE */
+
+  /* Look for flag arguments.  */
+
+  for (i = 1; i < argc; i++)
+    {
+      if (!strcmp (argv[i], "-q") || !strcmp (argv[i], "-quiet"))
+	quiet = 1;
+      else if (!strcmp (argv[i], "-nx"))
+	inhibit_gdbinit = 1;
+      else if (!strcmp (argv[i], "-nw"))
+	inhibit_windows = 1;
+      else if (!strcmp (argv[i], "-batch"))
+	batch = 1, quiet = 1;
+      else if (argv[i][0] == '-')
+	i++;
+    }
+
+  /* Run the init function of each source file */
+
+  initialize_all_files ();
+  initialize_main ();		/* But that omits this file!  Do it now */
+
+  signal (SIGINT, request_quit);
+  signal (SIGQUIT, SIG_IGN);
+
+  if (!quiet)
+    print_gdb_version ();
+
+  /* Process the command line arguments.  */
+
+  count = 0;
+  for (i = 1; i < argc; i++)
+    {
+      register char *arg = argv[i];
+      /* Args starting with - say what to do with the following arg
+	 as a filename.  */
+      if (arg[0] == '-')
+	{
+	  extern void exec_file_command (), symbol_file_command ();
+	  extern void core_file_command (), directory_command ();
+	  extern void tty_command ();
+
+	  if (!strcmp (arg, "-q") || !strcmp (arg, "-nx")
+	      || !strcmp (arg, "quiet") || !strcmp (arg, "-batch"))
+	    /* Already processed above */
+	    continue;
+
+	  if (++i == argc)
+	    fprintf (stderr, "No argument follows \"%s\".\n", arg);
+	  if (!setjmp (to_top_level))
+	    {
+	      /* -s foo: get syms from foo.  -e foo: execute foo.
+		 -se foo: do both with foo.  -c foo: use foo as core dump.  */
+	      if (!strcmp (arg, "-se"))
+		{
+		  exec_file_command (argv[i], !batch);
+		  symbol_file_command (argv[i], !batch);
+		}
+	      else if (!strcmp (arg, "-s") || !strcmp (arg, "-symbols"))
+		symbol_file_command (argv[i], !batch);
+	      else if (!strcmp (arg, "-e") || !strcmp (arg, "-exec"))
+		exec_file_command (argv[i], !batch);
+	      else if (!strcmp (arg, "-c") || !strcmp (arg, "-core"))
+		core_file_command (argv[i], !batch);
+	      /* -x foo: execute commands from foo.  */
+	      else if (!strcmp (arg, "-x") || !strcmp (arg, "-command")
+		       || !strcmp (arg, "-commands"))
+		source_command (argv[i]);
+	      /* -d foo: add directory `foo' to source-file directory
+		         search-list */
+	      else if (!strcmp (arg, "-d") || !strcmp (arg, "-dir")
+		       || !strcmp (arg, "-directory"))
+		directory_command (argv[i], 0);
+	      /* -t /def/ttyp1: use /dev/ttyp1 for inferior I/O.  */
+	      else if (!strcmp (arg, "-t") || !strcmp (arg, "-tty"))
+		tty_command (argv[i], 0);
+	      else
+		error ("Unknown command-line switch: \"%s\"\n", arg);
+	    }
+	}
+      else
+	{
+	  /* Args not thus accounted for
+	     are treated as, first, the symbol/executable file
+	     and, second, the core dump file.  */
+	  count++;
+	  if (!setjmp (to_top_level))
+	    switch (count)
+	      {
+	      case 1:
+		exec_file_command (arg, !batch);
+		symbol_file_command (arg, !batch);
+		break;
+
+	      case 2:
+		core_file_command (arg, !batch);
+		break;
+
+	      case 3:
+		fprintf (stderr, "Excess command line args ignored. (%s%s)\n",
+			 arg, (i == argc - 1) ? "" : " ...");
+	      }
+	}
+    }
+
+  /* Read init file, if it exists in home directory  */
+  if (getenv ("HOME"))
+    {
+      char *s;
+      s = (char *) xmalloc (strlen (getenv ("HOME")) + 10);
+      strcpy (s, getenv ("HOME"));
+      strcat (s, "/.gdbinit");
+      if (!inhibit_gdbinit && access (s, R_OK) == 0)
+	if (!setjmp (to_top_level))
+	  source_command (s);
+    }
+
+  /* Read init file, if it exists in current directory.  */
+  if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0)
+    if (!setjmp (to_top_level))
+      source_command (".gdbinit");
+
+  if (batch)
+    fatal ("Attempt to read commands from stdin in batch mode.");
+
+  if (!quiet)
+    printf ("Type \"help\" for a list of commands.\n");
+
+  /* The command loop.  */
+
+  while (1)
+    {
+      if (!setjmp (to_top_level))
+	command_loop ();
+      clearerr (stdin);		/* Don't get hung if C-d is typed.  */
+    }
+}
+
+/* Execute the line P as a command.
+   Pass FROM_TTY as second argument to the defining function.  */
+
+void
+execute_command (p, from_tty)
+     char *p;
+     int from_tty;
+{
+  register struct cmd_list_element *c;
+  register struct command_line *cmdlines;
+
+  free_all_values ();
+  while (*p == ' ' || *p == '\t') p++;
+  if (*p)
+    {
+      c = lookup_cmd (&p, cmdlist, "", 0);
+      if (c->function == 0)
+	error ("That is not a command, just a help topic.");
+      else if (c->class == (int) class_user)
+	{
+	  if (*p)
+	    error ("User-defined commands cannot take command-line arguments: \"%s\"",
+		   p);
+	  cmdlines = (struct command_line *) c->function;
+	  if (cmdlines == (struct command_line *) 0)
+	    /* Null command */
+	    return;
+	  while (cmdlines)
+	    {
+	      execute_command (cmdlines->line, 0);
+	      cmdlines = cmdlines->next;
+	    }
+	}
+      else
+	/* Pass null arg rather than an empty one.  */
+	(*c->function) (*p ? p : 0, from_tty);
+    }
+}
+
+static void
+do_nothing ()
+{
+}
+
+/* Read commands from `instream' and execute them
+   until end of file.  */
+void
+command_loop ()
+{
+  struct cleanup *old_chain;
+  while (!feof (instream))
+    {
+      if (instream == stdin)
+	printf ("%s", prompt);
+      fflush (stdout);
+
+      if (window_hook && instream == stdin)
+	(*window_hook) (instream, prompt);
+
+      quit_flag = 0;
+      old_chain = make_cleanup (do_nothing, 0);
+      execute_command (read_line (instream == stdin), instream == stdin);
+      /* Do any commands attached to breakpoint we stopped at.  */
+      do_breakpoint_commands ();
+      do_cleanups (old_chain);
+    }
+}
+
+static void
+stop_sig ()
+{
+  signal (SIGTSTP, SIG_DFL);
+  sigsetmask (0);
+  kill (getpid (), SIGTSTP);
+  signal (SIGTSTP, stop_sig);
+  printf ("%s", prompt);
+  fflush (stdout);
+
+  /* Forget about any previous command -- null line now will do nothing.  */
+  *line = 0;
+}
+
+/* Commands call this if they do not want to be repeated by null lines.  */
+
+void
+dont_repeat ()
+{
+  *line = 0;
+}
+
+/* Read one line from the command input stream `instream'
+   into the buffer `line' (whose current length is `linesize').
+   The buffer is made bigger as necessary.
+   Returns the address of the start of the line.  */
+
+char *
+read_line (repeat)
+     int repeat;
+{
+  register char *p = line;
+  register char *p1;
+  register int c;
+  char *nline;
+
+  /* Control-C quits instantly if typed while in this loop
+     since it should not wait until the user types a newline.  */
+  immediate_quit++;
+  signal (SIGTSTP, stop_sig);
+
+  while (1)
+    {
+      c = fgetc (instream);
+      if (c == -1 || c == '\n')
+	break;
+      if (p - line == linesize - 1)
+	{
+	  linesize *= 2;
+	  nline = (char *) xrealloc (line, linesize);
+	  p += nline - line;
+	  line = nline;
+	}
+      *p++ = c;
+    }
+
+  signal (SIGTSTP, SIG_DFL);
+  immediate_quit--;
+
+  /* If we just got an empty line, and that is supposed
+     to repeat the previous command, leave the last input unchanged.  */
+  if (p == line && repeat)
+    return line;
+
+  /* If line is a comment, clear it out.  */
+  p1 = line;
+  while ((c = *p1) == ' ' || c == '\t') p1++;
+  if (c == '#')
+    p = line;
+
+  *p = 0;
+
+  return line;
+}
+
+/* Read lines from the input stream
+   and accumulate them in a chain of struct command_line's
+   which is then returned.  */
+
+struct command_line *
+read_command_lines ()
+{
+  struct command_line *first = 0;
+  register struct command_line *next, *tail = 0;
+  register char *p, *p1;
+  struct cleanup *old_chain = 0;
+
+  while (1)
+    {
+      dont_repeat ();
+      p = read_line (1);
+      /* Remove leading and trailing blanks.  */
+      while (*p == ' ' || *p == '\t') p++;
+      p1 = p + strlen (p);
+      while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) p1--;
+
+      /* Is this "end"?  */
+      if (p1 - p == 3 && !strncmp (p, "end", 3))
+	break;
+
+      /* No => add this line to the chain of command lines.  */
+      next = (struct command_line *) xmalloc (sizeof (struct command_line));
+      next->line = savestring (p, p1 - p);
+      next->next = 0;
+      if (tail)
+	{
+	  tail->next = next;
+	}
+      else
+	{
+	  /* We just read the first line.
+	     From now on, arrange to throw away the lines we have
+	     if we quit or get an error while inside this function.  */
+	  first = next;
+	  old_chain = make_cleanup (free_command_lines, &first);
+	}
+      tail = next;
+    }
+
+  dont_repeat ();
+
+  /* Now we are about to return the chain to our caller,
+     so freeing it becomes his responsibility.  */
+  if (first)
+    discard_cleanups (old_chain);
+  return first;
+}
+
+/* Free a chain of struct command_line's.  */
+
+void
+free_command_lines (lptr)
+      struct command_line **lptr;
+{
+  register struct command_line *l = *lptr;
+  register struct command_line *next;
+
+  while (l)
+    {
+      next = l->next;
+      free (l->line);
+      free (l);
+      l = next;
+    }
+}
+
+/* Add an element to the list of info subcommands.  */
+
+void
+add_info (name, fun, doc)
+     char *name;
+     void (*fun) ();
+     char *doc;
+{
+  add_cmd (name, 0, fun, doc, &infolist);
+}
+
+/* Add an alias to the list of info subcommands.  */
+
+void
+add_info_alias (name, oldname, abbrev_flag)
+     char *name;
+     char *oldname;
+     int abbrev_flag;
+{
+  add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
+}
+
+/* The "info" command is defined as a prefix, with allow_unknown = 0.
+   Therefore, its own definition is called only for "info" with no args.  */
+
+static void
+info_command ()
+{
+  printf ("\"info\" must be followed by the name of an info command.\n");
+  help_cmd (0, infolist, "info ", -1, stdout);
+}
+
+/* Add an element to the list of commands.  */
+
+void
+add_com (name, class, fun, doc)
+     char *name;
+     int class;
+     void (*fun) ();
+     char *doc;
+{
+  add_cmd (name, class, fun, doc, &cmdlist);
+}
+
+/* Add an alias or abbreviation command to the list of commands.  */
+
+void
+add_com_alias (name, oldname, class, abbrev_flag)
+     char *name;
+     char *oldname;
+     int class;
+     int abbrev_flag;
+{
+  add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
+}
+
+void
+error_no_arg (why)
+     char *why;
+{
+  error ("Argument required (%s).", why);
+}
+
+static void
+help_command (command, from_tty)
+     char *command;
+     int from_tty; /* Ignored */
+{
+  help_cmd (command, cmdlist, "", -2, stdout);
+}
+
+static void
+validate_comname (comname)
+     char *comname;
+{
+  register char *p;
+
+  if (comname == 0)
+    error_no_arg ("name of command to define");
+
+  p = comname;
+  while (*p)
+    {
+      if (!(*p >= 'A' && *p <= 'Z')
+	  && !(*p >= 'a' && *p <= 'z')
+	  && !(*p >= '1' && *p <= '9')
+	  && *p != '-')
+	error ("Junk in argument list: \"%s\"", p);
+      p++;
+    }
+}
+
+static void
+define_command (comname, from_tty)
+     char *comname;
+     int from_tty;
+{
+  register struct command_line *cmds;
+  register struct cmd_list_element *c;
+  char *tem = comname;
+
+  validate_comname (comname);
+
+  c = lookup_cmd (&tem, cmdlist, "", -1);
+  if (c)
+    {
+      if (c->class == (int) class_user || c->class == (int) class_alias)
+	tem = "Redefine command \"%s\"? ";
+      else
+	tem = "Really redefine built-in command \"%s\"? ";
+      if (!query (tem, comname))
+	error ("Command \"%s\" not redefined.", comname);
+    }
+
+  if (from_tty)
+    printf ("Type commands for definition of \"%s\".\n\
+End with a line saying just \"end\".\n", comname);
+
+  comname = savestring (comname, strlen (comname));
+
+  cmds = read_command_lines ();
+
+  if (c && c->class == (int) class_user)
+    free_command_lines (&c->function);
+
+  add_com (comname, class_user, cmds,
+	   (c && c->class == (int) class_user)
+	   ? c->doc : savestring ("User-defined.", 13));
+}
+
+static void
+document_command (comname, from_tty)
+     char *comname;
+     int from_tty;
+{
+  struct command_line *doclines;
+  register struct cmd_list_element *c;
+  char *tem = comname;
+
+  validate_comname (comname);
+
+  c = lookup_cmd (&tem, cmdlist, "", 0);
+
+  if (c->class != (int) class_user)
+    error ("Command \"%s\" is built-in.", comname);
+
+  if (from_tty)
+    printf ("Type documentation for \"%s\".\n\
+End with a line saying just \"end\".\n", comname);
+
+  doclines = read_command_lines ();
+
+  if (c->doc) free (c->doc);
+
+  {
+    register struct command_line *cl1;
+    register int len = 0;
+
+    for (cl1 = doclines; cl1; cl1 = cl1->next)
+      len += strlen (cl1->line) + 1;
+
+    c->doc = (char *) xmalloc (len + 1);
+    *c->doc = 0;
+
+    for (cl1 = doclines; cl1; cl1 = cl1->next)
+      {
+	strcat (c->doc, cl1->line);
+	if (cl1->next)
+	  strcat (c->doc, "\n");
+      }
+  }
+
+  free_command_lines (&doclines);
+}
+
+static void
+copying_info ()
+{
+  immediate_quit++;
+  printf ("		    GDB GENERAL PUBLIC LICENSE\n\
+\n\
+ Copyright (C) 1986 Richard M. Stallman\n\
+ Everyone is permitted to copy and distribute verbatim copies\n\
+ of this license, but changing it is not allowed.\n\
+\n\
+  The license agreements of most software companies keep you at the\n\
+mercy of those companies.  By contrast, our general public license is\n\
+intended to give everyone the right to share GDB.  To make sure that\n\
+you get the rights we want you to have, we need to make restrictions\n\
+that forbid anyone to deny you these rights or to ask you to surrender\n\
+the rights.  Hence this license agreement.\n\
+\n\
+  Specifically, we want to make sure that you have the right to give\n\
+away copies of GDB, that you receive source code or else can get it\n\
+if you want it, that you can change GDB or use pieces of it in new\n\
+free programs, and that you know you can do these things.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  To make sure that everyone has such rights, we have to forbid you to\n\
+deprive anyone else of these rights.  For example, if you distribute\n\
+copies of GDB, you must give the recipients all the rights that you\n\
+have.  You must make sure that they, too, receive or can get the\n\
+source code.  And you must tell them their rights.\n\
+\n\
+  Also, for our own protection, we must make certain that everyone\n\
+finds out that there is no warranty for GDB.  If GDB is modified by\n\
+someone else and passed on, we want its recipients to know that what\n\
+they have is not what we distributed, so that any problems introduced\n\
+by others will not reflect on our reputation.\n\
+\n\
+  Therefore we (Richard Stallman and the Free Software Foundation,\n\
+Inc.) make the following terms which say what you must do to be\n\
+allowed to distribute or change GDB.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+			COPYING POLICIES\n\
+\n\
+  1. You may copy and distribute verbatim copies of GDB source code as\n\
+you receive it, in any medium, provided that you conspicuously and\n\
+appropriately publish on each copy a valid copyright notice \"Copyright\n\
+\(C) 1987 Free Software Foundation, Inc.\" (or with the year updated if\n\
+that is appropriate); keep intact the notices on all files that refer\n\
+to this License Agreement and to the absence of any warranty; and give\n\
+any other recipients of the GDB program a copy of this License\n\
+Agreement along with the program.  You may charge a distribution fee\n\
+for the physical act of transferring a copy.\n\
+\n\
+  2. You may modify your copy or copies of GDB or any portion of it,\n\
+and copy and distribute such modifications under the terms of\n\
+Paragraph 1 above, provided that you also do the following:\n\
+\n\
+    a) cause the modified files to carry prominent notices stating\n\
+    that you changed the files and the date of any change; and\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+    b) cause the whole of any work that you distribute or publish,\n\
+    that in whole or in part contains or is a derivative of GDB\n\
+    or any part thereof, to be licensed to all third parties on terms\n\
+    identical to those contained in this License Agreement (except that\n\
+    you may choose to grant more extensive warranty protection to third\n\
+    parties, at your option).\n\
+\n");
+  printf ("\
+    c) if the modified program serves as a debugger, cause it\n\
+    when started running in the simplest and usual way, to print\n\
+    an announcement including a valid copyright notice\n\
+    \"Copyright (C) 1987 Free Software Foundation, Inc.\" (or with\n\
+    the year updated if appropriate), saying that there\n\
+    is no warranty (or else, saying that you provide\n\
+    a warranty) and that users may redistribute the program under\n\
+    these conditions, and telling the user how to view a copy of\n\
+    this License Agreement.\n\
+\n\
+    d) You may charge a distribution fee for the physical act of\n\
+    transferring a copy, and you may at your option offer warranty\n\
+    protection in exchange for a fee.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  3. You may copy and distribute GDB or any portion of it in\n\
+compiled, executable or object code form under the terms of Paragraphs\n\
+1 and 2 above provided that you do the following:\n\
+\n\
+    a) cause each such copy to be accompanied by the\n\
+    corresponding machine-readable source code, which must\n\
+    be distributed under the terms of Paragraphs 1 and 2 above; or,\n\
+\n\
+    b) cause each such copy to be accompanied by a\n\
+    written offer, with no time limit, to give any third party\n\
+    free (except for a nominal shipping charge) a machine readable\n\
+    copy of the corresponding source code, to be distributed\n\
+    under the terms of Paragraphs 1 and 2 above; or,\n\n");
+
+  printf ("\
+    c) in the case of a recipient of GDB in compiled, executable\n\
+    or object code form (without the corresponding source code) you\n\
+    shall cause copies you distribute to be accompanied by a copy\n\
+    of the written offer of source code which you received along\n\
+    with the copy you received.\n\
+--Type Return to print more--");
+  fflush (stdout);
+  read_line ();
+
+  printf ("\
+  4. You may not copy, sublicense, distribute or transfer GDB\n\
+except as expressly provided under this License Agreement.  Any attempt\n\
+otherwise to copy, sublicense, distribute or transfer GDB is void and\n\
+your rights to use the program under this License agreement shall be\n\
+automatically terminated.  However, parties who have received computer\n\
+software programs from you with this License Agreement will not have\n\
+their licenses terminated so long as such parties remain in full compliance.\n\
+\n\
+  5. If you wish to incorporate parts of GDB into other free\n\
+programs whose distribution conditions are different, write to the Free\n\
+Software Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet\n\
+worked out a simple rule that can be stated here, but we will often permit\n\
+this.  We will be guided by the two goals of preserving the free status of\n\
+all derivatives of our free software and of promoting the sharing and reuse\n\
+of software.\n\
+\n\
+In other words, go ahead and share GDB, but don't try to stop\n\
+anyone else from sharing it farther.  Help stamp out software hoarding!\n\
+");
+  immediate_quit--;
+}
+
+static void
+warranty_info ()
+{
+  immediate_quit++;
+  printf ("			 NO WARRANTY\n\
+\n\
+  BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO\n\
+WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT\n\
+WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,\n\
+RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB \"AS IS\" WITHOUT\n\
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT\n\
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\
+A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND\n\
+PERFORMANCE OF GDB IS WITH YOU.  SHOULD GDB PROVE DEFECTIVE, YOU\n\
+ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n");
+
+  printf ("\
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.\n\
+STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY\n\
+WHO MAY MODIFY AND REDISTRIBUTE GDB, BE LIABLE TO\n\
+YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER\n\
+SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR\n\
+INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA\n\
+BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A\n\
+FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN\n\
+IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR\n\
+ANY CLAIM BY ANY OTHER PARTY.\n");
+  immediate_quit--;
+}
+
+static void
+print_gdb_version ()
+{
+  printf ("GDB %s, Copyright (C) 1987 Free Software Foundation, Inc.\n\
+There is ABSOLUTELY NO WARRANTY for GDB; type \"info warranty\" for details.\n\
+GDB is free software and you are welcome to distribute copies of it\n\
+ under certain conditions; type \"info copying\" to see the conditions.\n",
+	  version);
+}
+
+static void
+version_info ()
+{
+  immediate_quit++;
+  print_gdb_version ();
+  immediate_quit--;
+}
+
+static void
+set_prompt_command (text)
+     char *text;
+{
+  char *p, *q;
+  register int c;
+  char *new;
+
+  if (text == 0)
+    error_no_arg ("string to which to set prompt");
+
+  new = (char *) xmalloc (strlen (text) + 2);
+  p = text; q = new;
+  while (c = *p++)
+    {
+      if (c == '\\')
+	{
+	  /* \ at end of argument is used after spaces
+	     so they won't be lost.  */
+	  if (*p == 0)
+	    break;
+	  c = parse_escape (&p);
+	  if (c == 0)
+	    break; /* C loses */
+	  else if (c > 0)
+	    *q++ = c;
+	}
+      else
+	*q++ = c;
+    }
+  if (*(p - 1) != '\\')
+    *q++ = ' ';
+  *q++ = '\0';
+  new = (char *) xrealloc (new, q - new);
+  free (prompt);
+  prompt = new;
+}
+
+static void
+quit_command ()
+{
+  if (have_inferior_p ())
+    {
+      if (query ("The program is running.  Quit anyway? "))
+	{
+	  /* Prevent any warning message from reopen_exec_file, in case
+	     we have a core file that's inconsistent with the exec file.  */
+	  exec_file_command (0, 0);
+	  kill_inferior ();
+	}
+      else
+	error ("Not confirmed.");
+    }
+  exit (0);
+}
+
+int
+input_from_terminal_p ()
+{
+  return instream == stdin;
+}
+
+static void
+pwd_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  char buf[MAXPATHLEN];
+  if (arg) error ("The \"pwd\" command does not take an argument: %s", arg);
+  printf ("Working directory %s.\n", getwd (buf));
+}
+
+static void
+cd_command (dir, from_tty)
+     char *dir;
+     int from_tty;
+{
+  if (dir == 0)
+    error_no_arg ("new working directory");
+
+  if (chdir (dir) < 0)
+    perror_with_name (dir);
+  if (from_tty)
+    pwd_command ((char *) 0, 1);
+}
+
+
+/* Clean up on error during a "source" command.
+   Close the file opened by the command
+   and restore the previous input stream.  */
+
+static void
+source_cleanup (stream)
+     FILE *stream;
+{
+  fclose (instream);
+  instream = stream;
+}
+
+static void
+source_command (file)
+     char *file;
+{
+  FILE *stream;
+  struct cleanup *cleanups;
+
+  if (file == 0)
+    error_no_arg ("file to read commands from");
+
+  stream = fopen (file, "r");
+  if (stream == 0)
+    perror_with_name (file);
+
+  cleanups = make_cleanup (source_cleanup, instream);
+
+  instream = stream;
+
+  command_loop ();
+
+  do_cleanups (cleanups);
+}
+
+static void
+echo_command (text)
+     char *text;
+{
+  char *p = text;
+  register int c;
+
+  if (text)
+    while (c = *p++)
+      {
+	if (c == '\\')
+	  {
+	    /* \ at end of argument is used after spaces
+	       so they won't be lost.  */
+	    if (*p == 0)
+	      return;
+
+	    c = parse_escape (&p);
+	    if (c >= 0)
+	      fputc (c, stdout);
+	  }
+	else
+	  fputc (c, stdout);
+      }
+}
+
+static void
+dump_me_command ()
+{
+  if (query ("Should GDB dump core? "))
+    {
+      signal (SIGQUIT, SIG_DFL);
+      kill (getpid (), SIGQUIT);
+    }
+}
+
+
+static void
+initialize_main ()
+{
+  prompt = savestring ("(gdb) ", 6);
+
+  /* Define the classes of commands.
+     They will appear in the help list in the reverse of this order.  */
+
+  add_cmd ("obscure", class_obscure, 0, "Obscure features.", &cmdlist);
+  add_cmd ("alias", class_alias, 0, "Aliases of other commands.", &cmdlist);
+  add_cmd ("user", class_user, 0, "User-defined commands.\n\
+The commands in this class are those defined by the user.\n\
+Use the \"define\" command to define a command.", &cmdlist);
+  add_cmd ("support", class_support, 0, "Support facilities.", &cmdlist);
+  add_cmd ("status", class_info, 0, "Status inquiries.", &cmdlist);
+  add_cmd ("files", class_files, 0, "Specifying and examining files.", &cmdlist);
+  add_cmd ("breakpoints", class_breakpoint, 0, "Making program stop at certain points.", &cmdlist);
+  add_cmd ("data", class_vars, 0, "Examining data.", &cmdlist);
+  add_cmd ("stack", class_stack, 0, "Examining the stack.\n\
+The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
+counting from zero for the innermost (currently executing) frame.\n\n\
+At any time gdb identifies one frame as the \"selected\" frame.\n\
+Variable lookups are done with respect to the selected frame.\n\
+When the program being debugged stops, gdb selects the innermost frame.\n\
+The commands below can be used to select other frames by number or address.",
+	   &cmdlist);
+  add_cmd ("running", class_run, 0, "Running the program.", &cmdlist);
+
+  add_com ("pwd", class_files, pwd_command,
+	   "Print working directory.  This is used for your program as well.");
+  add_com ("cd", class_files, cd_command,
+	   "Set working directory to DIR for debugger and program being debugged.\n\
+The change does not take effect for the program being debugged\n\
+until the next time it is started.");
+
+  add_com ("set-prompt", class_support, set_prompt_command,
+	   "Change gdb's prompt from the default of \"(gdb)\"");
+  add_com ("echo", class_support, echo_command,
+	   "Print a constant string.  Give string as argument.\n\
+C escape sequences may be used in the argument.\n\
+No newline is added at the end of the argument;\n\
+use \"\\n\" if you want a newline to be printed.\n\
+Since leading and trailing whitespace are ignored in command arguments,\n\
+if you want to print some you must use \"\\\" before leading whitespace\n\
+to be printed or after trailing whitespace.");
+  add_com ("document", class_support, document_command,
+	   "Document a user-defined command.\n\
+Give command name as argument.  Give documentation on following lines.\n\
+End with a line of just \"end\".");
+  add_com ("define", class_support, define_command,
+	   "Define a new command name.  Command name is argument.\n\
+Definition appears on following lines, one command per line.\n\
+End with a line of just \"end\".\n\
+Use the \"document\" command to give documentation for the new command.\n\
+Commands defined in this way do not take arguments.");
+
+  add_com ("source", class_support, source_command,
+	   "Read commands from a file named FILE.\n\
+Note that the file \".gdbinit\" is read automatically in this way\n\
+when gdb is started.");
+  add_com ("quit", class_support, quit_command, "Exit gdb.");
+  add_com ("help", class_support, help_command, "Print list of commands.");
+  add_com_alias ("q", "quit", class_support, 1);
+  add_com_alias ("h", "help", class_support, 1);
+
+  add_com ("dump-me", class_obscure, dump_me_command,
+	   "Get fatal error; make debugger dump its core.");
+
+  add_prefix_cmd ("info", class_info, info_command,
+		  "Generic command for printing status.",
+		  &infolist, "info ", 0, &cmdlist);
+  add_com_alias ("i", "info", class_info, 1);
+
+  add_info ("copying", copying_info, "Conditions for redistributing copies of GDB.");
+  add_info ("warranty", warranty_info, "Various kinds of warranty you do not have.");
+  add_info ("version", version_info, "Report what version of GDB this is.");
+}
diff --git a/gdb/ns32k-opcode.h b/gdb/ns32k-opcode.h
new file mode 100644
index 0000000..2d5ff30
--- /dev/null
+++ b/gdb/ns32k-opcode.h
@@ -0,0 +1,307 @@
+/* ns32k-opcode.h */
+
+#ifndef ns32k_opcodeT
+#define ns32k_opcodeT int
+#endif /* no ns32k_opcodeT */
+
+struct not_wot			/* ns32k opcode table: wot to do with this */
+				/* particular opcode */
+{
+  int obits;		/* number of opcode bits */
+  int ibits;		/* number of instruction bits */
+  ns32k_opcodeT	code;	/* op-code (may be > 8 bits!) */
+  char *args;		/* how to compile said opcode */
+};
+
+struct not			/* ns32k opcode text */
+{
+  char *            name;	/* opcode name: lowercase string  [key]  */
+  struct not_wot    detail;	/* rest of opcode table          [datum] */
+};
+
+/* F : 32 bit float
+ * L : 64 bit float
+ * B : byte
+ * W : word
+ * D : double-word
+ * Q : quad-word
+ * d : displacement
+ * q : quick
+ * i : immediate (8 bits)
+ * r : register number (3 bits)
+ * p : displacement - pc relative addressing
+*/
+static struct not
+notstrs[] =
+{
+  { "absf",	14,24,	0x35be,	"1F2F" },
+  { "absl",	14,24,	0x34be,	"1L2L" },
+  { "absb",	14,24,	0x304e, "1B2B" },
+  { "absw",	14,24,	0x314e, "1W2W" },
+  { "absd",	14,24,	0x334e, "1D2D" },
+  { "acbb",	 7,16,	0x4c,	"2B1q3p" },
+  { "addf",	14,24,	0x01be,	"1F2F" },
+  { "addl",	14,24,	0x00be, "1L2L" },
+  { "addb",	 6,16,	0x00,	"1B2B" },
+  { "addw",	 6,16,	0x01,	"1W2W" },
+  { "addd",	 6,16,	0x03,	"1D2D" },
+  { "addcb",	 6,16,	0x10,	"1B2B" },
+  { "addcw",	 6,16,	0x11,	"1W2W" },
+  { "addcd",	 6,16,	0x13,	"1D2D" },
+  { "addpb",	14,24,	0x3c4e,	"1B2B" },
+  { "addpw",	14,24,	0x3d4e,	"1W2W" },
+  { "addpd",	14,24,	0x3f4e,	"1D2D" },
+  { "addqb",	 7,16,	0x0c,	"2B1q" },
+  { "addqw",	 7,16,	0x0d,	"2W1q" },
+  { "addqd",	 7,16,	0x0f,	"2D1q" },
+  { "addr",	 6,16,	0x27,	"1D2D" },
+  { "adjspb",	11,16,	0x057c,	"1B" },
+  { "adjspw",	11,16,	0x057d,	"1W" },
+  { "adjspd",	11,16,	0x057f,	"1D" },
+  { "andb",	 6,16,	0x28,	"1B2B" },
+  { "andw",	 6,16,	0x29,	"1W2W" },
+  { "andd",	 6,16,	0x2b,	"1D2D" },
+  { "ashb",	14,24,	0x044e,	"1B2B" },
+  { "ashw",	14,24,	0x054e,	"1B2W" },
+  { "ashd",	14,24,	0x074e,	"1B2D" },
+  { "beq",	 8,8,	0x0a,	"1p" },
+  { "bne",	 8,8,	0x1a,	"1p" },
+  { "bcs",	 8,8,	0x2a,	"1p" },
+  { "bcc",	 8,8,	0x3a,	"1p" },
+  { "bhi",	 8,8,	0x4a,	"1p" },
+  { "bls",	 8,8,	0x5a,	"1p" },
+  { "bgt",	 8,8,	0x6a,	"1p" },
+  { "ble",	 8,8,	0x7a,	"1p" },
+  { "bfs",	 8,8,	0x8a,	"1p" },
+  { "bfc",	 8,8,	0x9a,	"1p" },
+  { "blo",	 8,8,	0xaa,	"1p" },
+  { "bhs",	 8,8,	0xba,	"1p" },
+  { "blt",	 8,8,	0xca,	"1p" },
+  { "bge",	 8,8,	0xda,	"1p" },
+  { "bicb",	 6,16,	0x08,	"1B2B" },
+  { "bicw",	 6,16,	0x09,	"1W2W" },
+  { "bicd",	 6,16,	0x0b,	"1D2D" },
+  { "bicpsrb",	11,16,	0x17c,	"1B" },
+  { "bicpsrw",	11,16,	0x17d,	"1W" },
+  { "bispsrb",	11,16,	0x37c,	"1B" },
+  { "bispsrw",	11,16,	0x37d,	"1W" },
+  { "bpt",	 8,8,	0xf2,	"" },
+  { "br",	 8,8,	0xea,	"1p" },
+  { "bsr",	 8,8,	0x02,	"1p" },
+  { "caseb",	11,16,	0x77c,	"1B" },
+  { "casew",	11,16,	0x77d,	"1W" },
+  { "cased",	11,16,	0x77f,	"1D" },
+  { "cbitb",	14,24,	0x084e,	"1B2D" },
+  { "cbitw",	14,24,	0x094e,	"1W2D" },
+  { "cbitd",	14,24,	0x0b4e,	"1D2D" },
+  { "cbitib",	14,24,	0x0c4e,	"1B2D" },
+  { "cbitiw",	14,24,	0x0d4e,	"1W2D" },
+  { "cbitid",	14,24,	0x0f4e,	"1D2D" },
+  { "checkb",	11,24,	0x0ee,	"2A3B1r" },
+  { "checkw",	11,24,	0x1ee,	"2A3B1r" },
+  { "checkd",	11,24,	0x3ee,	"2A3D1r" },
+  { "cmpf",	14,24,	0x09be,	"1F2F" },
+  { "cmpl",	14,24,	0x08be,	"1L2L" },
+  { "cmpb",	 6,16,	0x04,	"1B2B" },
+  { "cmpw",	 6,16,	0x05,	"1W2W" },
+  { "cmpd",	 6,16,	0x07,	"1D2D" },
+  { "cmpmb",	14,24,	0x04ce,	"1D2D3d" },
+  { "cmpmw",	14,24,	0x05ce,	"1D2D3d" },
+  { "cmpmd",	14,24,	0x07ce,	"1D2D3d" },
+  { "cmpqb",	 7,16,	0x1c,	"2B1q" },
+  { "cmpqw",	 7,16,	0x1d,	"2W1q" },
+  { "cmpqd",	 7,16,	0x1f,	"2D1q" },
+  { "cmpsb",	16,16,	0x040e,	"1i" },
+  { "cmpsw",	16,16,	0x050e,	"1i" },
+  { "cmpsd",	16,16,	0x070e,	"1i" },
+  { "cmpst",	16,16,	0x840e,	"1i" },
+  { "comb",	14,24,	0x344e,	"1B2B" },
+  { "comw",	14,24,	0x354e,	"1W2W" },
+  { "comd",	14,24,	0x374e,	"1D2D" },
+  { "cvtp",	11,24,	0x036e,	"2D3D1r" },
+  { "cxp",	 8,8,	0x22,	"1p" },
+  { "cxpd",	11,16,	0x07f,	"1D" },
+  { "deib",	14,24,	0x2cce,	"1B2W" },
+  { "deiw",	14,24,	0x2cce,	"1W2D" },
+  { "deid",	14,24,	0x2cce,	"1D2Q" },
+  { "dia",	 8,8,	0xc2,	"" },
+  { "divf",	14,24,	0x21be,	"1F2F" },
+  { "divl",	14,24,	0x20be,	"1L2L" },
+  { "divb",	14,24,	0x3cce,	"1B2B" },
+  { "divw",	14,24,	0x3dce,	"1W2W" },
+  { "divd",	14,24,	0x3fce,	"1D2D" },
+  { "enter",	 8,8,	0x82,	"1i2d" },
+  { "exit",	 8,8,	0x92,	"1i" },
+  { "extb",	11,24,	0x02e,	"2D3B1r4d" },
+  { "extw",	11,24,	0x12e,	"2D3W1r4d" },
+  { "extd",	11,24,	0x32e,	"2D3D1r4d" },
+  { "extsb",	14,24,	0x0cce,	"1D2B3i" },
+  { "extsw",	14,24,	0x0dce,	"1D2W3i" },
+  { "extsd",	14,24,	0x0fce,	"1D2D3i" },
+  { "ffsb",	14,24,	0x046e,	"1B2B" },
+  { "ffsw",	14,24,	0x056e,	"1W2B" },
+  { "ffsd",	14,24,	0x076e,	"1D2B" },
+  { "flag",	 8,8,	0xd2,	"" },
+  { "floorfb",	14,24,	0x3c3e,	"1F2B" },
+  { "floorfw",	14,24,	0x3d3e,	"1F2W" },
+  { "floorfd",	14,24,	0x3f3e,	"1F2D" },
+  { "floorlb",	14,24,	0x383e,	"1L2B" },
+  { "floorlw",	14,24,	0x393e,	"1L2W" },
+  { "floorld",	14,24,	0x3b3e,	"1L2D" },
+  { "ibitb",	14,24,	0x384e,	"1B2D" },
+  { "ibitw",	14,24,	0x394e,	"1W2D" },
+  { "ibitd",	14,24,	0x3b4e,	"1D2D" },
+  { "indexb",	11,24,	0x42e,	"2B3B1r" },
+  { "indexw",	11,24,	0x52e,	"2W3W1r" },
+  { "indexd",	11,24,	0x72e,	"2D3D1r" },
+  { "insb",	11,24,	0x0ae,	"2B3B1r4d" },
+  { "insw",	11,24,	0x1ae,	"2W3W1r4d" },
+  { "insd",	11,24,	0x3ae,	"2D3D1r4d" },
+  { "inssb",	14,24,	0x08ce,	"1B2D3i" },
+  { "inssw",	14,24,	0x09ce,	"1W2D3i" },
+  { "inssd",	14,24,	0x0bce,	"1D2D3i" },
+  { "jsr",	11,16,	0x67f,	"1A" },
+  { "jump",	11,16,	0x27f,	"1A" },
+  { "lfsr",	19,24,	0x00f3e,"1D" },
+  { "lmr",	15,24,	0x0b1e,	"2D1q" },
+  { "lprb",	 7,16,	0x6c,	"2B1q" },
+  { "lprw",	 7,16,	0x6d,	"2W1q" },
+  { "lprd",	 7,16,	0x6f,	"2D1q" },
+  { "lshb",	14,24,	0x144e,	"1B2B" },
+  { "lshw",	14,24,	0x154e,	"1B2W" },
+  { "lshd",	14,24,	0x174e,	"1B2D" },
+  { "meib",	14,24,	0x24ce,	"1B2W" },
+  { "meiw",	14,24,	0x25ce,	"1W2D" },
+  { "meid",	14,24,	0x27ce,	"1D2Q" },
+  { "modb",	14,24,	0x38ce,	"1B2B" },
+  { "modw",	14,24,	0x39ce,	"1W2W" },
+  { "modd",	14,24,	0x3bce,	"1D2D" },
+  { "movf",	14,24,	0x05be,	"1F2F" },
+  { "movl",	14,24,	0x04be,	"1L2L" },
+  { "movb",	 6,16,	0x14,	"1B2B" },
+  { "movw",	 6,16,	0x15,	"1W2W" },
+  { "movd",	 6,16,	0x17,	"1D2D" },
+  { "movbf",	14,24,	0x043e,	"1B2F" },
+  { "movwf",	14,24,	0x053e,	"1W2F" },
+  { "movdf",	14,24,	0x073e,	"1D2F" },
+  { "movbl",	14,24,	0x003e,	"1B2L" },
+  { "movwl",	14,24,	0x013e,	"1W2L" },
+  { "movdl",	14,24,	0x033e,	"1D2L" },
+  { "movfl",	14,24,	0x1b3e,	"1F2L" },
+  { "movlf",	14,24,	0x163e,	"1L2F" },
+  { "movmb",	14,24,	0x00ce,	"1D2D3d" },
+  { "movmw",	14,24,	0x00de,	"1D2D3d" },
+  { "movmd",	14,24,	0x00fe,	"1D2D3d" },
+  { "movqb",	 7,16,	0x5c,	"2B1q" },
+  { "movqw",	 7,16,	0x5d,	"2B1q" },
+  { "movqd",	 7,16,	0x5f,	"2B1q" },
+  { "movsb",	16,16,	0x000e,	"1i" },
+  { "movsw",	16,16,	0x010e,	"1i" },
+  { "movsd",	16,16,	0x030e,	"1i" },
+  { "movst",	16,16,	0x800e,	"1i" },
+  { "movsub",	14,24,	0x0cae,	"1A1A" },
+  { "movsuw",	14,24,	0x0dae,	"1A1A" },
+  { "movsud",	14,24,	0x0fae,	"1A1A" },
+  { "movusb",	14,24,	0x1cae,	"1A1A" },
+  { "movusw",	14,24,	0x1dae,	"1A1A" },
+  { "movusd",	14,24,	0x1fae,	"1A1A" },
+  { "movxbd",	14,24,	0x1cce,	"1B2D" },
+  { "movxwd",	14,24,	0x1dce,	"1W2D" },
+  { "movxbw",	14,24,	0x10ce,	"1B2W" },
+  { "movzbd",	14,24,	0x18ce,	"1B2D" },
+  { "movzwd",	14,24,	0x19ce,	"1W2D" },
+  { "movzbw",	14,24,	0x14ce,	"1B2W" },
+  { "mulf",	14,24,	0x31be,	"1F2F" },
+  { "mull",	14,24,	0x30be,	"1L2L" },
+  { "mulb",	14,24,	0x20ce, "1B2B" },
+  { "mulw",	14,24,	0x21ce, "1W2W" },
+  { "muld",	14,24,	0x23ce, "1D2D" },
+  { "negf",	14,24,	0x15be, "1F2F" },
+  { "negl",	14,24,	0x14be, "1L2L" },
+  { "negb",	14,24,	0x204e, "1B2B" },
+  { "negw",	14,24,	0x214e, "1W2W" },
+  { "negd",	14,24,	0x234e, "1D2D" },
+  { "nop",	 8,8,	0xa2,	"" },
+  { "notb",	14,24,	0x244e, "1B2B" },
+  { "notw",	14,24,	0x254e, "1W2W" },
+  { "notd",	14,24,	0x274e, "1D2D" },
+  { "orb",	 6,16,	0x18,	"1B1B" },
+  { "orw",	 6,16,	0x19,	"1W1W" },
+  { "ord",	 6,16,	0x1b,	"1D1D" },
+  { "quob",	14,24,	0x30ce,	"1B2B" },
+  { "quow",	14,24,	0x31ce,	"1W2W" },
+  { "quod",	14,24,	0x33ce,	"1D2D" },
+  { "rdval",	19,24,	0x0031e,"1A" },
+  { "remb",	14,24,	0x34ce,	"1B2B" },
+  { "remw",	14,24,	0x35ce,	"1W2W" },
+  { "remd",	14,24,	0x37ce,	"1D2D" },
+  { "restore",	 8,8,	0x72,	"1i" },
+  { "ret",	 8,8,	0x12,	"1d" },
+  { "reti",	 8,8,	0x52,	"" },
+  { "rett",	 8,8,	0x42,	"" },
+  { "rotb",	14,24,	0x004e,	"1B2B" },
+  { "rotw",	14,24,	0x014e,	"1B2W" },
+  { "rotd",	14,24,	0x034e,	"1B2D" },
+  { "roundfb",	14,24,	0x243e,	"1F2B" },
+  { "roundfw",	14,24,	0x253e,	"1F2W" },
+  { "roundfd",	14,24,	0x273e,	"1F2D" },
+  { "roundlb",	14,24,	0x203e,	"1L2B" },
+  { "roundlw",	14,24,	0x213e,	"1L2W" },
+  { "roundld",	14,24,	0x233e,	"1L2D" },
+  { "rxp",	 8,8,	0x32,	"1d" },
+  { "sCONDb",	 7,16,	0x3c,	"2B1q" },
+  { "sCONDw",	 7,16,	0x3d,	"2D1q" },
+  { "sCONDd",	 7,16,	0x3f,	"2D1q" },
+  { "save",	 8,8,	0x62,	"1i" },
+  { "sbitb",	14,24,	0x184e,	"1B2A" },
+  { "sbitw",	14,24,	0x194e,	"1W2A" },
+  { "sbitd",	14,24,	0x1b4e,	"1D2A" },
+  { "sbitib",	14,24,	0x1c4e,	"1B2A" },
+  { "sbitiw",	14,24,	0x1d4e,	"1W2A" },
+  { "sbitid",	14,24,	0x1f4e,	"1D2A" },
+  { "setcfg",	15,24,	0x0b0e,	"5D1q" },
+  { "sfsr",	14,24,	0x673e,	"5D1D" },
+  { "skpsb",	16,16,	0x0c0e,	"1i" },
+  { "skpsw",	16,16,	0x0d0e,	"1i" },
+  { "skpsd",	16,16,	0x0f0e, "1i" },
+  { "skpst",	16,16,	0x8c0e,	"1i" },
+  { "smr",	15,24,	0x0f1e,	"2D1q" },
+  { "sprb",	 7,16,	0x2c,	"2B1q" },
+  { "sprw",	 7,16,	0x2d,	"2W1q" },
+  { "sprd",	 7,16,	0x2f,	"2D1q" },
+  { "subf",	14,24,	0x11be,	"1F2F" },
+  { "subl",	14,24,	0x10be,	"1L2L" },
+  { "subb",	 6,16,	0x20,	"1B2B" },
+  { "subw",	 6,16,	0x21,	"1W2W" },
+  { "subd",	 6,16,	0x23,	"1D2D" },
+  { "subcb",	 6,16,	0x30,	"1B2B" },
+  { "subcw",	 6,16,	0x31,	"1W2W" },
+  { "subcd",	 6,16,	0x33,	"1D2D" },
+  { "subpb",	14,24,	0x2c4e,	"1B2B" },
+  { "subpw",	14,24,	0x2d4e,	"1W2W" },
+  { "subpd",	14,24,	0x2f4e,	"1D2D" },
+#ifndef NS32K_SVC_IMMED_OPERANDS
+  { "svc",	 8,8,	0xe2,	"2i1i" }, /* not really, but unix uses it */
+#else
+  { "svc",	 8,8,	0xe2,	"" }, /* not really, but unix uses it */
+#endif
+  { "tbitb",	 6,16,	0x34,	"1B2A" },
+  { "tbitw",	 6,16,	0x35,	"1W2A" },
+  { "tbitd",	 6,16,	0x37,	"1D2A" },
+  { "truncfb",	14,24,	0x2c3e,	"1F2B" },
+  { "truncfw",	14,24,	0x2d3e,	"1F2W" },
+  { "truncfd",	14,24,	0x2f3e,	"1F2D" },
+  { "trunclb",	14,24,	0x283e,	"1L2B" },
+  { "trunclw",	14,24,	0x293e,	"1L2W" },
+  { "truncld",	14,24,	0x2b3e,	"1L2D" },
+  { "wait",	 8,8,	0xb2,	"" },
+  { "wrval",	19,24,	0x0071e,"1A" },
+  { "xorb",	 6,16,	0x38,	"1B2B" },
+  { "xorw",	 6,16,	0x39,	"1W2W" },
+  { "xord",	 6,16,	0x3b,	"1D2D" },
+};				/* notstrs */
+
+/* end: ns32k.opcode.h */
+
+#define MAX_ARGS 4
+#define ARG_LEN 50
diff --git a/gdb/ns32k-pinsn.c b/gdb/ns32k-pinsn.c
new file mode 100644
index 0000000..7afee48
--- /dev/null
+++ b/gdb/ns32k-pinsn.c
@@ -0,0 +1,437 @@
+/* Print 32000 instructions for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "ns32k-opcode.h"
+
+/* 32000 instructions are never longer than this.  */
+#define MAXLEN 62
+
+/* Number of elements in the opcode table.  */
+#define NOPCODES (sizeof notstrs / sizeof notstrs[0])
+
+extern char *reg_names[];
+
+#define NEXT_IS_ADDR	'|'
+
+/*
+ * extract "count" bits starting "offset" bits
+ * into buffer
+ */
+
+int
+bit_extract (buffer, offset, count)
+     char *buffer;
+     int offset;
+     int count;
+{
+  int result;
+  int mask;
+  int bit;
+
+  buffer += offset >> 3;
+  offset &= 7;
+  bit = 1;
+  result = 0;
+  while (count--) 
+    {
+      if ((*buffer & (1 << offset)))
+	result |= bit;
+      if (++offset == 8)
+	{
+	  offset = 0;
+	  buffer++;
+	}
+      bit <<= 1;
+    }
+  return result;
+}
+
+double
+dbit_extract (buffer, offset, count)
+{
+  union {
+    struct {int low, high; } ival;
+    double dval;
+  } foo;
+
+  foo.ival.low = bit_extract (buffer, offset, 32);
+  foo.ival.high = bit_extract (buffer, offset+32, 32);
+  return foo.dval;
+}
+
+sign_extend (value, bits)
+{
+  value = value & ((1 << bits) - 1);
+  return (value & (1 << (bits-1))
+	  ? value | (~((1 << bits) - 1))
+	  : value);
+}
+
+flip_bytes (ptr, count)
+     char *ptr;
+     int count;
+{
+  char tmp;
+
+  while (count > 0)
+    {
+      tmp = *ptr;
+      ptr[0] = ptr[count-1];
+      ptr[count-1] = tmp;
+      ptr++;
+      count -= 2;
+    }
+}
+
+
+/* Print the 32000 instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn (memaddr, stream)
+CORE_ADDR memaddr;
+FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  register int i;
+  register unsigned char *p;
+  register char *d;
+  unsigned short first_word;
+  int gen, disp;
+  int ioffset;		/* bits into instruction */
+  int aoffset;		/* bits into arguments */
+  char arg_bufs[MAX_ARGS+1][ARG_LEN];
+  int argnum;
+  int maxarg;
+
+  read_memory (memaddr, buffer, MAXLEN);
+
+  first_word = *(unsigned short *) buffer;
+  for (i = 0; i < NOPCODES; i++)
+    if ((first_word & ((1 << notstrs[i].detail.obits) - 1))
+	== notstrs[i].detail.code)
+      break;
+
+  /* Handle undefined instructions.  */
+  if (i == NOPCODES)
+    {
+      fprintf (stream, "0%o", buffer[0]);
+      return 1;
+    }
+
+  fprintf (stream, "%s", notstrs[i].name);
+
+  ioffset = notstrs[i].detail.ibits;
+  aoffset = notstrs[i].detail.ibits;
+  d = notstrs[i].detail.args;
+
+  if (*d)
+    {
+      fputc ('\t', stream);
+
+      maxarg = 0;
+      while (*d)
+	{
+	  argnum = *d - '1';
+	  d++;
+	  if (argnum > maxarg && argnum < MAX_ARGS)
+	    maxarg = argnum;
+	  ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer,
+				    memaddr, arg_bufs[argnum]);
+	  d++;
+	}
+      for (argnum = 0; argnum <= maxarg; argnum++)
+	{
+	  CORE_ADDR addr;
+	  char *ch, *index ();
+	  for (ch = arg_bufs[argnum]; *ch;)
+	    {
+	      if (*ch == NEXT_IS_ADDR)
+		{
+		  ++ch;
+		  addr = atoi (ch);
+		  print_address (addr, stream);
+		  while (*ch && *ch != NEXT_IS_ADDR)
+		    ++ch;
+		  if (*ch)
+		    ++ch;
+		}
+	      else
+		putc (*ch++, stream);
+	    }
+	  if (argnum < maxarg)
+	    fprintf (stream, ", ");
+	}
+    }
+  return aoffset / 8;
+}
+
+print_insn_arg (d, ioffset, aoffsetp, buffer, addr, result)
+     char d;
+     int ioffset, *aoffsetp;
+     char *buffer;
+     CORE_ADDR addr;
+     char *result;
+{
+  int addr_mode;
+  float Fvalue;
+  double Lvalue;
+  int Ivalue;
+  int disp1, disp2;
+  int index;
+
+  switch (d)
+    {
+    case 'F':
+    case 'L':
+    case 'B':
+    case 'W':
+    case 'D':
+    case 'A':
+      addr_mode = bit_extract (buffer, ioffset-5, 5);
+      ioffset -= 5;
+      switch (addr_mode)
+	{
+	case 0x0: case 0x1: case 0x2: case 0x3:
+	case 0x4: case 0x5: case 0x6: case 0x7:
+	  sprintf (result, "r%d", addr_mode);
+	  break;
+	case 0x8: case 0x9: case 0xa: case 0xb:
+	case 0xc: case 0xd: case 0xe: case 0xf:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
+	  break;
+	case 0x10:
+	case 0x11:
+	case 0x12:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  disp2 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "%d(%d(%s))", disp2, disp1,
+		   addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
+	  break;
+	case 0x13:
+	  sprintf (result, "reserved");
+	  break;
+	case 0x14:
+	  switch (d)
+	    {
+	    case 'B':
+	      Ivalue = bit_extract (buffer, *aoffsetp, 8);
+	      Ivalue = sign_extend (Ivalue, 8);
+	      *aoffsetp += 8;
+	      sprintf (result, "$%d", Ivalue);
+	      break;
+	    case 'W':
+	      Ivalue = bit_extract (buffer, *aoffsetp, 16);
+	      flip_bytes (&Ivalue, 2);
+	      *aoffsetp += 16;
+	      Ivalue = sign_extend (Ivalue, 16);
+	      sprintf (result, "$%d", Ivalue);
+	      break;
+	    case 'D':
+	      Ivalue = bit_extract (buffer, *aoffsetp, 32);
+	      flip_bytes (&Ivalue, 4);
+	      *aoffsetp += 32;
+	      sprintf (result, "$%d", Ivalue);
+	      break;
+	    case 'A':
+	      Ivalue = bit_extract (buffer, *aoffsetp, 32);
+	      flip_bytes (&Ivalue, 4);
+	      *aoffsetp += 32;
+	      sprintf (result, "$|%d|", Ivalue);
+	      break;
+	    case 'F':
+	      Fvalue = (float) bit_extract (buffer, *aoffsetp, 32);
+	      flip_bytes (&Fvalue, 4);
+	      *aoffsetp += 32;
+	      sprintf (result, "$%g", Fvalue);
+	      break;
+	    case 'L':
+	      Lvalue = dbit_extract (buffer, *aoffsetp, 64);
+	      flip_bytes (&Lvalue, 8);
+	      *aoffsetp += 64;
+	      sprintf (result, "$%g", Lvalue);
+	      break;
+	    }
+	  break;
+	case 0x15:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "@|%d|", disp1);
+	  break;
+	case 0x16:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  disp2 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "EXT(%d) + %d", disp1, disp2);
+	  break;
+	case 0x17:
+	  sprintf (result, "tos");
+	  break;
+	case 0x18:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "%d(fp)", disp1);
+	  break;
+	case 0x19:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "%d(sp)", disp1);
+	  break;
+	case 0x1a:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "%d(sb)", disp1);
+	  break;
+	case 0x1b:
+	  disp1 = get_displacement (buffer, aoffsetp);
+	  sprintf (result, "|%d|", addr + disp1);
+	  break;
+	case 0x1c:
+	case 0x1d:
+	case 0x1e:
+	case 0x1f:
+	  index = bit_extract (buffer, *aoffsetp, 8);
+	  *aoffsetp += 8;
+	  print_insn_arg (d, *aoffsetp, aoffsetp, buffer, addr,
+			  result);
+	  {
+	    static char	*ind[] = {"b", "w", "d", "q"};
+	    char *off;
+
+	    off = result + strlen (result);
+	    sprintf (off, "[r%d:%s]", index & 7,
+		     ind[addr_mode & 3]);
+	  }
+	  break;
+	}
+      break;
+    case 'q':
+      Ivalue = bit_extract (buffer, ioffset-4, 4);
+      Ivalue = sign_extend (Ivalue, 4);
+      sprintf (result, "%d", Ivalue);
+      ioffset -= 4;
+      break;
+    case 'r':
+      Ivalue = bit_extract (buffer, ioffset-3, 3);
+      sprintf (result, "r%d", Ivalue&7);
+      ioffset -= 3;
+      break;
+    case 'd':
+      sprintf (result, "%d", get_displacement (buffer, aoffsetp));
+      break;
+    case 'p':
+      sprintf (result, "%c%d%c", NEXT_IS_ADDR,
+	       addr + get_displacement (buffer, aoffsetp),
+	       NEXT_IS_ADDR);
+      break;
+    case 'i':
+      Ivalue = bit_extract (buffer, *aoffsetp, 8);
+      *aoffsetp += 8;
+      sprintf (result, "0x%x", Ivalue);
+      break;
+    }
+  return ioffset;
+}
+
+get_displacement (buffer, aoffsetp)
+     char *buffer;
+     int *aoffsetp;
+{
+  int Ivalue;
+
+  Ivalue = bit_extract (buffer, *aoffsetp, 8);
+  switch (Ivalue & 0xc0)
+    {
+    case 0x00:
+    case 0x40:
+      Ivalue = sign_extend (Ivalue, 7);
+      *aoffsetp += 8;
+      break;
+    case 0x80:
+      Ivalue = bit_extract (buffer, *aoffsetp, 16);
+      flip_bytes (&Ivalue, 2);
+      Ivalue = sign_extend (Ivalue, 14);
+      *aoffsetp += 16;
+      break;
+    case 0xc0:
+      Ivalue = bit_extract (buffer, *aoffsetp, 32);
+      flip_bytes (&Ivalue, 4);
+      Ivalue = sign_extend (Ivalue, 30);
+      *aoffsetp += 32;
+      break;
+    }
+  return Ivalue;
+}
+
+/* Return the number of locals in the current frame given a pc
+   pointing to the enter instruction.  This is used in the macro
+   FRAME_FIND_SAVED_REGS.  */
+
+ns32k_localcount (enter_pc)
+     CORE_ADDR enter_pc;
+{
+  unsigned char localtype;
+  int localcount;
+
+  localtype = read_memory_integer (enter_pc+2, 1);
+  if ((localtype & 0x80) == 0)
+    localcount = localtype;
+  else if ((localtype & 0xc0) == 0x80)
+    localcount = (((localtype & 0x3f) << 8)
+		  | (read_memory_integer (enter_pc+3, 1) & 0xff));
+  else
+    localcount = (((localtype & 0x3f) << 24)
+		  | ((read_memory_integer (enter_pc+3, 1) & 0xff) << 16)
+		  | ((read_memory_integer (enter_pc+4, 1) & 0xff) << 8 )
+		  | (read_memory_integer (enter_pc+5, 1) & 0xff));
+  return localcount;
+}
+
+/*
+ * Get the address of the enter opcode for the function
+ * containing PC, if there is an enter for the function,
+ * and if the pc is between the enter and exit.
+ * Returns positive address if pc is between enter/exit,
+ * 1 if pc before enter or after exit, 0 otherwise.
+ */
+
+CORE_ADDR
+n32k_get_enter_addr (pc)
+     CORE_ADDR pc;
+{
+  CORE_ADDR enter_addr;
+  unsigned char op;
+
+  if (ABOUT_TO_RETURN (pc))
+    return 1;		/* after exit */
+
+  enter_addr = get_pc_function_start (pc);
+
+  if (pc == enter_addr) 
+    return 1;		/* before enter */
+
+  op = read_memory_integer (enter_addr, 1);
+
+  if (op != 0x82)
+    return 0;		/* function has no enter/exit */
+
+  return enter_addr;	/* pc is between enter and exit */
+}
diff --git a/gdb/obstack.c b/gdb/obstack.c
new file mode 120000
index 0000000..887f348
--- /dev/null
+++ b/gdb/obstack.c
@@ -0,0 +1 @@
+../gcc/gcc-1.22/obstack.c
\ No newline at end of file
diff --git a/gdb/obstack.h b/gdb/obstack.h
new file mode 120000
index 0000000..db1184b
--- /dev/null
+++ b/gdb/obstack.h
@@ -0,0 +1 @@
+../gcc/gcc-1.19/obstack.h
\ No newline at end of file
diff --git a/gdb/param.h b/gdb/param.h
new file mode 100644
index 0000000..56f2c8a
--- /dev/null
+++ b/gdb/param.h
@@ -0,0 +1 @@
+#include "m-mac-aux.h"
diff --git a/gdb/pinsn.c b/gdb/pinsn.c
new file mode 100644
index 0000000..0b6414e
--- /dev/null
+++ b/gdb/pinsn.c
@@ -0,0 +1 @@
+#include "m68k-pinsn.c"
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
new file mode 100644
index 0000000..d84dd9d
--- /dev/null
+++ b/gdb/printcmd.c
@@ -0,0 +1,979 @@
+/* Print values for GNU debugger gdb.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "value.h"
+#include "expression.h"
+
+struct format_data
+{
+  int count;
+  char format;
+  char size;
+};
+
+/* Last specified output format.  */
+
+static char last_format = 'x';
+
+/* Last specified examination size.  'b', 'h', 'w' or `q'.  */
+
+static char last_size = 'w';
+
+/* Default address to examine next.  */
+
+static CORE_ADDR next_address;
+
+/* Last address examined.  */
+
+static CORE_ADDR last_examine_address;
+
+/* Contents of last address examined.
+   This is not valid past the end of the `x' command!  */
+
+static value last_examine_value;
+
+void do_displays ();
+void print_address ();
+
+START_FILE
+
+/* Decode a format specification.  *STRING_PTR should point to it.
+   OFORMAT and OSIZE are used as defaults for the format and size
+   if none are given in the format specification.
+   The structure returned describes all the data
+   found in the specification.  In addition, *STRING_PTR is advanced
+   past the specification and past all whitespace following it.  */
+
+struct format_data
+decode_format (string_ptr, oformat, osize)
+     char **string_ptr;
+     char oformat;
+     char osize;
+{
+  struct format_data val;
+  register char *p = *string_ptr;
+
+  val.format = oformat;
+  val.size = osize;
+  val.count = 1;
+
+  if (*p >= '0' && *p <= '9')
+    val.count = atoi (p);
+  while (*p >= '0' && *p <= '9') p++;
+
+  /* Now process size or format letters that follow.  */
+
+  while (1)
+    {
+      if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
+	val.size = *p++;
+      else if (*p >= 'a' && *p <= 'z')
+	val.format = *p++;
+      else
+	break;
+    }
+
+  while (*p == ' ' || *p == '\t') p++;
+  *string_ptr = p;
+
+  return val;
+}
+
+/* Print value VAL on stdout according to FORMAT, a letter or 0.
+   Do not end with a newline.
+   0 means print VAL according to its own type.  */
+
+static void
+print_formatted (val, format)
+     register value val;
+     register char format;
+{
+  register CORE_ADDR val_long;
+  int len = TYPE_LENGTH (VALUE_TYPE (val));
+
+  if (VALUE_LVAL (val) == lval_memory)
+    next_address = VALUE_ADDRESS (val) + len;
+
+  if (format && format != 's')
+    {
+      val_long = value_as_long (val);
+
+      /* If value is unsigned, truncate it in case negative.  */
+      if (format != 'd')
+	{
+	  if (len == sizeof (char))
+	    val_long &= (1 << 8 * sizeof(char)) - 1;
+	  else if (len == sizeof (short))
+	    val_long &= (1 << 8 * sizeof(short)) - 1;
+	}
+    }
+
+  switch (format)
+    {
+    case 's':
+      next_address = VALUE_ADDRESS (val)
+	+ value_print (value_addr (val), stdout);
+      break;
+
+    case 'i':
+      next_address = VALUE_ADDRESS (val)
+	+ print_insn (VALUE_ADDRESS (val), stdout);
+      break;
+
+    case 'x':
+      printf ("0x%x", val_long);
+      break;
+
+    case 'd':
+      printf ("%d", val_long);
+      break;
+
+    case 'u':
+      printf ("%u", val_long);
+      break;
+
+    case 'o':
+      if (val_long)
+	printf ("0%o", val_long);
+      else
+	printf ("0");
+      break;
+
+    case 'a':
+      print_address (val_long, stdout);
+      break;
+
+    case 'c':
+      value_print (value_cast (builtin_type_char, val), stdout);
+      break;
+
+    case 'f':
+      if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (float))
+	VALUE_TYPE (val) = builtin_type_float;
+      if (TYPE_LENGTH (VALUE_TYPE (val)) == sizeof (double))
+	VALUE_TYPE (val) = builtin_type_double;
+#ifdef IEEE_FLOAT
+      if (is_nan (value_as_double (val)))
+	{
+	  printf ("Nan");
+	  break;
+	}
+#endif
+      printf ("%g", value_as_double (val));
+      break;
+
+    case 0:
+      value_print (val, stdout);
+      break;
+
+    default:
+      error ("Undefined output format \"%c\".", format);
+    }
+}
+
+/* Specify default address for `x' command.
+   `info lines' uses this.  */
+
+void
+set_next_address (addr)
+     CORE_ADDR addr;
+{
+  next_address = addr;
+
+  /* Make address available to the user as $_.  */
+  set_internalvar (lookup_internalvar ("_"),
+		   value_from_long (builtin_type_int, addr));
+}
+
+/* Print address ADDR symbolically on STREAM.
+   First print it as a number.  Then perhaps print
+   <SYMBOL + OFFSET> after the number.  */
+
+void
+print_address (addr, stream)
+     CORE_ADDR addr;
+     FILE *stream;
+{
+  register int i;
+
+  fprintf (stream, "0x%x", addr);
+
+  i = find_pc_misc_function (addr);
+  if (i >= 0)
+    if (misc_function_vector[i].address != addr)
+      fprintf (stream, " <%s+%d>",
+	       misc_function_vector[i].name,
+	       addr - misc_function_vector[i].address);
+    else
+      fprintf (stream, " <%s>", misc_function_vector[i].name);
+
+}
+
+/* Examine data at address ADDR in format FMT.
+   Fetch it from memory and print on stdout.  */
+
+static void
+do_examine (fmt, addr)
+     struct format_data fmt;
+     CORE_ADDR addr;
+{
+  register char format = 0;
+  register char size;
+  register int count = 1;
+  struct type *val_type;
+  register int i;
+  register int maxelts;
+
+  format = fmt.format;
+  size = fmt.size;
+  count = fmt.count;
+  next_address = addr;
+
+  /* String or instruction format implies fetch single bytes
+     regardless of the specified size.  */
+  if (format == 's' || format == 'i')
+    size = 'b';
+
+  if (size == 'b')
+    val_type = builtin_type_char;
+  else if (size == 'h')
+    val_type = builtin_type_short;
+  else if (size == 'w')
+    val_type = builtin_type_long;
+  else if (size == 'g')
+    val_type = builtin_type_double;
+
+  maxelts = 8;
+  if (size == 'w')
+    maxelts = 4;
+  if (size == 'g')
+    maxelts = 2;
+  if (format == 's' || format == 'i')
+    maxelts = 1;
+
+  /* Print as many objects as specified in COUNT, at most maxelts per line,
+     with the address of the next one at the start of each line.  */
+
+  while (count > 0)
+    {
+      print_address (next_address, stdout);
+      for (i = maxelts;
+	   i > 0 && count > 0;
+	   i--, count--)
+	{
+	  fputc ('\t', stdout);
+	  /* Note that this sets next_address for the next object.  */
+	  last_examine_address = next_address;
+	  last_examine_value = value_at (val_type, next_address);
+	  print_formatted (last_examine_value, format);
+	}
+      fputc ('\n', stdout);
+      fflush (stdout);
+    }
+}
+
+static void
+validate_format (fmt, cmdname)
+     struct format_data fmt;
+     char *cmdname;
+{
+  if (fmt.size != 0)
+    error ("Size letters are meaningless in \"%s\" command.", cmdname);
+  if (fmt.count != 1)
+    error ("Item count other than 1 is meaningless in \"%s\" command.",
+	   cmdname);
+  if (fmt.format == 'i' || fmt.format == 's')
+    error ("Format letter \"%c\" is meaningless in \"%s\" command.",
+	   fmt.format, cmdname);
+}
+
+static void
+print_command (exp)
+     char *exp;
+{
+  struct expression *expr;
+  register struct cleanup *old_chain = 0;
+  register char format = 0;
+  register value val;
+  struct format_data fmt;
+  int histindex;
+  int cleanup = 0;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, last_format, 0);
+      validate_format (fmt, "print");
+      last_format = format = fmt.format;
+    }
+
+  if (exp && *exp)
+    {
+      expr = parse_c_expression (exp);
+      old_chain = make_cleanup (free_current_contents, &expr);
+      cleanup = 1;
+      val = evaluate_expression (expr);
+    }
+  else
+    val = access_value_history (0);
+
+  histindex = record_latest_value (val);
+  printf ("$%d = ", histindex);
+
+  print_formatted (val, format);
+  printf ("\n");
+
+  if (cleanup)
+    do_cleanups (old_chain);
+}
+
+static void
+output_command (exp)
+     char *exp;
+{
+  struct expression *expr;
+  register struct cleanup *old_chain;
+  register char format = 0;
+  register value val;
+  struct format_data fmt;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, 0, 0);
+      validate_format (fmt, "print");
+      format = fmt.format;
+    }
+
+  expr = parse_c_expression (exp);
+  old_chain = make_cleanup (free_current_contents, &expr);
+
+  val = evaluate_expression (expr);
+
+  print_formatted (val, format);
+
+  do_cleanups (old_chain);
+}
+
+static void
+set_command (exp)
+     char *exp;
+{
+  struct expression *expr = parse_c_expression (exp);
+  register struct cleanup *old_chain
+    = make_cleanup (free_current_contents, &expr);
+  evaluate_expression (expr);
+  do_cleanups (old_chain);
+}
+
+static void
+address_info (exp)
+     char *exp;
+{
+  register struct symbol *sym;
+  register CORE_ADDR val;
+
+  if (exp == 0)
+    error ("Argument required.");
+
+  sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE);
+  if (sym == 0)
+    {
+      register int i;
+
+      for (i = 0; i < misc_function_count; i++)
+	if (!strcmp (misc_function_vector[i].name, exp))
+	  break;
+
+      if (i < misc_function_count)
+	printf ("Symbol \"%s\" is at 0x%x in a file compiled without -g.\n",
+		exp, misc_function_vector[i].address);
+      else
+	error ("No symbol \"%s\" in current context.", exp);
+      return;
+    }
+
+  printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym));
+  val = SYMBOL_VALUE (sym);
+
+  switch (SYMBOL_CLASS (sym))
+    {
+    case LOC_CONST:
+    case LOC_CONST_BYTES:
+      printf ("constant");
+      break;
+
+    case LOC_LABEL:
+      printf ("a label at address 0x%x", val);
+      break;
+
+    case LOC_REGISTER:
+      printf ("a variable in register %s", reg_names[val]);
+      break;
+
+    case LOC_STATIC:
+      printf ("static at address 0x%x", val);
+      break;
+
+    case LOC_ARG:
+      printf ("an argument at offset %d", val);
+      break;
+
+    case LOC_LOCAL:
+      printf ("a local variable at frame offset %d", val);
+      break;
+
+    case LOC_TYPEDEF:
+      printf ("a typedef");
+      break;
+
+    case LOC_BLOCK:
+      printf ("a function at address 0x%x",
+	      BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
+      break;
+    }
+  printf (".\n");
+}
+
+static void
+x_command (exp, from_tty)
+     char *exp;
+     int from_tty;
+{
+  struct expression *expr;
+  struct format_data fmt;
+  struct cleanup *old_chain;
+
+  fmt.format = last_format;
+  fmt.size = last_size;
+  fmt.count = 1;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, last_format, last_size);
+      last_size = fmt.size;
+      last_format = fmt.format;
+    }
+
+  /* If we have an expression, evaluate it and use it as the address.  */
+
+  if (exp != 0 && *exp != 0)
+    {
+      expr = parse_c_expression (exp);
+      /* Cause expression not to be there any more
+	 if this command is repeated with Newline.
+	 But don't clobber a user-defined command's definition.  */
+      if (from_tty)
+	*exp = 0;
+      old_chain = make_cleanup (free_current_contents, &expr);
+      next_address = value_as_long (evaluate_expression (expr));
+      do_cleanups (old_chain);
+    }
+
+  do_examine (fmt, next_address);
+
+  /* Make last address examined available to the user as $_.  */
+  set_internalvar (lookup_internalvar ("_"),
+		   value_from_long (builtin_type_int, last_examine_address));
+
+  /* Make contents of last address examined available to the user as $__.  */
+  set_internalvar (lookup_internalvar ("__"), last_examine_value);
+}
+
+/* Commands for printing types of things.  */
+
+static void
+whatis_command (exp)
+     char *exp;
+{
+  struct expression *expr;
+  register value val;
+  register struct cleanup *old_chain;
+
+  if (exp)
+    {
+      expr = parse_c_expression (exp);
+      old_chain = make_cleanup (free_current_contents, &expr);
+      val = evaluate_type (expr);
+    }
+  else
+    val = access_value_history (0);
+
+  printf ("type = ");
+  type_print (VALUE_TYPE (val), "", stdout, 1);
+  printf ("\n");
+
+  if (exp)
+    do_cleanups (old_chain);
+}
+
+static void
+ptype_command (typename)
+     char *typename;
+{
+  register char *p = typename;
+  register int len;
+  extern struct block *get_current_block ();
+  register struct block *b
+    = (have_inferior_p () || have_core_file_p ()) ? get_current_block () : 0;
+  register struct type *type;
+
+  if (typename == 0)
+    error_no_arg ("type name");
+
+  while (*p && *p != ' ' && *p != '\t') p++;
+  len = p - typename;
+  while (*p == ' ' || *p == '\t') p++;
+
+  if (len == 6 && !strncmp (typename, "struct", 6))
+    type = lookup_struct (p, b);
+  else if (len == 5 && !strncmp (typename, "union", 5))
+    type = lookup_union (p, b);
+  else if (len == 4 && !strncmp (typename, "enum", 4))
+    type = lookup_enum (p, b);
+  else
+    {
+      type = lookup_typename (typename, b, 1);
+      if (type == 0)
+	{
+	  register struct symbol *sym
+	    = lookup_symbol (typename, b, STRUCT_NAMESPACE);
+	  if (sym == 0)
+	    error ("No type named %s.", typename);
+	  printf ("No type named %s, but there is a ",
+		  typename);
+	  switch (TYPE_CODE (SYMBOL_TYPE (sym)))
+	    {
+	    case TYPE_CODE_STRUCT:
+	      printf ("struct");
+	      break;
+
+	    case TYPE_CODE_UNION:
+	      printf ("union");
+	      break;
+
+	    case TYPE_CODE_ENUM:
+	      printf ("enum");
+	    }
+	  printf (" %s.  Type \"help ptype\".\n", typename);
+	  type = SYMBOL_TYPE (sym);
+	}
+    }
+
+  type_print (type, "", stdout, 1);
+  printf ("\n");
+}
+
+struct display
+{
+  /* Chain link to next auto-display item.  */
+  struct display *next;
+  /* Expression to be evaluated and displayed.  */
+  struct expression *exp;
+  /* Item number of this auto-display item.  */
+  int number;
+  /* Display format specified.  */
+  struct format_data format;
+  /* Block in which expression is to be evaluated.  */
+  struct block *block;
+};
+
+/* Chain of expressions whose values should be displayed
+   automatically each time the program stops.  */
+
+static struct display *display_chain;
+
+static int display_number;
+
+/* Add an expression to the auto-display chain.
+   Specify the expression.  */
+
+static void
+display_command (exp)
+     char *exp;
+{
+  struct format_data fmt;
+  register struct expression *expr;
+  register struct display *new;
+
+  if (exp == 0)
+    {
+      do_displays ();
+      return;
+    }
+
+  if (*exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, 0, 0);
+      if (fmt.size && fmt.format == 0)
+	fmt.format = 'x';
+      if (fmt.format == 'i' || fmt.format == 's')
+	fmt.size = 'b';
+    }
+  else
+    {
+      fmt.format = 0;
+      fmt.size = 0;
+      fmt.count = 0;
+    }
+
+  expr = parse_c_expression (exp);
+
+  new = (struct display *) xmalloc (sizeof (struct display));
+
+  new->exp = expr;
+  new->next = display_chain;
+  new->number = ++display_number;
+  new->format = fmt;
+  display_chain = new;
+
+  dont_repeat ();
+}
+
+static void
+free_display (d)
+     struct display *d;
+{
+  free (d->exp);
+  free (d);
+}
+
+/* Clear out the display_chain.
+   Done when new symtabs are loaded, since this invalidates
+   the types stored in many expressions.  */
+
+void
+clear_displays ()
+{
+  register struct display *d;
+
+  while (d = display_chain)
+    {
+      free (d->exp);
+      display_chain = d->next;
+      free (d);
+    }
+}
+
+/* Delete some values from the auto-display chain.
+   Specify the element numbers.  */
+
+static void
+undisplay_command (args)
+     char *args;
+{
+  register char *p = args;
+  register char *p1;
+  register int num;
+  register struct display *d, *d1;
+
+  if (args == 0)
+    {
+      if (query ("Delete all auto-display expressions? "))
+	clear_displays ();
+      dont_repeat ();
+      return;
+    }
+
+  while (*p)
+    {
+      p1 = p;
+      while (*p1 >= '0' && *p1 <= '9') p1++;
+      if (*p1 && *p1 != ' ' && *p1 != '\t')
+	error ("Arguments must be display numbers.");
+
+      num = atoi (p);
+
+      if (display_chain->number == num)
+	{
+	  d1 = display_chain;
+	  display_chain = d1->next;
+	  free_display (d1);
+	}
+      else
+	for (d = display_chain; ; d = d->next)
+	  {
+	    if (d->next == 0)
+	      error ("No display number %d.", num);
+	    if (d->next->number == num)
+	      {
+		d1 = d->next;
+		d->next = d1->next;
+		free_display (d1);
+		break;
+	      }
+	  }
+
+      p = p1;
+      while (*p == ' ' || *p == '\t') p++;
+    }
+  dont_repeat ();
+}
+
+/* Display all of the values on the auto-display chain.  */
+
+void
+do_displays ()
+{
+  register struct display *d;
+
+  for (d = display_chain; d; d = d->next)
+    {
+      printf ("%d: ", d->number);
+      if (d->format.size)
+	{
+	  printf ("x/");
+	  if (d->format.count != 1)
+	    printf ("%d", d->format.count);
+	  printf ("%c", d->format.format);
+	  if (d->format.format != 'i' && d->format.format != 's')
+	    printf ("%c", d->format.size);
+	  printf (" ");
+	  print_expression (d->exp, stdout);
+	  if (d->format.count != 1)
+	    printf ("\n");
+	  else
+	    printf ("  ");
+	  do_examine (d->format,
+		      value_as_long (evaluate_expression (d->exp)));
+	}
+      else
+	{
+	  if (d->format.format)
+	    printf ("/%c ", d->format.format);
+	  print_expression (d->exp, stdout);
+	  printf (" = ");
+	  print_formatted (evaluate_expression (d->exp), d->format.format);
+	  printf ("\n");
+	}
+      fflush (stdout);
+    }
+}
+
+static void
+display_info ()
+{
+  register struct display *d;
+
+  if (!display_chain)
+    printf ("There are no auto-display expressions now.\n");
+  else
+    printf ("Auto-display expressions now in effect:\n");
+  for (d = display_chain; d; d = d->next)
+    {
+      printf ("%d: ", d->number);
+      if (d->format.size)
+	printf ("/%d%c%c ", d->format.count, d->format.size,
+		d->format.format);
+      else if (d->format.format)
+	printf ("/%c ", d->format.format);
+      print_expression (d->exp, stdout);
+      printf ("\n");
+      fflush (stdout);
+    }
+}
+
+/* Print the value in stack frame FRAME of a variable
+   specified by a struct symbol.  */
+
+void
+print_variable_value (var, frame, stream)
+     struct symbol *var;
+     CORE_ADDR frame;
+     FILE *stream;
+{
+  value val = read_var_value (var, frame);
+  value_print (val, stream);
+}
+
+/* Print the arguments of a stack frame, given the function FUNC
+   running in that frame (as a symbol), the address of the arglist,
+   and the number of args according to the stack frame (or -1 if unknown).  */
+
+static void print_frame_nameless_args ();
+
+print_frame_args (func, addr, num, stream)
+     struct symbol *func;
+     register CORE_ADDR addr;
+     int num;
+     FILE *stream;
+{
+  struct block *b;
+  int nsyms = 0;
+  int first = 1;
+  register int i;
+  register int last_offset = FRAME_ARGS_SKIP;
+  register struct symbol *sym, *nextsym;
+  register value val;
+
+  if (func)
+    {
+      b = SYMBOL_BLOCK_VALUE (func);
+      nsyms = BLOCK_NSYMS (b);
+    }
+
+  while (1)
+    {
+      /* Find first arg that is not before LAST_OFFSET.  */
+      nextsym = 0;
+      for (i = 0; i < nsyms; i++)
+	{
+	  QUIT;
+	  sym = BLOCK_SYM (b, i);
+	  if (SYMBOL_CLASS (sym) == LOC_ARG
+	      && SYMBOL_VALUE (sym) >= last_offset
+	      && (nextsym == 0
+		  || SYMBOL_VALUE (sym) < SYMBOL_VALUE (nextsym)))
+	    nextsym = sym;
+	}
+      if (nextsym == 0)
+	break;
+      sym = nextsym;
+      /* Print any nameless args between the last arg printed
+	 and the next arg.  */
+      if (last_offset != (SYMBOL_VALUE (sym) / sizeof (int)) * sizeof (int))
+	{
+	  print_frame_nameless_args (addr, last_offset, SYMBOL_VALUE (sym),
+				     stream);
+	  first = 0;
+	}
+      /* Print the next arg.  */
+      val = value_at (SYMBOL_TYPE (sym), addr + SYMBOL_VALUE (sym));
+      if (! first)
+	fprintf (stream, ", ");
+      fprintf (stream, "%s=", SYMBOL_NAME (sym));
+      value_print (val, stream);
+      first = 0;
+      last_offset = SYMBOL_VALUE (sym) + TYPE_LENGTH (SYMBOL_TYPE (sym));
+      /* Round up address of next arg to multiple of size of int.  */
+      last_offset
+	= ((last_offset + sizeof (int) - 1) / sizeof (int)) * sizeof (int);
+    }
+  if (num >= 0 && num * sizeof (int) + FRAME_ARGS_SKIP > last_offset)
+    print_frame_nameless_args (addr, last_offset,
+			       num * sizeof (int) + FRAME_ARGS_SKIP, stream);
+}
+
+static void
+print_frame_nameless_args (argsaddr, start, end, stream)
+     CORE_ADDR argsaddr;
+     int start;
+     int end;
+     FILE *stream;
+{
+  while (start < end)
+    {
+      QUIT;
+      if (start != FRAME_ARGS_SKIP)
+	fprintf (stream, ", ");
+      fprintf (stream, "%d",
+	       read_memory_integer (argsaddr + start, sizeof (int)));
+      start += sizeof (int);
+    }
+}
+
+static
+initialize ()
+{
+  add_info ("address", address_info,
+	   "Describe where variable VAR is stored.");
+
+  add_com ("x", class_vars, x_command,
+	   "Examine memory: x/FMT ADDRESS.\n\
+ADDRESS is an expression for the memory address to examine.\n\
+FMT is a repeat count followed by a format letter and a size letter.\n\
+Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
+ f(float), a(address), i(instruction), c(char) and s(string).\n\
+Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
+  g is meaningful only with f, for type double.\n\
+The specified number of objects of the specified size are printed\n\
+according to the format.\n\n\
+Defaults for format and size letters are those previously used.\n\
+Default count is 1.  Default address is following last thing printed\n\
+with this command or \"print\".");
+
+  add_com ("ptype", class_vars, ptype_command,
+	   "Print definition of type TYPE.\n\
+Argument may be a type name defined by typedef, or \"struct STRUCTNAME\"\n\
+or \"union UNIONNAME\" or \"enum ENUMNAME\".\n\
+The selected stack frame's lexical context is used to look up the name.");
+
+  add_com ("whatis", class_vars, whatis_command,
+	   "Print data type of expression EXP.");
+
+  add_info ("display", display_info,
+	    "Expressions to display when program stops, with code numbers.");
+  add_com ("undisplay", class_vars, undisplay_command,
+	   "Cancel some expressions to be displayed whenever program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means cancel all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.");
+  add_com ("display", class_vars, display_command,
+	   "Print value of expression EXP each time the program stops.\n\
+/FMT may be used before EXP as in the \"print\" command.\n\
+/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
+as in the \"x\" command, and then EXP is used to get the address to examine\n\
+and examining is done as in the \"x\" command.\n\n\
+With no argument, display all currently requested auto-display expressions.\n\
+Use \"undisplay\" to cancel display requests previously made.");
+
+  add_com ("output", class_vars, output_command,
+	   "Like \"print\" but don't put in value history and don't print newline.\n\
+This is useful in user-defined commands.");
+
+  add_com ("set", class_vars, set_command,
+	   "Perform an assignment VAR = EXP.  You must type the \"=\".\n\
+VAR may be a debugger \"convenience\" variables (names starting with $),\n\
+a register (a few standard names starting with $), or an actual variable\n\
+in the program being debugger.  EXP is any expression.");
+
+  add_com ("print", class_vars, print_command,
+	   concat ("Print value of expression EXP.\n\
+Variables accessible are those of the lexical environment of the selected\n\
+stack frame, plus all those whose scope is global or an entire file.\n\
+\n\
+$NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
+$$NUM refers to NUM'th value back from the last one.\n\
+Names starting with $ refer to registers (with the values they would have\n\
+if the program were to return to the stack frame now selected, restoring\n\
+all registers saved by frames farther in) or else to debugger\n\
+\"convenience\" variables (any such name not a known register).\n\
+Use assignment expressions to give values to convenience variables.\n",
+		   "\n\
+\{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
+@ is a binary operator for treating consecutive data objects\n\
+anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
+element is FOO, whose second element is stored in the space following\n\
+where FOO is stored, etc.  FOO must be an expression whose value\n\
+resides in memory.\n",
+		   "\n\
+EXP may be preceded with /FMT, where FMT is a format letter\n\
+but no count or size letter (see \"x\" command)."));
+  add_com_alias ("p", "print", class_vars, 1);
+}
+
+END_FILE
diff --git a/gdb/song b/gdb/song
new file mode 100644
index 0000000..ad65ee9
--- /dev/null
+++ b/gdb/song
@@ -0,0 +1,44 @@
+Date: Tue, 6 Oct 87 08:52:07 PDT
+To: bug-gnu-emacs@prep.ai.mit.edu
+From: Lynn Slater <silvlis!wobegon!lrs@sun.com>
+Sender: silvlis!wobegon!lrs@sun.com
+Organization: Silvar-Lisco, 1080 Marsh Road, Menlo Park, CA 94025-1053
+Phone.......: (415) 853-6336 (Office); (415) 796-4149 (Home)
+Subject: GDB sing-along
+
+
+Somebody asked us what was GDB.  With apologies to Oscar Hemmerstein
+II, Richard Rodgers, and Julie Andrews, we offered the following reply:
+
+Let's start at the very beginning, a very good place to start,
+  When you're learning to sing, its Do, Re, Mi;
+  When you're learning to code, its G,  D,   B.
+                       (background) G,  D,   B.
+  The first three letters just happen to be, G, D, B.
+                       (background) G,  D,   B.
+
+(Chorus)
+   G!,    GNU!, it's Stallman's hope,
+   
+   B,     a break I set myself.
+   
+   D,     debug that rotten code,
+   
+   Run,   a far, far way to go.
+   
+   Print, to see what you have done,
+   
+   Set,   a patch that follows print.
+
+   Quit,  and recompile your code  - - -
+   
+That will bring it back to G,
+                            D,
+                             B,
+                               <link>
+ 
+(Resume from the Chorus)
+
+
+:-)  Joel Bion, Mark Baushke, and Lynn Slater :-)
+
diff --git a/gdb/source.c b/gdb/source.c
new file mode 100644
index 0000000..27ffd8f
--- /dev/null
+++ b/gdb/source.c
@@ -0,0 +1,667 @@
+/* List lines of source files for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+
+/* Path of directories to search for source files.
+   Same format as the PATH environment variable's value.  */
+
+static char *source_path;
+
+/* Symtab of default file for listing lines of.  */
+
+struct symtab *current_source_symtab;
+
+/* Default next line to list.  */
+
+int current_source_line;
+
+/* Line for "info line" to work on if no line specified.  */
+
+static int line_info_default_line;
+
+/* First line number listed by last listing command.  */
+
+static int first_line_listed;
+
+START_FILE
+
+/* Set the source file default for the "list" command,
+   specifying a symtab.  */
+
+void
+select_source_symtab (s)
+     register struct symtab *s;
+{
+  if (s)
+    {
+      struct symtab_and_line sal;
+
+      /* Make the default place to list be the function `main'
+	 if one exists.  */
+      if (lookup_symbol ("main", 0, VAR_NAMESPACE))
+	{
+	  sal = decode_line_spec ("main", 1);
+	  current_source_symtab = sal.symtab;
+	  current_source_line = sal.line - 9;
+	  return;
+	}
+
+      /* If there is no `main', use the last symtab in the list,
+	 which is actually the first found in the file's symbol table.
+	 But ignore .h files.  */
+      do
+	{
+	  char *name = s->filename;
+	  int len = strlen (name);
+	  if (! (len > 2 && !strcmp (&name[len - 2], ".h")))
+	    current_source_symtab = s;
+	  s = s->next;
+	}
+      while (s);
+      current_source_line = 1;
+    }
+}
+
+static void
+directories_info ()
+{
+  printf ("Source directories searched: %s\n", source_path);
+}
+
+static void
+init_source_path ()
+{
+  register struct symtab *s;
+  char wd[MAXPATHLEN];
+  if (getwd (wd) == NULL)
+    perror_with_name ("getwd");
+
+  source_path = savestring (wd, strlen (wd));
+
+  /* Forget what we learned about line positions in source files;
+     must check again now since files may be found in
+     a different directory now.  */
+  for (s = symtab_list; s; s = s->next)
+    if (s->line_charpos != 0)
+      {
+	free (s->line_charpos);
+	s->line_charpos = 0;
+      }
+}
+
+void
+directory_command (dirname, from_tty)
+     char *dirname;
+     int from_tty;
+{
+  char *old = source_path;
+
+  char wd[MAXPATHLEN];
+  if (getwd (wd) == NULL)
+    perror_with_name ("getwd");
+
+  if (dirname == 0)
+    {
+      if (query ("Reinitialize source path to %s? ", wd))
+	{
+	  init_source_path ();
+	  free (old);
+	}
+    }
+  else
+    {
+      struct stat st;
+      register int len = strlen (dirname);
+      register char *tem;
+      extern char *index ();
+
+      if (index (dirname, ':'))
+	error ("Please add one directory at a time to the source path.");
+      if (dirname[len - 1] == '/')
+	  /* Sigh. "foo/" => "foo" */
+	  dirname[--len] == '\0';
+
+      while (dirname[len - 1] == '.')
+	{
+	  if (len == 1)
+	    {
+	      /* "." => getwd () */
+	      dirname = wd;
+	      goto append;
+	    }
+	  else if (dirname[len - 2] == '/')
+	    {
+	      if (len == 2)
+		{
+		  /* "/." => "/" */
+		  dirname[--len] = '\0';
+		  goto append;
+		}
+	      else
+		{
+		  /* "...foo/." => "...foo" */
+		  dirname[len -= 2] = '\0';
+		  continue;
+		}
+	    }
+	  break;
+	}
+
+      if (dirname[0] != '/')
+	dirname = concat (wd, "/", dirname);
+      else
+	dirname = savestring (dirname, len);
+      make_cleanup (free, dirname);
+
+      if (stat (dirname, &st) < 0)
+	perror_with_name (dirname);
+      if ((st.st_mode & S_IFMT) != S_IFDIR)
+	error ("%s is not a directory.", dirname);
+
+    append:
+      len = strlen (dirname);
+      tem = source_path;
+      while (1)
+	{
+	  if (!strncmp (tem, dirname, len)
+	      && (tem[len] == '\0' || tem[len] == ':'))
+	    {
+	      printf ("\"%s\" is already in the source path.\n",
+		      dirname);
+	      break;
+	    }
+	  tem = index (tem, ':');
+	  if (tem)
+	    tem++;
+	  else
+	    {
+	      source_path = concat (old, ":", dirname);
+	      free (old);
+	      break;
+	    }
+	}
+      if (from_tty)
+	directories_info ();
+    }
+}
+
+/* Open a file named STRING, searching path PATH (dir names sep by colons)
+   using mode MODE and protection bits PROT in the calls to open.
+   If TRY_CWD_FIRST, try to open ./STRING before searching PATH.
+   (ie pretend the first element of PATH is ".")
+   If FILENAMED_OPENED is non-null, set it to a newly allocated string naming
+   the actual file opened (this string will always start with a "/"
+
+   If a file is found, return the descriptor.
+   Otherwise, return -1, with errno set for the last name we tried to open.  */
+
+/*  >>>> This should only allow files of certain types,
+    >>>>  eg executable, non-directory */
+int
+openp (path, try_cwd_first, string, mode, prot, filename_opened)
+     char *path;
+     int try_cwd_first;
+     char *string;
+     int mode;
+     int prot;
+     char **filename_opened;
+{
+  register int fd;
+  register char *filename;
+  register char *p, *p1;
+  register int len;
+
+  /* ./foo => foo */
+  while (string[0] == '.' && string[1] == '/')
+    string += 2;
+
+  if (try_cwd_first || string[0] == '/')
+    {
+      filename = string;
+      fd = open (filename, mode, prot);
+      if (fd >= 0 || string[0] == '/')
+	goto done;
+    }
+
+  filename = (char *) alloca (strlen (path) + strlen (string) + 2);
+  fd = -1;
+  for (p = path; p; p = p1 ? p1 + 1 : 0)
+    {
+      p1 = (char *) index (p, ':');
+      if (p1)
+	len = p1 - p;
+      else
+	len = strlen (p);
+
+      strncpy (filename, p, len);
+      filename[len] = 0;
+      strcat (filename, "/");
+      strcat (filename, string);
+
+      fd = open (filename, mode, prot);
+      if (fd >= 0) break;
+    }
+
+ done:
+  if (filename_opened)
+    if (fd < 0)
+      *filename_opened = (char *) 0;
+    else if (filename[0] == '/')
+      *filename_opened = savestring (filename, strlen (filename));
+    else
+      {
+	char dirname[MAXPATHLEN];
+	if (getwd (dirname) == NULL)
+	  perror_with_name ("getwd");
+	*filename_opened = concat (dirname, "/", filename);
+      }
+
+  return fd;
+}
+
+/* Create and initialize the table S->line_charpos that records
+   the positions of the lines in the source file, which is assumed
+   to be open on descriptor DESC.
+   All set S->nlines to the number of such lines.  */
+
+static void
+find_source_lines (s, desc)
+     struct symtab *s;
+     int desc;
+{
+  struct stat st;
+  register char *data, *p, *end;
+  int nlines = 0;
+  int lines_allocated = 1000;
+  int *line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
+  extern int exec_mtime;
+
+  fstat (desc, &st);
+  if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
+    printf ("Source file is more recent than executable.\n");
+
+  data = (char *) alloca (st.st_size);
+  myread (desc, data, st.st_size);
+  end = data + st.st_size;
+  p = data;
+  line_charpos[0] = 0;
+  nlines = 1;
+  while (p != end)
+    {
+      if (*p++ == '\n')
+	{
+	  if (nlines == lines_allocated)
+	    line_charpos = (int *) xrealloc (line_charpos,
+					     sizeof (int) * (lines_allocated *= 2));
+	  line_charpos[nlines++] = p - data;
+	}
+    }
+  s->nlines = nlines;
+  s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int));
+}
+
+/* Return the character position of a line LINE in symtab S.
+   Return 0 if anything is invalid.  */
+
+int
+source_line_charpos (s, line)
+     struct symtab *s;
+     int line;
+{
+  if (!s) return 0;
+  if (!s->line_charpos || line <= 0) return 0;
+  if (line > s->nlines)
+    line = s->nlines;
+  return s->line_charpos[line - 1];
+}
+
+/* Return the line number of character position POS in symtab S.  */
+
+int
+source_charpos_line (s, chr)
+    register struct symtab *s;
+    register int chr;
+{
+  register int line = 0;
+  register int *lnp;
+    
+  if (s == 0 || s->line_charpos == 0) return 0;
+  lnp = s->line_charpos;
+  /* Files are usually short, so sequential search is Ok */
+  while (line < s->nlines  && *lnp <= chr)
+    {
+      line++;
+      lnp++;
+    }
+  if (line >= s->nlines)
+    line = s->nlines;
+  return line;
+}
+
+/* Get full pathname and line number positions for a symtab.
+   Return nonzero if line numbers may have changed.
+   Set *FULLNAME to actual name of the file as found by `openp',
+   or to 0 if the file is not found.  */
+
+int
+get_filename_and_charpos (s, line, fullname)
+     struct symtab *s;
+     int line;
+     char **fullname;
+{
+  register int desc, linenums_changed = 0;
+  
+  desc = openp (source_path, 0, s->filename, O_RDONLY, 0, fullname);
+  if (desc < 0)
+    {
+      *fullname = NULL;
+      return 0;
+    }  
+  if (s->line_charpos == 0) linenums_changed = 1;
+  if (linenums_changed) find_source_lines (s, desc);
+  close (desc);
+  return linenums_changed;
+}
+
+/* Print source lines from the file of symtab S,
+   starting with line number LINE and stopping before line number STOPLINE.  */
+
+void
+print_source_lines (s, line, stopline)
+     struct symtab *s;
+     int line, stopline;
+{
+  register int c;
+  register int desc;
+  register FILE *stream;
+  int nlines = stopline - line;
+
+  desc = openp (source_path, 0, s->filename, O_RDONLY, 0, (char **) 0);
+  if (desc < 0)
+    perror_with_name (s->filename);
+
+  if (s->line_charpos == 0)
+    find_source_lines (s, desc);
+
+  if (line < 1 || line >= s->nlines)
+    {
+      close (desc);
+      error ("Line number out of range; %s has %d lines.",
+	     s->filename, s->nlines);
+    }
+
+  if (lseek (desc, s->line_charpos[line - 1], 0) < 0)
+    {
+      close (desc);
+      perror_with_name (s->filename);
+    }
+
+  current_source_symtab = s;
+  current_source_line = line;
+  first_line_listed = line;
+  
+  stream = fdopen (desc, "r");
+  clearerr (stream);
+
+  while (nlines-- > 0)
+    {
+      c = fgetc (stream);
+      if (c == EOF) break;
+      line_info_default_line = current_source_line;
+      printf ("%d\t", current_source_line++);
+      do
+	{
+	  if (c < 040 && c != '\t' && c != '\n')
+	    {
+	      fputc ('^', stdout);
+	      fputc (c + 0100, stdout);
+	    }
+	  else if (c == 0177)
+	    printf ("^?");
+	  else
+	    fputc (c, stdout);
+	} while (c != '\n' && (c = fgetc (stream)) >= 0);
+    }
+
+  fclose (stream);
+}
+
+static void
+list_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal, sal_end;
+  struct symbol *sym;
+  char *arg1;
+  int no_end = 1;
+  int dummy_end = 0;
+  int dummy_beg = 0;
+  int linenum_beg = 0;
+  char *p;
+
+  if (symtab_list == 0)
+    error ("Listing source lines requires symbols.");
+
+  /* "l" or "l +" lists next ten lines.  */
+
+  if (arg == 0 || !strcmp (arg, "+"))
+    {
+      if (current_source_symtab == 0)
+	error ("No default source file yet.  Do \"help list\".");
+      print_source_lines (current_source_symtab, current_source_line,
+			  current_source_line + 10);
+      return;
+    }
+
+  /* "l -" lists previous ten lines, the ones before the ten just listed.  */
+  if (!strcmp (arg, "-"))
+    {
+      if (current_source_symtab == 0)
+	error ("No default source file yet.  Do \"help list\".");
+      print_source_lines (current_source_symtab,
+			  max (first_line_listed - 10, 1),
+			  first_line_listed);
+      return;
+    }
+
+  /* Now if there is only one argument, decode it in SAL
+     and set NO_END.
+     If there are two arguments, decode them in SAL and SAL_END
+     and clear NO_END; however, if one of the arguments is blank,
+     set DUMMY_BEG or DUMMY_END to record that fact.  */
+
+  arg1 = arg;
+  if (*arg1 == ',')
+    dummy_beg = 1;
+  else
+    sal = decode_line_1 (&arg1, 0, 0, 0);
+
+  /* Record whether the BEG arg is all digits.  */
+
+  for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++);
+  linenum_beg = (p == arg1);
+
+  while (*arg1 == ' ' || *arg1 == '\t')
+    arg1++;
+  if (*arg1 == ',')
+    {
+      no_end = 0;
+      arg1++;
+      while (*arg1 == ' ' || *arg1 == '\t')
+	arg1++;
+      if (*arg1 == 0)
+	dummy_end = 1;
+      else if (dummy_beg)
+	sal_end = decode_line_1 (&arg1, 0, 0, 0);
+      else
+	sal_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line);
+    }
+
+  if (*arg1)
+    error ("Junk at end of line specification.");
+
+  if (!no_end && !dummy_beg && !dummy_end
+      && sal.symtab != sal_end.symtab)
+    error ("Specified start and end are in different files.");
+  if (dummy_beg && dummy_end)
+    error ("Two empty args do not say what lines to list.");
+ 
+  /* if line was specified by address,
+     first print exactly which line, and which file.
+     In this case, sal.symtab == 0 means address is outside
+     of all known source files, not that user failed to give a filename.  */
+  if (*arg == '*')
+    {
+      if (sal.symtab == 0)
+	error ("No source file for address 0x%x.", sal.pc);
+      sym = find_pc_function (sal.pc);
+      if (sym)
+	printf ("0x%x is in %s (%s, line %d).\n",
+		sal.pc, SYMBOL_NAME (sym), sal.symtab->filename, sal.line);
+      else
+	printf ("0x%x is in %s, line %d.\n",
+		sal.pc, sal.symtab->filename, sal.line);
+    }
+
+  /* If line was not specified by just a line number,
+     and it does not imply a symtab, it must be an undebuggable symbol
+     which means no source code.  */
+
+  if (! linenum_beg && sal.symtab == 0)
+    error ("No line number known for %s.", arg);
+
+  /* If this command is repeated with RET,
+     turn it into the no-arg variant.  */
+
+  if (from_tty)
+    *arg = 0;
+
+  if (dummy_beg && sal_end.symtab == 0)
+    error ("No default source file yet.  Do \"help list\".");
+  if (dummy_beg)
+    print_source_lines (sal_end.symtab, max (sal_end.line - 9, 1),
+			sal_end.line + 1);
+  else if (sal.symtab == 0)
+    error ("No default source file yet.  Do \"help list\".");
+  else if (no_end)
+    print_source_lines (sal.symtab, max (sal.line - 5, 1), sal.line + 5);
+  else
+    print_source_lines (sal.symtab, sal.line,
+			dummy_end ? sal.line + 10 : sal_end.line + 1);
+}
+
+/* Print info on range of pc's in a specified line.  */
+
+static void
+line_info (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  struct symtab_and_line sal;
+  int start_pc, end_pc;
+
+  if (arg == 0)
+    {
+      sal.symtab = current_source_symtab;
+      sal.line = line_info_default_line;
+    }
+  else
+    {
+      sal = decode_line_spec (arg);
+
+      /* If this command is repeated with RET,
+	 turn it into the no-arg variant.  */
+
+      if (from_tty)
+	*arg = 0;
+    }
+
+  if (sal.symtab == 0)
+    error ("No source file specified.");
+  if (sal.line > 0
+      && find_line_pc_range (sal.symtab, sal.line, &start_pc, &end_pc))
+    {
+      if (start_pc == end_pc)
+	printf ("Line %d of \"%s\" is at pc 0x%x but contains no code.\n",
+		sal.line, sal.symtab->filename, start_pc);
+      else
+	printf ("Line %d of \"%s\" starts at pc 0x%x and ends at 0x%x.\n",
+		sal.line, sal.symtab->filename, start_pc, end_pc);
+      /* x/i should display this line's code.  */
+      set_next_address (start_pc);
+      /* Repeating "info line" should do the following line.  */
+      line_info_default_line = sal.line + 1;
+    }
+  else
+    printf ("Line number %d is out of range for \"%s\".\n",
+	    sal.line, sal.symtab->filename);
+}
+
+static
+initialize ()
+{
+  current_source_symtab = 0;
+  init_source_path ();
+
+  add_com ("directory", class_files, directory_command,
+	   "Add directory DIR to end of search path for source files.\n\
+With no argument, reset the search path to just the working directory\n\
+and forget cached info on line positions in source files.");
+
+  add_info ("directories", directories_info,
+	    "Current search path for finding source files.");
+
+  add_info ("line", line_info,
+	    "Core addresses of the code for a source line.\n\
+Line can be specified as\n\
+  LINENUM, to list around that line in current file,\n\
+  FILE:LINENUM, to list around that line in that file,\n\
+  FUNCTION, to list around beginning of that function,\n\
+  FILE:FUNCTION, to distinguish among like-named static functions.\n\
+Default is to describe the last source line that was listed.\n\n\
+This sets the default address for \"x\" to the line's first instruction\n\
+so that \"x/i\" suffices to start examining the machine code.\n\
+The address is also stored as the value of \"$_\".");
+
+  add_com ("list", class_files, list_command,
+	   "List specified function or line.\n\
+With no argument, lists ten more lines after or around previous listing.\n\
+\"list -\" lists the ten lines before a previous ten-line listing.\n\
+One argument specifies a line, and ten lines are listed around that line.\n\
+Two arguments with comma between specify starting and ending lines to list.\n\
+Lines can be specified in these ways:\n\
+  LINENUM, to list around that line in current file,\n\
+  FILE:LINENUM, to list around that line in that file,\n\
+  FUNCTION, to list around beginning of that function,\n\
+  FILE:FUNCTION, to distinguish among like-named static functions.\n\
+  *ADDRESS, to list around the line containing that address.\n\
+With two args if one is empty it stands for ten lines away from the other arg.");
+}
+
+END_FILE
diff --git a/gdb/stack.c b/gdb/stack.c
new file mode 100644
index 0000000..2698729
--- /dev/null
+++ b/gdb/stack.c
@@ -0,0 +1,612 @@
+/* Print and select stack frames for GDB, the GNU debugger.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+
+START_FILE
+
+/* Thie "selected" stack frame is used by default for local and arg access.
+   May be zero, for no selected frame.  */
+
+FRAME selected_frame;
+
+/* Level of the selected frame:
+   0 for innermost, 1 for its caller, ...
+   or -1 for frame specified by address with no defined level.  */
+
+int selected_frame_level;
+
+static void select_calling_frame ();
+
+void print_frame_info ();
+
+/* Print a stack frame briefly.  FRAME should be the frame address
+   and LEVEL should be its level in the stack (or -1 for level not defined).
+   This prints the level, the function executing, the arguments,
+   and the file name and line number.
+   If the pc is not at the beginning of the source line,
+   the actual pc is printed at the beginning.
+
+   If SOURCE is 1, print the source line as well.
+   If SOURCE is -1, print ONLY the source line.  */
+
+static void
+print_stack_frame (frame, level, source)
+     FRAME frame;
+     int level;
+     int source;
+{
+  struct frame_info fi;
+
+  fi = get_frame_info (frame);
+
+  print_frame_info (&fi, level, source, 1);
+}
+
+void
+print_frame_info (fi, level, source, args)
+     struct frame_info *fi;
+     register int level;
+     int source;
+     int args;
+{
+  register FRAME frame = fi->frame;
+  struct symtab_and_line sal;
+  struct symbol *func;
+  register char *funname = 0;
+  int numargs;
+
+  sal = find_pc_line (fi->pc, fi->next_frame);
+  func = get_frame_function (frame);
+  if (func)
+    funname = SYMBOL_NAME (func);
+  else
+    {
+      register int misc_index = find_pc_misc_function (fi->pc);
+      if (misc_index >= 0)
+	funname = misc_function_vector[misc_index].name;
+    }
+
+  if (source >= 0 || !sal.symtab)
+    {
+      /* This avoids a bug in cc on the sun.  */
+      struct frame_info tem;
+      tem = *fi;
+
+      if (level >= 0)
+	printf ("#%-2d ", level);
+      if (fi->pc != sal.pc || !sal.symtab)
+	printf ("0x%x in ", fi->pc);
+      printf ("%s (", funname ? funname : "??");
+      if (args)
+	{
+	  FRAME_NUM_ARGS (numargs, tem);
+	  print_frame_args (func, FRAME_ARGS_ADDRESS (tem), numargs, stdout);
+	}
+      printf (")");
+      if (sal.symtab)
+	printf (" (%s line %d)", sal.symtab->filename, sal.line);
+      printf ("\n");
+    }
+
+  if (source != 0 && sal.symtab)
+    {
+      if (source < 0 && fi->pc != sal.pc)
+	printf ("0x%x\t", fi->pc);
+      print_source_lines (sal.symtab, sal.line, sal.line + 1);
+      current_source_line = max (sal.line - 5, 1);
+    }
+  if (source != 0)
+    set_default_breakpoint (1, fi->pc, sal.symtab, sal.line);
+
+  fflush (stdout);
+}
+
+/* Call here to print info on selected frame, after a trap.  */
+
+void
+print_sel_frame (just_source)
+     int just_source;
+{
+  print_stack_frame (selected_frame, -1, just_source ? -1 : 1);
+}
+
+/* Print info on the selected frame, including level number
+   but not source.  */
+
+print_selected_frame ()
+{
+  print_stack_frame (selected_frame, selected_frame_level, 0);
+}
+
+/* Print verbosely the selected frame or the frame at address ADDR.
+   This means absolutely all information in the frame is printed.  */
+
+static void
+frame_info (addr_exp)
+     char *addr_exp;
+{
+  FRAME frame = addr_exp ? parse_and_eval_address (addr_exp) : selected_frame;
+  struct frame_info fi;
+  struct frame_saved_regs fsr;
+  struct symtab_and_line sal;
+  struct symbol *func;
+  FRAME calling_frame;
+  int i, count;
+  char *funname = 0;
+  int numargs;
+
+  fi = get_frame_info (frame);
+  get_frame_saved_regs (&fi, &fsr);
+  sal = find_pc_line (fi.pc, fi.next_frame);
+  func = get_frame_function (frame);
+  if (func)
+    funname = SYMBOL_NAME (func);
+  else
+    {
+      register int misc_index = find_pc_misc_function (fi.pc);
+      if (misc_index >= 0)
+	funname = misc_function_vector[misc_index].name;
+    }
+  calling_frame = get_prev_frame (frame);
+
+  if (!addr_exp && selected_frame_level >= 0)
+    printf ("Stack level %d, frame at 0x%x:\n pc = 0x%x",
+	    selected_frame_level, frame, fi.pc);
+  else
+    printf ("Stack frame at 0x%x:\n pc = 0x%x",
+	    frame, fi.pc);
+
+  if (funname)
+    printf (" in %s", funname);
+  if (sal.symtab)
+    printf (" (%s line %d)", sal.symtab->filename, sal.line);
+  printf ("; saved pc 0x%x\n", FRAME_SAVED_PC (frame));
+  if (calling_frame)
+    printf (" called by frame at 0x%x", calling_frame);
+  if (fi.next_frame && calling_frame)
+    printf (",");
+  if (fi.next_frame)
+    printf (" caller of frame at 0x%x", fi.next_frame);
+  if (fi.next_frame || calling_frame)
+    printf ("\n");
+  printf (" Arglist at 0x%x,", FRAME_ARGS_ADDRESS (fi));
+  FRAME_NUM_ARGS (i, fi);
+  if (i < 0)
+    printf (" args: ");
+  else if (i == 0)
+    printf (" no args.");
+  else if (i == 1)
+    printf (" 1 arg: ");
+  else
+    printf (" %d args: ", i);
+
+  FRAME_NUM_ARGS (numargs, fi);
+  print_frame_args (func, FRAME_ARGS_ADDRESS (fi), numargs, stdout);
+  printf ("\n");
+  count = 0;
+  for (i = 0; i < NUM_REGS; i++)
+    if (fsr.regs[i])
+      {
+	if (count % 4 != 0)
+	  printf (", ");
+	else
+	  {
+	    if (count == 0)
+	      printf (" Saved registers:");
+	    printf ("\n  ");
+	  }
+	printf ("%s at 0x%x", reg_names[i], fsr.regs[i]);
+	count++;
+      }
+  if (count)
+    printf ("\n");
+}
+
+/* Print briefly all stack frames or just the innermost COUNT frames.  */
+
+static void
+backtrace_command (count_exp)
+     char *count_exp;
+{
+  struct frame_info fi;
+  register int count;
+  register FRAME frame;
+  register int i;
+
+  if (count_exp)
+    count = parse_and_eval_address (count_exp);
+  else
+    count = -1;
+
+  for (i = 0, frame = get_current_frame (), fi = get_frame_info (frame);
+       frame && count--;
+       i++, fi = get_prev_frame_info (fi.frame), frame = fi.frame)
+    {
+      QUIT;
+      print_frame_info (&fi, i, 0, 1);
+    }
+}
+
+/* Print the local variables of a block B active in FRAME.  */
+
+static void
+print_block_frame_locals (b, frame, stream)
+     struct block *b;
+     register FRAME frame;
+     register FILE *stream;
+{
+  int nsyms;
+  register int i;
+  register struct symbol *sym;
+
+  nsyms = BLOCK_NSYMS (b);
+
+  for (i = 0; i < nsyms; i++)
+    {
+      sym = BLOCK_SYM (b, i);
+      if (SYMBOL_CLASS (sym) == LOC_LOCAL
+	  || SYMBOL_CLASS (sym) == LOC_REGISTER)
+	{
+	  fprintf (stream, "%s = ", SYMBOL_NAME (sym));
+	  print_variable_value (sym, frame, stream);
+	  fprintf (stream, "\n");
+	  fflush (stream);
+	}
+    }
+}
+
+/* Print on STREAM all the local variables in frame FRAME,
+   including all the blocks active in that frame
+   at its current pc.
+
+   Returns 1 if the job was done,
+   or 0 if nothing was printed because we have no info
+   on the function running in FRAME.  */
+
+static int
+print_frame_local_vars (frame, stream)
+     register FRAME frame;
+     register FILE *stream;
+{
+  register struct block *block = get_frame_block (frame);
+  if (block == 0)
+    return 0;
+  while (block != 0)
+    {
+      print_block_frame_locals (block, frame, stream);
+      /* After handling the function's top-level block, stop.
+	 Don't continue to its superblock, the block of
+	 per-file symbols.  */
+      if (BLOCK_FUNCTION (block))
+	break;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+  return 1;
+}
+
+static void
+locals_info ()
+{
+  print_frame_local_vars (selected_frame, stdout);
+}
+
+static int
+print_frame_arg_vars (frame, stream)
+     register FRAME frame;
+     register FILE *stream;
+{
+  struct symbol *func = get_frame_function (frame);
+  register struct block *b;
+  int nsyms;
+  register int i;
+  register struct symbol *sym;
+
+  if (func == 0)
+    return 0;
+
+  b = SYMBOL_BLOCK_VALUE (func);
+  nsyms = BLOCK_NSYMS (b);
+
+  for (i = 0; i < nsyms; i++)
+    {
+      sym = BLOCK_SYM (b, i);
+      if (SYMBOL_CLASS (sym) == LOC_ARG)
+	{
+	  fprintf (stream, "%s = ", SYMBOL_NAME (sym));
+	  print_variable_value (sym, frame, stream);
+	  fprintf (stream, "\n");
+	  fflush (stream);
+	}
+    }
+
+  return 1;
+}
+
+static void
+args_info ()
+{
+  print_frame_arg_vars (selected_frame, stdout);
+}
+
+/* Select frame FRAME, and note that its stack level is LEVEL.
+   LEVEL may be -1 if an actual level number is not known.  */
+
+void
+select_frame (frame, level)
+     FRAME frame;
+     int level;
+{
+  selected_frame = frame;
+  selected_frame_level = level;
+}
+
+/* Store the selected frame and its level into *FRAMEP and *LEVELP.  */
+
+void
+record_selected_frame (framep, levelp)
+     FRAME *framep;
+     int *levelp;
+{
+  *framep = selected_frame;
+  *levelp = selected_frame_level;
+}
+
+/* Return the symbol-block in which the selected frame is executing.
+   Can return zero under various legitimate circumstances.  */
+
+struct block *
+get_selected_block ()
+{
+  if (!have_inferior_p () && !have_core_file_p ())
+    return 0;
+
+  if (!selected_frame)
+    return get_current_block ();
+  return get_frame_block (selected_frame);
+}
+
+/* Find a frame a certain number of levels away from FRAME.
+   LEVEL_OFFSET_PTR points to an int containing the number of levels.
+   Positive means go to earlier frames (up); negative, the reverse.
+   The int that contains the number of levels is counted toward
+   zero as the frames for those levels are found.
+   If the top or bottom frame is reached, that frame is returned,
+   but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
+   how much farther the original request asked to go.  */
+
+FRAME
+find_relative_frame (frame, level_offset_ptr)
+     register FRAME frame;
+     register int* level_offset_ptr;
+{
+  register FRAME prev;
+  struct frame_info fi;
+  register FRAME frame1, frame2;
+
+  /* Going up is simple: just do get_prev_frame enough times
+     or until initial frame is reached.  */
+  while (*level_offset_ptr > 0)
+    {
+      prev = get_prev_frame (frame);
+      if (prev == 0)
+	break;
+      (*level_offset_ptr)--;
+      frame = prev;
+    }
+  /* Going down could be done by iterating get_frame_info to
+     find the next frame, but that would be quadratic
+     since get_frame_info must scan all the way from the current frame.
+     The following algotithm is linear.  */
+  if (*level_offset_ptr < 0)
+    {
+      /* First put frame1 at innermost frame
+	 and frame2 N levels up from there.  */
+      frame1 = get_current_frame ();
+      frame2 = frame1;
+      while (*level_offset_ptr < 0 && frame2 != frame)
+	{
+	  frame2 = get_prev_frame (frame2);
+	  (*level_offset_ptr) ++;
+	}
+      /* Then slide frame1 and frame2 up in synchrony
+	 and when frame2 reaches our starting point
+	 frame1 must be N levels down from there.  */
+      while (frame2 != frame)
+	{
+	  frame1 = get_prev_frame (frame1);
+	  frame2 = get_prev_frame (frame2);
+	}
+      return frame1;
+    }
+  return frame;
+}
+
+/* The "frame" command.  With no arg, print selected frame briefly.
+   With arg LEVEL, select the frame at level LEVEL and print it.
+   With arg larger than 100000, use it as address of frame to select.
+   If from command file or user-defined command, don't print anything
+   if we have an argument.  */
+
+static void
+frame_command (level_exp, from_tty)
+     char *level_exp;
+     int from_tty;
+{
+  register int i;
+  register FRAME frame;
+  unsigned int level, level1;
+
+  if (level_exp)
+    {
+      level1 = level = parse_and_eval_address (level_exp);
+      if (level > 100000)
+	{
+	  select_frame (level, -1);
+	  frame_info (0);
+	  return;
+	}
+
+      frame = find_relative_frame (get_current_frame (), &level1);
+      if (level1 != 0)
+	error ("Stack level %d is out of range.", level);
+      select_frame (frame, level);
+      if (! from_tty)
+	return;
+    }
+
+  print_stack_frame (selected_frame, selected_frame_level, 1);
+}
+
+/* Select the frame up one or COUNT stack levels
+   from the previously selected frame, and print it briefly.  */
+
+static void
+up_command (count_exp)
+     char *count_exp;
+{
+  register FRAME frame;
+  int count = 1, count1;
+  if (count_exp)
+    count = parse_and_eval_address (count_exp);
+  count1 = count;
+  
+  frame = find_relative_frame (selected_frame, &count1);
+  if (count1 != 0 && count_exp == 0)
+    error ("Initial frame selected; you cannot go up.");
+  select_frame (frame, selected_frame_level + count - count1);
+
+  print_stack_frame (selected_frame, selected_frame_level, 1);
+}
+
+/* Select the frame down one or COUNT stack levels
+   from the previously selected frame, and print it briefly.  */
+
+static void
+down_command (count_exp)
+     char *count_exp;
+{
+  register FRAME frame;
+  int count = -1, count1;
+  if (count_exp)
+    count = - parse_and_eval_address (count_exp);
+  count1 = count;
+  
+  frame = find_relative_frame (selected_frame, &count1);
+  if (count1 != 0 && count_exp == 0)
+    error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
+  select_frame (frame, selected_frame_level + count - count1);
+
+  print_stack_frame (selected_frame, selected_frame_level, 1);
+}
+
+static void
+return_command (retval_exp, from_tty)
+     char *retval_exp;
+     int from_tty;
+{
+  struct symbol *thisfun = get_frame_function (selected_frame);
+
+  /* If interactive, require confirmation.  */
+
+  if (from_tty)
+    {
+      if (thisfun != 0)
+	{
+	  if (!query ("Make %s return now? ", SYMBOL_NAME (thisfun)))
+	    error ("Not confirmed.");
+	}
+      else
+	if (!query ("Make selected stack frame return now? "))
+	  error ("Not confirmed.");
+    }
+
+  /* Do the real work.  Pop until the specified frame is current.  */
+
+  while (selected_frame != get_current_frame ())
+    POP_FRAME;
+
+  /* Then pop that frame.  */
+
+  POP_FRAME;
+
+  /* Compute the return value (if any) and store in the place
+     for return values.  */
+
+  if (retval_exp)
+    set_return_value (parse_and_eval (retval_exp));
+
+  /* If interactive, print the frame that is now current.  */
+
+  if (from_tty)
+    frame_command ("0", 1);
+}
+
+static
+initialize ()
+{
+  add_com ("return", class_stack, return_command,
+	   "Make selected stack frame return to its caller.\n\
+Control remains in the debugger, but when you continue\n\
+execution will resume in the frame above the one now selected.\n\
+If an argument is given, it is an expression for the value to return.");
+
+  add_com ("up", class_stack, up_command,
+	   "Select and print stack frame that called this one.\n\
+An argument says how many frames up to go.");
+
+  add_com ("down", class_stack, down_command,
+	   "Select and print stack frame called by this one.\n\
+An argument says how many frames down to go.");
+  add_com_alias ("do", "down", class_stack, 1);
+
+  add_com ("frame", class_stack, frame_command,
+	   "Select and print a stack frame.\n\
+With no argument, print the selected stack frame.  (See also \"info frame\").\n\
+An argument specifies the frame to select.\n\
+It can be a stack frame number or the address of the frame.\n\
+With argument, nothing is printed if input is coming from\n\
+a command file or a user-defined command.");
+
+  add_com_alias ("f", "frame", class_stack, 1);
+
+  add_com ("backtrace", class_stack, backtrace_command,
+	   "Print backtrace of all stack frames, or innermost COUNT frames.");
+  add_com_alias ("bt", "backtrace", class_stack, 0);
+  add_com_alias ("where", "backtrace", class_alias, 0);
+  add_info ("stack", backtrace_command,
+	    "Backtrace of the stack, or innermost COUNT frames.");
+  add_info_alias ("s", "stack", 1);
+  add_info ("frame", frame_info,
+	    "All about selected stack frame, or frame at ADDR.");
+  add_info_alias ("f", "frame", 1);
+  add_info ("locals", locals_info,
+	    "Local variables of current stack frame.");
+  add_info ("args", args_info,
+	    "Argument variables of current stack frame.");
+}
+
+END_FILE
diff --git a/gdb/standalone.c b/gdb/standalone.c
new file mode 100644
index 0000000..94adf64
--- /dev/null
+++ b/gdb/standalone.c
@@ -0,0 +1,605 @@
+/* Interface to bare machine for GDB running as kernel debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if defined (SIGTSTP) && defined (SIGIO)
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif /* SIGTSTP and SIGIO defined (must be 4.2) */
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+#include "inferior.h"
+#include "wait.h"
+
+START_FILE
+
+/* Random system calls, mostly no-ops to prevent link problems  */
+
+ioctl (desc, code, arg)
+{}
+
+int (* signal ()) ()
+{}
+
+kill ()
+{}
+
+getpid ()
+{
+  return 0;
+}
+
+sigsetmask ()
+{}
+
+chdir ()
+{}
+
+char *
+getwd (buf)
+     char *buf;
+{
+  buf[0] = '/';
+  buf[1] = 0;
+  return buf;
+}
+
+/* Used to check for existence of .gdbinit.  Say no.  */
+
+access ()
+{
+  return -1;
+}
+
+exit ()
+{
+  error ("Fatal error; restarting.");
+}
+
+/* Reading "files".  The contents of some files are written into kdb's
+   data area before it is run.  These files are used to contain the
+   symbol table for kdb to load, and the source files (in case the
+   kdb user wants to print them).  The symbols are stored in a file
+   named "kdb-symbols" in a.out format (except that all the text and
+   data have been stripped to save room).
+
+   The files are stored in the following format:
+   int     number of bytes of data for this file, including these four.
+   char[]  name of the file, ending with a null.
+   padding to multiple of 4 boundary.
+   char[]  file contents.  The length can be deduced from what was
+           specified before.  There is no terminating null here.
+
+   If the int at the front is zero, it means there are no more files.
+
+   Opening a file in kdb returns a nonzero value to indicate success,
+   but the value does not matter.  Only one file can be open, and only
+   for reading.  All the primitives for input from the file know
+   which file is open and ignore what is specified for the descriptor
+   or for the stdio stream.
+
+   Input with fgetc can be done either on the file that is open
+   or on stdin (which reads from the terminal through tty_input ()  */
+
+/* Address of data for the files stored in format described above.  */
+char *files_start;
+
+/* The file stream currently open:  */
+
+char *sourcebeg;		/* beginning of contents */
+int sourcesize;			/* size of contents */
+char *sourceptr;		/* current read pointer */
+int sourceleft;			/* number of bytes to eof */
+
+/* "descriptor" for the file now open.
+   Incremented at each close.
+   If specified descriptor does not match this,
+   it means the program is trying to use a closed descriptor.
+   We report an error for that.  */
+
+int sourcedesc;
+
+open (filename, modes)
+     char *filename;
+     int modes;
+{
+  register char *next;
+  extern int errno;
+
+  if (modes)
+    {
+      errno = EROFS;
+      return -1;
+    }
+
+  if (sourceptr)
+    {
+      errno = EMFILE;
+      return -1;
+    }
+
+  for (next - files_start; * (int *) next;
+       next += * (int *) next)
+    {
+      if (!strcmp (next + 4, filename))
+	{
+	  sourcebeg = next + 4 + strlen (next + 4) + 1;
+	  sourcebeg = (char *) (((int) sourcebeg + 3) & (-4));
+	  sourceptr = sourcebeg;
+	  sourcesize = next + * (int *) next - sourceptr;
+	  sourceleft = sourcesize;
+	  return sourcedesc;
+	}
+    }
+  return 0;
+}
+
+close (desc)
+     int desc;
+{
+  sourceptr = 0;
+  sourcedesc++;
+  /* Don't let sourcedesc get big enough to be confused with stdin.  */
+  if (sourcedesc == 100)
+    sourcedesc = 5;
+}
+
+FILE *
+fopen (filename, modes)
+     char *filename;
+     char *modes;
+{
+  return (FILE *) open (filename, *modes == 'w');
+}
+
+FILE *
+fdopen (desc)
+     int desc;
+{
+  return (FILE *) desc;
+}
+
+fclose (desc)
+     int desc;
+{
+  close (desc);
+}
+
+fstat (desc, statbuf)
+     struct stat *statbuf;
+{
+  extern int errno;
+
+  if (desc != sourcedesc)
+    {
+      errno = EBADF;
+      return -1;
+    }
+  statbuf->st_size = sourcesize;
+}
+
+myread (desc, destptr, size, filename)
+     int desc;
+     char *destptr;
+     int size;
+     char *filename;
+{
+  int len = min (sourceleft, size);
+  extern int errno;
+
+  if (desc != sourcedesc)
+    {
+      errno = EBADF;
+      return -1;
+    }
+
+  bcopy (sourceptr, destptr, len);
+  sourceleft -= len;
+  return len;
+}
+
+int
+fread (bufp, numelts, eltsize, stream)
+{
+  register int elts = min (numelts, sourceleft / eltsize);
+  register int len = elts * eltsize;
+  extern int errno;
+
+  if (stream != sourcedesc)
+    {
+      errno = EBADF;
+      return -1;
+    }
+
+  bcopy (sourceptr, bufp, len);
+  sourceleft -= len;
+  return elts;
+}
+
+int
+fgetc (desc)
+     int desc;
+{
+  extern int errno;
+
+  if (desc == (int) stdin)
+    return tty_input ();
+
+  if (desc != sourcedesc)
+    {
+      errno = EBADF;
+      return -1;
+    }
+
+  if (sourceleft-- <= 0)
+    return EOF;
+  return *sourceptr++;
+}
+
+lseek (desc, pos)
+     int desc;
+     int pos;
+{
+  extern int errno;
+
+  if (desc != sourcedesc)
+    {
+      errno = EBADF;
+      return -1;
+    }
+
+  if (pos < 0 || pos > sourcesize)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  sourceptr = sourcebeg + pos;
+  sourceleft = sourcesize - pos;
+}
+
+/* Output in kdb can go only to the terminal, so the stream
+   specified may be ignored.  */
+
+printf (a1, a2, a3, a4, a5, a6, a7, a8, a9)
+{
+  char buffer[1024];
+  sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  display_string (buffer);
+}
+
+fprintf (ign, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+{
+  char buffer[1024];
+  sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  display_string (buffer);
+}
+
+fwrite (buf, numelts, size, stream)
+     register char *buf;
+     int numelts, size;
+{
+  register int i = numelts * size;
+  while (i-- > 0)
+    fputc (*buf++, stream);
+}
+
+fputc (c, ign)
+{
+  char buf[2];
+  buf[0] = c;
+  buf[1] = 0;
+  display_string (buf);
+}
+
+/* sprintf refers to this, but loading this from the
+   library would cause fflush to be loaded from it too.
+   In fact there should be no need to call this (I hope).  */
+
+_flsbuf ()
+{
+  error ("_flsbuf was actually called.");
+}
+
+fflush (ign)
+{
+}
+
+/* Entries into core and inflow, needed only to make things link ok.  */
+
+exec_file_command ()
+{}
+
+core_file_command ()
+{}
+
+char *
+get_exec_file ()
+{
+  /* Makes one printout look reasonable; value does not matter otherwise.  */
+  return "run";
+}
+
+have_core_file_p ()
+{
+  return 0;
+}
+
+kill_command ()
+{
+  inferior_pid = 0;
+}
+
+terminal_inferior ()
+{}
+
+terminal_ours ()
+{}
+
+terminal_init_inferior ()
+{}
+
+write_inferior_register ()
+{}
+
+read_inferior_register ()
+{}
+
+read_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  bcopy (memaddr, myaddr, len);
+}
+
+/* Always return 0 indicating success.  */
+
+write_memory (memaddr, myaddr, len)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+{
+  bcopy (myaddr, memaddr, len);
+  return 0;
+}
+
+static REGISTER_TYPE saved_regs[NUM_REGS];
+
+REGISTER_TYPE
+read_register (regno)
+     int regno;
+{
+  if (regno < 0 || regno >= NUM_REGS)
+    error ("Register number %d out of range.", regno);
+  return saved_regs[regno];
+}
+
+void
+write_register (regno, value)
+     int regno;
+     REGISTER_TYPE value;
+{
+  if (regno < 0 || regno >= NUM_REGS)
+    error ("Register number %d out of range.", regno);
+  saved_regs[regno] = value;
+}
+
+/* System calls needed in relation to running the "inferior".  */
+
+vfork ()
+{
+  /* Just appear to "succeed".  Say the inferior's pid is 1.  */
+  return 1;
+}
+
+/* These are called by code that normally runs in the inferior
+   that has just been forked.  That code never runs, when standalone,
+   and these definitions are so it will link without errors.  */
+
+ptrace ()
+{}
+
+setpgrp ()
+{}
+
+execle ()
+{}
+
+_exit ()
+{}
+
+/* Malloc calls these.  */
+
+malloc_warning (str)
+     char *str;
+{
+  printf ("\n%s.\n\n", str);
+}
+
+char *next_free;
+char *memory_limit;
+
+char *
+sbrk (amount)
+     int amount;
+{
+  if (next_free + amount > memory_limit)
+    return (char *) -1;
+  next_free += amount;
+  return next_free - amount;
+}
+
+/* Various ways malloc might ask where end of memory is.  */
+
+char *
+ulimit ()
+{
+  return memory_limit;
+}
+
+int
+vlimit ()
+{
+  return memory_limit - next_free;
+}
+
+getrlimit (addr)
+     struct rlimit *addr;
+{
+  addr->rlim_cur = memory_limit - next_free;
+}
+
+/* Context switching to and from program being debugged.  */
+
+/* GDB calls here to run the user program.
+   The frame pointer for this function is saved in
+   gdb_stack by save_frame_pointer; then we restore
+   all of the user program's registers, including PC and PS.  */
+
+static int fault_code;
+static REGISTER_TYPE gdb_stack;
+
+resume ()
+{
+  REGISTER_TYPE restore[NUM_REGS];
+
+  PUSH_FRAME_PTR;
+  save_frame_pointer ();
+
+  bcopy (saved_regs, restore, sizeof restore);
+  POP_REGISTERS;
+  /* Control does not drop through here!  */
+}
+
+save_frame_pointer (val)
+     CORE_ADDR val;
+{
+  gdb_stack = val;
+}
+
+/* Fault handlers call here, running in the user program stack.
+   They must first push a fault code,
+   old PC, old PS, and any other info about the fault.
+   The exact format is machine-dependent and is known only
+   in the definition of PUSH_REGISTERS.  */
+
+fault ()
+{
+  /* Transfer all registers and fault code to the stack
+     in canonical order: registers in order of GDB register number,
+     followed by fault code.  */
+  PUSH_REGISTERS;
+
+  /* Transfer them to saved_regs and fault_code.  */
+  save_registers ();
+
+  restore_gdb ();
+  /* Control does not reach here */
+}
+
+restore_gdb ()
+{
+  CORE_ADDR new_fp = gdb_stack;
+  /* Switch to GDB's stack  */
+  POP_FRAME_PTR;
+  /* Return from the function `resume'.  */
+}
+
+/* Assuming register contents and fault code have been pushed on the stack as
+   arguments to this function, copy them into the standard place
+   for the program's registers while GDB is running.  */
+
+save_registers (firstreg)
+     int firstreg;
+{
+  bcopy (&firstreg, saved_regs, sizeof saved_regs);
+  fault_code = (&firstreg)[NUM_REGS];
+}
+
+/* Store into the structure such as `wait' would return
+   the information on why the program faulted,
+   converted into a machine-independent signal number.  */
+
+static int fault_table[] = FAULT_TABLE;
+
+int
+wait (w)
+     WAITTYPE *w;
+{
+  WSETSTOP (*w, fault_table[fault_code / FAULT_CODE_UNITS]);
+  return inferior_pid;
+}
+
+/* Allocate a big space in which files for kdb to read will be stored.
+   Whatever is left is where malloc can allocate storage.
+
+   Initialize it, so that there will be space in the executable file
+   for it.  Then the files can be put into kdb by writing them into
+   kdb's executable file.  */
+
+/* The default size is as much space as we expect to be available
+   for kdb to use!  */
+
+#ifndef HEAP_SIZE
+#define HEAP_SIZE 400000
+#endif
+
+char heap[HEAP_SIZE] = {0};
+
+#ifndef STACK_SIZE
+#define STACK_SIZE 100000
+#endif
+
+int kdb_stack_beg[STACK_SIZE / sizeof (int)];
+int kdb_stack_end;
+
+static
+initialize ()
+{
+  register char *next;
+
+  /* Find start of data on files.  */
+
+  files_start = heap;
+
+  /* Find the end of the data on files.  */
+
+  for (next - files_start; * (int *) next;
+       next += * (int *) next)
+    {}
+
+  /* That is where free storage starts for sbrk to give out.  */
+  next_free = next;
+
+  memory_limit = heap + sizeof heap;
+}
+
+END_FILE
diff --git a/gdb/stuff.c b/gdb/stuff.c
new file mode 100644
index 0000000..0f0a503
--- /dev/null
+++ b/gdb/stuff.c
@@ -0,0 +1,168 @@
+/* Program to stuff files into a specially prepared space in kdb.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Written 13-Mar-86 by David Bridgham. */
+
+#include <stdio.h>
+#include <a.out.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+
+extern char *sys_errlist[];
+extern int errno;
+
+main (argc, argv)
+     int argc;
+     char *argv[];
+{
+  register char *cp;
+  char *outfile;
+  register int i;
+  int offset;
+  int out_fd, in_fd;
+  struct stat stat_buf;
+  int size, pad;
+  char buf[1024];
+  static char zeros[4] = {0};
+
+  if (argc < 4)
+    err("Not enough arguments\nUsage: %s -o kdb file1 file2 ...\n",
+	argv[0]);
+
+  outfile = 0;
+  for (i = 1; i < argc; i++)
+    {
+      if (strcmp (argv[i], "-o") == 0)
+	outfile = argv[++i];
+    }
+  if (outfile == 0)
+    err("Output file not specified\n");
+
+  offset = get_offset (outfile, "_heap");
+
+  out_fd = open (outfile, O_WRONLY);
+  if (out_fd < 0)
+    err ("Error opening %s for write: %s\n", outfile, sys_errlist[errno]);
+  if (lseek (out_fd, offset, 0) < 0)
+    err ("Error seeking to heap in %s: %s\n", outfile, sys_errlist[errno]);
+
+  /* For each file listed on the command line, write it into the
+   * 'heap' of the output file.  Make sure to skip the arguments
+   * that name the output file. */
+  for (i = 1; i < argc; i++)
+    {
+      if (strcmp (argv[i], "-o") == 0)
+	continue;
+      if ((in_fd = open (argv[i], O_RDONLY)) < 0)
+	err ("Error opening %s for read: %s\n", argv[i], sys_errlist[errno]);
+      if (fstat (in_fd, &stat_buf) < 0)
+	err ("Error stat'ing %s: %s\n", argv[i], sys_errlist[errno]);
+      size = strlen (argv[i]);
+      pad = 4 - (size & 3);
+      size += pad + stat_buf.st_size + sizeof (int);
+      write (out_fd, &size, sizeof (int));
+      write (out_fd, argv[i], strlen (argv[i]));
+      write (out_fd, zeros, pad);
+      while ((size = read (in_fd, buf, sizeof (buf))) > 0)
+	write (out_fd, buf, size);
+      close (in_fd);
+    }
+  size = 0;
+  write (out_fd, &size, sizeof (int));
+  close (out_fd);
+  return (0);
+}
+
+/* Read symbol table from file and returns the offset into the file
+ * where symbol sym_name is located.  If error, print message and
+ * exit. */
+get_offset (file, sym_name)
+     char *file;
+     char *sym_name;
+{
+  int f;
+  struct exec file_hdr;
+  struct nlist *symbol_table;
+  int size;
+  char *strings;
+
+  f = open (file, O_RDONLY);
+  if (f < 0)
+    err ("Error opening %s: %s\n", file, sys_errlist[errno]);
+  if (read (f, &file_hdr, sizeof (file_hdr)) < 0)
+    err ("Error reading exec structure: %s\n", sys_errlist[errno]);
+  if (N_BADMAG (file_hdr))
+    err ("File %s not an a.out file\n", file);
+
+  /* read in symbol table */
+  if ((symbol_table = (struct nlist *)malloc (file_hdr.a_syms)) == 0)
+    err ("Couldn't allocate space for symbol table\n");
+  if (lseek (f, N_SYMOFF (file_hdr), 0) == -1)
+    err ("lseek error: %s\n", sys_errlist[errno]);
+  if (read (f, symbol_table, file_hdr.a_syms) == -1)
+    err ("Error reading symbol table from %s: %s\n", file, sys_errlist[errno]);
+
+  /* read in string table */
+  if (read (f, &size, 4) == -1)
+    err ("reading string table size: %s\n", sys_errlist[errno]);
+  if ((strings = (char *)malloc (size)) == 0)
+    err ("Couldn't allocate memory for string table\n");
+  if (read (f, strings, size - 4) == -1)
+    err ("reading string table: %s\n", sys_errlist[errno]);
+
+  /* Find the core address at which the first byte of kdb text segment
+     should be loaded into core when kdb is run.  */
+  origin = find_symbol ("_etext", symbol_table, file_hdr.a_syms, strings)
+    - file_hdr.a_text;
+  /* Find the core address at which the heap will appear.  */
+  coreaddr = find_symbol (sym_name, symbol_table, file_hdr.a_syms, strings);
+  /* Return address in file of the heap data space.  */
+  return (N_TXTOFF (file_hdr) + core_addr - origin);
+}
+
+find_symbol (sym_name, symbol_table, length, strings)
+     char *sym_name;
+     struct nlist *symbol_table;
+     int length;
+     char *strings;
+{
+  register struct nlist *sym;
+
+  /* Find symbol in question */
+  for (sym = symbol_table;
+       sym != (struct nlist *)((char *)symbol_table + length);
+       sym++)
+      {
+	if ((sym->n_type & N_TYPE) != N_DATA) continue;
+	if (sym->n_un.n_strx == 0) continue;
+	if (strcmp (sym_name, strings + sym->n_un.n_strx - 4) == 0)
+	  return sym->n_value;
+      }
+    err ("Data symbol %s not found in %s\n", sym_name, file);
+}
+
+err (msg, a1, a2, a3)
+     char *msg;
+     int a1, a2, a3;
+{
+  fprintf (stderr, msg, a1, a2, a3);
+  exit (-1);
+}
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
new file mode 100644
index 0000000..d17cbdd
--- /dev/null
+++ b/gdb/symmisc.c
@@ -0,0 +1,535 @@
+/* Do various things to symbol tables (other than lookup)), for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+
+#include <stdio.h>
+#include <obstack.h>
+
+static void free_symtab ();
+
+START_FILE
+
+/* Free all the symtabs that are currently installed,
+   and all storage associated with them.
+   Leaves us in a consistent state with no symtabs installed.  */
+
+void
+free_all_symtabs ()
+{
+  register struct symtab *s, *snext;
+
+  /* All values will be invalid because their types will be!  */
+
+  clear_value_history ();
+  clear_displays ();
+  clear_internalvars ();
+  clear_breakpoints ();
+  set_default_breakpoint (0, 0, 0, 0);
+
+  current_source_symtab = 0;
+
+  for (s = symtab_list; s; s = snext)
+    {
+      snext = s->next;
+      free_symtab (s);
+    }
+  symtab_list = 0;
+  obstack_free (symbol_obstack, 0);
+  obstack_init (symbol_obstack);
+
+  if (misc_function_vector)
+    free (misc_function_vector);
+  misc_function_count = 0;
+  misc_function_vector = 0;
+}
+
+/* Free a struct block <- B and all the symbols defined in that block.  */
+
+static void
+free_symtab_block (b)
+     struct block *b;
+{
+  register int i, n;
+  n = BLOCK_NSYMS (b);
+  for (i = 0; i < n; i++)
+    {
+      free (SYMBOL_NAME (BLOCK_SYM (b, i)));
+      free (BLOCK_SYM (b, i));
+    }
+  free (b);
+}
+
+/* Free all the storage associated with the struct symtab <- S.
+   Note that some symtabs have contents malloc'ed structure by structure,
+   while some have contents that all live inside one big block of memory,
+   and some share the contents of another symbol table and so you should
+   not free the contents on their behalf (except sometimes the linetable,
+   which maybe per symtab even when the rest is not).
+   It is s->free_code that says which alternative to use.  */
+
+static void
+free_symtab (s)
+     register struct symtab *s;
+{
+  register int i, n;
+  register struct blockvector *bv;
+  register struct type *type;
+  register struct typevector *tv;
+
+  switch (s->free_code)
+    {
+    case free_nothing:
+      /* All the contents are part of a big block of memory
+	 and some other symtab is in charge of freeing that block.
+	 Therefore, do nothing.  */
+      break;
+
+    case free_explicit:
+      /* All the contents are part of a big block of memory
+	 and that is our `free_ptr' and will be freed below.  */
+      break;
+
+    case free_contents:
+      /* Here all the contents were malloc'ed structure by structure
+	 and must be freed that way.  */
+      /* First free the blocks (and their symbols.  */
+      bv = BLOCKVECTOR (s);
+      n = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < n; i++)
+	free_symtab_block (BLOCKVECTOR_BLOCK (bv, i));
+      /* Free the blockvector itself.  */
+      free (bv);
+      /* Free the type vector.  */
+      tv = TYPEVECTOR (s);
+      if (tv)		/* FIXME, should this happen?  It does... */
+	free (tv);
+      /* Also free the linetable.  */
+      
+    case free_linetable:
+      /* Everything will be freed either by our `free_ptr'
+	 or by some other symbatb, except for our linetable.
+	 Free that now.  */
+      free (LINETABLE (s));
+      break;
+    }
+
+  /* If there is a single block of memory to free, free it.  */
+  if (s->free_ptr)
+    free (s->free_ptr);
+
+  if (s->line_charpos)
+    free (s->line_charpos);
+  free (s->filename);
+  free (s);
+}
+
+/* Convert a raw symbol-segment to a struct symtab,
+   and relocate its internal pointers so that it is valid.  */
+
+/* This is how to relocate one pointer, given a name for it.
+   Works independent of the type of object pointed to.  */
+#define RELOCATE(slot) (slot ? (* (char **) &slot += relocation) : 0)
+
+/* This is the inverse of RELOCATE.  We use it when storing
+   a core address into a slot that has yet to be relocated.  */
+#define UNRELOCATE(slot) (slot ? (* (char **) &slot -= relocation) : 0)
+
+/* During the process of relocation, this holds the amount to relocate by
+   (the address of the file's symtab data, in core in the debugger).  */
+static int relocation;
+
+#define CORE_RELOCATE(slot) \
+  ((slot) += (((slot) < data_start) ? text_relocation		\
+	      : ((slot) < bss_start) ? data_relocation : bss_relocation))
+
+#define TEXT_RELOCATE(slot)  ((slot) += text_relocation)
+
+/* Relocation amounts for addresses in the program's core image.  */
+static int text_relocation, data_relocation, bss_relocation;
+
+/* Boundaries that divide program core addresses into text, data and bss;
+   used to determine which relocation amount to use.  */
+static int data_start, bss_start;
+
+static void relocate_typevector ();
+static void relocate_blockvector ();
+static void relocate_type ();
+static void relocate_block ();
+static void relocate_symbol ();
+
+/* Relocate a file symbol table so that all the pointers
+   are valid C pointers.  Pass the struct symtab for the file
+   and the amount to relocate by.  */
+
+static struct symtab *
+relocate_symtab (root)
+     struct symbol_root *root;
+{
+  struct symtab *sp = (struct symtab *) xmalloc (sizeof (struct symtab));
+  bzero (sp, sizeof (struct symtab));
+
+  relocation = (int) root;
+  text_relocation = root->textrel;
+  data_relocation = root->datarel;
+  bss_relocation = root->bssrel;
+  data_start = root->databeg;
+  bss_start = root->bssbeg;
+
+  sp->filename = root->filename;
+  sp->ldsymoff = root->ldsymoff;
+  sp->language = root->language;
+  sp->compilation = root->compilation;
+  sp->version = root->version;
+  sp->blockvector = root->blockvector;
+  sp->typevector = root->typevector;
+  sp->free_code = free_explicit;
+  sp->free_ptr = (char *) root;
+
+  RELOCATE (TYPEVECTOR (sp));
+  RELOCATE (BLOCKVECTOR (sp));
+  RELOCATE (sp->version);
+  RELOCATE (sp->compilation);
+  RELOCATE (sp->filename);
+
+  relocate_typevector (TYPEVECTOR (sp));
+  relocate_blockvector (BLOCKVECTOR (sp));
+
+  return sp;
+}
+
+static void
+relocate_typevector (tv)
+     struct typevector *tv;
+{
+  register int ntypes = TYPEVECTOR_NTYPES (tv);
+  register int i;
+
+  for (i = 0; i < ntypes; i++)
+    RELOCATE (TYPEVECTOR_TYPE (tv, i));
+  for (i = 0; i < ntypes; i++)
+    relocate_type (TYPEVECTOR_TYPE (tv, i));
+}
+
+static void
+relocate_blockvector (blp)
+     register struct blockvector *blp;
+{
+  register int nblocks = BLOCKVECTOR_NBLOCKS (blp);
+  register int i;
+  for (i = 0; i < nblocks; i++)
+    RELOCATE (BLOCKVECTOR_BLOCK (blp, i));
+  for (i = 0; i < nblocks; i++)
+    relocate_block (BLOCKVECTOR_BLOCK (blp, i));
+}
+
+static void
+relocate_block (bp)
+     register struct block *bp;
+{
+  register int nsyms = BLOCK_NSYMS (bp);
+  register int i;
+
+  TEXT_RELOCATE (BLOCK_START (bp));
+  TEXT_RELOCATE (BLOCK_END (bp));
+
+  /* These two should not be recursively processed.
+     The superblock need not be because all blocks are
+     processed from relocate_blockvector.
+     The function need not be because it will be processed
+     under the block which is its scope.  */
+  RELOCATE (BLOCK_SUPERBLOCK (bp));
+  RELOCATE (BLOCK_FUNCTION (bp));
+
+  for (i = 0; i < nsyms; i++)
+    RELOCATE (BLOCK_SYM (bp, i));
+
+  for (i = 0; i < nsyms; i++)
+    relocate_symbol (BLOCK_SYM (bp, i));
+}
+
+static void
+relocate_symbol (sp)
+     register struct symbol *sp;
+{
+  RELOCATE (SYMBOL_NAME (sp));
+  if (SYMBOL_CLASS (sp) == LOC_BLOCK)
+    {
+      RELOCATE (SYMBOL_BLOCK_VALUE (sp));
+      /* We can assume the block that belongs to this symbol
+	 is not relocated yet, since it comes after
+	 the block that contains this symbol.  */
+      BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)) = sp;
+      UNRELOCATE (BLOCK_FUNCTION (SYMBOL_BLOCK_VALUE (sp)));
+    }
+  else if (SYMBOL_CLASS (sp) == LOC_STATIC)
+    CORE_RELOCATE (SYMBOL_VALUE (sp));
+  else if (SYMBOL_CLASS (sp) == LOC_LABEL)
+    TEXT_RELOCATE (SYMBOL_VALUE (sp));
+  RELOCATE (SYMBOL_TYPE (sp));
+}
+
+/* We cannot come up with an a priori spanning tree
+   for the network of types, since types can be used
+   for many symbols and also as components of other types.
+   Therefore, we need to be able to mark types that we
+   already have relocated (or are already in the middle of relocating)
+   as in a garbage collector.  */
+
+static void
+relocate_type (tp)
+     register struct type *tp;
+{
+  register int nfields = TYPE_NFIELDS (tp);
+  register int i;
+
+  RELOCATE (TYPE_NAME (tp));
+  RELOCATE (TYPE_TARGET_TYPE (tp));
+  RELOCATE (TYPE_FIELDS (tp));
+  RELOCATE (TYPE_POINTER_TYPE (tp));
+
+  for (i = 0; i < nfields; i++)
+    {
+      RELOCATE (TYPE_FIELD_TYPE (tp, i));
+      RELOCATE (TYPE_FIELD_NAME (tp, i));
+    }
+}
+
+/* Read symsegs from file named NAME open on DESC,
+   make symtabs from them, and return a chain of them.
+   Assumes DESC is prepositioned at the end of the string table,
+   just before the symsegs if there are any.  */
+
+struct symtab *
+read_symsegs (desc, name)
+     int desc;
+     char *name;
+{
+  struct symbol_root root;
+  register char *data;
+  register struct symtab *sp, *chain = 0;
+  register int len;
+
+  while (1)
+    {
+      len = myread (desc, &root, sizeof root);
+      if (len == 0 || root.format == 0)
+	break;
+      if (root.format != 1 ||
+	  root.length < sizeof root)
+	error ("Invalid symbol segment format code");
+      data = (char *) xmalloc (root.length);
+      bcopy (&root, data, sizeof root);
+      len = myread (desc, data + sizeof root,
+		    root.length - sizeof root);
+      sp = relocate_symtab (data);
+      sp->next = chain;
+      chain = sp;
+    }
+
+  return chain;
+}
+
+static int block_depth ();
+static void print_spaces ();
+static void print_symbol ();
+
+print_symtabs (filename)
+     char *filename;
+{
+  FILE *outfile;
+  register struct symtab *s;
+  register int i, j;
+  int len, line, blen;
+  register struct linetable *l;
+  struct blockvector *bv;
+  register struct block *b;
+  int depth;
+  struct cleanup *cleanups;
+  extern int fclose();
+
+  if (filename == 0)
+    error_no_arg ("file to write symbol data in");
+  outfile = fopen (filename, "w");
+
+  cleanups = make_cleanup (fclose, outfile);
+  immediate_quit++;
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      /* First print the line table.  */
+      fprintf (outfile, "Symtab for file %s\n\n", s->filename);
+      fprintf (outfile, "Line table:\n\n");
+      l = LINETABLE (s);
+      len = l->nitems;
+      for (i = 0; i < len; i++)
+	{
+	  if (l->item[i] < 0)
+	    line = - l->item[i] - 1;
+	  else
+	    fprintf (outfile, " line %d at %x\n", ++line, l->item[i]);
+	}
+      /* Now print the block info.  */
+      fprintf (outfile, "\nBlockvector:\n\n");
+      bv = BLOCKVECTOR (s);
+      len = BLOCKVECTOR_NBLOCKS (bv);
+      for (i = 0; i < len; i++)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, i);
+	  depth = block_depth (b) * 2;
+	  print_spaces (depth, outfile);
+	  fprintf (outfile, "block #%03d (object 0x%x) ", i, b);
+	  fprintf (outfile, "[0x%x..0x%x]", BLOCK_START (b), BLOCK_END (b));
+	  if (BLOCK_SUPERBLOCK (b))
+	    fprintf (outfile, " (under 0x%x)", BLOCK_SUPERBLOCK (b));
+	  if (BLOCK_FUNCTION (b))
+	    fprintf (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
+	  fputc ('\n', outfile);
+	  blen = BLOCK_NSYMS (b);
+	  for (j = 0; j < blen; j++)
+	    {
+	      print_symbol (BLOCK_SYM (b, j), depth + 1, outfile);
+	    }
+	}
+
+      fprintf (outfile, "\n\n");
+    }
+
+  immediate_quit--;
+  do_cleanups (cleanups);
+}
+
+static void
+print_symbol (symbol, depth, outfile)
+     struct symbol *symbol;
+     int depth;
+     FILE *outfile;
+{
+  print_spaces (depth, outfile);
+  if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
+    {
+      fprintf (outfile, "label %s at 0x%x", SYMBOL_NAME (symbol),
+	       SYMBOL_VALUE (symbol));
+      return;
+    }
+  if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
+    {
+      if (TYPE_NAME (SYMBOL_TYPE (symbol)))
+	{
+	  type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+	}
+      else
+	{
+	  fprintf (outfile, "%s %s = ",
+	       (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
+		? "enum"
+		: (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
+		   ? "struct" : "union")),
+	       SYMBOL_NAME (symbol));
+	  type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
+	}
+      fprintf (outfile, ";\n");
+    }
+  else
+    {
+      if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
+	fprintf (outfile, "typedef ");
+      if (SYMBOL_TYPE (symbol))
+	{
+	  type_print_1 (SYMBOL_TYPE (symbol), SYMBOL_NAME (symbol),
+			outfile, 1, depth);
+	  fprintf (outfile, "; ");
+	}
+      else
+	fprintf (outfile, "%s ", SYMBOL_NAME (symbol));
+
+      switch (SYMBOL_CLASS (symbol))
+	{
+	case LOC_CONST:
+	  fprintf (outfile, "const %d (0x%x),",
+		   SYMBOL_VALUE (symbol), SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_CONST_BYTES:
+	  fprintf (outfile, "const %d hex bytes:",
+		   TYPE_LENGTH (SYMBOL_TYPE (symbol)));
+	  {
+	    int i;
+	    for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
+	      fprintf (outfile, " %2x", SYMBOL_VALUE_BYTES (symbol) [i]);
+	    fprintf (outfile, ",");
+	  }
+	  break;
+
+	case LOC_STATIC:
+	  fprintf (outfile, "static at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_REGISTER:
+	  fprintf (outfile, "register %d,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_ARG:
+	  fprintf (outfile, "arg at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_LOCAL:
+	  fprintf (outfile, "local at 0x%x,", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_TYPEDEF:
+	  break;
+
+	case LOC_LABEL:
+	  fprintf (outfile, "label at 0x%x", SYMBOL_VALUE (symbol));
+	  break;
+
+	case LOC_BLOCK:
+	  fprintf (outfile, "block (object 0x%x) starting at 0x%x,",
+		   SYMBOL_VALUE (symbol),
+		   BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)));
+	  break;
+	}
+    }
+  fprintf (outfile, "\n");
+}
+
+/* Return the nexting depth of a block within other blocks in its symtab.  */
+
+static int
+block_depth (block)
+     struct block *block;
+{
+  register int i = 0;
+  while (block = BLOCK_SUPERBLOCK (block)) i++;
+  return i;
+}
+
+static
+initialize ()
+{
+  add_com ("printsyms", class_obscure, print_symtabs,
+	   "Print dump of current symbol definitions to file OUTFILE.");
+}
+
+END_FILE
diff --git a/gdb/symseg.h b/gdb/symseg.h
new file mode 100644
index 0000000..11f4807
--- /dev/null
+++ b/gdb/symseg.h
@@ -0,0 +1,323 @@
+/* GDB symbol table format definitions.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Format of GDB symbol table data.
+   There is one symbol segment for each source file or
+   independant compilation.  These segments are simply concatenated
+   to form the GDB symbol table.  A zero word where the beginning
+   of a segment is expected indicates there are no more segments.
+
+Format of a symbol segment:
+
+   The symbol segment begins with a word containing 1
+   if it is in the format described here.  Other formats may
+   be designed, with other code numbers.
+
+   The segment contains many objects which point at each other.
+   The pointers are offsets in bytes from the beginning of the segment.
+   Thus, each segment can be loaded into core and its pointers relocated
+   to make valid in-core pointers.
+
+   All the data objects in the segment can be found indirectly from
+   one of them, the root object, of type `struct symbol_root'.
+   It appears at the beginning of the segment.
+
+   The total size of the segment, in bytes, appears as the `length'
+   field of this object.  This size includes the size of the
+   root object.
+
+   All the object data types are defined here to contain pointer types
+   appropriate for in-core use on a relocated symbol segment.
+   Casts to and from type int are required for working with
+   unrelocated symbol segments such as are found in the file.
+
+   The ldsymaddr word is filled in by the loader to contain
+   the offset (in bytes) within the ld symbol table
+   of the first nonglobal symbol from this compilation.
+   This makes it possible to match those symbols
+   (which contain line number information) reliably with
+   the segment they go with.
+
+   Core addresses within the program that appear in the symbol segment
+   are not relocated by the loader.  They are inserted by the assembler
+   and apply to addresses as output by the assembler, so GDB must
+   relocate them when it loads the symbol segment.  It gets the information
+   on how to relocate from the textrel, datarel, bssrel, databeg and bssbeg
+   words of the root object.
+
+   The words textrel, datarel and bssrel
+   are filled in by ld with the amounts to relocate within-the-file
+   text, data and bss addresses by; databeg and bssbeg can be
+   used to tell which kind of relocation an address needs.  */
+
+enum language {language_c};
+
+struct symbol_root
+{
+  int format;			/* Data format version */
+  int length;			/* # bytes in this symbol segment */
+  int ldsymoff;			/* Offset in ld symtab of this file's syms */
+  int textrel;			/* Relocation for text addresses */
+  int datarel;			/* Relocation for data addresses */
+  int bssrel;			/* Relocation for bss addresses */
+  char *filename;		/* Name of source file compiled */
+  char *filedir;		/* Name of directory it was reached from */
+  struct blockvector *blockvector; /* Vector of all symbol naming blocks */
+  struct typevector *typevector; /* Vector of all data types */
+  enum language language;	/* Code identifying the language used */
+  char *version;		/* Version info.  Not fully specified */
+  char *compilation;		/* Compilation info.  Not fully specified */
+  int databeg;			/* Address within the file of data start */
+  int bssbeg;			/* Address within the file of bss start */
+};
+
+/* All data types of symbols in the compiled program
+   are represented by `struct type' objects.
+   All of these objects are pointed to by the typevector.
+   The type vector may have empty slots that contain zero.  */
+
+struct typevector
+{
+  int length;
+  struct type *type[1];
+};
+
+/* Different kinds of data types are distinguished by the `code' field.  */
+
+enum type_code
+{
+  TYPE_CODE_UNDEF,		/* Not used; catches errors */
+  TYPE_CODE_PTR,		/* Pointer type */
+  TYPE_CODE_ARRAY,		/* Array type, lower bound zero */
+  TYPE_CODE_STRUCT,		/* C struct or Pascal record */
+  TYPE_CODE_UNION,		/* C union or Pascal variant part */
+  TYPE_CODE_ENUM,		/* Enumeration type */
+  TYPE_CODE_FUNC,		/* Function type */
+  TYPE_CODE_INT,		/* Integer type */
+  TYPE_CODE_FLT,		/* Floating type */
+  TYPE_CODE_VOID,		/* Void type (values zero length) */
+  TYPE_CODE_SET,		/* Pascal sets */
+  TYPE_CODE_RANGE,		/* Range (integers within spec'd bounds) */
+  TYPE_CODE_PASCAL_ARRAY,	/* Array with explicit type of index */
+};
+
+/* This appears in a type's flags word for an unsigned integer type.  */
+#define TYPE_FLAG_UNSIGNED 1
+
+/* Other flag bits are used with GDB.  */
+
+struct type
+{
+  /* Code for kind of type */
+  enum type_code code;
+  /* Name of this type, or zero if none.
+     This is used for printing only.
+     Type names specified as input are defined by symbols.  */
+  char *name;
+  /* Length in bytes of storage for a value of this type */
+  int length;
+  /* For a pointer type, describes the type of object pointed to.
+     For an array type, describes the type of the elements.
+     For a function type, describes the type of the value.
+     Unused otherwise.  */
+  struct type *target_type;
+  /* Type that is a pointer to this type.
+     Zero if no such pointer-to type is known yet.
+     The debugger may add the address of such a type
+     if it has to construct one later.  */ 
+  struct type *pointer_type;
+  /* Type that is a function returning this type.
+     Zero if no such function type is known here.
+     The debugger may add the address of such a type
+     if it has to construct one later.  */
+  struct type *function_type;
+  /* Flags about this type.  */
+  short flags;
+  /* Number of fields described for this type */
+  short nfields;
+  /* For structure and union types, a description of each field.
+     For set and pascal array types, there is one "field",
+     whose type is the domain type of the set or array.
+     For range types, there are two "fields",
+     the minimum and maximum values (both inclusive).
+     For enum types, each possible value is described by one "field".
+     For range types, there are two "fields", that record constant values
+     (inclusive) for the minimum and maximum.
+
+     Using a pointer to a separate array of fields
+     allows all types to have the same size, which is useful
+     because we can allocate the space for a type before
+     we know what to put in it.  */
+  struct field
+    {
+      /* Position of this field, counting in bits from start of
+	 containing structure.  For a function type, this is the
+	 position in the argument list of this argument.
+	 For a range bound or enum value, this is the value itself.  */
+      int bitpos;
+      /* Size of this field, in bits, or zero if not packed.
+	 For an unpacked field, the field's type's length
+	 says how many bytes the field occupies.  */
+      int bitsize;
+      /* In a struct or enum type, type of this field.
+	 In a function type, type of this argument.
+	 In an array type, the domain-type of the array.  */
+      struct type *type;
+      /* Name of field, value or argument.
+	 Zero for range bounds and array domains.  */
+      char *name;
+    } *fields;
+};
+
+/* All of the name-scope contours of the program
+   are represented by `struct block' objects.
+   All of these objects are pointed to by the blockvector.
+
+   Each block represents one name scope.
+   Each lexical context has its own block.
+
+   The first two blocks in the blockvector are special.
+   The first one contains all the symbols defined in this compilation
+   whose scope is the entire program linked together.
+   The second one contains all the symbols whose scope is the
+   entire compilation excluding other separate compilations.
+   In C, these correspond to global symbols and static symbols.
+
+   Each block records a range of core addresses for the code that
+   is in the scope of the block.  The first two special blocks
+   give, for the range of code, the entire range of code produced
+   by the compilation that the symbol segment belongs to.
+
+   The blocks appear in the blockvector
+   in order of increasing starting-address,
+   and, within that, in order of decreasing ending-address.
+
+   This implies that within the body of one function
+   the blocks appear in the order of a depth-first tree walk.  */
+
+struct blockvector
+{
+  /* Number of blocks in the list.  */
+  int nblocks;
+  /* The blocks themselves.  */
+  struct block *block[1];
+};
+
+struct block
+{
+  /* Addresses in the executable code that are in this block.
+     Note: in an unrelocated symbol segment in a file,
+     these are always zero.  They can be filled in from the
+     N_LBRAC and N_RBRAC symbols in the loader symbol table.  */
+  int startaddr, endaddr;
+  /* The symbol that names this block,
+     if the block is the body of a function;
+     otherwise, zero.
+     Note: In an unrelocated symbol segment in an object file,
+     this field may be zero even when the block has a name.
+     That is because the block is output before the name
+     (since the name resides in a higher block).
+     Since the symbol does point to the block (as its value),
+     it is possible to find the block and set its name properly.  */
+  struct symbol *function;
+  /* The `struct block' for the containing block, or 0 if none.  */
+  /* Note that in an unrelocated symbol segment in an object file
+     this pointer may be zero when the correct value should be
+     the second special block (for symbols whose scope is one compilation).
+     This is because the compiler ouptuts the special blocks at the
+     very end, after the other blocks.   */
+  struct block *superblock;
+  /* Number of local symbols.  */
+  int nsyms;
+  /* The symbols.  */
+  struct symbol *sym[1];
+};
+
+/* Represent one symbol name; a variable, constant, function or typedef.  */
+
+/* Different name spaces for symbols.  Looking up a symbol specifies
+   a namespace and ignores symbol definitions in other name spaces.
+
+   VAR_NAMESPACE is the usual namespace.
+   In C, this contains variables, function names, typedef names
+   and enum type values.
+
+   STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
+   Thus, if `struct foo' is used in a C program,
+   it produces a symbol named `foo' in the STRUCT_NAMESPACE.
+
+   LABEL_NAMESPACE may be used for names of labels (for gotos);
+   currently it is not used and labels are not recorded at all.  */
+
+/* For a non-global symbol allocated statically,
+   the correct core address cannot be determined by the compiler.
+   The compiler puts an index number into the symbol's value field.
+   This index number can be matched with the "desc" field of
+   an entry in the loader symbol table.  */
+
+enum namespace
+{
+  UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE,
+};
+
+/* An address-class says where to find the value of the symbol in core.  */
+
+enum address_class
+{
+  LOC_UNDEF,		/* Not used; catches errors */
+  LOC_CONST,		/* Value is constant int */
+  LOC_STATIC,		/* Value is at fixed address */
+  LOC_REGISTER,		/* Value is in register */
+  LOC_ARG,		/* Value is at spec'd position in arglist */
+  LOC_LOCAL,		/* Value is at spec'd pos in stack frame */
+  LOC_TYPEDEF,		/* Value not used; definition in SYMBOL_TYPE
+			   Symbols in the namespace STRUCT_NAMESPACE
+			   all have this class.  */
+  LOC_LABEL,		/* Value is address in the code */
+  LOC_BLOCK,		/* Value is address of a `struct block'.
+			   Function names have this class.  */
+  LOC_EXTERNAL,		/* Value is at address not in this compilation.
+			   This is used for .comm symbols
+			   and for extern symbols within functions.
+			   Inside GDB, this is changed to LOC_STATIC once the
+			   real address is obtained from a loader symbol.  */
+  LOC_CONST_BYTES	/* Value is a constant byte-sequence.   */
+};
+
+struct symbol
+{
+  /* Symbol name */
+  char *name;
+  /* Name space code.  */
+  enum namespace namespace;
+  /* Address class */
+  enum address_class class;
+  /* Data type of value */
+  struct type *type;
+  /* constant value, or address if static, or register number,
+     or offset in arguments, or offset in stack frame.  */
+  union
+    {
+      long value;
+      struct block *block;      /* for LOC_BLOCK */
+      char *bytes;		/* for LOC_CONST_BYTES */
+    }
+  value;
+};
diff --git a/gdb/symtab.c b/gdb/symtab.c
new file mode 100644
index 0000000..a413bfa
--- /dev/null
+++ b/gdb/symtab.c
@@ -0,0 +1,1099 @@
+/* Symbol table lookup for the GNU debugger, GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "param.h"
+
+#include <stdio.h>
+#include <obstack.h>
+
+#ifdef mac_aux
+#define REGCMP
+#endif
+
+START_FILE
+
+/* Allocate an obstack to hold objects that should be freed
+   when we load a new symbol table.
+   This includes the symbols made by dbxread
+   and the types that are not permanent.  */
+
+struct obstack obstack1;
+
+struct obstack *symbol_obstack = &obstack1;
+
+/* These variables point to the objects
+   representing the predefined C data types.  */
+
+struct type *builtin_type_void;
+struct type *builtin_type_char;
+struct type *builtin_type_short;
+struct type *builtin_type_int;
+struct type *builtin_type_long;
+struct type *builtin_type_unsigned_char;
+struct type *builtin_type_unsigned_short;
+struct type *builtin_type_unsigned_int;
+struct type *builtin_type_unsigned_long;
+struct type *builtin_type_float;
+struct type *builtin_type_double;
+
+/* Lookup the symbol table of a source file named NAME.  */
+
+struct symtab *
+lookup_symtab (name)
+     char *name;
+{
+  register struct symtab *s;
+  register char *copy;
+
+  for (s = symtab_list; s; s = s->next)
+    if (!strcmp (name, s->filename))
+      return s;
+
+  /* If name not found as specified, see if adding ".c" helps.  */
+
+  copy = (char *) alloca (strlen (name) + 3);
+  strcpy (copy, name);
+  strcat (copy, ".c");
+  for (s = symtab_list; s; s = s->next)
+    if (!strcmp (copy, s->filename))
+      return s;
+
+  return 0;
+}
+
+/* Lookup a typedef or primitive type named NAME,
+   visible in lexical block BLOCK.
+   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
+
+struct type *
+lookup_typename (name, block, noerr)
+     char *name;
+     struct block *block;
+     int noerr;
+{
+  register struct symbol *sym = lookup_symbol (name, block, VAR_NAMESPACE);
+  if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
+    {
+      if (!strcmp (name, "int"))
+	return builtin_type_int;
+      if (!strcmp (name, "long"))
+	return builtin_type_long;
+      if (!strcmp (name, "short"))
+	return builtin_type_short;
+      if (!strcmp (name, "char"))
+	return builtin_type_char;
+      if (!strcmp (name, "float"))
+	return builtin_type_float;
+      if (!strcmp (name, "double"))
+	return builtin_type_double;
+      if (!strcmp (name, "void"))
+	return builtin_type_void;
+
+      if (noerr)
+	return 0;
+      error ("No type named %s.", name);
+    }
+  return SYMBOL_TYPE (sym);
+}
+
+struct type *
+lookup_unsigned_typename (name)
+     char *name;
+{
+  if (!strcmp (name, "int"))
+    return builtin_type_unsigned_int;
+  if (!strcmp (name, "long"))
+    return builtin_type_unsigned_long;
+  if (!strcmp (name, "short"))
+    return builtin_type_unsigned_short;
+  if (!strcmp (name, "char"))
+    return builtin_type_unsigned_char;
+  error ("No type named unsigned %s.", name);
+}
+
+/* Lookup a structure type named "struct NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_struct (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No struct type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
+    error ("This context has union or enum %s, not a struct.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Lookup a union type named "union NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_union (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No union type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
+    error ("This context has struct or enum %s, not a union.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Lookup an enum type named "enum NAME",
+   visible in lexical block BLOCK.  */
+
+struct type *
+lookup_enum (name, block)
+     char *name;
+     struct block *block;
+{
+  register struct symbol *sym = lookup_symbol (name, block, STRUCT_NAMESPACE);
+  if (sym == 0)
+    error ("No enum type named %s.", name);
+  if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
+    error ("This context has struct or union %s, not an enum.", name);
+  return SYMBOL_TYPE (sym);
+}
+
+/* Given a type TYPE, return a type of pointers to that type.
+   May need to construct such a type if this is the first use.  */
+
+struct type *
+lookup_pointer_type (type)
+     struct type *type;
+{
+  register struct type *ptype = TYPE_POINTER_TYPE (type);
+  if (ptype) return ptype;
+
+  /* This is the first time anyone wanted a pointer to a TYPE.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    ptype  = (struct type *) xmalloc (sizeof (struct type));
+  else
+    ptype  = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+
+  bzero (ptype, sizeof (struct type));
+  TYPE_TARGET_TYPE (ptype) = type;
+  TYPE_POINTER_TYPE (type) = ptype;
+  /* New type is permanent if type pointed to is permanent.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
+  /* We assume the machine has only one representation for pointers!  */
+  TYPE_LENGTH (ptype) = sizeof (char *);
+  TYPE_CODE (ptype) = TYPE_CODE_PTR;
+  return ptype;
+}
+
+/* Given a type TYPE, return a type of functions that return that type.
+   May need to construct such a type if this is the first use.  */
+
+struct type *
+lookup_function_type (type)
+     struct type *type;
+{
+  register struct type *ptype = TYPE_FUNCTION_TYPE (type);
+  if (ptype) return ptype;
+
+  /* This is the first time anyone wanted a function returning a TYPE.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    ptype  = (struct type *) xmalloc (sizeof (struct type));
+  else
+    ptype  = (struct type *) obstack_alloc (symbol_obstack,
+					    sizeof (struct type));
+
+  bzero (ptype, sizeof (struct type));
+  TYPE_TARGET_TYPE (ptype) = type;
+  TYPE_FUNCTION_TYPE (type) = ptype;
+  /* New type is permanent if type returned is permanent.  */
+  if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
+    TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
+  TYPE_LENGTH (ptype) = 1;
+  TYPE_CODE (ptype) = TYPE_CODE_FUNC;
+  TYPE_NFIELDS (ptype) = 0;
+  return ptype;
+}
+
+/* Smash TYPE to be a type of pointers to TO_TYPE.
+   If TO_TYPE is not permanent and has no pointer-type yet,
+   record TYPE as its pointer-type.  */
+
+void
+smash_to_pointer_type (type, to_type)
+     struct type *type, *to_type;
+{
+  bzero (type, sizeof (struct type));
+  TYPE_TARGET_TYPE (type) = to_type;
+  /* We assume the machine has only one representation for pointers!  */
+  TYPE_LENGTH (type) = sizeof (char *);
+  TYPE_CODE (type) = TYPE_CODE_PTR;
+
+  if (TYPE_POINTER_TYPE (to_type) == 0
+      && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+    {
+      TYPE_POINTER_TYPE (to_type) = type;
+    }
+}
+
+/* Smash TYPE to be a type of functions returning TO_TYPE.
+   If TO_TYPE is not permanent and has no function-type yet,
+   record TYPE as its function-type.  */
+
+void
+smash_to_function_type (type, to_type)
+     struct type *type, *to_type;
+{
+  bzero (type, sizeof (struct type));
+  TYPE_TARGET_TYPE (type) = to_type;
+  TYPE_LENGTH (type) = 1;
+  TYPE_CODE (type) = TYPE_CODE_FUNC;
+  TYPE_NFIELDS (type) = 0;
+
+  if (TYPE_FUNCTION_TYPE (to_type) == 0
+      && !(TYPE_FLAGS (type) & TYPE_FLAG_PERM))
+    {
+      TYPE_FUNCTION_TYPE (to_type) = type;
+    }
+}
+
+static struct symbol *lookup_block_symbol ();
+
+/* Find the definition for a specified symbol name NAME
+   in namespace NAMESPACE, visible from lexical block BLOCK.
+   Returns the struct symbol pointer, or zero if no symbol is found.  */
+
+struct symbol *
+lookup_symbol (name, block, namespace)
+     char *name;
+     register struct block *block;
+     enum namespace namespace;
+{
+  register int i, n;
+  register struct symbol *sym;
+  register struct symtab *s;
+  struct blockvector *bv;
+
+  /* Search specified block and its superiors.  */
+
+  while (block != 0)
+    {
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  /* Now search all symtabs' global blocks.  */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      block = BLOCKVECTOR_BLOCK (bv, 0);
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+    }
+
+  /* Now search all symtabs' per-file blocks.
+     Not strictly correct, but more useful than an error.  */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      block = BLOCKVECTOR_BLOCK (bv, 1);
+      sym = lookup_block_symbol (block, name, namespace);
+      if (sym) return sym;
+    }
+  return 0;
+}
+
+/* Look for a symbol in block BLOCK using binary search.  */
+
+static struct symbol *
+lookup_block_symbol (block, name, namespace)
+     register struct block *block;
+     char *name;
+     enum namespace namespace;
+{
+  register int bot, top, inc;
+  register struct symbol *sym;
+
+  top = BLOCK_NSYMS (block);
+  bot = 0;
+
+  /* First, advance BOT to not far before
+     the first symbol whose name is NAME.  */
+
+  while (1)
+    {
+      inc = (top - bot + 1);
+      /* No need to keep binary searching for the last few bits worth.  */
+      if (inc < 7)
+	break;
+      inc >>= 1;
+      sym = BLOCK_SYM (block, bot + inc);
+      if (strcmp (SYMBOL_NAME (sym), name) < 0)
+	bot += inc;
+      else
+	top = bot + inc;
+    }
+
+  /* Now scan forward until we run out of symbols,
+     find one whose name is greater than NAME,
+     or find one we want.
+     If there is more than one symbol with the right name and namespace,
+     we return the first one.  dbxread.c is careful to make sure
+     that if one is a register then it comes first.  */
+
+  top = BLOCK_NSYMS (block);
+  while (bot < top)
+    {
+      sym = BLOCK_SYM (block, bot);
+      inc = strcmp (SYMBOL_NAME (sym), name);
+      if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
+	return sym;
+      if (inc > 0)
+	return 0;
+      bot++;
+    }
+  return 0;
+}
+
+/* Return the symbol for the function which contains a specified
+   lexical block, described by a struct block BL.  */
+
+struct symbol *
+block_function (bl)
+     struct block *bl;
+{
+  while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
+    bl = BLOCK_SUPERBLOCK (bl);
+
+  return BLOCK_FUNCTION (bl);
+}
+
+/* Subroutine of find_pc_line */
+
+static struct symtab *
+find_pc_symtab (pc)
+     register CORE_ADDR pc;
+{
+  register struct block *b;
+  struct blockvector *bv;
+  register struct symtab *s;
+
+  /* Search all symtabs for one whose file contains our pc */
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      bv = BLOCKVECTOR (s);
+      b = BLOCKVECTOR_BLOCK (bv, 0);
+      if (BLOCK_START (b) <= pc
+	  && BLOCK_END (b) > pc)
+	break;
+    }
+
+  return s;
+}
+
+/* Find the source file and line number for a given PC value.
+   Return a structure containing a symtab pointer, a line number,
+   and a pc range for the entire source line.
+   The value's .pc field is NOT the specified pc.
+   NOTCURRENT nonzero means, if specified pc is on a line boundary,
+   use the line that ends there.  Otherwise, in that case, the line
+   that begins there is used.  */
+
+struct symtab_and_line
+find_pc_line (pc, notcurrent)
+     CORE_ADDR pc;
+     int notcurrent;
+{
+  struct symtab *s;
+  register struct linetable *l;
+  register int len;
+  register int i, item;
+  int line;
+  struct symtab_and_line value;
+  struct blockvector *bv;
+
+  /* Info on best line seen so far, and where it starts, and its file.  */
+
+  int best_line = 0;
+  CORE_ADDR best_pc = 0;
+  CORE_ADDR best_end = 0;
+  struct symtab *best_symtab = 0;
+
+  /* Store here the first line number
+     of a file which contains the line at the smallest pc after PC.
+     If we don't find a line whose range contains PC,
+     we will use a line one less than this,
+     with a range from the start of that file to the first line's pc.  */
+  int alt_line = 0;
+  CORE_ADDR alt_pc = 0;
+  struct symtab *alt_symtab = 0;
+
+  /* Info on best line seen in this file.  */
+
+  int prev_line;
+  CORE_ADDR prev_pc;
+
+  /* Info on first line of this file.  */
+
+  int first_line;
+  CORE_ADDR first_pc;
+
+  /* If this pc is not from the current frame,
+     it is the address of the end of a call instruction.
+     Quite likely that is the start of the following statement.
+     But what we want is the statement containing the instruction.
+     Fudge the pc to make sure we get that.  */
+
+  if (notcurrent) pc -= 1;
+
+  s = find_pc_symtab (pc);
+  if (s == 0)
+    {
+      value.symtab = 0;
+      value.line = 0;
+      value.pc = pc;
+      return value;
+    }
+
+  bv = BLOCKVECTOR (s);
+
+  /* Look at all the symtabs that share this blockvector.
+     They all have the same apriori range, that we found was right;
+     but they have different line tables.  */
+
+  for (; s && BLOCKVECTOR (s) == bv; s = s->next)
+    {
+      /* Find the best line in this symtab.  */
+      l = LINETABLE (s);
+      len = l->nitems;
+      prev_line = -1;
+      first_line = -1;
+      for (i = 0; i < len; i++)
+	{
+	  item = l->item[i];
+	  if (item < 0)
+	    line = - item - 1;
+	  else
+	    {
+	      line++;
+	      if (first_line < 0)
+		{
+		  first_line = line;
+		  first_pc = item;
+		}
+	      /* Return the last line that did not start after PC.  */
+	      if (pc >= item)
+		{
+		  prev_line = line;
+		  prev_pc = item;
+		}
+	      else
+		break;
+	    }
+	}
+
+      /* Is this file's best line closer than the best in the other files?
+	 If so, record this file, and its best line, as best so far.  */
+      if (prev_line >= 0 && prev_pc > best_pc)
+	{
+	  best_pc = prev_pc;
+	  best_line = prev_line;
+	  best_symtab = s;
+	  if (i < len)
+	    best_end = item;
+	  else
+	    best_end = 0;
+	}
+      /* Is this file's first line closer than the first lines of other files?
+	 If so, record this file, and its first line, as best alternate.  */
+      if (first_line >= 0 && first_pc > pc
+	  && (alt_pc == 0 || first_pc < alt_pc))
+	{
+	  alt_pc = first_pc;
+	  alt_line = first_line;
+	  alt_symtab = s;
+	}
+    }
+  if (best_symtab == 0)
+    {
+      value.symtab = alt_symtab;
+      value.line = alt_line - 1;
+      value.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0));
+      value.end = alt_pc;
+    }
+  else
+    {
+      value.symtab = best_symtab;
+      value.line = best_line;
+      value.pc = best_pc;
+      value.end = (best_end ? best_end
+		   : (alt_pc ? alt_pc
+		      : BLOCK_END (BLOCKVECTOR_BLOCK (bv, 0))));
+    }
+  return value;
+}
+
+/* Find the range of pc values in a line.
+   Store the starting pc of the line into *STARTPTR
+   and the ending pc (start of next line) into *ENDPTR.
+   Returns 1 to indicate success.
+   Returns 0 if could not find the specified line.  */
+
+int
+find_line_pc_range (symtab, thisline, startptr, endptr)
+     struct symtab *symtab;
+     int thisline;
+     CORE_ADDR *startptr, *endptr;
+{
+  register struct linetable *l;
+  register int i, line, item;
+  int len;
+  register CORE_ADDR prev_pc;
+  CORE_ADDR last_pc;
+
+  if (symtab == 0)
+    return 0;
+
+  l = LINETABLE (symtab);
+  len = l->nitems;
+  prev_pc = -1;
+  for (i = 0; i < len; i++)
+    {
+      item = l->item[i];
+      if (item < 0)
+	line = - item - 1;
+      else
+	{
+	  line++;
+	  /* As soon as we find a line following the specified one
+	     we know the end pc and can return.  */
+	  if (line > thisline)
+	    {
+	      /* If we have not seen an entry for the specified line,
+		 assume that means the specified line has zero bytes.  */
+	      *startptr = prev_pc == -1 ? item : prev_pc;
+	      *endptr = item;
+	      return 1;
+	    }
+	  /* If we see an entry for the specified line,
+	     it gives the beginning.  */
+	  if (line == thisline)
+	    prev_pc = item;
+	  last_pc = item;
+	}
+    }
+  if (prev_pc != -1)
+    {
+      /* If we found the specified line but no later line, it's file's last.
+	 Its range is from line's pc to file's end pc.  */
+      *startptr = last_pc;
+      *endptr = BLOCK_END (BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), 0));
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Find the PC value for a given source file and line number.
+   Returns zero for invalid line number.
+   The source file is specified with a struct symtab.  */
+
+CORE_ADDR
+find_line_pc (symtab, line)
+     struct symtab *symtab;
+     int line;
+{
+  register struct linetable *l;
+  register int len;
+  register int i;
+  register int item;
+  register int nextline = -1;
+
+  if (line <= 0)
+    return 0;
+
+  l = LINETABLE (symtab);
+  len = l->nitems;
+  for (i = 0; i < len; i++)
+    {
+      item = l->item[i];
+      if (item < 0)
+	nextline = - item - 1;
+      else
+	{
+	  nextline++;
+	  if (line <= nextline)
+	    return item;
+	}
+    }
+  return 0;
+}
+
+int
+find_pc_line_pc_range (pc, startptr, endptr)
+     CORE_ADDR pc;
+     CORE_ADDR *startptr, *endptr;
+{
+  struct symtab_and_line sal;
+  sal = find_pc_line (pc, 0);
+  *startptr = sal.pc;
+  *endptr = sal.end;
+  return sal.symtab != 0;
+}
+
+/* Parse a string that specifies a line number.
+   Pass the address of a char * variable; that variable will be
+   advanced over the characters actually parsed.
+
+   The string can be:
+
+   LINENUM -- that line number in current file.  PC returned is 0.
+   FILE:LINENUM -- that line in that file.  PC returned is 0.
+   FUNCTION -- line number of openbrace of that function.
+      PC returned is the start of the function.
+   FILE:FUNCTION -- likewise, but prefer functions in that file.
+   *EXPR -- line in which address EXPR appears.
+
+   FUNCTION may be an undebuggable function found in misc_function_vector.
+
+   If the argument FUNFIRSTLINE is nonzero, we want the first line
+   of real code inside a function when a function is specified.
+
+   DEFAULT_SYMTAB specifies the file to use if none is specified.
+   It defaults to current_source_symtab.
+   DEFAULT_LINE specifies the line number to use for relative
+   line numbers (that start with signs).  Defaults to current_source_line.
+
+   Note that it is possible to return zero for the symtab
+   if no file is validly specified.  Callers must check that.
+   Also, the line number returned may be invalid.  */
+
+struct symtab_and_line
+decode_line_1 (argptr, funfirstline, default_symtab, default_line)
+     char **argptr;
+     int funfirstline;
+     struct symtab *default_symtab;
+     int default_line;
+{
+  struct symtab_and_line value;
+  register char *p, *p1;
+  register struct symtab *s;
+  register struct symbol *sym;
+  register CORE_ADDR pc;
+  register int i;
+  char *copy;
+
+  /* Defaults have defaults.  */
+
+  if (default_symtab == 0)
+    {
+      default_symtab = current_source_symtab;
+      default_line = current_source_line;
+    }
+
+  /* See if arg is *PC */
+
+  if (**argptr == '*')
+    {
+      (*argptr)++;
+      pc = parse_and_eval_address_1 (argptr);
+      value = find_pc_line (pc, 0);
+      value.pc = pc;
+      return value;
+    }
+
+  /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
+
+  s = 0;
+
+  for (p = *argptr; *p; p++)
+    {
+      if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
+	break;
+    }
+  while (p[0] == ' ' || p[0] == '\t') p++;
+
+  if (p[0] == ':')
+    {
+      /* Extract the file name.  */
+      p1 = p;
+      while (p != *argptr && p[-1] == ' ') --p;
+      copy = (char *) alloca (p - *argptr + 1);
+      bcopy (*argptr, copy, p - *argptr);
+      copy[p - *argptr] = 0;
+
+      /* Find that file's data.  */
+      s = lookup_symtab (copy);
+      if (s == 0)
+	{
+	  if (symtab_list == 0)
+	    error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+	  error ("No source file named %s.", copy);
+	}
+
+      /* Discard the file name from the arg.  */
+      p = p1 + 1;
+      while (*p == ' ' || *p == '\t') p++;
+      *argptr = p;
+    }
+
+  /* S is specified file's symtab, or 0 if no file specified.
+     arg no longer contains the file name.  */
+
+  /* Check whether arg is all digits (and sign) */
+
+  p = *argptr;
+  if (*p == '-' || *p == '+') p++;
+  while (*p >= '0' && *p <= '9')
+    p++;
+
+  if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
+    {
+      /* We found a token consisting of all digits -- at least one digit.  */
+      enum sign {none, plus, minus} sign = none;
+
+      if (**argptr == '+')
+	sign = plus, (*argptr)++;
+      else if (**argptr == '-')
+	sign = minus, (*argptr)++;
+      value.line = atoi (*argptr);
+      switch (sign)
+	{
+	case plus:
+	  if (p == *argptr)
+	    value.line = 5;
+	  if (s == 0)
+	    value.line = default_line + value.line;
+	  break;
+	case minus:
+	  if (p == *argptr)
+	    value.line = 15;
+	  if (s == 0)
+	    value.line = default_line - value.line;
+	  else
+	    value.line = 1;
+	  break;
+	}
+
+      while (*p == ' ' || *p == '\t') p++;
+      *argptr = p;
+      if (s == 0)
+	s = default_symtab;
+      value.symtab = s;
+      value.pc = 0;
+      return value;
+    }
+
+  /* Arg token is not digits => try it as a function name
+     Find the next token (everything up to end or next whitespace).  */
+  p = *argptr;
+  while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
+  copy = (char *) alloca (p - *argptr + 1);
+  bcopy (*argptr, copy, p - *argptr);
+  copy[p - *argptr] = 0;
+  while (*p == ' ' || *p == '\t') p++;
+  *argptr = p;
+
+  /* Look up that token as a function.
+     If file specified, use that file's per-file block to start with.  */
+
+  sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
+		       VAR_NAMESPACE);
+
+  if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+    {
+      /* Arg is the name of a function */
+      pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
+      if (funfirstline)
+	SKIP_PROLOGUE (pc);
+      value = find_pc_line (pc, 0);
+      value.pc = (value.end && value.pc != pc) ? value.end : pc;
+      return value;
+    }
+
+  if (sym)
+    error ("%s is not a function.", copy);
+
+  for (i = 0; i < misc_function_count; i++)
+    if (!strcmp (misc_function_vector[i].name, copy))
+      {
+	value.symtab = 0;
+	value.line = 0;
+	value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
+	if (funfirstline)
+	  SKIP_PROLOGUE (value.pc);
+	return value;
+      }
+
+  if (symtab_list == 0)
+    error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
+  error ("Function %s not defined.", copy);
+}
+
+struct symtab_and_line
+decode_line_spec (string, funfirstline)
+     char *string;
+     int funfirstline;
+{
+  struct symtab_and_line sal;
+  if (string == 0)
+    error ("Empty line specification.");
+  sal = decode_line_1 (&string, funfirstline,
+		       current_source_symtab, current_source_line);
+  if (*string)
+    error ("Junk at end of line specification: %s", string);
+  return sal;
+}
+
+static void
+sources_info ()
+{
+  register struct symtab *s;
+  register int column = 0;
+
+  if (symtab_list == 0)
+    {
+      printf ("No symbol table is loaded.\n");
+      return;
+    }
+  printf ("Source files for which symbol table is known:\n");
+  for (s = symtab_list; s; s = s->next)
+    {
+      if (column != 0 && column + strlen (s->filename) >= 70)
+	{
+	  printf ("\n");
+	  column = 0;
+	}
+      else if (column != 0)
+	{
+	  printf (" ");
+	  column++;
+	}
+      printf ("%s", s->filename);
+      column += strlen (s->filename);
+      if (s->next)
+	{
+	  printf (",");
+	  column++;
+	}
+    }
+  printf ("\n");
+}
+
+/* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
+   If CLASS is zero, list all symbols except functions and type names.
+   If CLASS is 1, list only functions.
+   If CLASS is 2, list only type names.  */
+
+#define MORE  \
+{ print_count++;		\
+  if (print_count >= 21)	\
+    { printf ("--Type Return to print more--");	\
+      print_count = 0;		\
+      fflush (stdout);		\
+      read_line (); } }
+
+static void
+list_symbols (regexp, class)
+     char *regexp;
+     int class;
+{
+  register struct symtab *s;
+  register struct blockvector *bv;
+  struct blockvector *prev_bv = 0;
+  register struct block *b;
+  register int i, j;
+  register struct symbol *sym;
+  char *val = 0;
+  int found_in_file;
+  static char *classnames[]
+    = {"variable", "function", "type"};
+  int print_count = 0;
+#ifdef REGCMP
+  extern char *regcmp(), *regex(), *loc1;
+#endif
+
+  if (regexp) {
+#ifdef REGCMP
+    val = regcmp(regexp, (char *)0);
+    if (val == 0)
+      error ("Invalid regexp: %s", regexp);
+#else
+    if (val = (char *) re_comp (regexp))
+      error ("Invalid regexp: %s", val);
+#endif
+  }
+
+  printf (regexp
+	  ? "All %ss matching regular expression \"%s\":\n"
+	  : "All defined %ss:\n",
+	  classnames[class],
+	  regexp);
+
+  for (s = symtab_list; s; s = s->next)
+    {
+      found_in_file = 0;
+      bv = BLOCKVECTOR (s);
+      /* Often many files share a blockvector.
+	 Scan each blockvector only once so that
+	 we don't get every symbol many times.
+	 It happens that the first symtab in the list
+	 for any given blockvector is the main file.  */
+      if (bv != prev_bv)
+	for (i = 0; i < 2; i++)
+	  {
+	    b = BLOCKVECTOR_BLOCK (bv, i);
+	    for (j = 0; j < BLOCK_NSYMS (b); j++)
+	      {
+		QUIT;
+		sym = BLOCK_SYM (b, j);
+		if (regexp) {
+#ifdef REGCMP
+		  if (!regex(val, SYMBOL_NAME (sym)))
+		    continue;
+#else
+		  if (!re_exec (SYMBOL_NAME (sym)))
+		    continue;
+#endif
+		}
+		if ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+			 && SYMBOL_CLASS (sym) != LOC_BLOCK)
+			|| (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
+			|| (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF))
+		  {
+		    if (!found_in_file)
+		      {
+			printf ("\nFile %s:\n", s->filename);
+			print_count += 2;
+		      }
+		    found_in_file = 1;
+		    MORE;
+		    if (class != 2 && i == 1)
+		      printf ("static ");
+		    if (class == 2
+			&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
+		      printf ("typedef ");
+
+		    type_print (SYMBOL_TYPE (sym),
+				(SYMBOL_CLASS (sym) == LOC_TYPEDEF
+				 ? "" : SYMBOL_NAME (sym)),
+				stdout, 0);
+		    if (class == 2
+			&& SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
+			&& (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
+			    || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
+					    SYMBOL_NAME (sym))))
+		      printf (" %s", SYMBOL_NAME (sym));
+		    printf (";\n");
+		  }
+	      }
+	  }
+      prev_bv = bv;
+    }
+#ifdef REGCMP
+    if (val)
+      (void)free(val);
+#endif
+}
+
+static void
+variables_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 0);
+}
+
+static void
+functions_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 1);
+}
+
+static void
+types_info (regexp)
+     char *regexp;
+{
+  list_symbols (regexp, 2);
+}
+
+/* Initialize the standard C scalar types.  */
+
+static
+struct type *
+init_type (code, length, uns, name)
+     enum type_code code;
+     int length, uns;
+     char *name;
+{
+  register struct type *type;
+
+  type = (struct type *) xmalloc (sizeof (struct type));
+  bzero (type, sizeof *type);
+  TYPE_CODE (type) = code;
+  TYPE_LENGTH (type) = length;
+  TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
+  TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
+  TYPE_NFIELDS (type) = 0;
+  TYPE_NAME (type) = name;
+
+  return type;
+}
+
+static
+initialize ()
+{
+  add_info ("variables", variables_info,
+	    "All global and static variable names, or those matching REGEXP.");
+  add_info ("functions", functions_info,
+	    "All function names, or those matching REGEXP.");
+  add_info ("types", types_info,
+	    "All types names, or those matching REGEXP.");
+  add_info ("sources", sources_info,
+	    "Source files in the program.");
+
+  obstack_init (symbol_obstack);
+
+  builtin_type_void = init_type (TYPE_CODE_VOID, 0, 0, "void");
+
+  builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float");
+  builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double");
+
+  builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char");
+  builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short");
+  builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long");
+  builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int");
+
+  builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char");
+  builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short");
+  builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long");
+  builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int");
+}
+
+END_FILE
diff --git a/gdb/symtab.h b/gdb/symtab.h
new file mode 100644
index 0000000..4d93355
--- /dev/null
+++ b/gdb/symtab.h
@@ -0,0 +1,228 @@
+/* Symbol table definitions for GDB.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* An obstack to hold objects that should be freed
+   when we load a new symbol table.
+   This includes the symbols made by dbxread
+   and the types that are not permanent.  */
+
+extern struct obstack *symbol_obstack;
+
+/* Some definitions and declarations to go with use of obstacks.  */
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+extern char *xmalloc ();
+extern void free ();
+
+/* gdb can know one or several symbol tables at the same time;
+   the ultimate intent is to have one for each separately-compiled module.
+   Each such symbol table is recorded by a struct symtab, and they
+   are all chained together.  */
+
+/* In addition, gdb can record any number of miscellaneous undebuggable
+   functions' addresses.  In a system that appends _ to function names,
+   the _'s are removed from the names stored in this table.  */
+
+struct misc_function
+{
+  char *name;
+  CORE_ADDR address;
+};
+
+/* Address and length of the vector recording all misc function names/addresses.  */
+
+struct misc_function *misc_function_vector;
+int misc_function_count;
+
+#include "symseg.h"
+
+/* Each source file is represented by a struct symtab.
+   These objects are chained through the `next' field.  */
+
+struct symtab
+  {
+    /* Chain of all existing symtabs.  */
+    struct symtab *next;
+    /* List of all symbol scope blocks for this symtab.  */
+    struct blockvector *blockvector;
+    /* Table mapping core addresses to line numbers for this file.  */
+    struct linetable *linetable;
+    /* Vector containing all types defined for this symtab.  */
+    struct typevector *typevector;
+    /* Name of this source file.  */
+    char *filename;
+    /* This component says how to free the data we point to:
+       free_contents => do a tree walk and free each object.
+       free_explicit => free what free_ptr points at, and the linetable.
+       free_nothing => do nothing; some other symtab will free
+         the data this one uses.
+       free_linetable => free just the linetable.  */
+    enum free_code {free_nothing, free_contents, free_explicit, free_linetable}
+      free_code;
+    /* Pointer to one block storage to be freed, if nonzero.  */
+    char *free_ptr;
+    /* Total number of lines found in source file.  */
+    int nlines;
+    /* Array mapping line number to character position.  */
+    int *line_charpos;
+    /* Language of this source file.  */
+    enum language language;
+    /* String of version information.  May be zero.  */
+    char *version;
+    /* String of compilation information.  May be zero.  */
+    char *compilation;
+    /* Offset within loader symbol table
+       of first local symbol for this file.  */
+    int ldsymoff;
+  };
+
+/* This is the list of struct symtab's that gdb considers current.  */
+
+struct symtab *symtab_list;
+
+/* This symtab variable specifies the current file for printing source lines */
+
+struct symtab *current_source_symtab;
+
+/* This is the next line to print for listing source lines.  */
+
+int current_source_line;
+
+#define BLOCKLIST(symtab) (symtab)->blockvector
+#define BLOCKVECTOR(symtab) (symtab)->blockvector
+
+#define TYPEVECTOR(symtab) (symtab)->typevector
+
+#define LINELIST(symtab) (symtab)->linetable
+#define LINETABLE(symtab) (symtab)->linetable
+
+/* Recording the code addresses of source lines.  */
+
+struct linetable
+  {
+    int nitems;
+    int item[1];
+  };
+
+/* Each item is either minus a line number, or a program counter.
+   If it represents a line number, that is the line described by the next
+   program counter value.  If it is positive, it is the program
+   counter at which the code for the next line starts.
+
+   Consecutive lines can be recorded by program counter entries
+   with no line number entries between them.  Line number entries
+   are used when there are lines to skip with no code on them.
+   This is to make the table shorter.  */
+
+/* Macros normally used to access components of symbol table structures.  */
+
+#define BLOCKLIST_NBLOCKS(blocklist) (blocklist)->nblocks
+#define BLOCKLIST_BLOCK(blocklist,n) (blocklist)->block[n]
+#define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
+#define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
+
+#define TYPEVECTOR_NTYPES(typelist) (typelist)->length
+#define TYPEVECTOR_TYPE(typelist,n) (typelist)->type[n]
+
+#define BLOCK_START(bl) (bl)->startaddr
+#define BLOCK_END(bl) (bl)->endaddr
+#define BLOCK_NSYMS(bl) (bl)->nsyms
+#define BLOCK_SYM(bl, n) (bl)->sym[n]
+#define BLOCK_FUNCTION(bl) (bl)->function
+#define BLOCK_SUPERBLOCK(bl) (bl)->superblock
+
+#define SYMBOL_NAME(symbol) (symbol)->name
+#define SYMBOL_NAMESPACE(symbol) (symbol)->namespace
+#define SYMBOL_CLASS(symbol) (symbol)->class
+#define SYMBOL_VALUE(symbol) (symbol)->value.value
+#define SYMBOL_VALUE_BYTES(symbol) (symbol)->value.bytes
+#define SYMBOL_BLOCK_VALUE(symbol) (symbol)->value.block
+#define SYMBOL_TYPE(symbol) (symbol)->type
+
+/* This appears in a type's flags word
+   if it is a (pointer to a|function returning a)* built in scalar type.
+   These types are never freed.  */
+#define TYPE_FLAG_PERM 4
+
+#define TYPE_NAME(thistype) (thistype)->name
+#define TYPE_TARGET_TYPE(thistype) (thistype)->target_type
+#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
+#define TYPE_FUNCTION_TYPE(thistype) (thistype)->function_type
+#define TYPE_LENGTH(thistype) (thistype)->length
+#define TYPE_FLAGS(thistype) (thistype)->flags
+#define TYPE_UNSIGNED(thistype) ((thistype)->flags & TYPE_FLAG_UNSIGNED)
+#define TYPE_CODE(thistype) (thistype)->code
+#define TYPE_NFIELDS(thistype) (thistype)->nfields
+#define TYPE_FIELDS(thistype) (thistype)->fields
+
+#define TYPE_FIELD(thistype, n) (thistype)->fields[n]
+#define TYPE_FIELD_TYPE(thistype, n) (thistype)->fields[n].type
+#define TYPE_FIELD_NAME(thistype, n) (thistype)->fields[n].name
+#define TYPE_FIELD_VALUE(thistype, n) (* (int*) &(thistype)->fields[n].type)
+#define TYPE_FIELD_BITPOS(thistype, n) (thistype)->fields[n].bitpos
+#define TYPE_FIELD_BITSIZE(thistype, n) (thistype)->fields[n].bitsize
+#define TYPE_FIELD_PACKED(thistype, n) (thistype)->fields[n].bitsize
+
+/* Functions that work on the objects described above */
+
+extern struct symtab *lookup_symtab ();
+extern struct symbol *lookup_symbol ();
+extern struct type *lookup_typename ();
+extern struct type *lookup_unsigned_typename ();
+extern struct type *lookup_struct ();
+extern struct type *lookup_union ();
+extern struct type *lookup_enum ();
+extern struct type *lookup_pointer_type ();
+extern struct type *lookup_function_type ();
+extern struct symbol *block_function ();
+extern struct symbol *find_pc_function ();
+extern int find_pc_misc_function ();
+
+extern struct type *builtin_type_void;
+extern struct type *builtin_type_char;
+extern struct type *builtin_type_short;
+extern struct type *builtin_type_int;
+extern struct type *builtin_type_long;
+extern struct type *builtin_type_unsigned_char;
+extern struct type *builtin_type_unsigned_short;
+extern struct type *builtin_type_unsigned_int;
+extern struct type *builtin_type_unsigned_long;
+extern struct type *builtin_type_float;
+extern struct type *builtin_type_double;
+
+struct symtab_and_line
+{
+  struct symtab *symtab;
+  int line;
+  CORE_ADDR pc;
+  CORE_ADDR end;
+};
+
+/* Given a pc value, return line number it is in.
+   Second arg nonzero means if pc is on the boundary
+   use the previous statement's line number.  */
+
+struct symtab_and_line find_pc_line ();
+
+/* Given a string, return the line specified by it.
+   For commands like "list" and "breakpoint".  */
+
+struct symtab_and_line decode_line_spec ();
+struct symtab_and_line decode_line_1 ();
diff --git a/gdb/test2.c b/gdb/test2.c
new file mode 100644
index 0000000..e6964f0
--- /dev/null
+++ b/gdb/test2.c
@@ -0,0 +1,13 @@
+#include <sys/param.h>
+#include <sys/dir.h>
+#include <sys/user.h>
+#include <stdio.h>
+
+main ()
+{
+  struct user u;
+  printf ("&u.u_ar0 - &u = %d, 0%o\n", (int) &u.u_ar0 - (int) &u,
+	  (int) &u.u_ar0 - (int) &u);
+  printf ("sizeof (struct pcb) = %d, 0%o\n",
+	  sizeof (struct pcb), sizeof (struct pcb));
+}
diff --git a/gdb/test3.c b/gdb/test3.c
new file mode 100644
index 0000000..cd27cdd
--- /dev/null
+++ b/gdb/test3.c
@@ -0,0 +1,25 @@
+enum foo {foo1, foo2};
+
+static double statdouble;
+
+newfun (ac)
+     struct haha {int a; } ac;
+{
+}
+
+struct temp {int a; };
+
+bar (a)
+     enum foo a;
+{
+  static int lose;
+  double happy;
+  typedef int myint;
+
+  {
+    union wow { int a; char b; } wowvar;
+    static union wow wowvar1;
+    typedef int yourint;
+    char *winner;
+  }
+}
diff --git a/gdb/testattach.c b/gdb/testattach.c
new file mode 100644
index 0000000..c56a0fe
--- /dev/null
+++ b/gdb/testattach.c
@@ -0,0 +1,10 @@
+main ()
+{
+  int x = 0;
+
+  while (1)
+    {
+      sleep (1);
+      x++;
+    }
+}
diff --git a/gdb/testbf.c b/gdb/testbf.c
new file mode 100644
index 0000000..dd661a0
--- /dev/null
+++ b/gdb/testbf.c
@@ -0,0 +1,13 @@
+struct foo
+{
+  int a : 5, : 4, b : 5;
+  char c;
+  int : 3, d : 8, : 0, e : 5;
+};
+
+struct foo x;
+
+main ()
+{
+  printf (x);
+}
diff --git a/gdb/testbit.c b/gdb/testbit.c
new file mode 100644
index 0000000..9359f0b
--- /dev/null
+++ b/gdb/testbit.c
@@ -0,0 +1,12 @@
+struct foo
+{
+  unsigned bar : 1;
+  unsigned lose : 1;
+};
+
+main ()
+{
+  struct foo *win;
+
+  printf ("%d, %d\n", win->bar, win->lose);
+}
diff --git a/gdb/testenum.c b/gdb/testenum.c
new file mode 100644
index 0000000..3d85f5e
--- /dev/null
+++ b/gdb/testenum.c
@@ -0,0 +1,25 @@
+/* Source file for showing ENUM lossage in GDB.
+   Compile with "cc -o foo -g foo.c".  */
+
+enum bar { value1, value2, value3 };
+
+struct foo {
+  enum bar enum_value;
+  int int_value;
+  char *pointer_value;
+};
+
+struct foo foo_instance;
+struct foo *foo_instance_pointer;
+
+main ()
+{
+  foo_instance_pointer = &foo_instance;
+  foo_instance.enum_value = value2;
+  foo_instance.int_value = 1;
+  foo_instance.pointer_value = "Text to make a char *";  
+
+  /* In GDB, set a breakpoint at this line.  Then try to change the
+     value of foo_instance.enum_value in any way.  I can't do it. */
+}
+
diff --git a/gdb/testfb.c b/gdb/testfb.c
new file mode 100644
index 0000000..1699471
--- /dev/null
+++ b/gdb/testfb.c
@@ -0,0 +1,12 @@
+
+main ()
+{
+  foo(2);
+  foo(3);
+}
+
+foo (i)
+{
+  printf ("i is %d, ", i);
+  printf ("i*i is %d\n", i * i);
+}
diff --git a/gdb/testfun.c b/gdb/testfun.c
new file mode 100644
index 0000000..eeeebd7
--- /dev/null
+++ b/gdb/testfun.c
@@ -0,0 +1,22 @@
+main ()
+{
+  register double a = 1.5;
+  foo (a);
+}
+
+foo (x)
+{
+  printf ("%f\n", x);
+}
+
+do_add (x, y)
+{
+  return x + y;
+}
+
+double
+do_float_add (x, y, z)
+     register double x, y, z;
+{
+  return x + y + z;
+}
diff --git a/gdb/testkill.c b/gdb/testkill.c
new file mode 100644
index 0000000..0e43c1f
--- /dev/null
+++ b/gdb/testkill.c
@@ -0,0 +1,5 @@
+
+	main()
+	{
+		printf("foo\n");
+	}
diff --git a/gdb/testrec.c b/gdb/testrec.c
new file mode 100644
index 0000000..797c08b
--- /dev/null
+++ b/gdb/testrec.c
@@ -0,0 +1,12 @@
+main ()
+{
+  foo (4);
+}
+
+foo (x)
+     int x;
+{
+  if (x > 0)
+    foo (x - 1);
+}
+
diff --git a/gdb/testreg.c b/gdb/testreg.c
new file mode 100644
index 0000000..f19ec05
--- /dev/null
+++ b/gdb/testreg.c
@@ -0,0 +1,22 @@
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  register int d1 = 34;
+  register int d2 = 35;
+  register int d3 = 36;
+  register int d4 = 37;
+  register char *a1 = "1";
+  register char *a2 = "2";
+  register char *a3 = "3";
+  register char *a4 = "4";
+  register char *a5 = "5";
+  int x[4];
+  foo ();
+  foo (0x222, abort (), 0x444);
+}
+
+foo ()
+{
+  return 22;
+}
diff --git a/gdb/testregs.c b/gdb/testregs.c
new file mode 100644
index 0000000..7a5acb3
--- /dev/null
+++ b/gdb/testregs.c
@@ -0,0 +1,20 @@
+typedef struct aa { int b;} *hack;
+
+static int
+foo (argc)
+{
+  register int a = 0x1234;
+  register int b = 0x56788765;
+  register char *x = (char *) 0xabababab;
+  register char *y = (char *) 0xcdcdcdcd;
+  register double d = 1.582;
+  int loser;
+  printf ("Address of loser is 0x%x.\n", &loser);
+  printf ("Address of argc is 0x%x.\n", &argc);
+  abort ();
+}
+
+main (argc)
+{
+  foo (argc);
+}
diff --git a/gdb/testshort.c b/gdb/testshort.c
new file mode 100644
index 0000000..2c60631
--- /dev/null
+++ b/gdb/testshort.c
@@ -0,0 +1,16 @@
+main ()
+{
+  register int ntabs;
+  register short x;
+  short stops[30];
+
+  foo ();
+}
+
+foo ()
+{
+  register int ntabs;
+  register short x;
+
+  printf (x, ntabs);
+}
diff --git a/gdb/testsig.c b/gdb/testsig.c
new file mode 100644
index 0000000..ded2d20
--- /dev/null
+++ b/gdb/testsig.c
@@ -0,0 +1,17 @@
+# include	<signal.h>
+
+main ()
+{
+	int	handle ();
+	int	i;
+	signal (SIGALRM, handle);
+	alarm (5);
+	for (i = 0; i < 100000; i++)
+		printf ("%d\n", i);
+}
+
+handle ()
+{
+	printf ("signal!\n");
+	alarm (5);
+}
diff --git a/gdb/utils.c.OK b/gdb/utils.c.OK
new file mode 100644
index 0000000..7c52ea4
--- /dev/null
+++ b/gdb/utils.c.OK
@@ -0,0 +1,422 @@
+/* General utility routines for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include "defs.h"
+
+void error ();
+void fatal ();
+
+/* Chain of cleanup actions established with make_cleanup,
+   to be executed if an error happens.  */
+
+static struct cleanup *cleanup_chain;
+
+/* Nonzero means a quit has been requested.  */
+
+int quit_flag;
+
+/* Nonzero means quit immediately if Control-C is typed now,
+   rather than waiting until QUIT is executed.  */
+
+int immediate_quit;
+
+/* Add a new cleanup to the cleanup_chain,
+   and return the previous chain pointer
+   to be passed later to do_cleanups or discard_cleanups.
+   Args are FUNCTION to clean up with, and ARG to pass to it.  */
+
+struct cleanup *
+make_cleanup (function, arg)
+     void (*function) ();
+     int arg;
+{
+  register struct cleanup *new
+    = (struct cleanup *) xmalloc (sizeof (struct cleanup));
+  register struct cleanup *old_chain = cleanup_chain;
+
+  new->next = cleanup_chain;
+  new->function = function;
+  new->arg = arg;
+  cleanup_chain = new;
+
+  return old_chain;
+}
+
+/* Discard cleanups and do the actions they describe
+   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
+
+void
+do_cleanups (old_chain)
+     register struct cleanup *old_chain;
+{
+  register struct cleanup *ptr;
+  while ((ptr = cleanup_chain) != old_chain)
+    {
+      (*ptr->function) (ptr->arg);
+      cleanup_chain = ptr->next;
+      free (ptr);
+    }
+}
+
+/* Discard cleanups, not doing the actions they describe,
+   until we get back to the point OLD_CHAIN in the cleanup_chain.  */
+
+void
+discard_cleanups (old_chain)
+     register struct cleanup *old_chain;
+{
+  register struct cleanup *ptr;
+  while ((ptr = cleanup_chain) != old_chain)
+    {
+      cleanup_chain = ptr->next;
+      free (ptr);
+    }
+}
+
+/* This function is useful for cleanups.
+   Do
+
+     foo = xmalloc (...);
+     old_chain = make_cleanup (free_current_contents, &foo);
+
+   to arrange to free the object thus allocated.  */
+
+void
+free_current_contents (location)
+     char **location;
+{
+  free (*location);
+}
+
+/* Generally useful subroutines used throughout the program.  */
+
+/* Like malloc but get error if no storage available.  */
+
+char *
+xmalloc (size)
+     long size;
+{
+  register char *val = (char *) malloc (size);
+  if (!val)
+    fatal ("virtual memory exhausted.", 0);
+  return val;
+}
+
+/* Like realloc but get error if no storage available.  */
+
+char *
+xrealloc (ptr, size)
+     char *ptr;
+     long size;
+{
+  register char *val = (char *) realloc (ptr, size);
+  if (!val)
+    fatal ("virtual memory exhausted.", 0);
+  return val;
+}
+
+/* Print the system error message for errno, and also mention STRING
+   as the file name for which the error was encountered.
+   Then return to command level.  */
+
+void
+perror_with_name (string)
+     char *string;
+{
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  extern int errno;
+  char *err;
+  char *combined;
+
+  if (errno < sys_nerr)
+    err = sys_errlist[errno];
+  else
+    err = "unknown error";
+
+  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
+  strcpy (combined, string);
+  strcat (combined, ": ");
+  strcat (combined, err);
+
+  error ("%s.", combined);
+}
+
+/* Print the system error message for ERRCODE, and also mention STRING
+   as the file name for which the error was encountered.  */
+
+void
+print_sys_errmsg (string, errcode)
+     char *string;
+     int errcode;
+{
+  extern int sys_nerr;
+  extern char *sys_errlist[];
+  char *err;
+  char *combined;
+
+  if (errcode < sys_nerr)
+    err = sys_errlist[errcode];
+  else
+    err = "unknown error";
+
+  combined = (char *) alloca (strlen (err) + strlen (string) + 3);
+  strcpy (combined, string);
+  strcat (combined, ": ");
+  strcat (combined, err);
+
+  printf ("%s.\n", combined);
+}
+
+void
+quit ()
+{
+  fflush (stdout);
+#ifdef TIOCFLUSH
+  ioctl (fileno (stdout), TIOCFLUSH, 0);
+#endif
+  error ("Quit");
+}
+
+/* Control C comes here */
+
+void
+request_quit ()
+{
+  quit_flag = 1;
+  if (immediate_quit)
+    quit ();
+}
+
+/* Print an error message and return to command level.
+   STRING is the error message, used as a fprintf string,
+   and ARG is passed as an argument to it.  */
+
+void
+error (string, arg1, arg2, arg3)
+     char *string;
+     int arg1, arg2, arg3;
+{
+  fflush (stdout);
+  fprintf (stderr, string, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+  return_to_top_level ();
+}
+
+/* Print an error message and exit reporting failure.
+   This is for a error that we cannot continue from.
+   STRING and ARG are passed to fprintf.  */
+
+void
+fatal (string, arg)
+     char *string;
+     int arg;
+{
+  fprintf (stderr, "gdb: ");
+  fprintf (stderr, string, arg);
+  fprintf (stderr, "\n");
+  exit (1);
+}
+
+/* Make a copy of the string at PTR with SIZE characters
+   (and add a null character at the end in the copy).
+   Uses malloc to get the space.  Returns the address of the copy.  */
+
+char *
+savestring (ptr, size)
+     char *ptr;
+     int size;
+{
+  register char *p = (char *) xmalloc (size + 1);
+  bcopy (ptr, p, size);
+  p[size] = 0;
+  return p;
+}
+
+char *
+concat (s1, s2, s3)
+     char *s1, *s2, *s3;
+{
+  register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
+  register char *val = (char *) xmalloc (len);
+  strcpy (val, s1);
+  strcat (val, s2);
+  strcat (val, s3);
+  return val;
+}
+
+void
+print_spaces (n, file)
+     register int n;
+     register FILE *file;
+{
+  while (n-- > 0)
+    fputc (' ', file);
+}
+
+/* Ask user a y-or-n question and return 1 iff answer is yes.
+   Takes three args which are given to printf to print the question.
+   The first, a control string, should end in "? ".
+   It should not say how to answer, because we do that.  */
+
+int
+query (ctlstr, arg1, arg2)
+     char *ctlstr;
+{
+  register int answer;
+
+  /* Automatically answer "yes" if input is not from a terminal.  */
+  if (!input_from_terminal_p ())
+    return 1;
+
+  while (1)
+    {
+      printf (ctlstr, arg1, arg2);
+      printf ("(y or n) ");
+      fflush (stdout);
+      answer = fgetc (stdin);
+      clearerr (stdin);		/* in case of C-d */
+      if (answer != '\n')
+	while (fgetc (stdin) != '\n') clearerr (stdin);
+      if (answer >= 'a')
+	answer -= 040;
+      if (answer == 'Y')
+	return 1;
+      if (answer == 'N')
+	return 0;
+      printf ("Please answer y or n.\n");
+    }
+}
+
+/* Parse a C escape sequence.  STRING_PTR points to a variable
+   containing a pointer to the string to parse.  That pointer
+   is updated past the characters we use.  The value of the
+   escape sequence is returned.
+
+   A negative value means the sequence \ newline was seen,
+   which is supposed to be equivalent to nothing at all.
+
+   If \ is followed by a null character, we return a negative
+   value and leave the string pointer pointing at the null character.
+
+   If \ is followed by 000, we return 0 and leave the string pointer
+   after the zeros.  A value of 0 does not mean end of string.  */
+
+int
+parse_escape (string_ptr)
+     char **string_ptr;
+{
+  register int c = *(*string_ptr)++;
+  switch (c)
+    {
+    case 'a':
+      return '\a';
+    case 'b':
+      return '\b';
+    case 'e':
+      return 033;
+    case 'f':
+      return '\f';
+    case 'n':
+      return '\n';
+    case 'r':
+      return '\r';
+    case 't':
+      return '\t';
+    case 'v':
+      return '\v';
+    case '\n':
+      return -2;
+    case 0:
+      (*string_ptr)--;
+      return 0;
+    case '^':
+      c = *(*string_ptr)++;
+      if (c == '\\')
+	c = parse_escape (string_ptr);
+      if (c == '?')
+	return 0177;
+      return (c & 0200) | (c & 037);
+      
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+      {
+	register int i = c - '0';
+	register int count = 0;
+	while (++count < 3)
+	  {
+	    if ((c = *(*string_ptr)++) >= '0' && c <= '7')
+	      {
+		i *= 8;
+		i += c - '0';
+	      }
+	    else
+	      {
+		(*string_ptr)--;
+		break;
+	      }
+	  }
+	return i;
+      }
+    default:
+      return c;
+    }
+}
+
+void
+printchar (ch, stream)
+     unsigned char ch;
+     FILE *stream;
+{
+  register int c = ch;
+  if (c < 040 || c >= 0177)
+    {
+      if (c == '\n')
+	fprintf (stream, "\\n");
+      else if (c == '\b')
+	fprintf (stream, "\\b");
+      else if (c == '\t')
+	fprintf (stream, "\\t");
+      else if (c == '\f')
+	fprintf (stream, "\\f");
+      else if (c == '\r')
+	fprintf (stream, "\\r");
+      else if (c == 033)
+	fprintf (stream, "\\e");
+      else if (c == '\a')
+	fprintf (stream, "\\a");
+      else
+	fprintf (stream, "\\%03o", c);
+    }
+  else
+    {
+      if (c == '\\' || c == '"' || c == '\'')
+	fputc ('\\', stream);
+      fputc (c, stream);
+    }
+}
diff --git a/gdb/valarith.c b/gdb/valarith.c
new file mode 100644
index 0000000..03bc1e1
--- /dev/null
+++ b/gdb/valarith.c
@@ -0,0 +1,365 @@
+/* Perform arithmetic and other operations on values, for GDB.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "value.h"
+#include "expression.h"
+
+START_FILE
+
+value
+value_add (arg1, arg2)
+	value arg1, arg2;
+{
+  register value val, valint, valptr;
+  register int len;
+
+  COERCE_ARRAY (arg1);
+  COERCE_ARRAY (arg2);
+
+  if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
+       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
+      &&
+      (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
+       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
+    /* Exactly one argument is a pointer, and one is an integer.  */
+    {
+      if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
+	{
+	  valptr = arg1;
+	  valint = arg2;
+	}
+      else
+	{
+	  valptr = arg2;
+	  valint = arg1;
+	}
+      len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
+      if (len == 0) len = 1;	/* For (void *) */
+      val = value_from_long (builtin_type_long,
+			     value_as_long (valptr)
+			     + (len * value_as_long (valint)));
+      VALUE_TYPE (val) = VALUE_TYPE (valptr);
+      return val;
+    }
+
+  return value_binop (arg1, arg2, BINOP_ADD);
+}
+
+value
+value_sub (arg1, arg2)
+	value arg1, arg2;
+{
+  register value val;
+
+  COERCE_ARRAY (arg1);
+  COERCE_ARRAY (arg2);
+
+  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
+      && 
+      TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
+    {
+      val = value_from_long (builtin_type_long,
+			     value_as_long (arg1)
+			     - TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) * value_as_long (arg2));
+      VALUE_TYPE (val) = VALUE_TYPE (arg1);
+      return val;
+    }
+
+  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
+      && 
+      VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
+    {
+      val = value_from_long (builtin_type_long,
+			     (value_as_long (arg1) - value_as_long (arg2))
+			     / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
+      return val;
+    }
+
+  return value_binop (arg1, arg2, BINOP_SUB);
+}
+
+/* Return the value of ARRAY[IDX].  */
+
+value
+value_subscript (array, idx)
+     value array, idx;
+{
+  return value_ind (value_add (array, idx));
+}
+
+/* Perform a binary operation on two integers or two floats.
+   Does not support addition and subtraction on pointers;
+   use value_add or value_sub if you want to handle those possibilities.  */
+
+value
+value_binop (arg1, arg2, op)
+     value arg1, arg2;
+     int op;
+{
+  register value val;
+
+  COERCE_ENUM (arg1);
+  COERCE_ENUM (arg2);
+
+  if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
+       &&
+       TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
+      ||
+      (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
+       &&
+       TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
+    error ("Argument to arithmetic operation not a number.");
+
+  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
+      ||
+      TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
+    {
+      double v1, v2, v;
+      v1 = value_as_double (arg1);
+      v2 = value_as_double (arg2);
+      switch (op)
+	{
+	case BINOP_ADD:
+	  v = v1 + v2;
+	  break;
+
+	case BINOP_SUB:
+	  v = v1 - v2;
+	  break;
+
+	case BINOP_MUL:
+	  v = v1 * v2;
+	  break;
+
+	case BINOP_DIV:
+	  v = v1 / v2;
+	  break;
+
+	default:
+	  error ("Integer-only operation on floating point number.");
+	}
+
+      val = allocate_value (builtin_type_double);
+      *(double *) VALUE_CONTENTS (val) = v;
+    }
+  else
+    {
+      long v1, v2, v;
+      v1 = value_as_long (arg1);
+      v2 = value_as_long (arg2);
+
+      switch (op)
+	{
+	case BINOP_ADD:
+	  v = v1 + v2;
+	  break;
+
+	case BINOP_SUB:
+	  v = v1 - v2;
+	  break;
+
+	case BINOP_MUL:
+	  v = v1 * v2;
+	  break;
+
+	case BINOP_DIV:
+	  v = v1 / v2;
+	  break;
+
+	case BINOP_REM:
+	  v = v1 % v2;
+	  break;
+
+	case BINOP_LSH:
+	  v = v1 << v2;
+	  break;
+
+	case BINOP_RSH:
+	  v = v1 >> v2;
+	  break;
+
+	case BINOP_LOGAND:
+	  v = v1 & v2;
+	  break;
+
+	case BINOP_LOGIOR:
+	  v = v1 | v2;
+	  break;
+
+	case BINOP_LOGXOR:
+	  v = v1 ^ v2;
+	  break;
+
+	case BINOP_AND:
+	  v = v1 && v2;
+	  break;
+
+	case BINOP_OR:
+	  v = v1 || v2;
+	  break;
+
+	default:
+	  error ("Invalid binary operation on numbers.");
+	}
+
+      val = allocate_value (builtin_type_long);
+      *(long *) VALUE_CONTENTS (val) = v;
+    }
+
+  return val;
+}
+
+/* Simulate the C operator ! -- return 1 if ARG1 contains zeros.  */
+
+int
+value_zerop (arg1)
+     value arg1;
+{
+  register int len;
+  register char *p;
+
+  COERCE_ARRAY (arg1);
+
+  len = TYPE_LENGTH (VALUE_TYPE (arg1));
+  p = VALUE_CONTENTS (arg1);
+
+  while (--len >= 0)
+    {
+      if (*p++)
+	break;
+    }
+
+  return len < 0;
+}
+
+/* Simulate the C operator == by returning a 1
+   iff ARG1 and ARG2 have equal contents.  */
+
+int
+value_equal (arg1, arg2)
+     register value arg1, arg2;
+
+{
+  register int len;
+  register char *p1, *p2;
+  enum type_code code1;
+  enum type_code code2;
+
+  COERCE_ARRAY (arg1);
+  COERCE_ARRAY (arg2);
+
+  code1 = TYPE_CODE (VALUE_TYPE (arg1));
+  code2 = TYPE_CODE (VALUE_TYPE (arg2));
+
+  if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
+    return value_as_long (arg1) == value_as_long (arg2);
+  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
+	   && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
+    return value_as_double (arg1) == value_as_double (arg2);
+  else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
+	   || (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
+    return value_as_long (arg1) == value_as_long (arg2);
+  else if (code1 == code2
+	   && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
+	       == TYPE_LENGTH (VALUE_TYPE (arg2))))
+    {
+      p1 = VALUE_CONTENTS (arg1);
+      p2 = VALUE_CONTENTS (arg2);
+      while (--len >= 0)
+	{
+	  if (*p1++ != *p2++)
+	    break;
+	}
+      return len < 0;
+    }
+  else
+    error ("Invalid type combination in equality test.");
+}
+
+/* Simulate the C operator < by returning 1
+   iff ARG1's contents are less than ARG2's.  */
+
+int
+value_less (arg1, arg2)
+     register value arg1, arg2;
+{
+  register enum type_code code1;
+  register enum type_code code2;
+
+  COERCE_ARRAY (arg1);
+  COERCE_ARRAY (arg2);
+
+  code1 = TYPE_CODE (VALUE_TYPE (arg1));
+  code2 = TYPE_CODE (VALUE_TYPE (arg2));
+
+  if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
+    return value_as_long (arg1) < value_as_long (arg2);
+  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
+	   && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
+    return value_as_double (arg1) < value_as_double (arg2);
+  else if ((code1 == TYPE_CODE_PTR || code1 == TYPE_CODE_INT)
+	   && (code2 == TYPE_CODE_PTR || code2 == TYPE_CODE_INT))
+    return value_as_long (arg1) < value_as_long (arg2);
+  else
+    error ("Invalid type combination in ordering comparison.");
+}
+
+/* The unary operators - and ~.  Both free the argument ARG1.  */
+
+value
+value_neg (arg1)
+     register value arg1;
+{
+  register struct type *type;
+
+  COERCE_ENUM (arg1);
+
+  type = VALUE_TYPE (arg1);
+
+  if (TYPE_CODE (type) == TYPE_CODE_FLT)
+    return value_from_double (type, - value_as_double (arg1));
+  else if (TYPE_CODE (type) == TYPE_CODE_INT)
+    return value_from_long (type, - value_as_long (arg1));
+  else
+    error ("Argument to negate operation not a number.");
+}
+
+value
+value_lognot (arg1)
+     register value arg1;
+{
+  COERCE_ENUM (arg1);
+
+  if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
+    error ("Argument to complement operation not an integer.");
+
+  return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
+}
+
+static
+initialize ()
+{
+}
+
+END_FILE
diff --git a/gdb/valops.c b/gdb/valops.c
new file mode 100644
index 0000000..9f0e3cc
--- /dev/null
+++ b/gdb/valops.c
@@ -0,0 +1,600 @@
+/* Perform non-arithmetic operations on values, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "value.h"
+
+START_FILE
+
+/* Cast value ARG2 to type TYPE and return as a value.
+   More general than a C cast: accepts any two types of the same length,
+   and if ARG2 is an lvalue it can be cast into anything at all.  */
+
+value
+value_cast (type, arg2)
+     struct type *type;
+     register value arg2;
+{
+  register enum type_code code1;
+  register enum type_code code2;
+  register int scalar;
+
+  /* Coerce arrays but not enums.  Enums will work as-is
+     and coercing them would cause an infinite recursion.  */
+  if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ENUM)
+    COERCE_ARRAY (arg2);
+
+  code1 = TYPE_CODE (type);
+  code2 = TYPE_CODE (VALUE_TYPE (arg2));
+  scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
+	    || code2 == TYPE_CODE_ENUM);
+
+  if (code1 == TYPE_CODE_FLT && scalar)
+    return value_from_double (type, value_as_double (arg2));
+  else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
+	   && (scalar || code2 == TYPE_CODE_PTR))
+    return value_from_long (type, value_as_long (arg2));
+  else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
+    {
+      VALUE_TYPE (arg2) = type;
+      return arg2;
+    }
+  else if (VALUE_LVAL (arg2) == lval_memory)
+    return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
+  else
+    error ("Invalid cast.");
+}
+
+/* Return the value with a specified type located at specified address.  */
+
+value
+value_at (type, addr)
+     struct type *type;
+     CORE_ADDR addr;
+{
+  register value val = allocate_value (type);
+
+  read_memory (addr, VALUE_CONTENTS (val), TYPE_LENGTH (type));
+  VALUE_LVAL (val) = lval_memory;
+  VALUE_ADDRESS (val) = addr;
+
+  return val;
+}
+
+/* Store the contents of FROMVAL into the location of TOVAL.
+   Return a new value with the location of TOVAL and contents of FROMVAL.  */
+
+value
+value_assign (toval, fromval)
+     register value toval, fromval;
+{
+  register struct type *type = VALUE_TYPE (toval);
+  register value val;
+  char raw_buffer[MAX_REGISTER_RAW_SIZE];
+  char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+  int use_buffer = 0;
+
+  COERCE_ARRAY (fromval);
+
+  if (VALUE_LVAL (toval) != lval_internalvar)
+    fromval = value_cast (type, fromval);
+
+  /* If TOVAL is a special machine register requiring conversion
+     of program values to a special raw format,
+     convert FROMVAL's contents now, with result in `raw_buffer',
+     and set USE_BUFFER to the number of bytes to write.  */
+     
+  if (VALUE_REGNO (toval) >= 0
+      && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
+    {
+      int regno = VALUE_REGNO (toval);
+      if (VALUE_TYPE (fromval) != REGISTER_VIRTUAL_TYPE (regno))
+	fromval = value_cast (REGISTER_VIRTUAL_TYPE (regno), fromval);
+      bcopy (VALUE_CONTENTS (fromval), virtual_buffer,
+	     REGISTER_VIRTUAL_SIZE (regno));
+      REGISTER_CONVERT_TO_RAW (regno, virtual_buffer, raw_buffer);
+      use_buffer = REGISTER_RAW_SIZE (regno);
+    }
+
+  switch (VALUE_LVAL (toval))
+    {
+    case lval_internalvar:
+      set_internalvar (VALUE_INTERNALVAR (toval), fromval);
+      break;
+
+    case lval_internalvar_component:
+      set_internalvar_component (VALUE_INTERNALVAR (toval),
+				 VALUE_OFFSET (toval),
+				 VALUE_BITPOS (toval),
+				 VALUE_BITSIZE (toval),
+				 fromval);
+      break;
+
+    case lval_memory:
+      if (VALUE_BITSIZE (toval))
+	{
+	  int val;
+	  read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+		       &val, sizeof val);
+	  modify_field (&val, value_as_long (fromval),
+			VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+	  write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			&val, sizeof val);
+	}
+      else if (use_buffer)
+	write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+		      raw_buffer, use_buffer);
+      else
+	write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+		      VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
+      break;
+
+    case lval_register:
+      if (VALUE_BITSIZE (toval))
+	{
+	  int val;
+
+	  read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			       &val, sizeof val);
+	  modify_field (&val, value_as_long (fromval),
+			VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+	  write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+				&val, sizeof val);
+	}
+      else if (use_buffer)
+	write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			      raw_buffer, use_buffer);
+      else
+	write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			      VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
+      break;
+
+    default:
+      error ("Left side of = operation is not an lvalue.");
+    }
+
+  /* Return a value just like TOVAL except with the contents of FROMVAL.  */
+
+  val = allocate_value (type);
+  bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
+  bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
+
+  return val;
+}
+
+/* Extend a value VAL to COUNT repetitions of its type.  */
+
+value
+value_repeat (arg1, count)
+     value arg1;
+     int count;
+{
+  register value val;
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Only values in memory can be extended with '@'.");
+  if (count < 1)
+    error ("Invalid number %d of repetitions.", count);
+
+  val = allocate_repeat_value (VALUE_TYPE (arg1), count);
+
+  read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
+	       VALUE_CONTENTS (val),
+	       TYPE_LENGTH (VALUE_TYPE (val)) * count);
+  VALUE_LVAL (val) = lval_memory;
+  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
+
+  return val;
+}
+
+value
+value_of_variable (var)
+     struct symbol *var;
+{
+  return read_var_value (var, (CORE_ADDR) 0);
+}
+
+/* Given a value which is an array, return a value which is
+   a pointer to its first element.  */
+
+value
+value_coerce_array (arg1)
+     value arg1;
+{
+  register struct type *type;
+  register value val;
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Attempt to take address of value not located in memory.");
+
+  /* Get type of elements.  */
+  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
+    type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
+  else
+    /* A phony array made by value_repeat.
+       Its type is the type of the elements, not an array type.  */
+    type = VALUE_TYPE (arg1);
+
+  /* Get the type of the result.  */
+  type = lookup_pointer_type (type);
+  val = value_from_long (builtin_type_long,
+			 VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1));
+  VALUE_TYPE (val) = type;
+  return val;
+}
+
+/* Return a pointer value for the object for which ARG1 is the contents.  */
+
+value
+value_addr (arg1)
+     value arg1;
+{
+  register struct type *type;
+  register value val, arg1_coerced;
+
+  /* Taking the address of an array is really a no-op
+     once the array is coerced to a pointer to its first element.  */
+  arg1_coerced = arg1;
+  COERCE_ARRAY (arg1_coerced);
+  if (arg1 != arg1_coerced)
+    return arg1_coerced;
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Attempt to take address of value not located in memory.");
+
+  /* Get the type of the result.  */
+  type = lookup_pointer_type (VALUE_TYPE (arg1));
+  val = value_from_long (builtin_type_long,
+			 VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1));
+  VALUE_TYPE (val) = type;
+  return val;
+}
+
+/* Given a value of a pointer type, apply the C unary * operator to it.  */
+
+value
+value_ind (arg1)
+     value arg1;
+{
+  COERCE_ARRAY (arg1);
+
+  /* Allow * on an integer so we can cast it to whatever we want.  */
+  if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
+    return value_at (builtin_type_long, 
+		     (CORE_ADDR) value_as_long (arg1));
+  else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
+    return value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
+		     (CORE_ADDR) value_as_long (arg1));
+  error ("Attempt to take contents of a non-pointer value.");
+}
+
+/* Pushing small parts of stack frames.  */
+
+/* Push one word (the size of object that a register holds).  */
+
+CORE_ADDR
+push_word (sp, buffer)
+     CORE_ADDR sp;
+     REGISTER_TYPE buffer;
+{
+  register int len = sizeof (REGISTER_TYPE);
+
+#if 1 INNER_THAN 2
+  sp -= len;
+  write_memory (sp, &buffer, len);
+#else /* stack grows upward */
+  write_memory (sp, &buffer, len);
+  sp += len;
+#endif /* stack grows upward */
+
+  return sp;
+}
+
+/* Push LEN bytes with data at BUFFER.  */
+
+CORE_ADDR
+push_bytes (sp, buffer, len)
+     CORE_ADDR sp;
+     char *buffer;
+     int len;
+{
+#if 1 INNER_THAN 2
+  sp -= len;
+  write_memory (sp, buffer, len);
+#else /* stack grows upward */
+  write_memory (sp, buffer, len);
+  sp += len;
+#endif /* stack grows upward */
+
+  return sp;
+}
+
+/* Push onto the stack the specified value VALUE.  */
+
+CORE_ADDR
+value_push (sp, arg)
+     register CORE_ADDR sp;
+     value arg;
+{
+  register int len = TYPE_LENGTH (VALUE_TYPE (arg));
+
+#if 1 INNER_THAN 2
+  sp -= len;
+  write_memory (sp, VALUE_CONTENTS (arg), len);
+#else /* stack grows upward */
+  write_memory (sp, VALUE_CONTENTS (arg), len);
+  sp += len;
+#endif /* stack grows upward */
+
+  return sp;
+}
+
+/* Perform the standard coercions that are specified
+   for arguments to be passed to C functions.  */
+
+value
+value_arg_coerce (arg)
+     value arg;
+{
+  register struct type *type;
+
+  COERCE_ENUM (arg);
+
+  type = VALUE_TYPE (arg);
+
+  if (TYPE_CODE (type) == TYPE_CODE_INT
+      && TYPE_LENGTH (type) < sizeof (int))
+    return value_cast (builtin_type_int, arg);
+
+  if (type == builtin_type_float)
+    return value_cast (builtin_type_double, arg);
+
+  return arg;
+}
+
+/* Push the value ARG, first coercing it as an argument
+   to a C function.  */
+
+CORE_ADDR
+value_arg_push (sp, arg)
+     register CORE_ADDR sp;
+     value arg;
+{
+  return value_push (sp, value_arg_coerce (arg));
+}
+
+/* Perform a function call in the inferior.
+   ARGS is a vector of values of arguments (NARGS of them).
+   FUNCTION is a value, the function to be called.
+   Returns a value representing what the function returned.
+   May fail to return, if a breakpoint or signal is hit
+   during the execution of the function.  */
+
+value
+call_function (function, nargs, args)
+     value function;
+     int nargs;
+     value *args;
+{
+  register CORE_ADDR sp;
+  register int i;
+  CORE_ADDR start_sp;
+  static REGISTER_TYPE dummy[] = CALL_DUMMY;
+  REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)];
+  CORE_ADDR old_sp;
+  struct type *value_type;
+
+  PUSH_DUMMY_FRAME;
+
+  {
+    register CORE_ADDR funaddr;
+    register struct type *ftype = VALUE_TYPE (function);
+    register enum type_code code = TYPE_CODE (ftype);
+
+    /* Determine address to call.  */
+    if (code == TYPE_CODE_FUNC)
+      {
+	funaddr = VALUE_ADDRESS (function);
+	value_type = TYPE_TARGET_TYPE (ftype);
+      }
+    else if (code == TYPE_CODE_PTR)
+      {
+	funaddr = value_as_long (function);
+	if (TYPE_CODE (TYPE_TARGET_TYPE (ftype))
+	    == TYPE_CODE_FUNC)
+	  value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
+	else
+	  value_type = builtin_type_int;
+      }
+    else if (code == TYPE_CODE_INT)
+      {
+	/* Handle the case of functions lacking debugging info.
+	   Their values are characters since their addresses are char */
+	if (TYPE_LENGTH (ftype) == 1)
+	  funaddr = value_as_long (value_addr (function));
+	else
+	  /* Handle integer used as address of a function.  */
+	  funaddr = value_as_long (function);
+
+	value_type = builtin_type_int;
+      }
+    else
+      error ("Invalid data type for function to be called.");
+
+    /* Create a call sequence customized for this function
+       and the number of arguments for it.  */
+    bcopy (dummy, dummy1, sizeof dummy);
+    FIX_CALL_DUMMY (dummy1, funaddr, nargs);
+  }
+
+  old_sp = sp = read_register (SP_REGNUM);
+
+#if 1 INNER_THAN 2  /* Stack grows down */
+  sp -= sizeof dummy;
+  write_memory (sp, dummy1, sizeof dummy);
+  start_sp = sp;
+  for (i = nargs - 1; i >= 0; i--)
+    sp = value_arg_push (sp, args[i]);
+#else  /* Stack grows up */
+  start_sp = sp;
+  write_memory (sp, dummy1, sizeof dummy);
+  sp += sizeof dummy;
+  for (i = 0; i < nargs; i++)
+    sp = value_arg_push (sp, args[i]);
+#endif  /* Stack grows up */
+
+  write_register (SP_REGNUM, sp);
+
+  /* Figure out the value returned by the function.  */
+  {
+    char retbuf[REGISTER_BYTES];
+
+    /* Execute the stack dummy routine, calling FUNCTION.
+       When it is done, discard the empty frame
+       after storing the contents of all regs into retbuf.  */
+    run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf);
+
+    return value_being_returned (value_type, retbuf);
+  }
+}
+
+/* Create a value for a string constant:
+   Call the function malloc in the inferior to get space for it,
+   then copy the data into that space
+   and then return the address with type char *.
+   PTR points to the string constant data; LEN is number of characters.  */
+
+value
+value_string (ptr, len)
+     char *ptr;
+     int len;
+{
+  register value val;
+  register struct symbol *sym;
+  value blocklen;
+  register char *copy = (char *) alloca (len + 1);
+  char *i = ptr;
+  register char *o = copy, *ibeg = ptr;
+  register int c;
+
+  /* Copy the string into COPY, processing escapes.
+     We could not conveniently process them in expread
+     because the string there wants to be a substring of the input.  */
+
+  while (i - ibeg < len)
+    {
+      c = *i++;
+      if (c == '\\')
+	{
+	  c = parse_escape (&i);
+	  if (c == -1)
+	    continue;
+	}
+      *o++ = c;
+    }
+  *o = 0;
+
+  /* Get the length of the string after escapes are processed.  */
+
+  len = o - copy;
+
+  /* Find the address of malloc in the inferior.  */
+
+  sym = lookup_symbol ("malloc", 0, VAR_NAMESPACE);
+  if (sym != 0)
+    {
+      if (SYMBOL_CLASS (sym) != LOC_BLOCK)
+	error ("\"malloc\" exists in this program but is not a function.");
+      val = value_of_variable (sym);
+    }
+  else
+    {
+      register int i;
+      for (i = 0; i < misc_function_count; i++)
+	if (!strcmp (misc_function_vector[i].name, "malloc"))
+	  break;
+      if (i < misc_function_count)
+	val = value_from_long (builtin_type_long,
+			       misc_function_vector[i].address);
+      else
+	error ("String constants require the program to have a function \"malloc\".");
+    }
+
+  blocklen = value_from_long (builtin_type_int, len + 1);
+  val = call_function (val, 1, &blocklen);
+  if (value_zerop (val))
+    error ("No memory available for string constant.");
+  write_memory (value_as_long (val), copy, len + 1);
+  VALUE_TYPE (val) = lookup_pointer_type (builtin_type_char);
+  return val;
+}
+
+/* Given ARG1, a value of type (pointer to a)* structure/union,
+   extract the component named NAME from the ultimate target structure/union
+   and return it as a value with its appropriate type.
+   ERR is used in the error message if ARG1's type is wrong.  */
+   
+value
+value_struct_elt (arg1, name, err)
+     register value arg1;
+     char *name;
+     char *err;
+{
+  register struct type *t;
+  register int i;
+
+  COERCE_ARRAY (arg1);
+
+  t = VALUE_TYPE (arg1);
+
+  /* Follow pointers until we get to a non-pointer.  */
+
+  while (TYPE_CODE (t) == TYPE_CODE_PTR)
+    {
+      arg1 = value_ind (arg1);
+      COERCE_ARRAY (arg1);
+      t = VALUE_TYPE (arg1);
+    }
+
+  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+      &&
+      TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Attempt to extract a component of a value that is not a %s.", err);
+
+  for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
+    {
+      if (!strcmp (TYPE_FIELD_NAME (t, i), name))
+	break;
+    }
+
+  if (i < 0)
+    error ("Structure has no component named %s.", name);
+
+  return value_field (arg1, i);
+}
+
+static
+initialize ()
+{ }
+
+END_FILE
diff --git a/gdb/valprint.c b/gdb/valprint.c
new file mode 100644
index 0000000..78c8d63
--- /dev/null
+++ b/gdb/valprint.c
@@ -0,0 +1,622 @@
+/* Print values for GNU debugger gdb.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include "defs.h"
+#include "initialize.h"
+#include "symtab.h"
+#include "value.h"
+
+/* Maximum number of chars to print for a string pointer value
+   or vector contents.  */
+
+static int print_max;
+
+static void type_print_varspec_suffix ();
+static void type_print_varspec_prefix ();
+static void type_print_base ();
+
+START_FILE
+
+char **unsigned_type_table;
+char **signed_type_table;
+char **float_type_table;
+
+/* Print the value VAL in C-ish syntax on stream STREAM.
+   If the object printed is a string pointer, returns
+   the number of string bytes printed.  */
+
+value_print (val, stream)
+     value val;
+     FILE *stream;
+{
+  register int i, n, typelen;
+
+  /* A "repeated" value really contains several values in a row.
+     They are made by the @ operator.
+     Print such values as if they were arrays.  */
+
+  if (VALUE_REPEATED (val))
+    {
+      n = VALUE_REPETITIONS (val);
+      typelen = TYPE_LENGTH (VALUE_TYPE (val));
+      fputc ('{', stream);
+      /* Print arrays of characters using string syntax.  */
+      if (VALUE_TYPE (val) == builtin_type_char
+	  || VALUE_TYPE (val) == builtin_type_unsigned_char)
+	{
+	  fputc ('"', stream);
+	  for (i = 0; i < n && i < print_max; i++)
+	    {
+	      QUIT;
+	      printchar (VALUE_CONTENTS (val)[i], stream);
+	    }
+	  if (i < n)
+	    fprintf (stream, "...");
+	  fputc ('"', stream);
+	}
+      else
+	{
+	  for (i = 0; i < n && i < print_max; i++)
+	    {
+	      if (i)
+		fprintf (stream, ", ");
+	      val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
+			 VALUE_ADDRESS (val) + typelen * i, stream);
+	    }
+	  if (i < n)
+	    fprintf (stream, "...");
+	}
+      fputc ('}', stream);
+    }
+  else
+    {
+      /* A simple (nonrepeated) value */
+      /* If it is a pointer, indicate what it points to.  */
+      if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
+	{
+	  fprintf (stream, "(");
+	  type_print (VALUE_TYPE (val), "", stream, -1);
+	  fprintf (stream, ") ");
+	}
+      return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
+			VALUE_ADDRESS (val), stream);
+    }
+}
+
+/* Print on STREAM data stored in debugger at address VALADDR
+   according to the format of type TYPE.
+   ADDRESS is the location in the inferior that the data
+   is supposed to have come from.
+
+   If the data are a string pointer, returns the number of
+   sting characters printed.  */
+
+int
+val_print (type, valaddr, address, stream)
+     struct type *type;
+     char *valaddr;
+     CORE_ADDR address;
+     FILE *stream;
+{
+  register int i;
+  int len;
+  struct type *elttype;
+  int eltlen;
+  int val;
+  unsigned char c;
+
+  QUIT;
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+      if (TYPE_LENGTH (type) >= 0)
+	{
+	  elttype = TYPE_TARGET_TYPE (type);
+	  eltlen = TYPE_LENGTH (elttype);
+	  len = TYPE_LENGTH (type) / eltlen;
+	  fprintf (stream, "{");
+	  /* For an array of chars, print with string syntax.  */
+	  if (elttype == builtin_type_char
+	      || elttype == builtin_type_unsigned_char)
+	    {
+	      fputc ('"', stream);
+	      for (i = 0; i < len && i < print_max; i++)
+		{
+		  QUIT;
+		  printchar (valaddr[i], stream);
+		}
+	      if (i < len)
+		fprintf (stream, "...");
+	      fputc ('"', stream);
+	    }
+	  else
+	    {
+	      for (i = 0; i < len && i < print_max; i++)
+		{
+		  if (i) fprintf (stream, ", ");
+		  val_print (elttype, valaddr + i * eltlen,
+			     0, stream);
+		}
+	      if (i < len)
+		fprintf (stream, "...");
+	    }
+	  fprintf (stream, "}");
+	  break;
+	}
+      /* Array of unspecified length: treat like pointer.  */
+
+    case TYPE_CODE_PTR:
+      fprintf (stream, "0x%x", * (int *) valaddr);
+      /* For a pointer to char or unsigned char,
+	 also print the string pointed to, unless pointer is null.  */
+      if ((TYPE_TARGET_TYPE (type) == builtin_type_char
+	   || TYPE_TARGET_TYPE (type) == builtin_type_unsigned_char)
+	  && unpack_long (type, valaddr) != 0)
+	{
+	  fputc (' ', stream);
+	  fputc ('"', stream);
+	  for (i = 0; i < print_max; i++)
+	    {
+	      QUIT;
+	      read_memory (unpack_long (type, valaddr) + i, &c, 1);
+	      if (c == 0)
+		break;
+	      printchar (c, stream);
+	    }
+	  fputc ('"', stream);
+	  if (i == print_max)
+	    fprintf (stream, "...");
+	  fflush (stream);
+	  /* Return number of characters printed, plus one for the
+	     terminating null if we have "reached the end".  */
+	  return i + (i != print_max);
+	}
+      break;
+
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+      fprintf (stream, "{");
+      len = TYPE_NFIELDS (type);
+      for (i = 0; i < len; i++)
+	{
+	  if (i) fprintf (stream, ", ");
+	  fprintf (stream, "%s = ", TYPE_FIELD_NAME (type, i));
+	  if (TYPE_FIELD_PACKED (type, i))
+	    {
+	      val = unpack_field_as_long (type, valaddr, i);
+	      val_print (TYPE_FIELD_TYPE (type, i), &val, 0, stream);
+	    }
+	  else
+	    val_print (TYPE_FIELD_TYPE (type, i), 
+		       valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
+		       0, stream);
+	}
+      fprintf (stream, "}");
+      break;
+
+    case TYPE_CODE_ENUM:
+      len = TYPE_NFIELDS (type);
+      val = unpack_long (builtin_type_int, valaddr);
+      for (i = 0; i < len; i++)
+	{
+	  QUIT;
+	  if (val == TYPE_FIELD_VALUE (type, i))
+	    break;
+	}
+      if (i < len)
+	fprintf (stream, "%s", TYPE_FIELD_NAME (type, i));
+      else
+	fprintf (stream, "%d", val);
+      break;
+
+    case TYPE_CODE_FUNC:
+      fprintf (stream, "{");
+      type_print (type, "", stream, -1);
+      fprintf (stream, "} ");
+      fprintf (stream, "0x%x", address);
+      break;
+
+    case TYPE_CODE_INT:
+      fprintf (stream,
+	       TYPE_UNSIGNED (type) ? "%u" : "%d",
+	       unpack_long (type, valaddr));
+      if (type == builtin_type_char
+	  || type == builtin_type_unsigned_char)
+	{
+	  fprintf (stream, " '");
+	  printchar (unpack_long (type, valaddr), stream);
+	  fputc ('\'', stream);
+	}
+      break;
+
+    case TYPE_CODE_FLT:
+#ifdef IEEE_FLOAT
+      if (is_nan (unpack_double (type, valaddr)))
+	{
+	  fprintf (stream, "Nan");
+	  break;
+	}
+#endif
+      fprintf (stream, "%g", unpack_double (type, valaddr));
+      break;
+
+    case TYPE_CODE_VOID:
+      fprintf (stream, "void");
+      break;
+
+    default:
+      error ("Invalid type code in symbol table.");
+    }
+  fflush (stream);
+}
+
+#ifdef IEEE_FLOAT
+
+union ieee {
+  int i[2];
+  double d;
+};
+
+/* Nonzero if ARG (a double) is a NAN.  */
+
+int
+is_nan (arg)
+     union ieee arg;
+{
+  int lowhalf, highhalf;
+  union { int i; char c; } test;
+
+  /* Separate the high and low words of the double.
+     Distinguish big and little-endian machines.  */
+  test.i = 1;
+  if (test.c != 1)
+    /* Big-endian machine */
+    lowhalf = arg.i[1], highhalf = arg.i[0];
+  else
+    lowhalf = arg.i[0], highhalf = arg.i[1];
+
+  /* Nan: exponent is the maximum possible, and fraction is nonzero.  */
+  return (((highhalf>>20) & 0x7ff) == 0x7ff
+	  &&
+	  ! ((highhalf & 0xfffff == 0) && (lowhalf == 0)));
+}
+#endif
+
+/* Print a description of a type TYPE
+   in the form of a declaration of a variable named VARSTRING.
+   Output goes to STREAM (via stdio).
+   If SHOW is positive, we show the contents of the outermost level
+   of structure even if there is a type name that could be used instead.
+   If SHOW is negative, we never show the details of elements' types.  */
+
+type_print (type, varstring, stream, show)
+     struct type *type;
+     char *varstring;
+     FILE *stream;
+     int show;
+{
+  type_print_1 (type, varstring, stream, show, 0);
+}
+
+/* LEVEL is the depth to indent lines by.  */
+
+type_print_1 (type, varstring, stream, show, level)
+     struct type *type;
+     char *varstring;
+     FILE *stream;
+     int show;
+     int level;
+{
+  register enum type_code code;
+  type_print_base (type, stream, show, level);
+  code = TYPE_CODE (type);
+  if ((varstring && *varstring)
+      ||
+      /* Need a space if going to print stars or brackets;
+	 but not if we will print just a type name.  */
+      ((show > 0 || TYPE_NAME (type) == 0)
+       &&
+       (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
+	|| code == TYPE_CODE_ARRAY)))
+    fprintf (stream, " ");
+  type_print_varspec_prefix (type, stream, show, 0);
+  fprintf (stream, "%s", varstring);
+  type_print_varspec_suffix (type, stream, show, 0);
+}
+
+/* Print any asterisks or open-parentheses needed before the
+   variable name (to describe its type).
+
+   On outermost call, pass 0 for PASSED_A_PTR.
+   On outermost call, SHOW > 0 means should ignore
+   any typename for TYPE and show its details.
+   SHOW is always zero on recursive calls.  */
+
+static void
+type_print_varspec_prefix (type, stream, show, passed_a_ptr)
+     struct type *type;
+     FILE *stream;
+     int show;
+     int passed_a_ptr;
+{
+  if (TYPE_NAME (type) && show <= 0)
+    return;
+
+  QUIT;
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_PTR:
+      type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+      fputc ('*', stream);
+      break;
+
+    case TYPE_CODE_FUNC:
+    case TYPE_CODE_ARRAY:
+      type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+      if (passed_a_ptr)
+	fputc ('(', stream);
+      break;
+    }
+}
+
+/* Print any array sizes, function arguments or close parentheses
+   needed after the variable name (to describe its type).
+   Args work like type_print_varspec_prefix.  */
+
+static void
+type_print_varspec_suffix (type, stream, show, passed_a_ptr)
+     struct type *type;
+     FILE *stream;
+     int show;
+     int passed_a_ptr;
+{
+  if (TYPE_NAME (type) && show <= 0)
+    return;
+
+  QUIT;
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+      type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+      if (passed_a_ptr)
+	fprintf (stream, ")");
+      fprintf (stream, "[");
+      if (TYPE_LENGTH (type) >= 0)
+	fprintf (stream, "%d",
+		 TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
+      fprintf (stream, "]");
+      break;
+
+    case TYPE_CODE_PTR:
+      type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1);
+      break;
+
+    case TYPE_CODE_FUNC:
+      type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
+      if (passed_a_ptr)
+	fprintf (stream, ")");
+      fprintf (stream, "()");
+      break;
+    }
+}
+
+/* Print the name of the type (or the ultimate pointer target,
+   function value or array element), or the description of a
+   structure or union.
+
+   SHOW nonzero means don't print this type as just its name;
+   show its real definition even if it has a name.
+   SHOW zero means print just typename or struct tag if there is one
+   SHOW negative means abbreviate structure elements.
+   SHOW is decremented for printing of structure elements.
+
+   LEVEL is the depth to indent by.
+   We increase it for some recursive calls.  */
+
+static void
+type_print_base (type, stream, show, level)
+     struct type *type;
+     FILE *stream;
+     int show;
+     int level;
+{
+  char *name;
+  register int i;
+  register int len;
+  register int lastval;
+
+  QUIT;
+
+  if (TYPE_NAME (type) && show <= 0)
+    {
+      fprintf (stream, TYPE_NAME (type));
+      return;
+    }
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_ARRAY:
+    case TYPE_CODE_PTR:
+    case TYPE_CODE_FUNC:
+      type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
+      break;
+
+    case TYPE_CODE_STRUCT:
+      fprintf (stream, "struct ");
+      goto struct_union;
+
+    case TYPE_CODE_UNION:
+      fprintf (stream, "union ");
+    struct_union:
+      if (TYPE_NAME (type) && (name = TYPE_NAME (type)))
+	{
+	  while (*name != ' ') name++;
+	  fprintf (stream, "%s ", name + 1);
+	}
+      if (show < 0)
+	fprintf (stream, "{...}");
+      else
+	{
+	  fprintf (stream, "{");
+	  len = TYPE_NFIELDS (type);
+	  fprintf (stream, "\n");
+	  for (i = 0; i < len; i++)
+	    {
+	      QUIT;
+	      print_spaces (level + 4, stream);
+
+	      /* If this is a bit-field and there is a gap before it,
+		 print a nameless field to account for the gap.  */
+
+	      if (TYPE_FIELD_PACKED (type, i))
+		{
+		  int gap = (TYPE_FIELD_BITPOS (type, i)
+			     - (i > 0
+				? (TYPE_FIELD_BITPOS (type, i - 1)
+				   + (TYPE_FIELD_PACKED (type, i - 1)
+				      ? TYPE_FIELD_BITSIZE (type, i - 1)
+				      : TYPE_LENGTH (TYPE_FIELD_TYPE (type, i - 1)) * 8))
+				: 0));
+		  if (gap != 0)
+		    {
+		      fprintf (stream, "int : %d;\n", gap);
+		      print_spaces (level + 4, stream);
+		    }
+		}
+
+	      /* Print the declaration of this field.  */
+
+	      type_print_1 (TYPE_FIELD_TYPE (type, i),
+			    TYPE_FIELD_NAME (type, i),
+			    stream, show - 1, level + 4);
+
+	      /* Print the field width.  */
+
+	      if (TYPE_FIELD_PACKED (type, i))
+		fprintf (stream, " : %d", TYPE_FIELD_BITSIZE (type, i));
+
+	      fprintf (stream, ";\n");
+	    }
+	  print_spaces (level, stream);
+	  fputc ('}', stream);
+	}
+      break;
+
+    case TYPE_CODE_ENUM:
+      fprintf (stream, "enum ");
+      if (TYPE_NAME (type))
+	{
+	  name = TYPE_NAME (type);
+	  while (*name != ' ') name++;
+	  fprintf (stream, "%s ", name + 1);
+	}
+      if (show < 0)
+	fprintf (stream, "{...}");
+      else
+	{
+	  fprintf (stream, "{");
+	  len = TYPE_NFIELDS (type);
+	  lastval = 0;
+	  for (i = 0; i < len; i++)
+	    {
+	      QUIT;
+	      if (i) fprintf (stream, ", ");
+	      fprintf (stream, "%s", TYPE_FIELD_NAME (type, i));
+	      if (lastval != TYPE_FIELD_VALUE (type, i))
+		{
+		  fprintf (stream, " : %d", TYPE_FIELD_VALUE (type, i));
+		  lastval = TYPE_FIELD_VALUE (type, i);
+		}
+	      lastval++;
+	    }
+	  fprintf (stream, "}");
+	}
+      break;
+
+    case TYPE_CODE_INT:
+      if (TYPE_UNSIGNED (type))
+	name = unsigned_type_table[TYPE_LENGTH (type)];
+      else
+	name = signed_type_table[TYPE_LENGTH (type)];
+      fprintf (stream, "%s", name);
+      break;
+
+    case TYPE_CODE_FLT:
+      name = float_type_table[TYPE_LENGTH (type)];
+      fprintf (stream, "%s", name);
+      break;
+
+    case TYPE_CODE_VOID:
+      fprintf (stream, "void");
+      break;
+
+    case 0:
+      fprintf (stream, "struct unknown");
+      break;
+
+    default:
+      error ("Invalid type code in symbol table.");
+    }
+}
+
+static void
+set_maximum_command (arg)
+     char *arg;
+{
+  if (!arg) error_no_arg ("value for maximum elements to print");
+  print_max = atoi (arg);
+}
+
+static
+initialize ()
+{
+  add_com ("set-maximum", class_vars, set_maximum_command,
+	   "Set NUMBER as limit on string chars or array elements to print.");
+
+  print_max = 200;
+
+  unsigned_type_table
+    = (char **) xmalloc ((1 + sizeof (unsigned long)) * sizeof (char *));
+  bzero (unsigned_type_table, (1 + sizeof (unsigned long)));
+  unsigned_type_table[sizeof (unsigned char)] = "unsigned char";
+  unsigned_type_table[sizeof (unsigned short)] = "unsigned short";
+  unsigned_type_table[sizeof (unsigned long)] = "unsigned long";
+  unsigned_type_table[sizeof (unsigned int)] = "unsigned int";
+
+  signed_type_table
+    = (char **) xmalloc ((1 + sizeof (long)) * sizeof (char *));
+  bzero (signed_type_table, (1 + sizeof (long)));
+  signed_type_table[sizeof (char)] = "char";
+  signed_type_table[sizeof (short)] = "short";
+  signed_type_table[sizeof (long)] = "long";
+  signed_type_table[sizeof (int)] = "int";
+
+  float_type_table
+    = (char **) xmalloc ((1 + sizeof (double)) * sizeof (char *));
+  bzero (float_type_table, (1 + sizeof (double)));
+  float_type_table[sizeof (float)] = "float";
+  float_type_table[sizeof (double)] = "double";
+}
+
+END_FILE
diff --git a/gdb/value.h b/gdb/value.h
new file mode 100644
index 0000000..9801d9a
--- /dev/null
+++ b/gdb/value.h
@@ -0,0 +1,130 @@
+/* Definitions for values of C expressions, for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+enum lval_type { not_lval, lval_memory, lval_register, lval_internalvar,
+		 lval_internalvar_component };
+
+struct value
+  {
+    enum lval_type lval;
+    union
+      {
+	CORE_ADDR address;
+	struct internalvar *internalvar;
+      } location;
+    int offset;
+    int bitsize;
+    int bitpos;
+    struct type *type;
+    struct value *next;
+    short repeated;
+    short repetitions;
+    short regno;
+    long contents[1];
+  };
+
+typedef struct value *value;
+
+#define VALUE_TYPE(val) (val)->type
+#define VALUE_CONTENTS(val) ((char *) (val)->contents)
+#define VALUE_LVAL(val) (val)->lval
+#define VALUE_ADDRESS(val) (val)->location.address
+#define VALUE_INTERNALVAR(val) (val)->location.internalvar
+#define VALUE_OFFSET(val) (val)->offset
+#define VALUE_BITSIZE(val) (val)->bitsize
+#define VALUE_BITPOS(val) (val)->bitpos
+#define VALUE_NEXT(val) (val)->next
+#define VALUE_REPEATED(val) (val)->repeated
+#define VALUE_REPETITIONS(val) (val)->repetitions
+#define VALUE_REGNO(val) (val)->regno
+
+/* If ARG is an array, convert it to a pointer.
+   If ARG is an enum, convert it to an integer.  */
+
+#define COERCE_ARRAY(arg)    \
+{ if (VALUE_REPEATED (arg)						\
+      || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)		\
+    arg = value_coerce_array (arg);					\
+  if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)			\
+    arg = value_cast (builtin_type_unsigned_int, arg);			\
+}
+
+/* If ARG is an enum, convert it to an integer.  */
+
+#define COERCE_ENUM(arg)    \
+{ if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)			\
+    arg = value_cast (builtin_type_unsigned_int, arg);			\
+}
+
+/* Internal variables (variables for convenience of use of debugger)
+   are recorded as a chain of these structures.  */
+
+struct internalvar
+{
+  struct internalvar *next;
+  char *name;
+  value value;
+};
+
+long value_as_long ();
+double value_as_double ();
+long unpack_long ();
+double unpack_double ();
+long unpack_field_as_long ();
+value value_from_long ();
+value value_from_double ();
+value value_at ();
+value value_of_variable ();
+value value_of_register ();
+value read_var_value ();
+value locate_var_value ();
+value allocate_value ();
+value allocate_repeat_value ();
+value value_string ();
+
+value value_binop ();
+value value_add ();
+value value_sub ();
+value value_coerce_array ();
+value value_ind ();
+value value_addr ();
+value value_assign ();
+value value_neg ();
+value value_lognot ();
+value value_struct_elt ();
+value value_field ();
+value value_cast ();
+value value_repeat ();
+value value_subscript ();
+
+value call_function ();
+value value_being_returned ();
+
+value evaluate_expression ();
+value evaluate_type ();
+value parse_and_eval ();
+
+value access_value_history ();
+value value_of_internalvar ();
+struct internalvar *lookup_internalvar ();
+
+int value_equal ();
+int value_less ();
+int value_zerop ();
diff --git a/gdb/values.c b/gdb/values.c
new file mode 100644
index 0000000..9af5d96
--- /dev/null
+++ b/gdb/values.c
@@ -0,0 +1,749 @@
+/* Low level packing and unpacking of values for GDB.
+   Copyright (C) 1986, 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "value.h"
+
+/* The value-history records all the values printed
+   by print commands during this session.  Each chunk
+   records 60 consecutive values.  The first chunk on
+   the chain records the most recent values.
+   The total number of values is in value_history_count.  */
+
+#define VALUE_HISTORY_CHUNK 60
+
+struct value_history_chunk
+{
+  struct value_history_chunk *next;
+  value values[VALUE_HISTORY_CHUNK];
+};
+
+/* Chain of chunks now in use.  */
+
+static struct value_history_chunk *value_history_chain;
+
+static int value_history_count;	/* Abs number of last entry stored */
+
+START_FILE
+
+/* List of all value objects currently allocated
+   (except for those released by calls to release_value)
+   This is so they can be freed after each command.  */
+
+static value all_values;
+
+/* Allocate a  value  that has the correct length for type TYPE.  */
+
+value
+allocate_value (type)
+     struct type *type;
+{
+  register value val;
+
+  val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
+  VALUE_NEXT (val) = all_values;
+  all_values = val;
+  VALUE_TYPE (val) = type;
+  VALUE_LVAL (val) = not_lval;
+  VALUE_ADDRESS (val) = 0;
+  VALUE_OFFSET (val) = 0;
+  VALUE_BITPOS (val) = 0;
+  VALUE_BITSIZE (val) = 0;
+  VALUE_REPEATED (val) = 0;
+  VALUE_REPETITIONS (val) = 0;
+  VALUE_REGNO (val) = -1;
+  return val;
+}
+
+/* Allocate a  value  that has the correct length
+   for COUNT repetitions type TYPE.  */
+
+value
+allocate_repeat_value (type, count)
+     struct type *type;
+     int count;
+{
+  register value val;
+
+  val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
+  VALUE_NEXT (val) = all_values;
+  all_values = val;
+  VALUE_TYPE (val) = type;
+  VALUE_LVAL (val) = not_lval;
+  VALUE_ADDRESS (val) = 0;
+  VALUE_OFFSET (val) = 0;
+  VALUE_BITPOS (val) = 0;
+  VALUE_BITSIZE (val) = 0;
+  VALUE_REPEATED (val) = 1;
+  VALUE_REPETITIONS (val) = count;
+  VALUE_REGNO (val) = -1;
+  return val;
+}
+
+/* Free all the values that have been allocated (except for those released).
+   Called after each command, successful or not.  */
+
+void
+free_all_values ()
+{
+  register value val, next;
+
+  for (val = all_values; val; val = next)
+    {
+      next = VALUE_NEXT (val);
+      free (val);
+    }
+
+  all_values = 0;
+}
+
+/* Remove VAL from the chain all_values
+   so it will not be freed automatically.  */
+
+void
+release_value (val)
+     register value val;
+{
+  register value v;
+
+  if (all_values == val)
+    {
+      all_values = val->next;
+      return;
+    }
+
+  for (v = all_values; v; v = v->next)
+    {
+      if (v->next == val)
+	{
+	  v->next = val->next;
+	  break;
+	}
+    }
+}
+
+/* Return a copy of the value ARG.
+   It contains the same contents, for same memory address,
+   but it's a different block of storage.  */
+
+static value
+value_copy (arg)
+     value arg;
+{
+  register value val;
+  register struct type *type = VALUE_TYPE (arg);
+  if (VALUE_REPEATED (arg))
+    val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
+  else
+    val = allocate_value (type);
+  VALUE_LVAL (val) = VALUE_LVAL (arg);
+  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
+  VALUE_OFFSET (val) = VALUE_OFFSET (arg);
+  VALUE_BITPOS (val) = VALUE_BITPOS (arg);
+  VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
+  VALUE_REGNO (val) = VALUE_REGNO (arg);
+  bcopy (VALUE_CONTENTS (arg), VALUE_CONTENTS (val),
+	 TYPE_LENGTH (VALUE_TYPE (arg))
+	 * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
+  return val;
+}
+
+/* Access to the value history.  */
+
+/* Record a new value in the value history.
+   Returns the absolute history index of the entry.  */
+
+int
+record_latest_value (val)
+     value val;
+{
+  register int i;
+
+  /* Get error now if about to store an invalid float.  */
+  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
+    value_as_double (val);
+
+  /* Here we treat value_history_count as origin-zero
+     and applying to the value being stored now.  */
+
+  i = value_history_count % VALUE_HISTORY_CHUNK;
+  if (i == 0)
+    {
+      register struct value_history_chunk *new
+	= (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk));
+      bzero (new->values, sizeof new->values);
+      new->next = value_history_chain;
+      value_history_chain = new;
+    }
+
+  value_history_chain->values[i] = val;
+  release_value (val);
+
+  /* Now we regard value_history_count as origin-one
+     and applying to the value just stored.  */
+
+  return ++value_history_count;
+}
+
+/* Return a copy of the value in the history with sequence number NUM.  */
+
+value
+access_value_history (num)
+     int num;
+{
+  register struct value_history_chunk *chunk;
+  register int i;
+  register int absnum = num;
+
+  if (absnum <= 0)
+    absnum += value_history_count;
+
+  if (absnum <= 0)
+    {
+      if (num == 0)
+	error ("The history is empty.");
+      else if (num == 1)
+	error ("There is only one value in the history.");
+      else
+	error ("History does not go back to $$%d.", -num);
+    }
+  if (absnum > value_history_count)
+    error ("History has not yet reached $%d.", absnum);
+
+  absnum--;
+
+  /* Now absnum is always absolute and origin zero.  */
+
+  chunk = value_history_chain;
+  for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
+       i > 0; i--)
+    chunk = chunk->next;
+
+  return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
+}
+
+/* Clear the value history entirely.
+   Must be done when new symbol tables are loaded,
+   because the type pointers become invalid.  */
+
+void
+clear_value_history ()
+{
+  register struct value_history_chunk *next;
+  register int i;
+  register value val;
+
+  while (value_history_chain)
+    {
+      for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
+	if (val = value_history_chain->values[i])
+	  free (val);
+      next = value_history_chain->next;
+      free (value_history_chain);
+      value_history_chain = next;
+    }
+  value_history_count = 0;
+}
+
+static void
+history_info (num_exp)
+     char *num_exp;
+{
+  register int i;
+  register value val;
+  register int num;
+
+  if (num_exp)
+    num = parse_and_eval_address (num_exp) - 5;
+  else
+    num = value_history_count - 9;
+
+  if (num <= 0)
+    num = 1;
+
+  for (i = num; i < num + 10 && i <= value_history_count; i++)
+    {
+      val = access_value_history (i);
+      printf ("$%d = ", i);
+      value_print (val, stdout);
+      printf ("\n");
+    }
+}
+
+/* Internal variables.  These are variables within the debugger
+   that hold values assigned by debugger commands.
+   The user refers to them with a '$' prefix
+   that does not appear in the variable names stored internally.  */
+
+static struct internalvar *internalvars;
+
+/* Look up an internal variable with name NAME.  NAME should not
+   normally include a dollar sign.
+
+   If the specified internal variable does not exist,
+   one is created, with a void value.  */
+
+struct internalvar *
+lookup_internalvar (name)
+     char *name;
+{
+  register struct internalvar *var;
+
+  for (var = internalvars; var; var = var->next)
+    if (!strcmp (var->name, name))
+      return var;
+
+  var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
+  var->name = concat (name, "", "");
+  var->value = allocate_value (builtin_type_void);
+  release_value (var->value);
+  var->next = internalvars;
+  internalvars = var;
+  return var;
+}
+
+value
+value_of_internalvar (var)
+     struct internalvar *var;
+{
+  register value val = value_copy (var->value);
+  VALUE_LVAL (val) = lval_internalvar;
+  VALUE_INTERNALVAR (val) = var;
+}
+
+void
+set_internalvar_component (var, offset, bitpos, bitsize, newval)
+     struct internalvar *var;
+     int offset, bitpos, bitsize;
+     value newval;
+{
+  register char *addr = VALUE_CONTENTS (var->value) + offset;
+  if (bitsize)
+    modify_field (addr, value_as_long (newval),
+		  bitpos, bitsize);
+  else
+    bcopy (VALUE_CONTENTS (newval), addr,
+	   TYPE_LENGTH (VALUE_TYPE (newval)));
+}
+
+void
+set_internalvar (var, val)
+     struct internalvar *var;
+     value val;
+{
+  free (var->value);
+  var->value = value_copy (val);
+  release_value (var->value);
+}
+
+char *
+internalvar_name (var)
+     struct internalvar *var;
+{
+  return var->name;
+}
+
+/* Free all internalvars.  Done when new symtabs are loaded,
+   because that makes the values invalid.  */
+
+void
+clear_internalvars ()
+{
+  register struct internalvar *var;
+
+  while (internalvars)
+    {
+      var = internalvars;
+      internalvars = var->next;
+      free (var->name);
+      free (var->value);
+      free (var);
+    }
+}
+
+static void
+convenience_info ()
+{
+  register struct internalvar *var;
+
+  if (internalvars)
+    printf ("Debugger convenience variables:\n\n");
+  else
+    printf ("No debugger convenience variables now defined.\n\
+Convenience variables have names starting with \"$\";\n\
+use \"set\" as in \"set $foo = 5\" to define them.\n");
+
+  for (var = internalvars; var; var = var->next)
+    {
+      printf ("$%s: ", var->name);
+      value_print (var->value, stdout);
+      printf ("\n");
+    }
+}
+
+/* Extract a value as a C number (either long or double).
+   Knows how to convert fixed values to double, or
+   floating values to long.
+   Does not deallocate the value.  */
+
+long
+value_as_long (val)
+     register value val;
+{
+  return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
+}
+
+double
+value_as_double (val)
+     register value val;
+{
+  return unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val));
+}
+
+/* Unpack raw data (copied from debugee) at VALADDR
+   as a long, or as a double, assuming the raw data is described
+   by type TYPE.  Knows how to convert different sizes of values
+   and can convert between fixed and floating point.  */
+
+long
+unpack_long (type, valaddr)
+     struct type *type;
+     char *valaddr;
+{
+  register enum type_code code = TYPE_CODE (type);
+  register int len = TYPE_LENGTH (type);
+  register int nosign = TYPE_UNSIGNED (type);
+
+  if (code == TYPE_CODE_ENUM)
+    code = TYPE_CODE_INT;
+  if (code == TYPE_CODE_FLT)
+    {
+      if (len == sizeof (float))
+	return * (float *) valaddr;
+
+      if (len == sizeof (double))
+	return * (double *) valaddr;
+    }
+  else if (code == TYPE_CODE_INT && nosign)
+    {
+      if (len == sizeof (char))
+	return * (unsigned char *) valaddr;
+
+      if (len == sizeof (short))
+	return * (unsigned short *) valaddr;
+
+      if (len == sizeof (int))
+	return * (unsigned int *) valaddr;
+
+      if (len == sizeof (long))
+	return * (unsigned long *) valaddr;
+    }
+  else if (code == TYPE_CODE_INT)
+    {
+      if (len == sizeof (char))
+	return * (char *) valaddr;
+
+      if (len == sizeof (short))
+	return * (short *) valaddr;
+
+      if (len == sizeof (int))
+	return * (int *) valaddr;
+
+      if (len == sizeof (long))
+	return * (long *) valaddr;
+    }
+  else if (code == TYPE_CODE_PTR)
+    {
+      if (len == sizeof (char *))
+	return (CORE_ADDR) * (char **) valaddr;
+    }
+
+  error ("Value not integer or pointer.");
+}
+
+double
+unpack_double (type, valaddr)
+     struct type *type;
+     char *valaddr;
+{
+  register enum type_code code = TYPE_CODE (type);
+  register int len = TYPE_LENGTH (type);
+  register int nosign = TYPE_UNSIGNED (type);
+
+  if (code == TYPE_CODE_FLT)
+    {
+      if (INVALID_FLOAT (valaddr, len))
+	error ("Invalid floating value found in program.");
+
+      if (len == sizeof (float))
+	return * (float *) valaddr;
+
+      if (len == sizeof (double))
+	return * (double *) valaddr;
+    }
+  else if (code == TYPE_CODE_INT && nosign)
+    {
+      if (len == sizeof (char))
+	return * (unsigned char *) valaddr;
+
+      if (len == sizeof (short))
+	return * (unsigned short *) valaddr;
+
+      if (len == sizeof (int))
+	return * (unsigned int *) valaddr;
+
+      if (len == sizeof (long))
+	return * (unsigned long *) valaddr;
+    }
+  else if (code == TYPE_CODE_INT)
+    {
+      if (len == sizeof (char))
+	return * (char *) valaddr;
+
+      if (len == sizeof (short))
+	return * (short *) valaddr;
+
+      if (len == sizeof (int))
+	return * (int *) valaddr;
+
+      if (len == sizeof (long))
+	return * (long *) valaddr;
+    }
+
+  error ("Value not floating number.");
+}
+
+/* Given a value ARG1 of a struct or union type,
+   extract and return the value of one of its fields.
+   FIELDNO says which field.  */
+
+value
+value_field (arg1, fieldno)
+     register value arg1;
+     register int fieldno;
+{
+  register value v;
+  register struct type *type = TYPE_FIELD_TYPE (VALUE_TYPE (arg1), fieldno);
+  register int offset;
+
+  /* Handle packed fields */
+
+  offset = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) / 8;
+  if (TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno))
+    {
+      v = value_from_long (type,
+			   unpack_field_as_long (VALUE_TYPE (arg1),
+						 VALUE_CONTENTS (arg1),
+						 fieldno));
+      VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) % 8;
+      VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno);
+    }
+  else
+    {
+      v = allocate_value (type);
+      bcopy (VALUE_CONTENTS (arg1) + offset,
+	     VALUE_CONTENTS (v),
+	     TYPE_LENGTH (type));
+    }
+  VALUE_LVAL (v) = VALUE_LVAL (arg1);
+  if (VALUE_LVAL (arg1) == lval_internalvar)
+    VALUE_LVAL (v) = lval_internalvar_component;
+  VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
+  VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
+  return v;
+}
+
+long
+unpack_field_as_long (type, valaddr, fieldno)
+     struct type *type;
+     char *valaddr;
+     int fieldno;
+{
+  long val;
+  int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
+  int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
+  union { int i; char c; } test;
+
+  bcopy (valaddr + bitpos / 8, &val, sizeof val);
+
+  /* Extracting bits depends on endianness of the machine.  */
+  test.i = 1;
+  if (test.c == 1)
+    /* Little-endian.  */
+    val = val >> (bitpos % 8);
+  else
+    val = val >> (sizeof val * 8 - bitpos % 8 - bitsize);
+
+  val &= (1 << bitsize) - 1;
+  return val;
+}
+
+modify_field (addr, fieldval, bitpos, bitsize)
+     char *addr;
+     int fieldval;
+     int bitpos, bitsize;
+{
+  long oword;
+  union { int i; char c; } test;
+
+  bcopy (addr, &oword, sizeof oword);
+
+  /* Shifting for bit field depends on endianness of the machine.  */
+  test.c = 1;
+  if (test.i != 1)
+    /* not little-endian: assume big-endian.  */
+    bitpos = sizeof oword * 8 - bitpos - bitsize;
+
+  oword &= ~(((1 << bitsize) - 1) << bitpos);
+  oword |= fieldval << bitpos;
+  bcopy (&oword, addr, sizeof oword);
+}
+
+/* Convert C numbers into newly allocated values */
+
+value
+value_from_long (type, num)
+     struct type *type;
+     register long num;
+{
+  register value val = allocate_value (type);
+  register enum type_code code = TYPE_CODE (type);
+  register int len = TYPE_LENGTH (type);
+
+  if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM)
+    {
+      if (len == sizeof (char))
+	* (char *) VALUE_CONTENTS (val) = num;
+      else if (len == sizeof (short))
+	* (short *) VALUE_CONTENTS (val) = num;
+      else if (len == sizeof (int))
+	* (int *) VALUE_CONTENTS (val) = num;
+      else if (len == sizeof (long))
+	* (long *) VALUE_CONTENTS (val) = num;
+      else
+	error ("Integer type encountered with unexpected data length.");
+    }
+  else
+    error ("Unexpected type encountered for integer constant.");
+
+  return val;
+}
+
+value
+value_from_double (type, num)
+     struct type *type;
+     double num;
+{
+  register value val = allocate_value (type);
+  register enum type_code code = TYPE_CODE (type);
+  register int len = TYPE_LENGTH (type);
+
+  if (code == TYPE_CODE_FLT)
+    {
+      if (len == sizeof (float))
+	* (float *) VALUE_CONTENTS (val) = num;
+      else if (len == sizeof (double))
+	* (double *) VALUE_CONTENTS (val) = num;
+      else
+	error ("Floating type encountered with unexpected data length.");
+    }
+  else
+    error ("Unexpected type encountered for floating constant.");
+
+  return val;
+}
+
+/* Deal with the value that is "about to be returned".  */
+
+/* Return the value that a function returning now
+   would be returning to its caller, assuming its type is VALTYPE.
+   RETBUF is where we look for what ought to be the contents
+   of the registers (in raw form).  This is because it is often
+   desirable to restore old values to those registers
+   after saving the contents of interest, and then call
+   this function using the saved values.  */
+
+value
+value_being_returned (valtype, retbuf)
+     register struct type *valtype;
+     char retbuf[REGISTER_BYTES];
+{
+  register value val;
+
+  if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+      || TYPE_CODE (valtype) == TYPE_CODE_UNION)
+    return value_at (valtype, EXTRACT_STRUCT_VALUE_ADDRESS (retbuf));
+
+  val = allocate_value (valtype);
+  EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS (val));
+
+  return val;
+}
+
+/* Store VAL so it will be returned if a function returns now.
+   Does not verify that VAL's type matches what the current
+   function wants to return.  */
+
+void
+set_return_value (val)
+     value val;
+{
+  register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
+  char regbuf[REGISTER_BYTES];
+  double dbuf;
+  long lbuf;
+
+  if (code == TYPE_CODE_STRUCT
+      || code == TYPE_CODE_UNION)
+    error ("Specifying a struct or union return value is not supported.");
+
+  if (code == TYPE_CODE_FLT)
+    {
+      dbuf = value_as_double (val);
+
+      STORE_RETURN_VALUE (VALUE_TYPE (val), &dbuf);
+    }
+  else
+    {
+      lbuf = value_as_long (val);
+      STORE_RETURN_VALUE (VALUE_TYPE (val), &lbuf);
+    }
+}
+
+static
+initialize ()
+{
+  add_info ("convenience", convenience_info,
+	    "Debugger convenience (\"$foo\") variables.\n\
+These variables are created when you assign them values;\n\
+thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
+A few convenience variables are given values automatically GDB:\n\
+\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
+\"$__\" holds the contents of the last address examined with \"x\".");
+
+  add_info ("history", history_info,
+	    "Elements of value history (around item number IDX, or last ten).");
+}
+
+END_FILE
diff --git a/gdb/vax-opcode.h b/gdb/vax-opcode.h
new file mode 100644
index 0000000..1ad1454
--- /dev/null
+++ b/gdb/vax-opcode.h
@@ -0,0 +1,365 @@
+/* vax.opcode.h */
+
+#ifndef vax_opcodeT
+#define vax_opcodeT int
+#endif /* no vax_opcodeT */
+
+struct vot_wot			/* vax opcode table: wot to do with this */
+				/* particular opcode */
+{
+  char *            args;	/* how to compile said opcode */
+  vax_opcodeT       code;	/* op-code (may be > 8 bits!) */
+};
+
+struct vot			/* vax opcode text */
+{
+  char *            name;	/* opcode name: lowercase string  [key]  */
+  struct vot_wot    detail;	/* rest of opcode table          [datum] */
+};
+
+#define vot_how args
+#define vot_code code
+#define vot_detail detail
+#define vot_name name
+
+static struct vot
+votstrs[] =
+{
+{    "halt",	{"",			0x00	} },
+{    "nop",	{"",			0x01	} },
+{    "rei",	{"",			0x02	} },
+{    "bpt",	{"",			0x03	} },
+{    "ret",	{"",			0x04	} },
+{    "rsb",	{"",			0x05	} },
+{    "ldpctx",	{"",			0x06	} },
+{    "svpctx",	{"",			0x07	} },
+{    "cvtps",	{"rwabrwab",		0x08	} },
+{    "cvtsp",	{"rwabrwab",		0x09	} },
+{    "index",	{"rlrlrlrlrlwl",	0x0a	} },
+{    "crc",	{"abrlrwab",		0x0b	} },
+{    "prober",	{"rbrwab",		0x0c	} },
+{    "probew",	{"rbrwab",	        0x0d	} },
+{    "insque",	{"abab",		0x0e	} },
+{    "remque",	{"abwl",		0x0f	} },
+{    "bsbb",	{"bb",			0x10	} },
+{    "brb",	{"bb",			0x11	} },
+{    "bneq",	{"bb",			0x12	} },
+{    "bnequ",	{"bb",			0x12	} },
+{    "beql",	{"bb",			0x13	} },
+{    "beqlu",	{"bb",			0x13	} },
+{    "bgtr",	{"bb",			0x14	} },
+{    "bleq",	{"bb",			0x15	} },
+{    "jsb",	{"ab",			0x16	} },
+{    "jmp",	{"ab",			0x17	} },
+{    "bgeq",	{"bb",			0x18	} },
+{    "blss",	{"bb",			0x19	} },
+{    "bgtru",	{"bb",			0x1a	} },
+{    "blequ",	{"bb",			0x1b	} },
+{    "bvc",	{"bb",			0x1c	} },
+{    "bvs",	{"bb",			0x1d	} },
+{    "bcc",	{"bb",			0x1e	} },
+{    "bgequ",	{"bb",			0x1e	} },
+{    "blssu",	{"bb",			0x1f	} },
+{    "bcs",	{"bb",			0x1f	} },
+{    "addp4",	{"rwabrwab",		0x20	} },
+{    "addp6",	{"rwabrwabrwab",	0x21	} },
+{    "subp4",	{"rwabrwab",		0x22	} },
+{    "subp6",	{"rwabrwabrwab",	0x23	} },
+{    "cvtpt",	{"rwababrwab",		0x24	} },
+{    "mulp",	{"rwabrwabrwab",	0x25	} },
+{    "cvttp",	{"rwababrwab",		0x26	} },
+{    "divp",	{"rwabrwabrwab",	0x27	} },
+{    "movc3",	{"rwabab",		0x28	} },
+{    "cmpc3",	{"rwabab",		0x29	} },
+{    "scanc",	{"rwababrb",		0x2a	} },
+{    "spanc",	{"rwababrb",		0x2b	} },
+{    "movc5",	{"rwabrbrwab",		0x2c	} },
+{    "cmpc5",	{"rwabrbrwab",		0x2d	} },
+{    "movtc",	{"rwabrbabrwab",	0x2e	} },
+{    "movtuc",	{"rwabrbabrwab",	0x2f	} },
+{    "bsbw",	{"bw",			0x30	} },
+{    "brw",	{"bw",			0x31	} },
+{    "cvtwl",	{"rwwl",		0x32	} },
+{    "cvtwb",	{"rwwb",		0x33	} },
+{    "movp",	{"rwabab",		0x34	} },
+{    "cmpp3",	{"rwabab",		0x35	} },
+{    "cvtpl",	{"rwabwl",		0x36	} },
+{    "cmpp4",	{"rwabrwab",		0x37	} },
+{    "editpc",	{"rwababab",		0x38	} },
+{    "matchc",	{"rwabrwab",		0x39	} },
+{    "locc",	{"rbrwab",		0x3a	} },
+{    "skpc",	{"rbrwab",		0x3b	} },
+{    "movzwl",	{"rwwl",		0x3c	} },
+{    "acbw",	{"rwrwmwbw",		0x3d	} },
+{    "movaw",	{"awwl",		0x3e	} },
+{    "pushaw",	{"aw",			0x3f	} },
+{    "addf2",	{"rfmf",		0x40	} },
+{    "addf3",	{"rfrfwf",		0x41	} },
+{    "subf2",	{"rfmf",		0x42	} },
+{    "subf3",	{"rfrfwf",		0x43	} },
+{    "mulf2",	{"rfmf",		0x44	} },
+{    "mulf3",	{"rfrfwf",		0x45	} },
+{    "divf2",	{"rfmf",		0x46	} },
+{    "divf3",	{"rfrfwf",		0x47	} },
+{    "cvtfb",	{"rfwb",		0x48	} },
+{    "cvtfw",	{"rfww",		0x49	} },
+{    "cvtfl",	{"rfwl",		0x4a	} },
+{    "cvtrfl",	{"rfwl",		0x4b	} },
+{    "cvtbf",	{"rbwf",		0x4c	} },
+{    "cvtwf",	{"rwwf",		0x4d	} },
+{    "cvtlf",	{"rlwf",		0x4e	} },
+{    "acbf",	{"rfrfmfbw",		0x4f	} },
+{    "movf",	{"rfwf",		0x50	} },
+{    "cmpf",	{"rfrf",		0x51	} },
+{    "mnegf",	{"rfwf",		0x52	} },
+{    "tstf",	{"rf",			0x53	} },
+{    "emodf",	{"rfrbrfwlwf",		0x54	} },
+{    "polyf",	{"rfrwab",		0x55	} },
+{    "cvtfd",	{"rfwd",		0x56	} },
+                                        /* opcode 57 is not defined yet */
+{    "adawi",	{"rwmw",		0x58	} },
+                                        /* opcode 59 is not defined yet */
+                                        /* opcode 5a is not defined yet */
+                                        /* opcode 5b is not defined yet */
+{    "insqhi",	{"abaq",		0x5c	} },
+{    "insqti",	{"abaq",		0x5d	} },
+{    "remqhi",	{"aqwl",		0x5e	} },
+{    "remqti",	{"aqwl",		0x5f	} },
+{    "addd2",	{"rdmd",		0x60	} },
+{    "addd3",	{"rdrdwd",		0x61	} },
+{    "subd2",	{"rdmd",		0x62	} },
+{    "subd3",	{"rdrdwd",		0x63	} },
+{    "muld2",	{"rdmd",		0x64	} },
+{    "muld3",	{"rdrdwd",		0x65	} },
+{    "divd2",	{"rdmd",		0x66	} },
+{    "divd3",	{"rdrdwd",		0x67	} },
+{    "cvtdb",	{"rdwb",		0x68	} },
+{    "cvtdw",	{"rdww",		0x69	} },
+{    "cvtdl",	{"rdwl",		0x6a	} },
+{    "cvtrdl",	{"rdwl",		0x6b	} },
+{    "cvtbd",	{"rbwd",		0x6c	} },
+{    "cvtwd",	{"rwwd",		0x6d	} },
+{    "cvtld",	{"rlwd",		0x6e	} },
+{    "acbd",	{"rdrdmdbw",		0x6f	} },
+{    "movd",	{"rdwd",		0x70	} },
+{    "cmpd",	{"rdrd",		0x71	} },
+{    "mnegd",	{"rdwd",		0x72	} },
+{    "tstd",	{"rd",			0x73	} },
+{    "emodd",	{"rdrbrdwlwd",		0x74	} },
+{    "polyd",	{"rdrwab",		0x75	} },
+{    "cvtdf",	{"rdwf",		0x76	} },
+                                        /* opcode 77 is not defined yet */
+{    "ashl",	{"rbrlwl",		0x78	} },
+{    "ashq",	{"rbrqwq",		0x79	} },
+{    "emul",	{"rlrlrlwq",		0x7a	} },
+{    "ediv",	{"rlrqwlwl",		0x7b	} },
+{    "clrd",	{"wd",			0x7c	} },
+{    "clrq",	{"wd",			0x7c	} },
+{    "clrg",	{"wg",			0x7c	} },
+{    "movq",	{"rqwq",		0x7d	} },
+{    "movaq",	{"aqwl",		0x7e	} },
+{    "movad",	{"adwl",		0x7e	} },
+{    "pushaq",	{"aq",			0x7f	} },
+{    "pushad",	{"ad",			0x7f	} },
+{    "addb2",	{"rbmb",		0x80	} },
+{    "addb3",	{"rbrbwb",		0x81	} },
+{    "subb2",	{"rbmb",		0x82	} },
+{    "subb3",	{"rbrbwb",		0x83	} },
+{    "mulb2",	{"rbmb",		0x84	} },
+{    "mulb3",	{"rbrbwb",		0x85	} },
+{    "divb2",	{"rbmb",		0x86	} },
+{    "divb3",	{"rbrbwb",		0x87	} },
+{    "bisb2",	{"rbmb",		0x88	} },
+{    "bisb3",	{"rbrbwb",		0x89	} },
+{    "bicb2",	{"rbmb",		0x8a	} },
+{    "bicb3",	{"rbrbwb",		0x8b	} },
+{    "xorb2",	{"rbmb",		0x8c	} },
+{    "xorb3",	{"rbrbwb",		0x8d	} },
+{    "mnegb",	{"rbwb",		0x8e	} },
+{    "caseb",	{"rbrbrb",		0x8f	} },
+{    "movb",	{"rbwb",		0x90	} },
+{    "cmpb",	{"rbrb",		0x91	} },
+{    "mcomb",	{"rbwb",		0x92	} },
+{    "bitb",	{"rbrb",		0x93	} },
+{    "clrb",	{"wb",			0x94	} },
+{    "tstb",	{"rb",			0x95	} },
+{    "incb",	{"mb",			0x96	} },
+{    "decb",	{"mb",			0x97	} },
+{    "cvtbl",	{"rbwl",		0x98	} },
+{    "cvtbw",	{"rbww",		0x99	} },
+{    "movzbl",	{"rbwl",		0x9a	} },
+{    "movzbw",	{"rbww",		0x9b	} },
+{    "rotl",	{"rbrlwl",		0x9c	} },
+{    "acbb",	{"rbrbmbbw",		0x9d	} },
+{    "movab",	{"abwl",		0x9e	} },
+{    "pushab",	{"ab",			0x9f	} },
+{    "addw2",	{"rwmw",		0xa0	} },
+{    "addw3",	{"rwrwww",		0xa1	} },
+{    "subw2",	{"rwmw",		0xa2	} },
+{    "subw3",	{"rwrwww",		0xa3	} },
+{    "mulw2",	{"rwmw",		0xa4	} },
+{    "mulw3",	{"rwrwww",		0xa5	} },
+{    "divw2",	{"rwmw",		0xa6	} },
+{    "divw3",	{"rwrwww",		0xa7	} },
+{    "bisw2",	{"rwmw",		0xa8	} },
+{    "bisw3",	{"rwrwww",		0xa9	} },
+{    "bicw2",	{"rwmw",		0xaa	} },
+{    "bicw3",	{"rwrwww",		0xab	} },
+{    "xorw2",	{"rwmw",		0xac	} },
+{    "xorw3",	{"rwrwww",		0xad	} },
+{    "mnegw",	{"rwww",		0xae	} },
+{    "casew",	{"rwrwrw",		0xaf	} },
+{    "movw",	{"rwww",		0xb0	} },
+{    "cmpw",	{"rwrw",		0xb1	} },
+{    "mcomw",	{"rwww",		0xb2	} },
+{    "bitw",	{"rwrw",		0xb3	} },
+{    "clrw",	{"ww",			0xb4	} },
+{    "tstw",	{"rw",			0xb5	} },
+{    "incw",	{"mw",			0xb6	} },
+{    "decw",	{"mw",			0xb7	} },
+{    "bispsw",	{"rw",			0xb8	} },
+{    "bicpsw",	{"rw",			0xb9	} },
+{    "popr",	{"rw",			0xba	} },
+{    "pushr<",	{"rw",			0xbb	} },
+{    "chmk",	{"rw",			0xbc	} },
+{    "chme",	{"rw",			0xbd	} },
+{    "chms",	{"rw",			0xbe	} },
+{    "chmu",	{"rw",			0xbf	} },
+{    "addl2",	{"rlml",		0xc0	} },
+{    "addl3",	{"rlrlwl",		0xc1	} },
+{    "subl2",	{"rlml",		0xc2	} },
+{    "subl3",	{"rlrlwl",		0xc3	} },
+{    "mull2",	{"rlml",		0xc4	} },
+{    "mull3",	{"rlrlwl",		0xc5	} },
+{    "divl2",	{"rlml",		0xc6	} },
+{    "divl3",	{"rlrlwl",		0xc7	} },
+{    "bisl2",	{"rlml",		0xc8	} },
+{    "bisl3",	{"rlrlwl",		0xc9	} },
+{    "bicl2",	{"rlml",		0xca	} },
+{    "bicl3",	{"rlrlwl",		0xcb	} },
+{    "xorl2",	{"rlml",		0xcc	} },
+{    "xorl3",	{"rlrlwl",		0xcd	} },
+{    "mnegl",	{"rlwl",		0xce	} },
+{    "casel",	{"rlrlrl",		0xcf	} },
+{    "movl",	{"rlwl",		0xd0	} },
+{    "cmpl",	{"rlrl",		0xd1	} },
+{    "mcoml",	{"rlwl",		0xd2	} },
+{    "bitl",	{"rlrl",		0xd3	} },
+{    "clrf",	{"wf",			0xd4	} },
+{    "clrl",	{"wl",			0xd4	} },
+{    "tstl",	{"rl",			0xd5	} },
+{    "incl",	{"ml",			0xd6	} },
+{    "decl",	{"ml",			0xd7	} },
+{    "adwc",	{"rlml",		0xd8	} },
+{    "sbwc",	{"rlml",		0xd9	} },
+{    "mtpr",	{"rlrl",		0xda	} },
+{    "mfpr",	{"rlwl",		0xdb	} },
+{    "movpsl",	{"wl",			0xdc	} },
+{    "pushl",	{"rl",			0xdd	} },
+{    "moval",	{"alwl",		0xde	} },
+{    "movaf",	{"afwl",		0xde	} },
+{    "pushal",	{"al",			0xdf	} },
+{    "pushaf",	{"af",			0xdf	} },
+{    "bbs",	{"rlabbb",		0xe0	} },
+{    "bbc",	{"rlabbb",		0xe1	} },
+{    "bbss",	{"rlabbb",		0xe2	} },
+{    "bbcs",	{"rlabbb",		0xe3	} },
+{    "bbsc",	{"rlabbb",		0xe4	} },
+{    "bbcc",	{"rlabbb",		0xe5	} },
+{    "bbssi",	{"rlabbb",		0xe6	} },
+{    "bbcci",	{"rlabbb",		0xe7	} },
+{    "blbs",	{"rlbb",		0xe8	} },
+{    "blbc",	{"rlbb",		0xe9	} },
+{    "ffs",	{"rlrbvbwl",		0xea	} },
+{    "ffc",	{"rlrbvbwl",		0xeb	} },
+{    "cmpv",	{"rlrbvbrl",		0xec	} },
+{    "cmpzv",	{"rlrbvbrl",		0xed	} },
+{    "extv",	{"rlrbvbwl",		0xee	} },
+{    "extzv",	{"rlrbvbwl",		0xef	} },
+{    "insv",	{"rlrlrbvb",		0xf0	} },
+{    "acbl",	{"rlrlmlbw",		0xf1	} },
+{    "aoblss",	{"rlmlbb",		0xf2	} },
+{    "aobleq",	{"rlmlbb",		0xf3	} },
+{    "sobgeq",	{"mlbb",		0xf4	} },
+{    "sobgtr",	{"mlbb",		0xf5	} },
+{    "cvtlb",	{"rlwb",		0xf6	} },
+{    "cvtlw",	{"rlww",		0xf7	} },
+{    "ashp",	{"rbrwabrbrwab",	0xf8	} },
+{    "cvtlp",	{"rlrwab",		0xf9	} },
+{    "callg",	{"abab",		0xfa	} },
+{    "calls",	{"rlab",		0xfb	} },
+{    "xfc",	{"",			0xfc	} },
+                                        /* undefined opcodes here */
+{    "cvtdh",	{"rdwh",		0x32fd	} },
+{    "cvtgf",	{"rgwh",		0x33fd	} },
+{    "addg2",	{"rgmg",		0x40fd	} },
+{    "addg3",	{"rgrgwg",		0x41fd	} },
+{    "subg2",	{"rgmg",		0x42fd	} },
+{    "subg3",	{"rgrgwg",		0x43fd	} },
+{    "mulg2",	{"rgmg",		0x44fd	} },
+{    "mulg3",	{"rgrgwg",		0x45fd	} },
+{    "divg2",	{"rgmg",		0x46fd	} },
+{    "divg3",	{"rgrgwg",		0x47fd	} },
+{    "cvtgb",	{"rgwb",		0x48fd	} },
+{    "cvtgw",	{"rgww",		0x49fd	} },
+{    "cvtgl",	{"rgwl",		0x4afd	} },
+{    "cvtrgl",	{"rgwl",		0x4bfd	} },
+{    "cvtbg",	{"rbwg",		0x4cfd	} },
+{    "cvtwg",	{"rwwg",		0x4dfd	} },
+{    "cvtlg",	{"rlwg",		0x4efd	} },
+{    "acbg",	{"rgrgmgbw",		0x4ffd	} },
+{    "movg",	{"rgwg",		0x50fd	} },
+{    "cmpg",	{"rgrg",		0x51fd	} },
+{    "mnegg",	{"rgwg",		0x52fd	} },
+{    "tstg",	{"rg",			0x53fd	} },
+{    "emodg",	{"rgrwrgwlwg",		0x54fd	} },
+{    "polyg",	{"rgrwab",		0x55fd	} },
+{    "cvtgh",	{"rgwh",		0x56fd	} },
+                                        /* undefined opcodes here */
+{    "addh2",	{"rhmh",		0x60fd	} },
+{    "addh3",	{"rhrhwh",		0x61fd	} },
+{    "subh2",	{"rhmh",		0x62fd	} },
+{    "subh3",	{"rhrhwh",		0x63fd	} },
+{    "mulh2",	{"rhmh",		0x64fd	} },
+{    "mulh3",	{"rhrhwh",		0x65fd	} },
+{    "divh2",	{"rhmh",		0x66fd	} },
+{    "divh3",	{"rhrhwh",		0x67fd	} },
+{    "cvthb",	{"rhwb",		0x68fd	} },
+{    "cvthw",	{"rhww",		0x69fd	} },
+{    "cvthl",	{"rhwl",		0x6afd	} },
+{    "cvtrhl",	{"rhwl",		0x6bfd	} },
+{    "cvtbh",	{"rbwh",		0x6cfd	} },
+{    "cvtwh",	{"rwwh",		0x6dfd	} },
+{    "cvtlh",	{"rlwh",		0x6efd	} },
+{    "acbh",	{"rhrhmhbw",		0x6ffd	} },
+{    "movh",	{"rhwh",		0x70fd	} },
+{    "cmph",	{"rhrh",		0x71fd	} },
+{    "mnegh",	{"rhwh",		0x72fd	} },
+{    "tsth",	{"rh",			0x73fd	} },
+{    "emodh",	{"rhrwrhwlwh",		0x74fd	} },
+{    "polyh",	{"rhrwab",		0x75fd	} },
+{    "cvthg",	{"rhwg",		0x76fd	} },
+                                        /* undefined opcodes here */
+{    "clrh",	{"wh",			0x7cfd	} },
+{    "clro",	{"wo",			0x7cfd	} },
+{    "movo",	{"rowo",		0x7dfd	} },
+{    "movah",	{"ahwl",		0x7efd	} },
+{    "movao",	{"aowl",		0x7efd	} },
+{    "pushah",	{"ah",			0x7ffd	} },
+{    "pushao",	{"ao",			0x7ffd	} },
+                                        /* undefined opcodes here */
+{    "cvtfh",	{"rfwh",		0x98fd	} },
+{    "cvtfg",	{"rfwg",		0x99fd	} },
+                                        /* undefined opcodes here */
+{    "cvthf",	{"rhwf",		0xf6fd	} },
+{    "cvthd",	{"rhwd",		0xf7fd	} },
+                                        /* undefined opcodes here */
+{    "bugl",	{"rl",			0xfdff	} },
+{    "bugw",	{"rw",			0xfeff	} },
+                                        /* undefined opcodes here */
+
+{      ""       ,   ""          } /* empty is end sentinel */
+
+};				/* votstrs */
+
+/* end: vax.opcode.h */
diff --git a/gdb/vax-pinsn.c b/gdb/vax-pinsn.c
new file mode 100644
index 0000000..9d97415
--- /dev/null
+++ b/gdb/vax-pinsn.c
@@ -0,0 +1,241 @@
+/* Print vax instructions for GDB, the GNU debugger.
+   Copyright (C) 1986 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+#include <stdio.h>
+
+#include "defs.h"
+#include "param.h"
+#include "symtab.h"
+#include "vax-opcode.h"
+
+/* Vax instructions are never longer than this.  */
+#define MAXLEN 62
+
+/* Number of elements in the opcode table.  */
+#define NOPCODES (sizeof votstrs / sizeof votstrs[0])
+
+extern char *reg_names[];
+
+static unsigned char *print_insn_arg ();
+
+/* Print the vax instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn (memaddr, stream)
+     CORE_ADDR memaddr;
+     FILE *stream;
+{
+  unsigned char buffer[MAXLEN];
+  register int i;
+  register unsigned char *p;
+  register char *d;
+
+  read_memory (memaddr, buffer, MAXLEN);
+
+  for (i = 0; i < NOPCODES; i++)
+    if (votstrs[i].detail.code == buffer[0]
+	|| votstrs[i].detail.code == *(unsigned short *)buffer)
+      break;
+
+  /* Handle undefined instructions.  */
+  if (i == NOPCODES)
+    {
+      fprintf (stream, "0%o", buffer[0]);
+      return 1;
+    }
+
+  fprintf (stream, "%s", votstrs[i].name);
+
+  /* Point at first byte of argument data,
+     and at descriptor for first argument.  */
+  p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
+  d = votstrs[i].detail.args;
+
+  if (*d)
+    fputc (' ', stream);
+
+  while (*d)
+    {
+      p = print_insn_arg (d, p, memaddr + (p - buffer), stream);
+      d += 2;
+      if (*d)
+	fprintf (stream, ",");
+    }
+  return p - buffer;
+}
+
+static unsigned char *
+print_insn_arg (d, p, addr, stream)
+     char *d;
+     register char *p;
+     CORE_ADDR addr;
+     FILE *stream;
+{
+  register int regnum = *p & 0xf;
+  float floatlitbuf;
+
+  if (*d == 'b')
+    {
+      if (d[1] == 'b')
+	fprintf (stream, "0x%x", addr + *p++ + 1);
+      else
+	{
+	  fprintf (stream, "0x%x", addr + *(short *)p + 2);
+	  p += 2;
+	}
+    }
+  else
+    switch ((*p++ >> 4) & 0xf)
+      {
+      case 0:
+      case 1:
+      case 2:
+      case 3:			/* Literal mode */
+	if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
+	  {
+	    *(int *)&floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
+	    fprintf (stream, "$%f", floatlitbuf);
+	  }
+	else
+	  fprintf (stream, "$%d", p[-1] & 0x3f);
+	break;
+
+      case 4:			/* Indexed */
+	p = (char *) print_insn_arg (d, p, addr + 1, stream);
+	fprintf (stream, "[%s]", reg_names[regnum]);
+	break;
+
+      case 5:			/* Register */
+	fprintf (stream, reg_names[regnum]);
+	break;
+
+      case 7:			/* Autodecrement */
+	fputc ('-', stream);
+      case 6:			/* Register deferred */
+	fprintf (stream, "(%s)", reg_names[regnum]);
+	break;
+
+      case 9:			/* Autoincrement deferred */
+	fputc ('@', stream);
+	if (regnum == PC_REGNUM)
+	  {
+	    fputc ('#', stream);
+	    print_address (*(long *)p, stream);
+	    p += 4;
+	    break;
+	  }
+      case 8:			/* Autoincrement */
+	if (regnum == PC_REGNUM)
+	  {
+	    fputc ('#', stream);
+	    switch (d[1])
+	      {
+	      case 'b':
+		fprintf (stream, "%d", *p++);
+		break;
+
+	      case 'w':
+		fprintf (stream, "%d", *(short *)p);
+		p += 2;
+		break;
+
+	      case 'l':
+		fprintf (stream, "%d", *(long *)p);
+		p += 4;
+		break;
+
+	      case 'q':
+		fprintf (stream, "0x%x%08x", ((long *)p)[1], ((long *)p)[0]);
+		p += 8;
+		break;
+
+	      case 'o':
+		fprintf (stream, "0x%x%08x%08x%08x",
+			 ((long *)p)[3], ((long *)p)[2],
+			 ((long *)p)[1], ((long *)p)[0]);
+		p += 16;
+		break;
+
+	      case 'f':
+		if (INVALID_FLOAT (p, 4))
+		  fprintf (stream, "<<invalid float 0x%x>>", *(int *) p);
+		else
+		  fprintf (stream, "%f", *(float *) p);
+		p += 4;
+		break;
+
+	      case 'd':
+		if (INVALID_FLOAT (p, 8))
+		  fprintf (stream, "<<invalid float 0x%x%08x>>",
+			   ((long *)p)[1], ((long *)p)[0]);
+		else
+		  fprintf (stream, "%f", *(double *) p);
+		p += 8;
+		break;
+
+	      case 'g':
+		fprintf (stream, "g-float");
+		p += 8;
+		break;
+
+	      case 'h':
+		fprintf (stream, "h-float");
+		p += 16;
+		break;
+
+	      }
+	  }
+	else
+	  fprintf (stream, "(%s)+", reg_names[regnum]);
+	break;
+
+      case 11:			/* Byte displacement deferred */
+	fputc ('@', stream);
+      case 10:			/* Byte displacement */
+	if (regnum == PC_REGNUM)
+	  print_address (addr + *p + 2, stream);
+	else
+	  fprintf (stream, "%d(%s)", *p, reg_names[regnum]);
+	p += 1;
+	break;
+
+      case 13:			/* Word displacement deferred */
+	fputc ('@', stream);
+      case 12:			/* Word displacement */
+	if (regnum == PC_REGNUM)
+	  print_address (addr + *(short *)p + 3, stream);
+	else
+	  fprintf (stream, "%d(%s)", *(short *)p, reg_names[regnum]);
+	p += 2;
+	break;
+
+      case 15:			/* Long displacement deferred */
+	fputc ('@', stream);
+      case 14:			/* Long displacement */
+	if (regnum == PC_REGNUM)
+	  print_address (addr + *(long *)p + 5, stream);
+	else
+	  fprintf (stream, "%d(%s)", *(long *)p, reg_names[regnum]);
+	p += 4;
+      }
+
+  return (unsigned char *) p;
+}
diff --git a/gdb/version.c b/gdb/version.c
new file mode 100644
index 0000000..452ccd8
--- /dev/null
+++ b/gdb/version.c
@@ -0,0 +1,3 @@
+/* Define the current version number of GDB.  */
+
+char *version = "2.4+";
diff --git a/gdb/wait.h b/gdb/wait.h
new file mode 100644
index 0000000..fe7f384
--- /dev/null
+++ b/gdb/wait.h
@@ -0,0 +1,25 @@
+
+/* Define how to access the structure that the wait system call stores.
+   On many systems, there is a structure defined for this.
+   But on vanilla-ish USG systems there is not.  */
+
+#ifndef HAVE_WAIT_STRUCT
+#define WAITTYPE int
+#define WIFSTOPPED(w) (((w)&0377) == 0177)
+#define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
+#define WIFEXITED(w) (((w)&0377) == 0)
+#define WRETCODE(w) ((w) >> 8)
+#define WSTOPSIG(w) ((w) >> 8)
+#define WCOREDUMP(w) (((w)&0200) != 0)
+#define WTERMSIG(w) ((w) & 0177)
+#define WSETSTOP(w,sig)  ((w) = (0177 | ((sig) << 8)))
+#else
+#include <sys/wait.h>
+#define WAITTYPE union wait
+#define WRETCODE(w) (w).w_retcode
+#define WSTOPSIG(w) (w).w_stopsig
+#define WCOREDUMP(w) (w).w_coredump
+#define WTERMSIG(w) (w).w_termsig
+#define WSETSTOP(w,sig)  \
+  ((w).stopsig = (sig), (w).coredump = 0, (w).termsig = 0177)
+#endif
diff --git a/gdb/xgdb.c b/gdb/xgdb.c
new file mode 100644
index 0000000..1b858e8
--- /dev/null
+++ b/gdb/xgdb.c
@@ -0,0 +1,672 @@
+/* Interface from GDB to X windows.
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Original version was contributed by Derek Beatty, 30 June 87.  */
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+
+#include <X11/Xlib.h>
+#include <X11/Intrinsic.h>
+#include <X11/Xresource.h>
+#include <X11/Atoms.h>
+#include <X11/TopLevel.h>
+#include <X11/VPane.h>
+#include <X11/Label.h>
+#include <X11/Text.h>
+#include <X11/Command.h>
+#include <X11/ButtonBox.h>
+
+#include <stdio.h>
+
+/* Cursor used in GDB window.  */
+
+#define gdb_width 16
+#define gdb_height 16
+#define gdb_x_hot 7
+#define gdb_y_hot 0
+static short gdb_bits[] = {
+   0x0000, 0x0140, 0x0220, 0x0220,
+   0x23e2, 0x13e4, 0x09c8, 0x0ff8,
+   0x0220, 0x3ffe, 0x0630, 0x03e0,
+   0x0220, 0x1ffc, 0x2632, 0x01c0};
+
+#define gdb_mask_width 16
+#define gdb_mask_height 16
+#define gdb_mask_x_hot 7
+#define gdb_mask_y_hot 0
+static short gdb_mask_bits[] = {
+   0x0360, 0x07f0, 0x07f0, 0x77f7,
+   0x7fff, 0x7fff, 0x1ffc, 0x1ffc,
+   0x7fff, 0x7fff, 0x7fff, 0x0ff8,
+   0x3ffe, 0x7fff, 0x7fff, 0x7fff};
+
+/* The X display on which the window appears.  */
+
+Display *screen_display;
+
+/* The graphics context.  */
+
+GC default_gc;
+
+/* Windows manipulated by this package.  */
+
+static Window icon_window;
+static Widget containing_widget;
+static Widget source_name_widget;
+static Widget source_text_widget;
+static Widget exec_name_widget;
+static Widget button_box_widget;
+
+/* Source text display.  */
+
+static struct symtab *source_window_symtab = 0;
+
+/* Forward declarations */
+
+static Widget create_text_widget ();
+
+START_FILE
+
+/* Display an appropriate piece of source code in the source window.  */
+
+xgdb_display_source ()
+{
+  char *filename;
+  static Arg labelArgs[1];
+  int linenumbers_changed = 0;
+  static int new = 1;
+
+  struct symtab_and_line get_selected_frame_sal ();
+  struct symtab_and_line sal;
+  struct frame_info fi;
+
+  /* Do nothing if called before we are initialized */
+
+  if (!containing_widget) return;
+
+  /* Get the symtab and line number of the selected frame.  */
+
+  fi = get_frame_info (selected_frame);
+  sal = find_pc_line (fi.pc, fi.next_frame);
+
+  /* Strictly this is wrong, but better than a blank display */
+
+  if (sal.symtab == NULL) 
+    {
+      sal.symtab = current_source_symtab;
+      /* current_source_line may be off by a small number like 4 */
+      sal.line = current_source_line;
+    }
+
+  /* Do a path search and get the exact filename of this source file.
+     Also scan it and find its source lines if not already done.  */
+
+  if (sal.symtab)
+    linenumbers_changed = get_filename_and_charpos (sal.symtab, sal.line,
+						    &filename);
+
+  if (!filename) sal.symtab = NULL;
+
+  /* If the source window may be wrong, destroy it (and make a new one).  */
+
+  if (linenumbers_changed || source_window_symtab != sal.symtab)
+    {
+      static Arg fileArgs[1];
+      new = 1;
+      source_window_symtab = sal.symtab;
+
+      XtSetArg (fileArgs[0], XtNfile, filename);
+      XtSetValues (source_text_widget, fileArgs, XtNumber (fileArgs));
+
+      XtSetArg (labelArgs[0], XtNlabel,
+		filename ? filename : "No source displayed.");
+      XtSetValues (source_name_widget, labelArgs, XtNumber (labelArgs));
+      if (filename) free (filename);
+    }
+
+  /* Update display and cursor positions as necessary.
+     Cursor should be placed on line sal.line.  */
+
+  {
+    static int top_line_number, bottom_line_number;
+    int current_top;
+    Arg textArgs[1];
+
+    if (! new)
+      {
+	int new_top;
+
+	/* Get positions of start of display, and caret */
+	XtSetArg (textArgs[0], XtNdisplayPosition, NULL);
+	XtGetValues (source_text_widget, textArgs, XtNumber (textArgs));
+	new_top = source_charpos_line (source_window_symtab,
+				       (int) textArgs[0].value);
+	bottom_line_number += new_top - top_line_number;
+	top_line_number = new_top;
+      }
+
+    /* If appropriate, scroll the text display.  */
+    if (sal.line < top_line_number
+	|| sal.line > bottom_line_number
+	|| new)
+      {
+	/* yes, these magic numbers are ugly, but I don't know how
+	 * to get the height of a text widget in a V11-portable way
+	 */
+	top_line_number = (sal.line > 15) ? sal.line - 15 : 0;
+	bottom_line_number = top_line_number + 35;
+      
+	XtSetArg (textArgs[0], XtNdisplayPosition,
+		  source_line_charpos (source_window_symtab, top_line_number));
+	XtSetValues (source_text_widget, textArgs, XtNumber (textArgs));
+      }
+
+    /* Set the text display cursor position within the text.  */
+
+    XtSetArg (textArgs[0], XtNinsertPosition, 
+	      source_line_charpos (source_window_symtab, sal.line));
+    XtSetValues (source_text_widget, textArgs, XtNumber (textArgs));
+  }
+}
+
+/* Display FILENAME in the title bar at bottom of window.  */
+
+xgdb_display_exec_file (filename)
+     char *filename;
+{
+  static Arg labelArgs[1];
+
+  XtSetArg (labelArgs[0], XtNlabel, filename);
+  XtSetValues (exec_name_widget, labelArgs, XtNumber (labelArgs));
+}
+
+/* Do any necessary prompting, etc.  */
+
+static char *prompt_string;
+
+static void
+print_prompt ()
+{
+  if (prompt_string)
+    printf ("%s", prompt_string);
+}
+
+/* Handlers for buttons.  */
+
+/* Subroutine used by "print" and "print*" buttons.
+   STARFLAG is 1 for print*, 0 for print.
+   Get the "selection" from X and use it as the operand of a print command.  */
+
+static void
+print_1 (starflag)
+     int starflag;
+{
+  int selected_length;
+  char *selected_text;
+
+  char *cmd = starflag ? "print * " : "print ";
+  register int cmdlen = strlen (cmd);
+  
+  selected_text = XFetchBytes (&selected_length);
+  if (selected_length)
+    {
+      char *line = xmalloc (cmdlen + selected_length + 1);
+      strcpy (line, cmd);
+      strncpy (line + cmdlen, selected_text, selected_length);
+      line[cmdlen + selected_length] = 0;
+
+      execute_command (line, 0);
+
+      free (selected_text);
+      free (line);
+    }
+
+  print_prompt ();
+}
+
+static void
+print_button () 
+{
+  print_1 (0);
+}
+
+static void
+print_star_button () 
+{
+  print_1 (1);
+}
+
+/* Subroutine used by "stop at" and "go till" buttons.
+   Set a breakpoint at the position indicated by the "selection"
+   in the source window, and, if RUNFLAG is nonzero, continue.  */
+
+static void
+breakpoint_button_1 (runflag)
+     int runflag;
+{
+  XtTextPosition start, finish;
+  
+  XtTextGetSelectionPos (screen_display, source_text_widget, &start, &finish);
+  if (!source_window_symtab)
+    printf ("No source file displayed.\n");
+  else
+    {
+      set_breakpoint (source_window_symtab, 
+		      source_charpos_line (source_window_symtab, start),
+		      runflag);
+      if (runflag)
+	{
+	  cont_command (0, 1);
+	  xgdb_display_source ();
+	}
+    }
+  print_prompt ();
+}
+
+static void
+breakpoint_button ()
+{
+  breakpoint_button_1 (0);
+}
+
+static void
+until_button ()
+{
+  breakpoint_button_1 (1);
+}
+
+/* decide if a character is trash */
+static int
+garbage (c)
+     char c;
+{
+  if ('a' <= c && c <= 'z') return 0;
+  if ('A' <= c && c <= 'Z') return 0;
+  if ('0' <= c && c <= '9') return 0;
+  if (c == '_') return 0;
+  return 1;
+}
+
+/* Set a breakpoint at the place specified by the "selection" in X.  */
+
+static void
+explicit_breakpoint_button ()
+{
+  int selected_length;
+  char *selected_text;
+
+  selected_text = XFetchBytes (screen_display, &selected_length);
+  if (selected_length)
+    {
+      char *line = (char *) xmalloc (selected_length + 6);
+      register char *p, *sp, *end;
+
+      strcpy (line, "break ");
+
+      /* Copy selection but exclude "garbage" characters.  */
+
+      p = selected_text;
+      end = p + selected_length;
+      sp = line + strlen (line);
+
+      while (garbage (*p) && p != end) p++;
+      while (!garbage (*p) && p != end)
+	*sp++ = *p++;
+      *sp = 0;
+
+      execute_command (line, 0);
+      free (selected_text);
+      free (line);
+    }
+  print_prompt ();
+}
+
+/* Various trivial buttons,
+   most of which just run one GDB command with no arg.  */
+
+static void
+next_button ()
+{
+  execute_command ("next", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+step_button ()
+{
+  execute_command ("step", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+cont_button ()
+{
+  execute_command ("cont", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+finish_button ()
+{
+  execute_command ("finish", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+#if 0
+static void
+deiconify_button ()
+{
+  XUnmapWindow (screen_display, icon_window);
+  XMapWindow (screen_display, containing_widget);
+}
+
+static void
+iconify_button ()
+{
+#if 0
+  static Arg iconArgs[1];
+  XtSetArg (iconArgs[0], XtNlabel, prompt_string);
+  XtCommandSetValues (icon_window, iconArgs, XtNumber (iconArgs));
+#endif 0
+  XUnmapWindow (screen_display, containing_widget);
+  XMapWindow (screen_display, icon_window);
+}
+#endif 0
+
+static void
+up_button ()
+{
+  execute_command ("up", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+down_button ()
+{
+  execute_command ("down", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+/* Define and display all the buttons.  */
+
+static void
+addbutton (parent, name, function)
+     Widget parent;
+     char *name;
+     void (*function) ();
+{
+  static Arg commandArgs[2];
+
+  XtSetArg (commandArgs[0], XtNlabel, name);
+  XtSetArg (commandArgs[1], XtNfunction, function);
+  XtCreateWidget (name, commandWidgetClass, parent,
+		  commandArgs, XtNumber (commandArgs));
+}
+
+/* Create the button windows and store them in `buttons'.  */
+
+static void
+create_buttons (parent)
+     Widget parent;
+{
+  addbutton (parent, "Brk At", breakpoint_button);
+  addbutton (parent, "Brk In", explicit_breakpoint_button);
+  addbutton (parent, "Go 'til", until_button);
+
+  addbutton (parent, "Print", print_button);
+  addbutton (parent, "Print*", print_star_button);
+
+  addbutton (parent, "Next", next_button);
+  addbutton (parent, "Step", step_button);
+  addbutton (parent, "Cont", cont_button);
+  addbutton (parent, "Finish", finish_button);
+  
+  addbutton (parent, "Up", up_button);
+  addbutton (parent, "Down", down_button);
+
+/*  addbutton (parent, "Iconify", iconify_button); */
+}
+
+/* Create a "label window" that just displays the string LABEL.  */
+
+static Widget
+create_label (name, label)
+     char *name, *label;
+{
+  static Arg labelArgs[2];
+  
+  XtSetArg (labelArgs[0], XtNname, name);
+  XtSetArg (labelArgs[1], XtNlabel, label);
+  return XtCreateWidget ("label1", labelWidgetClass, containing_widget,
+			 labelArgs, XtNumber (labelArgs));
+}
+
+/* Create a subwindow of PARENT that displays and scrolls the contents
+   of file FILENAME.  */
+
+static Widget
+create_text_widget (parent, filename)
+     Window parent;
+     char *filename;
+{
+  static Arg fileArgs[2];
+  
+  XtSetArg (fileArgs[0], XtNfile, filename);
+  XtSetArg (fileArgs[1], XtNtextOptions, scrollVertical);
+  return XtTextDiskCreate (parent, fileArgs, XtNumber (fileArgs));
+}
+
+/* Entry point to create the widgets representing our display.  */
+
+int
+xgdb_create_window ()
+{
+  static Arg frameArgs[]= {
+      {XtNwidth, (XtArgVal) 600},
+      {XtNheight, (XtArgVal) 700},
+  };
+  
+  XrmResourceDataBase db;
+  FILE *rdb_file;
+  XGCValues dummy;
+  
+  /* Init and database stuff.  */
+  screen_display = XOpenDisplay (NULL);
+  if (screen_display == 0)
+    {
+      fprintf (stderr, "Cannot connect to X server");
+      return 0;
+    }
+
+  {
+    char *dummy1[1];
+    dummy1[0] = 0;
+    XtInitialize ("gdb", "gdb", 0, 0, 0, dummy1);
+  }
+
+  /* should be checking .Xdefaults in $HOME */
+  rdb_file = fopen (".Xresources", "r");
+  if (rdb_file != NULL)
+    {
+      XrmGetDataBase (rdb_file, &db);
+      XrmSetCurrentDataBase (db);
+      fclose (rdb_file);
+    }
+  
+  /* Create the containing_widget.  */
+
+  containing_widget = XtCreateWidget ("frame", vPaneWidgetClass, 0,
+				      frameArgs, XtNumber (frameArgs));
+  
+  default_gc = XCreateGC (screen_display, containing_widget, 0, dummy);
+
+  /* Create source file name window and add to containing_widget */
+  source_name_widget
+    = create_label ("Source File", "No source file yet.");
+
+  /* Create an empty source-display window and add to containing_widget */
+  source_text_widget = create_text_widget (containing_widget, "/dev/null");
+
+  /* Create window full of buttons.  */
+  button_box_widget = XtCreateWidget ("Buttons", buttonBoxWidgetClass,
+				      containing_widget, NULL, 0);
+  create_buttons (button_box_widget);
+
+  /* Create exec file name window and add */
+  exec_name_widget = create_label ("Executable", "No executable specified.");
+
+#if 0
+  /* Create icon window.  */
+  {
+    static Arg iconArgs[2];
+    void (*compiler_bug) () = deiconify_button;
+    XtSetArg (iconArgs[0], XtNlabel, "(gdb)");
+    XtSetArg (iconArgs[1], XtNfunction, compiler_bug);
+    icon_window = XtCommandCreate (DefaultRootWindow (screen_display),
+				   iconArgs, XtNumber (iconArgs));
+    XMoveWindow (screen_display, icon_window, 100, 100);	/* HACK */
+#if 0
+    XSetIconWindow (screen_display, containing_widget, icon_window);
+#endif 0
+  }
+#endif 0
+
+#if 0
+  /* Now make the whole thing appear on the display.  */
+  {
+    Pixmap pm1, pm2;
+    XImage image;
+    Cursor curse;
+
+    image.width = gdb_width;
+    image.height = gdb_height;
+    image.xoffset = 0;
+    image.format = XYBitmap;
+    image.byte_order = LSBFirst;
+    image.bitmap_unit = 16;
+    image.bitmap_bit_order = LSBFirst;
+    image.depth = 1;
+    image.bytes_per_line = 2;
+    image.bits_per_pixel = 1;
+
+    pm1 = XCreatePixmap (screen_display, DefaultScreen (screen_display),
+			 gdb_width, gdb_height, 1);
+    pm2 = XCreatePixmap (screen_display, DefaultScreen (screen_display),
+			 gdb_width, gdb_height, 1);
+
+    image.data = (char *) gdb_bits;
+    XPutImage (screen_display, pm1, default_gc, &image, 0, 0, 0, 0,
+	       gdb_width, gdb_height);
+
+    image.data = (char *) gdb_mask_bits;
+    XPutImage (screen_display, pm2, default_gc, &image, 0, 0, 0, 0,
+	       gdb_width, gdb_height);
+
+    curse = XCreatePixmapCursor (screen_display, pm1, pm2,
+				 BlackPixel (screen_display,
+					     DefaultScreen (screen_display)),
+				 WhitePixel (screen_display,
+					     DefaultScreen (screen_display)),
+				 gdb_x_hot, gdb_y_hot);
+
+    XFreePixmap (screen_display, pm1);
+    XFreePixmap (screen_display, pm2);
+
+    XDefineCursor (screen_display, containing_widget, curse);
+    XDefineCursor (screen_display, icon_window, curse);
+  }
+#endif 0
+
+  XtRealizeWidget (containing_widget);
+  XFlush (screen_display);
+
+  return 1;
+}
+
+/* xgdb_dispatch -- Loop, dispatching on window events,
+   until data is available on FP (which is normally stdin).
+   Then return, so the data on FP can be processed.  */
+
+void
+xgdb_dispatch (fp)
+     FILE *fp;
+{
+  int inmask = 1 << fileno (fp);
+  int xmask = 1 << ConnectionNumber (screen_display);
+  int rfds = 0;
+  int nfds;
+  XEvent ev;
+  int pend;
+  
+  while (! (rfds & inmask))
+    {
+      pend = XPending ();
+      if (!pend)
+	{
+	  rfds = inmask | xmask;
+	  /* this isn't right for 4.3 but it works 'cuz of 4.2 compatibility */
+	  nfds = select (32, &rfds, 0, 0, (struct timeval *) 0);
+	}
+      if (pend || rfds & xmask)
+	{
+	  XNextEvent (screen_display, &ev);
+	  XtDispatchEvent (&ev);
+	}
+    }
+}  
+
+/* If we use an X window, the GDB command loop is told to call this function
+   before reading a command from stdin.
+   PROMPT is saved for later use so buttons can print a prompt-string.  */
+
+void
+xgdb_window_hook (infile, prompt)
+     FILE *infile;
+     char *prompt;
+{
+  prompt_string = prompt;
+  xgdb_display_source ();
+  xgdb_dispatch (infile);
+}
+
+static
+initialize ()
+{
+  extern void (*window_hook) ();
+  extern int inhibit_windows;
+
+  if (getenv ("DISPLAY") && ! inhibit_windows)
+    if (xgdb_create_window ())
+      window_hook = xgdb_window_hook;
+
+  specify_exec_file_hook (xgdb_display_exec_file);
+}
+
+END_FILE