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