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