gdb/partial-stab.h

   1 /* Shared code to pre-read a stab (dbx-style), when building a psymtab.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   3    1996, 1997, 1998, 1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* The following need to be defined:
  24    SET_NAMESTRING() --Set namestring to name of symbol.
  25    CUR_SYMBOL_TYPE --Type code of current symbol.
  26    CUR_SYMBOL_VALUE --Value field of current symbol.  May be adjusted here.
  27    namestring - variable pointing to the name of the stab.
  28    pst - the partial symbol table being built.
  29
  30    psymtab_include_list, includes_used, includes_allocated - list of include
  31    file names (N_SOL) seen so far.
  32    dependency_list, dependencies_used, dependencies_allocated - list of
  33    N_EXCL stabs seen so far.
  34
  35    END_PSYMTAB -- end a partial symbol table.
  36    START_PSYMTAB -- start a partial symbol table.
  37  */
  38
  39 /* End of macro definitions, now let's handle them symbols!  */
  40
  41 switch (CUR_SYMBOL_TYPE)
  42   {
  43     static struct complaint function_outside_compilation_unit = {
  44       "function `%s' appears to be defined outside of all compilation units", 0, 0
  45     };
  46     char *p;
  47     /*
  48      * Standard, external, non-debugger, symbols
  49      */
  50
  51   case N_TEXT | N_EXT:
  52   case N_NBTEXT | N_EXT:
  53     CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
  54     goto record_it;
  55
  56   case N_DATA | N_EXT:
  57   case N_NBDATA | N_EXT:
  58     CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
  59     goto record_it;
  60
  61   case N_BSS:
  62   case N_BSS | N_EXT:
  63   case N_NBBSS | N_EXT:
  64   case N_SETV | N_EXT:          /* FIXME, is this in BSS? */
  65     CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
  66     goto record_it;
  67
  68   case N_ABS | N_EXT:
  69   record_it:
  70 #ifdef DBXREAD_ONLY
  71     SET_NAMESTRING ();
  72
  73   bss_ext_symbol:
  74     record_minimal_symbol (namestring, CUR_SYMBOL_VALUE,
  75                            CUR_SYMBOL_TYPE, objfile);   /* Always */
  76 #endif /* DBXREAD_ONLY */
  77     continue;
  78
  79     /* Standard, local, non-debugger, symbols */
  80
  81   case N_NBTEXT:
  82
  83     /* We need to be able to deal with both N_FN or N_TEXT,
  84        because we have no way of knowing whether the sys-supplied ld
  85        or GNU ld was used to make the executable.  Sequents throw
  86        in another wrinkle -- they renumbered N_FN.  */
  87
  88   case N_FN:
  89   case N_FN_SEQ:
  90   case N_TEXT:
  91 #ifdef DBXREAD_ONLY
  92     CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
  93     SET_NAMESTRING ();
  94     if ((namestring[0] == '-' && namestring[1] == 'l')
  95         || (namestring[(nsl = strlen (namestring)) - 1] == 'o'
  96             && namestring[nsl - 2] == '.'))
  97       {
  98         if (objfile->ei.entry_point < CUR_SYMBOL_VALUE &&
  99             objfile->ei.entry_point >= last_o_file_start)
 100           {
 101             objfile->ei.entry_file_lowpc = last_o_file_start;
 102             objfile->ei.entry_file_highpc = CUR_SYMBOL_VALUE;
 103           }
 104         if (past_first_source_file && pst
 105         /* The gould NP1 uses low values for .o and -l symbols
 106            which are not the address.  */
 107             && CUR_SYMBOL_VALUE >= pst->textlow)
 108           {
 109             END_PSYMTAB (pst, psymtab_include_list, includes_used,
 110                          symnum * symbol_size,
 111                          CUR_SYMBOL_VALUE > pst->texthigh
 112                          ? CUR_SYMBOL_VALUE : pst->texthigh,
 113                        dependency_list, dependencies_used, textlow_not_set);
 114             pst = (struct partial_symtab *) 0;
 115             includes_used = 0;
 116             dependencies_used = 0;
 117           }
 118         else
 119           past_first_source_file = 1;
 120         last_o_file_start = CUR_SYMBOL_VALUE;
 121       }
 122     else
 123       goto record_it;
 124 #endif /* DBXREAD_ONLY */
 125     continue;
 126
 127   case N_DATA:
 128     CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
 129     goto record_it;
 130
 131   case N_UNDF | N_EXT:
 132 #ifdef DBXREAD_ONLY
 133     if (CUR_SYMBOL_VALUE != 0)
 134       {
 135         /* This is a "Fortran COMMON" symbol.  See if the target
 136            environment knows where it has been relocated to.  */
 137
 138         CORE_ADDR reladdr;
 139
 140         SET_NAMESTRING ();
 141         if (target_lookup_symbol (namestring, &reladdr))
 142           {
 143             continue;           /* Error in lookup; ignore symbol for now.  */
 144           }
 145         CUR_SYMBOL_TYPE ^= (N_BSS ^ N_UNDF);    /* Define it as a bss-symbol */
 146         CUR_SYMBOL_VALUE = reladdr;
 147         goto bss_ext_symbol;
 148       }
 149 #endif /* DBXREAD_ONLY */
 150     continue;                   /* Just undefined, not COMMON */
 151
 152   case N_UNDF:
 153 #ifdef DBXREAD_ONLY
 154     if (processing_acc_compilation && CUR_SYMBOL_STRX == 1)
 155       {
 156         /* Deal with relative offsets in the string table
 157            used in ELF+STAB under Solaris.  If we want to use the
 158            n_strx field, which contains the name of the file,
 159            we must adjust file_string_table_offset *before* calling
 160            SET_NAMESTRING().  */
 161         past_first_source_file = 1;
 162         file_string_table_offset = next_file_string_table_offset;
 163         next_file_string_table_offset =
 164           file_string_table_offset + CUR_SYMBOL_VALUE;
 165         if (next_file_string_table_offset < file_string_table_offset)
 166           error ("string table offset backs up at %d", symnum);
 167         /* FIXME -- replace error() with complaint.  */
 168         continue;
 169       }
 170 #endif /* DBXREAD_ONLY */
 171     continue;
 172
 173     /* Lots of symbol types we can just ignore.  */
 174
 175   case N_ABS:
 176   case N_NBDATA:
 177   case N_NBBSS:
 178     continue;
 179
 180     /* Keep going . . . */
 181
 182     /*
 183      * Special symbol types for GNU
 184      */
 185   case N_INDR:
 186   case N_INDR | N_EXT:
 187   case N_SETA:
 188   case N_SETA | N_EXT:
 189   case N_SETT:
 190   case N_SETT | N_EXT:
 191   case N_SETD:
 192   case N_SETD | N_EXT:
 193   case N_SETB:
 194   case N_SETB | N_EXT:
 195   case N_SETV:
 196     continue;
 197
 198     /*
 199      * Debugger symbols
 200      */
 201
 202   case N_SO:
 203     {
 204       unsigned long valu;
 205       static int prev_so_symnum = -10;
 206       static int first_so_symnum;
 207       char *p;
 208       int prev_textlow_not_set;
 209
 210       valu = CUR_SYMBOL_VALUE + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 211
 212       prev_textlow_not_set = textlow_not_set;
 213
 214 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 215       /* A zero value is probably an indication for the SunPRO 3.0
 216          compiler. end_psymtab explicitly tests for zero, so
 217          don't relocate it.  */
 218
 219       if (CUR_SYMBOL_VALUE == 0)
 220         {
 221           textlow_not_set = 1;
 222           valu = 0;
 223         }
 224       else
 225         textlow_not_set = 0;
 226 #else
 227       textlow_not_set = 0;
 228 #endif
 229       past_first_source_file = 1;
 230
 231       if (prev_so_symnum != symnum - 1)
 232         {                       /* Here if prev stab wasn't N_SO */
 233           first_so_symnum = symnum;
 234
 235           if (pst)
 236             {
 237               END_PSYMTAB (pst, psymtab_include_list, includes_used,
 238                            symnum * symbol_size,
 239                            valu > pst->texthigh ? valu : pst->texthigh,
 240                            dependency_list, dependencies_used,
 241                            prev_textlow_not_set);
 242               pst = (struct partial_symtab *) 0;
 243               includes_used = 0;
 244               dependencies_used = 0;
 245             }
 246         }
 247
 248       prev_so_symnum = symnum;
 249
 250       /* End the current partial symtab and start a new one */
 251
 252       SET_NAMESTRING ();
 253
 254       /* Null name means end of .o file.  Don't start a new one. */
 255       if (*namestring == '\000')
 256         continue;
 257
 258       /* Some compilers (including gcc) emit a pair of initial N_SOs.
 259          The first one is a directory name; the second the file name.
 260          If pst exists, is empty, and has a filename ending in '/',
 261          we assume the previous N_SO was a directory name. */
 262
 263       p = strrchr (namestring, '/');
 264       if (p && *(p + 1) == '\000')
 265         continue;               /* Simply ignore directory name SOs */
 266
 267       /* Some other compilers (C++ ones in particular) emit useless
 268          SOs for non-existant .c files.  We ignore all subsequent SOs that
 269          immediately follow the first.  */
 270
 271       if (!pst)
 272         pst = START_PSYMTAB (objfile,
 273                              namestring, valu,
 274                              first_so_symnum * symbol_size,
 275                              objfile->global_psymbols.next,
 276                              objfile->static_psymbols.next);
 277       continue;
 278     }
 279
 280   case N_BINCL:
 281     {
 282 #ifdef DBXREAD_ONLY
 283       enum language tmp_language;
 284       /* Add this bincl to the bincl_list for future EXCLs.  No
 285          need to save the string; it'll be around until
 286          read_dbx_symtab function returns */
 287
 288       SET_NAMESTRING ();
 289
 290       tmp_language = deduce_language_from_filename (namestring);
 291
 292       /* Only change the psymtab's language if we've learned
 293          something useful (eg. tmp_language is not language_unknown).
 294          In addition, to match what start_subfile does, never change
 295          from C++ to C.  */
 296       if (tmp_language != language_unknown
 297           && (tmp_language != language_c
 298               || psymtab_language != language_cplus))
 299         psymtab_language = tmp_language;
 300
 301       if (pst == NULL)
 302         {
 303           /* FIXME: we should not get here without a PST to work on.
 304              Attempt to recover.  */
 305           complain (&unclaimed_bincl_complaint, namestring, symnum);
 306           continue;
 307         }
 308       add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE);
 309
 310       /* Mark down an include file in the current psymtab */
 311
 312       goto record_include_file;
 313
 314 #else /* DBXREAD_ONLY */
 315       continue;
 316 #endif
 317     }
 318
 319   case N_SOL:
 320     {
 321       enum language tmp_language;
 322       /* Mark down an include file in the current psymtab */
 323
 324       SET_NAMESTRING ();
 325
 326       tmp_language = deduce_language_from_filename (namestring);
 327
 328       /* Only change the psymtab's language if we've learned
 329          something useful (eg. tmp_language is not language_unknown).
 330          In addition, to match what start_subfile does, never change
 331          from C++ to C.  */
 332       if (tmp_language != language_unknown
 333           && (tmp_language != language_c
 334               || psymtab_language != language_cplus))
 335         psymtab_language = tmp_language;
 336
 337       /* In C++, one may expect the same filename to come round many
 338          times, when code is coming alternately from the main file
 339          and from inline functions in other files. So I check to see
 340          if this is a file we've seen before -- either the main
 341          source file, or a previously included file.
 342
 343          This seems to be a lot of time to be spending on N_SOL, but
 344          things like "break c-exp.y:435" need to work (I
 345          suppose the psymtab_include_list could be hashed or put
 346          in a binary tree, if profiling shows this is a major hog).  */
 347       if (pst && STREQ (namestring, pst->filename))
 348         continue;
 349       {
 350         register int i;
 351         for (i = 0; i < includes_used; i++)
 352           if (STREQ (namestring, psymtab_include_list[i]))
 353             {
 354               i = -1;
 355               break;
 356             }
 357         if (i == -1)
 358           continue;
 359       }
 360
 361 #ifdef DBXREAD_ONLY
 362     record_include_file:
 363 #endif
 364
 365       psymtab_include_list[includes_used++] = namestring;
 366       if (includes_used >= includes_allocated)
 367         {
 368           char **orig = psymtab_include_list;
 369
 370           psymtab_include_list = (char **)
 371             alloca ((includes_allocated *= 2) *
 372                     sizeof (char *));
 373           memcpy ((PTR) psymtab_include_list, (PTR) orig,
 374                   includes_used * sizeof (char *));
 375         }
 376       continue;
 377     }
 378   case N_LSYM:                  /* Typedef or automatic variable. */
 379   case N_STSYM:         /* Data seg var -- static  */
 380   case N_LCSYM:         /* BSS      "  */
 381   case N_ROSYM:         /* Read-only data seg var -- static.  */
 382   case N_NBSTS:         /* Gould nobase.  */
 383   case N_NBLCS:         /* symbols.  */
 384   case N_FUN:
 385   case N_GSYM:                  /* Global (extern) variable; can be
 386                                    data or bss (sigh FIXME).  */
 387
 388     /* Following may probably be ignored; I'll leave them here
 389        for now (until I do Pascal and Modula 2 extensions).  */
 390
 391   case N_PC:                    /* I may or may not need this; I
 392                                    suspect not.  */
 393   case N_M2C:                   /* I suspect that I can ignore this here. */
 394   case N_SCOPE:         /* Same.   */
 395
 396     SET_NAMESTRING ();
 397
 398 #ifdef DBXREAD_ONLY
 399     /* See if this is an end of function stab.  */
 400     if (pst && CUR_SYMBOL_TYPE == N_FUN && *namestring == '\000')
 401       {
 402         unsigned long valu;
 403
 404         /* It's value is the size (in bytes) of the function for
 405            function relative stabs, or the address of the function's
 406            end for old style stabs.  */
 407         valu = CUR_SYMBOL_VALUE + last_function_start;
 408         if (pst->texthigh == 0 || valu > pst->texthigh)
 409           pst->texthigh = valu;
 410         break;
 411       }
 412 #endif
 413
 414     p = (char *) strchr (namestring, ':');
 415     if (!p)
 416       continue;                 /* Not a debugging symbol.   */
 417
 418
 419
 420     /* Main processing section for debugging symbols which
 421        the initial read through the symbol tables needs to worry
 422        about.  If we reach this point, the symbol which we are
 423        considering is definitely one we are interested in.
 424        p must also contain the (valid) index into the namestring
 425        which indicates the debugging type symbol.  */
 426
 427     switch (p[1])
 428       {
 429       case 'S':
 430         CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
 431 #ifdef STATIC_TRANSFORM_NAME
 432         namestring = STATIC_TRANSFORM_NAME (namestring);
 433 #endif
 434         add_psymbol_to_list (namestring, p - namestring,
 435                              VAR_NAMESPACE, LOC_STATIC,
 436                              &objfile->static_psymbols,
 437                              0, CUR_SYMBOL_VALUE,
 438                              psymtab_language, objfile);
 439         continue;
 440       case 'G':
 441         CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
 442         /* The addresses in these entries are reported to be
 443            wrong.  See the code that reads 'G's for symtabs. */
 444         add_psymbol_to_list (namestring, p - namestring,
 445                              VAR_NAMESPACE, LOC_STATIC,
 446                              &objfile->global_psymbols,
 447                              0, CUR_SYMBOL_VALUE,
 448                              psymtab_language, objfile);
 449         continue;
 450
 451       case 'T':
 452         /* When a 'T' entry is defining an anonymous enum, it
 453            may have a name which is the empty string, or a
 454            single space.  Since they're not really defining a
 455            symbol, those shouldn't go in the partial symbol
 456            table.  We do pick up the elements of such enums at
 457            'check_enum:', below.  */
 458         if (p >= namestring + 2
 459             || (p == namestring + 1
 460                 && namestring[0] != ' '))
 461           {
 462             add_psymbol_to_list (namestring, p - namestring,
 463                                  STRUCT_NAMESPACE, LOC_TYPEDEF,
 464                                  &objfile->static_psymbols,
 465                                  CUR_SYMBOL_VALUE, 0,
 466                                  psymtab_language, objfile);
 467             if (p[2] == 't')
 468               {
 469                 /* Also a typedef with the same name.  */
 470                 add_psymbol_to_list (namestring, p - namestring,
 471                                      VAR_NAMESPACE, LOC_TYPEDEF,
 472                                      &objfile->static_psymbols,
 473                                      CUR_SYMBOL_VALUE, 0,
 474                                      psymtab_language, objfile);
 475                 p += 1;
 476               }
 477             /* The semantics of C++ state that "struct foo { ... }"
 478                also defines a typedef for "foo".  Unfortuantely, cfront
 479                never makes the typedef when translating from C++ to C.
 480                We make the typedef here so that "ptype foo" works as
 481                expected for cfront translated code.  */
 482             else if (psymtab_language == language_cplus)
 483               {
 484                 /* Also a typedef with the same name.  */
 485                 add_psymbol_to_list (namestring, p - namestring,
 486                                      VAR_NAMESPACE, LOC_TYPEDEF,
 487                                      &objfile->static_psymbols,
 488                                      CUR_SYMBOL_VALUE, 0,
 489                                      psymtab_language, objfile);
 490               }
 491           }
 492         goto check_enum;
 493       case 't':
 494         if (p != namestring)    /* a name is there, not just :T... */
 495           {
 496             add_psymbol_to_list (namestring, p - namestring,
 497                                  VAR_NAMESPACE, LOC_TYPEDEF,
 498                                  &objfile->static_psymbols,
 499                                  CUR_SYMBOL_VALUE, 0,
 500                                  psymtab_language, objfile);
 501           }
 502       check_enum:
 503         /* If this is an enumerated type, we need to
 504            add all the enum constants to the partial symbol
 505            table.  This does not cover enums without names, e.g.
 506            "enum {a, b} c;" in C, but fortunately those are
 507            rare.  There is no way for GDB to find those from the
 508            enum type without spending too much time on it.  Thus
 509            to solve this problem, the compiler needs to put out the
 510            enum in a nameless type.  GCC2 does this.  */
 511
 512         /* We are looking for something of the form
 513            <name> ":" ("t" | "T") [<number> "="] "e"
 514            {<constant> ":" <value> ","} ";".  */
 515
 516         /* Skip over the colon and the 't' or 'T'.  */
 517         p += 2;
 518         /* This type may be given a number.  Also, numbers can come
 519            in pairs like (0,26).  Skip over it.  */
 520         while ((*p >= '0' && *p <= '9')
 521                || *p == '(' || *p == ',' || *p == ')'
 522                || *p == '=')
 523           p++;
 524
 525         if (*p++ == 'e')
 526           {
 527             /* The aix4 compiler emits extra crud before the members.  */
 528             if (*p == '-')
 529               {
 530                 /* Skip over the type (?).  */
 531                 while (*p != ':')
 532                   p++;
 533
 534                 /* Skip over the colon.  */
 535                 p++;
 536               }
 537
 538             /* We have found an enumerated type.  */
 539             /* According to comments in read_enum_type
 540                a comma could end it instead of a semicolon.
 541                I don't know where that happens.
 542                Accept either.  */
 543             while (*p && *p != ';' && *p != ',')
 544               {
 545                 char *q;
 546
 547                 /* Check for and handle cretinous dbx symbol name
 548                    continuation!  */
 549                 if (*p == '\\' || (*p == '?' && p[1] == '\0'))
 550                   p = next_symbol_text (objfile);
 551
 552                 /* Point to the character after the name
 553                    of the enum constant.  */
 554                 for (q = p; *q && *q != ':'; q++)
 555                   ;
 556                 /* Note that the value doesn't matter for
 557                    enum constants in psymtabs, just in symtabs.  */
 558                 add_psymbol_to_list (p, q - p,
 559                                      VAR_NAMESPACE, LOC_CONST,
 560                                      &objfile->static_psymbols, 0,
 561                                      0, psymtab_language, objfile);
 562                 /* Point past the name.  */
 563                 p = q;
 564                 /* Skip over the value.  */
 565                 while (*p && *p != ',')
 566                   p++;
 567                 /* Advance past the comma.  */
 568                 if (*p)
 569                   p++;
 570               }
 571           }
 572         continue;
 573       case 'c':
 574         /* Constant, e.g. from "const" in Pascal.  */
 575         add_psymbol_to_list (namestring, p - namestring,
 576                              VAR_NAMESPACE, LOC_CONST,
 577                              &objfile->static_psymbols, CUR_SYMBOL_VALUE,
 578                              0, psymtab_language, objfile);
 579         continue;
 580
 581       case 'f':
 582         if (! pst)
 583           {
 584             int name_len = p - namestring;
 585             char *name = xmalloc (name_len + 1);
 586             memcpy (name, namestring, name_len);
 587             name[name_len] = '\0';
 588             complain (&function_outside_compilation_unit, name);
 589           }
 590         CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 591 #ifdef DBXREAD_ONLY
 592         /* Kludges for ELF/STABS with Sun ACC */
 593         last_function_name = namestring;
 594 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 595         /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
 596            value for the bottom of the text seg in those cases. */
 597         if (pst && textlow_not_set)
 598           {
 599             pst->textlow =
 600               find_stab_function_addr (namestring, pst->filename, objfile);
 601             textlow_not_set = 0;
 602           }
 603 #endif
 604         /* End kludge.  */
 605
 606         /* Keep track of the start of the last function so we
 607            can handle end of function symbols.  */
 608         last_function_start = CUR_SYMBOL_VALUE;
 609
 610         /* In reordered executables this function may lie outside
 611            the bounds created by N_SO symbols.  If that's the case
 612            use the address of this function as the low bound for
 613            the partial symbol table.  */
 614         if (pst
 615             && (textlow_not_set
 616                 || (CUR_SYMBOL_VALUE < pst->textlow
 617                     && (CUR_SYMBOL_VALUE
 618                         != ANOFFSET (objfile->section_offsets,
 619                                      SECT_OFF_TEXT (objfile))))))
 620           {
 621             pst->textlow = CUR_SYMBOL_VALUE;
 622             textlow_not_set = 0;
 623           }
 624 #endif /* DBXREAD_ONLY */
 625         add_psymbol_to_list (namestring, p - namestring,
 626                              VAR_NAMESPACE, LOC_BLOCK,
 627                              &objfile->static_psymbols,
 628                              0, CUR_SYMBOL_VALUE,
 629                              psymtab_language, objfile);
 630         continue;
 631
 632         /* Global functions were ignored here, but now they
 633            are put into the global psymtab like one would expect.
 634            They're also in the minimal symbol table.  */
 635       case 'F':
 636         if (! pst)
 637           {
 638             int name_len = p - namestring;
 639             char *name = xmalloc (name_len + 1);
 640             memcpy (name, namestring, name_len);
 641             name[name_len] = '\0';
 642             complain (&function_outside_compilation_unit, name);
 643           }
 644         CUR_SYMBOL_VALUE += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 645 #ifdef DBXREAD_ONLY
 646         /* Kludges for ELF/STABS with Sun ACC */
 647         last_function_name = namestring;
 648 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 649         /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
 650            value for the bottom of the text seg in those cases. */
 651         if (CUR_SYMBOL_VALUE == ANOFFSET (objfile->section_offsets,
 652                                           SECT_OFF_TEXT (objfile)))
 653           CUR_SYMBOL_VALUE =
 654             find_stab_function_addr (namestring, pst->filename, objfile);
 655         if (pst && textlow_not_set)
 656           {
 657             pst->textlow = CUR_SYMBOL_VALUE;
 658             textlow_not_set = 0;
 659           }
 660 #endif
 661         /* End kludge.  */
 662
 663         /* Keep track of the start of the last function so we
 664            can handle end of function symbols.  */
 665         last_function_start = CUR_SYMBOL_VALUE;
 666
 667         /* In reordered executables this function may lie outside
 668            the bounds created by N_SO symbols.  If that's the case
 669            use the address of this function as the low bound for
 670            the partial symbol table.  */
 671         if (pst
 672             && (textlow_not_set
 673                 || (CUR_SYMBOL_VALUE < pst->textlow
 674                     && (CUR_SYMBOL_VALUE
 675                         != ANOFFSET (objfile->section_offsets,
 676                                      SECT_OFF_TEXT (objfile))))))
 677           {
 678             pst->textlow = CUR_SYMBOL_VALUE;
 679             textlow_not_set = 0;
 680           }
 681 #endif /* DBXREAD_ONLY */
 682         add_psymbol_to_list (namestring, p - namestring,
 683                              VAR_NAMESPACE, LOC_BLOCK,
 684                              &objfile->global_psymbols,
 685                              0, CUR_SYMBOL_VALUE,
 686                              psymtab_language, objfile);
 687         continue;
 688
 689         /* Two things show up here (hopefully); static symbols of
 690            local scope (static used inside braces) or extensions
 691            of structure symbols.  We can ignore both.  */
 692       case 'V':
 693       case '(':
 694       case '0':
 695       case '1':
 696       case '2':
 697       case '3':
 698       case '4':
 699       case '5':
 700       case '6':
 701       case '7':
 702       case '8':
 703       case '9':
 704       case '-':
 705       case '#':         /* for symbol identification (used in live ranges) */
 706         /* added to support cfront stabs strings */
 707       case 'Z':         /* for definition continuations */
 708       case 'P':         /* for prototypes */
 709         continue;
 710
 711       case ':':
 712         /* It is a C++ nested symbol.  We don't need to record it
 713            (I don't think); if we try to look up foo::bar::baz,
 714            then symbols for the symtab containing foo should get
 715            read in, I think.  */
 716         /* Someone says sun cc puts out symbols like
 717            /foo/baz/maclib::/usr/local/bin/maclib,
 718            which would get here with a symbol type of ':'.  */
 719         continue;
 720
 721       default:
 722         /* Unexpected symbol descriptor.  The second and subsequent stabs
 723            of a continued stab can show up here.  The question is
 724            whether they ever can mimic a normal stab--it would be
 725            nice if not, since we certainly don't want to spend the
 726            time searching to the end of every string looking for
 727            a backslash.  */
 728
 729         complain (&unknown_symchar_complaint, p[1]);
 730
 731         /* Ignore it; perhaps it is an extension that we don't
 732            know about.  */
 733         continue;
 734       }
 735
 736   case N_EXCL:
 737 #ifdef DBXREAD_ONLY
 738
 739     SET_NAMESTRING ();
 740
 741     /* Find the corresponding bincl and mark that psymtab on the
 742        psymtab dependency list */
 743     {
 744       struct partial_symtab *needed_pst =
 745       find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE);
 746
 747       /* If this include file was defined earlier in this file,
 748          leave it alone.  */
 749       if (needed_pst == pst)
 750         continue;
 751
 752       if (needed_pst)
 753         {
 754           int i;
 755           int found = 0;
 756
 757           for (i = 0; i < dependencies_used; i++)
 758             if (dependency_list[i] == needed_pst)
 759               {
 760                 found = 1;
 761                 break;
 762               }
 763
 764           /* If it's already in the list, skip the rest.  */
 765           if (found)
 766             continue;
 767
 768           dependency_list[dependencies_used++] = needed_pst;
 769           if (dependencies_used >= dependencies_allocated)
 770             {
 771               struct partial_symtab **orig = dependency_list;
 772               dependency_list =
 773                 (struct partial_symtab **)
 774                 alloca ((dependencies_allocated *= 2)
 775                         * sizeof (struct partial_symtab *));
 776               memcpy ((PTR) dependency_list, (PTR) orig,
 777                       (dependencies_used
 778                        * sizeof (struct partial_symtab *)));
 779 #ifdef DEBUG_INFO
 780               fprintf_unfiltered (gdb_stderr, "Had to reallocate dependency list.\n");
 781               fprintf_unfiltered (gdb_stderr, "New dependencies allocated: %d\n",
 782                                   dependencies_allocated);
 783 #endif
 784             }
 785         }
 786     }
 787 #endif /* DBXREAD_ONLY */
 788     continue;
 789
 790   case N_ENDM:
 791 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 792     /* Solaris 2 end of module, finish current partial symbol table.
 793        END_PSYMTAB will set pst->texthigh to the proper value, which
 794        is necessary if a module compiled without debugging info
 795        follows this module.  */
 796     if (pst)
 797       {
 798         END_PSYMTAB (pst, psymtab_include_list, includes_used,
 799                      symnum * symbol_size,
 800                      (CORE_ADDR) 0,
 801                      dependency_list, dependencies_used, textlow_not_set);
 802         pst = (struct partial_symtab *) 0;
 803         includes_used = 0;
 804         dependencies_used = 0;
 805       }
 806 #endif
 807     continue;
 808
 809   case N_RBRAC:
 810 #ifdef HANDLE_RBRAC
 811     HANDLE_RBRAC (CUR_SYMBOL_VALUE);
 812     continue;
 813 #endif
 814   case N_EINCL:
 815   case N_DSLINE:
 816   case N_BSLINE:
 817   case N_SSYM:                  /* Claim: Structure or union element.
 818                                    Hopefully, I can ignore this.  */
 819   case N_ENTRY:         /* Alternate entry point; can ignore. */
 820   case N_MAIN:                  /* Can definitely ignore this.   */
 821   case N_CATCH:         /* These are GNU C++ extensions */
 822   case N_EHDECL:                /* that can safely be ignored here. */
 823   case N_LENG:
 824   case N_BCOMM:
 825   case N_ECOMM:
 826   case N_ECOML:
 827   case N_FNAME:
 828   case N_SLINE:
 829   case N_RSYM:
 830   case N_PSYM:
 831   case N_LBRAC:
 832   case N_NSYMS:         /* Ultrix 4.0: symbol count */
 833   case N_DEFD:                  /* GNU Modula-2 */
 834   case N_ALIAS:         /* SunPro F77: alias name, ignore for now.  */
 835
 836   case N_OBJ:                   /* useless types from Solaris */
 837   case N_OPT:
 838     /* These symbols aren't interesting; don't worry about them */
 839
 840     continue;
 841
 842   default:
 843     /* If we haven't found it yet, ignore it.  It's probably some
 844        new type we don't know about yet.  */
 845     complain (&unknown_symtype_complaint,
 846               local_hex_string (CUR_SYMBOL_TYPE));
 847     continue;
 848   }