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