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