gdb/partial-stab.h

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