gdb/objfiles.h

   1 /* Definitions for symbol file management in GDB.
   2
   3    Copyright (C) 1992-2019 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 "hashtab.h"
  24 #include "gdb_obstack.h"        /* For obstack internals.  */
  25 #include "objfile-flags.h"
  26 #include "symfile.h"
  27 #include "progspace.h"
  28 #include "registry.h"
  29 #include "gdb_bfd.h"
  30 #include <vector>
  31 #include "common/next-iterator.h"
  32
  33 struct bcache;
  34 struct htab;
  35 struct objfile_data;
  36 struct partial_symbol;
  37
  38 /* This structure maintains information on a per-objfile basis about the
  39    "entry point" of the objfile, and the scope within which the entry point
  40    exists.  It is possible that gdb will see more than one objfile that is
  41    executable, each with its own entry point.
  42
  43    For example, for dynamically linked executables in SVR4, the dynamic linker
  44    code is contained within the shared C library, which is actually executable
  45    and is run by the kernel first when an exec is done of a user executable
  46    that is dynamically linked.  The dynamic linker within the shared C library
  47    then maps in the various program segments in the user executable and jumps
  48    to the user executable's recorded entry point, as if the call had been made
  49    directly by the kernel.
  50
  51    The traditional gdb method of using this info was to use the
  52    recorded entry point to set the entry-file's lowpc and highpc from
  53    the debugging information, where these values are the starting
  54    address (inclusive) and ending address (exclusive) of the
  55    instruction space in the executable which correspond to the
  56    "startup file", i.e. crt0.o in most cases.  This file is assumed to
  57    be a startup file and frames with pc's inside it are treated as
  58    nonexistent.  Setting these variables is necessary so that
  59    backtraces do not fly off the bottom of the stack.
  60
  61    NOTE: cagney/2003-09-09: It turns out that this "traditional"
  62    method doesn't work.  Corinna writes: ``It turns out that the call
  63    to test for "inside entry file" destroys a meaningful backtrace
  64    under some conditions.  E.g. the backtrace tests in the asm-source
  65    testcase are broken for some targets.  In this test the functions
  66    are all implemented as part of one file and the testcase is not
  67    necessarily linked with a start file (depending on the target).
  68    What happens is, that the first frame is printed normaly and
  69    following frames are treated as being inside the enttry file then.
  70    This way, only the #0 frame is printed in the backtrace output.''
  71    Ref "frame.c" "NOTE: vinschen/2003-04-01".
  72
  73    Gdb also supports an alternate method to avoid running off the bottom
  74    of the stack.
  75
  76    There are two frames that are "special", the frame for the function
  77    containing the process entry point, since it has no predecessor frame,
  78    and the frame for the function containing the user code entry point
  79    (the main() function), since all the predecessor frames are for the
  80    process startup code.  Since we have no guarantee that the linked
  81    in startup modules have any debugging information that gdb can use,
  82    we need to avoid following frame pointers back into frames that might
  83    have been built in the startup code, as we might get hopelessly
  84    confused.  However, we almost always have debugging information
  85    available for main().
  86
  87    These variables are used to save the range of PC values which are
  88    valid within the main() function and within the function containing
  89    the process entry point.  If we always consider the frame for
  90    main() as the outermost frame when debugging user code, and the
  91    frame for the process entry point function as the outermost frame
  92    when debugging startup code, then all we have to do is have
  93    DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
  94    current PC is within the range specified by these variables.  In
  95    essence, we set "ceilings" in the frame chain beyond which we will
  96    not proceed when following the frame chain back up the stack.
  97
  98    A nice side effect is that we can still debug startup code without
  99    running off the end of the frame chain, assuming that we have usable
 100    debugging information in the startup modules, and if we choose to not
 101    use the block at main, or can't find it for some reason, everything
 102    still works as before.  And if we have no startup code debugging
 103    information but we do have usable information for main(), backtraces
 104    from user code don't go wandering off into the startup code.  */
 105
 106 struct entry_info
 107 {
 108   /* The unrelocated value we should use for this objfile entry point.  */
 109   CORE_ADDR entry_point;
 110
 111   /* The index of the section in which the entry point appears.  */
 112   int the_bfd_section_index;
 113
 114   /* Set to 1 iff ENTRY_POINT contains a valid value.  */
 115   unsigned entry_point_p : 1;
 116
 117   /* Set to 1 iff this object was initialized.  */
 118   unsigned initialized : 1;
 119 };
 120
 121 /* Sections in an objfile.  The section offsets are stored in the
 122    OBJFILE.  */
 123
 124 struct obj_section
 125 {
 126   /* BFD section pointer */
 127   struct bfd_section *the_bfd_section;
 128
 129   /* Objfile this section is part of.  */
 130   struct objfile *objfile;
 131
 132   /* True if this "overlay section" is mapped into an "overlay region".  */
 133   int ovly_mapped;
 134 };
 135
 136 /* Relocation offset applied to S.  */
 137 #define obj_section_offset(s)                                           \
 138   (((s)->objfile->section_offsets)->offsets[gdb_bfd_section_index ((s)->objfile->obfd, (s)->the_bfd_section)])
 139
 140 /* The memory address of section S (vma + offset).  */
 141 #define obj_section_addr(s)                                             \
 142   (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section)         \
 143    + obj_section_offset (s))
 144
 145 /* The one-passed-the-end memory address of section S
 146    (vma + size + offset).  */
 147 #define obj_section_endaddr(s)                                          \
 148   (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section)         \
 149    + bfd_get_section_size ((s)->the_bfd_section)                        \
 150    + obj_section_offset (s))
 151
 152 /* The "objstats" structure provides a place for gdb to record some
 153    interesting information about its internal state at runtime, on a
 154    per objfile basis, such as information about the number of symbols
 155    read, size of string table (if any), etc.  */
 156
 157 struct objstats
 158 {
 159   /* Number of partial symbols read.  */
 160   int n_psyms = 0;
 161
 162   /* Number of full symbols read.  */
 163   int n_syms = 0;
 164
 165   /* Number of ".stabs" read (if applicable).  */
 166   int n_stabs = 0;
 167
 168   /* Number of types.  */
 169   int n_types = 0;
 170
 171   /* Size of stringtable, (if applicable).  */
 172   int sz_strtab = 0;
 173 };
 174
 175 #define OBJSTAT(objfile, expr) (objfile -> stats.expr)
 176 #define OBJSTATS struct objstats stats
 177 extern void print_objfile_statistics (void);
 178 extern void print_symbol_bcache_statistics (void);
 179
 180 /* Number of entries in the minimal symbol hash table.  */
 181 #define MINIMAL_SYMBOL_HASH_SIZE 2039
 182
 183 /* Some objfile data is hung off the BFD.  This enables sharing of the
 184    data across all objfiles using the BFD.  The data is stored in an
 185    instance of this structure, and associated with the BFD using the
 186    registry system.  */
 187
 188 struct objfile_per_bfd_storage
 189 {
 190   objfile_per_bfd_storage ()
 191     : minsyms_read (false)
 192   {}
 193
 194   /* The storage has an obstack of its own.  */
 195
 196   auto_obstack storage_obstack;
 197
 198   /* Byte cache for file names.  */
 199
 200   bcache *filename_cache = NULL;
 201
 202   /* Byte cache for macros.  */
 203
 204   bcache *macro_cache = NULL;
 205
 206   /* The gdbarch associated with the BFD.  Note that this gdbarch is
 207      determined solely from BFD information, without looking at target
 208      information.  The gdbarch determined from a running target may
 209      differ from this e.g. with respect to register types and names.  */
 210
 211   struct gdbarch *gdbarch = NULL;
 212
 213   /* Hash table for mapping symbol names to demangled names.  Each
 214      entry in the hash table is actually two consecutive strings,
 215      both null-terminated; the first one is a mangled or linkage
 216      name, and the second is the demangled name or just a zero byte
 217      if the name doesn't demangle.  */
 218
 219   htab *demangled_names_hash = NULL;
 220
 221   /* The per-objfile information about the entry point, the scope (file/func)
 222      containing the entry point, and the scope of the user's main() func.  */
 223
 224   entry_info ei {};
 225
 226   /* The name and language of any "main" found in this objfile.  The
 227      name can be NULL, which means that the information was not
 228      recorded.  */
 229
 230   const char *name_of_main = NULL;
 231   enum language language_of_main = language_unknown;
 232
 233   /* Each file contains a pointer to an array of minimal symbols for all
 234      global symbols that are defined within the file.  The array is
 235      terminated by a "null symbol", one that has a NULL pointer for the
 236      name and a zero value for the address.  This makes it easy to walk
 237      through the array when passed a pointer to somewhere in the middle
 238      of it.  There is also a count of the number of symbols, which does
 239      not include the terminating null symbol.  The array itself, as well
 240      as all the data that it points to, should be allocated on the
 241      objfile_obstack for this file.  */
 242
 243   minimal_symbol *msymbols = NULL;
 244   int minimal_symbol_count = 0;
 245
 246   /* The number of minimal symbols read, before any minimal symbol
 247      de-duplication is applied.  Note in particular that this has only
 248      a passing relationship with the actual size of the table above;
 249      use minimal_symbol_count if you need the true size.  */
 250
 251   int n_minsyms = 0;
 252
 253   /* This is true if minimal symbols have already been read.  Symbol
 254      readers can use this to bypass minimal symbol reading.  Also, the
 255      minimal symbol table management code in minsyms.c uses this to
 256      suppress new minimal symbols.  You might think that MSYMBOLS or
 257      MINIMAL_SYMBOL_COUNT could be used for this, but it is possible
 258      for multiple readers to install minimal symbols into a given
 259      per-BFD.  */
 260
 261   bool minsyms_read : 1;
 262
 263   /* This is a hash table used to index the minimal symbols by name.  */
 264
 265   minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE] {};
 266
 267   /* This hash table is used to index the minimal symbols by their
 268      demangled names.  */
 269
 270   minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE] {};
 271
 272   /* All the different languages of symbols found in the demangled
 273      hash table.  A flat/vector-based map is more efficient than a map
 274      or hash table here, since this will only usually contain zero or
 275      one entries.  */
 276   std::vector<enum language> demangled_hash_languages;
 277 };
 278
 279 /* Master structure for keeping track of each file from which
 280    gdb reads symbols.  There are several ways these get allocated: 1.
 281    The main symbol file, symfile_objfile, set by the symbol-file command,
 282    2.  Additional symbol files added by the add-symbol-file command,
 283    3.  Shared library objfiles, added by ADD_SOLIB,  4.  symbol files
 284    for modules that were loaded when GDB attached to a remote system
 285    (see remote-vx.c).  */
 286
 287 struct objfile
 288 {
 289   objfile (bfd *, const char *, objfile_flags);
 290   ~objfile ();
 291
 292   DISABLE_COPY_AND_ASSIGN (objfile);
 293
 294   /* All struct objfile's are chained together by their next pointers.
 295      The program space field "objfiles"  (frequently referenced via
 296      the macro "object_files") points to the first link in this chain.  */
 297
 298   struct objfile *next = nullptr;
 299
 300   /* The object file's original name as specified by the user,
 301      made absolute, and tilde-expanded.  However, it is not canonicalized
 302      (i.e., it has not been passed through gdb_realpath).
 303      This pointer is never NULL.  This does not have to be freed; it is
 304      guaranteed to have a lifetime at least as long as the objfile.  */
 305
 306   char *original_name = nullptr;
 307
 308   CORE_ADDR addr_low = 0;
 309
 310   /* Some flag bits for this objfile.  */
 311
 312   objfile_flags flags;
 313
 314   /* The program space associated with this objfile.  */
 315
 316   struct program_space *pspace;
 317
 318   /* List of compunits.
 319      These are used to do symbol lookups and file/line-number lookups.  */
 320
 321   struct compunit_symtab *compunit_symtabs = nullptr;
 322
 323   /* Each objfile points to a linked list of partial symtabs derived from
 324      this file, one partial symtab structure for each compilation unit
 325      (source file).  */
 326
 327   struct partial_symtab *psymtabs = nullptr;
 328
 329   /* Map addresses to the entries of PSYMTABS.  It would be more efficient to
 330      have a map per the whole process but ADDRMAP cannot selectively remove
 331      its items during FREE_OBJFILE.  This mapping is already present even for
 332      PARTIAL_SYMTABs which still have no corresponding full SYMTABs read.  */
 333
 334   struct addrmap *psymtabs_addrmap = nullptr;
 335
 336   /* List of freed partial symtabs, available for re-use.  */
 337
 338   struct partial_symtab *free_psymtabs = nullptr;
 339
 340   /* The object file's BFD.  Can be null if the objfile contains only
 341      minimal symbols, e.g. the run time common symbols for SunOS4.  */
 342
 343   bfd *obfd;
 344
 345   /* The per-BFD data.  Note that this is treated specially if OBFD
 346      is NULL.  */
 347
 348   struct objfile_per_bfd_storage *per_bfd = nullptr;
 349
 350   /* The modification timestamp of the object file, as of the last time
 351      we read its symbols.  */
 352
 353   long mtime = 0;
 354
 355   /* Obstack to hold objects that should be freed when we load a new symbol
 356      table from this object file.  */
 357
 358   struct obstack objfile_obstack {};
 359
 360   /* A byte cache where we can stash arbitrary "chunks" of bytes that
 361      will not change.  */
 362
 363   struct psymbol_bcache *psymbol_cache;
 364
 365   /* Map symbol addresses to the partial symtab that defines the
 366      object at that address.  */
 367
 368   std::vector<std::pair<CORE_ADDR, partial_symtab *>> psymbol_map;
 369
 370   /* Vectors of all partial symbols read in from file.  The actual data
 371      is stored in the objfile_obstack.  */
 372
 373   std::vector<partial_symbol *> global_psymbols;
 374   std::vector<partial_symbol *> static_psymbols;
 375
 376   /* Structure which keeps track of functions that manipulate objfile's
 377      of the same type as this objfile.  I.e. the function to read partial
 378      symbols for example.  Note that this structure is in statically
 379      allocated memory, and is shared by all objfiles that use the
 380      object module reader of this type.  */
 381
 382   const struct sym_fns *sf = nullptr;
 383
 384   /* Per objfile data-pointers required by other GDB modules.  */
 385
 386   REGISTRY_FIELDS {};
 387
 388   /* Set of relocation offsets to apply to each section.
 389      The table is indexed by the_bfd_section->index, thus it is generally
 390      as large as the number of sections in the binary.
 391      The table is stored on the objfile_obstack.
 392
 393      These offsets indicate that all symbols (including partial and
 394      minimal symbols) which have been read have been relocated by this
 395      much.  Symbols which are yet to be read need to be relocated by it.  */
 396
 397   struct section_offsets *section_offsets = nullptr;
 398   int num_sections = 0;
 399
 400   /* Indexes in the section_offsets array.  These are initialized by the
 401      *_symfile_offsets() family of functions (som_symfile_offsets,
 402      xcoff_symfile_offsets, default_symfile_offsets).  In theory they
 403      should correspond to the section indexes used by bfd for the
 404      current objfile.  The exception to this for the time being is the
 405      SOM version.
 406
 407      These are initialized to -1 so that we can later detect if they
 408      are used w/o being properly assigned to.  */
 409
 410   int sect_index_text = -1;
 411   int sect_index_data = -1;
 412   int sect_index_bss = -1;
 413   int sect_index_rodata = -1;
 414
 415   /* These pointers are used to locate the section table, which
 416      among other things, is used to map pc addresses into sections.
 417      SECTIONS points to the first entry in the table, and
 418      SECTIONS_END points to the first location past the last entry
 419      in the table.  The table is stored on the objfile_obstack.  The
 420      sections are indexed by the BFD section index; but the
 421      structure data is only valid for certain sections
 422      (e.g. non-empty, SEC_ALLOC).  */
 423
 424   struct obj_section *sections = nullptr;
 425   struct obj_section *sections_end = nullptr;
 426
 427   /* GDB allows to have debug symbols in separate object files.  This is
 428      used by .gnu_debuglink, ELF build id note and Mach-O OSO.
 429      Although this is a tree structure, GDB only support one level
 430      (ie a separate debug for a separate debug is not supported).  Note that
 431      separate debug object are in the main chain and therefore will be
 432      visited by ALL_OBJFILES & co iterators.  Separate debug objfile always
 433      has a non-nul separate_debug_objfile_backlink.  */
 434
 435   /* Link to the first separate debug object, if any.  */
 436
 437   struct objfile *separate_debug_objfile = nullptr;
 438
 439   /* If this is a separate debug object, this is used as a link to the
 440      actual executable objfile.  */
 441
 442   struct objfile *separate_debug_objfile_backlink = nullptr;
 443
 444   /* If this is a separate debug object, this is a link to the next one
 445      for the same executable objfile.  */
 446
 447   struct objfile *separate_debug_objfile_link = nullptr;
 448
 449   /* Place to stash various statistics about this objfile.  */
 450
 451   OBJSTATS;
 452
 453   /* A linked list of symbols created when reading template types or
 454      function templates.  These symbols are not stored in any symbol
 455      table, so we have to keep them here to relocate them
 456      properly.  */
 457
 458   struct symbol *template_symbols = nullptr;
 459
 460   /* Associate a static link (struct dynamic_prop *) to all blocks (struct
 461      block *) that have one.
 462
 463      In the context of nested functions (available in Pascal, Ada and GNU C,
 464      for instance), a static link (as in DWARF's DW_AT_static_link attribute)
 465      for a function is a way to get the frame corresponding to the enclosing
 466      function.
 467
 468      Very few blocks have a static link, so it's more memory efficient to
 469      store these here rather than in struct block.  Static links must be
 470      allocated on the objfile's obstack.  */
 471   htab_t static_links {};
 472 };
 473
 474 /* Declarations for functions defined in objfiles.c */
 475
 476 extern struct gdbarch *get_objfile_arch (const struct objfile *);
 477
 478 extern int entry_point_address_query (CORE_ADDR *entry_p);
 479
 480 extern CORE_ADDR entry_point_address (void);
 481
 482 extern void build_objfile_section_table (struct objfile *);
 483
 484 extern struct objfile *objfile_separate_debug_iterate (const struct objfile *,
 485                                                        const struct objfile *);
 486
 487 extern void put_objfile_before (struct objfile *, struct objfile *);
 488
 489 extern void add_separate_debug_objfile (struct objfile *, struct objfile *);
 490
 491 extern void unlink_objfile (struct objfile *);
 492
 493 extern void free_objfile_separate_debug (struct objfile *);
 494
 495 extern void free_all_objfiles (void);
 496
 497 extern void objfile_relocate (struct objfile *, const struct section_offsets *);
 498 extern void objfile_rebase (struct objfile *, CORE_ADDR);
 499
 500 extern int objfile_has_partial_symbols (struct objfile *objfile);
 501
 502 extern int objfile_has_full_symbols (struct objfile *objfile);
 503
 504 extern int objfile_has_symbols (struct objfile *objfile);
 505
 506 extern int have_partial_symbols (void);
 507
 508 extern int have_full_symbols (void);
 509
 510 extern void objfile_set_sym_fns (struct objfile *objfile,
 511                                  const struct sym_fns *sf);
 512
 513 extern void objfiles_changed (void);
 514
 515 extern int is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile);
 516
 517 /* Return true if ADDRESS maps into one of the sections of a
 518    OBJF_SHARED objfile of PSPACE and false otherwise.  */
 519
 520 extern int shared_objfile_contains_address_p (struct program_space *pspace,
 521                                               CORE_ADDR address);
 522
 523 /* This operation deletes all objfile entries that represent solibs that
 524    weren't explicitly loaded by the user, via e.g., the add-symbol-file
 525    command.  */
 526
 527 extern void objfile_purge_solibs (void);
 528
 529 /* Functions for dealing with the minimal symbol table, really a misc
 530    address<->symbol mapping for things we don't have debug symbols for.  */
 531
 532 extern int have_minimal_symbols (void);
 533
 534 extern struct obj_section *find_pc_section (CORE_ADDR pc);
 535
 536 /* Return non-zero if PC is in a section called NAME.  */
 537 extern int pc_in_section (CORE_ADDR, const char *);
 538
 539 /* Return non-zero if PC is in a SVR4-style procedure linkage table
 540    section.  */
 541
 542 static inline int
 543 in_plt_section (CORE_ADDR pc)
 544 {
 545   return pc_in_section (pc, ".plt");
 546 }
 547
 548 /* Keep a registry of per-objfile data-pointers required by other GDB
 549    modules.  */
 550 DECLARE_REGISTRY(objfile);
 551
 552 /* In normal use, the section map will be rebuilt by find_pc_section
 553    if objfiles have been added, removed or relocated since it was last
 554    called.  Calling inhibit_section_map_updates will inhibit this
 555    behavior until the returned scoped_restore object is destroyed.  If
 556    you call inhibit_section_map_updates you must ensure that every
 557    call to find_pc_section in the inhibited region relates to a
 558    section that is already in the section map and has not since been
 559    removed or relocated.  */
 560 extern scoped_restore_tmpl<int> inhibit_section_map_updates
 561     (struct program_space *pspace);
 562
 563 extern void default_iterate_over_objfiles_in_search_order
 564   (struct gdbarch *gdbarch,
 565    iterate_over_objfiles_in_search_order_cb_ftype *cb,
 566    void *cb_data, struct objfile *current_objfile);
 567 \f
 568
 569 /* An iterarable object that can be used to iterate over all
 570    objfiles.  The basic use is in a foreach, like:
 571
 572    for (objfile *objf : all_objfiles (pspace)) { ... }  */
 573
 574 class all_objfiles : public next_adapter<struct objfile>
 575 {
 576 public:
 577
 578   explicit all_objfiles (struct program_space *pspace)
 579     : next_adapter<struct objfile> (pspace->objfiles)
 580   {
 581   }
 582 };
 583
 584
 585 /* Traverse all object files in the current program space.
 586    ALL_OBJFILES_SAFE works even if you delete the objfile during the
 587    traversal.  */
 588
 589 /* Traverse all object files in program space SS.  */
 590
 591 #define ALL_PSPACE_OBJFILES(ss, obj)                                    \
 592   for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next)
 593
 594 #define ALL_OBJFILES(obj)                           \
 595   for ((obj) = current_program_space->objfiles; \
 596        (obj) != NULL;                               \
 597        (obj) = (obj)->next)
 598
 599 #define ALL_OBJFILES_SAFE(obj,nxt)                      \
 600   for ((obj) = current_program_space->objfiles; \
 601        (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
 602        (obj) = (nxt))
 603
 604 /* Traverse all symtabs in one objfile.  */
 605
 606 #define ALL_OBJFILE_FILETABS(objfile, cu, s) \
 607   ALL_OBJFILE_COMPUNITS (objfile, cu) \
 608     ALL_COMPUNIT_FILETABS (cu, s)
 609
 610 /* Traverse all compunits in one objfile.  */
 611
 612 #define ALL_OBJFILE_COMPUNITS(objfile, cu) \
 613   for ((cu) = (objfile) -> compunit_symtabs; (cu) != NULL; (cu) = (cu) -> next)
 614
 615 /* Traverse all minimal symbols in one objfile.  */
 616
 617 #define ALL_OBJFILE_MSYMBOLS(objfile, m)        \
 618     for ((m) = (objfile)->per_bfd->msymbols;    \
 619          MSYMBOL_LINKAGE_NAME (m) != NULL;      \
 620          (m)++)
 621
 622 /* Traverse all symtabs in all objfiles in the current symbol
 623    space.  */
 624
 625 #define ALL_FILETABS(objfile, ps, s)            \
 626   ALL_OBJFILES (objfile)                        \
 627     ALL_OBJFILE_FILETABS (objfile, ps, s)
 628
 629 /* Traverse all compunits in all objfiles in the current program space.  */
 630
 631 #define ALL_COMPUNITS(objfile, cu)      \
 632   ALL_OBJFILES (objfile)                \
 633     ALL_OBJFILE_COMPUNITS (objfile, cu)
 634
 635 /* Traverse all minimal symbols in all objfiles in the current symbol
 636    space.  */
 637
 638 #define ALL_MSYMBOLS(objfile, m) \
 639   ALL_OBJFILES (objfile)         \
 640     ALL_OBJFILE_MSYMBOLS (objfile, m)
 641
 642 #define ALL_OBJFILE_OSECTIONS(objfile, osect)   \
 643   for (osect = objfile->sections; osect < objfile->sections_end; osect++) \
 644     if (osect->the_bfd_section == NULL)                                 \
 645       {                                                                 \
 646         /* Nothing.  */                                                 \
 647       }                                                                 \
 648     else
 649
 650 /* Traverse all obj_sections in all objfiles in the current program
 651    space.
 652
 653    Note that this detects a "break" in the inner loop, and exits
 654    immediately from the outer loop as well, thus, client code doesn't
 655    need to know that this is implemented with a double for.  The extra
 656    hair is to make sure that a "break;" stops the outer loop iterating
 657    as well, and both OBJFILE and OSECT are left unmodified:
 658
 659     - The outer loop learns about the inner loop's end condition, and
 660       stops iterating if it detects the inner loop didn't reach its
 661       end.  In other words, the outer loop keeps going only if the
 662       inner loop reached its end cleanly [(osect) ==
 663       (objfile)->sections_end].
 664
 665     - OSECT is initialized in the outer loop initialization
 666       expressions, such as if the inner loop has reached its end, so
 667       the check mentioned above succeeds the first time.
 668
 669     - The trick to not clearing OBJFILE on a "break;" is, in the outer
 670       loop's loop expression, advance OBJFILE, but iff the inner loop
 671       reached its end.  If not, there was a "break;", so leave OBJFILE
 672       as is; the outer loop's conditional will break immediately as
 673       well (as OSECT will be different from OBJFILE->sections_end).  */
 674
 675 #define ALL_OBJSECTIONS(objfile, osect)                                 \
 676   for ((objfile) = current_program_space->objfiles,                     \
 677          (objfile) != NULL ? ((osect) = (objfile)->sections_end) : 0;   \
 678        (objfile) != NULL                                                \
 679          && (osect) == (objfile)->sections_end;                         \
 680        ((osect) == (objfile)->sections_end                              \
 681         ? ((objfile) = (objfile)->next,                                 \
 682            (objfile) != NULL ? (osect) = (objfile)->sections_end : 0)   \
 683         : 0))                                                           \
 684     ALL_OBJFILE_OSECTIONS (objfile, osect)
 685
 686 #define SECT_OFF_DATA(objfile) \
 687      ((objfile->sect_index_data == -1) \
 688       ? (internal_error (__FILE__, __LINE__, \
 689                          _("sect_index_data not initialized")), -1)     \
 690       : objfile->sect_index_data)
 691
 692 #define SECT_OFF_RODATA(objfile) \
 693      ((objfile->sect_index_rodata == -1) \
 694       ? (internal_error (__FILE__, __LINE__, \
 695                          _("sect_index_rodata not initialized")), -1)   \
 696       : objfile->sect_index_rodata)
 697
 698 #define SECT_OFF_TEXT(objfile) \
 699      ((objfile->sect_index_text == -1) \
 700       ? (internal_error (__FILE__, __LINE__, \
 701                          _("sect_index_text not initialized")), -1)     \
 702       : objfile->sect_index_text)
 703
 704 /* Sometimes the .bss section is missing from the objfile, so we don't
 705    want to die here.  Let the users of SECT_OFF_BSS deal with an
 706    uninitialized section index.  */
 707 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
 708
 709 /* Answer whether there is more than one object file loaded.  */
 710
 711 #define MULTI_OBJFILE_P() (object_files && object_files->next)
 712
 713 /* Reset the per-BFD storage area on OBJ.  */
 714
 715 void set_objfile_per_bfd (struct objfile *obj);
 716
 717 /* Return canonical name for OBJFILE.
 718    This is the real file name if the file has been opened.
 719    Otherwise it is the original name supplied by the user.  */
 720
 721 const char *objfile_name (const struct objfile *objfile);
 722
 723 /* Return the (real) file name of OBJFILE if the file has been opened,
 724    otherwise return NULL.  */
 725
 726 const char *objfile_filename (const struct objfile *objfile);
 727
 728 /* Return the name to print for OBJFILE in debugging messages.  */
 729
 730 extern const char *objfile_debug_name (const struct objfile *objfile);
 731
 732 /* Return the name of the file format of OBJFILE if the file has been opened,
 733    otherwise return NULL.  */
 734
 735 const char *objfile_flavour_name (struct objfile *objfile);
 736
 737 /* Set the objfile's notion of the "main" name and language.  */
 738
 739 extern void set_objfile_main_name (struct objfile *objfile,
 740                                    const char *name, enum language lang);
 741
 742 extern void objfile_register_static_link
 743   (struct objfile *objfile,
 744    const struct block *block,
 745    const struct dynamic_prop *static_link);
 746
 747 extern const struct dynamic_prop *objfile_lookup_static_link
 748   (struct objfile *objfile, const struct block *block);
 749
 750 #endif /* !defined (OBJFILES_H) */