Patches for GDB 3.6- for ISC 2.2 (386)

src at eliabel.sf.ca.us src at eliabel.sf.ca.us
Sat Aug 18 16:13:01 AEST 1990


Those are the patches for GDB 3.6- for G++ support under ISC 2.2.

WARNING: The Tar files distributed as the second part of the patches
for ISC 2.2 should be also used for GDB 3.6-. I do not report it for
GDB 3.6- as there is no changes, but some of those files are needed.

Eric P. Meyer
ELIABEL Corp.
emeyer at eliabel.sf.ca.us

diff -pr gdb-3.6/Makefile.dist ../gdb-3.6/Makefile.dist
*** gdb-3.6/Makefile.dist	Tue Jun 26 06:23:36 1990
--- ../gdb-3.6/Makefile.dist	Tue Aug  7 21:26:21 1990
*************** ALLOCA1 =
*** 82,89 ****
   define this to be "malloc.o" if you want to use the gnu malloc routine
   (useful for debugging memory allocation problems in gdb).  Otherwise, leave
   it blank. */
! /* GNU_MALLOC = */
! GNU_MALLOC = malloc.o
  
  /* Flags to be used in compiling malloc.o
   Specify range checking for storage allocation. */
--- 82,89 ----
   define this to be "malloc.o" if you want to use the gnu malloc routine
   (useful for debugging memory allocation problems in gdb).  Otherwise, leave
   it blank. */
! GNU_MALLOC = 
! /* GNU_MALLOC = malloc.o */
  
  /* Flags to be used in compiling malloc.o
   Specify range checking for storage allocation. */
*************** TERMCAP = -ltermcap
*** 114,119 ****
--- 114,126 ----
  #ifndef M_CLIBS
  #define M_CLIBS
  #endif
+ 
+ /* M_COBJS, if defined, has system-dependent objects
+  For example, coff-dbx-dep.o on systems using stabs in coff.  */
+ #ifndef M_COBJS
+ #define M_COBJS
+ #endif
+ 
  CLIBS = ${ADD_FILES} ${TERMCAP} M_CLIBS
  
  ADD_FILES = ${OBSTACK} ${REGEX} ${ALLOCA} ${GNU_MALLOC}
*************** SFILES = blockframe.c breakpoint.c dbxre
*** 126,132 ****
  	 utils.c valarith.c valops.c valprint.c values.c version.c expread.y \
  	 xgdb.c cplus-dem.c
  
! DEPFILES = umax-dep.c gould-dep.c default-dep.c sun3-dep.c \
  	   sparc-dep.c hp9k320-dep.c hp300bsd-dep.c news-dep.c i386-dep.c \
  	   symmetry-dep.c convex-dep.c altos-dep.c isi-dep.c pyr-dep.c
  
--- 133,139 ----
  	 utils.c valarith.c valops.c valprint.c values.c version.c expread.y \
  	 xgdb.c cplus-dem.c
  
! DEPFILES = umax-dep.c gould-dep.c default-dep.c sun3-dep.c coff-dbx-dep.c \
  	   sparc-dep.c hp9k320-dep.c hp300bsd-dep.c news-dep.c i386-dep.c \
  	   symmetry-dep.c convex-dep.c altos-dep.c isi-dep.c pyr-dep.c
  
*************** OBS = main.o blockframe.o breakpoint.o f
*** 177,183 ****
      command.o utils.o expread.o expprint.o pinsn.o environ.o version.o \
      copying.o cplus-dem.o ${READLINEOBS}
  
! TSOBS = core.o inflow.o dep.o
  
  NTSOBS = standalone.o
  
--- 184,190 ----
      command.o utils.o expread.o expprint.o pinsn.o environ.o version.o \
      copying.o cplus-dem.o ${READLINEOBS}
  
! TSOBS = core.o inflow.o dep.o M_COBJS
  
  NTSOBS = standalone.o
  
diff -pr gdb-3.6/a.out.gnu.h ../gdb-3.6/a.out.gnu.h
*** gdb-3.6/a.out.gnu.h	Tue Jan 16 19:17:57 1990
--- ../gdb-3.6/a.out.gnu.h	Tue Aug  7 21:00:14 1990
*************** enum machine_type {
*** 37,43 ****
    M_68020 = 2,
  #endif
  #if defined (M_SPARC)
!   M__SPARC = M_SPARC
  #else
    M_SPARC = 3,
  #endif
--- 37,43 ----
    M_68020 = 2,
  #endif
  #if defined (M_SPARC)
!   M__SPARC = M_SPARC,
  #else
    M_SPARC = 3,
  #endif
diff -pr gdb-3.6/breakpoint.c ../gdb-3.6/breakpoint.c
*** gdb-3.6/breakpoint.c	Sat Jun 30 06:03:33 1990
--- ../gdb-3.6/breakpoint.c	Thu Aug 16 17:43:37 1990
*************** breakpoint_1 (bnum)
*** 436,442 ****
    ALL_BREAKPOINTS (b)
      if (bnum == -1 || bnum == b->number)
        {
! 	printf_filtered ("#%-3d %c  0x%08x ", b->number,
  		"nyod"[(int) b->enable],
  		b->address);
  	last_addr = b->address;
--- 436,442 ----
    ALL_BREAKPOINTS (b)
      if (bnum == -1 || bnum == b->number)
        {
! 	printf_filtered ("#%-3d %c  0x%08x", b->number,
  		"nyod"[(int) b->enable],
  		b->address);
  	last_addr = b->address;
*************** breakpoint_1 (bnum)
*** 444,467 ****
  	  {
  	    sym = find_pc_function (b->address);
  	    if (sym)
- 	      printf_filtered (" in %s (%s line %d)", SYMBOL_NAME (sym),
- 			       b->symtab->filename, b->line_number);
- 	    else
- 	      printf_filtered ("%s line %d", b->symtab->filename, b->line_number);
- 	  }
- 	else
- 	  {
- 	    char *name;
- 	    int addr;
- 
- 	    if (find_pc_partial_function (b->address, &name, &addr))
  	      {
! 		if (b->address - addr)
! 		  printf_filtered ("<%s+%d>", name, b->address - addr);
! 		else
! 		  printf_filtered ("<%s>", name);
  	      }
  	  }
  	      
  	printf_filtered ("\n");
  
--- 444,460 ----
  	  {
  	    sym = find_pc_function (b->address);
  	    if (sym)
  	      {
! 		fputs_filtered (" in ", stdout);
! 		fputs_demangled (SYMBOL_NAME (sym), stdout, 1);
! 		fputs_filtered (" (", stdout);
  	      }
+ 	    fputs_filtered (b->symtab->filename, stdout);
+ 	    printf_filtered (" line %d", b->line_number);
+ 	    if (sym) fputs_filtered(")", stdout);
  	  }
+ 	else
+ 	      print_address_symbolic (b->address, stdout);
  	      
  	printf_filtered ("\n");
  
diff -pr gdb-3.6/coffread.c ../gdb-3.6/coffread.c
*** gdb-3.6/coffread.c	Wed Jan 10 15:54:43 1990
--- ../gdb-3.6/coffread.c	Tue Aug  7 21:00:17 1990
*************** the Free Software Foundation, 675 Mass A
*** 23,29 ****
  #include <stdio.h>
  #include "defs.h"
  #include "param.h"
! #ifdef COFF_FORMAT
  #include "symtab.h"
  
  #ifdef USG
--- 23,29 ----
  #include <stdio.h>
  #include "defs.h"
  #include "param.h"
! #if defined(COFF_FORMAT) && !defined(READ_DBX_FORMAT)
  #include "symtab.h"
  
  #ifdef USG
diff -pr gdb-3.6/config.gdb ../gdb-3.6/config.gdb
*** gdb-3.6/config.gdb	Tue Jan 30 12:35:46 1990
--- ../gdb-3.6/config.gdb	Tue Aug  7 23:06:46 1990
***************
*** 1,3 ****
--- 1,4 ----
+ 
  #!/bin/sh
  
  #
*************** altosgas)
*** 134,139 ****
--- 135,150 ----
  	depfile=altos-dep.c
  	opcodefile=m68k-opcode.h
  	;;
+ pbb)
+ 	m_regex=-DM_REGEX=regex.o
+ 	m_clibs=-DM_CLIBS=-lbsd
+ 	m_cflags=-DM_CFLAGS=-DSETJMP_MASKS_SIGNALS
+ 	m_cobjs=-DM_COBJS=coff-dbx-dep.o
+ 	makedefine="$m_regex $m_cobjs $m_clibs $m_cflags -DM_SYSV"
+ 	pinsnfile=m68k-pinsn.c
+ 	depfile=pbb-dep.c
+ 	opcodefile=m68k-opcode.h
+ 	;;
  pyramid)
  	echo
  	echo "Note that GDB on Pyramids only works with GCC."
*************** i386gas)
*** 195,201 ****
  # These names are short and cryptic due to the @#$#!@#$@! System V
  # 14 character file name limit.
  i386-sv32)
! 	makedefine="-DM_CLIBS=-lPW -DM_SYSV -DM_REGEX=regex.o"
  	pinsnfile=i386-pinsn.c
  	depfile=i386-dep.c
  # The following is a lie, but a necessary one.  See comment at beginning
--- 206,212 ----
  # These names are short and cryptic due to the @#$#!@#$@! System V
  # 14 character file name limit.
  i386-sv32)
! 	makedefine="-DM_CLIBS=-lPW -DM_SYSV -DM_REGEX=regex.o -DM_CFLAGS=-USETJMP_MASKS_SIGNALS -DM_COBJS=coff-dbx-dep.o"
  	pinsnfile=i386-pinsn.c
  	depfile=i386-dep.c
  # The following is a lie, but a necessary one.  See comment at beginning
*************** sun3os4|sun3-os4)
*** 285,290 ****
--- 296,315 ----
  	pinsnfile=m68k-pinsn.c
  	opcodefile=m68k-opcode.h
  	depfile=sun3-dep.c
+ 	;;	
+ sun386i)
+ # Compile GDB without shared libraries so that it can be run on itself.
+ 	makedefine="-DM_CFLAGS=-Bstatic -DM_COBJS=coff-dbx-dep.o"
+ 	echo
+ 	echo "Make sure to compile any program on which you want to run gdb"
+ 	echo " without shared libraries (cc -Bstatic)"
+ 	echo
+ 	paramfile=m-sun386i.h
+ 	pinsnfile=i386-pinsn.c
+ # The following is a lie, but a necessary one.  See comment at beginning
+ # of this file about unneeded files.
+ 	opcodefile=m68k-opcode.h
+ 	depfile=sun386i-dep.c
  	;;	
  sun4os4|sun4-os4)
  # Compile GDB without shared libraries so that it can be run on itself.
diff -pr gdb-3.6/core.c ../gdb-3.6/core.c
*** gdb-3.6/core.c	Wed Jan 10 15:55:17 1990
--- ../gdb-3.6/core.c	Tue Aug  7 21:00:18 1990
*************** xfer_core_file (memaddr, myaddr, len)
*** 343,348 ****
--- 343,352 ----
    int fileptr;
    int returnval = 0;
  
+ #ifdef KERNEL_CORE_HOOK
+   KERNEL_CORE_HOOK	/* can have data definitions and code using them */
+ #endif
+ 
    while (len > 0)
      {
        xferfile = 0;
diff -pr gdb-3.6/cplus-dem.c ../gdb-3.6/cplus-dem.c
*** gdb-3.6/cplus-dem.c	Tue Jun 26 06:23:14 1990
--- ../gdb-3.6/cplus-dem.c	Thu Aug 16 17:44:39 1990
***************
*** 23,29 ****
  
  /* This file exports one function
  
!    char *cplus_demangle (const char *name, int ansi)
     
     If NAME is a mangled function name produced by GNU C++, then
     a pointer to a malloced string giving a C++ representation
--- 23,29 ----
  
  /* This file exports one function
  
!    char *cplus_demangle (const char *name, int mode)
     
     If NAME is a mangled function name produced by GNU C++, then
     a pointer to a malloced string giving a C++ representation
***************
*** 31,39 ****
     It is the caller's responsibility to free the string which
     is returned.
  
!    If ANSI is non-zero, then ANSI qualifiers such as `const',
     `void', and the ellipses operator `...' are output.  Otherwise
     they are not.
  
     For example,
     
--- 31,40 ----
     It is the caller's responsibility to free the string which
     is returned.
  
!    If MODE > 0, then ANSI qualifiers such as `const',
     `void', and the ellipses operator `...' are output.  Otherwise
     they are not.
+    if MODE >= 0, parameter are emiitted; otherwise not.
  
     For example,
     
***************
*** 59,67 ****
--- 60,70 ----
  #include <strings.h>
  #define memcpy(s1, s2, n) bcopy ((s2), (s1), (n))
  #define memcmp(s1, s2, n) bcmp ((s2), (s1), (n))
+ #ifndef i386
  #define strchr index 
  #define strrchr rindex
  #endif
+ #endif
  
  #ifndef __STDC__
  #define const
***************
*** 68,74 ****
  #endif
  
  #ifdef __STDC__
! extern char *cplus_demangle (const char *type, int ansi);
  #else
  extern char *cplus_demangle ();
  #endif
--- 71,77 ----
  #endif
  
  #ifdef __STDC__
! extern char *cplus_demangle (const char *type, int mode);
  #else
  extern char *cplus_demangle ();
  #endif
*************** static void string_prepends (string *p, 
*** 148,158 ****
  #endif
  static void string_prependn (string *p, const char *s, int n);
  static int get_count (const char **type, int *count);
! static int do_args (const char **type, string *decl);
! static int do_type (const char **type, string *result);
! static int do_arg (const char **type, string *result);
! static int do_args (const char **type, string *decl);
! static void munge_function_name (string *name);
  static void remember_type (const char *type, int len);
  #else
  static void string_need ();
--- 151,160 ----
  #endif
  static void string_prependn (string *p, const char *s, int n);
  static int get_count (const char **type, int *count);
! static int do_args (const char **type, string *decl, int arg_mode);
! static int do_type (const char **type, string *result, int arg_mode);
! static int do_arg (const char **type, string *result, int arg_mode);
! static void munge_function_name (string *name, int arg_mode);
  static void remember_type (const char *type, int len);
  #else
  static void string_need ();
*************** static void munge_function_name ();
*** 175,186 ****
  static void remember_type ();
  #endif
  
- static int print_ansi_qualifiers;
- 
  char *
! cplus_demangle (type, ansi)
       const char *type;
!      int ansi;
  {
    string decl;
    int n;
--- 177,186 ----
  static void remember_type ();
  #endif
  
  char *
! cplus_demangle (type, arg_mode)
       const char *type;
!      int arg_mode;
  {
    string decl;
    int n;
*************** cplus_demangle (type, ansi)
*** 193,199 ****
    const char *premangle;
  #endif
  
!   print_ansi_qualifiers = ansi;
  
    if (type == NULL || *type == '\0')
      return NULL;
--- 193,200 ----
    const char *premangle;
  #endif
  
! #define print_ansi_qualifiers (arg_mode > 0)
! #define print_arg_types (arg_mode >= 0)
  
    if (type == NULL || *type == '\0')
      return NULL;
*************** cplus_demangle (type, ansi)
*** 253,259 ****
    else
      {
        string_appendn (&decl, type, p - type);
!       munge_function_name (&decl);
      }
    p += 2;
  
--- 254,260 ----
    else
      {
        string_appendn (&decl, type, p - type);
!       munge_function_name (&decl, arg_mode);
      }
    p += 2;
  
*************** cplus_demangle (type, ansi)
*** 310,322 ****
  #ifndef LONGERNAMES
        remember_type (premangle, p - premangle);
  #endif
!       success = do_args (&p, &decl);
!       if (const_flag)
  	string_append (&decl, " const");
        break;
      case 'F':
        p += 1;
!       success = do_args (&p, &decl);
        break;
      }
  
--- 311,323 ----
  #ifndef LONGERNAMES
        remember_type (premangle, p - premangle);
  #endif
!       success = do_args (&p, &decl, arg_mode);
!       if (const_flag && print_arg_types)
  	string_append (&decl, " const");
        break;
      case 'F':
        p += 1;
!       success = do_args (&p, &decl, arg_mode);
        break;
      }
  
*************** get_count (type, count)
*** 376,384 ****
  /* result will be initialised here; it will be freed on failure */
  
  static int
! do_type (type, result)
       const char **type;
       string *result;
  {
    int n;
    int done;
--- 377,386 ----
  /* result will be initialised here; it will be freed on failure */
  
  static int
! do_type (type, result, arg_mode)
       const char **type;
       string *result;
+      int arg_mode;
  {
    int n;
    int done;
*************** do_type (type, result)
*** 425,431 ****
  	      string_prepend (&decl, "(");
  	      string_append (&decl, ")");
  	    }
! 	  if (!do_args (type, &decl) || **type != '_')
  	    success = 0;
  	  else
  	    *type += 1;
--- 427,433 ----
  	      string_prepend (&decl, "(");
  	      string_append (&decl, ")");
  	    }
! 	  if (!do_args (type, &decl, arg_mode) || **type != '_')
  	    success = 0;
  	  else
  	    *type += 1;
*************** do_type (type, result)
*** 480,486 ****
  		    break;
  		  }
  	      }
! 	    if ((member && !do_args (type, &decl)) || **type != '_')
  	      {
  		success = 0;
  		break;
--- 482,488 ----
  		    break;
  		  }
  	      }
! 	    if ((member && !do_args (type, &decl, arg_mode)) || **type != '_')
  	      {
  		success = 0;
  		break;
*************** do_type (type, result)
*** 502,508 ****
  		  string_append (&decl, " ");
  		else
  		  non_empty = 1;
! 		string_append (&decl, "volatilep");
  	      }
  	    break;
  	  }
--- 504,510 ----
  		  string_append (&decl, " ");
  		else
  		  non_empty = 1;
! 		string_append (&decl, "volatile");
  	      }
  	    break;
  	  }
*************** do_type (type, result)
*** 691,703 ****
  /* `result' will be initialised in do_type; it will be freed on failure */
  
  static int
! do_arg (type, result)
       const char **type;
       string *result;
  {
    const char *start = *type;
  
!   if (!do_type (type, result))
      return 0;
    remember_type (start, *type - start);
    return 1;
--- 693,706 ----
  /* `result' will be initialised in do_type; it will be freed on failure */
  
  static int
! do_arg (type, result, arg_mode)
       const char **type;
       string *result;
+      int arg_mode;
  {
    const char *start = *type;
  
!   if (!do_type (type, result, arg_mode))
      return 0;
    remember_type (start, *type - start);
    return 1;
*************** remember_type (start, len)
*** 733,746 ****
     it won't be freed on failure */
  
  static int
! do_args (type, decl)
       const char **type;
       string *decl;
  {
    string arg;
    int need_comma = 0;
  
!   string_append (decl, "(");
  
    while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v')
      {
--- 736,751 ----
     it won't be freed on failure */
  
  static int
! do_args (type, decl, arg_mode)
       const char **type;
       string *decl;
+      int arg_mode;
  {
    string arg;
    int need_comma = 0;
  
!   if (print_arg_types)
!     string_append (decl, "(");
  
    while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v')
      {
*************** do_args (type, decl)
*** 754,764 ****
  	  while (--r >= 0)
  	    {
  	      const char *tem = typevec[t];
! 	      if (need_comma)
  		string_append (decl, ", ");
! 	      if (!do_arg (&tem, &arg))
  		return 0;
! 	      string_appends (decl, &arg);
  	      string_delete (&arg);
  	      need_comma = 1;
  	    }
--- 759,770 ----
  	  while (--r >= 0)
  	    {
  	      const char *tem = typevec[t];
! 	      if (need_comma && print_arg_types)
  		string_append (decl, ", ");
! 	      if (!do_arg (&tem, &arg, arg_mode))
  		return 0;
! 	      if (print_arg_types)
! 	        string_appends (decl, &arg);
  	      string_delete (&arg);
  	      need_comma = 1;
  	    }
*************** do_args (type, decl)
*** 765,775 ****
  	}
        else
  	{
! 	  if (need_comma)
  	    string_append (decl, ", ");
! 	  if (!do_arg (type, &arg))
  	    return 0;
! 	  string_appends (decl, &arg);
  	  string_delete (&arg);
  	  need_comma = 1;
  	}
--- 771,782 ----
  	}
        else
  	{
! 	  if (need_comma && print_arg_types)
  	    string_append (decl, ", ");
! 	  if (!do_arg (type, &arg, arg_mode))
  	    return 0;
! 	  if (print_arg_types)
! 	    string_appends (decl, &arg);
  	  string_delete (&arg);
  	  need_comma = 1;
  	}
*************** do_args (type, decl)
*** 780,796 ****
    else if (**type == 'e')
      {
        *type += 1;
!       if (need_comma)
! 	string_append (decl, ",");
!       string_append (decl, "...");
      }
  
!   string_append (decl, ")");
    return 1;
  }
  
  static void
! munge_function_name (name)
       string *name;
  {
    if (!string_empty (name) && name->p - name->b >= 3 
--- 787,807 ----
    else if (**type == 'e')
      {
        *type += 1;
!       if (print_arg_types)
! 	{
! 	  if (need_comma)
! 	    string_append (decl, ",");
! 	  string_append (decl, "...");
!         }
      }
  
!   if (print_arg_types)
!     string_append (decl, ")");
    return 1;
  }
  
  static void
! munge_function_name (name, arg_mode)
       string *name;
  {
    if (!string_empty (name) && name->p - name->b >= 3 
*************** munge_function_name (name)
*** 838,844 ****
        /* type conversion operator */
        string type;
        const char *tem = name->b + 5;
!       if (do_type (&tem, &type))
  	{
  	  string_clear (name);
  	  string_append (name, "operator ");
--- 849,855 ----
        /* type conversion operator */
        string type;
        const char *tem = name->b + 5;
!       if (do_type (&tem, &type, arg_mode))
  	{
  	  string_clear (name);
  	  string_append (name, "operator ");
diff -pr gdb-3.6/dbxread.c ../gdb-3.6/dbxread.c
*** gdb-3.6/dbxread.c	Tue Jul  3 12:38:14 1990
--- ../gdb-3.6/dbxread.c	Tue Aug  7 21:03:54 1990
*************** the Free Software Foundation, 675 Mass A
*** 40,57 ****
  #define L_INCR 1
  #endif
  
! #ifdef COFF_ENCAPSULATE
! #include "a.out.encap.h"
! #include "stab.gnu.h"
  #else
! #include <a.out.h>
! 
! #if 0
! #include <stab.h>
! #else
! #include "stab.gnu.h"
! #endif /* 0 */
! 
  #endif
  #include <ctype.h>
  
--- 40,60 ----
  #define L_INCR 1
  #endif
  
! #ifdef COFF_FORMAT
! #  ifdef COFF_ENCAPSULATE
! #    include "a.out.encap.h"
! #    include "stab.gnu.h"
! #  else
! #    include "coff-a.out.h"
! #    ifdef NO_NATIVE_STAB_INCLUDE
! #      include "stab.gnu.h"
! #    else
! #      include <stab.h>
! #    endif
! #  endif
  #else
! #  include <a.out.h>
! #  include <stab.h>
  #endif
  #include <ctype.h>
  
*************** the Free Software Foundation, 675 Mass A
*** 139,144 ****
--- 142,279 ----
  #include "defs.h"
  #include "symtab.h"
  
+ #ifndef SET_NAMESTRING
+ /* Set namestring based on bufp.  */
+ 
+ #ifndef COFF_FORMAT
+ 
+ #define SET_NAMESTRING()\
+   if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)  \
+     error ("Invalid symbol data: bad string table offset: %d",       \
+ 	   bufp->n_un.n_strx);                                       \
+   namestring = bufp->n_un.n_strx + stringtab
+ 
+ #define NEXT_SYMBOL_TEXT() \
+   if (symbuf_idx == symbuf_end) \
+     fill_symbuf (); \
+   symnum++; \
+   return NLIST_INDEX(symbuf,symbuf_idx++).n_un.n_strx + stringtab_global; \
+ 
+ #define IS_O_FILE_START(name,len) ((name[0] == '-' && name[1] == 'l') \
+ 	      || (name [(len = strlen (name)) - 1] == 'o'	      \
+ 		  && name [len - 2] == '.'))
+ 
+ 
+ #else /* COFF FORMAT */
+ 
+ /* copy of symbol count */
+ int  number_of_symbols;	
+ 
+ /* Set namestring based on bufp.  */
+ 
+ struct extra_strings {
+   int next;
+   char *strings;	/* to handle 8 byte or shorter strings 
+ 			 * and continuations.
+ 			 */
+ };
+ 
+ struct extra_strings extra_strings = { 0};
+ struct extra_strings addl_extra_strings = { 0};
+ struct extra_strings *cur_extra = 0;
+ 
+ #define EXTRA_STRINGS_INIT(extra) \
+ { \
+   if (extra.strings) \
+     free (extra.strings); \
+   extra.next = 0; \
+   cur_extra = &extra; \
+   extra.strings = xmalloc(number_of_symbols * (SYMNMLEN+1)); }
+ 
+ #define SET_NAMESTRING()						\
+   if (bufp->n_zeroes)							\
+   {									\
+      ADD_STRING(namestring,(char *) &bufp->n_zeroes);			\
+   }									\
+   else { 								\
+     if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)  \
+ 	error ("Invalid symbol data: bad string table offset: %d",      \
+ 	   bufp->n_un.n_strx);                                       	\
+   namestring = bufp->n_un.n_strx + stringtab;				\
+   }
+ #if 0
+ #ifndef SYMNMLEN
+ #define SYMNMLEN 8
+ #endif
+ #endif
+ 
+ #define ADD_STRING(result,str) { \
+      int i = cur_extra->next; \
+      char *new = &cur_extra->strings[i]; \
+      strncpy(new,str,SYMNMLEN);			\
+      new[SYMNMLEN] = 0;				\
+      cur_extra->next = i + 1 + strlen(new);	\
+      result = new; }
+ 
+ #define NEXT_SYMBOL_TEXT() {						\
+   struct nlist *bufp;							\
+   if (symbuf_idx == symbuf_end) 					\
+     fill_symbuf (); 							\
+   symnum++; 								\
+   bufp = &NLIST_INDEX(symbuf,symbuf_idx++); 				\
+   if (bufp->n_zeroes)							\
+   {									\
+      char *namestring;							\
+      ADD_STRING(namestring,(char *) &bufp->n_zeroes);			\
+      return namestring;							\
+   }									\
+   else	 								\
+     return bufp->n_un.n_strx + stringtab_global;			\
+    }
+ 
+ #define IS_DOT_FILE(name) ( name [0] == '.' && name [1] == 'f' 	\
+ 			      && name [2] == 'i' && name [3] == 'l'	\
+ 			      && name [4] == 'e' && name [5] == 0 )
+ 
+ #define IS_DOT_TEXT(name) ( name [0] == '.' && name [1] == 't'	\
+ 			      && name [2] == 'e' && name [3] == 'x'	\
+ 			      && name [4] == 't' && name [5] == 0 )
+ #ifndef IS_O_FILE_START
+ #ifdef sun386
+ 				/* on the sun386i, the .file symbol oddly
+ 				 * has the same value as the .text symbol 
+ 				 * DESPITE (!) it having scnum -2, and the
+ 				 * .text symbol comes too late.
+ 				 */
+ #define IS_O_FILE_START(name,len) IS_DOT_FILE(name)
+ #else /* not sun386 */
+ #define IS_O_FILE_START(name,len) IS_DOT_TEXT(name)
+ #endif /* not sun386 */ 
+ #endif /* notdef IS_OFILE_START */
+ 
+ 
+ #endif /* COFF FORMAT */
+ #endif /* SET_NAMESTRING */
+ 
+ /* Macro for the size of the on disk symbol table entry. Due to machine
+  * dependent alignment considerations, This might not be the same size
+  * as that generated by the native compiler for the equivalent defining 
+  * structure definition.
+  * The sun386i is one machine for which this is a problem.
+  *
+  * The "index" argument to NLIST_INDEX macro must not be multiply evaluated 
+  */
+ #ifndef NLIST_STRUCT_SIZE
+ #define NLIST_STRUCT_SIZE sizeof(struct nlist)
+ #define NLIST_INCR(p) p++
+ #define NLIST_INDEX(ptr,index) ptr[index]
+ #endif
+ 
+ /* Size (in elements) of buffer for reading the symbol table entries.  */
+ #ifndef SYMBUFSIZE
+ #define SYMBUFSIZE 4096
+ #endif
+ 
  #ifndef COFF_FORMAT
  #ifndef AOUTHDR
  #define AOUTHDR		struct exec
*************** static struct type **read_args ();
*** 197,205 ****
  #ifdef COFF_HEADER
  #define NUMBER_OF_SYMBOLS \
    ((COFF_HEADER(hdr) ? hdr.coffhdr.filehdr.f_nsyms : hdr.a_syms) /	\
!    sizeof (struct nlist))
  #else
! #define NUMBER_OF_SYMBOLS (hdr.a_syms / sizeof (struct nlist))
  #endif
  #endif
  
--- 332,340 ----
  #ifdef COFF_HEADER
  #define NUMBER_OF_SYMBOLS \
    ((COFF_HEADER(hdr) ? hdr.coffhdr.filehdr.f_nsyms : hdr.a_syms) /	\
!    NLIST_STRUCT_SIZE)
  #else
! #define NUMBER_OF_SYMBOLS (hdr.a_syms / NLIST_STRUCT_SIZE)
  #endif
  #endif
  
*************** static struct subfile *current_subfile;
*** 345,351 ****
  
  /* Count symbols as they are processed, for error messages.  */
  
! 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,
--- 480,489 ----
  
  /* Count symbols as they are processed, for error messages.  */
  
! static int symnum=0;
! 				/* dont bother ifdeffing these; theyre cheap */
! int symnum_limit =0;
! int conv_symnum =0;
  
  /* Vector of types defined so far, indexed by their dbx type numbers.
     (In newer sun systems, dbx uses a pair of numbers in parens,
*************** static int undef_types_allocated, undef_
*** 485,492 ****
--- 623,637 ----
  
  #ifdef NAMES_HAVE_UNDERSCORE
  #define HASH_OFFSET 1
+ #define IS_ETEXT(name) name[6] == '\0' && name[5] == 't' \
+ 	      && name[4] == 'x' && name[3] == 'e'	 \
+ 	      && name[2] == 't' && name[1] == 'e'	 \
+ 	      && name[0] == '_'
  #else
  #define HASH_OFFSET 0
+ #define IS_ETEXT(name) name[5] == '\0' && name[4] == 't' \
+ 		    && name[3] == 'x' && name[2] == 'e'	 \
+ 		    && name[1] == 't' && name[0] == 'e'	 
  #endif
  
  #if 0
*************** make_blockvector ()
*** 1090,1097 ****
  }
  
  /* Manage the vector of line numbers.  */
! 
! static void
  record_line (line, pc)
       int line;
       CORE_ADDR pc;
--- 1235,1244 ----
  }
  
  /* Manage the vector of line numbers.  */
! 				/* not static: must be visible from dep.c
! 				 * at least on sun 386i systems.
! 				 */
! void
  record_line (line, pc)
       int line;
       CORE_ADDR pc;
*************** start_symtab (name, start_addr)
*** 1144,1150 ****
    new_object_header_files ();
  
    for (s = symseg_chain; s; s = s->next)
!     if (s->ldsymoff == symnum * sizeof (struct nlist))
        break;
    current_symseg = s;
    if (s != 0)
--- 1291,1297 ----
    new_object_header_files ();
  
    for (s = symseg_chain; s; s = s->next)
!     if (s->ldsymoff == symnum * NLIST_STRUCT_SIZE)
        break;
    current_symseg = s;
    if (s != 0)
*************** extern struct symtab *psymtab_to_symtab 
*** 1580,1585 ****
--- 1727,1735 ----
  /* The entry point.  */
  static CORE_ADDR entry_point;
  
+ static char *symfile_string_table;
+ static int symfile_string_table_size;
+ 
  /* This is the symbol-file command.  Read the file, analyze its symbols,
     and add a struct symtab to symtab_list.  */
  
*************** symbol_file_command (name, from_tty)
*** 1641,1646 ****
--- 1791,1801 ----
  
    READ_FILE_HEADERS (desc, name);
  
+ #ifdef N_MULTI_LINE_TYPE
+   val = init_lineno (desc, scn[text_scn].s_lnnoptr, scn[text_scn].s_nlnno);
+   if (val < 0)
+     error ("\"%s\": error reading line numbers\n", name);
+ #endif 
    entry_point = ENTRY_POINT;
  
    if (NUMBER_OF_SYMBOLS == 0)
*************** symbol_file_command (name, from_tty)
*** 1668,1673 ****
--- 1823,1836 ----
    READ_STRING_TABLE_SIZE (buffer);
    if (buffer >= 0 && buffer < statbuf.st_size)
      {
+       /* This should speed things up without consuming much
+ 	 extra memory (because probably little of the space is going
+ 	 to be reused anyway, whether in data or stack space).
+ 
+ 	 A quick test (running GDB on itself and setting 9 breakpoints
+ 	 in different files) showed that memory usage was almost
+ 	 identical for the two cases.  */
+ #if 0
  #ifdef BROKEN_LARGE_ALLOCA
        stringtab = (char *) xmalloc (buffer);
        make_cleanup (free, stringtab);
*************** symbol_file_command (name, from_tty)
*** 1674,1679 ****
--- 1837,1846 ----
  #else
        stringtab = (char *) alloca (buffer);
  #endif
+ #endif
+       stringtab = (char *) xmalloc (buffer);
+       symfile_string_table = stringtab;
+       symfile_string_table_size = buffer;
      }
    else
      stringtab = NULL;
*************** symbol_file_command (name, from_tty)
*** 1724,1729 ****
--- 1891,1900 ----
    global_symbols = 0;
    make_cleanup (really_free_pendings, 0);
  
+ #ifdef EXTRA_STRINGS_INIT
+   EXTRA_STRINGS_INIT (extra_strings)
+ #endif  
+ 
    /* Now that the symbol table data of the executable file are all in core,
       process them and define symbols accordingly.  Closes desc.  */
  
*************** get_sym_file ()
*** 1773,1788 ****
  }
  
  /* Buffer for reading the symbol table entries.  */
! static struct nlist symbuf[4096];
  static int symbuf_idx;
! static int symbuf_end;
! 
  /* I/O descriptor for reading the symbol table.  */
  static int symtab_input_desc;
  
  /* The address of the string table
     of the object file we are reading (as copied into core).  */
! static char *stringtab_global;
  
  /* Refill the symbol table input buffer
     and set the variables that control fetching entries from it.
--- 1944,1961 ----
  }
  
  /* Buffer for reading the symbol table entries.  */
! static struct nlist symbuf[SYMBUFSIZE];
  static int symbuf_idx;
! int symbuf_end;			/* Not static: may be adjusted from dep.c
! 				 * on coff systems if the buffer's last symbol 
! 				 * has an auxent.
! 				 */
  /* I/O descriptor for reading the symbol table.  */
  static int symtab_input_desc;
  
  /* The address of the string table
     of the object file we are reading (as copied into core).  */
! char *stringtab_global;		/* Not static: dep.c may need it. */
  
  /* Refill the symbol table input buffer
     and set the variables that control fetching entries from it.
*************** static char *stringtab_global;
*** 1793,1802 ****
  static int
  fill_symbuf ()
  {
!   int nbytes = myread (symtab_input_desc, symbuf, sizeof (symbuf));
    if (nbytes <= 0)
      error ("error or end of file reading symbol table");
!   symbuf_end = nbytes / sizeof (struct nlist);
    symbuf_idx = 0;
    return 1;
  }
--- 1966,1978 ----
  static int
  fill_symbuf ()
  {
!   int nbytes = myread (symtab_input_desc, symbuf, SYMBUFSIZE * NLIST_STRUCT_SIZE);
    if (nbytes <= 0)
      error ("error or end of file reading symbol table");
!   symbuf_end = nbytes / NLIST_STRUCT_SIZE;
! #ifdef CONVERT_SYMBUF
!   convert_symbuf(symtab_input_desc,symbuf,symbuf_end);
! #endif  
    symbuf_idx = 0;
    return 1;
  }
*************** fill_symbuf ()
*** 1809,1818 ****
  static char *
  next_symbol_text ()
  {
!   if (symbuf_idx == symbuf_end)
!     fill_symbuf ();
!   symnum++;
!   return symbuf[symbuf_idx++].n_un.n_strx + stringtab_global;
  }
  
  /*
--- 1985,1991 ----
  static char *
  next_symbol_text ()
  {
!   NEXT_SYMBOL_TEXT();		/* contains return of ptr */
  }
  
  /*
*************** read_dbx_symtab (desc, stringtab, string
*** 2001,2006 ****
--- 2174,2182 ----
    symtab_input_desc = desc;	/* This is needed for fill_symbuf below */
    symbuf_end = symbuf_idx = 0;
  
+   symnum_limit = nlistlen;
+   conv_symnum = 0;
+ 
    for (symnum = 0; symnum < nlistlen; symnum++)
      {
        /* Get the symbol for this run and pull out some info */
*************** read_dbx_symtab (desc, stringtab, string
*** 2007,2013 ****
        QUIT;	/* allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf ();
!       bufp = &symbuf[symbuf_idx++];
  
  #ifdef PROFILE_TYPES
        profile_types[bufp->n_type]++;
--- 2183,2189 ----
        QUIT;	/* allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf ();
!       bufp = & NLIST_INDEX(symbuf,symbuf_idx++);
  
  #ifdef PROFILE_TYPES
        profile_types[bufp->n_type]++;
*************** read_dbx_symtab (desc, stringtab, string
*** 2017,2023 ****
         * Special case to speed up readin.
         */
        if (bufp->n_type == N_SLINE) continue;
! 
        /* Ok.  There is a lot of code duplicated in the rest of this
           switch statiement (for efficiency reasons).  Since I don't
           like duplicating code, I will do my penance here, and
--- 2193,2201 ----
         * Special case to speed up readin.
         */
        if (bufp->n_type == N_SLINE) continue;
! #ifdef  N_MULTI_LINE_TYPE
!       if (bufp->n_type == N_MULTI_LINE_TYPE) continue;
! #endif
        /* Ok.  There is a lot of code duplicated in the rest of this
           switch statiement (for efficiency reasons).  Since I don't
           like duplicating code, I will do my penance here, and
*************** read_dbx_symtab (desc, stringtab, string
*** 2030,2041 ****
  	    I've imbedded it in the following macro.
  	 */
        
- /* Set namestring based on bufp.  */
- #define SET_NAMESTRING()\
-   if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)  \
-     error ("Invalid symbol data: bad string table offset: %d",       \
- 	   bufp->n_un.n_strx);                                       \
-   namestring = bufp->n_un.n_strx + stringtab
  
  #define	ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE)\
    do {		        						\
--- 2208,2213 ----
*************** read_dbx_symtab (desc, stringtab, string
*** 2075,2084 ****
  
  	  SET_NAMESTRING();
  
! 	  if (namestring[6] == '\0' && namestring[5] == 't'
! 	      && namestring[4] == 'x' && namestring[3] == 'e'
! 	      && namestring[2] == 't' && namestring[1] == 'e'
! 	      && namestring[0] == '_')
  	    end_of_text_addr = bufp->n_value;
  
  	  /* Figure out beginning and end of global linker symbol
--- 2247,2253 ----
  
  	  SET_NAMESTRING();
  
! 	  if (IS_ETEXT(namestring))
  	    end_of_text_addr = bufp->n_value;
  
  	  /* Figure out beginning and end of global linker symbol
*************** read_dbx_symtab (desc, stringtab, string
*** 2139,2147 ****
  	case N_TEXT:
  /* #endif */
  	  SET_NAMESTRING();
! 	  if ((namestring[0] == '-' && namestring[1] == 'l')
! 	      || (namestring [(nsl = strlen (namestring)) - 1] == 'o'
! 		  && namestring [nsl - 2] == '.'))
  	    {
  	      if (entry_point < bufp->n_value
  		  && entry_point >= last_o_file_start)
--- 2308,2315 ----
  	case N_TEXT:
  /* #endif */
  	  SET_NAMESTRING();
! 
! 	  if (IS_O_FILE_START(namestring,nsl))
  	    {
  	      if (entry_point < bufp->n_value
  		  && entry_point >= last_o_file_start)
*************** read_dbx_symtab (desc, stringtab, string
*** 2149,2158 ****
  		  startup_file_start = last_o_file_start;
  		  startup_file_end = bufp->n_value;
  		}
! 	      if (past_first_source_file && pst)
  		{
  		  end_psymtab (pst, psymtab_include_list, includes_used,
! 			       symnum * sizeof (struct nlist), bufp->n_value,
  			       dependency_list, dependencies_used,
  			       global_psymbols.next, static_psymbols.next);
  		  pst = (struct partial_symtab *) 0;
--- 2317,2329 ----
  		  startup_file_start = last_o_file_start;
  		  startup_file_end = bufp->n_value;
  		}
! 	      if (past_first_source_file && pst
! 		  /* The gould NP1 uses low values for .o and -l symbols
! 		     which are not the address.  */
! 		  && bufp->n_value > pst->textlow)
  		{
  		  end_psymtab (pst, psymtab_include_list, includes_used,
! 			       symnum * NLIST_STRUCT_SIZE, bufp->n_value,
  			       dependency_list, dependencies_used,
  			       global_psymbols.next, static_psymbols.next);
  		  pst = (struct partial_symtab *) 0;
*************** read_dbx_symtab (desc, stringtab, string
*** 2222,2228 ****
  	  if (pst && past_first_source_file)
  	    {
  	      end_psymtab (pst, psymtab_include_list, includes_used,
! 			   symnum * sizeof (struct nlist), bufp->n_value,
  			   dependency_list, dependencies_used,
  			   global_psymbols.next, static_psymbols.next);
  	      pst = (struct partial_symtab *) 0;
--- 2393,2399 ----
  	  if (pst && past_first_source_file)
  	    {
  	      end_psymtab (pst, psymtab_include_list, includes_used,
! 			   symnum * NLIST_STRUCT_SIZE, bufp->n_value,
  			   dependency_list, dependencies_used,
  			   global_psymbols.next, static_psymbols.next);
  	      pst = (struct partial_symtab *) 0;
*************** read_dbx_symtab (desc, stringtab, string
*** 2233,2239 ****
  	    past_first_source_file = 1;
  
  	  pst = start_psymtab (namestring, bufp->n_value,
! 			       symnum * sizeof (struct nlist),
  			       global_psymbols.next, static_psymbols.next);
  
  	  continue;
--- 2404,2410 ----
  	    past_first_source_file = 1;
  
  	  pst = start_psymtab (namestring, bufp->n_value,
! 			       symnum * NLIST_STRUCT_SIZE,
  			       global_psymbols.next, static_psymbols.next);
  
  	  continue;
*************** read_dbx_symtab (desc, stringtab, string
*** 2437,2442 ****
--- 2608,2618 ----
  	case N_STSYM:		/* Data seg var -- static  */
  	case N_LCSYM:		/* BSS      "  */
  
+ #if defined (N_NBSTS)
+ 	case N_NBSTS:           /* Gould nobase.  */
+ 	case N_NBLCS:           /* symbols.  */
+ #endif
+ 
  	/* Following may probably be ignored; I'll leave them here
  	   for now (until I do Pascal and Modula 2 extensions).  */
  
*************** read_dbx_symtab (desc, stringtab, string
*** 2627,2633 ****
    if (pst)
      {
        end_psymtab (pst, psymtab_include_list, includes_used,
! 		   symnum * sizeof (struct nlist), end_of_text_addr,
  		   dependency_list, dependencies_used,
  		   global_psymbols.next, static_psymbols.next);
        includes_used = 0;
--- 2803,2809 ----
    if (pst)
      {
        end_psymtab (pst, psymtab_include_list, includes_used,
! 		   symnum * NLIST_STRUCT_SIZE, end_of_text_addr,
  		   dependency_list, dependencies_used,
  		   global_psymbols.next, static_psymbols.next);
        includes_used = 0;
*************** psymtab_to_symtab(pst)
*** 2931,2936 ****
--- 3107,3113 ----
  
        READ_FILE_HEADERS (desc, name);
  
+ #if 0
        /* Read in the string table */
        lseek (desc, STRING_TABLE_OFFSET, L_SET);
        READ_STRING_TABLE_SIZE (stsize);
*************** psymtab_to_symtab(pst)
*** 2956,2961 ****
--- 3133,3141 ----
        val = myread (desc, stringtab, stsize);
        if (val < 0)
  	perror_with_name (name);
+ #endif /* 0 */
+       stringtab = symfile_string_table;
+       stsize = symfile_string_table_size;
  
        psymtab_to_symtab_1 (pst, desc, stringtab, stsize,
  			   SYMBOL_TABLE_OFFSET);
*************** read_ofile_symtab (desc, stringtab, stri
*** 3090,3105 ****
  
       Detecting this in read_dbx_symtab
       would slow down initial readin, so we look for it here instead.  */
!   if (sym_offset >= sizeof (struct nlist))
      {
!       lseek (desc, sym_offset - sizeof (struct nlist), L_INCR);
        fill_symbuf ();
!       bufp = &symbuf[symbuf_idx++];
  
!       if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)
! 	error ("Invalid symbol data: bad string table offset: %d",
! 	       bufp->n_un.n_strx);
!       namestring = bufp->n_un.n_strx + stringtab;
  
        processing_gcc_compilation =
  	(bufp->n_type == N_TEXT
--- 3270,3286 ----
  
       Detecting this in read_dbx_symtab
       would slow down initial readin, so we look for it here instead.  */
! 
!   conv_symnum = 0;
!   symnum_limit = sym_size / NLIST_STRUCT_SIZE;
! 
!   if (sym_offset >= NLIST_STRUCT_SIZE)
      {
!       lseek (desc, sym_offset - NLIST_STRUCT_SIZE, L_INCR);
        fill_symbuf ();
!       bufp =  & NLIST_INDEX(symbuf,symbuf_idx++);
  
!       SET_NAMESTRING();
  
        processing_gcc_compilation =
  	(bufp->n_type == N_TEXT
*************** read_ofile_symtab (desc, stringtab, stri
*** 3116,3133 ****
  
    if (symbuf_idx == symbuf_end)
      fill_symbuf();
!   bufp = &symbuf[symbuf_idx];
    if ((unsigned char) bufp->n_type != N_SO)
      fatal("First symbol in segment of executable not a source symbol");
  
    for (symnum = 0;
!        symnum < sym_size / sizeof(struct nlist);
         symnum++)
      {
        QUIT;			/* Allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf();
!       bufp = &symbuf[symbuf_idx++];
        type = bufp->n_type;
  
        if (type == N_CATCH)
--- 3297,3314 ----
  
    if (symbuf_idx == symbuf_end)
      fill_symbuf();
!   bufp = & NLIST_INDEX(symbuf,symbuf_idx);
    if ((unsigned char) bufp->n_type != N_SO)
      fatal("First symbol in segment of executable not a source symbol");
  
    for (symnum = 0;
!        symnum < sym_size / NLIST_STRUCT_SIZE;
         symnum++)
      {
        QUIT;			/* Allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf();
!       bufp = & NLIST_INDEX(symbuf,symbuf_idx++);
        type = bufp->n_type;
  
        if (type == N_CATCH)
*************** read_ofile_symtab (desc, stringtab, stri
*** 3140,3149 ****
  	       (type == N_TEXT || type == N_DATA || type == N_BSS))
  	bufp->n_value += text_offset;
  
!       if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)
! 	error ("Invalid symbol data: bad string table offset: %d",
! 	       bufp->n_un.n_strx);
!       namestring = bufp->n_un.n_strx + stringtab;
  
        if (type & N_STAB)
  	process_one_symbol(type, bufp->n_desc,
--- 3321,3327 ----
  	       (type == N_TEXT || type == N_DATA || type == N_BSS))
  	bufp->n_value += text_offset;
  
!       SET_NAMESTRING();
  
        if (type & N_STAB)
  	process_one_symbol(type, bufp->n_desc,
*************** process_one_symbol (type, desc, value, n
*** 3259,3264 ****
--- 3437,3447 ----
  
    switch (type)
      {
+ #ifdef N_MULTI_LINE_TYPE
+     case  N_MULTI_LINE_TYPE:
+       sun_enter_linenos (value);
+       break;
+ #endif
      case N_FUN:
      case N_FNAME:
        /* Either of these types of symbols indicates the start of
*************** process_one_symbol (type, desc, value, n
*** 3366,3373 ****
--- 3549,3561 ----
  	    new->start_addr = value;
  	  /* Make a block for the local symbols within.  */
  	  finish_block (0, &local_symbols, new->old_blocks,
+ #if defined (BLOCK_ADDRESS_ABSOLUTE)
+ 			new->start_addr,
+ 			value);
+ #else
  			new->start_addr + last_source_start_addr,
  			value + last_source_start_addr);
+ #endif
  	}
        else
  	{
*************** condense_addl_misc_bunches ()
*** 3521,3532 ****
  /* Read in another .o file and create a symtab entry for it.*/
  
  static void
! read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
       int desc;
       register char *stringtab;
       register int nlistlen;
       unsigned text_addr;
       int text_size;
  {
    FILE *stream = fdopen (desc, "r");
    register char *namestring;
--- 3709,3721 ----
  /* Read in another .o file and create a symtab entry for it.*/
  
  static void
! read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size, stringtab_size)
       int desc;
       register char *stringtab;
       register int nlistlen;
       unsigned text_addr;
       int text_size;
+      int  stringtab_size;
  {
    FILE *stream = fdopen (desc, "r");
    register char *namestring;
*************** read_addl_syms (desc, stringtab, nlistle
*** 3541,3546 ****
--- 3730,3739 ----
    bzero (global_sym_chain, sizeof global_sym_chain);
    symtab_input_desc = desc;
    stringtab_global = stringtab;
+ 
+   conv_symnum = 0;
+   symnum_limit = nlistlen;
+ 
    fill_symbuf ();
  
    for (symnum = 0; symnum < nlistlen; symnum++)
*************** read_addl_syms (desc, stringtab, nlistle
*** 3551,3559 ****
        QUIT;	/* allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf ();
!       bufp = &symbuf[symbuf_idx++];
        type = bufp->n_type & N_TYPE;
!       namestring = bufp->n_un.n_strx + stringtab;
  
        if( (type == N_TEXT) || (type == N_DATA) || (type == N_BSS) )
  	{
--- 3744,3752 ----
        QUIT;	/* allow this to be interruptable */
        if (symbuf_idx == symbuf_end)
  	fill_symbuf ();
!       bufp = & NLIST_INDEX(symbuf,symbuf_idx++);
        type = bufp->n_type & N_TYPE;
!       SET_NAMESTRING();
  
        if( (type == N_TEXT) || (type == N_DATA) || (type == N_BSS) )
  	{
*************** read_addl_syms (desc, stringtab, nlistle
*** 3593,3601 ****
  	  int used_up = 0;
  
  	  /* Record the location of _etext.  */
! 	  if (type == (N_TEXT | N_EXT)
! 	      && !strcmp (namestring, "_etext"))
! 	    end_of_text_addr = bufp->n_value;
  
  #if 0
  	  /* 25 Sep 89: The following seems to be stolen from
--- 3786,3793 ----
  	  int used_up = 0;
  
  	  /* Record the location of _etext.  */
! 	  if (type == (N_TEXT | N_EXT) && IS_ETEXT (namestring))
! 	      end_of_text_addr = bufp->n_value;
  
  #if 0
  	  /* 25 Sep 89: The following seems to be stolen from
*************** add_file_command (arg_string)
*** 3786,3793 ****
    global_symbols = 0;
    make_cleanup (really_free_pendings, 0);
  
    read_addl_syms (desc, stringtab, NUMBER_OF_SYMBOLS, text_addr,
! 		  SIZE_OF_TEXT_SEGMENT);
  
  
    /* Sort symbols alphabetically within each block.  */
--- 3978,3989 ----
    global_symbols = 0;
    make_cleanup (really_free_pendings, 0);
  
+ #ifdef EXTRA_STRINGS_INIT
+   EXTRA_STRINGS_INIT (addl_extra_strings)
+ #endif  
+ 
    read_addl_syms (desc, stringtab, NUMBER_OF_SYMBOLS, text_addr,
! 		  SIZE_OF_TEXT_SEGMENT, buffer /* really string table size */); 
  
  
    /* Sort symbols alphabetically within each block.  */
*************** cleanup_undefined_types ()
*** 4282,4287 ****
--- 4478,4522 ----
      }
    undef_types_length = 0;
  }
+ /* Skip rest of this symbol and return an error type.
+ 
+    General notes on error recovery:  error_type always skips to the
+    end of the symbol (modulo cretinous dbx symbol name continuation).
+    Thus code like this:
+ 
+    if (*(*pp)++ != ';')
+      return error_type (pp);
+ 
+    is wrong because if *pp starts out pointing at '\0' (typically as the
+    result of an earlier error), it will be incremented to point to the
+    start of the next symbol, which might produce strange results, at least
+    if you run off the end of the string table.  Instead use
+ 
+    if (**pp != ';')
+      return error_type (pp);
+    ++*pp;
+ 
+    And in case it isn't obvious, the point of all this hair is so the compiler
+    can define new types and new syntaxes, and old versions of the
+    debugger will be able to read the new symbol tables.  */
+ static struct type *
+ error_type (pp)
+      char **pp;
+ {
+   while (1)
+     {
+       /* Skip to end of symbol.  */
+       while (**pp != '\0')
+ 	(*pp)++;
+ 
+       /* Check for and handle cretinous dbx symbol name continuation!  */
+       if ((*pp)[-1] == '\\')
+ 	*pp = next_symbol_text ();
+       else
+ 	break;
+     }
+   return builtin_type_error;
+ }
  
  
  
*************** read_struct_type (pp, type)
*** 4722,4728 ****
  	  if (**pp == '\\')
  	    *pp = next_symbol_text ();
  
! 	  switch (*(*pp)++)
  	    {
  	    case '0':
  	      via_virtual = 0;
--- 4957,4963 ----
  	  if (**pp == '\\')
  	    *pp = next_symbol_text ();
  
! 	  switch (**pp)
  	    {
  	    case '0':
  	      via_virtual = 0;
*************** read_struct_type (pp, type)
*** 4734,4741 ****
  	      error ("Invalid symbol data: bad visibility format at symtab pos %d",
  		     symnum);
  	    }
  
! 	  switch (*(*pp)++)
  	    {
  	    case '0':
  	      via_public = 0;
--- 4969,4977 ----
  	      error ("Invalid symbol data: bad visibility format at symtab pos %d",
  		     symnum);
  	    }
+ 	  ++*pp;
  
! 	  switch (**pp)
  	    {
  	    case '0':
  	      via_public = 0;
*************** read_struct_type (pp, type)
*** 4744,4753 ****
  	      via_public = 1;
  	      break;
  	    default:
! 	      error ("Invalid symbol data: bad visibility format at symtab pos %d.",
! 		     symnum);
  	    }
  
  	  /* Offset of the portion of the object corresponding to
  	     this baseclass.  Always zero in the absence of
  	     multiple inheritance.  */
--- 4980,4991 ----
  	      via_public = 1;
  	      break;
  	    default:
! 	      /* Bad visibility format.  */
! 	      return error_type (pp);
  	    }
  
+ 	  ++*pp;
+ 
  	  /* Offset of the portion of the object corresponding to
  	     this baseclass.  Always zero in the absence of
  	     multiple inheritance.  */
*************** read_struct_type (pp, type)
*** 4911,4918 ****
   	  continue;
   	}
         else 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, ';');
--- 5149,5157 ----
   	  continue;
   	}
         else if (**pp != ',')
! 	 /* Bad structure-type format.  */
! 	 return error_type (pp);
! 
        (*pp)++;			/* Skip the comma.  */
        list->field.bitpos = read_number (pp, ',');
        list->field.bitsize = read_number (pp, ';');
*************** Therefore GDB will not know about your c
*** 5040,5047 ****
  
  	      new_sublist->fn_field.type = read_type (pp);
  	      if (**pp != ':')
! 		error ("invalid symtab info for method at symbol number %d.",
! 		       symnum);
  	      *pp += 1;
  	      p = *pp;
  	      while (*p != ';') p++;
--- 5279,5287 ----
  
  	      new_sublist->fn_field.type = read_type (pp);
  	      if (**pp != ':')
! 		/* Invalid symtab info for method.  */
! 		return error_type (pp);
! 
  	      *pp += 1;
  	      p = *pp;
  	      while (*p != ';') p++;
*************** Therefore GDB will not know about your c
*** 5180,5186 ****
  
  	  t = read_type (pp);
  	  p = (*pp)++;
! 	  while (*p != ';') p++;
  	  TYPE_VPTR_BASETYPE (type) = t;
  	  if (type == t)
  	    {
--- 5420,5430 ----
  
  	  t = read_type (pp);
  	  p = (*pp)++;
! 	  while (*p != '\0' && *p != ';') p++;
! 	  if (*p == '\0')
! 	    /* Premature end of symbol.  */
! 	    return error_type (pp);
! 	  
  	  TYPE_VPTR_BASETYPE (type) = t;
  	  if (type == t)
  	    {
*************** Therefore GDB will not know about your c
*** 5193,5199 ****
  		    break;
  		  }
  	      if (i < 0)
! 		error ("virtual function table field not found");
  	    }
  	  else
  	    TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
--- 5437,5444 ----
  		    break;
  		  }
  	      if (i < 0)
! 		/* Virtual function table field not found.  */
! 		return error_type (pp);
  	    }
  	  else
  	    TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
*************** read_array_type (pp, type)
*** 5235,5242 ****
       for these, produce a type like float[][].  */
  
    index_type = read_type (pp);
!   if (*(*pp)++ != ';')
!     error ("Invalid symbol data; improper format of array type decl.");
  
    if (!(**pp >= '0' && **pp <= '9'))
      {
--- 5480,5489 ----
       for these, produce a type like float[][].  */
  
    index_type = read_type (pp);
!   if (**pp != ';')
!     /* Improper format of array type decl.  */
!     return error_type (pp);
!   ++*pp;
  
    if (!(**pp >= '0' && **pp <= '9'))
      {
*************** read_range_type (pp, typenums)
*** 5507,5513 ****
    else if (n2 >= MIN_OF_TYPE(long) && n3 <= MAX_OF_TYPE(long))
      TYPE_LENGTH (result_type) = sizeof (long);
    else
!     error ("Ranged type doesn't fit within known sizes.");
  
    TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
    TYPE_CODE (result_type) = TYPE_CODE_RANGE;
--- 5754,5761 ----
    else if (n2 >= MIN_OF_TYPE(long) && n3 <= MAX_OF_TYPE(long))
      TYPE_LENGTH (result_type) = sizeof (long);
    else
!     /* Ranged type doesn't fit within known sizes.  */
!     return error_type (pp);
  
    TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
    TYPE_CODE (result_type) = TYPE_CODE_RANGE;
diff -pr gdb-3.6/i386-dep.c ../gdb-3.6/i386-dep.c
*** gdb-3.6/i386-dep.c	Wed Jan 10 15:58:05 1990
--- ../gdb-3.6/i386-dep.c	Tue Aug  7 22:04:08 1990
*************** exec_file_command (filename, from_tty)
*** 501,508 ****
--- 501,513 ----
  	aout_hdrsize = file_hdr.f_opthdr;
  	num_sections = file_hdr.f_nscns;
  
+ #ifndef NEVER
+ 	if ( ! aout_hdrsize )
+ 	  printf ("Warning:  no optional header--File may be relocatable.\n");
+ #else
  	if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0)
  	  error ("\"%s\": can't read optional aouthdr", execfile);
+ #endif
  
  	if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections,
  			      aout_hdrsize) < 0)
diff -pr gdb-3.6/m-i386-sv32.h ../gdb-3.6/m-i386-sv32.h
*** gdb-3.6/m-i386-sv32.h	Wed Aug 16 14:20:30 1989
--- ../gdb-3.6/m-i386-sv32.h	Tue Aug  7 22:04:08 1990
*************** You should have received a copy of the G
*** 17,24 ****
  along with GDB; see the file COPYING.  If not, write to
  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  
! #include "m-i386.h"
  
  /* Apparently there is inconsistency among various System V's about what
     the name of this field is.  */
  #define U_FPSTATE(u) u.u_fps.u_fpstate
--- 17,398 ----
  along with GDB; see the file COPYING.  If not, write to
  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  
! /* Define the bit, byte, and word ordering of the machine.  */
! /* #define BITS_BIG_ENDIAN  */
! /* #define BYTES_BIG_ENDIAN */
! /* #define WORDS_BIG_ENDIAN */
  
+ /*
+  * Changes for 80386 by Pace Willisson (pace at prep.ai.mit.edu)
+  * July 1988
+  */
+ 
+ 
+ #ifndef i386
+ #define i386
+ #endif
+ 
+ /* I'm running gdb 3.4 under 386/ix 2.0.2, which is a derivative of AT&T's
+ Sys V/386 3.2.
+ 
+ On some machines, gdb crashes when it's starting up while calling the
+ vendor's termio tgetent() routine.  It always works when run under
+ itself (actually, under 3.2, it's not an infinitely recursive bug.)
+ After some poking around, it appears that depending on the environment
+ size, or whether you're running YP, or the phase of the moon or something,
+ the stack is not always long-aligned when main() is called, and tgetent()
+ takes strong offense at that.  On some machines this bug never appears, but
+ on those where it does, it occurs quite reliably.  */
+ #define ALIGN_STACK_ON_STARTUP
+ 
+ /* define USG if you are using sys5 /usr/include's */
+ #define USG
+ 
+ /* USG systems need these */
+ #define vfork() fork()
+ #define MAXPATHLEN 500
+ 
+ /* define this if you don't have the extension to coff that allows
+  * file names to appear in the string table
+  * (aux.x_file.x_foff)
+  */
+ #define COFF_NO_LONG_FILE_NAMES
+ 
+ /* turn this on when rest of gdb is ready */
+ /* #define IEEE_FLOAT */
+ 
+ #define NBPG NBPC
+ #define UPAGES USIZE
+ 
+ #define HAVE_TERMIO
+ 
+ /* Get rid of any system-imposed stack limit if possible.  */
+ 
+ /* #define SET_STACK_LIMIT_HUGE not in sys5 */
+ 
+ /* 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 */
+ 
+ /* Specify debugger information format.  */
+ 
+ #define READ_DBX_FORMAT
+ #define COFF_FORMAT
+ 
+ /* number of traps that happen between exec'ing the shell 
+  * to run an inferior, and when we finally get to 
+  * the inferior code.  This is 2 on most implementations.
+  */
+ #define START_INFERIOR_TRAPS_EXPECTED 4
+ 
+ /* 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(frompc)   {(frompc) = i386_skip_prologue((frompc));}
+ 
+ /* 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 0xe0000000
+ 
+ /* Address of end of stack space.  */
+ 
+ #define STACK_END_ADDR 0x80000000
+ 
+ /* Stack grows downward.  */
+ 
+ #define INNER_THAN <
+ 
+ /* Sequence of bytes for breakpoint instruction.  */
+ 
+ #define BREAKPOINT {0xcc}
+ 
+ /* 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 1
+ 
+ /* Nonzero if instruction at PC is a return instruction.  */
+ 
+ #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0xc3)
+ 
+ /* Return 1 if P points to an invalid floating point value.
+    LEN is the length in bytes -- not relevant on the 386.  */
+ 
+ #define INVALID_FLOAT(p, len) (0)
+ 
+ /* code to execute to print interesting information about the
+  * floating point processor (if any)
+  * No need to define if there is nothing to do.
+  */
+ #define FLOAT_INFO { i386_float_info (); }
+ 
+ 
+ /* Largest integer type */
+ #define LONGEST long
+ 
+ /* Name of the builtin type for the LONGEST type above. */
+ #define BUILTIN_TYPE_LONGEST builtin_type_long
+ 
+ /* Say how long (ordinary) registers are.  */
+ 
+ #define REGISTER_TYPE long
+ 
+ /* Number of machine registers */
+ 
+ #define NUM_REGS 16
+ 
+ /* Initializer for an array of names of registers.
+    There should be NUM_REGS strings in this initializer.  */
+ 
+ /* the order of the first 8 registers must match the compiler's 
+  * numbering scheme (which is the same as the 386 scheme)
+  * also, this table must match regmap in i386-pinsn.c.
+  */
+ #define REGISTER_NAMES { "eax", "ecx", "edx", "ebx", \
+ 			 "esp", "ebp", "esi", "edi", \
+ 			 "eip", "ps", "cs", "ss", \
+ 			 "ds", "es", "fs", "gs", \
+ 			 }
+ 
+ /* 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 5		/* Contains address of executing stack frame */
+ #define SP_REGNUM 4		/* Contains address of top of stack */
+ 
+ #define PC_REGNUM 8
+ #define PS_REGNUM 9
+ 
+ #define REGISTER_U_ADDR(addr, blockend, regno) \
+ 	(addr) = i386_register_u_addr ((blockend),(regno));
+ 
+ /* 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.  */
+ 
+ #define REGISTER_RAW_SIZE(N) (4)
+ 
+ /* Number of bytes of storage in the program's representation
+    for register N. */
+ 
+ #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)
+ 
+ /* Store the address of the place in which to copy the structure the
+    subroutine will return.  This is called from call_function. */
+ 
+ #define STORE_STRUCT_RETURN(ADDR, SP) \
+   { (SP) -= sizeof (ADDR);		\
+     write_memory ((SP), &(ADDR), sizeof (ADDR)); }
+ 
+ /* 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.  */
+ 
+ #define FRAME_CHAIN(thisframe) \
+   (outside_startup_file ((thisframe)->pc) ? \
+    read_memory_integer ((thisframe)->frame, 4) :\
+    0)
+ 
+ #define FRAME_CHAIN_VALID(chain, thisframe) \
+   (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe))))
+ 
+ #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+ 
+ /* Define other aspects of the stack frame.  */
+ 
+ /* A macro that tells us whether the function invocation represented
+    by FI does not have a frame on the stack associated with it.  If it
+    does not, FRAMELESS is set to 1, else 0.  */
+ #define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
+   FRAMELESS_LOOK_FOR_PROLOGUE(FI, FRAMELESS)
+ 
+ #define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->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(numargs, fi) (numargs) = i386_frame_num_args(fi)
+ 
+ /* 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) \
+ { i386_frame_find_saved_regs ((frame_info), &(frame_saved_regs)); }
+ 
+ 
+ /* Things needed for making the inferior call functions.  */
+ 
+ /* Push an empty stack frame, to record the current PC, etc.  */
+ 
+ #define PUSH_DUMMY_FRAME { i386_push_dummy_frame (); }
+ 
+ /* Discard from the stack the innermost frame, restoring all registers.  */
+ 
+ #define POP_FRAME  { i386_pop_frame (); }
+ 
+ /* this is 
+  *   call 11223344 (32 bit relative)
+  *   int3
+  */
+ 
+ #define CALL_DUMMY { 0x223344e8, 0xcc11 }
+ 
+ #define CALL_DUMMY_LENGTH 8
+ 
+ #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, pc, fun, nargs, type)   \
+ { \
+ 	int from, to, delta, loc; \
+ 	loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \
+ 	from = loc + 5; \
+ 	to = (int)(fun); \
+ 	delta = to - from; \
+ 	*(int *)((char *)(dummyname) + 1) = delta; \
+ }
+ 
+ 
+ #if 0
+ /* 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, 0, 0, 0, 0, \
+   0, 0, 0, 0, 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)  {}
+ 
+ /* 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      {}
+ #endif
+ 
  /* Apparently there is inconsistency among various System V's about what
     the name of this field is.  */
  #define U_FPSTATE(u) u.u_fps.u_fpstate
*************** the Free Software Foundation, 675 Mass A
*** 26,28 ****
--- 400,498 ----
  /* TIOCGETC is defined in System V 3.2 termio.h, but struct tchars
     is not.  This makes problems for inflow.c.  */
  #define TIOCGETC_BROKEN
+ 
+ /* COFF PARAMS: */
+ /* Macro to declare variables to hold the file's header data.  */
+ #define DECLARE_FILE_HEADERS  struct aouthdr hdr; 		\
+ 	 FILHDR coffhdr; SCNHDR scn[10];/*char * extra_strings; */  \
+ 	extern int text_scn, data_scn, bss_scn
+ 
+ /* macro to declare the entry point of this file */
+ #define ENTRY_POINT hdr.entry
+ 
+ /* Macro for number of symbol table entries */
+ #define NUMBER_OF_SYMBOLS (coffhdr.f_nsyms)
+ 
+ /* Macro for file-offset of string table (in usual a.out format).  */
+ #define STRING_TABLE_OFFSET (coffhdr.f_symptr+coffhdr.f_nsyms*SYMESZ)
+ 
+ /* Macro for file-offset of symbol table (in usual a.out format).  */
+ #define SYMBOL_TABLE_OFFSET (coffhdr.f_symptr)
+ 
+ #define IS_OBJECT_FILE ((hdr.f_flags & F_EXEC) == 0)
+ 
+ /* Get the address in debugged memory of the start
+    of the text segment.  */
+ #define ADDR_OF_TEXT_SEGMENT (scn[text_scn].s_vaddr)
+ 
+ /* Macro for size of text segment */
+ #define SIZE_OF_TEXT_SEGMENT (scn[text_scn].s_size)
+ 
+ #define TEXT_SECTION_NAME ".text"
+ #define DATA_SECTION_NAME ".data"
+ #define BSS_SECTION_NAME  ".bss"
+ 
+ /* Macro to read the header data from descriptor DESC and validate it.
+    NAME is the file name, for error messages.  */
+ 
+ #define READ_FILE_HEADERS(DESC, NAME)				\
+ { int optsz,i;							\
+   int val = myread (DESC, &coffhdr, sizeof coffhdr);		\
+   if (val < 0)							\
+     perror_with_name (NAME);					\
+   if (!ISCOFF(coffhdr.f_magic))					\
+     error ("File \"%s\" not in coff executable format.", NAME);	\
+   number_of_symbols = coffhdr.f_nsyms;				\
+   optsz = (coffhdr.f_opthdr> sizeof hdr)?sizeof hdr:coffhdr.f_opthdr; \
+   val = myread (DESC, &hdr, optsz);				\
+   if (val < 0)							\
+     perror_with_name (NAME);					\
+ /*  if (N_BADMAG (hdr))						\
+     error ("File \"%s\" not in executable format.", NAME); */   \
+   bzero(&scn[0],sizeof(scn[0]));				\
+   val = myread (DESC, &scn[1], sizeof scn[0]*coffhdr.f_nscns);	\
+   if (val < 0)							\
+     perror_with_name (NAME);					\
+   clear_coff_sections();					\
+   for (i = 1; i <=coffhdr.f_nscns;i++) 				\
+     map_coff_section(i,&scn[i]);				\
+ }
+ 
+ /* Define SETJMP_MASKS_SIGNALS if your operating system uses bsd style 
+    signals but has the old signal mask is not restored after a longjmp. */
+ /* #define SETJMP_MASKS_SIGNALS DEFINED via config.gdb now */
+ 
+ #ifdef COFF_FORMAT
+ 
+ /* This is the type to set unwanted symbols to in convert_symbuf() */
+ #define IGNORED_SYMBOL_TYPE ( 0xff)
+ 
+ /* Function auxents containing line table indexes are converted to symbols
+    having this type: */
+ #define N_MULTI_LINE_TYPE ( 0xf0)
+ 
+ /* This is how dbxread recognizes symbols to be ignored */
+ #define IGNORE_SYMBOL(type) (IGNORED_SYMBOL_TYPE==type)
+ 
+ #endif
+ 
+ /* this is the ON DISK size of a symbol. This may not be the same as the
+    value sizeof() yields. On the sun 386i, they are not the same */
+ #define NLIST_STRUCT_SIZE SYMESZ
+ 
+ /* This is how to increment a pointer to a symbol. usually: p++ */
+ #define NLIST_INCR(p)  p = (struct nlist *) ((int)p + SYMESZ )
+ 
+ /* This is how to index into an arrayof symbols. Usually: ptr[index]  */
+ #define NLIST_INDEX(ptr,index) (* (struct nlist *) ((int)ptr + index*SYMESZ))
+ 
+ /* define this if preprocessing needs to be done on a buffer of symbols. */
+ #define CONVERT_SYMBUF
+ 
+ /* define this if absolute values are used for block symbols */
+ #define BLOCK_ADDRESS_ABSOLUTE
+ 
+ #define ADJUST_STARTUP_VALUES
+ #define NO_NATIVE_STAB_INCLUDE
+ 
+ #define EXTRA_MISC_INIT extra_misc_init() ; /* move to dep */
diff -pr gdb-3.6/main.c ../gdb-3.6/main.c
*** gdb-3.6/main.c	Fri Jan 26 12:12:59 1990
--- ../gdb-3.6/main.c	Wed Aug  8 17:20:53 1990
*************** int linesize;
*** 156,161 ****
--- 156,174 ----
  
  jmp_buf to_top_level;
  
+ /* This kludge is for the TTI Unicom "pbb" systems, which implement
+    the signal mask in signal() but not in setjmp()!!!  The expression
+    below will call setjmp, and then if setjmp returned nonzero, it executes
+    the sigsetmask and returns a 1 itself.  None of the setjmp callers
+    in this function care about the result from setjmp, only whether it
+    is zero or nonzero.  */
+ 
+ #ifdef SETJMP_MASKS_SIGNALS
+ #define kludge_setjmp(x) (setjmp(x) && (sigsetmask (0), 1))
+ #else
+ #define	kludge_setjmp(x)  setjmp(x)
+ #endif
+ 
  void
  return_to_top_level ()
  {
*************** catch_errors (func, arg, errstring)
*** 187,193 ****
  
    bcopy (to_top_level, saved, sizeof (jmp_buf));
  
!   if (setjmp (to_top_level) == 0)
      val = (*func) (arg);
    else
      {
--- 200,206 ----
  
    bcopy (to_top_level, saved, sizeof (jmp_buf));
  
!   if (kludge_setjmp (to_top_level) == 0)
      val = (*func) (arg);
    else
      {
*************** GDB manual (available as on-line info or
*** 351,357 ****
  
  	  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.  */
--- 364,370 ----
  
  	  if (++i == argc)
  	    fprintf (stderr, "No argument follows \"%s\".\n", arg);
! 	  if (!kludge_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.  */
*************** GDB manual (available as on-line info or
*** 396,402 ****
  	     are treated as, first, the symbol/executable file
  	     and, second, the core dump file.  */
  	  count++;
! 	  if (!setjmp (to_top_level))
  	    switch (count)
  	      {
  	      case 1:
--- 409,415 ----
  	     are treated as, first, the symbol/executable file
  	     and, second, the core dump file.  */
  	  count++;
! 	  if (!kludge_setjmp (to_top_level))
  	    switch (count)
  	      {
  	      case 1:
*************** GDB manual (available as on-line info or
*** 427,433 ****
  	strcpy (homeinit, getenv ("HOME"));
  	strcat (homeinit, "/.gdbinit");
  	if (!inhibit_gdbinit && access (homeinit, R_OK) == 0)
! 	  if (!setjmp (to_top_level))
  	    source_command (homeinit);
  
  	/* Do stats; no need to do them elsewhere since we'll only
--- 440,446 ----
  	strcpy (homeinit, getenv ("HOME"));
  	strcat (homeinit, "/.gdbinit");
  	if (!inhibit_gdbinit && access (homeinit, R_OK) == 0)
! 	  if (!kludge_setjmp (to_top_level))
  	    source_command (homeinit);
  
  	/* Do stats; no need to do them elsewhere since we'll only
*************** GDB manual (available as on-line info or
*** 451,457 ****
  		 (char *) &cwdbuf,
  		 sizeof (struct stat)))
        if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0)
! 	if (!setjmp (to_top_level))
  	  source_command (".gdbinit");
    }
  
--- 464,470 ----
  		 (char *) &cwdbuf,
  		 sizeof (struct stat)))
        if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0)
! 	if (!kludge_setjmp (to_top_level))
  	  source_command (".gdbinit");
    }
  
*************** GDB manual (available as on-line info or
*** 471,477 ****
  
    while (1)
      {
!       if (!setjmp (to_top_level))
  	command_loop ();
        clearerr (stdin);		/* Don't get hung if C-d is typed.  */
      }
--- 484,490 ----
  
    while (1)
      {
!       if (!kludge_setjmp (to_top_level))
  	command_loop ();
        clearerr (stdin);		/* Don't get hung if C-d is typed.  */
      }
*************** stop_sig ()
*** 751,757 ****
--- 764,772 ----
  {
  #if STOP_SIGNAL == SIGTSTP
    signal (SIGTSTP, SIG_DFL);
+ #ifdef SETJMP_MASKS_SIGNALS
    sigsetmask (0);
+ #endif
    kill (getpid (), SIGTSTP);
    signal (SIGTSTP, stop_sig);
  #else
diff -pr gdb-3.6/malloc.c ../gdb-3.6/malloc.c
*** gdb-3.6/malloc.c	Sat Sep 30 12:48:54 1989
--- ../gdb-3.6/malloc.c	Tue Aug  7 21:23:14 1990
*************** what you give them.   Help stamp out sof
*** 171,177 ****
--- 171,179 ----
  
  #ifndef BSD4_2
  #ifndef USG
+ #ifndef i386
  #include <sys/vlimit.h>		/* warn the user when near the end */
+ #endif
  #endif /* not USG */
  #else /* if BSD4_2 */
  #include <sys/time.h>
diff -pr gdb-3.6/munch ../gdb-3.6/munch
*** gdb-3.6/munch	Wed Jul  5 12:46:28 1989
--- ../gdb-3.6/munch	Tue Aug  7 21:00:37 1990
*************** if test "$1" = "-DSYSV" ; then
*** 10,17 ****
      nm $* | egrep '^(.*[^a-zA-Z_]_|_)initialize_' | \
  	sed -e 's/^.*\(_initialize_[a-zA-Z0-9_]*\)[^a-zA-Z0-9_].*$/   \1 ();/'
  else
!     nm -p $* | egrep 'T *__initialize_' | \
! 	sed -e 's/^.*T *_*\(.*\)/    _\1 ();/'
  fi
  
  echo '}'
--- 10,25 ----
      nm $* | egrep '^(.*[^a-zA-Z_]_|_)initialize_' | \
  	sed -e 's/^.*\(_initialize_[a-zA-Z0-9_]*\)[^a-zA-Z0-9_].*$/   \1 ();/'
  else
! 
!   # if (NAMES_HAVE_UNDERSCORES)
! 
!     if test ""`nm version.o |grep -c _version` != 0  ; then
!         nm -p $* | egrep 'T *__initialize_' | \
! 	    sed -e 's/^.*T *_*\(.*\)/    _\1 ();/'
!     else
!         nm -p $* | egrep 'T *_initialize_' | \
! 	    sed -e 's/^.*T *_*\(.*\)/    _\1 ();/'
!     fi
  fi
  
  echo '}'
diff -pr gdb-3.6/printcmd.c ../gdb-3.6/printcmd.c
*** gdb-3.6/printcmd.c	Fri Jan 19 19:32:54 1990
--- ../gdb-3.6/printcmd.c	Thu Aug 16 17:44:41 1990
*************** set_next_address (addr)
*** 396,428 ****
  		   value_from_long (builtin_type_int, (LONGEST) 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 = 0;
    register char *format;
-   register struct symbol *fs;
-   char *name;
    int name_location;
  
-   i = find_pc_partial_function (addr, &name, &name_location);
- 
    /* If nothing comes out, don't print anything symbolic.  */
!   
!   if (i == 0)
!     format = "0x%x";
!   else if (addr - name_location)
!     format = "0x%x <%s+%d>";
    else
!     format = "0x%x <%s>";
  
!   fprintf_filtered (stream, format, addr, name, addr - name_location);
  }
  
  /* Examine data at address ADDR in format FMT.
--- 396,436 ----
  		   value_from_long (builtin_type_int, (LONGEST) addr));
  }
  
! /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM. */
  
  void
! print_address_symbolic (addr, stream)
       CORE_ADDR addr;
       FILE *stream;
  {
    register char *format;
    int name_location;
+   register int i = find_pc_misc_function (addr);
  
    /* If nothing comes out, don't print anything symbolic.  */
!   if (i < 0) return;
!   name_location = misc_function_vector[i].address;
! 
!   if (addr - name_location)
!     format = " <%s+%d>";
    else
!     format = " <%s>";
! 
!   fprintf_filtered (stream, format,
! 		    misc_function_vector[i].name, addr - name_location);
! }
! 
! /* 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;
! {
!   fprintf_filtered (stream, "0x%x", addr);
!   print_address_symbolic (addr, stream);
  }
  
  /* Examine data at address ADDR in format FMT.
diff -pr gdb-3.6/readline/Makefile ../gdb-3.6/readline/Makefile
*** gdb-3.6/readline/Makefile	Wed Feb  7 22:05:33 1990
--- ../gdb-3.6/readline/Makefile	Tue Aug  7 21:00:54 1990
*************** READLINE_DEFINES = -DVI_MODE
*** 33,39 ****
  
  DEBUG_FLAGS = -g
  LDFLAGS = $(DEBUG_FLAGS) 
! CFLAGS = $(DEBUG_FLAGS) $(TYPE) $(SYSV) -I.
  
  # A good alternative is gcc -traditional.
  #CC = gcc -traditional
--- 33,39 ----
  
  DEBUG_FLAGS = -g
  LDFLAGS = $(DEBUG_FLAGS) 
! CFLAGS = $(DEBUG_FLAGS) $(TYPES) $(SIGS)  $(SYSV) -I.
  
  # A good alternative is gcc -traditional.
  #CC = gcc -traditional
diff -pr gdb-3.6/readline/readline.c ../gdb-3.6/readline/readline.c
*** gdb-3.6/readline/readline.c	Sun Nov 26 13:31:36 1989
--- ../gdb-3.6/readline/readline.c	Tue Aug  7 21:01:06 1990
*************** readline_internal ()
*** 320,330 ****
    while (!rl_done)
      {
        int lk = last_command_was_kill;
        int code = setjmp (readline_top_level);
  
        if (code)
! 	rl_redisplay ();
! 
        if (!rl_pending_input)
  	{
  	  /* Then initialize the argument and number of keys read. */
--- 320,337 ----
    while (!rl_done)
      {
        int lk = last_command_was_kill;
+ #ifdef SETJMP_MASKS_SIGNALS
+       int mask = sigblock(0);
+ #endif
        int code = setjmp (readline_top_level);
  
        if (code)
!         {
! #ifdef SETJMP_MASKS_SIGNALS
! 	  sigsetmask(mask);
! #endif
! 	  rl_redisplay ();
!         }
        if (!rl_pending_input)
  	{
  	  /* Then initialize the argument and number of keys read. */
diff -pr gdb-3.6/stack.c ../gdb-3.6/stack.c
*** gdb-3.6/stack.c	Tue Jun  5 07:19:27 1990
--- ../gdb-3.6/stack.c	Thu Aug 16 17:44:42 1990
*************** print_frame_info (fi, level, source, arg
*** 99,105 ****
        printf_filtered ("#%-2d ", level);
        printf_filtered ("0x%x in ", fi->pc);
  
!       printf_filtered ("%s (...) (...)\n", fname);
        
        return;
      }
--- 99,106 ----
        printf_filtered ("#%-2d ", level);
        printf_filtered ("0x%x in ", fi->pc);
  
!       fputs_demangled(fname, stdout, -1);
!       fputs_filtered(" (...)\n", stdout);
        
        return;
      }
*************** print_frame_info (fi, level, source, arg
*** 152,158 ****
  	printf ("#%-2d ", 0);
        if (fi->pc != sal.pc || !sal.symtab)
  	printf_filtered ("0x%x in ", fi->pc);
!       printf_filtered ("%s (", funname ? funname : "??");
        if (args)
  	{
  	  FRAME_NUM_ARGS (numargs, fi);
--- 153,160 ----
  	printf ("#%-2d ", 0);
        if (fi->pc != sal.pc || !sal.symtab)
  	printf_filtered ("0x%x in ", fi->pc);
!       fputs_demangled(funname ? funname : "??", stdout, -1);
!       printf_filtered(" (");
        if (args)
  	{
  	  FRAME_NUM_ARGS (numargs, fi);
*************** print_block_frame_labels (b, frame, have
*** 571,577 ****
  	  struct symtab_and_line sal;
  	  sal = find_pc_line (SYMBOL_VALUE (sym), 0);
  	  values_printed = 1;
! 	  fputs_filtered (SYMBOL_NAME (sym), stream);
  	  fprintf_filtered (stream, " 0x%x in file %s, line %d\n",
  			    SYMBOL_VALUE (sym), sal.symtab->filename, sal.line);
  	  fflush (stream);
--- 573,579 ----
  	  struct symtab_and_line sal;
  	  sal = find_pc_line (SYMBOL_VALUE (sym), 0);
  	  values_printed = 1;
! 	  fputs_demangled (SYMBOL_NAME (sym), stream, 1);
  	  fprintf_filtered (stream, " 0x%x in file %s, line %d\n",
  			    SYMBOL_VALUE (sym), sal.symtab->filename, sal.line);
  	  fflush (stream);
diff -pr gdb-3.6/symseg.h ../gdb-3.6/symseg.h
*** gdb-3.6/symseg.h	Tue Jun 26 05:39:01 1990
--- ../gdb-3.6/symseg.h	Tue Aug  7 21:00:38 1990
*************** enum type_code
*** 117,122 ****
--- 117,123 ----
    TYPE_CODE_SET,		/* Pascal sets */
    TYPE_CODE_RANGE,		/* Range (integers within spec'd bounds) */
    TYPE_CODE_PASCAL_ARRAY,	/* Array with explicit type of index */
+   TYPE_CODE_ERROR,		/* Unknown type */
  
    /* C++ */
    TYPE_CODE_MEMBER,		/* Member type */
*************** struct partial_symbol
*** 470,479 ****
   * Vectors of all partial symbols read in from file; actually declared
   * and used in dbxread.c.
   */
! extern struct psymbol_allocation_list {
    struct partial_symbol *list, *next;
    int size;
! } global_psymbols, static_psymbols;
  
  
  /* Source-file information.
--- 471,480 ----
   * Vectors of all partial symbols read in from file; actually declared
   * and used in dbxread.c.
   */
! struct psymbol_allocation_list {
    struct partial_symbol *list, *next;
    int size;
! };
  
  
  /* Source-file information.
diff -pr gdb-3.6/symtab.c ../gdb-3.6/symtab.c
*** gdb-3.6/symtab.c	Wed Jul  4 05:27:41 1990
--- ../gdb-3.6/symtab.c	Thu Aug 16 17:44:44 1990
*************** the Free Software Foundation, 675 Mass A
*** 26,31 ****
--- 26,33 ----
  #include <assert.h>
  
  char *index ();
+ extern char *cplus_demangle ();
+ extern struct value * value_of_this ();
  
  /* Allocate an obstack to hold objects that should be freed
     when we load a new symbol table.
*************** struct type *builtin_type_unsigned_long_
*** 65,70 ****
--- 67,73 ----
  #endif
  struct type *builtin_type_float;
  struct type *builtin_type_double;
+ struct type *builtin_type_error;
  
  /* Block in which the most recently searched-for symbol was found.
     Might be better to make this a parameter to lookup_symbol and 
*************** lookup_symbol (name, block, namespace, i
*** 934,940 ****
       check to see if NAME is a field of `this'. */
    if (is_a_field_of_this)
      {
!       int v = (int) value_of_this (0);
        
        *is_a_field_of_this = 0;
        if (v && check_field (v, name))
--- 937,943 ----
       check to see if NAME is a field of `this'. */
    if (is_a_field_of_this)
      {
!       struct value *v = value_of_this (0);
        
        *is_a_field_of_this = 0;
        if (v && check_field (v, name))
*************** lookup_symbol (name, block, namespace, i
*** 967,972 ****
--- 970,995 ----
      {
        int index = lookup_misc_func (name);
  
+       if (index == -1)
+ 	{ /* Look for a mangled C++ name for NAME. */
+ 	  int name_len = strlen (name);
+ 	  for (index = misc_function_count; --index >= 0; )
+ 	      /* Assume orginal name is prefix of mangled name. */
+ 	      if (!strncmp (misc_function_vector[index].name, name, name_len))
+ 		{
+ 		  char *demangled =
+ 		      cplus_demangle(misc_function_vector[index].name, -1);
+ 		  if (demangled != NULL)
+ 		    {
+ 		      int cond = strcmp (demangled, name);
+ 		      free (demangled);
+ 		      if (!cond)
+ 			  break;
+ 		    }
+ 	        }
+ 	  /* Loop terminates on no match with index == -1. */
+         }
+ 
        if (index != -1)
  	{
  	  ps = find_pc_psymtab (misc_function_vector[index].address);
*************** decode_line_1 (argptr, funfirstline, def
*** 1861,1869 ****
    if (sym)
      error ("%s is not a function.", copy);
  
!   if ((i = lookup_misc_func (copy)) < 0)
!     error ("Function %s not defined.", copy);
!   else
      {
        value.symtab = 0;
        value.line = 0;
--- 1884,1893 ----
    if (sym)
      error ("%s is not a function.", copy);
  
!   if (symtab_list == 0 && partial_symtab_list == 0)
!     error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
! 
!   if ((i = lookup_misc_func (copy)) >= 0)
      {
        value.symtab = 0;
        value.line = 0;
*************** decode_line_1 (argptr, funfirstline, def
*** 1876,1883 ****
        return values;
      }
  
-   if (symtab_list == 0 && partial_symtab_list == 0)
-     error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
    error ("Function %s not defined.", copy);
  }
  
--- 1900,1905 ----
*************** decode_line_2 (argptr, sym_arr, physname
*** 1929,1934 ****
--- 1951,1957 ----
  	  if (funfirstline)
  	    SKIP_PROLOGUE (pc);
  	  values.sals[i] = find_pc_line (pc, 0);
+ 	  values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ? values.sals[i].end : pc;
  	  printf("[%d] file:%s; line number:%d\n",
  		 (i+2), values.sals[i].symtab->filename, values.sals[i].line);
  	}
*************** are listed.");
*** 2547,2551 ****
--- 2570,2576 ----
    builtin_type_unsigned_long_long = 
      init_type (TYPE_CODE_INT, sizeof (long long), 1, "unsigned long long");
  #endif
+   builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>");
+ 
  }
  
diff -pr gdb-3.6/symtab.h ../gdb-3.6/symtab.h
*** gdb-3.6/symtab.h	Tue Jun 26 23:47:00 1990
--- ../gdb-3.6/symtab.h	Tue Aug  7 21:00:42 1990
*************** struct symtab *symtab_list;
*** 159,164 ****
--- 159,168 ----
  
  struct partial_symtab *partial_symtab_list;
  
+ /* From symtab.c */
+ 
+ extern struct psymbol_allocation_list static_psymbols, global_psymbols;
+ 
  /* This symtab variable specifies the current file for printing source lines */
  
  struct symtab *current_source_symtab;
*************** extern struct type *builtin_type_unsigne
*** 325,330 ****
--- 329,337 ----
  extern struct type *builtin_type_unsigned_long;
  extern struct type *builtin_type_float;
  extern struct type *builtin_type_double;
+ /* This type represents a type that was unrecognized in symbol
+    read-in.  */
+ extern struct type *builtin_type_error;
  
  #ifdef LONG_LONG
  extern struct type *builtin_type_long_long;
diff -pr gdb-3.6/utils.c ../gdb-3.6/utils.c
*** gdb-3.6/utils.c	Tue Jun 26 06:20:28 1990
--- ../gdb-3.6/utils.c	Thu Aug 16 17:44:45 1990
*************** screensize_info (arg, from_tty)
*** 582,656 ****
  
     Note that a longjmp to top level may occur in this routine
     (since prompt_for_continue may do so) so this routine should not be
!    called when cleanups are not in place.
  
-    fputs_filtered demangles g++ names.*/
- 
- void _fputs_filtered (); /* forward decl. */
- 
- 
  void
  fputs_filtered (linebuffer, stream)
       char *linebuffer;
       FILE *stream;
  {
- #ifdef __STDC__
-   extern char *cplus_demangle (const char *, int);
- #else
-   extern char *cplus_demangle ();
- #endif
- #define SYMBOL_MAX 1024
- 
- #define SYMBOL_CHAR(c) (isascii(c) && (isalnum(c) || (c) == '_' || (c) == '$'))
- 
-   char buf[SYMBOL_MAX+1];
-   char *p;
- 
-   if (linebuffer == NULL)
-     return;
- 
-   p = linebuffer;
- 
-   while ( *p != (char) 0 ) {
-     int i = 0;
- 
-     /* collect non-interesting characters into buf */
-     while ( *p != (char) 0 && !SYMBOL_CHAR(*p) ) {
-       buf[i++] = *p;
-       p++;
-     }
-     if (i > 0) {
-       /* output the non-interesting characters without demangling */
-       buf[i] = (char) 0;
-       _fputs_filtered(buf, stream);
-       i = 0;  /* reset buf */
-     }
- 
-     /* and now the interesting characters */
-     while (i < SYMBOL_MAX && *p != (char) 0 && SYMBOL_CHAR(*p) ) {
-       buf[i++] = *p;
-       p++;
-     }
-     buf[i] = (char) 0;
-     if (i > 0) {
-       char * result;
-       
-       if ( (result = cplus_demangle(buf, 1)) != NULL ) {
- 	_fputs_filtered(result, stream);
- 	free(result);
-       }
-       else {
- 	_fputs_filtered(buf, stream);
-       }
-     }
-   }
- }
- 
- void
- _fputs_filtered (linebuffer, stream)
-      char *linebuffer;
-      FILE *stream;
- {
    char *lineptr;
  
    if (linebuffer == 0)
--- 582,594 ----
  
     Note that a longjmp to top level may occur in this routine
     (since prompt_for_continue may do so) so this routine should not be
!    called when cleanups are not in place. */
  
  void
  fputs_filtered (linebuffer, stream)
       char *linebuffer;
       FILE *stream;
  {
    char *lineptr;
  
    if (linebuffer == 0)
*************** _fputs_filtered (linebuffer, stream)
*** 711,716 ****
--- 649,714 ----
  	  chars_printed = 0;
  	}
      }
+ }
+ 
+ /* fputs_demangled is a variant of fputs_filtered that
+    demangles g++ names.*/
+ 
+ void
+ fputs_demangled (linebuffer, stream, arg_mode)
+      char *linebuffer;
+      FILE *stream;
+ {
+ #ifdef __STDC__
+   extern char *cplus_demangle (const char *, int);
+ #else
+   extern char *cplus_demangle ();
+ #endif
+ #define SYMBOL_MAX 1024
+ 
+ #define SYMBOL_CHAR(c) (isascii(c) && (isalnum(c) || (c) == '_' || (c) == '$'))
+ 
+   char buf[SYMBOL_MAX+1];
+   char *p;
+ 
+   if (linebuffer == NULL)
+     return;
+ 
+   p = linebuffer;
+ 
+   while ( *p != (char) 0 ) {
+     int i = 0;
+ 
+     /* collect non-interesting characters into buf */
+     while ( *p != (char) 0 && !SYMBOL_CHAR(*p) ) {
+       buf[i++] = *p;
+       p++;
+     }
+     if (i > 0) {
+       /* output the non-interesting characters without demangling */
+       buf[i] = (char) 0;
+       fputs_filtered(buf, stream);
+       i = 0;  /* reset buf */
+     }
+ 
+     /* and now the interesting characters */
+     while (i < SYMBOL_MAX && *p != (char) 0 && SYMBOL_CHAR(*p) ) {
+       buf[i++] = *p;
+       p++;
+     }
+     buf[i] = (char) 0;
+     if (i > 0) {
+       char * result;
+       
+       if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) {
+ 	fputs_filtered(result, stream);
+ 	free(result);
+       }
+       else {
+ 	fputs_filtered(buf, stream);
+       }
+     }
+   }
  }
  
  /* Print ARG1, ARG2, and ARG3 on stdout using format FORMAT.  If this
diff -pr gdb-3.6/valops.c ../gdb-3.6/valops.c
*** gdb-3.6/valops.c	Tue Jun 26 23:47:04 1990
--- ../gdb-3.6/valops.c	Thu Aug 16 17:44:46 1990
*************** value_string (ptr, len)
*** 768,773 ****
--- 768,807 ----
    return val;
  }
  
+ /* Helper function used by value_struct_elt to recurse through baseclasses.
+    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
+    and treat the result as having type TYPE.
+    If found, return value, else return NULL. */
+ 
+ static value search_struct_field (name, arg1, offset, type)
+      char *name;
+      register value arg1;
+      int offset;
+      register struct type *type;
+ {
+   int i;
+   check_stub_type (type);
+   for (i = TYPE_NFIELDS (type) - 1; i >= 0; i--)
+     {
+       char *t_field_name = TYPE_FIELD_NAME (type, i);
+       if (t_field_name && !strcmp (t_field_name, name))
+ 	  return TYPE_FIELD_STATIC (type, i)
+ 	      ? value_static_field (type, name, i)
+ 	      : value_primitive_field (arg1, offset, i, type);
+     }
+ 
+   for (i = TYPE_N_BASECLASSES (type); --i >= 0; )
+     {
+       /* Needs work for virtual base classes */
+       value v = search_struct_field (name,
+ 				     arg1,
+ 				     offset + TYPE_FIELD_BITPOS (type, i) / 8,
+ 				     TYPE_FIELD_TYPE (type, i));
+       if (v) return v;
+     }
+   return NULL;
+ }
+ 
  /* 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.
*************** value_struct_elt (arg1, args, name, stat
*** 827,856 ****
  
        /* Try as a variable first, because if we succeed, there
  	 is less work to be done.  */
!       while (t)
! 	{
! 	  check_stub_type (t);
! 
! 	  for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
! 	    {
! 	      char *t_field_name = TYPE_FIELD_NAME (t, i);
! 	      if (t_field_name && !strcmp (t_field_name, name))
! 		{
! 		  found = 1;
! 		  break;
! 		}
! 	    }
! 
! 	  if (i >= 0)
! 	    return TYPE_FIELD_STATIC (t, i)
! 	      ? value_static_field (t, name, i) : value_field (arg1, i);
! 
! 	  if (TYPE_N_BASECLASSES (t) == 0)
! 	    break;
! 
! 	  t = TYPE_BASECLASS (t, 1);
! 	  VALUE_TYPE (arg1) = t; /* side effect! */
! 	}
  
        /* C++: If it was not found as a data field, then try to
           return it as a pointer to a method.  */
--- 861,868 ----
  
        /* Try as a variable first, because if we succeed, there
  	 is less work to be done.  */
!       value v = search_struct_field (name, arg1, 0, t);
!       if (v) return v;
  
        /* C++: If it was not found as a data field, then try to
           return it as a pointer to a method.  */
*************** destructor_name_p (name, type)
*** 998,1003 ****
--- 1010,1055 ----
    return 0;
  }
  
+ /* Helper function for check_field: Given TYPE, a structure/union,
+    return 1 if the component named NAME from the ultimate
+    target structure/union is defined, otherwise, return 0. */
+ 
+ static int
+ check_field_in (type, name)
+      register struct type *type;
+      char *name;
+ {
+   register int i;
+ 
+   for (i = TYPE_NFIELDS (type); --i >= 0; )
+     {
+       char *t_field_name = TYPE_FIELD_NAME (type, i);
+       if (t_field_name && !strcmp (t_field_name, name))
+ 	return 1;
+     }
+ 
+   /* C++: If it was not found as a data field, then try to
+      return it as a pointer to a method.  */
+ 
+   /* Destructors are a special case.  */
+   if (destructor_name_p (name, type))
+     return 1;
+ 
+   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
+     {
+       if (!strcmp (TYPE_FN_FIELDLIST_NAME (type, i), name))
+ 	return 1;
+     }
+ 
+   for (i = TYPE_N_BASECLASSES (type); i > 0; i--)
+     {
+       if (check_field_in (TYPE_BASECLASS (type, i), name))
+ 	return 1;
+     }
+       
+   return 0;
+ }
+ 
  /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
     return 1 if the component named NAME from the ultimate
     target structure/union is defined, otherwise, return 0.  */
*************** check_field (arg1, name)
*** 1008,1018 ****
       char *name;
  {
    register struct type *t;
-   register int i;
-   int found = 0;
- 
-   struct type *baseclass;
- 
    COERCE_ARRAY (arg1);
  
    t = VALUE_TYPE (arg1);
--- 1060,1065 ----
*************** check_field (arg1, name)
*** 1029,1075 ****
        && TYPE_CODE (t) != TYPE_CODE_UNION)
      error ("Internal error: `this' is not an aggregate");
  
!   baseclass = t;
! 
!   while (t)
!     {
!       for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
! 	{
! 	  char *t_field_name = TYPE_FIELD_NAME (t, i);
! 	  if (t_field_name && !strcmp (t_field_name, name))
! 	    {
! 	      return 1;
! 	    }
! 	}
!       if (TYPE_N_BASECLASSES (t) == 0)
! 	break;
! 
!       t = TYPE_BASECLASS (t, 1);
!     }
! 
!   /* C++: If it was not found as a data field, then try to
!      return it as a pointer to a method.  */
!   t = baseclass;
!   VALUE_TYPE (arg1) = t;	/* side effect! */
! 
!   /* Destructors are a special case.  */
!   if (destructor_name_p (name, t))
!     return 1;
! 
!   while (t)
!     {
!       for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
! 	{
! 	  if (!strcmp (TYPE_FN_FIELDLIST_NAME (t, i), name))
! 	    return 1;
! 	}
! 
!       if (TYPE_N_BASECLASSES (t) == 0)
! 	break;
! 
!       t = TYPE_BASECLASS (t, 1);
!     }
!   return 0;
  }
  
  /* C++: Given an aggregate type DOMAIN, and a member name NAME,
--- 1076,1082 ----
        && TYPE_CODE (t) != TYPE_CODE_UNION)
      error ("Internal error: `this' is not an aggregate");
  
!   return check_field_in (t, name);
  }
  
  /* C++: Given an aggregate type DOMAIN, and a member name NAME,
*************** value_of_this (complain)
*** 1251,1257 ****
      else return 0;
  
    sym = BLOCK_SYM (b, 0);
!   if (strncmp ("$this", SYMBOL_NAME (sym), 5))
      if (complain)
        error ("current stack frame not in method");
      else return 0;
--- 1258,1264 ----
      else return 0;
  
    sym = BLOCK_SYM (b, 0);
!   if (strcmp ("this", SYMBOL_NAME (sym)))
      if (complain)
        error ("current stack frame not in method");
      else return 0;
diff -pr gdb-3.6/valprint.c ../gdb-3.6/valprint.c
*** gdb-3.6/valprint.c	Tue Jun 26 23:47:04 1990
--- ../gdb-3.6/valprint.c	Thu Aug 16 17:44:47 1990
*************** val_print (type, valaddr, address, strea
*** 635,654 ****
  	  val_print (TYPE_FIELD_TYPE (type, i-1), baddr,
  		     0, stream, 0, 0, recurse + 1, pretty);
  	}
-       if (i > 1) {
- 	fprintf_filtered (stream, "\n");
- 	print_spaces_filtered (2 + 2 * recurse, stream);
- 	fputs_filtered ("members of ", stream);
-         fputs_filtered (type_name_no_tag (type), stream);
-         fputs_filtered (": ", stream);
-       }
        if (!len && i == 1)
  	fprintf_filtered (stream, "<No data fields>");
        else
  	{
  	  for (i -= 1; i < len; i++)
  	    {
! 	      if (i > n_baseclasses) fprintf_filtered (stream, ", ");
  	      if (pretty)
  		{
  		  fprintf_filtered (stream, "\n");
--- 635,660 ----
  	  val_print (TYPE_FIELD_TYPE (type, i-1), baddr,
  		     0, stream, 0, 0, recurse + 1, pretty);
  	}
        if (!len && i == 1)
  	fprintf_filtered (stream, "<No data fields>");
        else
  	{
+ 	  int fields_seen = 0;
  	  for (i -= 1; i < len; i++)
  	    {
! 	      /* check if static field */
! 	      if (TYPE_FIELD_STATIC (type, i))
! 		  continue;
! 	      if (fields_seen) fprintf_filtered (stream, ", ");
! 	      else if (n_baseclasses > 0)
! 		{
! 		  fprintf_filtered (stream, "\n");
! 		  print_spaces_filtered (2 + 2 * recurse, stream);
! 		  fputs_filtered ("members of ", stream);
! 		  fputs_filtered (type_name_no_tag (type), stream);
! 		  fputs_filtered (": ", stream);
! 	        }
! 	      fields_seen = 1;
  	      if (pretty)
  		{
  		  fprintf_filtered (stream, "\n");
*************** val_print (type, valaddr, address, strea
*** 656,672 ****
  		}
  	      fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
  	      fputs_filtered (" = ", stream);
! 	      /* check if static field */
! 	      if (TYPE_FIELD_STATIC (type, i))
! 		{
! 		  value v;
! 		  
! 		  v = value_static_field (type, TYPE_FIELD_NAME (type, i), i);
! 		  val_print (TYPE_FIELD_TYPE (type, i),
! 			     VALUE_CONTENTS (v), 0, stream, format,
! 			     deref_ref, recurse + 1, pretty);
! 		}
! 	      else if (TYPE_FIELD_PACKED (type, i))
  		{
  		  char *valp = (char *) & val;
  		  union {int i; char c;} test;
--- 662,668 ----
  		}
  	      fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
  	      fputs_filtered (" = ", stream);
! 	      if (TYPE_FIELD_PACKED (type, i))
  		{
  		  char *valp = (char *) & val;
  		  union {int i; char c;} test;
*************** type_print_method_args (args, prefix, va
*** 893,900 ****
    int i;
  
    fputs_filtered (" ", stream);
!   fputs_filtered (prefix, stream);
!   fputs_filtered (varstring, stream);
    fputs_filtered (" (", stream);
    if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
      {
--- 889,896 ----
    int i;
  
    fputs_filtered (" ", stream);
!   fputs_demangled (prefix, stream, 1);
!   fputs_demangled (varstring, stream, 1);
    fputs_filtered (" (", stream);
    if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
      {
*************** type_print_derivation_info (stream, type
*** 930,957 ****
    int i, n_baseclasses = TYPE_N_BASECLASSES (type);
    struct type *basetype = 0;
  
!   while (type && n_baseclasses == 1)
!     {
! 
!       check_stub_type(type);	/* Not actually sure about this one -- Bryan. */
! 
!       basetype = TYPE_BASECLASS (type, 1);
!       if (name = type_name_no_tag (basetype))
! 	{
! 	  fprintf_filtered (stream, ": %s%s ",
! 		   TYPE_VIA_PUBLIC (basetype) ? "public" : "private",
! 		   TYPE_VIA_VIRTUAL (basetype) ? " virtual" : "");
! 	  fputs_filtered (name, stream);
! 	  fputs_filtered (" ", stream);
! 	}
!       n_baseclasses = TYPE_N_BASECLASSES (basetype);
!       type = basetype;
!     }
! 
!   if (type)
      {
!       if (n_baseclasses != 0)
! 	fprintf_filtered (stream, ": ");
        for (i = 1; i <= n_baseclasses; i++)
  	{
  	  basetype = TYPE_BASECLASS (type, i);
--- 926,937 ----
    int i, n_baseclasses = TYPE_N_BASECLASSES (type);
    struct type *basetype = 0;
  
!   while (type && n_baseclasses > 0)
      {
!       /* Not actually sure about this one -- Bryan. */
!       check_stub_type (type);
!       
!       fprintf_filtered (stream, ": ");
        for (i = 1; i <= n_baseclasses; i++)
  	{
  	  basetype = TYPE_BASECLASS (type, i);
*************** type_print_derivation_info (stream, type
*** 965,971 ****
--- 945,955 ----
  	  if (i < n_baseclasses)
  	    fprintf_filtered (stream, ", ");
  	}
+ 
        fprintf_filtered (stream, " ");
+       if (n_baseclasses != 1) break;
+       n_baseclasses = TYPE_N_BASECLASSES (basetype);
+       type = basetype;
      }
  }
  
*************** type_print_base (type, stream, show, lev
*** 1288,1294 ****
  
  		  fprintf_filtered (stream, ";\n");
  		}
- 	      if (len2) fprintf_filtered (stream, "\n");
  	    }
  
  	  print_spaces_filtered (level, stream);
--- 1272,1277 ----
diff -pr gdb-3.6/value.h ../gdb-3.6/value.h
*** gdb-3.6/value.h	Mon Jun 25 23:51:38 1990
--- ../gdb-3.6/value.h	Thu Aug 16 17:44:48 1990
*************** value value_assign ();
*** 165,171 ****
  value value_neg ();
  value value_lognot ();
  value value_struct_elt (), value_struct_elt_for_address ();
! value value_field ();
  value value_cast ();
  value value_zero ();
  value value_repeat ();
--- 165,171 ----
  value value_neg ();
  value value_lognot ();
  value value_struct_elt (), value_struct_elt_for_address ();
! value value_field (), value_primitive_field();
  value value_cast ();
  value value_zero ();
  value value_repeat ();
diff -pr gdb-3.6/values.c ../gdb-3.6/values.c
*** gdb-3.6/values.c	Tue Jul  3 09:39:15 1990
--- ../gdb-3.6/values.c	Thu Aug 16 17:44:50 1990
*************** unpack_double (type, valaddr, invp)
*** 642,648 ****
    return (double) 0;		/* To silence compiler warning.  */
  }
  
! /* Given a value ARG1 of a struct or union type,
     extract and return the value of one of its fields.
     FIELDNO says which field.
  
--- 642,649 ----
    return (double) 0;		/* To silence compiler warning.  */
  }
  
! /* Given a value ARG1 (offset by OFFSET bytes)
!    of a struct or union type ARG_TYPE,
     extract and return the value of one of its fields.
     FIELDNO says which field.
  
*************** unpack_double (type, valaddr, invp)
*** 649,676 ****
     For C++, must also be able to return values from static fields */
  
  value
! value_field (arg1, fieldno)
       register value arg1;
       register int fieldno;
  {
    register value v;
    register struct type *type;
-   register int offset;
  
!   check_stub_type (VALUE_TYPE (arg1));
!   type = TYPE_FIELD_TYPE (VALUE_TYPE (arg1), fieldno);
  
    /* 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
      {
--- 650,677 ----
     For C++, must also be able to return values from static fields */
  
  value
! value_primitive_field (arg1, offset, fieldno, arg_type)
       register value arg1;
       register int fieldno;
+      register struct type *arg_type;
  {
    register value v;
    register struct type *type;
  
!   check_stub_type (arg_type);
!   type = TYPE_FIELD_TYPE (arg_type, fieldno);
  
    /* Handle packed fields */
  
!   offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
    if (TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno))
      {
        v = value_from_long (type,
! 			   unpack_field_as_long (arg_type,
  						 VALUE_CONTENTS (arg1),
  						 fieldno));
!       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
!       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
      }
    else
      {
*************** value_field (arg1, fieldno)
*** 685,690 ****
--- 686,705 ----
    VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
    VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
    return v;
+ }
+ 
+ /* Given a value ARG1 of a struct or union type,
+    extract and return the value of one of its fields.
+    FIELDNO says which field.
+ 
+    For C++, must also be able to return values from static fields */
+ 
+ value
+ value_field (arg1, fieldno)
+      register value arg1;
+      register int fieldno;
+ {
+   return value_primitive_field (arg1, 0, VALUE_TYPE (arg1), fieldno);
  }
  
  value



More information about the Comp.unix.i386 mailing list