[deliverable/binutils-gdb.git] / gdb / partial-stab.h

/* Shared code to pre-read a stab (dbx-style), when building a psymtab.
   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
   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.
 */

/* End of macro definitions, now let's handle them symbols!  */

      switch (CUR_SYMBOL_TYPE)
	{
	  char *p;
	  /*
	   * Standard, external, non-debugger, symbols
	   */

	case N_TEXT | N_EXT:
	case N_NBTEXT | N_EXT:
	  CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_TEXT);
	  goto record_it;

	case N_DATA | N_EXT:
	case N_NBDATA | N_EXT:
	  CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	  goto record_it;

	case N_BSS | N_EXT:
	case N_NBBSS | N_EXT:
        case N_SETV | N_EXT:		/* FIXME, is this in BSS? */
	  CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_BSS);
	  goto record_it;

	case N_ABS | N_EXT:
	record_it:
#ifdef DBXREAD_ONLY
	  SET_NAMESTRING();

	bss_ext_symbol:
	  record_minimal_symbol (namestring, CUR_SYMBOL_VALUE,
				 CUR_SYMBOL_TYPE, objfile); /* Always */
#endif /* DBXREAD_ONLY */
	  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:
#ifdef DBXREAD_ONLY
	  CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_TEXT);
	  SET_NAMESTRING();
	  if ((namestring[0] == '-' && namestring[1] == 'l')
	      || (namestring [(nsl = strlen (namestring)) - 1] == 'o'
		  && namestring [nsl - 2] == '.')
#ifdef GDB_TARGET_IS_HPPA
              /* some cooperation from gcc to get around ld stupidity */
              || (namestring[0] == 'e' && STREQ (namestring, "end_file."))
#endif
	      )
	    {
#ifndef GDB_TARGET_IS_HPPA
	      if (objfile -> ei.entry_point <  CUR_SYMBOL_VALUE &&
		  objfile -> ei.entry_point >= last_o_file_start)
		{
		  objfile -> ei.entry_file_lowpc = last_o_file_start;
		  objfile -> ei.entry_file_highpc = CUR_SYMBOL_VALUE;
		}
#endif
	      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;
	    }
#endif /* DBXREAD_ONLY */
	  continue;

	case N_DATA:
#ifdef DBXREAD_ONLY
	  CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	  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.
	     FIXME:  this might want to check for _DYNAMIC and the current
		     symbol_leading_char.  */
	  if (namestring[8] == 'C' && STREQ ("__DYNAMIC", namestring))
	    goto record_it;

	  /* Same with virtual function tables, both global and static.  */
	  {
	    char *tempstring = namestring;
	    if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
	      tempstring++;
	    if (VTBL_PREFIX_P ((tempstring)))
	      goto record_it;
	  }
#endif /* DBXREAD_ONLY */
	  continue;

	case N_UNDF | N_EXT:
#ifdef DBXREAD_ONLY
	  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;
	  }
#endif /* DBXREAD_ONLY */
	  continue;	/* Just undefined, not COMMON */

	case N_UNDF:
#ifdef DBXREAD_ONLY
	  if (processing_acc_compilation && bufp->n_strx == 1) {
	    /* Deal with relative offsets in the string table
	       used in ELF+STAB under Solaris.  If we want to use the
	       n_strx field, which contains the name of the file,
	       we must adjust file_string_table_offset *before* calling
	       SET_NAMESTRING().  */
	    past_first_source_file = 1;
	    file_string_table_offset = next_file_string_table_offset;
	    next_file_string_table_offset =
	      file_string_table_offset + bufp->n_value;
	    if (next_file_string_table_offset < file_string_table_offset)
	      error ("string table offset backs up at %d", symnum);
  /* FIXME -- replace error() with complaint.  */
	    continue;
	  }
#endif /* DBXREAD_ONLY */
	  continue;

	    /* Lots of symbol types we can just ignore.  */

	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;
	  static int prev_so_symnum = -10;
	  static int first_so_symnum;
	  char *p;
	  
	  past_first_source_file = 1;

	  if (prev_so_symnum != symnum - 1)
	    {			/* Here if prev stab wasn't N_SO */
	      first_so_symnum = symnum;

	      if (pst)
		{
		  END_PSYMTAB (pst, psymtab_include_list, includes_used,
			       symnum * symbol_size, valu,
			       dependency_list, dependencies_used);
		  pst = (struct partial_symtab *) 0;
		  includes_used = 0;
		  dependencies_used = 0;
		}
	    }

	  prev_so_symnum = symnum;

	  /* End the current partial symtab and start a new one */

	  SET_NAMESTRING();

	  valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);

	  /* Some compilers (including gcc) emit a pair of initial N_SOs.
	     The first one is a directory name; the second the file name.
	     If pst exists, is empty, and has a filename ending in '/',
	     we assume the previous N_SO was a directory name. */

	  p = strrchr (namestring, '/');
	  if (p && *(p+1) == '\000')
	    continue;		/* Simply ignore directory name SOs */

	  /* Some other compilers (C++ ones in particular) emit useless
	     SOs for non-existant .c files.  We ignore all subsequent SOs that
	     immediately follow the first.  */

	  if (!pst)
	    pst = START_PSYMTAB (objfile, section_offsets,
				 namestring, valu,
				 first_so_symnum * symbol_size,
				 objfile -> global_psymbols.next,
				 objfile -> static_psymbols.next);
	  continue;
	}

	case N_BINCL:
#ifdef DBXREAD_ONLY
	  /* 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 */

	  goto record_include_file;

#else /* DBXREAD_ONLY */
	  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 && STREQ (namestring, pst->filename))
	    continue;
	  {
	    register int i;
	    for (i = 0; i < includes_used; i++)
	      if (STREQ (namestring, psymtab_include_list[i]))
		{
		  i = -1; 
		  break;
		}
	    if (i == -1)
	      continue;
	  }

	record_include_file:

	  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 *));
	      memcpy ((PTR)psymtab_include_list, (PTR)orig,
		      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_ROSYM:		/* Read-only data seg var -- static.  */
	case N_NBSTS:           /* Gould nobase.  */
	case N_NBLCS:           /* symbols.  */
	case N_FUN:
	case N_GSYM:		/* Global (extern) variable; can be
				   data or bss (sigh FIXME).  */

	/* 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 'S':
	      CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	      ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
					VAR_NAMESPACE, LOC_STATIC,
					objfile->static_psymbols,
					CUR_SYMBOL_VALUE,
					psymtab_language, objfile);
	      continue;
	    case 'G':
	      CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	      /* 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,
					objfile->global_psymbols,
					CUR_SYMBOL_VALUE,
					psymtab_language, objfile);
	      continue;

	    case 'T':
	      if (p != namestring)	/* a name is there, not just :T... */
		{
		  ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
				       STRUCT_NAMESPACE, LOC_TYPEDEF,
				       objfile->static_psymbols,
				       CUR_SYMBOL_VALUE,
				       psymtab_language, objfile);
		  if (p[2] == 't')
		    {
		      /* Also a typedef with the same name.  */
		      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
					   VAR_NAMESPACE, LOC_TYPEDEF,
					   objfile->static_psymbols,
					   CUR_SYMBOL_VALUE, psymtab_language,
					   objfile);
		      p += 1;
		    }
		}
	      goto check_enum;
	    case 't':
	      if (p != namestring)	/* a name is there, not just :T... */
		{
		  ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
				       VAR_NAMESPACE, LOC_TYPEDEF,
				       objfile->static_psymbols,
				       CUR_SYMBOL_VALUE,
				       psymtab_language, objfile);
		}
	    check_enum:
	      /* 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 the
		 enum in a nameless type.  GCC2 does this.  */

	      /* 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,
					   objfile->static_psymbols, 0,
					   psymtab_language, objfile);
		      /* Point past the name.  */
		      p = q;
		      /* Skip over the value.  */
		      while (*p && *p != ',')
			p++;
		      /* Advance past the comma.  */
		      if (*p)
			p++;
		    }
		}
	      continue;
	    case 'c':
	      /* Constant, e.g. from "const" in Pascal.  */
	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
				   VAR_NAMESPACE, LOC_CONST,
				   objfile->static_psymbols, CUR_SYMBOL_VALUE,
				   psymtab_language, objfile);
	      continue;

	    case 'f':
#ifdef DBXREAD_ONLY
	      /* Kludges for ELF/STABS with Sun ACC */
	      last_function_name = namestring;
	      if (pst && pst->textlow == 0)
		pst->textlow = CUR_SYMBOL_VALUE;
#if 0
	      if (startup_file_end == 0)
		startup_file_end = CUR_SYMBOL_VALUE;
#endif
	      /* End kludge.  */
#endif /* DBXREAD_ONLY */
	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
				   VAR_NAMESPACE, LOC_BLOCK,
				   objfile->static_psymbols, CUR_SYMBOL_VALUE,
				   psymtab_language, objfile);
	      continue;

	      /* Global functions were ignored here, but now they
	         are put into the global psymtab like one would expect.
		 They're also in the minimal symbol table.  */
	    case 'F':
#ifdef DBXREAD_ONLY
	      /* Kludges for ELF/STABS with Sun ACC */
	      last_function_name = namestring;
	      if (pst && pst->textlow == 0)
		pst->textlow = CUR_SYMBOL_VALUE;
#if 0
	      if (startup_file_end == 0)
		startup_file_end = CUR_SYMBOL_VALUE;
#endif
	      /* End kludge.  */
#endif /* DBXREAD_ONLY */
	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
				   VAR_NAMESPACE, LOC_BLOCK,
				   objfile->global_psymbols, CUR_SYMBOL_VALUE,
				   psymtab_language, objfile);
	      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 ':'.  */
	      complain (&unknown_symchar_complaint, p[1]);
	      continue;
	    }

	case N_EXCL:
#ifdef DBXREAD_ONLY

	  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 *));
		    memcpy ((PTR)dependency_list, (PTR)orig,
			   (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);
	  }
#endif /* DBXREAD_ONLY */
	  continue;

	case N_RBRAC:
#ifdef HANDLE_RBRAC
	  HANDLE_RBRAC(CUR_SYMBOL_VALUE);
	  continue;
#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 */

	case N_OBJ:		/* useless types from Solaris */
	case N_OPT:
	case N_ENDM:
	  /* These symbols aren't interesting; don't worry about them */

	  continue;

	default:
	  /* 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));
	  continue;
	}
Commit	Line	Data
7e258d18	1	/* Shared code to pre-read a stab (dbx-style), when building a psymtab.
65ce5df4 JG	2	Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
65ce5df4 JG	3	Free Software Foundation, Inc.
7e258d18 PB	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21	/* The following need to be defined:
	22	SET_NAMESTRING() --Set namestring to name of symbol.
	23	CUR_SYMBOL_TYPE --Type code of current symbol.
	24	CUR_SYMBOL_VALUE --Value field of current symbol. May be adjusted here.
	25	*/
	26
7e258d18 PB	27	/* End of macro definitions, now let's handle them symbols! */
	28
	29	switch (CUR_SYMBOL_TYPE)
	30	{
	31	char *p;
	32	/*
	33	* Standard, external, non-debugger, symbols
	34	*/
	35
7e258d18 PB	36	case N_TEXT \| N_EXT:
7e258d18 PB	37	case N_NBTEXT \| N_EXT:
2670f34d JG	38	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_TEXT);
	39	goto record_it;
	40
	41	case N_DATA \| N_EXT:
7e258d18	42	case N_NBDATA \| N_EXT:
2670f34d JG	43	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	44	goto record_it;
	45
	46	case N_BSS \| N_EXT:
7e258d18	47	case N_NBBSS \| N_EXT:
2670f34d JG	48	case N_SETV \| N_EXT: /* FIXME, is this in BSS? */
	49	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_BSS);
	50	goto record_it;
	51
7e258d18	52	case N_ABS \| N_EXT:
2670f34d	53	record_it:
aab77d5f	54	#ifdef DBXREAD_ONLY
7e258d18 PB	55	SET_NAMESTRING();
	56
	57	bss_ext_symbol:
1ab3bf1b JG	58	record_minimal_symbol (namestring, CUR_SYMBOL_VALUE,
1ab3bf1b JG	59	CUR_SYMBOL_TYPE, objfile); /* Always */
aab77d5f	60	#endif /* DBXREAD_ONLY */
7e258d18 PB	61	continue;
	62
	63	/* Standard, local, non-debugger, symbols */
	64
	65	case N_NBTEXT:
	66
	67	/* We need to be able to deal with both N_FN or N_TEXT,
	68	because we have no way of knowing whether the sys-supplied ld
	69	or GNU ld was used to make the executable. Sequents throw
	70	in another wrinkle -- they renumbered N_FN. */
	71
	72	case N_FN:
	73	case N_FN_SEQ:
	74	case N_TEXT:
aab77d5f	75	#ifdef DBXREAD_ONLY
2670f34d	76	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_TEXT);
7e258d18 PB	77	SET_NAMESTRING();
	78	if ((namestring[0] == '-' && namestring[1] == 'l')
	79	\|\| (namestring [(nsl = strlen (namestring)) - 1] == 'o'
7da1e27d	80	&& namestring [nsl - 2] == '.')
e0ba1d14	81	#ifdef GDB_TARGET_IS_HPPA
7da1e27d	82	/* some cooperation from gcc to get around ld stupidity */
2e4964ad	83	\|\| (namestring[0] == 'e' && STREQ (namestring, "end_file."))
7da1e27d SG	84	#endif
7da1e27d SG	85	)
7e258d18	86	{
e0ba1d14	87	#ifndef GDB_TARGET_IS_HPPA
5e2e79f8	88	if (objfile -> ei.entry_point < CUR_SYMBOL_VALUE &&
2670f34d	89	objfile -> ei.entry_point >= last_o_file_start)
7e258d18	90	{
5e2e79f8 FF	91	objfile -> ei.entry_file_lowpc = last_o_file_start;
5e2e79f8 FF	92	objfile -> ei.entry_file_highpc = CUR_SYMBOL_VALUE;
7e258d18	93	}
7da1e27d	94	#endif
7e258d18 PB	95	if (past_first_source_file && pst
	96	/* The gould NP1 uses low values for .o and -l symbols
	97	which are not the address. */
369172bb	98	&& CUR_SYMBOL_VALUE >= pst->textlow)
7e258d18 PB	99	{
	100	END_PSYMTAB (pst, psymtab_include_list, includes_used,
	101	symnum * symbol_size, CUR_SYMBOL_VALUE,
	102	dependency_list, dependencies_used);
	103	pst = (struct partial_symtab *) 0;
	104	includes_used = 0;
	105	dependencies_used = 0;
	106	}
	107	else
	108	past_first_source_file = 1;
	109	last_o_file_start = CUR_SYMBOL_VALUE;
	110	}
aab77d5f	111	#endif /* DBXREAD_ONLY */
7e258d18 PB	112	continue;
	113
	114	case N_DATA:
aab77d5f	115	#ifdef DBXREAD_ONLY
2670f34d	116	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
7e258d18 PB	117	SET_NAMESTRING ();
	118	/* Check for __DYNAMIC, which is used by Sun shared libraries.
	119	Record it even if it's local, not global, so we can find it.
de9bef49 JG	120	FIXME: this might want to check for _DYNAMIC and the current
de9bef49 JG	121	symbol_leading_char. */
2e4964ad	122	if (namestring[8] == 'C' && STREQ ("__DYNAMIC", namestring))
de9bef49 JG	123	goto record_it;
	124
	125	/* Same with virtual function tables, both global and static. */
	126	{
	127	char *tempstring = namestring;
	128	if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
	129	tempstring++;
	130	if (VTBL_PREFIX_P ((tempstring)))
	131	goto record_it;
	132	}
aab77d5f	133	#endif /* DBXREAD_ONLY */
7e258d18 PB	134	continue;
	135
	136	case N_UNDF \| N_EXT:
aab77d5f	137	#ifdef DBXREAD_ONLY
7e258d18 PB	138	if (CUR_SYMBOL_VALUE != 0) {
	139	/* This is a "Fortran COMMON" symbol. See if the target
	140	environment knows where it has been relocated to. */
	141
	142	CORE_ADDR reladdr;
	143
	144	SET_NAMESTRING();
	145	if (target_lookup_symbol (namestring, &reladdr)) {
	146	continue; /* Error in lookup; ignore symbol for now. */
	147	}
	148	CUR_SYMBOL_TYPE ^= (N_BSS^N_UNDF); /* Define it as a bss-symbol */
	149	CUR_SYMBOL_VALUE = reladdr;
	150	goto bss_ext_symbol;
	151	}
aab77d5f	152	#endif /* DBXREAD_ONLY */
7e258d18	153	continue; /* Just undefined, not COMMON */
7e258d18	154
9342ecb9 JG	155	case N_UNDF:
	156	#ifdef DBXREAD_ONLY
	157	if (processing_acc_compilation && bufp->n_strx == 1) {
bcbf9559 JG	158	/* Deal with relative offsets in the string table
	159	used in ELF+STAB under Solaris. If we want to use the
	160	n_strx field, which contains the name of the file,
	161	we must adjust file_string_table_offset before calling
	162	SET_NAMESTRING(). */
9342ecb9 JG	163	past_first_source_file = 1;
	164	file_string_table_offset = next_file_string_table_offset;
	165	next_file_string_table_offset =
	166	file_string_table_offset + bufp->n_value;
	167	if (next_file_string_table_offset < file_string_table_offset)
	168	error ("string table offset backs up at %d", symnum);
	169	/* FIXME -- replace error() with complaint. */
	170	continue;
	171	}
	172	#endif /* DBXREAD_ONLY */
	173	continue;
	174
7e258d18 PB	175	/* Lots of symbol types we can just ignore. */
7e258d18 PB	176
7e258d18 PB	177	case N_ABS:
	178	case N_BSS:
	179	case N_NBDATA:
	180	case N_NBBSS:
	181	continue;
	182
	183	/* Keep going . . .*/
	184
	185	/*
	186	* Special symbol types for GNU
	187	*/
	188	case N_INDR:
	189	case N_INDR \| N_EXT:
	190	case N_SETA:
	191	case N_SETA \| N_EXT:
	192	case N_SETT:
	193	case N_SETT \| N_EXT:
	194	case N_SETD:
	195	case N_SETD \| N_EXT:
	196	case N_SETB:
	197	case N_SETB \| N_EXT:
	198	case N_SETV:
	199	continue;
	200
	201	/*
	202	* Debugger symbols
	203	*/
	204
	205	case N_SO: {
	206	unsigned long valu = CUR_SYMBOL_VALUE;
cdaa27e9 SG	207	static int prev_so_symnum = -10;
cdaa27e9 SG	208	static int first_so_symnum;
c72af089	209	char *p;
7e258d18	210
cdaa27e9 SG	211	past_first_source_file = 1;
	212
	213	if (prev_so_symnum != symnum - 1)
	214	{ /* Here if prev stab wasn't N_SO */
	215	first_so_symnum = symnum;
	216
	217	if (pst)
	218	{
	219	END_PSYMTAB (pst, psymtab_include_list, includes_used,
	220	symnum * symbol_size, valu,
	221	dependency_list, dependencies_used);
	222	pst = (struct partial_symtab *) 0;
	223	includes_used = 0;
	224	dependencies_used = 0;
	225	}
	226	}
	227
	228	prev_so_symnum = symnum;
	229
7e258d18 PB	230	/* End the current partial symtab and start a new one */
	231
	232	SET_NAMESTRING();
	233
2670f34d	234	valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
7e258d18	235
c72af089 SG	236	/* Some compilers (including gcc) emit a pair of initial N_SOs.
	237	The first one is a directory name; the second the file name.
	238	If pst exists, is empty, and has a filename ending in '/',
	239	we assume the previous N_SO was a directory name. */
	240
323227fe	241	p = strrchr (namestring, '/');
c72af089	242	if (p && *(p+1) == '\000')
cdaa27e9	243	continue; /* Simply ignore directory name SOs */
c72af089 SG	244
c72af089 SG	245	/* Some other compilers (C++ ones in particular) emit useless
cdaa27e9 SG	246	SOs for non-existant .c files. We ignore all subsequent SOs that
	247	immediately follow the first. */
	248
	249	if (!pst)
	250	pst = START_PSYMTAB (objfile, section_offsets,
	251	namestring, valu,
	252	first_so_symnum * symbol_size,
	253	objfile -> global_psymbols.next,
	254	objfile -> static_psymbols.next);
7e258d18 PB	255	continue;
	256	}
	257
7e258d18	258	case N_BINCL:
aab77d5f	259	#ifdef DBXREAD_ONLY
7e258d18 PB	260	/* Add this bincl to the bincl_list for future EXCLs. No
	261	need to save the string; it'll be around until
	262	read_dbx_symtab function returns */
	263
	264	SET_NAMESTRING();
	265
	266	add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE);
	267
	268	/* Mark down an include file in the current psymtab */
	269
8a1c3e99	270	goto record_include_file;
7e258d18	271
8a1c3e99	272	#else /* DBXREAD_ONLY */
7e258d18	273	continue;
8a1c3e99	274	#endif
7e258d18 PB	275
	276	case N_SOL:
	277	/* Mark down an include file in the current psymtab */
	278
	279	SET_NAMESTRING();
	280
	281	/* In C++, one may expect the same filename to come round many
	282	times, when code is coming alternately from the main file
	283	and from inline functions in other files. So I check to see
	284	if this is a file we've seen before -- either the main
	285	source file, or a previously included file.
	286
	287	This seems to be a lot of time to be spending on N_SOL, but
	288	things like "break c-exp.y:435" need to work (I
	289	suppose the psymtab_include_list could be hashed or put
	290	in a binary tree, if profiling shows this is a major hog). */
2e4964ad	291	if (pst && STREQ (namestring, pst->filename))
7e258d18 PB	292	continue;
	293	{
	294	register int i;
	295	for (i = 0; i < includes_used; i++)
2e4964ad	296	if (STREQ (namestring, psymtab_include_list[i]))
7e258d18 PB	297	{
	298	i = -1;
	299	break;
	300	}
	301	if (i == -1)
	302	continue;
	303	}
	304
8a1c3e99 SG	305	record_include_file:
8a1c3e99 SG	306
7e258d18 PB	307	psymtab_include_list[includes_used++] = namestring;
	308	if (includes_used >= includes_allocated)
	309	{
	310	char **orig = psymtab_include_list;
	311
	312	psymtab_include_list = (char **)
	313	alloca ((includes_allocated = 2)
	314	sizeof (char *));
be772100 JG	315	memcpy ((PTR)psymtab_include_list, (PTR)orig,
be772100 JG	316	includes_used * sizeof (char *));
7e258d18 PB	317	}
7e258d18 PB	318	continue;
aab77d5f	319
7e258d18 PB	320	case N_LSYM: /* Typedef or automatic variable. */
	321	case N_STSYM: /* Data seg var -- static */
	322	case N_LCSYM: /* BSS " */
2670f34d	323	case N_ROSYM: /* Read-only data seg var -- static. */
7e258d18 PB	324	case N_NBSTS: /* Gould nobase. */
7e258d18 PB	325	case N_NBLCS: /* symbols. */
4ae030b9 JK	326	case N_FUN:
	327	case N_GSYM: /* Global (extern) variable; can be
	328	data or bss (sigh FIXME). */
	329
	330	/* Following may probably be ignored; I'll leave them here
	331	for now (until I do Pascal and Modula 2 extensions). */
	332
	333	case N_PC: /* I may or may not need this; I
	334	suspect not. */
	335	case N_M2C: /* I suspect that I can ignore this here. */
	336	case N_SCOPE: /* Same. */
7e258d18 PB	337
	338	SET_NAMESTRING();
	339
	340	p = (char *) strchr (namestring, ':');
4ae030b9 JK	341	if (!p)
4ae030b9 JK	342	continue; /* Not a debugging symbol. */
7e258d18	343
4ae030b9 JK	344
	345
	346	/* Main processing section for debugging symbols which
	347	the initial read through the symbol tables needs to worry
	348	about. If we reach this point, the symbol which we are
	349	considering is definitely one we are interested in.
	350	p must also contain the (valid) index into the namestring
	351	which indicates the debugging type symbol. */
7e258d18 PB	352
	353	switch (p[1])
	354	{
4ae030b9 JK	355	case 'S':
	356	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	357	ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
	358	VAR_NAMESPACE, LOC_STATIC,
	359	objfile->static_psymbols,
	360	CUR_SYMBOL_VALUE,
	361	psymtab_language, objfile);
	362	continue;
	363	case 'G':
	364	CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
	365	/* The addresses in these entries are reported to be
	366	wrong. See the code that reads 'G's for symtabs. */
	367	ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
	368	VAR_NAMESPACE, LOC_STATIC,
	369	objfile->global_psymbols,
	370	CUR_SYMBOL_VALUE,
	371	psymtab_language, objfile);
	372	continue;
	373
7e258d18	374	case 'T':
bcbf9559	375	if (p != namestring) /* a name is there, not just :T... */
7e258d18	376	{
7e258d18	377	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
bcbf9559	378	STRUCT_NAMESPACE, LOC_TYPEDEF,
2e4964ad FF	379	objfile->static_psymbols,
	380	CUR_SYMBOL_VALUE,
	381	psymtab_language, objfile);
bcbf9559 JG	382	if (p[2] == 't')
	383	{
	384	/* Also a typedef with the same name. */
	385	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
	386	VAR_NAMESPACE, LOC_TYPEDEF,
2e4964ad FF	387	objfile->static_psymbols,
	388	CUR_SYMBOL_VALUE, psymtab_language,
	389	objfile);
bcbf9559 JG	390	p += 1;
bcbf9559 JG	391	}
7e258d18 PB	392	}
	393	goto check_enum;
	394	case 't':
bcbf9559 JG	395	if (p != namestring) /* a name is there, not just :T... */
	396	{
	397	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
	398	VAR_NAMESPACE, LOC_TYPEDEF,
2e4964ad FF	399	objfile->static_psymbols,
	400	CUR_SYMBOL_VALUE,
	401	psymtab_language, objfile);
bcbf9559	402	}
7e258d18	403	check_enum:
7e258d18 PB	404	/* If this is an enumerated type, we need to
	405	add all the enum constants to the partial symbol
	406	table. This does not cover enums without names, e.g.
	407	"enum {a, b} c;" in C, but fortunately those are
	408	rare. There is no way for GDB to find those from the
	409	enum type without spending too much time on it. Thus
4ae030b9 JK	410	to solve this problem, the compiler needs to put out the
4ae030b9 JK	411	enum in a nameless type. GCC2 does this. */
7e258d18 PB	412
	413	/* We are looking for something of the form
	414	<name> ":" ("t" \| "T") [<number> "="] "e"
	415	{<constant> ":" <value> ","} ";". */
	416
	417	/* Skip over the colon and the 't' or 'T'. */
	418	p += 2;
	419	/* This type may be given a number. Also, numbers can come
	420	in pairs like (0,26). Skip over it. */
	421	while ((p >= '0' && p <= '9')
	422	\|\| p == '(' \|\| p == ',' \|\| *p == ')'
	423	\|\| *p == '=')
	424	p++;
	425
	426	if (*p++ == 'e')
	427	{
	428	/* We have found an enumerated type. */
	429	/* According to comments in read_enum_type
	430	a comma could end it instead of a semicolon.
	431	I don't know where that happens.
	432	Accept either. */
	433	while (p && p != ';' && *p != ',')
	434	{
	435	char *q;
	436
	437	/* Check for and handle cretinous dbx symbol name
	438	continuation! */
	439	if (*p == '\\')
	440	p = next_symbol_text ();
	441
	442	/* Point to the character after the name
	443	of the enum constant. */
	444	for (q = p; q && q != ':'; q++)
	445	;
	446	/* Note that the value doesn't matter for
	447	enum constants in psymtabs, just in symtabs. */
	448	ADD_PSYMBOL_TO_LIST (p, q - p,
	449	VAR_NAMESPACE, LOC_CONST,
2e4964ad FF	450	objfile->static_psymbols, 0,
2e4964ad FF	451	psymtab_language, objfile);
7e258d18 PB	452	/* Point past the name. */
	453	p = q;
	454	/* Skip over the value. */
	455	while (p && p != ',')
	456	p++;
	457	/* Advance past the comma. */
	458	if (*p)
	459	p++;
	460	}
	461	}
7e258d18 PB	462	continue;
	463	case 'c':
	464	/* Constant, e.g. from "const" in Pascal. */
	465	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
	466	VAR_NAMESPACE, LOC_CONST,
2e4964ad FF	467	objfile->static_psymbols, CUR_SYMBOL_VALUE,
2e4964ad FF	468	psymtab_language, objfile);
7e258d18	469	continue;
7e258d18 PB	470
7e258d18 PB	471	case 'f':
9342ecb9 JG	472	#ifdef DBXREAD_ONLY
	473	/* Kludges for ELF/STABS with Sun ACC */
	474	last_function_name = namestring;
fef84cc4	475	if (pst && pst->textlow == 0)
9342ecb9 JG	476	pst->textlow = CUR_SYMBOL_VALUE;
	477	#if 0
	478	if (startup_file_end == 0)
	479	startup_file_end = CUR_SYMBOL_VALUE;
	480	#endif
	481	/* End kludge. */
	482	#endif /* DBXREAD_ONLY */
7e258d18 PB	483	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
7e258d18 PB	484	VAR_NAMESPACE, LOC_BLOCK,
2e4964ad FF	485	objfile->static_psymbols, CUR_SYMBOL_VALUE,
2e4964ad FF	486	psymtab_language, objfile);
7e258d18 PB	487	continue;
	488
	489	/* Global functions were ignored here, but now they
	490	are put into the global psymtab like one would expect.
65ce5df4	491	They're also in the minimal symbol table. */
7e258d18	492	case 'F':
9342ecb9 JG	493	#ifdef DBXREAD_ONLY
	494	/* Kludges for ELF/STABS with Sun ACC */
	495	last_function_name = namestring;
fef84cc4	496	if (pst && pst->textlow == 0)
9342ecb9 JG	497	pst->textlow = CUR_SYMBOL_VALUE;
	498	#if 0
	499	if (startup_file_end == 0)
	500	startup_file_end = CUR_SYMBOL_VALUE;
	501	#endif
	502	/* End kludge. */
	503	#endif /* DBXREAD_ONLY */
7e258d18 PB	504	ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
7e258d18 PB	505	VAR_NAMESPACE, LOC_BLOCK,
2e4964ad FF	506	objfile->global_psymbols, CUR_SYMBOL_VALUE,
2e4964ad FF	507	psymtab_language, objfile);
7e258d18 PB	508	continue;
	509
	510	/* Two things show up here (hopefully); static symbols of
	511	local scope (static used inside braces) or extensions
	512	of structure symbols. We can ignore both. */
	513	case 'V':
	514	case '(':
	515	case '0':
	516	case '1':
	517	case '2':
	518	case '3':
	519	case '4':
	520	case '5':
	521	case '6':
	522	case '7':
	523	case '8':
	524	case '9':
	525	continue;
	526
	527	default:
	528	/* Unexpected symbol. Ignore it; perhaps it is an extension
	529	that we don't know about.
	530
	531	Someone says sun cc puts out symbols like
	532	/foo/baz/maclib::/usr/local/bin/maclib,
	533	which would get here with a symbol type of ':'. */
65ce5df4	534	complain (&unknown_symchar_complaint, p[1]);
7e258d18 PB	535	continue;
	536	}
	537
7e258d18	538	case N_EXCL:
aab77d5f	539	#ifdef DBXREAD_ONLY
7e258d18 PB	540
	541	SET_NAMESTRING();
	542
	543	/* Find the corresponding bincl and mark that psymtab on the
	544	psymtab dependency list */
	545	{
	546	struct partial_symtab *needed_pst =
	547	find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE);
	548
	549	/* If this include file was defined earlier in this file,
	550	leave it alone. */
	551	if (needed_pst == pst) continue;
	552
	553	if (needed_pst)
	554	{
	555	int i;
	556	int found = 0;
	557
	558	for (i = 0; i < dependencies_used; i++)
	559	if (dependency_list[i] == needed_pst)
	560	{
	561	found = 1;
	562	break;
	563	}
	564
	565	/* If it's already in the list, skip the rest. */
	566	if (found) continue;
	567
	568	dependency_list[dependencies_used++] = needed_pst;
	569	if (dependencies_used >= dependencies_allocated)
	570	{
	571	struct partial_symtab **orig = dependency_list;
	572	dependency_list =
	573	(struct partial_symtab **)
	574	alloca ((dependencies_allocated *= 2)
	575	* sizeof (struct partial_symtab *));
be772100	576	memcpy ((PTR)dependency_list, (PTR)orig,
7e258d18 PB	577	(dependencies_used
	578	* sizeof (struct partial_symtab *)));
	579	#ifdef DEBUG_INFO
	580	fprintf (stderr, "Had to reallocate dependency list.\n");
	581	fprintf (stderr, "New dependencies allocated: %d\n",
	582	dependencies_allocated);
	583	#endif
	584	}
	585	}
	586	else
	587	error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
	588	symnum);
	589	}
aab77d5f	590	#endif /* DBXREAD_ONLY */
7e258d18	591	continue;
7e258d18 PB	592
	593	case N_RBRAC:
	594	#ifdef HANDLE_RBRAC
	595	HANDLE_RBRAC(CUR_SYMBOL_VALUE);
aab77d5f	596	continue;
7e258d18 PB	597	#endif
	598	case N_EINCL:
	599	case N_DSLINE:
	600	case N_BSLINE:
	601	case N_SSYM: /* Claim: Structure or union element.
	602	Hopefully, I can ignore this. */
	603	case N_ENTRY: /* Alternate entry point; can ignore. */
	604	case N_MAIN: /* Can definitely ignore this. */
	605	case N_CATCH: /* These are GNU C++ extensions */
	606	case N_EHDECL: /* that can safely be ignored here. */
	607	case N_LENG:
	608	case N_BCOMM:
	609	case N_ECOMM:
	610	case N_ECOML:
	611	case N_FNAME:
	612	case N_SLINE:
	613	case N_RSYM:
	614	case N_PSYM:
	615	case N_LBRAC:
	616	case N_NSYMS: /* Ultrix 4.0: symbol count */
	617	case N_DEFD: /* GNU Modula-2 */
9342ecb9	618
4c7c6bab	619	case N_OBJ: /* useless types from Solaris */
9342ecb9	620	case N_OPT:
4c7c6bab	621	case N_ENDM:
7e258d18 PB	622	/* These symbols aren't interesting; don't worry about them */
	623
	624	continue;
	625
	626	default:
7e258d18 PB	627	/* If we haven't found it yet, ignore it. It's probably some
7e258d18 PB	628	new type we don't know about yet. */
51b80b00 FF	629	complain (&unknown_symtype_complaint,
51b80b00 FF	630	local_hex_string (CUR_SYMBOL_TYPE));
7e258d18 PB	631	continue;
7e258d18 PB	632	}