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