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
   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 #ifdef DBXREAD_ONLY
 244           /* Add this bincl to the bincl_list for future EXCLs.  No
 245              need to save the string; it'll be around until
 246              read_dbx_symtab function returns */
 247
 248           SET_NAMESTRING();
 249
 250           add_bincl_to_list (pst, namestring, CUR_SYMBOL_VALUE);
 251
 252           /* Mark down an include file in the current psymtab */
 253
 254           goto record_include_file;
 255
 256 #else /* DBXREAD_ONLY */
 257           continue;
 258 #endif
 259
 260         case N_SOL:
 261           /* Mark down an include file in the current psymtab */
 262
 263           SET_NAMESTRING();
 264
 265           /* In C++, one may expect the same filename to come round many
 266              times, when code is coming alternately from the main file
 267              and from inline functions in other files. So I check to see
 268              if this is a file we've seen before -- either the main
 269              source file, or a previously included file.
 270
 271              This seems to be a lot of time to be spending on N_SOL, but
 272              things like "break c-exp.y:435" need to work (I
 273              suppose the psymtab_include_list could be hashed or put
 274              in a binary tree, if profiling shows this is a major hog).  */
 275           if (pst && STREQ (namestring, pst->filename))
 276             continue;
 277           {
 278             register int i;
 279             for (i = 0; i < includes_used; i++)
 280               if (STREQ (namestring, psymtab_include_list[i]))
 281                 {
 282                   i = -1;
 283                   break;
 284                 }
 285             if (i == -1)
 286               continue;
 287           }
 288
 289 #ifdef DBXREAD_ONLY
 290         record_include_file:
 291 #endif
 292
 293           psymtab_include_list[includes_used++] = namestring;
 294           if (includes_used >= includes_allocated)
 295             {
 296               char **orig = psymtab_include_list;
 297
 298               psymtab_include_list = (char **)
 299                 alloca ((includes_allocated *= 2) *
 300                         sizeof (char *));
 301               memcpy ((PTR)psymtab_include_list, (PTR)orig,
 302                       includes_used * sizeof (char *));
 303             }
 304           continue;
 305
 306         case N_LSYM:            /* Typedef or automatic variable. */
 307         case N_STSYM:           /* Data seg var -- static  */
 308         case N_LCSYM:           /* BSS      "  */
 309         case N_ROSYM:           /* Read-only data seg var -- static.  */
 310         case N_NBSTS:           /* Gould nobase.  */
 311         case N_NBLCS:           /* symbols.  */
 312         case N_FUN:
 313         case N_GSYM:            /* Global (extern) variable; can be
 314                                    data or bss (sigh FIXME).  */
 315
 316         /* Following may probably be ignored; I'll leave them here
 317            for now (until I do Pascal and Modula 2 extensions).  */
 318
 319         case N_PC:              /* I may or may not need this; I
 320                                    suspect not.  */
 321         case N_M2C:             /* I suspect that I can ignore this here. */
 322         case N_SCOPE:           /* Same.   */
 323
 324           SET_NAMESTRING();
 325
 326           p = (char *) strchr (namestring, ':');
 327           if (!p)
 328             continue;           /* Not a debugging symbol.   */
 329
 330
 331
 332           /* Main processing section for debugging symbols which
 333              the initial read through the symbol tables needs to worry
 334              about.  If we reach this point, the symbol which we are
 335              considering is definitely one we are interested in.
 336              p must also contain the (valid) index into the namestring
 337              which indicates the debugging type symbol.  */
 338
 339           switch (p[1])
 340             {
 341             case 'S':
 342               CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
 343               ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
 344                                         VAR_NAMESPACE, LOC_STATIC,
 345                                         objfile->static_psymbols,
 346                                         CUR_SYMBOL_VALUE,
 347                                         psymtab_language, objfile);
 348               continue;
 349             case 'G':
 350               CUR_SYMBOL_VALUE += ANOFFSET (section_offsets, SECT_OFF_DATA);
 351               /* The addresses in these entries are reported to be
 352                  wrong.  See the code that reads 'G's for symtabs. */
 353               ADD_PSYMBOL_ADDR_TO_LIST (namestring, p - namestring,
 354                                         VAR_NAMESPACE, LOC_STATIC,
 355                                         objfile->global_psymbols,
 356                                         CUR_SYMBOL_VALUE,
 357                                         psymtab_language, objfile);
 358               continue;
 359
 360             case 'T':
 361               if (p != namestring)      /* a name is there, not just :T... */
 362                 {
 363                   ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 364                                        STRUCT_NAMESPACE, LOC_TYPEDEF,
 365                                        objfile->static_psymbols,
 366                                        CUR_SYMBOL_VALUE,
 367                                        psymtab_language, objfile);
 368                   if (p[2] == 't')
 369                     {
 370                       /* Also a typedef with the same name.  */
 371                       ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 372                                            VAR_NAMESPACE, LOC_TYPEDEF,
 373                                            objfile->static_psymbols,
 374                                            CUR_SYMBOL_VALUE, psymtab_language,
 375                                            objfile);
 376                       p += 1;
 377                     }
 378                 }
 379               goto check_enum;
 380             case 't':
 381               if (p != namestring)      /* a name is there, not just :T... */
 382                 {
 383                   ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 384                                        VAR_NAMESPACE, LOC_TYPEDEF,
 385                                        objfile->static_psymbols,
 386                                        CUR_SYMBOL_VALUE,
 387                                        psymtab_language, objfile);
 388                 }
 389             check_enum:
 390               /* If this is an enumerated type, we need to
 391                  add all the enum constants to the partial symbol
 392                  table.  This does not cover enums without names, e.g.
 393                  "enum {a, b} c;" in C, but fortunately those are
 394                  rare.  There is no way for GDB to find those from the
 395                  enum type without spending too much time on it.  Thus
 396                  to solve this problem, the compiler needs to put out the
 397                  enum in a nameless type.  GCC2 does this.  */
 398
 399               /* We are looking for something of the form
 400                  <name> ":" ("t" | "T") [<number> "="] "e"
 401                  {<constant> ":" <value> ","} ";".  */
 402
 403               /* Skip over the colon and the 't' or 'T'.  */
 404               p += 2;
 405               /* This type may be given a number.  Also, numbers can come
 406                  in pairs like (0,26).  Skip over it.  */
 407               while ((*p >= '0' && *p <= '9')
 408                      || *p == '(' || *p == ',' || *p == ')'
 409                      || *p == '=')
 410                 p++;
 411
 412               if (*p++ == 'e')
 413                 {
 414                   /* We have found an enumerated type.  */
 415                   /* According to comments in read_enum_type
 416                      a comma could end it instead of a semicolon.
 417                      I don't know where that happens.
 418                      Accept either.  */
 419                   while (*p && *p != ';' && *p != ',')
 420                     {
 421                       char *q;
 422
 423                       /* Check for and handle cretinous dbx symbol name
 424                          continuation!  */
 425                       if (*p == '\\')
 426                         p = next_symbol_text ();
 427
 428                       /* Point to the character after the name
 429                          of the enum constant.  */
 430                       for (q = p; *q && *q != ':'; q++)
 431                         ;
 432                       /* Note that the value doesn't matter for
 433                          enum constants in psymtabs, just in symtabs.  */
 434                       ADD_PSYMBOL_TO_LIST (p, q - p,
 435                                            VAR_NAMESPACE, LOC_CONST,
 436                                            objfile->static_psymbols, 0,
 437                                            psymtab_language, objfile);
 438                       /* Point past the name.  */
 439                       p = q;
 440                       /* Skip over the value.  */
 441                       while (*p && *p != ',')
 442                         p++;
 443                       /* Advance past the comma.  */
 444                       if (*p)
 445                         p++;
 446                     }
 447                 }
 448               continue;
 449             case 'c':
 450               /* Constant, e.g. from "const" in Pascal.  */
 451               ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 452                                    VAR_NAMESPACE, LOC_CONST,
 453                                    objfile->static_psymbols, CUR_SYMBOL_VALUE,
 454                                    psymtab_language, objfile);
 455               continue;
 456
 457             case 'f':
 458 #ifdef DBXREAD_ONLY
 459               /* Kludges for ELF/STABS with Sun ACC */
 460               last_function_name = namestring;
 461               if (pst && pst->textlow == 0)
 462                 pst->textlow = CUR_SYMBOL_VALUE;
 463 #if 0
 464               if (startup_file_end == 0)
 465                 startup_file_end = CUR_SYMBOL_VALUE;
 466 #endif
 467               /* End kludge.  */
 468 #endif /* DBXREAD_ONLY */
 469               ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 470                                    VAR_NAMESPACE, LOC_BLOCK,
 471                                    objfile->static_psymbols, CUR_SYMBOL_VALUE,
 472                                    psymtab_language, objfile);
 473               continue;
 474
 475               /* Global functions were ignored here, but now they
 476                  are put into the global psymtab like one would expect.
 477                  They're also in the minimal symbol table.  */
 478             case 'F':
 479 #ifdef DBXREAD_ONLY
 480               /* Kludges for ELF/STABS with Sun ACC */
 481               last_function_name = namestring;
 482               if (pst && pst->textlow == 0)
 483                 pst->textlow = CUR_SYMBOL_VALUE;
 484 #if 0
 485               if (startup_file_end == 0)
 486                 startup_file_end = CUR_SYMBOL_VALUE;
 487 #endif
 488               /* End kludge.  */
 489 #endif /* DBXREAD_ONLY */
 490               ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
 491                                    VAR_NAMESPACE, LOC_BLOCK,
 492                                    objfile->global_psymbols, CUR_SYMBOL_VALUE,
 493                                    psymtab_language, objfile);
 494               continue;
 495
 496               /* Two things show up here (hopefully); static symbols of
 497                  local scope (static used inside braces) or extensions
 498                  of structure symbols.  We can ignore both.  */
 499             case 'V':
 500             case '(':
 501             case '0':
 502             case '1':
 503             case '2':
 504             case '3':
 505             case '4':
 506             case '5':
 507             case '6':
 508             case '7':
 509             case '8':
 510             case '9':
 511               continue;
 512
 513             default:
 514               /* Unexpected symbol.  Ignore it; perhaps it is an extension
 515                  that we don't know about.
 516
 517                  Someone says sun cc puts out symbols like
 518                  /foo/baz/maclib::/usr/local/bin/maclib,
 519                  which would get here with a symbol type of ':'.  */
 520               complain (&unknown_symchar_complaint, p[1]);
 521               continue;
 522             }
 523
 524         case N_EXCL:
 525 #ifdef DBXREAD_ONLY
 526
 527           SET_NAMESTRING();
 528
 529           /* Find the corresponding bincl and mark that psymtab on the
 530              psymtab dependency list */
 531           {
 532             struct partial_symtab *needed_pst =
 533               find_corresponding_bincl_psymtab (namestring, CUR_SYMBOL_VALUE);
 534
 535             /* If this include file was defined earlier in this file,
 536                leave it alone.  */
 537             if (needed_pst == pst) continue;
 538
 539             if (needed_pst)
 540               {
 541                 int i;
 542                 int found = 0;
 543
 544                 for (i = 0; i < dependencies_used; i++)
 545                   if (dependency_list[i] == needed_pst)
 546                     {
 547                       found = 1;
 548                       break;
 549                     }
 550
 551                 /* If it's already in the list, skip the rest.  */
 552                 if (found) continue;
 553
 554                 dependency_list[dependencies_used++] = needed_pst;
 555                 if (dependencies_used >= dependencies_allocated)
 556                   {
 557                     struct partial_symtab **orig = dependency_list;
 558                     dependency_list =
 559                       (struct partial_symtab **)
 560                         alloca ((dependencies_allocated *= 2)
 561                                 * sizeof (struct partial_symtab *));
 562                     memcpy ((PTR)dependency_list, (PTR)orig,
 563                            (dependencies_used
 564                             * sizeof (struct partial_symtab *)));
 565 #ifdef DEBUG_INFO
 566                     fprintf (stderr, "Had to reallocate dependency list.\n");
 567                     fprintf (stderr, "New dependencies allocated: %d\n",
 568                              dependencies_allocated);
 569 #endif
 570                   }
 571               }
 572             else
 573               error ("Invalid symbol data: \"repeated\" header file not previously seen, at symtab pos %d.",
 574                      symnum);
 575           }
 576 #endif /* DBXREAD_ONLY */
 577           continue;
 578
 579         case N_RBRAC:
 580 #ifdef HANDLE_RBRAC
 581           HANDLE_RBRAC(CUR_SYMBOL_VALUE);
 582           continue;
 583 #endif
 584         case N_EINCL:
 585         case N_DSLINE:
 586         case N_BSLINE:
 587         case N_SSYM:            /* Claim: Structure or union element.
 588                                    Hopefully, I can ignore this.  */
 589         case N_ENTRY:           /* Alternate entry point; can ignore. */
 590         case N_MAIN:            /* Can definitely ignore this.   */
 591         case N_CATCH:           /* These are GNU C++ extensions */
 592         case N_EHDECL:          /* that can safely be ignored here. */
 593         case N_LENG:
 594         case N_BCOMM:
 595         case N_ECOMM:
 596         case N_ECOML:
 597         case N_FNAME:
 598         case N_SLINE:
 599         case N_RSYM:
 600         case N_PSYM:
 601         case N_LBRAC:
 602         case N_NSYMS:           /* Ultrix 4.0: symbol count */
 603         case N_DEFD:            /* GNU Modula-2 */
 604
 605         case N_OBJ:             /* useless types from Solaris */
 606         case N_OPT:
 607         case N_ENDM:
 608           /* These symbols aren't interesting; don't worry about them */
 609
 610           continue;
 611
 612         default:
 613           /* If we haven't found it yet, ignore it.  It's probably some
 614              new type we don't know about yet.  */
 615           complain (&unknown_symtype_complaint,
 616                     local_hex_string ((unsigned long) CUR_SYMBOL_TYPE));
 617           continue;
 618         }