gdb/objfiles.h

   1 /* Definitions for symbol file management in GDB.
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2007, 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #if !defined (OBJFILES_H)
  22 #define OBJFILES_H
  23
  24 #include "gdb_obstack.h"        /* For obstack internals.  */
  25 #include "symfile.h"            /* For struct psymbol_allocation_list */
  26 #include "progspace.h"
  27
  28 struct bcache;
  29 struct htab;
  30 struct symtab;
  31 struct objfile_data;
  32
  33 /* This structure maintains information on a per-objfile basis about the
  34    "entry point" of the objfile, and the scope within which the entry point
  35    exists.  It is possible that gdb will see more than one objfile that is
  36    executable, each with its own entry point.
  37
  38    For example, for dynamically linked executables in SVR4, the dynamic linker
  39    code is contained within the shared C library, which is actually executable
  40    and is run by the kernel first when an exec is done of a user executable
  41    that is dynamically linked.  The dynamic linker within the shared C library
  42    then maps in the various program segments in the user executable and jumps
  43    to the user executable's recorded entry point, as if the call had been made
  44    directly by the kernel.
  45
  46    The traditional gdb method of using this info was to use the
  47    recorded entry point to set the entry-file's lowpc and highpc from
  48    the debugging information, where these values are the starting
  49    address (inclusive) and ending address (exclusive) of the
  50    instruction space in the executable which correspond to the
  51    "startup file", I.E. crt0.o in most cases.  This file is assumed to
  52    be a startup file and frames with pc's inside it are treated as
  53    nonexistent.  Setting these variables is necessary so that
  54    backtraces do not fly off the bottom of the stack.
  55
  56    NOTE: cagney/2003-09-09: It turns out that this "traditional"
  57    method doesn't work.  Corinna writes: ``It turns out that the call
  58    to test for "inside entry file" destroys a meaningful backtrace
  59    under some conditions.  E. g. the backtrace tests in the asm-source
  60    testcase are broken for some targets.  In this test the functions
  61    are all implemented as part of one file and the testcase is not
  62    necessarily linked with a start file (depending on the target).
  63    What happens is, that the first frame is printed normaly and
  64    following frames are treated as being inside the enttry file then.
  65    This way, only the #0 frame is printed in the backtrace output.''
  66    Ref "frame.c" "NOTE: vinschen/2003-04-01".
  67
  68    Gdb also supports an alternate method to avoid running off the bottom
  69    of the stack.
  70
  71    There are two frames that are "special", the frame for the function
  72    containing the process entry point, since it has no predecessor frame,
  73    and the frame for the function containing the user code entry point
  74    (the main() function), since all the predecessor frames are for the
  75    process startup code.  Since we have no guarantee that the linked
  76    in startup modules have any debugging information that gdb can use,
  77    we need to avoid following frame pointers back into frames that might
  78    have been built in the startup code, as we might get hopelessly
  79    confused.  However, we almost always have debugging information
  80    available for main().
  81
  82    These variables are used to save the range of PC values which are
  83    valid within the main() function and within the function containing
  84    the process entry point.  If we always consider the frame for
  85    main() as the outermost frame when debugging user code, and the
  86    frame for the process entry point function as the outermost frame
  87    when debugging startup code, then all we have to do is have
  88    DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
  89    current PC is within the range specified by these variables.  In
  90    essence, we set "ceilings" in the frame chain beyond which we will
  91    not proceed when following the frame chain back up the stack.
  92
  93    A nice side effect is that we can still debug startup code without
  94    running off the end of the frame chain, assuming that we have usable
  95    debugging information in the startup modules, and if we choose to not
  96    use the block at main, or can't find it for some reason, everything
  97    still works as before.  And if we have no startup code debugging
  98    information but we do have usable information for main(), backtraces
  99    from user code don't go wandering off into the startup code.  */
 100
 101 struct entry_info
 102   {
 103
 104     /* The value we should use for this objects entry point.
 105        The illegal/unknown value needs to be something other than 0, ~0
 106        for instance, which is much less likely than 0. */
 107
 108     CORE_ADDR entry_point;
 109
 110 #define INVALID_ENTRY_POINT (~0)        /* ~0 will not be in any file, we hope.  */
 111
 112   };
 113
 114 /* Sections in an objfile.  The section offsets are stored in the
 115    OBJFILE.  */
 116
 117 struct obj_section
 118   {
 119     struct bfd_section *the_bfd_section;        /* BFD section pointer */
 120
 121     /* Objfile this section is part of.  */
 122     struct objfile *objfile;
 123
 124     /* True if this "overlay section" is mapped into an "overlay region". */
 125     int ovly_mapped;
 126   };
 127
 128 /* Relocation offset applied to S.  */
 129 #define obj_section_offset(s)                                           \
 130   (((s)->objfile->section_offsets)->offsets[(s)->the_bfd_section->index])
 131
 132 /* The memory address of section S (vma + offset).  */
 133 #define obj_section_addr(s)                                             \
 134   (bfd_get_section_vma ((s)->objfile->abfd, s->the_bfd_section)         \
 135    + obj_section_offset (s))
 136
 137 /* The one-passed-the-end memory address of section S
 138    (vma + size + offset).  */
 139 #define obj_section_endaddr(s)                                          \
 140   (bfd_get_section_vma ((s)->objfile->abfd, s->the_bfd_section)         \
 141    + bfd_get_section_size ((s)->the_bfd_section)                        \
 142    + obj_section_offset (s))
 143
 144 /* The "objstats" structure provides a place for gdb to record some
 145    interesting information about its internal state at runtime, on a
 146    per objfile basis, such as information about the number of symbols
 147    read, size of string table (if any), etc. */
 148
 149 struct objstats
 150   {
 151     int n_minsyms;              /* Number of minimal symbols read */
 152     int n_psyms;                /* Number of partial symbols read */
 153     int n_syms;                 /* Number of full symbols read */
 154     int n_stabs;                /* Number of ".stabs" read (if applicable) */
 155     int n_types;                /* Number of types */
 156     int sz_strtab;              /* Size of stringtable, (if applicable) */
 157   };
 158
 159 #define OBJSTAT(objfile, expr) (objfile -> stats.expr)
 160 #define OBJSTATS struct objstats stats
 161 extern void print_objfile_statistics (void);
 162 extern void print_symbol_bcache_statistics (void);
 163
 164 /* Number of entries in the minimal symbol hash table.  */
 165 #define MINIMAL_SYMBOL_HASH_SIZE 2039
 166
 167 /* Master structure for keeping track of each file from which
 168    gdb reads symbols.  There are several ways these get allocated: 1.
 169    The main symbol file, symfile_objfile, set by the symbol-file command,
 170    2.  Additional symbol files added by the add-symbol-file command,
 171    3.  Shared library objfiles, added by ADD_SOLIB,  4.  symbol files
 172    for modules that were loaded when GDB attached to a remote system
 173    (see remote-vx.c).  */
 174
 175 struct objfile
 176   {
 177
 178     /* All struct objfile's are chained together by their next pointers.
 179        The global variable "object_files" points to the first link in this
 180        chain.
 181
 182        FIXME:  There is a problem here if the objfile is reusable, and if
 183        multiple users are to be supported.  The problem is that the objfile
 184        list is linked through a member of the objfile struct itself, which
 185        is only valid for one gdb process.  The list implementation needs to
 186        be changed to something like:
 187
 188        struct list {struct list *next; struct objfile *objfile};
 189
 190        where the list structure is completely maintained separately within
 191        each gdb process. */
 192
 193     struct objfile *next;
 194
 195     /* The object file's name, tilde-expanded and absolute.
 196        Malloc'd; free it if you free this struct.  */
 197
 198     char *name;
 199
 200     /* Some flag bits for this objfile. */
 201
 202     unsigned short flags;
 203
 204     /* The program space associated with this objfile.  */
 205
 206     struct program_space *pspace;
 207
 208     /* Each objfile points to a linked list of symtabs derived from this file,
 209        one symtab structure for each compilation unit (source file).  Each link
 210        in the symtab list contains a backpointer to this objfile. */
 211
 212     struct symtab *symtabs;
 213
 214     /* Each objfile points to a linked list of partial symtabs derived from
 215        this file, one partial symtab structure for each compilation unit
 216        (source file). */
 217
 218     struct partial_symtab *psymtabs;
 219
 220     /* Map addresses to the entries of PSYMTABS.  It would be more efficient to
 221        have a map per the whole process but ADDRMAP cannot selectively remove
 222        its items during FREE_OBJFILE.  This mapping is already present even for
 223        PARTIAL_SYMTABs which still have no corresponding full SYMTABs read.  */
 224
 225     struct addrmap *psymtabs_addrmap;
 226
 227     /* List of freed partial symtabs, available for re-use */
 228
 229     struct partial_symtab *free_psymtabs;
 230
 231     /* The object file's BFD.  Can be null if the objfile contains only
 232        minimal symbols, e.g. the run time common symbols for SunOS4.  */
 233
 234     bfd *obfd;
 235
 236     /* The gdbarch associated with the BFD.  Note that this gdbarch is
 237        determined solely from BFD information, without looking at target
 238        information.  The gdbarch determined from a running target may
 239        differ from this e.g. with respect to register types and names.  */
 240
 241     struct gdbarch *gdbarch;
 242
 243     /* The modification timestamp of the object file, as of the last time
 244        we read its symbols.  */
 245
 246     long mtime;
 247
 248     /* Obstack to hold objects that should be freed when we load a new symbol
 249        table from this object file. */
 250
 251     struct obstack objfile_obstack;
 252
 253     /* A byte cache where we can stash arbitrary "chunks" of bytes that
 254        will not change. */
 255
 256     struct bcache *psymbol_cache;       /* Byte cache for partial syms */
 257     struct bcache *macro_cache;          /* Byte cache for macros */
 258
 259     /* Hash table for mapping symbol names to demangled names.  Each
 260        entry in the hash table is actually two consecutive strings,
 261        both null-terminated; the first one is a mangled or linkage
 262        name, and the second is the demangled name or just a zero byte
 263        if the name doesn't demangle.  */
 264     struct htab *demangled_names_hash;
 265
 266     /* Vectors of all partial symbols read in from file.  The actual data
 267        is stored in the objfile_obstack. */
 268
 269     struct psymbol_allocation_list global_psymbols;
 270     struct psymbol_allocation_list static_psymbols;
 271
 272     /* Each file contains a pointer to an array of minimal symbols for all
 273        global symbols that are defined within the file.  The array is terminated
 274        by a "null symbol", one that has a NULL pointer for the name and a zero
 275        value for the address.  This makes it easy to walk through the array
 276        when passed a pointer to somewhere in the middle of it.  There is also
 277        a count of the number of symbols, which does not include the terminating
 278        null symbol.  The array itself, as well as all the data that it points
 279        to, should be allocated on the objfile_obstack for this file. */
 280
 281     struct minimal_symbol *msymbols;
 282     int minimal_symbol_count;
 283
 284     /* This is a hash table used to index the minimal symbols by name.  */
 285
 286     struct minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE];
 287
 288     /* This hash table is used to index the minimal symbols by their
 289        demangled names.  */
 290
 291     struct minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE];
 292
 293     /* Structure which keeps track of functions that manipulate objfile's
 294        of the same type as this objfile.  I.E. the function to read partial
 295        symbols for example.  Note that this structure is in statically
 296        allocated memory, and is shared by all objfiles that use the
 297        object module reader of this type. */
 298
 299     struct sym_fns *sf;
 300
 301     /* The per-objfile information about the entry point, the scope (file/func)
 302        containing the entry point, and the scope of the user's main() func. */
 303
 304     struct entry_info ei;
 305
 306     /* Information about stabs.  Will be filled in with a dbx_symfile_info
 307        struct by those readers that need it. */
 308     /* NOTE: cagney/2004-10-23: This has been replaced by per-objfile
 309        data points implemented using "data" and "num_data" below.  For
 310        an example of how to use this replacement, see "objfile_data"
 311        in "mips-tdep.c".  */
 312
 313     struct dbx_symfile_info *deprecated_sym_stab_info;
 314
 315     /* Hook for information for use by the symbol reader (currently used
 316        for information shared by sym_init and sym_read).  It is
 317        typically a pointer to malloc'd memory.  The symbol reader's finish
 318        function is responsible for freeing the memory thusly allocated.  */
 319     /* NOTE: cagney/2004-10-23: This has been replaced by per-objfile
 320        data points implemented using "data" and "num_data" below.  For
 321        an example of how to use this replacement, see "objfile_data"
 322        in "mips-tdep.c".  */
 323
 324     void *deprecated_sym_private;
 325
 326     /* Per objfile data-pointers required by other GDB modules.  */
 327     /* FIXME: kettenis/20030711: This mechanism could replace
 328        deprecated_sym_stab_info and deprecated_sym_private
 329        entirely.  */
 330
 331     void **data;
 332     unsigned num_data;
 333
 334     /* Set of relocation offsets to apply to each section.
 335        Currently on the objfile_obstack (which makes no sense, but I'm
 336        not sure it's harming anything).
 337
 338        These offsets indicate that all symbols (including partial and
 339        minimal symbols) which have been read have been relocated by this
 340        much.  Symbols which are yet to be read need to be relocated by
 341        it.  */
 342
 343     struct section_offsets *section_offsets;
 344     int num_sections;
 345
 346     /* Indexes in the section_offsets array. These are initialized by the
 347        *_symfile_offsets() family of functions (som_symfile_offsets,
 348        xcoff_symfile_offsets, default_symfile_offsets). In theory they
 349        should correspond to the section indexes used by bfd for the
 350        current objfile. The exception to this for the time being is the
 351        SOM version. */
 352
 353     int sect_index_text;
 354     int sect_index_data;
 355     int sect_index_bss;
 356     int sect_index_rodata;
 357
 358     /* These pointers are used to locate the section table, which
 359        among other things, is used to map pc addresses into sections.
 360        SECTIONS points to the first entry in the table, and
 361        SECTIONS_END points to the first location past the last entry
 362        in the table.  Currently the table is stored on the
 363        objfile_obstack (which makes no sense, but I'm not sure it's
 364        harming anything).  */
 365
 366     struct obj_section
 367      *sections, *sections_end;
 368
 369     /* Link to objfile that contains the debug symbols for this one.
 370        One is loaded if this file has an debug link to an existing
 371        debug file with the right checksum */
 372     struct objfile *separate_debug_objfile;
 373
 374     /* If this is a separate debug object, this is used as a link to the
 375        actual executable objfile. */
 376     struct objfile *separate_debug_objfile_backlink;
 377
 378     /* Place to stash various statistics about this objfile */
 379       OBJSTATS;
 380
 381     /* A symtab that the C++ code uses to stash special symbols
 382        associated to namespaces.  */
 383
 384     /* FIXME/carlton-2003-06-27: Delete this in a few years once
 385        "possible namespace symbols" go away.  */
 386     struct symtab *cp_namespace_symtab;
 387   };
 388
 389 /* Defines for the objfile flag word. */
 390
 391 /* When an object file has its functions reordered (currently Irix-5.2
 392    shared libraries exhibit this behaviour), we will need an expensive
 393    algorithm to locate a partial symtab or symtab via an address.
 394    To avoid this penalty for normal object files, we use this flag,
 395    whose setting is determined upon symbol table read in.  */
 396
 397 #define OBJF_REORDERED  (1 << 0)        /* Functions are reordered */
 398
 399 /* Distinguish between an objfile for a shared library and a "vanilla"
 400    objfile. (If not set, the objfile may still actually be a solib.
 401    This can happen if the user created the objfile by using the
 402    add-symbol-file command.  GDB doesn't in that situation actually
 403    check whether the file is a solib.  Rather, the target's
 404    implementation of the solib interface is responsible for setting
 405    this flag when noticing solibs used by an inferior.)  */
 406
 407 #define OBJF_SHARED     (1 << 1)        /* From a shared library */
 408
 409 /* User requested that this objfile be read in it's entirety. */
 410
 411 #define OBJF_READNOW    (1 << 2)        /* Immediate full read */
 412
 413 /* This objfile was created because the user explicitly caused it
 414    (e.g., used the add-symbol-file command).  This bit offers a way
 415    for run_command to remove old objfile entries which are no longer
 416    valid (i.e., are associated with an old inferior), but to preserve
 417    ones that the user explicitly loaded via the add-symbol-file
 418    command. */
 419
 420 #define OBJF_USERLOADED (1 << 3)        /* User loaded */
 421
 422 /* The object file that contains the runtime common minimal symbols
 423    for SunOS4. Note that this objfile has no associated BFD.  */
 424
 425 extern struct objfile *rt_common_objfile;
 426
 427 /* When we need to allocate a new type, we need to know which objfile_obstack
 428    to allocate the type on, since there is one for each objfile.  The places
 429    where types are allocated are deeply buried in function call hierarchies
 430    which know nothing about objfiles, so rather than trying to pass a
 431    particular objfile down to them, we just do an end run around them and
 432    set current_objfile to be whatever objfile we expect to be using at the
 433    time types are being allocated.  For instance, when we start reading
 434    symbols for a particular objfile, we set current_objfile to point to that
 435    objfile, and when we are done, we set it back to NULL, to ensure that we
 436    never put a type someplace other than where we are expecting to put it.
 437    FIXME:  Maybe we should review the entire type handling system and
 438    see if there is a better way to avoid this problem. */
 439
 440 extern struct objfile *current_objfile;
 441
 442 /* Declarations for functions defined in objfiles.c */
 443
 444 extern struct objfile *allocate_objfile (bfd *, int);
 445
 446 extern struct gdbarch *get_objfile_arch (struct objfile *);
 447
 448 extern void init_entry_point_info (struct objfile *);
 449
 450 extern CORE_ADDR entry_point_address (void);
 451
 452 extern int build_objfile_section_table (struct objfile *);
 453
 454 extern void terminate_minimal_symbol_table (struct objfile *objfile);
 455
 456 extern void put_objfile_before (struct objfile *, struct objfile *);
 457
 458 extern void objfile_to_front (struct objfile *);
 459
 460 extern void unlink_objfile (struct objfile *);
 461
 462 extern void free_objfile (struct objfile *);
 463
 464 extern struct cleanup *make_cleanup_free_objfile (struct objfile *);
 465
 466 extern void free_all_objfiles (void);
 467
 468 extern void objfile_relocate (struct objfile *, struct section_offsets *);
 469
 470 extern int objfile_has_partial_symbols (struct objfile *objfile);
 471
 472 extern int objfile_has_full_symbols (struct objfile *objfile);
 473
 474 extern int objfile_has_symbols (struct objfile *objfile);
 475
 476 extern int have_partial_symbols (void);
 477
 478 extern int have_full_symbols (void);
 479
 480 extern void objfiles_changed (void);
 481
 482 /* This operation deletes all objfile entries that represent solibs that
 483    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 484    command.
 485  */
 486 extern void objfile_purge_solibs (void);
 487
 488 /* Functions for dealing with the minimal symbol table, really a misc
 489    address<->symbol mapping for things we don't have debug symbols for.  */
 490
 491 extern int have_minimal_symbols (void);
 492
 493 extern struct obj_section *find_pc_section (CORE_ADDR pc);
 494
 495 extern int in_plt_section (CORE_ADDR, char *);
 496
 497 /* Keep a registry of per-objfile data-pointers required by other GDB
 498    modules.  */
 499
 500 /* Allocate an entry in the per-objfile registry.  */
 501 extern const struct objfile_data *register_objfile_data (void);
 502
 503 /* Allocate an entry in the per-objfile registry.
 504    SAVE and FREE are called when clearing objfile data.
 505    First all registered SAVE functions are called.
 506    Then all registered FREE functions are called.
 507    Either or both of SAVE, FREE may be NULL.  */
 508 extern const struct objfile_data *register_objfile_data_with_cleanup
 509   (void (*save) (struct objfile *, void *),
 510    void (*free) (struct objfile *, void *));
 511
 512 extern void clear_objfile_data (struct objfile *objfile);
 513 extern void set_objfile_data (struct objfile *objfile,
 514                               const struct objfile_data *data, void *value);
 515 extern void *objfile_data (struct objfile *objfile,
 516                            const struct objfile_data *data);
 517
 518 extern struct bfd *gdb_bfd_ref (struct bfd *abfd);
 519 extern void gdb_bfd_unref (struct bfd *abfd);
 520 \f
 521
 522 /* Traverse all object files in the current program space.
 523    ALL_OBJFILES_SAFE works even if you delete the objfile during the
 524    traversal.  */
 525
 526 /* Traverse all object files in program space SS.  */
 527
 528 #define ALL_PSPACE_OBJFILES(ss, obj)                                    \
 529   for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next)        \
 530
 531 #define ALL_PSPACE_OBJFILES_SAFE(ss, obj, nxt)          \
 532   for ((obj) = ss->objfiles;                    \
 533        (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
 534        (obj) = (nxt))
 535
 536 #define ALL_OBJFILES(obj)                           \
 537   for ((obj) = current_program_space->objfiles; \
 538        (obj) != NULL;                               \
 539        (obj) = (obj)->next)
 540
 541 #define ALL_OBJFILES_SAFE(obj,nxt)                      \
 542   for ((obj) = current_program_space->objfiles; \
 543        (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
 544        (obj) = (nxt))
 545
 546 /* Traverse all symtabs in one objfile.  */
 547
 548 #define ALL_OBJFILE_SYMTABS(objfile, s) \
 549     for ((s) = (objfile) -> symtabs; (s) != NULL; (s) = (s) -> next)
 550
 551 /* Traverse all psymtabs in one objfile.  */
 552
 553 #define ALL_OBJFILE_PSYMTABS(objfile, p) \
 554     for ((p) = (objfile) -> psymtabs; (p) != NULL; (p) = (p) -> next)
 555
 556 /* Traverse all minimal symbols in one objfile.  */
 557
 558 #define ALL_OBJFILE_MSYMBOLS(objfile, m) \
 559     for ((m) = (objfile) -> msymbols; SYMBOL_LINKAGE_NAME(m) != NULL; (m)++)
 560
 561 /* Traverse all symtabs in all objfiles in the current symbol
 562    space.  */
 563
 564 #define ALL_SYMTABS(objfile, s) \
 565   ALL_OBJFILES (objfile)         \
 566     ALL_OBJFILE_SYMTABS (objfile, s)
 567
 568 #define ALL_PSPACE_SYMTABS(ss, objfile, s)              \
 569   ALL_PSPACE_OBJFILES (ss, objfile)                     \
 570     ALL_OBJFILE_SYMTABS (objfile, s)
 571
 572 /* Traverse all symtabs in all objfiles in the current program space,
 573    skipping included files (which share a blockvector with their
 574    primary symtab).  */
 575
 576 #define ALL_PRIMARY_SYMTABS(objfile, s) \
 577   ALL_OBJFILES (objfile)                \
 578     ALL_OBJFILE_SYMTABS (objfile, s)    \
 579       if ((s)->primary)
 580
 581 #define ALL_PSPACE_PRIMARY_SYMTABS(pspace, objfile, s)  \
 582   ALL_PSPACE_OBJFILES (ss, objfile)                     \
 583     ALL_OBJFILE_SYMTABS (objfile, s)                    \
 584       if ((s)->primary)
 585
 586 /* Traverse all psymtabs in all objfiles in the current symbol
 587    space.  */
 588
 589 #define ALL_PSYMTABS(objfile, p) \
 590   ALL_OBJFILES (objfile)         \
 591     ALL_OBJFILE_PSYMTABS (objfile, p)
 592
 593 #define ALL_PSPACE_PSYMTABS(ss, objfile, p)             \
 594   ALL_PSPACE_OBJFILES (ss, objfile)                     \
 595     ALL_OBJFILE_PSYMTABS (objfile, p)
 596
 597 /* Traverse all minimal symbols in all objfiles in the current symbol
 598    space.  */
 599
 600 #define ALL_MSYMBOLS(objfile, m) \
 601   ALL_OBJFILES (objfile)         \
 602     ALL_OBJFILE_MSYMBOLS (objfile, m)
 603
 604 #define ALL_OBJFILE_OSECTIONS(objfile, osect)   \
 605   for (osect = objfile->sections; osect < objfile->sections_end; osect++)
 606
 607 #define ALL_OBJSECTIONS(objfile, osect)         \
 608   ALL_OBJFILES (objfile)                        \
 609     ALL_OBJFILE_OSECTIONS (objfile, osect)
 610
 611 #define SECT_OFF_DATA(objfile) \
 612      ((objfile->sect_index_data == -1) \
 613       ? (internal_error (__FILE__, __LINE__, _("sect_index_data not initialized")), -1) \
 614       : objfile->sect_index_data)
 615
 616 #define SECT_OFF_RODATA(objfile) \
 617      ((objfile->sect_index_rodata == -1) \
 618       ? (internal_error (__FILE__, __LINE__, _("sect_index_rodata not initialized")), -1) \
 619       : objfile->sect_index_rodata)
 620
 621 #define SECT_OFF_TEXT(objfile) \
 622      ((objfile->sect_index_text == -1) \
 623       ? (internal_error (__FILE__, __LINE__, _("sect_index_text not initialized")), -1) \
 624       : objfile->sect_index_text)
 625
 626 /* Sometimes the .bss section is missing from the objfile, so we don't
 627    want to die here. Let the users of SECT_OFF_BSS deal with an
 628    uninitialized section index. */
 629 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
 630
 631 /* Answer whether there is more than one object file loaded.  */
 632
 633 #define MULTI_OBJFILE_P() (object_files && object_files->next)
 634
 635 #endif /* !defined (OBJFILES_H) */