gdb/objfiles.h

   1 /* Definitions for symbol file management in GDB.
   2
   3    Copyright (C) 1992-2015 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (OBJFILES_H)
  21 #define OBJFILES_H
  22
  23 #include "gdb_obstack.h"        /* For obstack internals.  */
  24 #include "symfile.h"            /* For struct psymbol_allocation_list.  */
  25 #include "progspace.h"
  26 #include "registry.h"
  27 #include "gdb_bfd.h"
  28
  29 struct bcache;
  30 struct htab;
  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     /* The unrelocated value we should use for this objfile entry point.  */
 104     CORE_ADDR entry_point;
 105
 106     /* The index of the section in which the entry point appears.  */
 107     int the_bfd_section_index;
 108
 109     /* Set to 1 iff ENTRY_POINT contains a valid value.  */
 110     unsigned entry_point_p : 1;
 111
 112     /* Set to 1 iff this object was initialized.  */
 113     unsigned initialized : 1;
 114   };
 115
 116 /* Sections in an objfile.  The section offsets are stored in the
 117    OBJFILE.  */
 118
 119 struct obj_section
 120   {
 121     struct bfd_section *the_bfd_section;        /* BFD section pointer */
 122
 123     /* Objfile this section is part of.  */
 124     struct objfile *objfile;
 125
 126     /* True if this "overlay section" is mapped into an "overlay region".  */
 127     int ovly_mapped;
 128   };
 129
 130 /* Relocation offset applied to S.  */
 131 #define obj_section_offset(s)                                           \
 132   (((s)->objfile->section_offsets)->offsets[gdb_bfd_section_index ((s)->objfile->obfd, (s)->the_bfd_section)])
 133
 134 /* The memory address of section S (vma + offset).  */
 135 #define obj_section_addr(s)                                             \
 136   (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section)         \
 137    + obj_section_offset (s))
 138
 139 /* The one-passed-the-end memory address of section S
 140    (vma + size + offset).  */
 141 #define obj_section_endaddr(s)                                          \
 142   (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section)         \
 143    + bfd_get_section_size ((s)->the_bfd_section)                        \
 144    + obj_section_offset (s))
 145
 146 /* The "objstats" structure provides a place for gdb to record some
 147    interesting information about its internal state at runtime, on a
 148    per objfile basis, such as information about the number of symbols
 149    read, size of string table (if any), etc.  */
 150
 151 struct objstats
 152   {
 153     int n_psyms;                /* Number of partial symbols read */
 154     int n_syms;                 /* Number of full symbols read */
 155     int n_stabs;                /* Number of ".stabs" read (if applicable) */
 156     int n_types;                /* Number of types */
 157     int sz_strtab;              /* Size of stringtable, (if applicable) */
 158   };
 159
 160 #define OBJSTAT(objfile, expr) (objfile -> stats.expr)
 161 #define OBJSTATS struct objstats stats
 162 extern void print_objfile_statistics (void);
 163 extern void print_symbol_bcache_statistics (void);
 164
 165 /* Number of entries in the minimal symbol hash table.  */
 166 #define MINIMAL_SYMBOL_HASH_SIZE 2039
 167
 168 /* Some objfile data is hung off the BFD.  This enables sharing of the
 169    data across all objfiles using the BFD.  The data is stored in an
 170    instance of this structure, and associated with the BFD using the
 171    registry system.  */
 172
 173 struct objfile_per_bfd_storage
 174 {
 175   /* The storage has an obstack of its own.  */
 176
 177   struct obstack storage_obstack;
 178
 179   /* Byte cache for file names.  */
 180
 181   struct bcache *filename_cache;
 182
 183   /* Byte cache for macros.  */
 184   struct bcache *macro_cache;
 185
 186   /* The gdbarch associated with the BFD.  Note that this gdbarch is
 187      determined solely from BFD information, without looking at target
 188      information.  The gdbarch determined from a running target may
 189      differ from this e.g. with respect to register types and names.  */
 190
 191   struct gdbarch *gdbarch;
 192
 193   /* Hash table for mapping symbol names to demangled names.  Each
 194      entry in the hash table is actually two consecutive strings,
 195      both null-terminated; the first one is a mangled or linkage
 196      name, and the second is the demangled name or just a zero byte
 197      if the name doesn't demangle.  */
 198   struct htab *demangled_names_hash;
 199
 200   /* The per-objfile information about the entry point, the scope (file/func)
 201      containing the entry point, and the scope of the user's main() func.  */
 202
 203   struct entry_info ei;
 204
 205   /* The name and language of any "main" found in this objfile.  The
 206      name can be NULL, which means that the information was not
 207      recorded.  */
 208
 209   const char *name_of_main;
 210   enum language language_of_main;
 211
 212   /* Each file contains a pointer to an array of minimal symbols for all
 213      global symbols that are defined within the file.  The array is
 214      terminated by a "null symbol", one that has a NULL pointer for the
 215      name and a zero value for the address.  This makes it easy to walk
 216      through the array when passed a pointer to somewhere in the middle
 217      of it.  There is also a count of the number of symbols, which does
 218      not include the terminating null symbol.  The array itself, as well
 219      as all the data that it points to, should be allocated on the
 220      objfile_obstack for this file.  */
 221
 222   struct minimal_symbol *msymbols;
 223   int minimal_symbol_count;
 224
 225   /* The number of minimal symbols read, before any minimal symbol
 226      de-duplication is applied.  Note in particular that this has only
 227      a passing relationship with the actual size of the table above;
 228      use minimal_symbol_count if you need the true size.  */
 229   int n_minsyms;
 230
 231   /* This is true if minimal symbols have already been read.  Symbol
 232      readers can use this to bypass minimal symbol reading.  Also, the
 233      minimal symbol table management code in minsyms.c uses this to
 234      suppress new minimal symbols.  You might think that MSYMBOLS or
 235      MINIMAL_SYMBOL_COUNT could be used for this, but it is possible
 236      for multiple readers to install minimal symbols into a given
 237      per-BFD.  */
 238
 239   unsigned int minsyms_read : 1;
 240
 241   /* This is a hash table used to index the minimal symbols by name.  */
 242
 243   struct minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE];
 244
 245   /* This hash table is used to index the minimal symbols by their
 246      demangled names.  */
 247
 248   struct minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE];
 249 };
 250
 251 /* Master structure for keeping track of each file from which
 252    gdb reads symbols.  There are several ways these get allocated: 1.
 253    The main symbol file, symfile_objfile, set by the symbol-file command,
 254    2.  Additional symbol files added by the add-symbol-file command,
 255    3.  Shared library objfiles, added by ADD_SOLIB,  4.  symbol files
 256    for modules that were loaded when GDB attached to a remote system
 257    (see remote-vx.c).  */
 258
 259 struct objfile
 260   {
 261
 262     /* All struct objfile's are chained together by their next pointers.
 263        The program space field "objfiles"  (frequently referenced via
 264        the macro "object_files") points to the first link in this
 265        chain.  */
 266
 267     struct objfile *next;
 268
 269     /* The object file's original name as specified by the user,
 270        made absolute, and tilde-expanded.  However, it is not canonicalized
 271        (i.e., it has not been passed through gdb_realpath).
 272        This pointer is never NULL.  This does not have to be freed; it is
 273        guaranteed to have a lifetime at least as long as the objfile.  */
 274
 275     char *original_name;
 276
 277     CORE_ADDR addr_low;
 278
 279     /* Some flag bits for this objfile.
 280        The values are defined by OBJF_*.  */
 281
 282     unsigned short flags;
 283
 284     /* The program space associated with this objfile.  */
 285
 286     struct program_space *pspace;
 287
 288     /* List of compunits.
 289        These are used to do symbol lookups and file/line-number lookups.  */
 290
 291     struct compunit_symtab *compunit_symtabs;
 292
 293     /* Each objfile points to a linked list of partial symtabs derived from
 294        this file, one partial symtab structure for each compilation unit
 295        (source file).  */
 296
 297     struct partial_symtab *psymtabs;
 298
 299     /* Map addresses to the entries of PSYMTABS.  It would be more efficient to
 300        have a map per the whole process but ADDRMAP cannot selectively remove
 301        its items during FREE_OBJFILE.  This mapping is already present even for
 302        PARTIAL_SYMTABs which still have no corresponding full SYMTABs read.  */
 303
 304     struct addrmap *psymtabs_addrmap;
 305
 306     /* List of freed partial symtabs, available for re-use.  */
 307
 308     struct partial_symtab *free_psymtabs;
 309
 310     /* The object file's BFD.  Can be null if the objfile contains only
 311        minimal symbols, e.g. the run time common symbols for SunOS4.  */
 312
 313     bfd *obfd;
 314
 315     /* The per-BFD data.  Note that this is treated specially if OBFD
 316        is NULL.  */
 317
 318     struct objfile_per_bfd_storage *per_bfd;
 319
 320     /* The modification timestamp of the object file, as of the last time
 321        we read its symbols.  */
 322
 323     long mtime;
 324
 325     /* Obstack to hold objects that should be freed when we load a new symbol
 326        table from this object file.  */
 327
 328     struct obstack objfile_obstack;
 329
 330     /* A byte cache where we can stash arbitrary "chunks" of bytes that
 331        will not change.  */
 332
 333     struct psymbol_bcache *psymbol_cache; /* Byte cache for partial syms.  */
 334
 335     /* Vectors of all partial symbols read in from file.  The actual data
 336        is stored in the objfile_obstack.  */
 337
 338     struct psymbol_allocation_list global_psymbols;
 339     struct psymbol_allocation_list static_psymbols;
 340
 341     /* Structure which keeps track of functions that manipulate objfile's
 342        of the same type as this objfile.  I.e. the function to read partial
 343        symbols for example.  Note that this structure is in statically
 344        allocated memory, and is shared by all objfiles that use the
 345        object module reader of this type.  */
 346
 347     const struct sym_fns *sf;
 348
 349     /* Per objfile data-pointers required by other GDB modules.  */
 350
 351     REGISTRY_FIELDS;
 352
 353     /* Set of relocation offsets to apply to each section.
 354        The table is indexed by the_bfd_section->index, thus it is generally
 355        as large as the number of sections in the binary.
 356        The table is stored on the objfile_obstack.
 357
 358        These offsets indicate that all symbols (including partial and
 359        minimal symbols) which have been read have been relocated by this
 360        much.  Symbols which are yet to be read need to be relocated by it.  */
 361
 362     struct section_offsets *section_offsets;
 363     int num_sections;
 364
 365     /* Indexes in the section_offsets array.  These are initialized by the
 366        *_symfile_offsets() family of functions (som_symfile_offsets,
 367        xcoff_symfile_offsets, default_symfile_offsets).  In theory they
 368        should correspond to the section indexes used by bfd for the
 369        current objfile.  The exception to this for the time being is the
 370        SOM version.  */
 371
 372     int sect_index_text;
 373     int sect_index_data;
 374     int sect_index_bss;
 375     int sect_index_rodata;
 376
 377     /* These pointers are used to locate the section table, which
 378        among other things, is used to map pc addresses into sections.
 379        SECTIONS points to the first entry in the table, and
 380        SECTIONS_END points to the first location past the last entry
 381        in the table.  The table is stored on the objfile_obstack.  The
 382        sections are indexed by the BFD section index; but the
 383        structure data is only valid for certain sections
 384        (e.g. non-empty, SEC_ALLOC).  */
 385
 386     struct obj_section *sections, *sections_end;
 387
 388     /* GDB allows to have debug symbols in separate object files.  This is
 389        used by .gnu_debuglink, ELF build id note and Mach-O OSO.
 390        Although this is a tree structure, GDB only support one level
 391        (ie a separate debug for a separate debug is not supported).  Note that
 392        separate debug object are in the main chain and therefore will be
 393        visited by ALL_OBJFILES & co iterators.  Separate debug objfile always
 394        has a non-nul separate_debug_objfile_backlink.  */
 395
 396     /* Link to the first separate debug object, if any.  */
 397     struct objfile *separate_debug_objfile;
 398
 399     /* If this is a separate debug object, this is used as a link to the
 400        actual executable objfile.  */
 401     struct objfile *separate_debug_objfile_backlink;
 402
 403     /* If this is a separate debug object, this is a link to the next one
 404        for the same executable objfile.  */
 405     struct objfile *separate_debug_objfile_link;
 406
 407     /* Place to stash various statistics about this objfile.  */
 408     OBJSTATS;
 409
 410     /* A linked list of symbols created when reading template types or
 411        function templates.  These symbols are not stored in any symbol
 412        table, so we have to keep them here to relocate them
 413        properly.  */
 414     struct symbol *template_symbols;
 415   };
 416
 417 /* Defines for the objfile flag word.  */
 418
 419 /* When an object file has its functions reordered (currently Irix-5.2
 420    shared libraries exhibit this behaviour), we will need an expensive
 421    algorithm to locate a partial symtab or symtab via an address.
 422    To avoid this penalty for normal object files, we use this flag,
 423    whose setting is determined upon symbol table read in.  */
 424
 425 #define OBJF_REORDERED  (1 << 0)        /* Functions are reordered */
 426
 427 /* Distinguish between an objfile for a shared library and a "vanilla"
 428    objfile.  This may come from a target's implementation of the solib
 429    interface, from add-symbol-file, or any other mechanism that loads
 430    dynamic objects.  */
 431
 432 #define OBJF_SHARED     (1 << 1)        /* From a shared library */
 433
 434 /* User requested that this objfile be read in it's entirety.  */
 435
 436 #define OBJF_READNOW    (1 << 2)        /* Immediate full read */
 437
 438 /* This objfile was created because the user explicitly caused it
 439    (e.g., used the add-symbol-file command).  This bit offers a way
 440    for run_command to remove old objfile entries which are no longer
 441    valid (i.e., are associated with an old inferior), but to preserve
 442    ones that the user explicitly loaded via the add-symbol-file
 443    command.  */
 444
 445 #define OBJF_USERLOADED (1 << 3)        /* User loaded */
 446
 447 /* Set if we have tried to read partial symtabs for this objfile.
 448    This is used to allow lazy reading of partial symtabs.  */
 449
 450 #define OBJF_PSYMTABS_READ (1 << 4)
 451
 452 /* Set if this is the main symbol file
 453    (as opposed to symbol file for dynamically loaded code).  */
 454
 455 #define OBJF_MAINLINE (1 << 5)
 456
 457 /* ORIGINAL_NAME and OBFD->FILENAME correspond to text description unrelated to
 458    filesystem names.  It can be for example "<image in memory>".  */
 459
 460 #define OBJF_NOT_FILENAME (1 << 6)
 461
 462 /* Declarations for functions defined in objfiles.c */
 463
 464 extern struct objfile *allocate_objfile (bfd *, const char *name, int);
 465
 466 extern struct gdbarch *get_objfile_arch (const struct objfile *);
 467
 468 extern int entry_point_address_query (CORE_ADDR *entry_p);
 469
 470 extern CORE_ADDR entry_point_address (void);
 471
 472 extern void build_objfile_section_table (struct objfile *);
 473
 474 extern void terminate_minimal_symbol_table (struct objfile *objfile);
 475
 476 extern struct objfile *objfile_separate_debug_iterate (const struct objfile *,
 477                                                        const struct objfile *);
 478
 479 extern void put_objfile_before (struct objfile *, struct objfile *);
 480
 481 extern void add_separate_debug_objfile (struct objfile *, struct objfile *);
 482
 483 extern void unlink_objfile (struct objfile *);
 484
 485 extern void free_objfile (struct objfile *);
 486
 487 extern void free_objfile_separate_debug (struct objfile *);
 488
 489 extern struct cleanup *make_cleanup_free_objfile (struct objfile *);
 490
 491 extern void free_all_objfiles (void);
 492
 493 extern void objfile_relocate (struct objfile *, const struct section_offsets *);
 494 extern void objfile_rebase (struct objfile *, CORE_ADDR);
 495
 496 extern int objfile_has_partial_symbols (struct objfile *objfile);
 497
 498 extern int objfile_has_full_symbols (struct objfile *objfile);
 499
 500 extern int objfile_has_symbols (struct objfile *objfile);
 501
 502 extern int have_partial_symbols (void);
 503
 504 extern int have_full_symbols (void);
 505
 506 extern void objfile_set_sym_fns (struct objfile *objfile,
 507                                  const struct sym_fns *sf);
 508
 509 extern void objfiles_changed (void);
 510
 511 extern int is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile);
 512
 513 /* Return true if ADDRESS maps into one of the sections of a
 514    OBJF_SHARED objfile of PSPACE and false otherwise.  */
 515
 516 extern int shared_objfile_contains_address_p (struct program_space *pspace,
 517                                               CORE_ADDR address);
 518
 519 /* This operation deletes all objfile entries that represent solibs that
 520    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 521    command.  */
 522
 523 extern void objfile_purge_solibs (void);
 524
 525 /* Functions for dealing with the minimal symbol table, really a misc
 526    address<->symbol mapping for things we don't have debug symbols for.  */
 527
 528 extern int have_minimal_symbols (void);
 529
 530 extern struct obj_section *find_pc_section (CORE_ADDR pc);
 531
 532 /* Return non-zero if PC is in a section called NAME.  */
 533 extern int pc_in_section (CORE_ADDR, char *);
 534
 535 /* Return non-zero if PC is in a SVR4-style procedure linkage table
 536    section.  */
 537
 538 static inline int
 539 in_plt_section (CORE_ADDR pc)
 540 {
 541   return pc_in_section (pc, ".plt");
 542 }
 543
 544 /* Keep a registry of per-objfile data-pointers required by other GDB
 545    modules.  */
 546 DECLARE_REGISTRY(objfile);
 547
 548 /* In normal use, the section map will be rebuilt by find_pc_section
 549    if objfiles have been added, removed or relocated since it was last
 550    called.  Calling inhibit_section_map_updates will inhibit this
 551    behavior until resume_section_map_updates is called.  If you call
 552    inhibit_section_map_updates you must ensure that every call to
 553    find_pc_section in the inhibited region relates to a section that
 554    is already in the section map and has not since been removed or
 555    relocated.  */
 556 extern void inhibit_section_map_updates (struct program_space *pspace);
 557
 558 /* Resume automatically rebuilding the section map as required.  */
 559 extern void resume_section_map_updates (struct program_space *pspace);
 560
 561 /* Version of the above suitable for use as a cleanup.  */
 562 extern void resume_section_map_updates_cleanup (void *arg);
 563
 564 extern void default_iterate_over_objfiles_in_search_order
 565   (struct gdbarch *gdbarch,
 566    iterate_over_objfiles_in_search_order_cb_ftype *cb,
 567    void *cb_data, struct objfile *current_objfile);
 568 \f
 569
 570 /* Traverse all object files in the current program space.
 571    ALL_OBJFILES_SAFE works even if you delete the objfile during the
 572    traversal.  */
 573
 574 /* Traverse all object files in program space SS.  */
 575
 576 #define ALL_PSPACE_OBJFILES(ss, obj)                                    \
 577   for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next)
 578
 579 #define ALL_OBJFILES(obj)                           \
 580   for ((obj) = current_program_space->objfiles; \
 581        (obj) != NULL;                               \
 582        (obj) = (obj)->next)
 583
 584 #define ALL_OBJFILES_SAFE(obj,nxt)                      \
 585   for ((obj) = current_program_space->objfiles; \
 586        (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
 587        (obj) = (nxt))
 588
 589 /* Traverse all symtabs in one objfile.  */
 590
 591 #define ALL_OBJFILE_FILETABS(objfile, cu, s) \
 592   ALL_OBJFILE_COMPUNITS (objfile, cu) \
 593     ALL_COMPUNIT_FILETABS (cu, s)
 594
 595 /* Traverse all compunits in one objfile.  */
 596
 597 #define ALL_OBJFILE_COMPUNITS(objfile, cu) \
 598   for ((cu) = (objfile) -> compunit_symtabs; (cu) != NULL; (cu) = (cu) -> next)
 599
 600 /* Traverse all minimal symbols in one objfile.  */
 601
 602 #define ALL_OBJFILE_MSYMBOLS(objfile, m)        \
 603     for ((m) = (objfile)->per_bfd->msymbols;    \
 604          MSYMBOL_LINKAGE_NAME (m) != NULL;      \
 605          (m)++)
 606
 607 /* Traverse all symtabs in all objfiles in the current symbol
 608    space.  */
 609
 610 #define ALL_FILETABS(objfile, ps, s)            \
 611   ALL_OBJFILES (objfile)                        \
 612     ALL_OBJFILE_FILETABS (objfile, ps, s)
 613
 614 /* Traverse all compunits in all objfiles in the current program space.  */
 615
 616 #define ALL_COMPUNITS(objfile, cu)      \
 617   ALL_OBJFILES (objfile)                \
 618     ALL_OBJFILE_COMPUNITS (objfile, cu)
 619
 620 /* Traverse all minimal symbols in all objfiles in the current symbol
 621    space.  */
 622
 623 #define ALL_MSYMBOLS(objfile, m) \
 624   ALL_OBJFILES (objfile)         \
 625     ALL_OBJFILE_MSYMBOLS (objfile, m)
 626
 627 #define ALL_OBJFILE_OSECTIONS(objfile, osect)   \
 628   for (osect = objfile->sections; osect < objfile->sections_end; osect++) \
 629     if (osect->the_bfd_section == NULL)                                 \
 630       {                                                                 \
 631         /* Nothing.  */                                                 \
 632       }                                                                 \
 633     else
 634
 635 /* Traverse all obj_sections in all objfiles in the current program
 636    space.
 637
 638    Note that this detects a "break" in the inner loop, and exits
 639    immediately from the outer loop as well, thus, client code doesn't
 640    need to know that this is implemented with a double for.  The extra
 641    hair is to make sure that a "break;" stops the outer loop iterating
 642    as well, and both OBJFILE and OSECT are left unmodified:
 643
 644     - The outer loop learns about the inner loop's end condition, and
 645       stops iterating if it detects the inner loop didn't reach its
 646       end.  In other words, the outer loop keeps going only if the
 647       inner loop reached its end cleanly [(osect) ==
 648       (objfile)->sections_end].
 649
 650     - OSECT is initialized in the outer loop initialization
 651       expressions, such as if the inner loop has reached its end, so
 652       the check mentioned above succeeds the first time.
 653
 654     - The trick to not clearing OBJFILE on a "break;" is, in the outer
 655       loop's loop expression, advance OBJFILE, but iff the inner loop
 656       reached its end.  If not, there was a "break;", so leave OBJFILE
 657       as is; the outer loop's conditional will break immediately as
 658       well (as OSECT will be different from OBJFILE->sections_end).  */
 659
 660 #define ALL_OBJSECTIONS(objfile, osect)                                 \
 661   for ((objfile) = current_program_space->objfiles,                     \
 662          (objfile) != NULL ? ((osect) = (objfile)->sections_end) : 0;   \
 663        (objfile) != NULL                                                \
 664          && (osect) == (objfile)->sections_end;                         \
 665        ((osect) == (objfile)->sections_end                              \
 666         ? ((objfile) = (objfile)->next,                                 \
 667            (objfile) != NULL ? (osect) = (objfile)->sections_end : 0)   \
 668         : 0))                                                           \
 669     ALL_OBJFILE_OSECTIONS (objfile, osect)
 670
 671 #define SECT_OFF_DATA(objfile) \
 672      ((objfile->sect_index_data == -1) \
 673       ? (internal_error (__FILE__, __LINE__, \
 674                          _("sect_index_data not initialized")), -1)     \
 675       : objfile->sect_index_data)
 676
 677 #define SECT_OFF_RODATA(objfile) \
 678      ((objfile->sect_index_rodata == -1) \
 679       ? (internal_error (__FILE__, __LINE__, \
 680                          _("sect_index_rodata not initialized")), -1)   \
 681       : objfile->sect_index_rodata)
 682
 683 #define SECT_OFF_TEXT(objfile) \
 684      ((objfile->sect_index_text == -1) \
 685       ? (internal_error (__FILE__, __LINE__, \
 686                          _("sect_index_text not initialized")), -1)     \
 687       : objfile->sect_index_text)
 688
 689 /* Sometimes the .bss section is missing from the objfile, so we don't
 690    want to die here.  Let the users of SECT_OFF_BSS deal with an
 691    uninitialized section index.  */
 692 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
 693
 694 /* Answer whether there is more than one object file loaded.  */
 695
 696 #define MULTI_OBJFILE_P() (object_files && object_files->next)
 697
 698 /* Reset the per-BFD storage area on OBJ.  */
 699
 700 void set_objfile_per_bfd (struct objfile *obj);
 701
 702 /* Return canonical name for OBJFILE.
 703    This is the real file name if the file has been opened.
 704    Otherwise it is the original name supplied by the user.  */
 705
 706 const char *objfile_name (const struct objfile *objfile);
 707
 708 /* Return the (real) file name of OBJFILE if the file has been opened,
 709    otherwise return NULL.  */
 710
 711 const char *objfile_filename (const struct objfile *objfile);
 712
 713 /* Return the name to print for OBJFILE in debugging messages.  */
 714
 715 extern const char *objfile_debug_name (const struct objfile *objfile);
 716
 717 /* Set the objfile's notion of the "main" name and language.  */
 718
 719 extern void set_objfile_main_name (struct objfile *objfile,
 720                                    const char *name, enum language lang);
 721
 722 #endif /* !defined (OBJFILES_H) */