Oodles of changes. The most important is adding support for stabs

encapsulated in mips ecoff.  See ChangeLog for the gory details.

1 files changed, 576 insertions, 0 deletions

diff --git a/gdb/partial-stab.h b/gdb/partial-stab.h
new file mode 100644
index 0000000..d901795
--- /dev/null
+++ b/gdb/partial-stab.h
@@ -0,0 +1,576 @@
+/* Shared code to pre-read a stab (dbx-style), when building a psymtab.
+   Copyright (C) 1986-1991 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* The following need to be defined:
+   SET_NAMESTRING() --Set namestring to name of symbol.
+   CUR_SYMBOL_TYPE --Type code of current symbol.
+   CUR_SYMBOL_VALUE --Value field of current symbol.  May be adjusted here.
+ */
+
+#ifdef DEBUG
+/* Since one arg is a struct, we have to pass in a ptr and deref it (sigh) */
+#define	ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS,  LIST, VALUE) \
+       add_psymbol_to_plist(NAME, NAMELENGTH, NAMESPACE, CLASS, &LIST, VALUE)
+#define	ADD_PSYMBOL_ADDR_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS,  LIST, VALUE) \
+       add_psymbol_to_plist(NAME, NAMELENGTH, NAMESPACE, CLASS, &LIST, VALUE)
+#else
+/* Add a symbol with an integer value to a psymtab. */
+#define ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE) \
+  ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, SYMBOL_VALUE)
+
+/* Add a symbol with a CORE_ADDR value to a psymtab. */
+#define	ADD_PSYMBOL_ADDR_TO_LIST(NAME,NAMELENGTH, NAMESPACE,CLASS, LIST,VALUE)\
+  ADD_PSYMBOL_VT_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE, SYMBOL_VALUE_ADDRESS)
+#endif
+
+/* End of macro definitions, now let's handle them symbols!  */
+
+      switch (CUR_SYMBOL_TYPE)
+	{
+	  char *p;
+	  /*
+	   * Standard, external, non-debugger, symbols
+	   */
+
+#ifdef DBXREAD_ONLY
+	case N_TEXT | N_EXT:
+	case N_NBTEXT | N_EXT:
+	case N_NBDATA | N_EXT:
+	case N_NBBSS | N_EXT:
+	case N_SETV | N_EXT:
+	case N_ABS | N_EXT:
+	case N_DATA | N_EXT:
+	case N_BSS | N_EXT:
+
+	  CUR_SYMBOL_VALUE += addr;		/* Relocate */
+
+	  SET_NAMESTRING();
+
+	bss_ext_symbol:
+	  record_misc_function (namestring, CUR_SYMBOL_VALUE,
+				CUR_SYMBOL_TYPE); /* Always */
+
+	  continue;
+
+	  /* Standard, local, non-debugger, symbols */
+
+	case N_NBTEXT:
+
+	  /* We need to be able to deal with both N_FN or N_TEXT,
+	     because we have no way of knowing whether the sys-supplied ld
+	     or GNU ld was used to make the executable.  Sequents throw
+	     in another wrinkle -- they renumbered N_FN.  */
+
+	case N_FN:
+	case N_FN_SEQ:
+	case N_TEXT:
+	  CUR_SYMBOL_VALUE += addr;		/* Relocate */
+	  SET_NAMESTRING();
+	  if ((namestring[0] == '-' && namestring[1] == 'l')
+	      || (namestring [(nsl = strlen (namestring)) - 1] == 'o'
+		  && namestring [nsl - 2] == '.'))
+	    {
+	      if (entry_point < CUR_SYMBOL_VALUE
+		  && entry_point >= last_o_file_start
+		  && addr == 0)		/* FIXME nogood nomore */
+		{
+		  startup_file_start = last_o_file_start;
+		  startup_file_end = CUR_SYMBOL_VALUE;
+		}
+	      if (past_first_source_file && pst
+		  /* The gould NP1 uses low values for .o and -l symbols
+		     which are not the address.  */
+		  && CUR_SYMBOL_VALUE > pst->textlow)
+		{
+		  END_PSYMTAB (pst, psymtab_include_list, includes_used,
+			       symnum * symbol_size, CUR_SYMBOL_VALUE,
+			       dependency_list, dependencies_used);
+		  pst = (struct partial_symtab *) 0;
+		  includes_used = 0;
+		  dependencies_used = 0;
+		}
+	      else
+		past_first_source_file = 1;
+	      last_o_file_start = CUR_SYMBOL_VALUE;
+	    }
+	  continue;
+
+	case N_DATA:
+	  CUR_SYMBOL_VALUE += addr;		/* Relocate */
+	  SET_NAMESTRING ();
+	  /* Check for __DYNAMIC, which is used by Sun shared libraries. 
+	     Record it even if it's local, not global, so we can find it.
+	     Same with virtual function tables, both global and static.  */
+	  if ((namestring[8] == 'C' && (strcmp ("__DYNAMIC", namestring) == 0))
+	      || VTBL_PREFIX_P ((namestring+HASH_OFFSET)))
+	    {
+	      /* Not really a function here, but... */
+	      record_misc_function (namestring, CUR_SYMBOL_VALUE,
+				    CUR_SYMBOL_TYPE); /* Always */
+	  }
+	  continue;
+
+	case N_UNDF | N_EXT:
+	  if (CUR_SYMBOL_VALUE != 0) {
+	    /* This is a "Fortran COMMON" symbol.  See if the target
+	       environment knows where it has been relocated to.  */
+
+	    CORE_ADDR reladdr;
+
+	    SET_NAMESTRING();
+	    if (target_lookup_symbol (namestring, &reladdr)) {
+	      continue;		/* Error in lookup; ignore symbol for now.  */
+	    }
+	    CUR_SYMBOL_TYPE ^= (N_BSS^N_UNDF);	/* Define it as a bss-symbol */
+	    CUR_SYMBOL_VALUE = reladdr;
+	    goto bss_ext_symbol;
+	  }
+	  continue;	/* Just undefined, not COMMON */
+#endif
+
+	    /* Lots of symbol types we can just ignore.  */
+
+	case N_UNDF:
+	case N_ABS:
+	case N_BSS:
+	case N_NBDATA:
+	case N_NBBSS:
+	  continue;
+
+	  /* Keep going . . .*/
+
+	  /*
+	   * Special symbol types for GNU
+	   */
+	case N_INDR:
+	case N_INDR | N_EXT:
+	case N_SETA:
+	case N_SETA | N_EXT:
+	case N_SETT:
+	case N_SETT | N_EXT:
+	case N_SETD:
+	case N_SETD | N_EXT:
+	case N_SETB:
+	case N_SETB | N_EXT:
+	case N_SETV:
+	  continue;
+
+	  /*
+	   * Debugger symbols
+	   */
+
+	case N_SO: {
+	  unsigned long valu = CUR_SYMBOL_VALUE;
+	  /* Symbol number of the first symbol of this file (i.e. the N_SO
+	     if there is just one, or the first if we have a pair).  */
+	  int first_symnum = symnum;
+	  
+	  /* End the current partial symtab and start a new one */
+
+	  SET_NAMESTRING();
+
+	  /* Peek at the next symbol.  If it is also an N_SO, the
+	     first one just indicates the directory.  */
+	  CHECK_SECOND_N_SO();
+	  valu += addr;		/* Relocate */
+
+	  if (pst && past_first_source_file)
+	    {
+	      END_PSYMTAB (pst, psymtab_include_list, includes_used,
+			   first_symnum * symbol_size, valu,
+			   dependency_list, dependencies_used);
+	      pst = (struct partial_symtab *) 0;
+	      includes_used = 0;
+	      dependencies_used = 0;
+	    }
+	  else
+	    past_first_source_file = 1;
+
+	  pst = START_PSYMTAB (objfile, addr,
+			       namestring, valu,
+			       first_symnum * symbol_size,
+			       global_psymbols.next, static_psymbols.next);
+	  continue;
+	}
+
+#ifdef DBXREAD_ONLY
+	case N_BINCL:
+	  /* Add this bincl to the bincl_list for future EXCLs.  No
+	     need to save the string; it'll be around until
+	     read_dbx_symtab function returns */
+
+	  SET_NAMESTRING();
+
+	  add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE);
+
+	  /* Mark down an include file in the current psymtab */
+
+	  psymtab_include_list[includes_used++] = namestring;
+	  if (includes_used >= includes_allocated)
+	    {
+	      char **orig = psymtab_include_list;
+
+	      psymtab_include_list = (char **)
+		alloca ((includes_allocated *= 2) *
+			sizeof (char *));
+	      bcopy (orig, psymtab_include_list,
+		     includes_used * sizeof (char *));
+	    }
+
+	  continue;
+#endif
+
+	case N_SOL:
+	  /* Mark down an include file in the current psymtab */
+
+	  SET_NAMESTRING();
+
+	  /* In C++, one may expect the same filename to come round many
+	     times, when code is coming alternately from the main file
+	     and from inline functions in other files. So I check to see
+	     if this is a file we've seen before -- either the main
+	     source file, or a previously included file.
+
+	     This seems to be a lot of time to be spending on N_SOL, but
+	     things like "break c-exp.y:435" need to work (I
+	     suppose the psymtab_include_list could be hashed or put
+	     in a binary tree, if profiling shows this is a major hog).  */
+	  if (pst && !strcmp (namestring, pst->filename))
+	    continue;
+	  {
+	    register int i;
+	    for (i = 0; i < includes_used; i++)
+	      if (!strcmp (namestring, psymtab_include_list[i]))
+		{
+		  i = -1; 
+		  break;
+		}
+	    if (i == -1)
+	      continue;
+	  }
+
+	  psymtab_include_list[includes_used++] = namestring;
+	  if (includes_used >= includes_allocated)
+	    {
+	      char **orig = psymtab_include_list;
+
+	      psymtab_include_list = (char **)
+		alloca ((includes_allocated *= 2) *
+			sizeof (char *));
+	      bcopy (orig, psymtab_include_list,
+		     includes_used * sizeof (char *));
+	    }
+	  continue;
+	case N_LSYM:		/* Typedef or automatic variable. */
+	case N_STSYM:		/* Data seg var -- static  */
+	case N_LCSYM:		/* BSS      "  */
+	case N_NBSTS:           /* Gould nobase.  */
+	case N_NBLCS:           /* symbols.  */
+
+	  SET_NAMESTRING();
+
+	  p = (char *) strchr (namestring, ':');
+
+	  /* Skip if there is no :.  */
+	  if (!p) continue;
+
+	  switch (p[1])
+	    {
+	    case 'T':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   STRUCT_NAMESPACE, LOC_TYPEDEF,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      if (p[2] == 't')
+		{
+		  /* Also a typedef with the same name.  */
+		  ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				       VAR_NAMESPACE, LOC_TYPEDEF,
+				       static_psymbols, CUR_SYMBOL_VALUE);
+		  p += 1;
+		}
+	      goto check_enum;
+	    case 't':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_TYPEDEF,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	    check_enum:
+#ifdef DBXREAD_ONLY
+	      /* If this is an enumerated type, we need to
+		 add all the enum constants to the partial symbol
+		 table.  This does not cover enums without names, e.g.
+		 "enum {a, b} c;" in C, but fortunately those are
+		 rare.  There is no way for GDB to find those from the
+		 enum type without spending too much time on it.  Thus
+		 to solve this problem, the compiler needs to put out separate
+		 constant symbols ('c' N_LSYMS) for enum constants in
+		 enums without names, or put out a dummy type.  */
+
+	      /* We are looking for something of the form
+		 <name> ":" ("t" | "T") [<number> "="] "e"
+		 {<constant> ":" <value> ","} ";".  */
+
+	      /* Skip over the colon and the 't' or 'T'.  */
+	      p += 2;
+	      /* This type may be given a number.  Also, numbers can come
+		 in pairs like (0,26).  Skip over it.  */
+	      while ((*p >= '0' && *p <= '9')
+		     || *p == '(' || *p == ',' || *p == ')'
+		     || *p == '=')
+		p++;
+
+	      if (*p++ == 'e')
+		{
+		  /* We have found an enumerated type.  */
+		  /* According to comments in read_enum_type
+		     a comma could end it instead of a semicolon.
+		     I don't know where that happens.
+		     Accept either.  */
+		  while (*p && *p != ';' && *p != ',')
+		    {
+		      char *q;
+
+		      /* Check for and handle cretinous dbx symbol name
+			 continuation!  */
+		      if (*p == '\\')
+			p = next_symbol_text ();
+
+		      /* Point to the character after the name
+			 of the enum constant.  */
+		      for (q = p; *q && *q != ':'; q++)
+			;
+		      /* Note that the value doesn't matter for
+			 enum constants in psymtabs, just in symtabs.  */
+		      ADD_PSYMBOL_TO_LIST (p, q - p,
+					   VAR_NAMESPACE, LOC_CONST,
+					   static_psymbols, 0);
+		      /* Point past the name.  */
+		      p = q;
+		      /* Skip over the value.  */
+		      while (*p && *p != ',')
+			p++;
+		      /* Advance past the comma.  */
+		      if (*p)
+			p++;
+		    }
+		}
+#endif
+	      continue;
+	    case 'c':
+	      /* Constant, e.g. from "const" in Pascal.  */
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_CONST,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+	    default:
+	      /* Skip if the thing following the : is
+	         not a letter (which indicates declaration of a local
+	         variable, which we aren't interested in).  */
+	      continue;
+	    }
+
+	case N_FUN:
+	case N_GSYM:		/* Global (extern) variable; can be
+				   data or bss (sigh).  */
+
+	/* Following may probably be ignored; I'll leave them here
+	   for now (until I do Pascal and Modula 2 extensions).  */
+
+	case N_PC:		/* I may or may not need this; I
+				   suspect not.  */
+	case N_M2C:		/* I suspect that I can ignore this here. */
+	case N_SCOPE:		/* Same.   */
+
+	  SET_NAMESTRING();
+
+	  p = (char *) strchr (namestring, ':');
+	  if (!p)
+	    continue;		/* Not a debugging symbol.   */
+
+
+
+	  /* Main processing section for debugging symbols which
+	     the initial read through the symbol tables needs to worry
+	     about.  If we reach this point, the symbol which we are
+	     considering is definitely one we are interested in.
+	     p must also contain the (valid) index into the namestring
+	     which indicates the debugging type symbol.  */
+
+	  switch (p[1])
+	    {
+	    case 'c':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_CONST,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+	    case 'S':
+	      CUR_SYMBOL_VALUE += addr;		/* Relocate */
+	      ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_STATIC,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+	    case 'G':
+	      CUR_SYMBOL_VALUE += addr;		/* Relocate */
+	      /* The addresses in these entries are reported to be
+		 wrong.  See the code that reads 'G's for symtabs. */
+	      ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_STATIC,
+				   global_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+
+	    case 't':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_TYPEDEF,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+
+	    case 'f':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_BLOCK,
+				   static_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+
+	      /* Global functions were ignored here, but now they
+	         are put into the global psymtab like one would expect.
+		 They're also in the misc fn vector... 
+		 FIXME, why did it used to ignore these?  That broke
+		 "i fun" on these functions.  */
+	    case 'F':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_BLOCK,
+				   global_psymbols, CUR_SYMBOL_VALUE);
+	      continue;
+
+	      /* Two things show up here (hopefully); static symbols of
+		 local scope (static used inside braces) or extensions
+		 of structure symbols.  We can ignore both.  */
+	    case 'V':
+	    case '(':
+	    case '0':
+	    case '1':
+	    case '2':
+	    case '3':
+	    case '4':
+	    case '5':
+	    case '6':
+	    case '7':
+	    case '8':
+	    case '9':
+	      continue;
+
+	    default:
+	      /* Unexpected symbol.  Ignore it; perhaps it is an extension
+		 that we don't know about.
+
+		 Someone says sun cc puts out symbols like
+		 /foo/baz/maclib::/usr/local/bin/maclib,
+		 which would get here with a symbol type of ':'.  */
+	      continue;
+	    }
+
+#ifdef DBXREAD_ONLY
+	case N_EXCL:
+
+	  SET_NAMESTRING();
+
+	  /* Find the corresponding bincl and mark that psymtab on the
+	     psymtab dependency list */
+	  {
+	    struct partial_symtab *needed_pst =
+	      find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE);
+
+	    /* If this include file was defined earlier in this file,
+	       leave it alone.  */
+	    if (needed_pst == pst) continue;
+
+	    if (needed_pst)
+	      {
+		int i;
+		int found = 0;
+
+		for (i = 0; i < dependencies_used; i++)
+		  if (dependency_list[i] == needed_pst)
+		    {
+		      found = 1;
+		      break;
+		    }
+
+		/* If it's already in the list, skip the rest.  */
+		if (found) continue;
+
+		dependency_list[dependencies_used++] = needed_pst;
+		if (dependencies_used >= dependencies_allocated)
+		  {
+		    struct partial_symtab **orig = dependency_list;
+		    dependency_list =
+		      (struct partial_symtab **)
+			alloca ((dependencies_allocated *= 2)
+				* sizeof (struct partial_symtab *));
+		    bcopy (orig, dependency_list,
+			   (dependencies_used
+			    * sizeof (struct partial_symtab *)));
+#ifdef DEBUG_INFO
+		    fprintf (stderr, "Had to reallocate dependency list.\n");
+		    fprintf (stderr, "New dependencies allocated: %d\n",
+			     dependencies_allocated);
+#endif
+		  }
+	      }
+	    else
+	      error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
+		     symnum);
+	  }
+	  continue;
+#endif
+
+	case N_RBRAC:
+#ifdef HANDLE_RBRAC
+	  HANDLE_RBRAC(CUR_SYMBOL_VALUE);
+#endif
+	case N_EINCL:
+	case N_DSLINE:
+	case N_BSLINE:
+	case N_SSYM:		/* Claim: Structure or union element.
+				   Hopefully, I can ignore this.  */
+	case N_ENTRY:		/* Alternate entry point; can ignore. */
+	case N_MAIN:		/* Can definitely ignore this.   */
+	case N_CATCH:		/* These are GNU C++ extensions */
+	case N_EHDECL:		/* that can safely be ignored here. */
+	case N_LENG:
+	case N_BCOMM:
+	case N_ECOMM:
+	case N_ECOML:
+	case N_FNAME:
+	case N_SLINE:
+	case N_RSYM:
+	case N_PSYM:
+	case N_LBRAC:
+	case N_NSYMS:		/* Ultrix 4.0: symbol count */
+	case N_DEFD:		/* GNU Modula-2 */
+	  /* These symbols aren't interesting; don't worry about them */
+
+	  continue;
+
+	default:
+#ifdef DBXREAD_ONLY
+	  /* If we haven't found it yet, ignore it.  It's probably some
+	     new type we don't know about yet.  */
+	  complain (&unknown_symtype_complaint, local_hex_string(CUR_SYMBOL_TYPE));
+#endif
+	  continue;
+	}