1 /* Definitions for reading symbol files into GDB. 2 3 Copyright (C) 1990-2013 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 (SYMFILE_H) 21 #define SYMFILE_H 22 23 /* This file requires that you first include "bfd.h". */ 24 #include "symtab.h" 25 #include "probe.h" 26 27 /* Opaque declarations. */ 28 struct target_section; 29 struct objfile; 30 struct obj_section; 31 struct obstack; 32 struct block; 33 struct probe; 34 struct value; 35 struct frame_info; 36 struct agent_expr; 37 struct axs_value; 38 39 /* Comparison function for symbol look ups. */ 40 41 typedef int (symbol_compare_ftype) (const char *string1, 42 const char *string2); 43 44 /* Partial symbols are stored in the psymbol_cache and pointers to 45 them are kept in a dynamically grown array that is obtained from 46 malloc and grown as necessary via realloc. Each objfile typically 47 has two of these, one for global symbols and one for static 48 symbols. Although this adds a level of indirection for storing or 49 accessing the partial symbols, it allows us to throw away duplicate 50 psymbols and set all pointers to the single saved instance. */ 51 52 struct psymbol_allocation_list 53 { 54 55 /* Pointer to beginning of dynamically allocated array of pointers 56 to partial symbols. The array is dynamically expanded as 57 necessary to accommodate more pointers. */ 58 59 struct partial_symbol **list; 60 61 /* Pointer to next available slot in which to store a pointer to a 62 partial symbol. */ 63 64 struct partial_symbol **next; 65 66 /* Number of allocated pointer slots in current dynamic array (not 67 the number of bytes of storage). The "next" pointer will always 68 point somewhere between list[0] and list[size], and when at 69 list[size] the array will be expanded on the next attempt to 70 store a pointer. */ 71 72 int size; 73 }; 74 75 /* Define an array of addresses to accommodate non-contiguous dynamic 76 loading of modules. This is for use when entering commands, so we 77 can keep track of the section names until we read the file and can 78 map them to bfd sections. This structure is also used by solib.c 79 to communicate the section addresses in shared objects to 80 symbol_file_add (). */ 81 82 struct section_addr_info 83 { 84 /* The number of sections for which address information is 85 available. */ 86 size_t num_sections; 87 /* Sections whose names are file format dependent. */ 88 struct other_sections 89 { 90 CORE_ADDR addr; 91 char *name; 92 93 /* SECTINDEX must be valid for associated BFD or set to -1. */ 94 int sectindex; 95 } other[1]; 96 }; 97 98 99 /* A table listing the load segments in a symfile, and which segment 100 each BFD section belongs to. */ 101 struct symfile_segment_data 102 { 103 /* How many segments are present in this file. If there are 104 two, the text segment is the first one and the data segment 105 is the second one. */ 106 int num_segments; 107 108 /* If NUM_SEGMENTS is greater than zero, the original base address 109 of each segment. */ 110 CORE_ADDR *segment_bases; 111 112 /* If NUM_SEGMENTS is greater than zero, the memory size of each 113 segment. */ 114 CORE_ADDR *segment_sizes; 115 116 /* If NUM_SEGMENTS is greater than zero, this is an array of entries 117 recording which segment contains each BFD section. 118 SEGMENT_INFO[I] is S+1 if the I'th BFD section belongs to segment 119 S, or zero if it is not in any segment. */ 120 int *segment_info; 121 }; 122 123 /* Callback for quick_symbol_functions->map_symbol_filenames. */ 124 125 typedef void (symbol_filename_ftype) (const char *filename, 126 const char *fullname, void *data); 127 128 /* The "quick" symbol functions exist so that symbol readers can 129 avoiding an initial read of all the symbols. For example, symbol 130 readers might choose to use the "partial symbol table" utilities, 131 which is one implementation of the quick symbol functions. 132 133 The quick symbol functions are generally opaque: the underlying 134 representation is hidden from the caller. 135 136 In general, these functions should only look at whatever special 137 index the symbol reader creates -- looking through the symbol 138 tables themselves is handled by generic code. If a function is 139 defined as returning a "symbol table", this means that the function 140 should only return a newly-created symbol table; it should not 141 examine pre-existing ones. 142 143 The exact list of functions here was determined in an ad hoc way 144 based on gdb's history. */ 145 146 struct quick_symbol_functions 147 { 148 /* Return true if this objfile has any "partial" symbols 149 available. */ 150 int (*has_symbols) (struct objfile *objfile); 151 152 /* Return the symbol table for the "last" file appearing in 153 OBJFILE. */ 154 struct symtab *(*find_last_source_symtab) (struct objfile *objfile); 155 156 /* Forget all cached full file names for OBJFILE. */ 157 void (*forget_cached_source_info) (struct objfile *objfile); 158 159 /* Expand and iterate over each "partial" symbol table in OBJFILE 160 where the source file is named NAME. 161 162 If NAME is not absolute, a match after a '/' in the symbol table's 163 file name will also work, REAL_PATH is NULL then. If NAME is 164 absolute then REAL_PATH is non-NULL absolute file name as resolved 165 via gdb_realpath from NAME. 166 167 If a match is found, the "partial" symbol table is expanded. 168 Then, this calls iterate_over_some_symtabs (or equivalent) over 169 all newly-created symbol tables, passing CALLBACK and DATA to it. 170 The result of this call is returned. */ 171 int (*map_symtabs_matching_filename) (struct objfile *objfile, 172 const char *name, 173 const char *real_path, 174 int (*callback) (struct symtab *, 175 void *), 176 void *data); 177 178 /* Check to see if the symbol is defined in a "partial" symbol table 179 of OBJFILE. KIND should be either GLOBAL_BLOCK or STATIC_BLOCK, 180 depending on whether we want to search global symbols or static 181 symbols. NAME is the name of the symbol to look for. DOMAIN 182 indicates what sort of symbol to search for. 183 184 Returns the newly-expanded symbol table in which the symbol is 185 defined, or NULL if no such symbol table exists. If OBJFILE 186 contains !TYPE_OPAQUE symbol prefer its symtab. If it contains 187 only TYPE_OPAQUE symbol(s), return at least that symtab. */ 188 struct symtab *(*lookup_symbol) (struct objfile *objfile, 189 int kind, const char *name, 190 domain_enum domain); 191 192 /* Print statistics about any indices loaded for OBJFILE. The 193 statistics should be printed to gdb_stdout. This is used for 194 "maint print statistics". */ 195 void (*print_stats) (struct objfile *objfile); 196 197 /* Dump any indices loaded for OBJFILE. The dump should go to 198 gdb_stdout. This is used for "maint print objfiles". */ 199 void (*dump) (struct objfile *objfile); 200 201 /* This is called by objfile_relocate to relocate any indices loaded 202 for OBJFILE. */ 203 void (*relocate) (struct objfile *objfile, 204 struct section_offsets *new_offsets, 205 struct section_offsets *delta); 206 207 /* Find all the symbols in OBJFILE named FUNC_NAME, and ensure that 208 the corresponding symbol tables are loaded. */ 209 void (*expand_symtabs_for_function) (struct objfile *objfile, 210 const char *func_name); 211 212 /* Read all symbol tables associated with OBJFILE. */ 213 void (*expand_all_symtabs) (struct objfile *objfile); 214 215 /* Read all symbol tables associated with OBJFILE which have 216 symtab_to_fullname equal to FULLNAME. 217 This is for the purposes of examining code only, e.g., expand_line_sal. 218 The routine may ignore debug info that is known to not be useful with 219 code, e.g., DW_TAG_type_unit for dwarf debug info. */ 220 void (*expand_symtabs_with_fullname) (struct objfile *objfile, 221 const char *fullname); 222 223 /* Return the file name of the file holding the global symbol in OBJFILE 224 named NAME. If no such symbol exists in OBJFILE, return NULL. 225 Only file extension of returned filename is recognized. */ 226 const char *(*find_symbol_file) (struct objfile *objfile, const char *name); 227 228 /* Find global or static symbols in all tables that are in NAMESPACE 229 and for which MATCH (symbol name, NAME) == 0, passing each to 230 CALLBACK, reading in partial symbol tables as needed. Look 231 through global symbols if GLOBAL and otherwise static symbols. 232 Passes NAME, NAMESPACE, and DATA to CALLBACK with each symbol 233 found. After each block is processed, passes NULL to CALLBACK. 234 MATCH must be weaker than strcmp_iw_ordered in the sense that 235 strcmp_iw_ordered(x,y) == 0 --> MATCH(x,y) == 0. ORDERED_COMPARE, 236 if non-null, must be an ordering relation compatible with 237 strcmp_iw_ordered in the sense that 238 strcmp_iw_ordered(x,y) == 0 --> ORDERED_COMPARE(x,y) == 0 239 and 240 strcmp_iw_ordered(x,y) <= 0 --> ORDERED_COMPARE(x,y) <= 0 241 (allowing strcmp_iw_ordered(x,y) < 0 while ORDERED_COMPARE(x, y) == 0). 242 CALLBACK returns 0 to indicate that the scan should continue, or 243 non-zero to indicate that the scan should be terminated. */ 244 245 void (*map_matching_symbols) (const char *name, domain_enum namespace, 246 struct objfile *, int global, 247 int (*callback) (struct block *, 248 struct symbol *, void *), 249 void *data, 250 symbol_compare_ftype *match, 251 symbol_compare_ftype *ordered_compare); 252 253 /* Expand all symbol tables in OBJFILE matching some criteria. 254 255 FILE_MATCHER is called for each file in OBJFILE. The file name 256 and the DATA argument are passed to it. If it returns zero, this 257 file is skipped. If FILE_MATCHER is NULL such file is not skipped. 258 If BASENAMES is non-zero the function should consider only base name of 259 DATA (passed file name is already only the lbasename part). 260 261 Otherwise, if KIND does not match this symbol is skipped. 262 263 If even KIND matches, then NAME_MATCHER is called for each symbol 264 defined in the file. The symbol "search" name and DATA are passed 265 to NAME_MATCHER. 266 267 If NAME_MATCHER returns zero, then this symbol is skipped. 268 269 Otherwise, this symbol's symbol table is expanded. 270 271 DATA is user data that is passed unmodified to the callback 272 functions. */ 273 void (*expand_symtabs_matching) 274 (struct objfile *objfile, 275 int (*file_matcher) (const char *, void *, int basenames), 276 int (*name_matcher) (const char *, void *), 277 enum search_domain kind, 278 void *data); 279 280 /* Return the symbol table from OBJFILE that contains PC and 281 SECTION. Return NULL if there is no such symbol table. This 282 should return the symbol table that contains a symbol whose 283 address exactly matches PC, or, if there is no exact match, the 284 symbol table that contains a symbol whose address is closest to 285 PC. */ 286 struct symtab *(*find_pc_sect_symtab) (struct objfile *objfile, 287 struct minimal_symbol *msymbol, 288 CORE_ADDR pc, 289 struct obj_section *section, 290 int warn_if_readin); 291 292 /* Call a callback for every file defined in OBJFILE whose symtab is 293 not already read in. FUN is the callback. It is passed the file's 294 FILENAME, the file's FULLNAME (if need_fullname is non-zero), and 295 the DATA passed to this function. */ 296 void (*map_symbol_filenames) (struct objfile *objfile, 297 symbol_filename_ftype *fun, void *data, 298 int need_fullname); 299 }; 300 301 /* Structure of functions used for probe support. If one of these functions 302 is provided, all must be. */ 303 304 struct sym_probe_fns 305 { 306 /* If non-NULL, return an array of probe objects. 307 308 The returned value does not have to be freed and it has lifetime of the 309 OBJFILE. */ 310 VEC (probe_p) *(*sym_get_probes) (struct objfile *); 311 312 /* Return the number of arguments available to PROBE. PROBE will 313 have come from a call to this objfile's sym_get_probes method. 314 If you provide an implementation of sym_get_probes, you must 315 implement this method as well. */ 316 unsigned (*sym_get_probe_argument_count) (struct probe *probe); 317 318 /* Evaluate the Nth argument available to PROBE. PROBE will have 319 come from a call to this objfile's sym_get_probes method. N will 320 be between 0 and the number of arguments available to this probe. 321 FRAME is the frame in which the evaluation is done; the frame's 322 PC will match the address of the probe. If you provide an 323 implementation of sym_get_probes, you must implement this method 324 as well. */ 325 struct value *(*sym_evaluate_probe_argument) (struct probe *probe, 326 unsigned n); 327 328 /* Compile the Nth probe argument to an agent expression. PROBE 329 will have come from a call to this objfile's sym_get_probes 330 method. N will be between 0 and the number of arguments 331 available to this probe. EXPR and VALUE are the agent expression 332 that is being updated. */ 333 void (*sym_compile_to_ax) (struct probe *probe, 334 struct agent_expr *expr, 335 struct axs_value *value, 336 unsigned n); 337 338 /* Relocate the probe section of OBJFILE. */ 339 void (*sym_relocate_probe) (struct objfile *objfile, 340 struct section_offsets *new_offsets, 341 struct section_offsets *delta); 342 }; 343 344 /* Structure to keep track of symbol reading functions for various 345 object file types. */ 346 347 struct sym_fns 348 { 349 350 /* BFD flavour that we handle, or (as a special kludge, see 351 xcoffread.c, (enum bfd_flavour)-1 for xcoff). */ 352 353 enum bfd_flavour sym_flavour; 354 355 /* Initializes anything that is global to the entire symbol table. 356 It is called during symbol_file_add, when we begin debugging an 357 entirely new program. */ 358 359 void (*sym_new_init) (struct objfile *); 360 361 /* Reads any initial information from a symbol file, and initializes 362 the struct sym_fns SF in preparation for sym_read(). It is 363 called every time we read a symbol file for any reason. */ 364 365 void (*sym_init) (struct objfile *); 366 367 /* sym_read (objfile, symfile_flags) Reads a symbol file into a psymtab 368 (or possibly a symtab). OBJFILE is the objfile struct for the 369 file we are reading. SYMFILE_FLAGS are the flags passed to 370 symbol_file_add & co. */ 371 372 void (*sym_read) (struct objfile *, int); 373 374 /* Read the partial symbols for an objfile. This may be NULL, in which case 375 gdb has to check other ways if this objfile has any symbols. This may 376 only be non-NULL if the objfile actually does have debuginfo available. 377 */ 378 379 void (*sym_read_psymbols) (struct objfile *); 380 381 /* Called when we are finished with an objfile. Should do all 382 cleanup that is specific to the object file format for the 383 particular objfile. */ 384 385 void (*sym_finish) (struct objfile *); 386 387 /* This function produces a file-dependent section_offsets 388 structure, allocated in the objfile's storage, and based on the 389 parameter. The parameter is currently a CORE_ADDR (FIXME!) for 390 backward compatibility with the higher levels of GDB. It should 391 probably be changed to a string, where NULL means the default, 392 and others are parsed in a file dependent way. */ 393 394 void (*sym_offsets) (struct objfile *, struct section_addr_info *); 395 396 /* This function produces a format-independent description of 397 the segments of ABFD. Each segment is a unit of the file 398 which may be relocated independently. */ 399 400 struct symfile_segment_data *(*sym_segments) (bfd *abfd); 401 402 /* This function should read the linetable from the objfile when 403 the line table cannot be read while processing the debugging 404 information. */ 405 406 void (*sym_read_linetable) (void); 407 408 /* Relocate the contents of a debug section SECTP. The 409 contents are stored in BUF if it is non-NULL, or returned in a 410 malloc'd buffer otherwise. */ 411 412 bfd_byte *(*sym_relocate) (struct objfile *, asection *sectp, bfd_byte *buf); 413 414 /* If non-NULL, this objfile has probe support, and all the probe 415 functions referred to here will be non-NULL. */ 416 const struct sym_probe_fns *sym_probe_fns; 417 418 /* The "quick" (aka partial) symbol functions for this symbol 419 reader. */ 420 const struct quick_symbol_functions *qf; 421 }; 422 423 extern struct section_addr_info * 424 build_section_addr_info_from_objfile (const struct objfile *objfile); 425 426 extern void relative_addr_info_to_section_offsets 427 (struct section_offsets *section_offsets, int num_sections, 428 struct section_addr_info *addrs); 429 430 extern void addr_info_make_relative (struct section_addr_info *addrs, 431 bfd *abfd); 432 433 /* The default version of sym_fns.sym_offsets for readers that don't 434 do anything special. */ 435 436 extern void default_symfile_offsets (struct objfile *objfile, 437 struct section_addr_info *); 438 439 /* The default version of sym_fns.sym_segments for readers that don't 440 do anything special. */ 441 442 extern struct symfile_segment_data *default_symfile_segments (bfd *abfd); 443 444 /* The default version of sym_fns.sym_relocate for readers that don't 445 do anything special. */ 446 447 extern bfd_byte *default_symfile_relocate (struct objfile *objfile, 448 asection *sectp, bfd_byte *buf); 449 450 extern struct symtab *allocate_symtab (const char *, struct objfile *) 451 ATTRIBUTE_NONNULL (1); 452 453 extern void add_symtab_fns (const struct sym_fns *); 454 455 /* This enum encodes bit-flags passed as ADD_FLAGS parameter to 456 syms_from_objfile, symbol_file_add, etc. */ 457 458 enum symfile_add_flags 459 { 460 /* Be chatty about what you are doing. */ 461 SYMFILE_VERBOSE = 1 << 1, 462 463 /* This is the main symbol file (as opposed to symbol file for dynamically 464 loaded code). */ 465 SYMFILE_MAINLINE = 1 << 2, 466 467 /* Do not call breakpoint_re_set when adding this symbol file. */ 468 SYMFILE_DEFER_BP_RESET = 1 << 3, 469 470 /* Do not immediately read symbols for this file. By default, 471 symbols are read when the objfile is created. */ 472 SYMFILE_NO_READ = 1 << 4 473 }; 474 475 extern void syms_from_objfile (struct objfile *, 476 struct section_addr_info *, 477 struct section_offsets *, int, int); 478 479 extern void new_symfile_objfile (struct objfile *, int); 480 481 extern struct objfile *symbol_file_add (char *, int, 482 struct section_addr_info *, int); 483 484 extern struct objfile *symbol_file_add_from_bfd (bfd *, int, 485 struct section_addr_info *, 486 int, struct objfile *parent); 487 488 extern void symbol_file_add_separate (bfd *, int, struct objfile *); 489 490 extern char *find_separate_debug_file_by_debuglink (struct objfile *); 491 492 /* Create a new section_addr_info, with room for NUM_SECTIONS. */ 493 494 extern struct section_addr_info *alloc_section_addr_info (size_t 495 num_sections); 496 497 /* Build (allocate and populate) a section_addr_info struct from an 498 existing section table. */ 499 500 extern struct section_addr_info 501 *build_section_addr_info_from_section_table (const struct target_section 502 *start, 503 const struct target_section 504 *end); 505 506 /* Free all memory allocated by 507 build_section_addr_info_from_section_table. */ 508 509 extern void free_section_addr_info (struct section_addr_info *); 510 511 512 /* Variables */ 513 514 /* If non-zero, shared library symbols will be added automatically 515 when the inferior is created, new libraries are loaded, or when 516 attaching to the inferior. This is almost always what users will 517 want to have happen; but for very large programs, the startup time 518 will be excessive, and so if this is a problem, the user can clear 519 this flag and then add the shared library symbols as needed. Note 520 that there is a potential for confusion, since if the shared 521 library symbols are not loaded, commands like "info fun" will *not* 522 report all the functions that are actually present. */ 523 524 extern int auto_solib_add; 525 526 /* From symfile.c */ 527 528 extern void set_initial_language (void); 529 530 extern void find_lowest_section (bfd *, asection *, void *); 531 532 extern bfd *symfile_bfd_open (char *); 533 534 extern bfd *gdb_bfd_open_maybe_remote (const char *); 535 536 extern int get_section_index (struct objfile *, char *); 537 538 /* Utility functions for overlay sections: */ 539 extern enum overlay_debugging_state 540 { 541 ovly_off, 542 ovly_on, 543 ovly_auto 544 } overlay_debugging; 545 extern int overlay_cache_invalid; 546 547 /* Return the "mapped" overlay section containing the PC. */ 548 extern struct obj_section *find_pc_mapped_section (CORE_ADDR); 549 550 /* Return any overlay section containing the PC (even in its LMA 551 region). */ 552 extern struct obj_section *find_pc_overlay (CORE_ADDR); 553 554 /* Return true if the section is an overlay. */ 555 extern int section_is_overlay (struct obj_section *); 556 557 /* Return true if the overlay section is currently "mapped". */ 558 extern int section_is_mapped (struct obj_section *); 559 560 /* Return true if pc belongs to section's VMA. */ 561 extern CORE_ADDR pc_in_mapped_range (CORE_ADDR, struct obj_section *); 562 563 /* Return true if pc belongs to section's LMA. */ 564 extern CORE_ADDR pc_in_unmapped_range (CORE_ADDR, struct obj_section *); 565 566 /* Map an address from a section's LMA to its VMA. */ 567 extern CORE_ADDR overlay_mapped_address (CORE_ADDR, struct obj_section *); 568 569 /* Map an address from a section's VMA to its LMA. */ 570 extern CORE_ADDR overlay_unmapped_address (CORE_ADDR, struct obj_section *); 571 572 /* Convert an address in an overlay section (force into VMA range). */ 573 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *); 574 575 /* Load symbols from a file. */ 576 extern void symbol_file_add_main (char *args, int from_tty); 577 578 /* Clear GDB symbol tables. */ 579 extern void symbol_file_clear (int from_tty); 580 581 /* Default overlay update function. */ 582 extern void simple_overlay_update (struct obj_section *); 583 584 extern bfd_byte *symfile_relocate_debug_section (struct objfile *, asection *, 585 bfd_byte *); 586 587 extern int symfile_map_offsets_to_segments (bfd *, 588 struct symfile_segment_data *, 589 struct section_offsets *, 590 int, const CORE_ADDR *); 591 struct symfile_segment_data *get_symfile_segment_data (bfd *abfd); 592 void free_symfile_segment_data (struct symfile_segment_data *data); 593 594 extern struct cleanup *increment_reading_symtab (void); 595 596 /* From dwarf2read.c */ 597 598 /* Names for a dwarf2 debugging section. The field NORMAL is the normal 599 section name (usually from the DWARF standard), while the field COMPRESSED 600 is the name of compressed sections. If your object file format doesn't 601 support compressed sections, the field COMPRESSED can be NULL. Likewise, 602 the debugging section is not supported, the field NORMAL can be NULL too. 603 It doesn't make sense to have a NULL NORMAL field but a non-NULL COMPRESSED 604 field. */ 605 606 struct dwarf2_section_names { 607 const char *normal; 608 const char *compressed; 609 }; 610 611 /* List of names for dward2 debugging sections. Also most object file formats 612 use the standardized (ie ELF) names, some (eg XCOFF) have customized names 613 due to restrictions. 614 The table for the standard names is defined in dwarf2read.c. Please 615 update all instances of dwarf2_debug_sections if you add a field to this 616 structure. It is always safe to use { NULL, NULL } in this case. */ 617 618 struct dwarf2_debug_sections { 619 struct dwarf2_section_names info; 620 struct dwarf2_section_names abbrev; 621 struct dwarf2_section_names line; 622 struct dwarf2_section_names loc; 623 struct dwarf2_section_names macinfo; 624 struct dwarf2_section_names macro; 625 struct dwarf2_section_names str; 626 struct dwarf2_section_names ranges; 627 struct dwarf2_section_names types; 628 struct dwarf2_section_names addr; 629 struct dwarf2_section_names frame; 630 struct dwarf2_section_names eh_frame; 631 struct dwarf2_section_names gdb_index; 632 /* This field has no meaning, but exists solely to catch changes to 633 this structure which are not reflected in some instance. */ 634 int sentinel; 635 }; 636 637 extern int dwarf2_has_info (struct objfile *, 638 const struct dwarf2_debug_sections *); 639 640 /* Dwarf2 sections that can be accessed by dwarf2_get_section_info. */ 641 enum dwarf2_section_enum { 642 DWARF2_DEBUG_FRAME, 643 DWARF2_EH_FRAME 644 }; 645 646 extern void dwarf2_get_section_info (struct objfile *, 647 enum dwarf2_section_enum, 648 asection **, gdb_byte **, 649 bfd_size_type *); 650 651 extern int dwarf2_initialize_objfile (struct objfile *); 652 extern void dwarf2_build_psymtabs (struct objfile *); 653 extern void dwarf2_build_frame_info (struct objfile *); 654 655 void dwarf2_free_objfile (struct objfile *); 656 657 /* From mdebugread.c */ 658 659 extern void mdebug_build_psymtabs (struct objfile *, 660 const struct ecoff_debug_swap *, 661 struct ecoff_debug_info *); 662 663 extern void elfmdebug_build_psymtabs (struct objfile *, 664 const struct ecoff_debug_swap *, 665 asection *); 666 667 /* From minidebug.c. */ 668 669 extern bfd *find_separate_debug_file_in_section (struct objfile *); 670 671 #endif /* !defined(SYMFILE_H) */ 672