symfile.c revision 1.5
1/* Generic symbol file reading for the GNU debugger, GDB. 2 3 Copyright (C) 1990-2015 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Support, using pieces from other GDB modules. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22#include "defs.h" 23#include "arch-utils.h" 24#include "bfdlink.h" 25#include "symtab.h" 26#include "gdbtypes.h" 27#include "gdbcore.h" 28#include "frame.h" 29#include "target.h" 30#include "value.h" 31#include "symfile.h" 32#include "objfiles.h" 33#include "source.h" 34#include "gdbcmd.h" 35#include "breakpoint.h" 36#include "language.h" 37#include "complaints.h" 38#include "demangle.h" 39#include "inferior.h" 40#include "regcache.h" 41#include "filenames.h" /* for DOSish file names */ 42#include "gdb-stabs.h" 43#include "gdb_obstack.h" 44#include "completer.h" 45#include "bcache.h" 46#include "hashtab.h" 47#include "readline/readline.h" 48#include "block.h" 49#include "observer.h" 50#include "exec.h" 51#include "parser-defs.h" 52#include "varobj.h" 53#include "elf-bfd.h" 54#include "solib.h" 55#include "remote.h" 56#include "stack.h" 57#include "gdb_bfd.h" 58#include "cli/cli-utils.h" 59 60#include <sys/types.h> 61#include <fcntl.h> 62#include <sys/stat.h> 63#include <ctype.h> 64#include <time.h> 65#include <sys/time.h> 66 67#include "psymtab.h" 68 69int (*deprecated_ui_load_progress_hook) (const char *section, 70 unsigned long num); 71void (*deprecated_show_load_progress) (const char *section, 72 unsigned long section_sent, 73 unsigned long section_size, 74 unsigned long total_sent, 75 unsigned long total_size); 76void (*deprecated_pre_add_symbol_hook) (const char *); 77void (*deprecated_post_add_symbol_hook) (void); 78 79static void clear_symtab_users_cleanup (void *ignore); 80 81/* Global variables owned by this file. */ 82int readnow_symbol_files; /* Read full symbols immediately. */ 83 84/* Functions this file defines. */ 85 86static void load_command (char *, int); 87 88static void symbol_file_add_main_1 (const char *args, int from_tty, int flags); 89 90static void add_symbol_file_command (char *, int); 91 92static const struct sym_fns *find_sym_fns (bfd *); 93 94static void decrement_reading_symtab (void *); 95 96static void overlay_invalidate_all (void); 97 98static void overlay_auto_command (char *, int); 99 100static void overlay_manual_command (char *, int); 101 102static void overlay_off_command (char *, int); 103 104static void overlay_load_command (char *, int); 105 106static void overlay_command (char *, int); 107 108static void simple_free_overlay_table (void); 109 110static void read_target_long_array (CORE_ADDR, unsigned int *, int, int, 111 enum bfd_endian); 112 113static int simple_read_overlay_table (void); 114 115static int simple_overlay_update_1 (struct obj_section *); 116 117static void add_filename_language (char *ext, enum language lang); 118 119static void info_ext_lang_command (char *args, int from_tty); 120 121static void init_filename_language_table (void); 122 123static void symfile_find_segment_sections (struct objfile *objfile); 124 125void _initialize_symfile (void); 126 127/* List of all available sym_fns. On gdb startup, each object file reader 128 calls add_symtab_fns() to register information on each format it is 129 prepared to read. */ 130 131typedef struct 132{ 133 /* BFD flavour that we handle. */ 134 enum bfd_flavour sym_flavour; 135 136 /* The "vtable" of symbol functions. */ 137 const struct sym_fns *sym_fns; 138} registered_sym_fns; 139 140DEF_VEC_O (registered_sym_fns); 141 142static VEC (registered_sym_fns) *symtab_fns = NULL; 143 144/* Values for "set print symbol-loading". */ 145 146const char print_symbol_loading_off[] = "off"; 147const char print_symbol_loading_brief[] = "brief"; 148const char print_symbol_loading_full[] = "full"; 149static const char *print_symbol_loading_enums[] = 150{ 151 print_symbol_loading_off, 152 print_symbol_loading_brief, 153 print_symbol_loading_full, 154 NULL 155}; 156static const char *print_symbol_loading = print_symbol_loading_full; 157 158/* If non-zero, shared library symbols will be added automatically 159 when the inferior is created, new libraries are loaded, or when 160 attaching to the inferior. This is almost always what users will 161 want to have happen; but for very large programs, the startup time 162 will be excessive, and so if this is a problem, the user can clear 163 this flag and then add the shared library symbols as needed. Note 164 that there is a potential for confusion, since if the shared 165 library symbols are not loaded, commands like "info fun" will *not* 166 report all the functions that are actually present. */ 167 168int auto_solib_add = 1; 169 170 171/* Return non-zero if symbol-loading messages should be printed. 172 FROM_TTY is the standard from_tty argument to gdb commands. 173 If EXEC is non-zero the messages are for the executable. 174 Otherwise, messages are for shared libraries. 175 If FULL is non-zero then the caller is printing a detailed message. 176 E.g., the message includes the shared library name. 177 Otherwise, the caller is printing a brief "summary" message. */ 178 179int 180print_symbol_loading_p (int from_tty, int exec, int full) 181{ 182 if (!from_tty && !info_verbose) 183 return 0; 184 185 if (exec) 186 { 187 /* We don't check FULL for executables, there are few such 188 messages, therefore brief == full. */ 189 return print_symbol_loading != print_symbol_loading_off; 190 } 191 if (full) 192 return print_symbol_loading == print_symbol_loading_full; 193 return print_symbol_loading == print_symbol_loading_brief; 194} 195 196/* True if we are reading a symbol table. */ 197 198int currently_reading_symtab = 0; 199 200static void 201decrement_reading_symtab (void *dummy) 202{ 203 currently_reading_symtab--; 204 gdb_assert (currently_reading_symtab >= 0); 205} 206 207/* Increment currently_reading_symtab and return a cleanup that can be 208 used to decrement it. */ 209 210struct cleanup * 211increment_reading_symtab (void) 212{ 213 ++currently_reading_symtab; 214 gdb_assert (currently_reading_symtab > 0); 215 return make_cleanup (decrement_reading_symtab, NULL); 216} 217 218/* Remember the lowest-addressed loadable section we've seen. 219 This function is called via bfd_map_over_sections. 220 221 In case of equal vmas, the section with the largest size becomes the 222 lowest-addressed loadable section. 223 224 If the vmas and sizes are equal, the last section is considered the 225 lowest-addressed loadable section. */ 226 227void 228find_lowest_section (bfd *abfd, asection *sect, void *obj) 229{ 230 asection **lowest = (asection **) obj; 231 232 if (0 == (bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))) 233 return; 234 if (!*lowest) 235 *lowest = sect; /* First loadable section */ 236 else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect)) 237 *lowest = sect; /* A lower loadable section */ 238 else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect) 239 && (bfd_section_size (abfd, (*lowest)) 240 <= bfd_section_size (abfd, sect))) 241 *lowest = sect; 242} 243 244/* Create a new section_addr_info, with room for NUM_SECTIONS. The 245 new object's 'num_sections' field is set to 0; it must be updated 246 by the caller. */ 247 248struct section_addr_info * 249alloc_section_addr_info (size_t num_sections) 250{ 251 struct section_addr_info *sap; 252 size_t size; 253 254 size = (sizeof (struct section_addr_info) 255 + sizeof (struct other_sections) * (num_sections - 1)); 256 sap = (struct section_addr_info *) xmalloc (size); 257 memset (sap, 0, size); 258 259 return sap; 260} 261 262/* Build (allocate and populate) a section_addr_info struct from 263 an existing section table. */ 264 265extern struct section_addr_info * 266build_section_addr_info_from_section_table (const struct target_section *start, 267 const struct target_section *end) 268{ 269 struct section_addr_info *sap; 270 const struct target_section *stp; 271 int oidx; 272 273 sap = alloc_section_addr_info (end - start); 274 275 for (stp = start, oidx = 0; stp != end; stp++) 276 { 277 struct bfd_section *asect = stp->the_bfd_section; 278 bfd *abfd = asect->owner; 279 280 if (bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD) 281 && oidx < end - start) 282 { 283 sap->other[oidx].addr = stp->addr; 284 sap->other[oidx].name = xstrdup (bfd_section_name (abfd, asect)); 285 sap->other[oidx].sectindex = gdb_bfd_section_index (abfd, asect); 286 oidx++; 287 } 288 } 289 290 sap->num_sections = oidx; 291 292 return sap; 293} 294 295/* Create a section_addr_info from section offsets in ABFD. */ 296 297static struct section_addr_info * 298build_section_addr_info_from_bfd (bfd *abfd) 299{ 300 struct section_addr_info *sap; 301 int i; 302 struct bfd_section *sec; 303 304 sap = alloc_section_addr_info (bfd_count_sections (abfd)); 305 for (i = 0, sec = abfd->sections; sec != NULL; sec = sec->next) 306 if (bfd_get_section_flags (abfd, sec) & (SEC_ALLOC | SEC_LOAD)) 307 { 308 sap->other[i].addr = bfd_get_section_vma (abfd, sec); 309 sap->other[i].name = xstrdup (bfd_get_section_name (abfd, sec)); 310 sap->other[i].sectindex = gdb_bfd_section_index (abfd, sec); 311 i++; 312 } 313 314 sap->num_sections = i; 315 316 return sap; 317} 318 319/* Create a section_addr_info from section offsets in OBJFILE. */ 320 321struct section_addr_info * 322build_section_addr_info_from_objfile (const struct objfile *objfile) 323{ 324 struct section_addr_info *sap; 325 int i; 326 327 /* Before reread_symbols gets rewritten it is not safe to call: 328 gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd)); 329 */ 330 sap = build_section_addr_info_from_bfd (objfile->obfd); 331 for (i = 0; i < sap->num_sections; i++) 332 { 333 int sectindex = sap->other[i].sectindex; 334 335 sap->other[i].addr += objfile->section_offsets->offsets[sectindex]; 336 } 337 return sap; 338} 339 340/* Free all memory allocated by build_section_addr_info_from_section_table. */ 341 342extern void 343free_section_addr_info (struct section_addr_info *sap) 344{ 345 int idx; 346 347 for (idx = 0; idx < sap->num_sections; idx++) 348 xfree (sap->other[idx].name); 349 xfree (sap); 350} 351 352/* Initialize OBJFILE's sect_index_* members. */ 353 354static void 355init_objfile_sect_indices (struct objfile *objfile) 356{ 357 asection *sect; 358 int i; 359 360 sect = bfd_get_section_by_name (objfile->obfd, ".text"); 361 if (sect) 362 objfile->sect_index_text = sect->index; 363 364 sect = bfd_get_section_by_name (objfile->obfd, ".data"); 365 if (sect) 366 objfile->sect_index_data = sect->index; 367 368 sect = bfd_get_section_by_name (objfile->obfd, ".bss"); 369 if (sect) 370 objfile->sect_index_bss = sect->index; 371 372 sect = bfd_get_section_by_name (objfile->obfd, ".rodata"); 373 if (sect) 374 objfile->sect_index_rodata = sect->index; 375 376 /* This is where things get really weird... We MUST have valid 377 indices for the various sect_index_* members or gdb will abort. 378 So if for example, there is no ".text" section, we have to 379 accomodate that. First, check for a file with the standard 380 one or two segments. */ 381 382 symfile_find_segment_sections (objfile); 383 384 /* Except when explicitly adding symbol files at some address, 385 section_offsets contains nothing but zeros, so it doesn't matter 386 which slot in section_offsets the individual sect_index_* members 387 index into. So if they are all zero, it is safe to just point 388 all the currently uninitialized indices to the first slot. But 389 beware: if this is the main executable, it may be relocated 390 later, e.g. by the remote qOffsets packet, and then this will 391 be wrong! That's why we try segments first. */ 392 393 for (i = 0; i < objfile->num_sections; i++) 394 { 395 if (ANOFFSET (objfile->section_offsets, i) != 0) 396 { 397 break; 398 } 399 } 400 if (i == objfile->num_sections) 401 { 402 if (objfile->sect_index_text == -1) 403 objfile->sect_index_text = 0; 404 if (objfile->sect_index_data == -1) 405 objfile->sect_index_data = 0; 406 if (objfile->sect_index_bss == -1) 407 objfile->sect_index_bss = 0; 408 if (objfile->sect_index_rodata == -1) 409 objfile->sect_index_rodata = 0; 410 } 411} 412 413/* The arguments to place_section. */ 414 415struct place_section_arg 416{ 417 struct section_offsets *offsets; 418 CORE_ADDR lowest; 419}; 420 421/* Find a unique offset to use for loadable section SECT if 422 the user did not provide an offset. */ 423 424static void 425place_section (bfd *abfd, asection *sect, void *obj) 426{ 427 struct place_section_arg *arg = obj; 428 CORE_ADDR *offsets = arg->offsets->offsets, start_addr; 429 int done; 430 ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect); 431 432 /* We are only interested in allocated sections. */ 433 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 434 return; 435 436 /* If the user specified an offset, honor it. */ 437 if (offsets[gdb_bfd_section_index (abfd, sect)] != 0) 438 return; 439 440 /* Otherwise, let's try to find a place for the section. */ 441 start_addr = (arg->lowest + align - 1) & -align; 442 443 do { 444 asection *cur_sec; 445 446 done = 1; 447 448 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next) 449 { 450 int indx = cur_sec->index; 451 452 /* We don't need to compare against ourself. */ 453 if (cur_sec == sect) 454 continue; 455 456 /* We can only conflict with allocated sections. */ 457 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0) 458 continue; 459 460 /* If the section offset is 0, either the section has not been placed 461 yet, or it was the lowest section placed (in which case LOWEST 462 will be past its end). */ 463 if (offsets[indx] == 0) 464 continue; 465 466 /* If this section would overlap us, then we must move up. */ 467 if (start_addr + bfd_get_section_size (sect) > offsets[indx] 468 && start_addr < offsets[indx] + bfd_get_section_size (cur_sec)) 469 { 470 start_addr = offsets[indx] + bfd_get_section_size (cur_sec); 471 start_addr = (start_addr + align - 1) & -align; 472 done = 0; 473 break; 474 } 475 476 /* Otherwise, we appear to be OK. So far. */ 477 } 478 } 479 while (!done); 480 481 offsets[gdb_bfd_section_index (abfd, sect)] = start_addr; 482 arg->lowest = start_addr + bfd_get_section_size (sect); 483} 484 485/* Store struct section_addr_info as prepared (made relative and with SECTINDEX 486 filled-in) by addr_info_make_relative into SECTION_OFFSETS of NUM_SECTIONS 487 entries. */ 488 489void 490relative_addr_info_to_section_offsets (struct section_offsets *section_offsets, 491 int num_sections, 492 const struct section_addr_info *addrs) 493{ 494 int i; 495 496 memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections)); 497 498 /* Now calculate offsets for section that were specified by the caller. */ 499 for (i = 0; i < addrs->num_sections; i++) 500 { 501 const struct other_sections *osp; 502 503 osp = &addrs->other[i]; 504 if (osp->sectindex == -1) 505 continue; 506 507 /* Record all sections in offsets. */ 508 /* The section_offsets in the objfile are here filled in using 509 the BFD index. */ 510 section_offsets->offsets[osp->sectindex] = osp->addr; 511 } 512} 513 514/* Transform section name S for a name comparison. prelink can split section 515 `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly 516 prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address 517 of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss' 518 (`.sbss') section has invalid (increased) virtual address. */ 519 520static const char * 521addr_section_name (const char *s) 522{ 523 if (strcmp (s, ".dynbss") == 0) 524 return ".bss"; 525 if (strcmp (s, ".sdynbss") == 0) 526 return ".sbss"; 527 528 return s; 529} 530 531/* qsort comparator for addrs_section_sort. Sort entries in ascending order by 532 their (name, sectindex) pair. sectindex makes the sort by name stable. */ 533 534static int 535addrs_section_compar (const void *ap, const void *bp) 536{ 537 const struct other_sections *a = *((struct other_sections **) ap); 538 const struct other_sections *b = *((struct other_sections **) bp); 539 int retval; 540 541 retval = strcmp (addr_section_name (a->name), addr_section_name (b->name)); 542 if (retval) 543 return retval; 544 545 return a->sectindex - b->sectindex; 546} 547 548/* Provide sorted array of pointers to sections of ADDRS. The array is 549 terminated by NULL. Caller is responsible to call xfree for it. */ 550 551static struct other_sections ** 552addrs_section_sort (struct section_addr_info *addrs) 553{ 554 struct other_sections **array; 555 int i; 556 557 /* `+ 1' for the NULL terminator. */ 558 array = xmalloc (sizeof (*array) * (addrs->num_sections + 1)); 559 for (i = 0; i < addrs->num_sections; i++) 560 array[i] = &addrs->other[i]; 561 array[i] = NULL; 562 563 qsort (array, i, sizeof (*array), addrs_section_compar); 564 565 return array; 566} 567 568/* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in 569 also SECTINDEXes specific to ABFD there. This function can be used to 570 rebase ADDRS to start referencing different BFD than before. */ 571 572void 573addr_info_make_relative (struct section_addr_info *addrs, bfd *abfd) 574{ 575 asection *lower_sect; 576 CORE_ADDR lower_offset; 577 int i; 578 struct cleanup *my_cleanup; 579 struct section_addr_info *abfd_addrs; 580 struct other_sections **addrs_sorted, **abfd_addrs_sorted; 581 struct other_sections **addrs_to_abfd_addrs; 582 583 /* Find lowest loadable section to be used as starting point for 584 continguous sections. */ 585 lower_sect = NULL; 586 bfd_map_over_sections (abfd, find_lowest_section, &lower_sect); 587 if (lower_sect == NULL) 588 { 589 warning (_("no loadable sections found in added symbol-file %s"), 590 bfd_get_filename (abfd)); 591 lower_offset = 0; 592 } 593 else 594 lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect); 595 596 /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections 597 in ABFD. Section names are not unique - there can be multiple sections of 598 the same name. Also the sections of the same name do not have to be 599 adjacent to each other. Some sections may be present only in one of the 600 files. Even sections present in both files do not have to be in the same 601 order. 602 603 Use stable sort by name for the sections in both files. Then linearly 604 scan both lists matching as most of the entries as possible. */ 605 606 addrs_sorted = addrs_section_sort (addrs); 607 my_cleanup = make_cleanup (xfree, addrs_sorted); 608 609 abfd_addrs = build_section_addr_info_from_bfd (abfd); 610 make_cleanup_free_section_addr_info (abfd_addrs); 611 abfd_addrs_sorted = addrs_section_sort (abfd_addrs); 612 make_cleanup (xfree, abfd_addrs_sorted); 613 614 /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and 615 ABFD_ADDRS_SORTED. */ 616 617 addrs_to_abfd_addrs = xzalloc (sizeof (*addrs_to_abfd_addrs) 618 * addrs->num_sections); 619 make_cleanup (xfree, addrs_to_abfd_addrs); 620 621 while (*addrs_sorted) 622 { 623 const char *sect_name = addr_section_name ((*addrs_sorted)->name); 624 625 while (*abfd_addrs_sorted 626 && strcmp (addr_section_name ((*abfd_addrs_sorted)->name), 627 sect_name) < 0) 628 abfd_addrs_sorted++; 629 630 if (*abfd_addrs_sorted 631 && strcmp (addr_section_name ((*abfd_addrs_sorted)->name), 632 sect_name) == 0) 633 { 634 int index_in_addrs; 635 636 /* Make the found item directly addressable from ADDRS. */ 637 index_in_addrs = *addrs_sorted - addrs->other; 638 gdb_assert (addrs_to_abfd_addrs[index_in_addrs] == NULL); 639 addrs_to_abfd_addrs[index_in_addrs] = *abfd_addrs_sorted; 640 641 /* Never use the same ABFD entry twice. */ 642 abfd_addrs_sorted++; 643 } 644 645 addrs_sorted++; 646 } 647 648 /* Calculate offsets for the loadable sections. 649 FIXME! Sections must be in order of increasing loadable section 650 so that contiguous sections can use the lower-offset!!! 651 652 Adjust offsets if the segments are not contiguous. 653 If the section is contiguous, its offset should be set to 654 the offset of the highest loadable section lower than it 655 (the loadable section directly below it in memory). 656 this_offset = lower_offset = lower_addr - lower_orig_addr */ 657 658 for (i = 0; i < addrs->num_sections; i++) 659 { 660 struct other_sections *sect = addrs_to_abfd_addrs[i]; 661 662 if (sect) 663 { 664 /* This is the index used by BFD. */ 665 addrs->other[i].sectindex = sect->sectindex; 666 667 if (addrs->other[i].addr != 0) 668 { 669 addrs->other[i].addr -= sect->addr; 670 lower_offset = addrs->other[i].addr; 671 } 672 else 673 addrs->other[i].addr = lower_offset; 674 } 675 else 676 { 677 /* addr_section_name transformation is not used for SECT_NAME. */ 678 const char *sect_name = addrs->other[i].name; 679 680 /* This section does not exist in ABFD, which is normally 681 unexpected and we want to issue a warning. 682 683 However, the ELF prelinker does create a few sections which are 684 marked in the main executable as loadable (they are loaded in 685 memory from the DYNAMIC segment) and yet are not present in 686 separate debug info files. This is fine, and should not cause 687 a warning. Shared libraries contain just the section 688 ".gnu.liblist" but it is not marked as loadable there. There is 689 no other way to identify them than by their name as the sections 690 created by prelink have no special flags. 691 692 For the sections `.bss' and `.sbss' see addr_section_name. */ 693 694 if (!(strcmp (sect_name, ".gnu.liblist") == 0 695 || strcmp (sect_name, ".gnu.conflict") == 0 696 || (strcmp (sect_name, ".bss") == 0 697 && i > 0 698 && strcmp (addrs->other[i - 1].name, ".dynbss") == 0 699 && addrs_to_abfd_addrs[i - 1] != NULL) 700 || (strcmp (sect_name, ".sbss") == 0 701 && i > 0 702 && strcmp (addrs->other[i - 1].name, ".sdynbss") == 0 703 && addrs_to_abfd_addrs[i - 1] != NULL))) 704 warning (_("section %s not found in %s"), sect_name, 705 bfd_get_filename (abfd)); 706 707 addrs->other[i].addr = 0; 708 addrs->other[i].sectindex = -1; 709 } 710 } 711 712 do_cleanups (my_cleanup); 713} 714 715/* Parse the user's idea of an offset for dynamic linking, into our idea 716 of how to represent it for fast symbol reading. This is the default 717 version of the sym_fns.sym_offsets function for symbol readers that 718 don't need to do anything special. It allocates a section_offsets table 719 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */ 720 721void 722default_symfile_offsets (struct objfile *objfile, 723 const struct section_addr_info *addrs) 724{ 725 objfile->num_sections = gdb_bfd_count_sections (objfile->obfd); 726 objfile->section_offsets = (struct section_offsets *) 727 obstack_alloc (&objfile->objfile_obstack, 728 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 729 relative_addr_info_to_section_offsets (objfile->section_offsets, 730 objfile->num_sections, addrs); 731 732 /* For relocatable files, all loadable sections will start at zero. 733 The zero is meaningless, so try to pick arbitrary addresses such 734 that no loadable sections overlap. This algorithm is quadratic, 735 but the number of sections in a single object file is generally 736 small. */ 737 if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0) 738 { 739 struct place_section_arg arg; 740 bfd *abfd = objfile->obfd; 741 asection *cur_sec; 742 743 for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next) 744 /* We do not expect this to happen; just skip this step if the 745 relocatable file has a section with an assigned VMA. */ 746 if (bfd_section_vma (abfd, cur_sec) != 0) 747 break; 748 749 if (cur_sec == NULL) 750 { 751 CORE_ADDR *offsets = objfile->section_offsets->offsets; 752 753 /* Pick non-overlapping offsets for sections the user did not 754 place explicitly. */ 755 arg.offsets = objfile->section_offsets; 756 arg.lowest = 0; 757 bfd_map_over_sections (objfile->obfd, place_section, &arg); 758 759 /* Correctly filling in the section offsets is not quite 760 enough. Relocatable files have two properties that 761 (most) shared objects do not: 762 763 - Their debug information will contain relocations. Some 764 shared libraries do also, but many do not, so this can not 765 be assumed. 766 767 - If there are multiple code sections they will be loaded 768 at different relative addresses in memory than they are 769 in the objfile, since all sections in the file will start 770 at address zero. 771 772 Because GDB has very limited ability to map from an 773 address in debug info to the correct code section, 774 it relies on adding SECT_OFF_TEXT to things which might be 775 code. If we clear all the section offsets, and set the 776 section VMAs instead, then symfile_relocate_debug_section 777 will return meaningful debug information pointing at the 778 correct sections. 779 780 GDB has too many different data structures for section 781 addresses - a bfd, objfile, and so_list all have section 782 tables, as does exec_ops. Some of these could probably 783 be eliminated. */ 784 785 for (cur_sec = abfd->sections; cur_sec != NULL; 786 cur_sec = cur_sec->next) 787 { 788 if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0) 789 continue; 790 791 bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]); 792 exec_set_section_address (bfd_get_filename (abfd), 793 cur_sec->index, 794 offsets[cur_sec->index]); 795 offsets[cur_sec->index] = 0; 796 } 797 } 798 } 799 800 /* Remember the bfd indexes for the .text, .data, .bss and 801 .rodata sections. */ 802 init_objfile_sect_indices (objfile); 803} 804 805/* Divide the file into segments, which are individual relocatable units. 806 This is the default version of the sym_fns.sym_segments function for 807 symbol readers that do not have an explicit representation of segments. 808 It assumes that object files do not have segments, and fully linked 809 files have a single segment. */ 810 811struct symfile_segment_data * 812default_symfile_segments (bfd *abfd) 813{ 814 int num_sections, i; 815 asection *sect; 816 struct symfile_segment_data *data; 817 CORE_ADDR low, high; 818 819 /* Relocatable files contain enough information to position each 820 loadable section independently; they should not be relocated 821 in segments. */ 822 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0) 823 return NULL; 824 825 /* Make sure there is at least one loadable section in the file. */ 826 for (sect = abfd->sections; sect != NULL; sect = sect->next) 827 { 828 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 829 continue; 830 831 break; 832 } 833 if (sect == NULL) 834 return NULL; 835 836 low = bfd_get_section_vma (abfd, sect); 837 high = low + bfd_get_section_size (sect); 838 839 data = XCNEW (struct symfile_segment_data); 840 data->num_segments = 1; 841 data->segment_bases = XCNEW (CORE_ADDR); 842 data->segment_sizes = XCNEW (CORE_ADDR); 843 844 num_sections = bfd_count_sections (abfd); 845 data->segment_info = XCNEWVEC (int, num_sections); 846 847 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 848 { 849 CORE_ADDR vma; 850 851 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 852 continue; 853 854 vma = bfd_get_section_vma (abfd, sect); 855 if (vma < low) 856 low = vma; 857 if (vma + bfd_get_section_size (sect) > high) 858 high = vma + bfd_get_section_size (sect); 859 860 data->segment_info[i] = 1; 861 } 862 863 data->segment_bases[0] = low; 864 data->segment_sizes[0] = high - low; 865 866 return data; 867} 868 869/* This is a convenience function to call sym_read for OBJFILE and 870 possibly force the partial symbols to be read. */ 871 872static void 873read_symbols (struct objfile *objfile, int add_flags) 874{ 875 (*objfile->sf->sym_read) (objfile, add_flags); 876 objfile->per_bfd->minsyms_read = 1; 877 878 /* find_separate_debug_file_in_section should be called only if there is 879 single binary with no existing separate debug info file. */ 880 if (!objfile_has_partial_symbols (objfile) 881 && objfile->separate_debug_objfile == NULL 882 && objfile->separate_debug_objfile_backlink == NULL) 883 { 884 bfd *abfd = find_separate_debug_file_in_section (objfile); 885 struct cleanup *cleanup = make_cleanup_bfd_unref (abfd); 886 887 if (abfd != NULL) 888 { 889 /* find_separate_debug_file_in_section uses the same filename for the 890 virtual section-as-bfd like the bfd filename containing the 891 section. Therefore use also non-canonical name form for the same 892 file containing the section. */ 893 symbol_file_add_separate (abfd, objfile->original_name, add_flags, 894 objfile); 895 } 896 897 do_cleanups (cleanup); 898 } 899 if ((add_flags & SYMFILE_NO_READ) == 0) 900 require_partial_symbols (objfile, 0); 901} 902 903/* Initialize entry point information for this objfile. */ 904 905static void 906init_entry_point_info (struct objfile *objfile) 907{ 908 struct entry_info *ei = &objfile->per_bfd->ei; 909 910 if (ei->initialized) 911 return; 912 ei->initialized = 1; 913 914 /* Save startup file's range of PC addresses to help blockframe.c 915 decide where the bottom of the stack is. */ 916 917 if (bfd_get_file_flags (objfile->obfd) & EXEC_P) 918 { 919 /* Executable file -- record its entry point so we'll recognize 920 the startup file because it contains the entry point. */ 921 ei->entry_point = bfd_get_start_address (objfile->obfd); 922 ei->entry_point_p = 1; 923 } 924 else if (bfd_get_file_flags (objfile->obfd) & DYNAMIC 925 && bfd_get_start_address (objfile->obfd) != 0) 926 { 927 /* Some shared libraries may have entry points set and be 928 runnable. There's no clear way to indicate this, so just check 929 for values other than zero. */ 930 ei->entry_point = bfd_get_start_address (objfile->obfd); 931 ei->entry_point_p = 1; 932 } 933 else 934 { 935 /* Examination of non-executable.o files. Short-circuit this stuff. */ 936 ei->entry_point_p = 0; 937 } 938 939 if (ei->entry_point_p) 940 { 941 struct obj_section *osect; 942 CORE_ADDR entry_point = ei->entry_point; 943 int found; 944 945 /* Make certain that the address points at real code, and not a 946 function descriptor. */ 947 entry_point 948 = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile), 949 entry_point, 950 ¤t_target); 951 952 /* Remove any ISA markers, so that this matches entries in the 953 symbol table. */ 954 ei->entry_point 955 = gdbarch_addr_bits_remove (get_objfile_arch (objfile), entry_point); 956 957 found = 0; 958 ALL_OBJFILE_OSECTIONS (objfile, osect) 959 { 960 struct bfd_section *sect = osect->the_bfd_section; 961 962 if (entry_point >= bfd_get_section_vma (objfile->obfd, sect) 963 && entry_point < (bfd_get_section_vma (objfile->obfd, sect) 964 + bfd_get_section_size (sect))) 965 { 966 ei->the_bfd_section_index 967 = gdb_bfd_section_index (objfile->obfd, sect); 968 found = 1; 969 break; 970 } 971 } 972 973 if (!found) 974 ei->the_bfd_section_index = SECT_OFF_TEXT (objfile); 975 } 976} 977 978/* Process a symbol file, as either the main file or as a dynamically 979 loaded file. 980 981 This function does not set the OBJFILE's entry-point info. 982 983 OBJFILE is where the symbols are to be read from. 984 985 ADDRS is the list of section load addresses. If the user has given 986 an 'add-symbol-file' command, then this is the list of offsets and 987 addresses he or she provided as arguments to the command; or, if 988 we're handling a shared library, these are the actual addresses the 989 sections are loaded at, according to the inferior's dynamic linker 990 (as gleaned by GDB's shared library code). We convert each address 991 into an offset from the section VMA's as it appears in the object 992 file, and then call the file's sym_offsets function to convert this 993 into a format-specific offset table --- a `struct section_offsets'. 994 995 ADD_FLAGS encodes verbosity level, whether this is main symbol or 996 an extra symbol file such as dynamically loaded code, and wether 997 breakpoint reset should be deferred. */ 998 999static void 1000syms_from_objfile_1 (struct objfile *objfile, 1001 struct section_addr_info *addrs, 1002 int add_flags) 1003{ 1004 struct section_addr_info *local_addr = NULL; 1005 struct cleanup *old_chain; 1006 const int mainline = add_flags & SYMFILE_MAINLINE; 1007 1008 objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd)); 1009 1010 if (objfile->sf == NULL) 1011 { 1012 /* No symbols to load, but we still need to make sure 1013 that the section_offsets table is allocated. */ 1014 int num_sections = gdb_bfd_count_sections (objfile->obfd); 1015 size_t size = SIZEOF_N_SECTION_OFFSETS (num_sections); 1016 1017 objfile->num_sections = num_sections; 1018 objfile->section_offsets 1019 = obstack_alloc (&objfile->objfile_obstack, size); 1020 memset (objfile->section_offsets, 0, size); 1021 return; 1022 } 1023 1024 /* Make sure that partially constructed symbol tables will be cleaned up 1025 if an error occurs during symbol reading. */ 1026 old_chain = make_cleanup_free_objfile (objfile); 1027 1028 /* If ADDRS is NULL, put together a dummy address list. 1029 We now establish the convention that an addr of zero means 1030 no load address was specified. */ 1031 if (! addrs) 1032 { 1033 local_addr = alloc_section_addr_info (1); 1034 make_cleanup (xfree, local_addr); 1035 addrs = local_addr; 1036 } 1037 1038 if (mainline) 1039 { 1040 /* We will modify the main symbol table, make sure that all its users 1041 will be cleaned up if an error occurs during symbol reading. */ 1042 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/); 1043 1044 /* Since no error yet, throw away the old symbol table. */ 1045 1046 if (symfile_objfile != NULL) 1047 { 1048 free_objfile (symfile_objfile); 1049 gdb_assert (symfile_objfile == NULL); 1050 } 1051 1052 /* Currently we keep symbols from the add-symbol-file command. 1053 If the user wants to get rid of them, they should do "symbol-file" 1054 without arguments first. Not sure this is the best behavior 1055 (PR 2207). */ 1056 1057 (*objfile->sf->sym_new_init) (objfile); 1058 } 1059 1060 /* Convert addr into an offset rather than an absolute address. 1061 We find the lowest address of a loaded segment in the objfile, 1062 and assume that <addr> is where that got loaded. 1063 1064 We no longer warn if the lowest section is not a text segment (as 1065 happens for the PA64 port. */ 1066 if (addrs->num_sections > 0) 1067 addr_info_make_relative (addrs, objfile->obfd); 1068 1069 /* Initialize symbol reading routines for this objfile, allow complaints to 1070 appear for this new file, and record how verbose to be, then do the 1071 initial symbol reading for this file. */ 1072 1073 (*objfile->sf->sym_init) (objfile); 1074 clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE); 1075 1076 (*objfile->sf->sym_offsets) (objfile, addrs); 1077 1078 read_symbols (objfile, add_flags); 1079 1080 /* Discard cleanups as symbol reading was successful. */ 1081 1082 discard_cleanups (old_chain); 1083 xfree (local_addr); 1084} 1085 1086/* Same as syms_from_objfile_1, but also initializes the objfile 1087 entry-point info. */ 1088 1089static void 1090syms_from_objfile (struct objfile *objfile, 1091 struct section_addr_info *addrs, 1092 int add_flags) 1093{ 1094 syms_from_objfile_1 (objfile, addrs, add_flags); 1095 init_entry_point_info (objfile); 1096} 1097 1098/* Perform required actions after either reading in the initial 1099 symbols for a new objfile, or mapping in the symbols from a reusable 1100 objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */ 1101 1102static void 1103finish_new_objfile (struct objfile *objfile, int add_flags) 1104{ 1105 /* If this is the main symbol file we have to clean up all users of the 1106 old main symbol file. Otherwise it is sufficient to fixup all the 1107 breakpoints that may have been redefined by this symbol file. */ 1108 if (add_flags & SYMFILE_MAINLINE) 1109 { 1110 /* OK, make it the "real" symbol file. */ 1111 symfile_objfile = objfile; 1112 1113 clear_symtab_users (add_flags); 1114 } 1115 else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0) 1116 { 1117 breakpoint_re_set (); 1118 } 1119 1120 /* We're done reading the symbol file; finish off complaints. */ 1121 clear_complaints (&symfile_complaints, 0, add_flags & SYMFILE_VERBOSE); 1122} 1123 1124/* Process a symbol file, as either the main file or as a dynamically 1125 loaded file. 1126 1127 ABFD is a BFD already open on the file, as from symfile_bfd_open. 1128 A new reference is acquired by this function. 1129 1130 For NAME description see allocate_objfile's definition. 1131 1132 ADD_FLAGS encodes verbosity, whether this is main symbol file or 1133 extra, such as dynamically loaded code, and what to do with breakpoins. 1134 1135 ADDRS is as described for syms_from_objfile_1, above. 1136 ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS. 1137 1138 PARENT is the original objfile if ABFD is a separate debug info file. 1139 Otherwise PARENT is NULL. 1140 1141 Upon success, returns a pointer to the objfile that was added. 1142 Upon failure, jumps back to command level (never returns). */ 1143 1144static struct objfile * 1145symbol_file_add_with_addrs (bfd *abfd, const char *name, int add_flags, 1146 struct section_addr_info *addrs, 1147 int flags, struct objfile *parent) 1148{ 1149 struct objfile *objfile; 1150 const int from_tty = add_flags & SYMFILE_VERBOSE; 1151 const int mainline = add_flags & SYMFILE_MAINLINE; 1152 const int should_print = (print_symbol_loading_p (from_tty, mainline, 1) 1153 && (readnow_symbol_files 1154 || (add_flags & SYMFILE_NO_READ) == 0)); 1155 1156 if (readnow_symbol_files) 1157 { 1158 flags |= OBJF_READNOW; 1159 add_flags &= ~SYMFILE_NO_READ; 1160 } 1161 1162 /* Give user a chance to burp if we'd be 1163 interactively wiping out any existing symbols. */ 1164 1165 if ((have_full_symbols () || have_partial_symbols ()) 1166 && mainline 1167 && from_tty 1168 && !query (_("Load new symbol table from \"%s\"? "), name)) 1169 error (_("Not confirmed.")); 1170 1171 objfile = allocate_objfile (abfd, name, 1172 flags | (mainline ? OBJF_MAINLINE : 0)); 1173 1174 if (parent) 1175 add_separate_debug_objfile (objfile, parent); 1176 1177 /* We either created a new mapped symbol table, mapped an existing 1178 symbol table file which has not had initial symbol reading 1179 performed, or need to read an unmapped symbol table. */ 1180 if (should_print) 1181 { 1182 if (deprecated_pre_add_symbol_hook) 1183 deprecated_pre_add_symbol_hook (name); 1184 else 1185 { 1186 printf_unfiltered (_("Reading symbols from %s..."), name); 1187 wrap_here (""); 1188 gdb_flush (gdb_stdout); 1189 } 1190 } 1191 syms_from_objfile (objfile, addrs, add_flags); 1192 1193 /* We now have at least a partial symbol table. Check to see if the 1194 user requested that all symbols be read on initial access via either 1195 the gdb startup command line or on a per symbol file basis. Expand 1196 all partial symbol tables for this objfile if so. */ 1197 1198 if ((flags & OBJF_READNOW)) 1199 { 1200 if (should_print) 1201 { 1202 printf_unfiltered (_("expanding to full symbols...")); 1203 wrap_here (""); 1204 gdb_flush (gdb_stdout); 1205 } 1206 1207 if (objfile->sf) 1208 objfile->sf->qf->expand_all_symtabs (objfile); 1209 } 1210 1211 if (should_print && !objfile_has_symbols (objfile)) 1212 { 1213 wrap_here (""); 1214 printf_unfiltered (_("(no debugging symbols found)...")); 1215 wrap_here (""); 1216 } 1217 1218 if (should_print) 1219 { 1220 if (deprecated_post_add_symbol_hook) 1221 deprecated_post_add_symbol_hook (); 1222 else 1223 printf_unfiltered (_("done.\n")); 1224 } 1225 1226 /* We print some messages regardless of whether 'from_tty || 1227 info_verbose' is true, so make sure they go out at the right 1228 time. */ 1229 gdb_flush (gdb_stdout); 1230 1231 if (objfile->sf == NULL) 1232 { 1233 observer_notify_new_objfile (objfile); 1234 return objfile; /* No symbols. */ 1235 } 1236 1237 finish_new_objfile (objfile, add_flags); 1238 1239 observer_notify_new_objfile (objfile); 1240 1241 bfd_cache_close_all (); 1242 return (objfile); 1243} 1244 1245/* Add BFD as a separate debug file for OBJFILE. For NAME description 1246 see allocate_objfile's definition. */ 1247 1248void 1249symbol_file_add_separate (bfd *bfd, const char *name, int symfile_flags, 1250 struct objfile *objfile) 1251{ 1252 struct objfile *new_objfile; 1253 struct section_addr_info *sap; 1254 struct cleanup *my_cleanup; 1255 1256 /* Create section_addr_info. We can't directly use offsets from OBJFILE 1257 because sections of BFD may not match sections of OBJFILE and because 1258 vma may have been modified by tools such as prelink. */ 1259 sap = build_section_addr_info_from_objfile (objfile); 1260 my_cleanup = make_cleanup_free_section_addr_info (sap); 1261 1262 new_objfile = symbol_file_add_with_addrs 1263 (bfd, name, symfile_flags, sap, 1264 objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW 1265 | OBJF_USERLOADED), 1266 objfile); 1267 1268 do_cleanups (my_cleanup); 1269} 1270 1271/* Process the symbol file ABFD, as either the main file or as a 1272 dynamically loaded file. 1273 See symbol_file_add_with_addrs's comments for details. */ 1274 1275struct objfile * 1276symbol_file_add_from_bfd (bfd *abfd, const char *name, int add_flags, 1277 struct section_addr_info *addrs, 1278 int flags, struct objfile *parent) 1279{ 1280 return symbol_file_add_with_addrs (abfd, name, add_flags, addrs, flags, 1281 parent); 1282} 1283 1284/* Process a symbol file, as either the main file or as a dynamically 1285 loaded file. See symbol_file_add_with_addrs's comments for details. */ 1286 1287struct objfile * 1288symbol_file_add (const char *name, int add_flags, 1289 struct section_addr_info *addrs, int flags) 1290{ 1291 bfd *bfd = symfile_bfd_open (name); 1292 struct cleanup *cleanup = make_cleanup_bfd_unref (bfd); 1293 struct objfile *objf; 1294 1295 objf = symbol_file_add_from_bfd (bfd, name, add_flags, addrs, flags, NULL); 1296 do_cleanups (cleanup); 1297 return objf; 1298} 1299 1300/* Call symbol_file_add() with default values and update whatever is 1301 affected by the loading of a new main(). 1302 Used when the file is supplied in the gdb command line 1303 and by some targets with special loading requirements. 1304 The auxiliary function, symbol_file_add_main_1(), has the flags 1305 argument for the switches that can only be specified in the symbol_file 1306 command itself. */ 1307 1308void 1309symbol_file_add_main (const char *args, int from_tty) 1310{ 1311 symbol_file_add_main_1 (args, from_tty, 0); 1312} 1313 1314static void 1315symbol_file_add_main_1 (const char *args, int from_tty, int flags) 1316{ 1317 const int add_flags = (current_inferior ()->symfile_flags 1318 | SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0)); 1319 1320 symbol_file_add (args, add_flags, NULL, flags); 1321 1322 /* Getting new symbols may change our opinion about 1323 what is frameless. */ 1324 reinit_frame_cache (); 1325 1326 if ((flags & SYMFILE_NO_READ) == 0) 1327 set_initial_language (); 1328} 1329 1330void 1331symbol_file_clear (int from_tty) 1332{ 1333 if ((have_full_symbols () || have_partial_symbols ()) 1334 && from_tty 1335 && (symfile_objfile 1336 ? !query (_("Discard symbol table from `%s'? "), 1337 objfile_name (symfile_objfile)) 1338 : !query (_("Discard symbol table? ")))) 1339 error (_("Not confirmed.")); 1340 1341 /* solib descriptors may have handles to objfiles. Wipe them before their 1342 objfiles get stale by free_all_objfiles. */ 1343 no_shared_libraries (NULL, from_tty); 1344 1345 free_all_objfiles (); 1346 1347 gdb_assert (symfile_objfile == NULL); 1348 if (from_tty) 1349 printf_unfiltered (_("No symbol file now.\n")); 1350} 1351 1352static int 1353separate_debug_file_exists (const char *name, unsigned long crc, 1354 struct objfile *parent_objfile) 1355{ 1356 unsigned long file_crc; 1357 int file_crc_p; 1358 bfd *abfd; 1359 struct stat parent_stat, abfd_stat; 1360 int verified_as_different; 1361 1362 /* Find a separate debug info file as if symbols would be present in 1363 PARENT_OBJFILE itself this function would not be called. .gnu_debuglink 1364 section can contain just the basename of PARENT_OBJFILE without any 1365 ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where 1366 the separate debug infos with the same basename can exist. */ 1367 1368 if (filename_cmp (name, objfile_name (parent_objfile)) == 0) 1369 return 0; 1370 1371 abfd = gdb_bfd_open (name, gnutarget, -1); 1372 1373 if (!abfd) 1374 return 0; 1375 1376 /* Verify symlinks were not the cause of filename_cmp name difference above. 1377 1378 Some operating systems, e.g. Windows, do not provide a meaningful 1379 st_ino; they always set it to zero. (Windows does provide a 1380 meaningful st_dev.) Files accessed from gdbservers that do not 1381 support the vFile:fstat packet will also have st_ino set to zero. 1382 Do not indicate a duplicate library in either case. While there 1383 is no guarantee that a system that provides meaningful inode 1384 numbers will never set st_ino to zero, this is merely an 1385 optimization, so we do not need to worry about false negatives. */ 1386 1387 if (bfd_stat (abfd, &abfd_stat) == 0 1388 && abfd_stat.st_ino != 0 1389 && bfd_stat (parent_objfile->obfd, &parent_stat) == 0) 1390 { 1391 if (abfd_stat.st_dev == parent_stat.st_dev 1392 && abfd_stat.st_ino == parent_stat.st_ino) 1393 { 1394 gdb_bfd_unref (abfd); 1395 return 0; 1396 } 1397 verified_as_different = 1; 1398 } 1399 else 1400 verified_as_different = 0; 1401 1402 file_crc_p = gdb_bfd_crc (abfd, &file_crc); 1403 1404 gdb_bfd_unref (abfd); 1405 1406 if (!file_crc_p) 1407 return 0; 1408 1409 if (crc != file_crc) 1410 { 1411 unsigned long parent_crc; 1412 1413 /* If the files could not be verified as different with 1414 bfd_stat then we need to calculate the parent's CRC 1415 to verify whether the files are different or not. */ 1416 1417 if (!verified_as_different) 1418 { 1419 if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc)) 1420 return 0; 1421 } 1422 1423 if (verified_as_different || parent_crc != file_crc) 1424 warning (_("the debug information found in \"%s\"" 1425 " does not match \"%s\" (CRC mismatch).\n"), 1426 name, objfile_name (parent_objfile)); 1427 1428 return 0; 1429 } 1430 1431 return 1; 1432} 1433 1434char *debug_file_directory = NULL; 1435static void 1436show_debug_file_directory (struct ui_file *file, int from_tty, 1437 struct cmd_list_element *c, const char *value) 1438{ 1439 fprintf_filtered (file, 1440 _("The directory where separate debug " 1441 "symbols are searched for is \"%s\".\n"), 1442 value); 1443} 1444 1445#if ! defined (DEBUG_SUBDIRECTORY) 1446#define DEBUG_SUBDIRECTORY ".debug" 1447#endif 1448 1449/* Find a separate debuginfo file for OBJFILE, using DIR as the directory 1450 where the original file resides (may not be the same as 1451 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are 1452 looking for. CANON_DIR is the "realpath" form of DIR. 1453 DIR must contain a trailing '/'. 1454 Returns the path of the file with separate debug info, of NULL. */ 1455 1456static char * 1457find_separate_debug_file (const char *dir, 1458 const char *canon_dir, 1459 const char *debuglink, 1460 unsigned long crc32, struct objfile *objfile) 1461{ 1462 char *debugdir; 1463 char *debugfile; 1464 int i; 1465 VEC (char_ptr) *debugdir_vec; 1466 struct cleanup *back_to; 1467 int ix; 1468 1469 /* Set I to max (strlen (canon_dir), strlen (dir)). */ 1470 i = strlen (dir); 1471 if (canon_dir != NULL && strlen (canon_dir) > i) 1472 i = strlen (canon_dir); 1473 1474 debugfile = xmalloc (strlen (debug_file_directory) + 1 1475 + i 1476 + strlen (DEBUG_SUBDIRECTORY) 1477 + strlen ("/") 1478 + strlen (debuglink) 1479 + 1); 1480 1481 /* First try in the same directory as the original file. */ 1482 strcpy (debugfile, dir); 1483 strcat (debugfile, debuglink); 1484 1485 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1486 return debugfile; 1487 1488 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */ 1489 strcpy (debugfile, dir); 1490 strcat (debugfile, DEBUG_SUBDIRECTORY); 1491 strcat (debugfile, "/"); 1492 strcat (debugfile, debuglink); 1493 1494 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1495 return debugfile; 1496 1497 /* Then try in the global debugfile directories. 1498 1499 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will 1500 cause "/..." lookups. */ 1501 1502 debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory); 1503 back_to = make_cleanup_free_char_ptr_vec (debugdir_vec); 1504 1505 for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix) 1506 { 1507 strcpy (debugfile, debugdir); 1508 strcat (debugfile, "/"); 1509 strcat (debugfile, dir); 1510 strcat (debugfile, debuglink); 1511 1512 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1513 { 1514 do_cleanups (back_to); 1515 return debugfile; 1516 } 1517 1518 /* If the file is in the sysroot, try using its base path in the 1519 global debugfile directory. */ 1520 if (canon_dir != NULL 1521 && filename_ncmp (canon_dir, gdb_sysroot, 1522 strlen (gdb_sysroot)) == 0 1523 && IS_DIR_SEPARATOR (canon_dir[strlen (gdb_sysroot)])) 1524 { 1525 strcpy (debugfile, debugdir); 1526 strcat (debugfile, canon_dir + strlen (gdb_sysroot)); 1527 strcat (debugfile, "/"); 1528 strcat (debugfile, debuglink); 1529 1530 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1531 { 1532 do_cleanups (back_to); 1533 return debugfile; 1534 } 1535 } 1536 } 1537 1538 do_cleanups (back_to); 1539 xfree (debugfile); 1540 return NULL; 1541} 1542 1543/* Modify PATH to contain only "[/]directory/" part of PATH. 1544 If there were no directory separators in PATH, PATH will be empty 1545 string on return. */ 1546 1547static void 1548terminate_after_last_dir_separator (char *path) 1549{ 1550 int i; 1551 1552 /* Strip off the final filename part, leaving the directory name, 1553 followed by a slash. The directory can be relative or absolute. */ 1554 for (i = strlen(path) - 1; i >= 0; i--) 1555 if (IS_DIR_SEPARATOR (path[i])) 1556 break; 1557 1558 /* If I is -1 then no directory is present there and DIR will be "". */ 1559 path[i + 1] = '\0'; 1560} 1561 1562/* Find separate debuginfo for OBJFILE (using .gnu_debuglink section). 1563 Returns pathname, or NULL. */ 1564 1565char * 1566find_separate_debug_file_by_debuglink (struct objfile *objfile) 1567{ 1568 char *debuglink; 1569 char *dir, *canon_dir; 1570 char *debugfile; 1571 unsigned long crc32; 1572 struct cleanup *cleanups; 1573 1574 debuglink = bfd_get_debug_link_info (objfile->obfd, &crc32); 1575 1576 if (debuglink == NULL) 1577 { 1578 /* There's no separate debug info, hence there's no way we could 1579 load it => no warning. */ 1580 return NULL; 1581 } 1582 1583 cleanups = make_cleanup (xfree, debuglink); 1584 dir = xstrdup (objfile_name (objfile)); 1585 make_cleanup (xfree, dir); 1586 terminate_after_last_dir_separator (dir); 1587 canon_dir = lrealpath (dir); 1588 1589 debugfile = find_separate_debug_file (dir, canon_dir, debuglink, 1590 crc32, objfile); 1591 xfree (canon_dir); 1592 1593 if (debugfile == NULL) 1594 { 1595 /* For PR gdb/9538, try again with realpath (if different from the 1596 original). */ 1597 1598 struct stat st_buf; 1599 1600 if (lstat (objfile_name (objfile), &st_buf) == 0 1601 && S_ISLNK (st_buf.st_mode)) 1602 { 1603 char *symlink_dir; 1604 1605 symlink_dir = lrealpath (objfile_name (objfile)); 1606 if (symlink_dir != NULL) 1607 { 1608 make_cleanup (xfree, symlink_dir); 1609 terminate_after_last_dir_separator (symlink_dir); 1610 if (strcmp (dir, symlink_dir) != 0) 1611 { 1612 /* Different directory, so try using it. */ 1613 debugfile = find_separate_debug_file (symlink_dir, 1614 symlink_dir, 1615 debuglink, 1616 crc32, 1617 objfile); 1618 } 1619 } 1620 } 1621 } 1622 1623 do_cleanups (cleanups); 1624 return debugfile; 1625} 1626 1627/* This is the symbol-file command. Read the file, analyze its 1628 symbols, and add a struct symtab to a symtab list. The syntax of 1629 the command is rather bizarre: 1630 1631 1. The function buildargv implements various quoting conventions 1632 which are undocumented and have little or nothing in common with 1633 the way things are quoted (or not quoted) elsewhere in GDB. 1634 1635 2. Options are used, which are not generally used in GDB (perhaps 1636 "set mapped on", "set readnow on" would be better) 1637 1638 3. The order of options matters, which is contrary to GNU 1639 conventions (because it is confusing and inconvenient). */ 1640 1641void 1642symbol_file_command (char *args, int from_tty) 1643{ 1644 dont_repeat (); 1645 1646 if (args == NULL) 1647 { 1648 symbol_file_clear (from_tty); 1649 } 1650 else 1651 { 1652 char **argv = gdb_buildargv (args); 1653 int flags = OBJF_USERLOADED; 1654 struct cleanup *cleanups; 1655 char *name = NULL; 1656 1657 cleanups = make_cleanup_freeargv (argv); 1658 while (*argv != NULL) 1659 { 1660 if (strcmp (*argv, "-readnow") == 0) 1661 flags |= OBJF_READNOW; 1662 else if (**argv == '-') 1663 error (_("unknown option `%s'"), *argv); 1664 else 1665 { 1666 symbol_file_add_main_1 (*argv, from_tty, flags); 1667 name = *argv; 1668 } 1669 1670 argv++; 1671 } 1672 1673 if (name == NULL) 1674 error (_("no symbol file name was specified")); 1675 1676 do_cleanups (cleanups); 1677 } 1678} 1679 1680/* Set the initial language. 1681 1682 FIXME: A better solution would be to record the language in the 1683 psymtab when reading partial symbols, and then use it (if known) to 1684 set the language. This would be a win for formats that encode the 1685 language in an easily discoverable place, such as DWARF. For 1686 stabs, we can jump through hoops looking for specially named 1687 symbols or try to intuit the language from the specific type of 1688 stabs we find, but we can't do that until later when we read in 1689 full symbols. */ 1690 1691void 1692set_initial_language (void) 1693{ 1694 enum language lang = main_language (); 1695 1696 if (lang == language_unknown) 1697 { 1698 char *name = main_name (); 1699 struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL); 1700 1701 if (sym != NULL) 1702 lang = SYMBOL_LANGUAGE (sym); 1703 } 1704 1705 if (lang == language_unknown) 1706 { 1707 /* Make C the default language */ 1708 lang = language_c; 1709 } 1710 1711 set_language (lang); 1712 expected_language = current_language; /* Don't warn the user. */ 1713} 1714 1715/* Open the file specified by NAME and hand it off to BFD for 1716 preliminary analysis. Return a newly initialized bfd *, which 1717 includes a newly malloc'd` copy of NAME (tilde-expanded and made 1718 absolute). In case of trouble, error() is called. */ 1719 1720bfd * 1721symfile_bfd_open (const char *name) 1722{ 1723 bfd *sym_bfd; 1724 int desc = -1; 1725 struct cleanup *back_to = make_cleanup (null_cleanup, 0); 1726 1727 if (!is_target_filename (name)) 1728 { 1729 char *expanded_name, *absolute_name; 1730 1731 expanded_name = tilde_expand (name); /* Returns 1st new malloc'd copy. */ 1732 1733 /* Look down path for it, allocate 2nd new malloc'd copy. */ 1734 desc = openp (getenv ("PATH"), 1735 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, 1736 expanded_name, O_RDONLY | O_BINARY, &absolute_name); 1737#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__) 1738 if (desc < 0) 1739 { 1740 char *exename = alloca (strlen (expanded_name) + 5); 1741 1742 strcat (strcpy (exename, expanded_name), ".exe"); 1743 desc = openp (getenv ("PATH"), 1744 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, 1745 exename, O_RDONLY | O_BINARY, &absolute_name); 1746 } 1747#endif 1748 if (desc < 0) 1749 { 1750 make_cleanup (xfree, expanded_name); 1751 perror_with_name (expanded_name); 1752 } 1753 1754 xfree (expanded_name); 1755 make_cleanup (xfree, absolute_name); 1756 name = absolute_name; 1757 } 1758 1759 sym_bfd = gdb_bfd_open (name, gnutarget, desc); 1760 if (!sym_bfd) 1761 error (_("`%s': can't open to read symbols: %s."), name, 1762 bfd_errmsg (bfd_get_error ())); 1763 1764 if (!gdb_bfd_has_target_filename (sym_bfd)) 1765 bfd_set_cacheable (sym_bfd, 1); 1766 1767 if (!bfd_check_format (sym_bfd, bfd_object)) 1768 { 1769 make_cleanup_bfd_unref (sym_bfd); 1770 error (_("`%s': can't read symbols: %s."), name, 1771 bfd_errmsg (bfd_get_error ())); 1772 } 1773 1774 do_cleanups (back_to); 1775 1776 return sym_bfd; 1777} 1778 1779/* Return the section index for SECTION_NAME on OBJFILE. Return -1 if 1780 the section was not found. */ 1781 1782int 1783get_section_index (struct objfile *objfile, char *section_name) 1784{ 1785 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name); 1786 1787 if (sect) 1788 return sect->index; 1789 else 1790 return -1; 1791} 1792 1793/* Link SF into the global symtab_fns list. 1794 FLAVOUR is the file format that SF handles. 1795 Called on startup by the _initialize routine in each object file format 1796 reader, to register information about each format the reader is prepared 1797 to handle. */ 1798 1799void 1800add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *sf) 1801{ 1802 registered_sym_fns fns = { flavour, sf }; 1803 1804 VEC_safe_push (registered_sym_fns, symtab_fns, &fns); 1805} 1806 1807/* Initialize OBJFILE to read symbols from its associated BFD. It 1808 either returns or calls error(). The result is an initialized 1809 struct sym_fns in the objfile structure, that contains cached 1810 information about the symbol file. */ 1811 1812static const struct sym_fns * 1813find_sym_fns (bfd *abfd) 1814{ 1815 registered_sym_fns *rsf; 1816 enum bfd_flavour our_flavour = bfd_get_flavour (abfd); 1817 int i; 1818 1819 if (our_flavour == bfd_target_srec_flavour 1820 || our_flavour == bfd_target_ihex_flavour 1821 || our_flavour == bfd_target_tekhex_flavour) 1822 return NULL; /* No symbols. */ 1823 1824 for (i = 0; VEC_iterate (registered_sym_fns, symtab_fns, i, rsf); ++i) 1825 if (our_flavour == rsf->sym_flavour) 1826 return rsf->sym_fns; 1827 1828 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."), 1829 bfd_get_target (abfd)); 1830} 1831 1832 1833/* This function runs the load command of our current target. */ 1834 1835static void 1836load_command (char *arg, int from_tty) 1837{ 1838 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 1839 1840 dont_repeat (); 1841 1842 /* The user might be reloading because the binary has changed. Take 1843 this opportunity to check. */ 1844 reopen_exec_file (); 1845 reread_symbols (); 1846 1847 if (arg == NULL) 1848 { 1849 char *parg; 1850 int count = 0; 1851 1852 parg = arg = get_exec_file (1); 1853 1854 /* Count how many \ " ' tab space there are in the name. */ 1855 while ((parg = strpbrk (parg, "\\\"'\t "))) 1856 { 1857 parg++; 1858 count++; 1859 } 1860 1861 if (count) 1862 { 1863 /* We need to quote this string so buildargv can pull it apart. */ 1864 char *temp = xmalloc (strlen (arg) + count + 1 ); 1865 char *ptemp = temp; 1866 char *prev; 1867 1868 make_cleanup (xfree, temp); 1869 1870 prev = parg = arg; 1871 while ((parg = strpbrk (parg, "\\\"'\t "))) 1872 { 1873 strncpy (ptemp, prev, parg - prev); 1874 ptemp += parg - prev; 1875 prev = parg++; 1876 *ptemp++ = '\\'; 1877 } 1878 strcpy (ptemp, prev); 1879 1880 arg = temp; 1881 } 1882 } 1883 1884 target_load (arg, from_tty); 1885 1886 /* After re-loading the executable, we don't really know which 1887 overlays are mapped any more. */ 1888 overlay_cache_invalid = 1; 1889 1890 do_cleanups (cleanup); 1891} 1892 1893/* This version of "load" should be usable for any target. Currently 1894 it is just used for remote targets, not inftarg.c or core files, 1895 on the theory that only in that case is it useful. 1896 1897 Avoiding xmodem and the like seems like a win (a) because we don't have 1898 to worry about finding it, and (b) On VMS, fork() is very slow and so 1899 we don't want to run a subprocess. On the other hand, I'm not sure how 1900 performance compares. */ 1901 1902static int validate_download = 0; 1903 1904/* Callback service function for generic_load (bfd_map_over_sections). */ 1905 1906static void 1907add_section_size_callback (bfd *abfd, asection *asec, void *data) 1908{ 1909 bfd_size_type *sum = data; 1910 1911 *sum += bfd_get_section_size (asec); 1912} 1913 1914/* Opaque data for load_section_callback. */ 1915struct load_section_data { 1916 CORE_ADDR load_offset; 1917 struct load_progress_data *progress_data; 1918 VEC(memory_write_request_s) *requests; 1919}; 1920 1921/* Opaque data for load_progress. */ 1922struct load_progress_data { 1923 /* Cumulative data. */ 1924 unsigned long write_count; 1925 unsigned long data_count; 1926 bfd_size_type total_size; 1927}; 1928 1929/* Opaque data for load_progress for a single section. */ 1930struct load_progress_section_data { 1931 struct load_progress_data *cumulative; 1932 1933 /* Per-section data. */ 1934 const char *section_name; 1935 ULONGEST section_sent; 1936 ULONGEST section_size; 1937 CORE_ADDR lma; 1938 gdb_byte *buffer; 1939}; 1940 1941/* Target write callback routine for progress reporting. */ 1942 1943static void 1944load_progress (ULONGEST bytes, void *untyped_arg) 1945{ 1946 struct load_progress_section_data *args = untyped_arg; 1947 struct load_progress_data *totals; 1948 1949 if (args == NULL) 1950 /* Writing padding data. No easy way to get at the cumulative 1951 stats, so just ignore this. */ 1952 return; 1953 1954 totals = args->cumulative; 1955 1956 if (bytes == 0 && args->section_sent == 0) 1957 { 1958 /* The write is just starting. Let the user know we've started 1959 this section. */ 1960 ui_out_message (current_uiout, 0, "Loading section %s, size %s lma %s\n", 1961 args->section_name, hex_string (args->section_size), 1962 paddress (target_gdbarch (), args->lma)); 1963 return; 1964 } 1965 1966 if (validate_download) 1967 { 1968 /* Broken memories and broken monitors manifest themselves here 1969 when bring new computers to life. This doubles already slow 1970 downloads. */ 1971 /* NOTE: cagney/1999-10-18: A more efficient implementation 1972 might add a verify_memory() method to the target vector and 1973 then use that. remote.c could implement that method using 1974 the ``qCRC'' packet. */ 1975 gdb_byte *check = xmalloc (bytes); 1976 struct cleanup *verify_cleanups = make_cleanup (xfree, check); 1977 1978 if (target_read_memory (args->lma, check, bytes) != 0) 1979 error (_("Download verify read failed at %s"), 1980 paddress (target_gdbarch (), args->lma)); 1981 if (memcmp (args->buffer, check, bytes) != 0) 1982 error (_("Download verify compare failed at %s"), 1983 paddress (target_gdbarch (), args->lma)); 1984 do_cleanups (verify_cleanups); 1985 } 1986 totals->data_count += bytes; 1987 args->lma += bytes; 1988 args->buffer += bytes; 1989 totals->write_count += 1; 1990 args->section_sent += bytes; 1991 if (check_quit_flag () 1992 || (deprecated_ui_load_progress_hook != NULL 1993 && deprecated_ui_load_progress_hook (args->section_name, 1994 args->section_sent))) 1995 error (_("Canceled the download")); 1996 1997 if (deprecated_show_load_progress != NULL) 1998 deprecated_show_load_progress (args->section_name, 1999 args->section_sent, 2000 args->section_size, 2001 totals->data_count, 2002 totals->total_size); 2003} 2004 2005/* Callback service function for generic_load (bfd_map_over_sections). */ 2006 2007static void 2008load_section_callback (bfd *abfd, asection *asec, void *data) 2009{ 2010 struct memory_write_request *new_request; 2011 struct load_section_data *args = data; 2012 struct load_progress_section_data *section_data; 2013 bfd_size_type size = bfd_get_section_size (asec); 2014 gdb_byte *buffer; 2015 const char *sect_name = bfd_get_section_name (abfd, asec); 2016 2017 if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0) 2018 return; 2019 2020 if (size == 0) 2021 return; 2022 2023 new_request = VEC_safe_push (memory_write_request_s, 2024 args->requests, NULL); 2025 memset (new_request, 0, sizeof (struct memory_write_request)); 2026 section_data = xcalloc (1, sizeof (struct load_progress_section_data)); 2027 new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset; 2028 new_request->end = new_request->begin + size; /* FIXME Should size 2029 be in instead? */ 2030 new_request->data = xmalloc (size); 2031 new_request->baton = section_data; 2032 2033 buffer = new_request->data; 2034 2035 section_data->cumulative = args->progress_data; 2036 section_data->section_name = sect_name; 2037 section_data->section_size = size; 2038 section_data->lma = new_request->begin; 2039 section_data->buffer = buffer; 2040 2041 bfd_get_section_contents (abfd, asec, buffer, 0, size); 2042} 2043 2044/* Clean up an entire memory request vector, including load 2045 data and progress records. */ 2046 2047static void 2048clear_memory_write_data (void *arg) 2049{ 2050 VEC(memory_write_request_s) **vec_p = arg; 2051 VEC(memory_write_request_s) *vec = *vec_p; 2052 int i; 2053 struct memory_write_request *mr; 2054 2055 for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i) 2056 { 2057 xfree (mr->data); 2058 xfree (mr->baton); 2059 } 2060 VEC_free (memory_write_request_s, vec); 2061} 2062 2063void 2064generic_load (const char *args, int from_tty) 2065{ 2066 bfd *loadfile_bfd; 2067 struct timeval start_time, end_time; 2068 char *filename; 2069 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0); 2070 struct load_section_data cbdata; 2071 struct load_progress_data total_progress; 2072 struct ui_out *uiout = current_uiout; 2073 2074 CORE_ADDR entry; 2075 char **argv; 2076 2077 memset (&cbdata, 0, sizeof (cbdata)); 2078 memset (&total_progress, 0, sizeof (total_progress)); 2079 cbdata.progress_data = &total_progress; 2080 2081 make_cleanup (clear_memory_write_data, &cbdata.requests); 2082 2083 if (args == NULL) 2084 error_no_arg (_("file to load")); 2085 2086 argv = gdb_buildargv (args); 2087 make_cleanup_freeargv (argv); 2088 2089 filename = tilde_expand (argv[0]); 2090 make_cleanup (xfree, filename); 2091 2092 if (argv[1] != NULL) 2093 { 2094 const char *endptr; 2095 2096 cbdata.load_offset = strtoulst (argv[1], &endptr, 0); 2097 2098 /* If the last word was not a valid number then 2099 treat it as a file name with spaces in. */ 2100 if (argv[1] == endptr) 2101 error (_("Invalid download offset:%s."), argv[1]); 2102 2103 if (argv[2] != NULL) 2104 error (_("Too many parameters.")); 2105 } 2106 2107 /* Open the file for loading. */ 2108 loadfile_bfd = gdb_bfd_open (filename, gnutarget, -1); 2109 if (loadfile_bfd == NULL) 2110 { 2111 perror_with_name (filename); 2112 return; 2113 } 2114 2115 make_cleanup_bfd_unref (loadfile_bfd); 2116 2117 if (!bfd_check_format (loadfile_bfd, bfd_object)) 2118 { 2119 error (_("\"%s\" is not an object file: %s"), filename, 2120 bfd_errmsg (bfd_get_error ())); 2121 } 2122 2123 bfd_map_over_sections (loadfile_bfd, add_section_size_callback, 2124 (void *) &total_progress.total_size); 2125 2126 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata); 2127 2128 gettimeofday (&start_time, NULL); 2129 2130 if (target_write_memory_blocks (cbdata.requests, flash_discard, 2131 load_progress) != 0) 2132 error (_("Load failed")); 2133 2134 gettimeofday (&end_time, NULL); 2135 2136 entry = bfd_get_start_address (loadfile_bfd); 2137 entry = gdbarch_addr_bits_remove (target_gdbarch (), entry); 2138 ui_out_text (uiout, "Start address "); 2139 ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch (), entry)); 2140 ui_out_text (uiout, ", load size "); 2141 ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count); 2142 ui_out_text (uiout, "\n"); 2143 /* We were doing this in remote-mips.c, I suspect it is right 2144 for other targets too. */ 2145 regcache_write_pc (get_current_regcache (), entry); 2146 2147 /* Reset breakpoints, now that we have changed the load image. For 2148 instance, breakpoints may have been set (or reset, by 2149 post_create_inferior) while connected to the target but before we 2150 loaded the program. In that case, the prologue analyzer could 2151 have read instructions from the target to find the right 2152 breakpoint locations. Loading has changed the contents of that 2153 memory. */ 2154 2155 breakpoint_re_set (); 2156 2157 /* FIXME: are we supposed to call symbol_file_add or not? According 2158 to a comment from remote-mips.c (where a call to symbol_file_add 2159 was commented out), making the call confuses GDB if more than one 2160 file is loaded in. Some targets do (e.g., remote-vx.c) but 2161 others don't (or didn't - perhaps they have all been deleted). */ 2162 2163 print_transfer_performance (gdb_stdout, total_progress.data_count, 2164 total_progress.write_count, 2165 &start_time, &end_time); 2166 2167 do_cleanups (old_cleanups); 2168} 2169 2170/* Report how fast the transfer went. */ 2171 2172void 2173print_transfer_performance (struct ui_file *stream, 2174 unsigned long data_count, 2175 unsigned long write_count, 2176 const struct timeval *start_time, 2177 const struct timeval *end_time) 2178{ 2179 ULONGEST time_count; 2180 struct ui_out *uiout = current_uiout; 2181 2182 /* Compute the elapsed time in milliseconds, as a tradeoff between 2183 accuracy and overflow. */ 2184 time_count = (end_time->tv_sec - start_time->tv_sec) * 1000; 2185 time_count += (end_time->tv_usec - start_time->tv_usec) / 1000; 2186 2187 ui_out_text (uiout, "Transfer rate: "); 2188 if (time_count > 0) 2189 { 2190 unsigned long rate = ((ULONGEST) data_count * 1000) / time_count; 2191 2192 if (ui_out_is_mi_like_p (uiout)) 2193 { 2194 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8); 2195 ui_out_text (uiout, " bits/sec"); 2196 } 2197 else if (rate < 1024) 2198 { 2199 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate); 2200 ui_out_text (uiout, " bytes/sec"); 2201 } 2202 else 2203 { 2204 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024); 2205 ui_out_text (uiout, " KB/sec"); 2206 } 2207 } 2208 else 2209 { 2210 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8)); 2211 ui_out_text (uiout, " bits in <1 sec"); 2212 } 2213 if (write_count > 0) 2214 { 2215 ui_out_text (uiout, ", "); 2216 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count); 2217 ui_out_text (uiout, " bytes/write"); 2218 } 2219 ui_out_text (uiout, ".\n"); 2220} 2221 2222/* This function allows the addition of incrementally linked object files. 2223 It does not modify any state in the target, only in the debugger. */ 2224/* Note: ezannoni 2000-04-13 This function/command used to have a 2225 special case syntax for the rombug target (Rombug is the boot 2226 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the 2227 rombug case, the user doesn't need to supply a text address, 2228 instead a call to target_link() (in target.c) would supply the 2229 value to use. We are now discontinuing this type of ad hoc syntax. */ 2230 2231static void 2232add_symbol_file_command (char *args, int from_tty) 2233{ 2234 struct gdbarch *gdbarch = get_current_arch (); 2235 char *filename = NULL; 2236 int flags = OBJF_USERLOADED | OBJF_SHARED; 2237 char *arg; 2238 int section_index = 0; 2239 int argcnt = 0; 2240 int sec_num = 0; 2241 int i; 2242 int expecting_sec_name = 0; 2243 int expecting_sec_addr = 0; 2244 char **argv; 2245 struct objfile *objf; 2246 2247 struct sect_opt 2248 { 2249 char *name; 2250 char *value; 2251 }; 2252 2253 struct section_addr_info *section_addrs; 2254 struct sect_opt *sect_opts = NULL; 2255 size_t num_sect_opts = 0; 2256 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL); 2257 2258 num_sect_opts = 16; 2259 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts 2260 * sizeof (struct sect_opt)); 2261 2262 dont_repeat (); 2263 2264 if (args == NULL) 2265 error (_("add-symbol-file takes a file name and an address")); 2266 2267 argv = gdb_buildargv (args); 2268 make_cleanup_freeargv (argv); 2269 2270 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt]) 2271 { 2272 /* Process the argument. */ 2273 if (argcnt == 0) 2274 { 2275 /* The first argument is the file name. */ 2276 filename = tilde_expand (arg); 2277 make_cleanup (xfree, filename); 2278 } 2279 else if (argcnt == 1) 2280 { 2281 /* The second argument is always the text address at which 2282 to load the program. */ 2283 sect_opts[section_index].name = ".text"; 2284 sect_opts[section_index].value = arg; 2285 if (++section_index >= num_sect_opts) 2286 { 2287 num_sect_opts *= 2; 2288 sect_opts = ((struct sect_opt *) 2289 xrealloc (sect_opts, 2290 num_sect_opts 2291 * sizeof (struct sect_opt))); 2292 } 2293 } 2294 else 2295 { 2296 /* It's an option (starting with '-') or it's an argument 2297 to an option. */ 2298 if (expecting_sec_name) 2299 { 2300 sect_opts[section_index].name = arg; 2301 expecting_sec_name = 0; 2302 } 2303 else if (expecting_sec_addr) 2304 { 2305 sect_opts[section_index].value = arg; 2306 expecting_sec_addr = 0; 2307 if (++section_index >= num_sect_opts) 2308 { 2309 num_sect_opts *= 2; 2310 sect_opts = ((struct sect_opt *) 2311 xrealloc (sect_opts, 2312 num_sect_opts 2313 * sizeof (struct sect_opt))); 2314 } 2315 } 2316 else if (strcmp (arg, "-readnow") == 0) 2317 flags |= OBJF_READNOW; 2318 else if (strcmp (arg, "-s") == 0) 2319 { 2320 expecting_sec_name = 1; 2321 expecting_sec_addr = 1; 2322 } 2323 else 2324 error (_("USAGE: add-symbol-file <filename> <textaddress>" 2325 " [-readnow] [-s <secname> <addr>]*")); 2326 } 2327 } 2328 2329 /* This command takes at least two arguments. The first one is a 2330 filename, and the second is the address where this file has been 2331 loaded. Abort now if this address hasn't been provided by the 2332 user. */ 2333 if (section_index < 1) 2334 error (_("The address where %s has been loaded is missing"), filename); 2335 2336 /* Print the prompt for the query below. And save the arguments into 2337 a sect_addr_info structure to be passed around to other 2338 functions. We have to split this up into separate print 2339 statements because hex_string returns a local static 2340 string. */ 2341 2342 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename); 2343 section_addrs = alloc_section_addr_info (section_index); 2344 make_cleanup (xfree, section_addrs); 2345 for (i = 0; i < section_index; i++) 2346 { 2347 CORE_ADDR addr; 2348 char *val = sect_opts[i].value; 2349 char *sec = sect_opts[i].name; 2350 2351 addr = parse_and_eval_address (val); 2352 2353 /* Here we store the section offsets in the order they were 2354 entered on the command line. */ 2355 section_addrs->other[sec_num].name = sec; 2356 section_addrs->other[sec_num].addr = addr; 2357 printf_unfiltered ("\t%s_addr = %s\n", sec, 2358 paddress (gdbarch, addr)); 2359 sec_num++; 2360 2361 /* The object's sections are initialized when a 2362 call is made to build_objfile_section_table (objfile). 2363 This happens in reread_symbols. 2364 At this point, we don't know what file type this is, 2365 so we can't determine what section names are valid. */ 2366 } 2367 section_addrs->num_sections = sec_num; 2368 2369 if (from_tty && (!query ("%s", ""))) 2370 error (_("Not confirmed.")); 2371 2372 objf = symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0, 2373 section_addrs, flags); 2374 2375 add_target_sections_of_objfile (objf); 2376 2377 /* Getting new symbols may change our opinion about what is 2378 frameless. */ 2379 reinit_frame_cache (); 2380 do_cleanups (my_cleanups); 2381} 2382 2383 2384/* This function removes a symbol file that was added via add-symbol-file. */ 2385 2386static void 2387remove_symbol_file_command (char *args, int from_tty) 2388{ 2389 char **argv; 2390 struct objfile *objf = NULL; 2391 struct cleanup *my_cleanups; 2392 struct program_space *pspace = current_program_space; 2393 struct gdbarch *gdbarch = get_current_arch (); 2394 2395 dont_repeat (); 2396 2397 if (args == NULL) 2398 error (_("remove-symbol-file: no symbol file provided")); 2399 2400 my_cleanups = make_cleanup (null_cleanup, NULL); 2401 2402 argv = gdb_buildargv (args); 2403 2404 if (strcmp (argv[0], "-a") == 0) 2405 { 2406 /* Interpret the next argument as an address. */ 2407 CORE_ADDR addr; 2408 2409 if (argv[1] == NULL) 2410 error (_("Missing address argument")); 2411 2412 if (argv[2] != NULL) 2413 error (_("Junk after %s"), argv[1]); 2414 2415 addr = parse_and_eval_address (argv[1]); 2416 2417 ALL_OBJFILES (objf) 2418 { 2419 if ((objf->flags & OBJF_USERLOADED) != 0 2420 && (objf->flags & OBJF_SHARED) != 0 2421 && objf->pspace == pspace && is_addr_in_objfile (addr, objf)) 2422 break; 2423 } 2424 } 2425 else if (argv[0] != NULL) 2426 { 2427 /* Interpret the current argument as a file name. */ 2428 char *filename; 2429 2430 if (argv[1] != NULL) 2431 error (_("Junk after %s"), argv[0]); 2432 2433 filename = tilde_expand (argv[0]); 2434 make_cleanup (xfree, filename); 2435 2436 ALL_OBJFILES (objf) 2437 { 2438 if ((objf->flags & OBJF_USERLOADED) != 0 2439 && (objf->flags & OBJF_SHARED) != 0 2440 && objf->pspace == pspace 2441 && filename_cmp (filename, objfile_name (objf)) == 0) 2442 break; 2443 } 2444 } 2445 2446 if (objf == NULL) 2447 error (_("No symbol file found")); 2448 2449 if (from_tty 2450 && !query (_("Remove symbol table from file \"%s\"? "), 2451 objfile_name (objf))) 2452 error (_("Not confirmed.")); 2453 2454 free_objfile (objf); 2455 clear_symtab_users (0); 2456 2457 do_cleanups (my_cleanups); 2458} 2459 2460typedef struct objfile *objfilep; 2461 2462DEF_VEC_P (objfilep); 2463 2464/* Re-read symbols if a symbol-file has changed. */ 2465 2466void 2467reread_symbols (void) 2468{ 2469 struct objfile *objfile; 2470 long new_modtime; 2471 struct stat new_statbuf; 2472 int res; 2473 VEC (objfilep) *new_objfiles = NULL; 2474 struct cleanup *all_cleanups; 2475 2476 all_cleanups = make_cleanup (VEC_cleanup (objfilep), &new_objfiles); 2477 2478 /* With the addition of shared libraries, this should be modified, 2479 the load time should be saved in the partial symbol tables, since 2480 different tables may come from different source files. FIXME. 2481 This routine should then walk down each partial symbol table 2482 and see if the symbol table that it originates from has been changed. */ 2483 2484 for (objfile = object_files; objfile; objfile = objfile->next) 2485 { 2486 if (objfile->obfd == NULL) 2487 continue; 2488 2489 /* Separate debug objfiles are handled in the main objfile. */ 2490 if (objfile->separate_debug_objfile_backlink) 2491 continue; 2492 2493 /* If this object is from an archive (what you usually create with 2494 `ar', often called a `static library' on most systems, though 2495 a `shared library' on AIX is also an archive), then you should 2496 stat on the archive name, not member name. */ 2497 if (objfile->obfd->my_archive) 2498 res = stat (objfile->obfd->my_archive->filename, &new_statbuf); 2499 else 2500 res = stat (objfile_name (objfile), &new_statbuf); 2501 if (res != 0) 2502 { 2503 /* FIXME, should use print_sys_errmsg but it's not filtered. */ 2504 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"), 2505 objfile_name (objfile)); 2506 continue; 2507 } 2508 new_modtime = new_statbuf.st_mtime; 2509 if (new_modtime != objfile->mtime) 2510 { 2511 struct cleanup *old_cleanups; 2512 struct section_offsets *offsets; 2513 int num_offsets; 2514 char *original_name; 2515 2516 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"), 2517 objfile_name (objfile)); 2518 2519 /* There are various functions like symbol_file_add, 2520 symfile_bfd_open, syms_from_objfile, etc., which might 2521 appear to do what we want. But they have various other 2522 effects which we *don't* want. So we just do stuff 2523 ourselves. We don't worry about mapped files (for one thing, 2524 any mapped file will be out of date). */ 2525 2526 /* If we get an error, blow away this objfile (not sure if 2527 that is the correct response for things like shared 2528 libraries). */ 2529 old_cleanups = make_cleanup_free_objfile (objfile); 2530 /* We need to do this whenever any symbols go away. */ 2531 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/); 2532 2533 if (exec_bfd != NULL 2534 && filename_cmp (bfd_get_filename (objfile->obfd), 2535 bfd_get_filename (exec_bfd)) == 0) 2536 { 2537 /* Reload EXEC_BFD without asking anything. */ 2538 2539 exec_file_attach (bfd_get_filename (objfile->obfd), 0); 2540 } 2541 2542 /* Keep the calls order approx. the same as in free_objfile. */ 2543 2544 /* Free the separate debug objfiles. It will be 2545 automatically recreated by sym_read. */ 2546 free_objfile_separate_debug (objfile); 2547 2548 /* Remove any references to this objfile in the global 2549 value lists. */ 2550 preserve_values (objfile); 2551 2552 /* Nuke all the state that we will re-read. Much of the following 2553 code which sets things to NULL really is necessary to tell 2554 other parts of GDB that there is nothing currently there. 2555 2556 Try to keep the freeing order compatible with free_objfile. */ 2557 2558 if (objfile->sf != NULL) 2559 { 2560 (*objfile->sf->sym_finish) (objfile); 2561 } 2562 2563 clear_objfile_data (objfile); 2564 2565 /* Clean up any state BFD has sitting around. */ 2566 { 2567 struct bfd *obfd = objfile->obfd; 2568 char *obfd_filename; 2569 2570 obfd_filename = bfd_get_filename (objfile->obfd); 2571 /* Open the new BFD before freeing the old one, so that 2572 the filename remains live. */ 2573 objfile->obfd = gdb_bfd_open (obfd_filename, gnutarget, -1); 2574 if (objfile->obfd == NULL) 2575 { 2576 /* We have to make a cleanup and error here, rather 2577 than erroring later, because once we unref OBFD, 2578 OBFD_FILENAME will be freed. */ 2579 make_cleanup_bfd_unref (obfd); 2580 error (_("Can't open %s to read symbols."), obfd_filename); 2581 } 2582 gdb_bfd_unref (obfd); 2583 } 2584 2585 original_name = xstrdup (objfile->original_name); 2586 make_cleanup (xfree, original_name); 2587 2588 /* bfd_openr sets cacheable to true, which is what we want. */ 2589 if (!bfd_check_format (objfile->obfd, bfd_object)) 2590 error (_("Can't read symbols from %s: %s."), objfile_name (objfile), 2591 bfd_errmsg (bfd_get_error ())); 2592 2593 /* Save the offsets, we will nuke them with the rest of the 2594 objfile_obstack. */ 2595 num_offsets = objfile->num_sections; 2596 offsets = ((struct section_offsets *) 2597 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets))); 2598 memcpy (offsets, objfile->section_offsets, 2599 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2600 2601 /* FIXME: Do we have to free a whole linked list, or is this 2602 enough? */ 2603 if (objfile->global_psymbols.list) 2604 xfree (objfile->global_psymbols.list); 2605 memset (&objfile->global_psymbols, 0, 2606 sizeof (objfile->global_psymbols)); 2607 if (objfile->static_psymbols.list) 2608 xfree (objfile->static_psymbols.list); 2609 memset (&objfile->static_psymbols, 0, 2610 sizeof (objfile->static_psymbols)); 2611 2612 /* Free the obstacks for non-reusable objfiles. */ 2613 psymbol_bcache_free (objfile->psymbol_cache); 2614 objfile->psymbol_cache = psymbol_bcache_init (); 2615 obstack_free (&objfile->objfile_obstack, 0); 2616 objfile->sections = NULL; 2617 objfile->compunit_symtabs = NULL; 2618 objfile->psymtabs = NULL; 2619 objfile->psymtabs_addrmap = NULL; 2620 objfile->free_psymtabs = NULL; 2621 objfile->template_symbols = NULL; 2622 2623 /* obstack_init also initializes the obstack so it is 2624 empty. We could use obstack_specify_allocation but 2625 gdb_obstack.h specifies the alloc/dealloc functions. */ 2626 obstack_init (&objfile->objfile_obstack); 2627 2628 /* set_objfile_per_bfd potentially allocates the per-bfd 2629 data on the objfile's obstack (if sharing data across 2630 multiple users is not possible), so it's important to 2631 do it *after* the obstack has been initialized. */ 2632 set_objfile_per_bfd (objfile); 2633 2634 objfile->original_name = obstack_copy0 (&objfile->objfile_obstack, 2635 original_name, 2636 strlen (original_name)); 2637 2638 /* Reset the sym_fns pointer. The ELF reader can change it 2639 based on whether .gdb_index is present, and we need it to 2640 start over. PR symtab/15885 */ 2641 objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd)); 2642 2643 build_objfile_section_table (objfile); 2644 terminate_minimal_symbol_table (objfile); 2645 2646 /* We use the same section offsets as from last time. I'm not 2647 sure whether that is always correct for shared libraries. */ 2648 objfile->section_offsets = (struct section_offsets *) 2649 obstack_alloc (&objfile->objfile_obstack, 2650 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2651 memcpy (objfile->section_offsets, offsets, 2652 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2653 objfile->num_sections = num_offsets; 2654 2655 /* What the hell is sym_new_init for, anyway? The concept of 2656 distinguishing between the main file and additional files 2657 in this way seems rather dubious. */ 2658 if (objfile == symfile_objfile) 2659 { 2660 (*objfile->sf->sym_new_init) (objfile); 2661 } 2662 2663 (*objfile->sf->sym_init) (objfile); 2664 clear_complaints (&symfile_complaints, 1, 1); 2665 2666 objfile->flags &= ~OBJF_PSYMTABS_READ; 2667 read_symbols (objfile, 0); 2668 2669 if (!objfile_has_symbols (objfile)) 2670 { 2671 wrap_here (""); 2672 printf_unfiltered (_("(no debugging symbols found)\n")); 2673 wrap_here (""); 2674 } 2675 2676 /* We're done reading the symbol file; finish off complaints. */ 2677 clear_complaints (&symfile_complaints, 0, 1); 2678 2679 /* Getting new symbols may change our opinion about what is 2680 frameless. */ 2681 2682 reinit_frame_cache (); 2683 2684 /* Discard cleanups as symbol reading was successful. */ 2685 discard_cleanups (old_cleanups); 2686 2687 /* If the mtime has changed between the time we set new_modtime 2688 and now, we *want* this to be out of date, so don't call stat 2689 again now. */ 2690 objfile->mtime = new_modtime; 2691 init_entry_point_info (objfile); 2692 2693 VEC_safe_push (objfilep, new_objfiles, objfile); 2694 } 2695 } 2696 2697 if (new_objfiles) 2698 { 2699 int ix; 2700 2701 /* Notify objfiles that we've modified objfile sections. */ 2702 objfiles_changed (); 2703 2704 clear_symtab_users (0); 2705 2706 /* clear_objfile_data for each objfile was called before freeing it and 2707 observer_notify_new_objfile (NULL) has been called by 2708 clear_symtab_users above. Notify the new files now. */ 2709 for (ix = 0; VEC_iterate (objfilep, new_objfiles, ix, objfile); ix++) 2710 observer_notify_new_objfile (objfile); 2711 2712 /* At least one objfile has changed, so we can consider that 2713 the executable we're debugging has changed too. */ 2714 observer_notify_executable_changed (); 2715 } 2716 2717 do_cleanups (all_cleanups); 2718} 2719 2720 2721typedef struct 2722{ 2723 char *ext; 2724 enum language lang; 2725} 2726filename_language; 2727 2728static filename_language *filename_language_table; 2729static int fl_table_size, fl_table_next; 2730 2731static void 2732add_filename_language (char *ext, enum language lang) 2733{ 2734 if (fl_table_next >= fl_table_size) 2735 { 2736 fl_table_size += 10; 2737 filename_language_table = 2738 xrealloc (filename_language_table, 2739 fl_table_size * sizeof (*filename_language_table)); 2740 } 2741 2742 filename_language_table[fl_table_next].ext = xstrdup (ext); 2743 filename_language_table[fl_table_next].lang = lang; 2744 fl_table_next++; 2745} 2746 2747static char *ext_args; 2748static void 2749show_ext_args (struct ui_file *file, int from_tty, 2750 struct cmd_list_element *c, const char *value) 2751{ 2752 fprintf_filtered (file, 2753 _("Mapping between filename extension " 2754 "and source language is \"%s\".\n"), 2755 value); 2756} 2757 2758static void 2759set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e) 2760{ 2761 int i; 2762 char *cp = ext_args; 2763 enum language lang; 2764 2765 /* First arg is filename extension, starting with '.' */ 2766 if (*cp != '.') 2767 error (_("'%s': Filename extension must begin with '.'"), ext_args); 2768 2769 /* Find end of first arg. */ 2770 while (*cp && !isspace (*cp)) 2771 cp++; 2772 2773 if (*cp == '\0') 2774 error (_("'%s': two arguments required -- " 2775 "filename extension and language"), 2776 ext_args); 2777 2778 /* Null-terminate first arg. */ 2779 *cp++ = '\0'; 2780 2781 /* Find beginning of second arg, which should be a source language. */ 2782 cp = skip_spaces (cp); 2783 2784 if (*cp == '\0') 2785 error (_("'%s': two arguments required -- " 2786 "filename extension and language"), 2787 ext_args); 2788 2789 /* Lookup the language from among those we know. */ 2790 lang = language_enum (cp); 2791 2792 /* Now lookup the filename extension: do we already know it? */ 2793 for (i = 0; i < fl_table_next; i++) 2794 if (0 == strcmp (ext_args, filename_language_table[i].ext)) 2795 break; 2796 2797 if (i >= fl_table_next) 2798 { 2799 /* New file extension. */ 2800 add_filename_language (ext_args, lang); 2801 } 2802 else 2803 { 2804 /* Redefining a previously known filename extension. */ 2805 2806 /* if (from_tty) */ 2807 /* query ("Really make files of type %s '%s'?", */ 2808 /* ext_args, language_str (lang)); */ 2809 2810 xfree (filename_language_table[i].ext); 2811 filename_language_table[i].ext = xstrdup (ext_args); 2812 filename_language_table[i].lang = lang; 2813 } 2814} 2815 2816static void 2817info_ext_lang_command (char *args, int from_tty) 2818{ 2819 int i; 2820 2821 printf_filtered (_("Filename extensions and the languages they represent:")); 2822 printf_filtered ("\n\n"); 2823 for (i = 0; i < fl_table_next; i++) 2824 printf_filtered ("\t%s\t- %s\n", 2825 filename_language_table[i].ext, 2826 language_str (filename_language_table[i].lang)); 2827} 2828 2829static void 2830init_filename_language_table (void) 2831{ 2832 if (fl_table_size == 0) /* Protect against repetition. */ 2833 { 2834 fl_table_size = 20; 2835 fl_table_next = 0; 2836 filename_language_table = 2837 xmalloc (fl_table_size * sizeof (*filename_language_table)); 2838 add_filename_language (".c", language_c); 2839 add_filename_language (".d", language_d); 2840 add_filename_language (".C", language_cplus); 2841 add_filename_language (".cc", language_cplus); 2842 add_filename_language (".cp", language_cplus); 2843 add_filename_language (".cpp", language_cplus); 2844 add_filename_language (".cxx", language_cplus); 2845 add_filename_language (".c++", language_cplus); 2846 add_filename_language (".java", language_java); 2847 add_filename_language (".class", language_java); 2848 add_filename_language (".m", language_objc); 2849 add_filename_language (".f", language_fortran); 2850 add_filename_language (".F", language_fortran); 2851 add_filename_language (".for", language_fortran); 2852 add_filename_language (".FOR", language_fortran); 2853 add_filename_language (".ftn", language_fortran); 2854 add_filename_language (".FTN", language_fortran); 2855 add_filename_language (".fpp", language_fortran); 2856 add_filename_language (".FPP", language_fortran); 2857 add_filename_language (".f90", language_fortran); 2858 add_filename_language (".F90", language_fortran); 2859 add_filename_language (".f95", language_fortran); 2860 add_filename_language (".F95", language_fortran); 2861 add_filename_language (".f03", language_fortran); 2862 add_filename_language (".F03", language_fortran); 2863 add_filename_language (".f08", language_fortran); 2864 add_filename_language (".F08", language_fortran); 2865 add_filename_language (".s", language_asm); 2866 add_filename_language (".sx", language_asm); 2867 add_filename_language (".S", language_asm); 2868 add_filename_language (".pas", language_pascal); 2869 add_filename_language (".p", language_pascal); 2870 add_filename_language (".pp", language_pascal); 2871 add_filename_language (".adb", language_ada); 2872 add_filename_language (".ads", language_ada); 2873 add_filename_language (".a", language_ada); 2874 add_filename_language (".ada", language_ada); 2875 add_filename_language (".dg", language_ada); 2876 } 2877} 2878 2879enum language 2880deduce_language_from_filename (const char *filename) 2881{ 2882 int i; 2883 char *cp; 2884 2885 if (filename != NULL) 2886 if ((cp = strrchr (filename, '.')) != NULL) 2887 for (i = 0; i < fl_table_next; i++) 2888 if (strcmp (cp, filename_language_table[i].ext) == 0) 2889 return filename_language_table[i].lang; 2890 2891 return language_unknown; 2892} 2893 2894/* Allocate and initialize a new symbol table. 2895 CUST is from the result of allocate_compunit_symtab. */ 2896 2897struct symtab * 2898allocate_symtab (struct compunit_symtab *cust, const char *filename) 2899{ 2900 struct objfile *objfile = cust->objfile; 2901 struct symtab *symtab 2902 = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab); 2903 2904 symtab->filename = bcache (filename, strlen (filename) + 1, 2905 objfile->per_bfd->filename_cache); 2906 symtab->fullname = NULL; 2907 symtab->language = deduce_language_from_filename (filename); 2908 2909 /* This can be very verbose with lots of headers. 2910 Only print at higher debug levels. */ 2911 if (symtab_create_debug >= 2) 2912 { 2913 /* Be a bit clever with debugging messages, and don't print objfile 2914 every time, only when it changes. */ 2915 static char *last_objfile_name = NULL; 2916 2917 if (last_objfile_name == NULL 2918 || strcmp (last_objfile_name, objfile_name (objfile)) != 0) 2919 { 2920 xfree (last_objfile_name); 2921 last_objfile_name = xstrdup (objfile_name (objfile)); 2922 fprintf_unfiltered (gdb_stdlog, 2923 "Creating one or more symtabs for objfile %s ...\n", 2924 last_objfile_name); 2925 } 2926 fprintf_unfiltered (gdb_stdlog, 2927 "Created symtab %s for module %s.\n", 2928 host_address_to_string (symtab), filename); 2929 } 2930 2931 /* Add it to CUST's list of symtabs. */ 2932 if (cust->filetabs == NULL) 2933 { 2934 cust->filetabs = symtab; 2935 cust->last_filetab = symtab; 2936 } 2937 else 2938 { 2939 cust->last_filetab->next = symtab; 2940 cust->last_filetab = symtab; 2941 } 2942 2943 /* Backlink to the containing compunit symtab. */ 2944 symtab->compunit_symtab = cust; 2945 2946 return symtab; 2947} 2948 2949/* Allocate and initialize a new compunit. 2950 NAME is the name of the main source file, if there is one, or some 2951 descriptive text if there are no source files. */ 2952 2953struct compunit_symtab * 2954allocate_compunit_symtab (struct objfile *objfile, const char *name) 2955{ 2956 struct compunit_symtab *cu = OBSTACK_ZALLOC (&objfile->objfile_obstack, 2957 struct compunit_symtab); 2958 const char *saved_name; 2959 2960 cu->objfile = objfile; 2961 2962 /* The name we record here is only for display/debugging purposes. 2963 Just save the basename to avoid path issues (too long for display, 2964 relative vs absolute, etc.). */ 2965 saved_name = lbasename (name); 2966 cu->name = obstack_copy0 (&objfile->objfile_obstack, saved_name, 2967 strlen (saved_name)); 2968 2969 COMPUNIT_DEBUGFORMAT (cu) = "unknown"; 2970 2971 if (symtab_create_debug) 2972 { 2973 fprintf_unfiltered (gdb_stdlog, 2974 "Created compunit symtab %s for %s.\n", 2975 host_address_to_string (cu), 2976 cu->name); 2977 } 2978 2979 return cu; 2980} 2981 2982/* Hook CU to the objfile it comes from. */ 2983 2984void 2985add_compunit_symtab_to_objfile (struct compunit_symtab *cu) 2986{ 2987 cu->next = cu->objfile->compunit_symtabs; 2988 cu->objfile->compunit_symtabs = cu; 2989} 2990 2991 2992/* Reset all data structures in gdb which may contain references to symbol 2993 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */ 2994 2995void 2996clear_symtab_users (int add_flags) 2997{ 2998 /* Someday, we should do better than this, by only blowing away 2999 the things that really need to be blown. */ 3000 3001 /* Clear the "current" symtab first, because it is no longer valid. 3002 breakpoint_re_set may try to access the current symtab. */ 3003 clear_current_source_symtab_and_line (); 3004 3005 clear_displays (); 3006 clear_last_displayed_sal (); 3007 clear_pc_function_cache (); 3008 observer_notify_new_objfile (NULL); 3009 3010 /* Clear globals which might have pointed into a removed objfile. 3011 FIXME: It's not clear which of these are supposed to persist 3012 between expressions and which ought to be reset each time. */ 3013 expression_context_block = NULL; 3014 innermost_block = NULL; 3015 3016 /* Varobj may refer to old symbols, perform a cleanup. */ 3017 varobj_invalidate (); 3018 3019 /* Now that the various caches have been cleared, we can re_set 3020 our breakpoints without risking it using stale data. */ 3021 if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0) 3022 breakpoint_re_set (); 3023} 3024 3025static void 3026clear_symtab_users_cleanup (void *ignore) 3027{ 3028 clear_symtab_users (0); 3029} 3030 3031/* OVERLAYS: 3032 The following code implements an abstraction for debugging overlay sections. 3033 3034 The target model is as follows: 3035 1) The gnu linker will permit multiple sections to be mapped into the 3036 same VMA, each with its own unique LMA (or load address). 3037 2) It is assumed that some runtime mechanism exists for mapping the 3038 sections, one by one, from the load address into the VMA address. 3039 3) This code provides a mechanism for gdb to keep track of which 3040 sections should be considered to be mapped from the VMA to the LMA. 3041 This information is used for symbol lookup, and memory read/write. 3042 For instance, if a section has been mapped then its contents 3043 should be read from the VMA, otherwise from the LMA. 3044 3045 Two levels of debugger support for overlays are available. One is 3046 "manual", in which the debugger relies on the user to tell it which 3047 overlays are currently mapped. This level of support is 3048 implemented entirely in the core debugger, and the information about 3049 whether a section is mapped is kept in the objfile->obj_section table. 3050 3051 The second level of support is "automatic", and is only available if 3052 the target-specific code provides functionality to read the target's 3053 overlay mapping table, and translate its contents for the debugger 3054 (by updating the mapped state information in the obj_section tables). 3055 3056 The interface is as follows: 3057 User commands: 3058 overlay map <name> -- tell gdb to consider this section mapped 3059 overlay unmap <name> -- tell gdb to consider this section unmapped 3060 overlay list -- list the sections that GDB thinks are mapped 3061 overlay read-target -- get the target's state of what's mapped 3062 overlay off/manual/auto -- set overlay debugging state 3063 Functional interface: 3064 find_pc_mapped_section(pc): if the pc is in the range of a mapped 3065 section, return that section. 3066 find_pc_overlay(pc): find any overlay section that contains 3067 the pc, either in its VMA or its LMA 3068 section_is_mapped(sect): true if overlay is marked as mapped 3069 section_is_overlay(sect): true if section's VMA != LMA 3070 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA 3071 pc_in_unmapped_range(...): true if pc belongs to section's LMA 3072 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap 3073 overlay_mapped_address(...): map an address from section's LMA to VMA 3074 overlay_unmapped_address(...): map an address from section's VMA to LMA 3075 symbol_overlayed_address(...): Return a "current" address for symbol: 3076 either in VMA or LMA depending on whether 3077 the symbol's section is currently mapped. */ 3078 3079/* Overlay debugging state: */ 3080 3081enum overlay_debugging_state overlay_debugging = ovly_off; 3082int overlay_cache_invalid = 0; /* True if need to refresh mapped state. */ 3083 3084/* Function: section_is_overlay (SECTION) 3085 Returns true if SECTION has VMA not equal to LMA, ie. 3086 SECTION is loaded at an address different from where it will "run". */ 3087 3088int 3089section_is_overlay (struct obj_section *section) 3090{ 3091 if (overlay_debugging && section) 3092 { 3093 bfd *abfd = section->objfile->obfd; 3094 asection *bfd_section = section->the_bfd_section; 3095 3096 if (bfd_section_lma (abfd, bfd_section) != 0 3097 && bfd_section_lma (abfd, bfd_section) 3098 != bfd_section_vma (abfd, bfd_section)) 3099 return 1; 3100 } 3101 3102 return 0; 3103} 3104 3105/* Function: overlay_invalidate_all (void) 3106 Invalidate the mapped state of all overlay sections (mark it as stale). */ 3107 3108static void 3109overlay_invalidate_all (void) 3110{ 3111 struct objfile *objfile; 3112 struct obj_section *sect; 3113 3114 ALL_OBJSECTIONS (objfile, sect) 3115 if (section_is_overlay (sect)) 3116 sect->ovly_mapped = -1; 3117} 3118 3119/* Function: section_is_mapped (SECTION) 3120 Returns true if section is an overlay, and is currently mapped. 3121 3122 Access to the ovly_mapped flag is restricted to this function, so 3123 that we can do automatic update. If the global flag 3124 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call 3125 overlay_invalidate_all. If the mapped state of the particular 3126 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */ 3127 3128int 3129section_is_mapped (struct obj_section *osect) 3130{ 3131 struct gdbarch *gdbarch; 3132 3133 if (osect == 0 || !section_is_overlay (osect)) 3134 return 0; 3135 3136 switch (overlay_debugging) 3137 { 3138 default: 3139 case ovly_off: 3140 return 0; /* overlay debugging off */ 3141 case ovly_auto: /* overlay debugging automatic */ 3142 /* Unles there is a gdbarch_overlay_update function, 3143 there's really nothing useful to do here (can't really go auto). */ 3144 gdbarch = get_objfile_arch (osect->objfile); 3145 if (gdbarch_overlay_update_p (gdbarch)) 3146 { 3147 if (overlay_cache_invalid) 3148 { 3149 overlay_invalidate_all (); 3150 overlay_cache_invalid = 0; 3151 } 3152 if (osect->ovly_mapped == -1) 3153 gdbarch_overlay_update (gdbarch, osect); 3154 } 3155 /* fall thru to manual case */ 3156 case ovly_on: /* overlay debugging manual */ 3157 return osect->ovly_mapped == 1; 3158 } 3159} 3160 3161/* Function: pc_in_unmapped_range 3162 If PC falls into the lma range of SECTION, return true, else false. */ 3163 3164CORE_ADDR 3165pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section) 3166{ 3167 if (section_is_overlay (section)) 3168 { 3169 bfd *abfd = section->objfile->obfd; 3170 asection *bfd_section = section->the_bfd_section; 3171 3172 /* We assume the LMA is relocated by the same offset as the VMA. */ 3173 bfd_vma size = bfd_get_section_size (bfd_section); 3174 CORE_ADDR offset = obj_section_offset (section); 3175 3176 if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc 3177 && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size) 3178 return 1; 3179 } 3180 3181 return 0; 3182} 3183 3184/* Function: pc_in_mapped_range 3185 If PC falls into the vma range of SECTION, return true, else false. */ 3186 3187CORE_ADDR 3188pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section) 3189{ 3190 if (section_is_overlay (section)) 3191 { 3192 if (obj_section_addr (section) <= pc 3193 && pc < obj_section_endaddr (section)) 3194 return 1; 3195 } 3196 3197 return 0; 3198} 3199 3200/* Return true if the mapped ranges of sections A and B overlap, false 3201 otherwise. */ 3202 3203static int 3204sections_overlap (struct obj_section *a, struct obj_section *b) 3205{ 3206 CORE_ADDR a_start = obj_section_addr (a); 3207 CORE_ADDR a_end = obj_section_endaddr (a); 3208 CORE_ADDR b_start = obj_section_addr (b); 3209 CORE_ADDR b_end = obj_section_endaddr (b); 3210 3211 return (a_start < b_end && b_start < a_end); 3212} 3213 3214/* Function: overlay_unmapped_address (PC, SECTION) 3215 Returns the address corresponding to PC in the unmapped (load) range. 3216 May be the same as PC. */ 3217 3218CORE_ADDR 3219overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section) 3220{ 3221 if (section_is_overlay (section) && pc_in_mapped_range (pc, section)) 3222 { 3223 bfd *abfd = section->objfile->obfd; 3224 asection *bfd_section = section->the_bfd_section; 3225 3226 return pc + bfd_section_lma (abfd, bfd_section) 3227 - bfd_section_vma (abfd, bfd_section); 3228 } 3229 3230 return pc; 3231} 3232 3233/* Function: overlay_mapped_address (PC, SECTION) 3234 Returns the address corresponding to PC in the mapped (runtime) range. 3235 May be the same as PC. */ 3236 3237CORE_ADDR 3238overlay_mapped_address (CORE_ADDR pc, struct obj_section *section) 3239{ 3240 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section)) 3241 { 3242 bfd *abfd = section->objfile->obfd; 3243 asection *bfd_section = section->the_bfd_section; 3244 3245 return pc + bfd_section_vma (abfd, bfd_section) 3246 - bfd_section_lma (abfd, bfd_section); 3247 } 3248 3249 return pc; 3250} 3251 3252/* Function: symbol_overlayed_address 3253 Return one of two addresses (relative to the VMA or to the LMA), 3254 depending on whether the section is mapped or not. */ 3255 3256CORE_ADDR 3257symbol_overlayed_address (CORE_ADDR address, struct obj_section *section) 3258{ 3259 if (overlay_debugging) 3260 { 3261 /* If the symbol has no section, just return its regular address. */ 3262 if (section == 0) 3263 return address; 3264 /* If the symbol's section is not an overlay, just return its 3265 address. */ 3266 if (!section_is_overlay (section)) 3267 return address; 3268 /* If the symbol's section is mapped, just return its address. */ 3269 if (section_is_mapped (section)) 3270 return address; 3271 /* 3272 * HOWEVER: if the symbol is in an overlay section which is NOT mapped, 3273 * then return its LOADED address rather than its vma address!! 3274 */ 3275 return overlay_unmapped_address (address, section); 3276 } 3277 return address; 3278} 3279 3280/* Function: find_pc_overlay (PC) 3281 Return the best-match overlay section for PC: 3282 If PC matches a mapped overlay section's VMA, return that section. 3283 Else if PC matches an unmapped section's VMA, return that section. 3284 Else if PC matches an unmapped section's LMA, return that section. */ 3285 3286struct obj_section * 3287find_pc_overlay (CORE_ADDR pc) 3288{ 3289 struct objfile *objfile; 3290 struct obj_section *osect, *best_match = NULL; 3291 3292 if (overlay_debugging) 3293 ALL_OBJSECTIONS (objfile, osect) 3294 if (section_is_overlay (osect)) 3295 { 3296 if (pc_in_mapped_range (pc, osect)) 3297 { 3298 if (section_is_mapped (osect)) 3299 return osect; 3300 else 3301 best_match = osect; 3302 } 3303 else if (pc_in_unmapped_range (pc, osect)) 3304 best_match = osect; 3305 } 3306 return best_match; 3307} 3308 3309/* Function: find_pc_mapped_section (PC) 3310 If PC falls into the VMA address range of an overlay section that is 3311 currently marked as MAPPED, return that section. Else return NULL. */ 3312 3313struct obj_section * 3314find_pc_mapped_section (CORE_ADDR pc) 3315{ 3316 struct objfile *objfile; 3317 struct obj_section *osect; 3318 3319 if (overlay_debugging) 3320 ALL_OBJSECTIONS (objfile, osect) 3321 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect)) 3322 return osect; 3323 3324 return NULL; 3325} 3326 3327/* Function: list_overlays_command 3328 Print a list of mapped sections and their PC ranges. */ 3329 3330static void 3331list_overlays_command (char *args, int from_tty) 3332{ 3333 int nmapped = 0; 3334 struct objfile *objfile; 3335 struct obj_section *osect; 3336 3337 if (overlay_debugging) 3338 ALL_OBJSECTIONS (objfile, osect) 3339 if (section_is_mapped (osect)) 3340 { 3341 struct gdbarch *gdbarch = get_objfile_arch (objfile); 3342 const char *name; 3343 bfd_vma lma, vma; 3344 int size; 3345 3346 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section); 3347 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section); 3348 size = bfd_get_section_size (osect->the_bfd_section); 3349 name = bfd_section_name (objfile->obfd, osect->the_bfd_section); 3350 3351 printf_filtered ("Section %s, loaded at ", name); 3352 fputs_filtered (paddress (gdbarch, lma), gdb_stdout); 3353 puts_filtered (" - "); 3354 fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout); 3355 printf_filtered (", mapped at "); 3356 fputs_filtered (paddress (gdbarch, vma), gdb_stdout); 3357 puts_filtered (" - "); 3358 fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout); 3359 puts_filtered ("\n"); 3360 3361 nmapped++; 3362 } 3363 if (nmapped == 0) 3364 printf_filtered (_("No sections are mapped.\n")); 3365} 3366 3367/* Function: map_overlay_command 3368 Mark the named section as mapped (ie. residing at its VMA address). */ 3369 3370static void 3371map_overlay_command (char *args, int from_tty) 3372{ 3373 struct objfile *objfile, *objfile2; 3374 struct obj_section *sec, *sec2; 3375 3376 if (!overlay_debugging) 3377 error (_("Overlay debugging not enabled. Use " 3378 "either the 'overlay auto' or\n" 3379 "the 'overlay manual' command.")); 3380 3381 if (args == 0 || *args == 0) 3382 error (_("Argument required: name of an overlay section")); 3383 3384 /* First, find a section matching the user supplied argument. */ 3385 ALL_OBJSECTIONS (objfile, sec) 3386 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3387 { 3388 /* Now, check to see if the section is an overlay. */ 3389 if (!section_is_overlay (sec)) 3390 continue; /* not an overlay section */ 3391 3392 /* Mark the overlay as "mapped". */ 3393 sec->ovly_mapped = 1; 3394 3395 /* Next, make a pass and unmap any sections that are 3396 overlapped by this new section: */ 3397 ALL_OBJSECTIONS (objfile2, sec2) 3398 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2)) 3399 { 3400 if (info_verbose) 3401 printf_unfiltered (_("Note: section %s unmapped by overlap\n"), 3402 bfd_section_name (objfile->obfd, 3403 sec2->the_bfd_section)); 3404 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */ 3405 } 3406 return; 3407 } 3408 error (_("No overlay section called %s"), args); 3409} 3410 3411/* Function: unmap_overlay_command 3412 Mark the overlay section as unmapped 3413 (ie. resident in its LMA address range, rather than the VMA range). */ 3414 3415static void 3416unmap_overlay_command (char *args, int from_tty) 3417{ 3418 struct objfile *objfile; 3419 struct obj_section *sec = NULL; 3420 3421 if (!overlay_debugging) 3422 error (_("Overlay debugging not enabled. " 3423 "Use either the 'overlay auto' or\n" 3424 "the 'overlay manual' command.")); 3425 3426 if (args == 0 || *args == 0) 3427 error (_("Argument required: name of an overlay section")); 3428 3429 /* First, find a section matching the user supplied argument. */ 3430 ALL_OBJSECTIONS (objfile, sec) 3431 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3432 { 3433 if (!sec->ovly_mapped) 3434 error (_("Section %s is not mapped"), args); 3435 sec->ovly_mapped = 0; 3436 return; 3437 } 3438 error (_("No overlay section called %s"), args); 3439} 3440 3441/* Function: overlay_auto_command 3442 A utility command to turn on overlay debugging. 3443 Possibly this should be done via a set/show command. */ 3444 3445static void 3446overlay_auto_command (char *args, int from_tty) 3447{ 3448 overlay_debugging = ovly_auto; 3449 enable_overlay_breakpoints (); 3450 if (info_verbose) 3451 printf_unfiltered (_("Automatic overlay debugging enabled.")); 3452} 3453 3454/* Function: overlay_manual_command 3455 A utility command to turn on overlay debugging. 3456 Possibly this should be done via a set/show command. */ 3457 3458static void 3459overlay_manual_command (char *args, int from_tty) 3460{ 3461 overlay_debugging = ovly_on; 3462 disable_overlay_breakpoints (); 3463 if (info_verbose) 3464 printf_unfiltered (_("Overlay debugging enabled.")); 3465} 3466 3467/* Function: overlay_off_command 3468 A utility command to turn on overlay debugging. 3469 Possibly this should be done via a set/show command. */ 3470 3471static void 3472overlay_off_command (char *args, int from_tty) 3473{ 3474 overlay_debugging = ovly_off; 3475 disable_overlay_breakpoints (); 3476 if (info_verbose) 3477 printf_unfiltered (_("Overlay debugging disabled.")); 3478} 3479 3480static void 3481overlay_load_command (char *args, int from_tty) 3482{ 3483 struct gdbarch *gdbarch = get_current_arch (); 3484 3485 if (gdbarch_overlay_update_p (gdbarch)) 3486 gdbarch_overlay_update (gdbarch, NULL); 3487 else 3488 error (_("This target does not know how to read its overlay state.")); 3489} 3490 3491/* Function: overlay_command 3492 A place-holder for a mis-typed command. */ 3493 3494/* Command list chain containing all defined "overlay" subcommands. */ 3495static struct cmd_list_element *overlaylist; 3496 3497static void 3498overlay_command (char *args, int from_tty) 3499{ 3500 printf_unfiltered 3501 ("\"overlay\" must be followed by the name of an overlay command.\n"); 3502 help_list (overlaylist, "overlay ", all_commands, gdb_stdout); 3503} 3504 3505/* Target Overlays for the "Simplest" overlay manager: 3506 3507 This is GDB's default target overlay layer. It works with the 3508 minimal overlay manager supplied as an example by Cygnus. The 3509 entry point is via a function pointer "gdbarch_overlay_update", 3510 so targets that use a different runtime overlay manager can 3511 substitute their own overlay_update function and take over the 3512 function pointer. 3513 3514 The overlay_update function pokes around in the target's data structures 3515 to see what overlays are mapped, and updates GDB's overlay mapping with 3516 this information. 3517 3518 In this simple implementation, the target data structures are as follows: 3519 unsigned _novlys; /# number of overlay sections #/ 3520 unsigned _ovly_table[_novlys][4] = { 3521 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/ 3522 {..., ..., ..., ...}, 3523 } 3524 unsigned _novly_regions; /# number of overlay regions #/ 3525 unsigned _ovly_region_table[_novly_regions][3] = { 3526 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/ 3527 {..., ..., ...}, 3528 } 3529 These functions will attempt to update GDB's mappedness state in the 3530 symbol section table, based on the target's mappedness state. 3531 3532 To do this, we keep a cached copy of the target's _ovly_table, and 3533 attempt to detect when the cached copy is invalidated. The main 3534 entry point is "simple_overlay_update(SECT), which looks up SECT in 3535 the cached table and re-reads only the entry for that section from 3536 the target (whenever possible). */ 3537 3538/* Cached, dynamically allocated copies of the target data structures: */ 3539static unsigned (*cache_ovly_table)[4] = 0; 3540static unsigned cache_novlys = 0; 3541static CORE_ADDR cache_ovly_table_base = 0; 3542enum ovly_index 3543 { 3544 VMA, SIZE, LMA, MAPPED 3545 }; 3546 3547/* Throw away the cached copy of _ovly_table. */ 3548 3549static void 3550simple_free_overlay_table (void) 3551{ 3552 if (cache_ovly_table) 3553 xfree (cache_ovly_table); 3554 cache_novlys = 0; 3555 cache_ovly_table = NULL; 3556 cache_ovly_table_base = 0; 3557} 3558 3559/* Read an array of ints of size SIZE from the target into a local buffer. 3560 Convert to host order. int LEN is number of ints. */ 3561 3562static void 3563read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, 3564 int len, int size, enum bfd_endian byte_order) 3565{ 3566 /* FIXME (alloca): Not safe if array is very large. */ 3567 gdb_byte *buf = alloca (len * size); 3568 int i; 3569 3570 read_memory (memaddr, buf, len * size); 3571 for (i = 0; i < len; i++) 3572 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order); 3573} 3574 3575/* Find and grab a copy of the target _ovly_table 3576 (and _novlys, which is needed for the table's size). */ 3577 3578static int 3579simple_read_overlay_table (void) 3580{ 3581 struct bound_minimal_symbol novlys_msym; 3582 struct bound_minimal_symbol ovly_table_msym; 3583 struct gdbarch *gdbarch; 3584 int word_size; 3585 enum bfd_endian byte_order; 3586 3587 simple_free_overlay_table (); 3588 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL); 3589 if (! novlys_msym.minsym) 3590 { 3591 error (_("Error reading inferior's overlay table: " 3592 "couldn't find `_novlys' variable\n" 3593 "in inferior. Use `overlay manual' mode.")); 3594 return 0; 3595 } 3596 3597 ovly_table_msym = lookup_bound_minimal_symbol ("_ovly_table"); 3598 if (! ovly_table_msym.minsym) 3599 { 3600 error (_("Error reading inferior's overlay table: couldn't find " 3601 "`_ovly_table' array\n" 3602 "in inferior. Use `overlay manual' mode.")); 3603 return 0; 3604 } 3605 3606 gdbarch = get_objfile_arch (ovly_table_msym.objfile); 3607 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 3608 byte_order = gdbarch_byte_order (gdbarch); 3609 3610 cache_novlys = read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym), 3611 4, byte_order); 3612 cache_ovly_table 3613 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table)); 3614 cache_ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym); 3615 read_target_long_array (cache_ovly_table_base, 3616 (unsigned int *) cache_ovly_table, 3617 cache_novlys * 4, word_size, byte_order); 3618 3619 return 1; /* SUCCESS */ 3620} 3621 3622/* Function: simple_overlay_update_1 3623 A helper function for simple_overlay_update. Assuming a cached copy 3624 of _ovly_table exists, look through it to find an entry whose vma, 3625 lma and size match those of OSECT. Re-read the entry and make sure 3626 it still matches OSECT (else the table may no longer be valid). 3627 Set OSECT's mapped state to match the entry. Return: 1 for 3628 success, 0 for failure. */ 3629 3630static int 3631simple_overlay_update_1 (struct obj_section *osect) 3632{ 3633 int i, size; 3634 bfd *obfd = osect->objfile->obfd; 3635 asection *bsect = osect->the_bfd_section; 3636 struct gdbarch *gdbarch = get_objfile_arch (osect->objfile); 3637 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 3638 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 3639 3640 size = bfd_get_section_size (osect->the_bfd_section); 3641 for (i = 0; i < cache_novlys; i++) 3642 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3643 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3644 /* && cache_ovly_table[i][SIZE] == size */ ) 3645 { 3646 read_target_long_array (cache_ovly_table_base + i * word_size, 3647 (unsigned int *) cache_ovly_table[i], 3648 4, word_size, byte_order); 3649 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3650 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3651 /* && cache_ovly_table[i][SIZE] == size */ ) 3652 { 3653 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3654 return 1; 3655 } 3656 else /* Warning! Warning! Target's ovly table has changed! */ 3657 return 0; 3658 } 3659 return 0; 3660} 3661 3662/* Function: simple_overlay_update 3663 If OSECT is NULL, then update all sections' mapped state 3664 (after re-reading the entire target _ovly_table). 3665 If OSECT is non-NULL, then try to find a matching entry in the 3666 cached ovly_table and update only OSECT's mapped state. 3667 If a cached entry can't be found or the cache isn't valid, then 3668 re-read the entire cache, and go ahead and update all sections. */ 3669 3670void 3671simple_overlay_update (struct obj_section *osect) 3672{ 3673 struct objfile *objfile; 3674 3675 /* Were we given an osect to look up? NULL means do all of them. */ 3676 if (osect) 3677 /* Have we got a cached copy of the target's overlay table? */ 3678 if (cache_ovly_table != NULL) 3679 { 3680 /* Does its cached location match what's currently in the 3681 symtab? */ 3682 struct bound_minimal_symbol minsym 3683 = lookup_minimal_symbol ("_ovly_table", NULL, NULL); 3684 3685 if (minsym.minsym == NULL) 3686 error (_("Error reading inferior's overlay table: couldn't " 3687 "find `_ovly_table' array\n" 3688 "in inferior. Use `overlay manual' mode.")); 3689 3690 if (cache_ovly_table_base == BMSYMBOL_VALUE_ADDRESS (minsym)) 3691 /* Then go ahead and try to look up this single section in 3692 the cache. */ 3693 if (simple_overlay_update_1 (osect)) 3694 /* Found it! We're done. */ 3695 return; 3696 } 3697 3698 /* Cached table no good: need to read the entire table anew. 3699 Or else we want all the sections, in which case it's actually 3700 more efficient to read the whole table in one block anyway. */ 3701 3702 if (! simple_read_overlay_table ()) 3703 return; 3704 3705 /* Now may as well update all sections, even if only one was requested. */ 3706 ALL_OBJSECTIONS (objfile, osect) 3707 if (section_is_overlay (osect)) 3708 { 3709 int i, size; 3710 bfd *obfd = osect->objfile->obfd; 3711 asection *bsect = osect->the_bfd_section; 3712 3713 size = bfd_get_section_size (bsect); 3714 for (i = 0; i < cache_novlys; i++) 3715 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3716 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3717 /* && cache_ovly_table[i][SIZE] == size */ ) 3718 { /* obj_section matches i'th entry in ovly_table. */ 3719 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3720 break; /* finished with inner for loop: break out. */ 3721 } 3722 } 3723} 3724 3725/* Set the output sections and output offsets for section SECTP in 3726 ABFD. The relocation code in BFD will read these offsets, so we 3727 need to be sure they're initialized. We map each section to itself, 3728 with no offset; this means that SECTP->vma will be honored. */ 3729 3730static void 3731symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy) 3732{ 3733 sectp->output_section = sectp; 3734 sectp->output_offset = 0; 3735} 3736 3737/* Default implementation for sym_relocate. */ 3738 3739bfd_byte * 3740default_symfile_relocate (struct objfile *objfile, asection *sectp, 3741 bfd_byte *buf) 3742{ 3743 /* Use sectp->owner instead of objfile->obfd. sectp may point to a 3744 DWO file. */ 3745 bfd *abfd = sectp->owner; 3746 3747 /* We're only interested in sections with relocation 3748 information. */ 3749 if ((sectp->flags & SEC_RELOC) == 0) 3750 return NULL; 3751 3752 /* We will handle section offsets properly elsewhere, so relocate as if 3753 all sections begin at 0. */ 3754 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL); 3755 3756 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); 3757} 3758 3759/* Relocate the contents of a debug section SECTP in ABFD. The 3760 contents are stored in BUF if it is non-NULL, or returned in a 3761 malloc'd buffer otherwise. 3762 3763 For some platforms and debug info formats, shared libraries contain 3764 relocations against the debug sections (particularly for DWARF-2; 3765 one affected platform is PowerPC GNU/Linux, although it depends on 3766 the version of the linker in use). Also, ELF object files naturally 3767 have unresolved relocations for their debug sections. We need to apply 3768 the relocations in order to get the locations of symbols correct. 3769 Another example that may require relocation processing, is the 3770 DWARF-2 .eh_frame section in .o files, although it isn't strictly a 3771 debug section. */ 3772 3773bfd_byte * 3774symfile_relocate_debug_section (struct objfile *objfile, 3775 asection *sectp, bfd_byte *buf) 3776{ 3777 gdb_assert (objfile->sf->sym_relocate); 3778 3779 return (*objfile->sf->sym_relocate) (objfile, sectp, buf); 3780} 3781 3782struct symfile_segment_data * 3783get_symfile_segment_data (bfd *abfd) 3784{ 3785 const struct sym_fns *sf = find_sym_fns (abfd); 3786 3787 if (sf == NULL) 3788 return NULL; 3789 3790 return sf->sym_segments (abfd); 3791} 3792 3793void 3794free_symfile_segment_data (struct symfile_segment_data *data) 3795{ 3796 xfree (data->segment_bases); 3797 xfree (data->segment_sizes); 3798 xfree (data->segment_info); 3799 xfree (data); 3800} 3801 3802/* Given: 3803 - DATA, containing segment addresses from the object file ABFD, and 3804 the mapping from ABFD's sections onto the segments that own them, 3805 and 3806 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual 3807 segment addresses reported by the target, 3808 store the appropriate offsets for each section in OFFSETS. 3809 3810 If there are fewer entries in SEGMENT_BASES than there are segments 3811 in DATA, then apply SEGMENT_BASES' last entry to all the segments. 3812 3813 If there are more entries, then ignore the extra. The target may 3814 not be able to distinguish between an empty data segment and a 3815 missing data segment; a missing text segment is less plausible. */ 3816 3817int 3818symfile_map_offsets_to_segments (bfd *abfd, 3819 const struct symfile_segment_data *data, 3820 struct section_offsets *offsets, 3821 int num_segment_bases, 3822 const CORE_ADDR *segment_bases) 3823{ 3824 int i; 3825 asection *sect; 3826 3827 /* It doesn't make sense to call this function unless you have some 3828 segment base addresses. */ 3829 gdb_assert (num_segment_bases > 0); 3830 3831 /* If we do not have segment mappings for the object file, we 3832 can not relocate it by segments. */ 3833 gdb_assert (data != NULL); 3834 gdb_assert (data->num_segments > 0); 3835 3836 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 3837 { 3838 int which = data->segment_info[i]; 3839 3840 gdb_assert (0 <= which && which <= data->num_segments); 3841 3842 /* Don't bother computing offsets for sections that aren't 3843 loaded as part of any segment. */ 3844 if (! which) 3845 continue; 3846 3847 /* Use the last SEGMENT_BASES entry as the address of any extra 3848 segments mentioned in DATA->segment_info. */ 3849 if (which > num_segment_bases) 3850 which = num_segment_bases; 3851 3852 offsets->offsets[i] = (segment_bases[which - 1] 3853 - data->segment_bases[which - 1]); 3854 } 3855 3856 return 1; 3857} 3858 3859static void 3860symfile_find_segment_sections (struct objfile *objfile) 3861{ 3862 bfd *abfd = objfile->obfd; 3863 int i; 3864 asection *sect; 3865 struct symfile_segment_data *data; 3866 3867 data = get_symfile_segment_data (objfile->obfd); 3868 if (data == NULL) 3869 return; 3870 3871 if (data->num_segments != 1 && data->num_segments != 2) 3872 { 3873 free_symfile_segment_data (data); 3874 return; 3875 } 3876 3877 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 3878 { 3879 int which = data->segment_info[i]; 3880 3881 if (which == 1) 3882 { 3883 if (objfile->sect_index_text == -1) 3884 objfile->sect_index_text = sect->index; 3885 3886 if (objfile->sect_index_rodata == -1) 3887 objfile->sect_index_rodata = sect->index; 3888 } 3889 else if (which == 2) 3890 { 3891 if (objfile->sect_index_data == -1) 3892 objfile->sect_index_data = sect->index; 3893 3894 if (objfile->sect_index_bss == -1) 3895 objfile->sect_index_bss = sect->index; 3896 } 3897 } 3898 3899 free_symfile_segment_data (data); 3900} 3901 3902/* Listen for free_objfile events. */ 3903 3904static void 3905symfile_free_objfile (struct objfile *objfile) 3906{ 3907 /* Remove the target sections owned by this objfile. */ 3908 if (objfile != NULL) 3909 remove_target_sections ((void *) objfile); 3910} 3911 3912/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method". 3913 Expand all symtabs that match the specified criteria. 3914 See quick_symbol_functions.expand_symtabs_matching for details. */ 3915 3916void 3917expand_symtabs_matching (expand_symtabs_file_matcher_ftype *file_matcher, 3918 expand_symtabs_symbol_matcher_ftype *symbol_matcher, 3919 expand_symtabs_exp_notify_ftype *expansion_notify, 3920 enum search_domain kind, 3921 void *data) 3922{ 3923 struct objfile *objfile; 3924 3925 ALL_OBJFILES (objfile) 3926 { 3927 if (objfile->sf) 3928 objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher, 3929 symbol_matcher, 3930 expansion_notify, kind, 3931 data); 3932 } 3933} 3934 3935/* Wrapper around the quick_symbol_functions map_symbol_filenames "method". 3936 Map function FUN over every file. 3937 See quick_symbol_functions.map_symbol_filenames for details. */ 3938 3939void 3940map_symbol_filenames (symbol_filename_ftype *fun, void *data, 3941 int need_fullname) 3942{ 3943 struct objfile *objfile; 3944 3945 ALL_OBJFILES (objfile) 3946 { 3947 if (objfile->sf) 3948 objfile->sf->qf->map_symbol_filenames (objfile, fun, data, 3949 need_fullname); 3950 } 3951} 3952 3953void 3954_initialize_symfile (void) 3955{ 3956 struct cmd_list_element *c; 3957 3958 observer_attach_free_objfile (symfile_free_objfile); 3959 3960 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\ 3961Load symbol table from executable file FILE.\n\ 3962The `file' command can also load symbol tables, as well as setting the file\n\ 3963to execute."), &cmdlist); 3964 set_cmd_completer (c, filename_completer); 3965 3966 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\ 3967Load symbols from FILE, assuming FILE has been dynamically loaded.\n\ 3968Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\ 3969 ...]\nADDR is the starting address of the file's text.\n\ 3970The optional arguments are section-name section-address pairs and\n\ 3971should be specified if the data and bss segments are not contiguous\n\ 3972with the text. SECT is a section name to be loaded at SECT_ADDR."), 3973 &cmdlist); 3974 set_cmd_completer (c, filename_completer); 3975 3976 c = add_cmd ("remove-symbol-file", class_files, 3977 remove_symbol_file_command, _("\ 3978Remove a symbol file added via the add-symbol-file command.\n\ 3979Usage: remove-symbol-file FILENAME\n\ 3980 remove-symbol-file -a ADDRESS\n\ 3981The file to remove can be identified by its filename or by an address\n\ 3982that lies within the boundaries of this symbol file in memory."), 3983 &cmdlist); 3984 3985 c = add_cmd ("load", class_files, load_command, _("\ 3986Dynamically load FILE into the running program, and record its symbols\n\ 3987for access from GDB.\n\ 3988A load OFFSET may also be given."), &cmdlist); 3989 set_cmd_completer (c, filename_completer); 3990 3991 add_prefix_cmd ("overlay", class_support, overlay_command, 3992 _("Commands for debugging overlays."), &overlaylist, 3993 "overlay ", 0, &cmdlist); 3994 3995 add_com_alias ("ovly", "overlay", class_alias, 1); 3996 add_com_alias ("ov", "overlay", class_alias, 1); 3997 3998 add_cmd ("map-overlay", class_support, map_overlay_command, 3999 _("Assert that an overlay section is mapped."), &overlaylist); 4000 4001 add_cmd ("unmap-overlay", class_support, unmap_overlay_command, 4002 _("Assert that an overlay section is unmapped."), &overlaylist); 4003 4004 add_cmd ("list-overlays", class_support, list_overlays_command, 4005 _("List mappings of overlay sections."), &overlaylist); 4006 4007 add_cmd ("manual", class_support, overlay_manual_command, 4008 _("Enable overlay debugging."), &overlaylist); 4009 add_cmd ("off", class_support, overlay_off_command, 4010 _("Disable overlay debugging."), &overlaylist); 4011 add_cmd ("auto", class_support, overlay_auto_command, 4012 _("Enable automatic overlay debugging."), &overlaylist); 4013 add_cmd ("load-target", class_support, overlay_load_command, 4014 _("Read the overlay mapping state from the target."), &overlaylist); 4015 4016 /* Filename extension to source language lookup table: */ 4017 init_filename_language_table (); 4018 add_setshow_string_noescape_cmd ("extension-language", class_files, 4019 &ext_args, _("\ 4020Set mapping between filename extension and source language."), _("\ 4021Show mapping between filename extension and source language."), _("\ 4022Usage: set extension-language .foo bar"), 4023 set_ext_lang_command, 4024 show_ext_args, 4025 &setlist, &showlist); 4026 4027 add_info ("extensions", info_ext_lang_command, 4028 _("All filename extensions associated with a source language.")); 4029 4030 add_setshow_optional_filename_cmd ("debug-file-directory", class_support, 4031 &debug_file_directory, _("\ 4032Set the directories where separate debug symbols are searched for."), _("\ 4033Show the directories where separate debug symbols are searched for."), _("\ 4034Separate debug symbols are first searched for in the same\n\ 4035directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\ 4036and lastly at the path of the directory of the binary with\n\ 4037each global debug-file-directory component prepended."), 4038 NULL, 4039 show_debug_file_directory, 4040 &setlist, &showlist); 4041 4042 add_setshow_enum_cmd ("symbol-loading", no_class, 4043 print_symbol_loading_enums, &print_symbol_loading, 4044 _("\ 4045Set printing of symbol loading messages."), _("\ 4046Show printing of symbol loading messages."), _("\ 4047off == turn all messages off\n\ 4048brief == print messages for the executable,\n\ 4049 and brief messages for shared libraries\n\ 4050full == print messages for the executable,\n\ 4051 and messages for each shared library."), 4052 NULL, 4053 NULL, 4054 &setprintlist, &showprintlist); 4055} 4056