1 /* Definitions for symbol file management in GDB. 2 3 Copyright (C) 1992-2017 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" /* For struct psymbol_allocation_list. */ 27 #include "progspace.h" 28 #include "registry.h" 29 #include "gdb_bfd.h" 30 31 struct bcache; 32 struct htab; 33 struct objfile_data; 34 35 /* This structure maintains information on a per-objfile basis about the 36 "entry point" of the objfile, and the scope within which the entry point 37 exists. It is possible that gdb will see more than one objfile that is 38 executable, each with its own entry point. 39 40 For example, for dynamically linked executables in SVR4, the dynamic linker 41 code is contained within the shared C library, which is actually executable 42 and is run by the kernel first when an exec is done of a user executable 43 that is dynamically linked. The dynamic linker within the shared C library 44 then maps in the various program segments in the user executable and jumps 45 to the user executable's recorded entry point, as if the call had been made 46 directly by the kernel. 47 48 The traditional gdb method of using this info was to use the 49 recorded entry point to set the entry-file's lowpc and highpc from 50 the debugging information, where these values are the starting 51 address (inclusive) and ending address (exclusive) of the 52 instruction space in the executable which correspond to the 53 "startup file", i.e. crt0.o in most cases. This file is assumed to 54 be a startup file and frames with pc's inside it are treated as 55 nonexistent. Setting these variables is necessary so that 56 backtraces do not fly off the bottom of the stack. 57 58 NOTE: cagney/2003-09-09: It turns out that this "traditional" 59 method doesn't work. Corinna writes: ``It turns out that the call 60 to test for "inside entry file" destroys a meaningful backtrace 61 under some conditions. E.g. the backtrace tests in the asm-source 62 testcase are broken for some targets. In this test the functions 63 are all implemented as part of one file and the testcase is not 64 necessarily linked with a start file (depending on the target). 65 What happens is, that the first frame is printed normaly and 66 following frames are treated as being inside the enttry file then. 67 This way, only the #0 frame is printed in the backtrace output.'' 68 Ref "frame.c" "NOTE: vinschen/2003-04-01". 69 70 Gdb also supports an alternate method to avoid running off the bottom 71 of the stack. 72 73 There are two frames that are "special", the frame for the function 74 containing the process entry point, since it has no predecessor frame, 75 and the frame for the function containing the user code entry point 76 (the main() function), since all the predecessor frames are for the 77 process startup code. Since we have no guarantee that the linked 78 in startup modules have any debugging information that gdb can use, 79 we need to avoid following frame pointers back into frames that might 80 have been built in the startup code, as we might get hopelessly 81 confused. However, we almost always have debugging information 82 available for main(). 83 84 These variables are used to save the range of PC values which are 85 valid within the main() function and within the function containing 86 the process entry point. If we always consider the frame for 87 main() as the outermost frame when debugging user code, and the 88 frame for the process entry point function as the outermost frame 89 when debugging startup code, then all we have to do is have 90 DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's 91 current PC is within the range specified by these variables. In 92 essence, we set "ceilings" in the frame chain beyond which we will 93 not proceed when following the frame chain back up the stack. 94 95 A nice side effect is that we can still debug startup code without 96 running off the end of the frame chain, assuming that we have usable 97 debugging information in the startup modules, and if we choose to not 98 use the block at main, or can't find it for some reason, everything 99 still works as before. And if we have no startup code debugging 100 information but we do have usable information for main(), backtraces 101 from user code don't go wandering off into the startup code. */ 102 103 struct entry_info 104 { 105 /* The unrelocated value we should use for this objfile entry point. */ 106 CORE_ADDR entry_point; 107 108 /* The index of the section in which the entry point appears. */ 109 int the_bfd_section_index; 110 111 /* Set to 1 iff ENTRY_POINT contains a valid value. */ 112 unsigned entry_point_p : 1; 113 114 /* Set to 1 iff this object was initialized. */ 115 unsigned initialized : 1; 116 }; 117 118 /* Sections in an objfile. The section offsets are stored in the 119 OBJFILE. */ 120 121 struct obj_section 122 { 123 /* BFD section pointer */ 124 struct bfd_section *the_bfd_section; 125 126 /* Objfile this section is part of. */ 127 struct objfile *objfile; 128 129 /* True if this "overlay section" is mapped into an "overlay region". */ 130 int ovly_mapped; 131 }; 132 133 /* Relocation offset applied to S. */ 134 #define obj_section_offset(s) \ 135 (((s)->objfile->section_offsets)->offsets[gdb_bfd_section_index ((s)->objfile->obfd, (s)->the_bfd_section)]) 136 137 /* The memory address of section S (vma + offset). */ 138 #define obj_section_addr(s) \ 139 (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \ 140 + obj_section_offset (s)) 141 142 /* The one-passed-the-end memory address of section S 143 (vma + size + offset). */ 144 #define obj_section_endaddr(s) \ 145 (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \ 146 + bfd_get_section_size ((s)->the_bfd_section) \ 147 + obj_section_offset (s)) 148 149 /* The "objstats" structure provides a place for gdb to record some 150 interesting information about its internal state at runtime, on a 151 per objfile basis, such as information about the number of symbols 152 read, size of string table (if any), etc. */ 153 154 struct objstats 155 { 156 /* Number of partial symbols read. */ 157 int n_psyms; 158 159 /* Number of full symbols read. */ 160 int n_syms; 161 162 /* Number of ".stabs" read (if applicable). */ 163 int n_stabs; 164 165 /* Number of types. */ 166 int n_types; 167 168 /* Size of stringtable, (if applicable). */ 169 int sz_strtab; 170 }; 171 172 #define OBJSTAT(objfile, expr) (objfile -> stats.expr) 173 #define OBJSTATS struct objstats stats 174 extern void print_objfile_statistics (void); 175 extern void print_symbol_bcache_statistics (void); 176 177 /* Number of entries in the minimal symbol hash table. */ 178 #define MINIMAL_SYMBOL_HASH_SIZE 2039 179 180 /* Some objfile data is hung off the BFD. This enables sharing of the 181 data across all objfiles using the BFD. The data is stored in an 182 instance of this structure, and associated with the BFD using the 183 registry system. */ 184 185 struct objfile_per_bfd_storage 186 { 187 /* The storage has an obstack of its own. */ 188 189 struct obstack storage_obstack; 190 191 /* Byte cache for file names. */ 192 193 struct bcache *filename_cache; 194 195 /* Byte cache for macros. */ 196 197 struct bcache *macro_cache; 198 199 /* The gdbarch associated with the BFD. Note that this gdbarch is 200 determined solely from BFD information, without looking at target 201 information. The gdbarch determined from a running target may 202 differ from this e.g. with respect to register types and names. */ 203 204 struct gdbarch *gdbarch; 205 206 /* Hash table for mapping symbol names to demangled names. Each 207 entry in the hash table is actually two consecutive strings, 208 both null-terminated; the first one is a mangled or linkage 209 name, and the second is the demangled name or just a zero byte 210 if the name doesn't demangle. */ 211 212 struct htab *demangled_names_hash; 213 214 /* The per-objfile information about the entry point, the scope (file/func) 215 containing the entry point, and the scope of the user's main() func. */ 216 217 struct entry_info ei; 218 219 /* The name and language of any "main" found in this objfile. The 220 name can be NULL, which means that the information was not 221 recorded. */ 222 223 const char *name_of_main; 224 enum language language_of_main; 225 226 /* Each file contains a pointer to an array of minimal symbols for all 227 global symbols that are defined within the file. The array is 228 terminated by a "null symbol", one that has a NULL pointer for the 229 name and a zero value for the address. This makes it easy to walk 230 through the array when passed a pointer to somewhere in the middle 231 of it. There is also a count of the number of symbols, which does 232 not include the terminating null symbol. The array itself, as well 233 as all the data that it points to, should be allocated on the 234 objfile_obstack for this file. */ 235 236 struct minimal_symbol *msymbols; 237 int minimal_symbol_count; 238 239 /* The number of minimal symbols read, before any minimal symbol 240 de-duplication is applied. Note in particular that this has only 241 a passing relationship with the actual size of the table above; 242 use minimal_symbol_count if you need the true size. */ 243 244 int n_minsyms; 245 246 /* This is true if minimal symbols have already been read. Symbol 247 readers can use this to bypass minimal symbol reading. Also, the 248 minimal symbol table management code in minsyms.c uses this to 249 suppress new minimal symbols. You might think that MSYMBOLS or 250 MINIMAL_SYMBOL_COUNT could be used for this, but it is possible 251 for multiple readers to install minimal symbols into a given 252 per-BFD. */ 253 254 unsigned int minsyms_read : 1; 255 256 /* This is a hash table used to index the minimal symbols by name. */ 257 258 struct minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE]; 259 260 /* This hash table is used to index the minimal symbols by their 261 demangled names. */ 262 263 struct minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE]; 264 }; 265 266 /* Master structure for keeping track of each file from which 267 gdb reads symbols. There are several ways these get allocated: 1. 268 The main symbol file, symfile_objfile, set by the symbol-file command, 269 2. Additional symbol files added by the add-symbol-file command, 270 3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files 271 for modules that were loaded when GDB attached to a remote system 272 (see remote-vx.c). */ 273 274 struct objfile 275 { 276 /* All struct objfile's are chained together by their next pointers. 277 The program space field "objfiles" (frequently referenced via 278 the macro "object_files") points to the first link in this chain. */ 279 280 struct objfile *next; 281 282 /* The object file's original name as specified by the user, 283 made absolute, and tilde-expanded. However, it is not canonicalized 284 (i.e., it has not been passed through gdb_realpath). 285 This pointer is never NULL. This does not have to be freed; it is 286 guaranteed to have a lifetime at least as long as the objfile. */ 287 288 char *original_name; 289 290 CORE_ADDR addr_low; 291 292 /* Some flag bits for this objfile. */ 293 294 objfile_flags 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 /* Declarations for functions defined in objfiles.c */ 448 449 extern struct objfile *allocate_objfile (bfd *, const char *name, 450 objfile_flags); 451 452 extern struct gdbarch *get_objfile_arch (const struct objfile *); 453 454 extern int entry_point_address_query (CORE_ADDR *entry_p); 455 456 extern CORE_ADDR entry_point_address (void); 457 458 extern void build_objfile_section_table (struct objfile *); 459 460 extern struct objfile *objfile_separate_debug_iterate (const struct objfile *, 461 const struct objfile *); 462 463 extern void put_objfile_before (struct objfile *, struct objfile *); 464 465 extern void add_separate_debug_objfile (struct objfile *, struct objfile *); 466 467 extern void unlink_objfile (struct objfile *); 468 469 extern void free_objfile (struct objfile *); 470 471 extern void free_objfile_separate_debug (struct objfile *); 472 473 extern struct cleanup *make_cleanup_free_objfile (struct objfile *); 474 475 extern void free_all_objfiles (void); 476 477 extern void objfile_relocate (struct objfile *, const struct section_offsets *); 478 extern void objfile_rebase (struct objfile *, CORE_ADDR); 479 480 extern int objfile_has_partial_symbols (struct objfile *objfile); 481 482 extern int objfile_has_full_symbols (struct objfile *objfile); 483 484 extern int objfile_has_symbols (struct objfile *objfile); 485 486 extern int have_partial_symbols (void); 487 488 extern int have_full_symbols (void); 489 490 extern void objfile_set_sym_fns (struct objfile *objfile, 491 const struct sym_fns *sf); 492 493 extern void objfiles_changed (void); 494 495 extern int is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile); 496 497 /* Return true if ADDRESS maps into one of the sections of a 498 OBJF_SHARED objfile of PSPACE and false otherwise. */ 499 500 extern int shared_objfile_contains_address_p (struct program_space *pspace, 501 CORE_ADDR address); 502 503 /* This operation deletes all objfile entries that represent solibs that 504 weren't explicitly loaded by the user, via e.g., the add-symbol-file 505 command. */ 506 507 extern void objfile_purge_solibs (void); 508 509 /* Functions for dealing with the minimal symbol table, really a misc 510 address<->symbol mapping for things we don't have debug symbols for. */ 511 512 extern int have_minimal_symbols (void); 513 514 extern struct obj_section *find_pc_section (CORE_ADDR pc); 515 516 /* Return non-zero if PC is in a section called NAME. */ 517 extern int pc_in_section (CORE_ADDR, const char *); 518 519 /* Return non-zero if PC is in a SVR4-style procedure linkage table 520 section. */ 521 522 static inline int 523 in_plt_section (CORE_ADDR pc) 524 { 525 return pc_in_section (pc, ".plt"); 526 } 527 528 /* Keep a registry of per-objfile data-pointers required by other GDB 529 modules. */ 530 DECLARE_REGISTRY(objfile); 531 532 /* In normal use, the section map will be rebuilt by find_pc_section 533 if objfiles have been added, removed or relocated since it was last 534 called. Calling inhibit_section_map_updates will inhibit this 535 behavior until resume_section_map_updates is called. If you call 536 inhibit_section_map_updates you must ensure that every call to 537 find_pc_section in the inhibited region relates to a section that 538 is already in the section map and has not since been removed or 539 relocated. */ 540 extern void inhibit_section_map_updates (struct program_space *pspace); 541 542 /* Resume automatically rebuilding the section map as required. */ 543 extern void resume_section_map_updates (struct program_space *pspace); 544 545 /* Version of the above suitable for use as a cleanup. */ 546 extern void resume_section_map_updates_cleanup (void *arg); 547 548 extern void default_iterate_over_objfiles_in_search_order 549 (struct gdbarch *gdbarch, 550 iterate_over_objfiles_in_search_order_cb_ftype *cb, 551 void *cb_data, struct objfile *current_objfile); 552 553 554 /* Traverse all object files in the current program space. 555 ALL_OBJFILES_SAFE works even if you delete the objfile during the 556 traversal. */ 557 558 /* Traverse all object files in program space SS. */ 559 560 #define ALL_PSPACE_OBJFILES(ss, obj) \ 561 for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next) 562 563 #define ALL_OBJFILES(obj) \ 564 for ((obj) = current_program_space->objfiles; \ 565 (obj) != NULL; \ 566 (obj) = (obj)->next) 567 568 #define ALL_OBJFILES_SAFE(obj,nxt) \ 569 for ((obj) = current_program_space->objfiles; \ 570 (obj) != NULL? ((nxt)=(obj)->next,1) :0; \ 571 (obj) = (nxt)) 572 573 /* Traverse all symtabs in one objfile. */ 574 575 #define ALL_OBJFILE_FILETABS(objfile, cu, s) \ 576 ALL_OBJFILE_COMPUNITS (objfile, cu) \ 577 ALL_COMPUNIT_FILETABS (cu, s) 578 579 /* Traverse all compunits in one objfile. */ 580 581 #define ALL_OBJFILE_COMPUNITS(objfile, cu) \ 582 for ((cu) = (objfile) -> compunit_symtabs; (cu) != NULL; (cu) = (cu) -> next) 583 584 /* Traverse all minimal symbols in one objfile. */ 585 586 #define ALL_OBJFILE_MSYMBOLS(objfile, m) \ 587 for ((m) = (objfile)->per_bfd->msymbols; \ 588 MSYMBOL_LINKAGE_NAME (m) != NULL; \ 589 (m)++) 590 591 /* Traverse all symtabs in all objfiles in the current symbol 592 space. */ 593 594 #define ALL_FILETABS(objfile, ps, s) \ 595 ALL_OBJFILES (objfile) \ 596 ALL_OBJFILE_FILETABS (objfile, ps, s) 597 598 /* Traverse all compunits in all objfiles in the current program space. */ 599 600 #define ALL_COMPUNITS(objfile, cu) \ 601 ALL_OBJFILES (objfile) \ 602 ALL_OBJFILE_COMPUNITS (objfile, cu) 603 604 /* Traverse all minimal symbols in all objfiles in the current symbol 605 space. */ 606 607 #define ALL_MSYMBOLS(objfile, m) \ 608 ALL_OBJFILES (objfile) \ 609 ALL_OBJFILE_MSYMBOLS (objfile, m) 610 611 #define ALL_OBJFILE_OSECTIONS(objfile, osect) \ 612 for (osect = objfile->sections; osect < objfile->sections_end; osect++) \ 613 if (osect->the_bfd_section == NULL) \ 614 { \ 615 /* Nothing. */ \ 616 } \ 617 else 618 619 /* Traverse all obj_sections in all objfiles in the current program 620 space. 621 622 Note that this detects a "break" in the inner loop, and exits 623 immediately from the outer loop as well, thus, client code doesn't 624 need to know that this is implemented with a double for. The extra 625 hair is to make sure that a "break;" stops the outer loop iterating 626 as well, and both OBJFILE and OSECT are left unmodified: 627 628 - The outer loop learns about the inner loop's end condition, and 629 stops iterating if it detects the inner loop didn't reach its 630 end. In other words, the outer loop keeps going only if the 631 inner loop reached its end cleanly [(osect) == 632 (objfile)->sections_end]. 633 634 - OSECT is initialized in the outer loop initialization 635 expressions, such as if the inner loop has reached its end, so 636 the check mentioned above succeeds the first time. 637 638 - The trick to not clearing OBJFILE on a "break;" is, in the outer 639 loop's loop expression, advance OBJFILE, but iff the inner loop 640 reached its end. If not, there was a "break;", so leave OBJFILE 641 as is; the outer loop's conditional will break immediately as 642 well (as OSECT will be different from OBJFILE->sections_end). */ 643 644 #define ALL_OBJSECTIONS(objfile, osect) \ 645 for ((objfile) = current_program_space->objfiles, \ 646 (objfile) != NULL ? ((osect) = (objfile)->sections_end) : 0; \ 647 (objfile) != NULL \ 648 && (osect) == (objfile)->sections_end; \ 649 ((osect) == (objfile)->sections_end \ 650 ? ((objfile) = (objfile)->next, \ 651 (objfile) != NULL ? (osect) = (objfile)->sections_end : 0) \ 652 : 0)) \ 653 ALL_OBJFILE_OSECTIONS (objfile, osect) 654 655 #define SECT_OFF_DATA(objfile) \ 656 ((objfile->sect_index_data == -1) \ 657 ? (internal_error (__FILE__, __LINE__, \ 658 _("sect_index_data not initialized")), -1) \ 659 : objfile->sect_index_data) 660 661 #define SECT_OFF_RODATA(objfile) \ 662 ((objfile->sect_index_rodata == -1) \ 663 ? (internal_error (__FILE__, __LINE__, \ 664 _("sect_index_rodata not initialized")), -1) \ 665 : objfile->sect_index_rodata) 666 667 #define SECT_OFF_TEXT(objfile) \ 668 ((objfile->sect_index_text == -1) \ 669 ? (internal_error (__FILE__, __LINE__, \ 670 _("sect_index_text not initialized")), -1) \ 671 : objfile->sect_index_text) 672 673 /* Sometimes the .bss section is missing from the objfile, so we don't 674 want to die here. Let the users of SECT_OFF_BSS deal with an 675 uninitialized section index. */ 676 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss 677 678 /* Answer whether there is more than one object file loaded. */ 679 680 #define MULTI_OBJFILE_P() (object_files && object_files->next) 681 682 /* Reset the per-BFD storage area on OBJ. */ 683 684 void set_objfile_per_bfd (struct objfile *obj); 685 686 /* Return canonical name for OBJFILE. 687 This is the real file name if the file has been opened. 688 Otherwise it is the original name supplied by the user. */ 689 690 const char *objfile_name (const struct objfile *objfile); 691 692 /* Return the (real) file name of OBJFILE if the file has been opened, 693 otherwise return NULL. */ 694 695 const char *objfile_filename (const struct objfile *objfile); 696 697 /* Return the name to print for OBJFILE in debugging messages. */ 698 699 extern const char *objfile_debug_name (const struct objfile *objfile); 700 701 /* Return the name of the file format of OBJFILE if the file has been opened, 702 otherwise return NULL. */ 703 704 const char *objfile_flavour_name (struct objfile *objfile); 705 706 /* Set the objfile's notion of the "main" name and language. */ 707 708 extern void set_objfile_main_name (struct objfile *objfile, 709 const char *name, enum language lang); 710 711 extern void objfile_register_static_link 712 (struct objfile *objfile, 713 const struct block *block, 714 const struct dynamic_prop *static_link); 715 716 extern const struct dynamic_prop *objfile_lookup_static_link 717 (struct objfile *objfile, const struct block *block); 718 719 #endif /* !defined (OBJFILES_H) */ 720