1 /* Definitions for symbol file management in GDB. 2 3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 4 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #if !defined (OBJFILES_H) 24 #define OBJFILES_H 25 26 #include "gdb_obstack.h" /* For obstack internals. */ 27 #include "symfile.h" /* For struct psymbol_allocation_list */ 28 29 struct bcache; 30 struct htab; 31 struct symtab; 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 105 /* The value we should use for this objects entry point. 106 The illegal/unknown value needs to be something other than 0, ~0 107 for instance, which is much less likely than 0. */ 108 109 CORE_ADDR entry_point; 110 111 #define INVALID_ENTRY_POINT (~0) /* ~0 will not be in any file, we hope. */ 112 113 }; 114 115 /* Sections in an objfile. 116 117 It is strange that we have both this notion of "sections" 118 and the one used by section_offsets. Section as used 119 here, (currently at least) means a BFD section, and the sections 120 are set up from the BFD sections in allocate_objfile. 121 122 The sections in section_offsets have their meaning determined by 123 the symbol format, and they are set up by the sym_offsets function 124 for that symbol file format. 125 126 I'm not sure this could or should be changed, however. */ 127 128 struct obj_section 129 { 130 CORE_ADDR addr; /* lowest address in section */ 131 CORE_ADDR endaddr; /* 1+highest address in section */ 132 133 /* This field is being used for nefarious purposes by syms_from_objfile. 134 It is said to be redundant with section_offsets; it's not really being 135 used that way, however, it's some sort of hack I don't understand 136 and am not going to try to eliminate (yet, anyway). FIXME. 137 138 It was documented as "offset between (end)addr and actual memory 139 addresses", but that's not true; addr & endaddr are actual memory 140 addresses. */ 141 CORE_ADDR offset; 142 143 struct bfd_section *the_bfd_section; /* BFD section pointer */ 144 145 /* Objfile this section is part of. */ 146 struct objfile *objfile; 147 148 /* True if this "overlay section" is mapped into an "overlay region". */ 149 int ovly_mapped; 150 }; 151 152 /* An import entry contains information about a symbol that 153 is used in this objfile but not defined in it, and so needs 154 to be imported from some other objfile */ 155 /* Currently we just store the name; no attributes. 1997-08-05 */ 156 typedef char *ImportEntry; 157 158 159 /* An export entry contains information about a symbol that 160 is defined in this objfile and available for use in other 161 objfiles */ 162 typedef struct 163 { 164 char *name; /* name of exported symbol */ 165 int address; /* offset subject to relocation */ 166 /* Currently no other attributes 1997-08-05 */ 167 } 168 ExportEntry; 169 170 171 /* The "objstats" structure provides a place for gdb to record some 172 interesting information about its internal state at runtime, on a 173 per objfile basis, such as information about the number of symbols 174 read, size of string table (if any), etc. */ 175 176 struct objstats 177 { 178 int n_minsyms; /* Number of minimal symbols read */ 179 int n_psyms; /* Number of partial symbols read */ 180 int n_syms; /* Number of full symbols read */ 181 int n_stabs; /* Number of ".stabs" read (if applicable) */ 182 int n_types; /* Number of types */ 183 int sz_strtab; /* Size of stringtable, (if applicable) */ 184 }; 185 186 #define OBJSTAT(objfile, expr) (objfile -> stats.expr) 187 #define OBJSTATS struct objstats stats 188 extern void print_objfile_statistics (void); 189 extern void print_symbol_bcache_statistics (void); 190 191 /* Number of entries in the minimal symbol hash table. */ 192 #define MINIMAL_SYMBOL_HASH_SIZE 2039 193 194 /* Master structure for keeping track of each file from which 195 gdb reads symbols. There are several ways these get allocated: 1. 196 The main symbol file, symfile_objfile, set by the symbol-file command, 197 2. Additional symbol files added by the add-symbol-file command, 198 3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files 199 for modules that were loaded when GDB attached to a remote system 200 (see remote-vx.c). */ 201 202 struct objfile 203 { 204 205 /* All struct objfile's are chained together by their next pointers. 206 The global variable "object_files" points to the first link in this 207 chain. 208 209 FIXME: There is a problem here if the objfile is reusable, and if 210 multiple users are to be supported. The problem is that the objfile 211 list is linked through a member of the objfile struct itself, which 212 is only valid for one gdb process. The list implementation needs to 213 be changed to something like: 214 215 struct list {struct list *next; struct objfile *objfile}; 216 217 where the list structure is completely maintained separately within 218 each gdb process. */ 219 220 struct objfile *next; 221 222 /* The object file's name, tilde-expanded and absolute. 223 Malloc'd; free it if you free this struct. */ 224 225 char *name; 226 227 /* Some flag bits for this objfile. */ 228 229 unsigned short flags; 230 231 /* Each objfile points to a linked list of symtabs derived from this file, 232 one symtab structure for each compilation unit (source file). Each link 233 in the symtab list contains a backpointer to this objfile. */ 234 235 struct symtab *symtabs; 236 237 /* Each objfile points to a linked list of partial symtabs derived from 238 this file, one partial symtab structure for each compilation unit 239 (source file). */ 240 241 struct partial_symtab *psymtabs; 242 243 /* List of freed partial symtabs, available for re-use */ 244 245 struct partial_symtab *free_psymtabs; 246 247 /* The object file's BFD. Can be null if the objfile contains only 248 minimal symbols, e.g. the run time common symbols for SunOS4. */ 249 250 bfd *obfd; 251 252 /* The modification timestamp of the object file, as of the last time 253 we read its symbols. */ 254 255 time_t mtime; 256 257 /* Obstack to hold objects that should be freed when we load a new symbol 258 table from this object file. */ 259 260 struct obstack objfile_obstack; 261 262 /* A byte cache where we can stash arbitrary "chunks" of bytes that 263 will not change. */ 264 265 struct bcache *psymbol_cache; /* Byte cache for partial syms */ 266 struct bcache *macro_cache; /* Byte cache for macros */ 267 268 /* Hash table for mapping symbol names to demangled names. Each 269 entry in the hash table is actually two consecutive strings, 270 both null-terminated; the first one is a mangled or linkage 271 name, and the second is the demangled name or just a zero byte 272 if the name doesn't demangle. */ 273 struct htab *demangled_names_hash; 274 275 /* Vectors of all partial symbols read in from file. The actual data 276 is stored in the objfile_obstack. */ 277 278 struct psymbol_allocation_list global_psymbols; 279 struct psymbol_allocation_list static_psymbols; 280 281 /* Each file contains a pointer to an array of minimal symbols for all 282 global symbols that are defined within the file. The array is terminated 283 by a "null symbol", one that has a NULL pointer for the name and a zero 284 value for the address. This makes it easy to walk through the array 285 when passed a pointer to somewhere in the middle of it. There is also 286 a count of the number of symbols, which does not include the terminating 287 null symbol. The array itself, as well as all the data that it points 288 to, should be allocated on the objfile_obstack for this file. */ 289 290 struct minimal_symbol *msymbols; 291 int minimal_symbol_count; 292 293 /* This is a hash table used to index the minimal symbols by name. */ 294 295 struct minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE]; 296 297 /* This hash table is used to index the minimal symbols by their 298 demangled names. */ 299 300 struct minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE]; 301 302 /* For object file formats which don't specify fundamental types, gdb 303 can create such types. For now, it maintains a vector of pointers 304 to these internally created fundamental types on a per objfile basis, 305 however it really should ultimately keep them on a per-compilation-unit 306 basis, to account for linkage-units that consist of a number of 307 compilation units that may have different fundamental types, such as 308 linking C modules with ADA modules, or linking C modules that are 309 compiled with 32-bit ints with C modules that are compiled with 64-bit 310 ints (not inherently evil with a smarter linker). */ 311 312 struct type **fundamental_types; 313 314 /* The mmalloc() malloc-descriptor for this objfile if we are using 315 the memory mapped malloc() package to manage storage for this objfile's 316 data. NULL if we are not. */ 317 318 void *md; 319 320 /* The file descriptor that was used to obtain the mmalloc descriptor 321 for this objfile. If we call mmalloc_detach with the malloc descriptor 322 we should then close this file descriptor. */ 323 324 int mmfd; 325 326 /* Structure which keeps track of functions that manipulate objfile's 327 of the same type as this objfile. I.E. the function to read partial 328 symbols for example. Note that this structure is in statically 329 allocated memory, and is shared by all objfiles that use the 330 object module reader of this type. */ 331 332 struct sym_fns *sf; 333 334 /* The per-objfile information about the entry point, the scope (file/func) 335 containing the entry point, and the scope of the user's main() func. */ 336 337 struct entry_info ei; 338 339 /* Information about stabs. Will be filled in with a dbx_symfile_info 340 struct by those readers that need it. */ 341 342 struct dbx_symfile_info *sym_stab_info; 343 344 /* Hook for information for use by the symbol reader (currently used 345 for information shared by sym_init and sym_read). It is 346 typically a pointer to malloc'd memory. The symbol reader's finish 347 function is responsible for freeing the memory thusly allocated. */ 348 349 void *sym_private; 350 351 /* Hook for target-architecture-specific information. This must 352 point to memory allocated on one of the obstacks in this objfile, 353 so that it gets freed automatically when reading a new object 354 file. */ 355 356 void *obj_private; 357 358 /* Per objfile data-pointers required by other GDB modules. */ 359 /* FIXME: kettenis/20030711: This mechanism could replace 360 sym_stab_info, sym_private and obj_private entirely. */ 361 362 void **data; 363 unsigned num_data; 364 365 /* Set of relocation offsets to apply to each section. 366 Currently on the objfile_obstack (which makes no sense, but I'm 367 not sure it's harming anything). 368 369 These offsets indicate that all symbols (including partial and 370 minimal symbols) which have been read have been relocated by this 371 much. Symbols which are yet to be read need to be relocated by 372 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. Currently the table is stored on the 394 objfile_obstack (which makes no sense, but I'm not sure it's 395 harming anything). */ 396 397 struct obj_section 398 *sections, *sections_end; 399 400 /* Imported symbols */ 401 /* FIXME: ezannoni 2004-02-10: This is just SOM (HP) specific (see 402 somread.c). It should not pollute generic objfiles. */ 403 ImportEntry *import_list; 404 int import_list_size; 405 406 /* Exported symbols */ 407 /* FIXME: ezannoni 2004-02-10: This is just SOM (HP) specific (see 408 somread.c). It should not pollute generic objfiles. */ 409 ExportEntry *export_list; 410 int export_list_size; 411 412 /* Link to objfile that contains the debug symbols for this one. 413 One is loaded if this file has an debug link to an existing 414 debug file with the right checksum */ 415 struct objfile *separate_debug_objfile; 416 417 /* If this is a separate debug object, this is used as a link to the 418 actual executable objfile. */ 419 struct objfile *separate_debug_objfile_backlink; 420 421 /* Place to stash various statistics about this objfile */ 422 OBJSTATS; 423 424 /* A symtab that the C++ code uses to stash special symbols 425 associated to namespaces. */ 426 427 /* FIXME/carlton-2003-06-27: Delete this in a few years once 428 "possible namespace symbols" go away. */ 429 struct symtab *cp_namespace_symtab; 430 }; 431 432 /* Defines for the objfile flag word. */ 433 434 /* When using mapped/remapped predigested gdb symbol information, we need 435 a flag that indicates that we have previously done an initial symbol 436 table read from this particular objfile. We can't just look for the 437 absence of any of the three symbol tables (msymbols, psymtab, symtab) 438 because if the file has no symbols for example, none of these will 439 exist. */ 440 441 #define OBJF_SYMS (1 << 1) /* Have tried to read symbols */ 442 443 /* When an object file has its functions reordered (currently Irix-5.2 444 shared libraries exhibit this behaviour), we will need an expensive 445 algorithm to locate a partial symtab or symtab via an address. 446 To avoid this penalty for normal object files, we use this flag, 447 whose setting is determined upon symbol table read in. */ 448 449 #define OBJF_REORDERED (1 << 2) /* Functions are reordered */ 450 451 /* Distinguish between an objfile for a shared library and a "vanilla" 452 objfile. (If not set, the objfile may still actually be a solib. 453 This can happen if the user created the objfile by using the 454 add-symbol-file command. GDB doesn't in that situation actually 455 check whether the file is a solib. Rather, the target's 456 implementation of the solib interface is responsible for setting 457 this flag when noticing solibs used by an inferior.) */ 458 459 #define OBJF_SHARED (1 << 3) /* From a shared library */ 460 461 /* User requested that this objfile be read in it's entirety. */ 462 463 #define OBJF_READNOW (1 << 4) /* Immediate full read */ 464 465 /* This objfile was created because the user explicitly caused it 466 (e.g., used the add-symbol-file command). This bit offers a way 467 for run_command to remove old objfile entries which are no longer 468 valid (i.e., are associated with an old inferior), but to preserve 469 ones that the user explicitly loaded via the add-symbol-file 470 command. */ 471 472 #define OBJF_USERLOADED (1 << 5) /* User loaded */ 473 474 /* The object file that the main symbol table was loaded from (e.g. the 475 argument to the "symbol-file" or "file" command). */ 476 477 extern struct objfile *symfile_objfile; 478 479 /* The object file that contains the runtime common minimal symbols 480 for SunOS4. Note that this objfile has no associated BFD. */ 481 482 extern struct objfile *rt_common_objfile; 483 484 /* When we need to allocate a new type, we need to know which objfile_obstack 485 to allocate the type on, since there is one for each objfile. The places 486 where types are allocated are deeply buried in function call hierarchies 487 which know nothing about objfiles, so rather than trying to pass a 488 particular objfile down to them, we just do an end run around them and 489 set current_objfile to be whatever objfile we expect to be using at the 490 time types are being allocated. For instance, when we start reading 491 symbols for a particular objfile, we set current_objfile to point to that 492 objfile, and when we are done, we set it back to NULL, to ensure that we 493 never put a type someplace other than where we are expecting to put it. 494 FIXME: Maybe we should review the entire type handling system and 495 see if there is a better way to avoid this problem. */ 496 497 extern struct objfile *current_objfile; 498 499 /* All known objfiles are kept in a linked list. This points to the 500 root of this list. */ 501 502 extern struct objfile *object_files; 503 504 /* Declarations for functions defined in objfiles.c */ 505 506 extern struct objfile *allocate_objfile (bfd *, int); 507 508 extern void init_entry_point_info (struct objfile *); 509 510 extern CORE_ADDR entry_point_address (void); 511 512 extern int build_objfile_section_table (struct objfile *); 513 514 extern void terminate_minimal_symbol_table (struct objfile *objfile); 515 516 extern void put_objfile_before (struct objfile *, struct objfile *); 517 518 extern void objfile_to_front (struct objfile *); 519 520 extern void unlink_objfile (struct objfile *); 521 522 extern void free_objfile (struct objfile *); 523 524 extern struct cleanup *make_cleanup_free_objfile (struct objfile *); 525 526 extern void free_all_objfiles (void); 527 528 extern void objfile_relocate (struct objfile *, struct section_offsets *); 529 530 extern int have_partial_symbols (void); 531 532 extern int have_full_symbols (void); 533 534 /* This operation deletes all objfile entries that represent solibs that 535 weren't explicitly loaded by the user, via e.g., the add-symbol-file 536 command. 537 */ 538 extern void objfile_purge_solibs (void); 539 540 /* Functions for dealing with the minimal symbol table, really a misc 541 address<->symbol mapping for things we don't have debug symbols for. */ 542 543 extern int have_minimal_symbols (void); 544 545 extern struct obj_section *find_pc_section (CORE_ADDR pc); 546 547 extern struct obj_section *find_pc_sect_section (CORE_ADDR pc, 548 asection * section); 549 550 extern int in_plt_section (CORE_ADDR, char *); 551 552 extern int is_in_import_list (char *, struct objfile *); 553 554 /* Keep a registry of per-objfile data-pointers required by other GDB 555 modules. */ 556 557 extern const struct objfile_data *register_objfile_data (void); 558 extern void clear_objfile_data (struct objfile *objfile); 559 extern void set_objfile_data (struct objfile *objfile, 560 const struct objfile_data *data, void *value); 561 extern void *objfile_data (struct objfile *objfile, 562 const struct objfile_data *data); 563 564 565 /* Traverse all object files. ALL_OBJFILES_SAFE works even if you delete 566 the objfile during the traversal. */ 567 568 #define ALL_OBJFILES(obj) \ 569 for ((obj) = object_files; (obj) != NULL; (obj) = (obj)->next) 570 571 #define ALL_OBJFILES_SAFE(obj,nxt) \ 572 for ((obj) = object_files; \ 573 (obj) != NULL? ((nxt)=(obj)->next,1) :0; \ 574 (obj) = (nxt)) 575 576 /* Traverse all symtabs in one objfile. */ 577 578 #define ALL_OBJFILE_SYMTABS(objfile, s) \ 579 for ((s) = (objfile) -> symtabs; (s) != NULL; (s) = (s) -> next) 580 581 /* Traverse all psymtabs in one objfile. */ 582 583 #define ALL_OBJFILE_PSYMTABS(objfile, p) \ 584 for ((p) = (objfile) -> psymtabs; (p) != NULL; (p) = (p) -> next) 585 586 /* Traverse all minimal symbols in one objfile. */ 587 588 #define ALL_OBJFILE_MSYMBOLS(objfile, m) \ 589 for ((m) = (objfile) -> msymbols; DEPRECATED_SYMBOL_NAME(m) != NULL; (m)++) 590 591 /* Traverse all symtabs in all objfiles. */ 592 593 #define ALL_SYMTABS(objfile, s) \ 594 ALL_OBJFILES (objfile) \ 595 ALL_OBJFILE_SYMTABS (objfile, s) 596 597 /* Traverse all psymtabs in all objfiles. */ 598 599 #define ALL_PSYMTABS(objfile, p) \ 600 ALL_OBJFILES (objfile) \ 601 ALL_OBJFILE_PSYMTABS (objfile, p) 602 603 /* Traverse all minimal symbols in all objfiles. */ 604 605 #define ALL_MSYMBOLS(objfile, m) \ 606 ALL_OBJFILES (objfile) \ 607 ALL_OBJFILE_MSYMBOLS (objfile, m) 608 609 #define ALL_OBJFILE_OSECTIONS(objfile, osect) \ 610 for (osect = objfile->sections; osect < objfile->sections_end; osect++) 611 612 #define ALL_OBJSECTIONS(objfile, osect) \ 613 ALL_OBJFILES (objfile) \ 614 ALL_OBJFILE_OSECTIONS (objfile, osect) 615 616 #define SECT_OFF_DATA(objfile) \ 617 ((objfile->sect_index_data == -1) \ 618 ? (internal_error (__FILE__, __LINE__, "sect_index_data not initialized"), -1) \ 619 : objfile->sect_index_data) 620 621 #define SECT_OFF_RODATA(objfile) \ 622 ((objfile->sect_index_rodata == -1) \ 623 ? (internal_error (__FILE__, __LINE__, "sect_index_rodata not initialized"), -1) \ 624 : objfile->sect_index_rodata) 625 626 #define SECT_OFF_TEXT(objfile) \ 627 ((objfile->sect_index_text == -1) \ 628 ? (internal_error (__FILE__, __LINE__, "sect_index_text not initialized"), -1) \ 629 : objfile->sect_index_text) 630 631 /* Sometimes the .bss section is missing from the objfile, so we don't 632 want to die here. Let the users of SECT_OFF_BSS deal with an 633 uninitialized section index. */ 634 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss 635 636 #endif /* !defined (OBJFILES_H) */ 637