Update year range in copyright notice of all files owned by the GDB project.
[external/binutils.git] / 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 const char *objfile_name (const struct objfile *objfile);
703
704 /* Return the name to print for OBJFILE in debugging messages.  */
705
706 extern const char *objfile_debug_name (const struct objfile *objfile);
707
708 /* Set the objfile's notion of the "main" name and language.  */
709
710 extern void set_objfile_main_name (struct objfile *objfile,
711                                    const char *name, enum language lang);
712
713 #endif /* !defined (OBJFILES_H) */