symfile.c revision 1.3
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 1102void 1103new_symfile_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 new_symfile_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_maybe_remote (name); 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.) Do not indicate a duplicate library in that 1381 case. While there is no guarantee that a system that provides 1382 meaningful inode numbers will never set st_ino to zero, this is 1383 merely an optimization, so we do not need to worry about false 1384 negatives. */ 1385 1386 if (bfd_stat (abfd, &abfd_stat) == 0 1387 && abfd_stat.st_ino != 0 1388 && bfd_stat (parent_objfile->obfd, &parent_stat) == 0) 1389 { 1390 if (abfd_stat.st_dev == parent_stat.st_dev 1391 && abfd_stat.st_ino == parent_stat.st_ino) 1392 { 1393 gdb_bfd_unref (abfd); 1394 return 0; 1395 } 1396 verified_as_different = 1; 1397 } 1398 else 1399 verified_as_different = 0; 1400 1401 file_crc_p = gdb_bfd_crc (abfd, &file_crc); 1402 1403 gdb_bfd_unref (abfd); 1404 1405 if (!file_crc_p) 1406 return 0; 1407 1408 if (crc != file_crc) 1409 { 1410 unsigned long parent_crc; 1411 1412 /* If one (or both) the files are accessed for example the via "remote:" 1413 gdbserver way it does not support the bfd_stat operation. Verify 1414 whether those two files are not the same manually. */ 1415 1416 if (!verified_as_different) 1417 { 1418 if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc)) 1419 return 0; 1420 } 1421 1422 if (verified_as_different || parent_crc != file_crc) 1423 warning (_("the debug information found in \"%s\"" 1424 " does not match \"%s\" (CRC mismatch).\n"), 1425 name, objfile_name (parent_objfile)); 1426 1427 return 0; 1428 } 1429 1430 return 1; 1431} 1432 1433char *debug_file_directory = NULL; 1434static void 1435show_debug_file_directory (struct ui_file *file, int from_tty, 1436 struct cmd_list_element *c, const char *value) 1437{ 1438 fprintf_filtered (file, 1439 _("The directory where separate debug " 1440 "symbols are searched for is \"%s\".\n"), 1441 value); 1442} 1443 1444#if ! defined (DEBUG_SUBDIRECTORY) 1445#define DEBUG_SUBDIRECTORY ".debug" 1446#endif 1447 1448/* Find a separate debuginfo file for OBJFILE, using DIR as the directory 1449 where the original file resides (may not be the same as 1450 dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are 1451 looking for. CANON_DIR is the "realpath" form of DIR. 1452 DIR must contain a trailing '/'. 1453 Returns the path of the file with separate debug info, of NULL. */ 1454 1455static char * 1456find_separate_debug_file (const char *dir, 1457 const char *canon_dir, 1458 const char *debuglink, 1459 unsigned long crc32, struct objfile *objfile) 1460{ 1461 char *debugdir; 1462 char *debugfile; 1463 int i; 1464 VEC (char_ptr) *debugdir_vec; 1465 struct cleanup *back_to; 1466 int ix; 1467 1468 /* Set I to max (strlen (canon_dir), strlen (dir)). */ 1469 i = strlen (dir); 1470 if (canon_dir != NULL && strlen (canon_dir) > i) 1471 i = strlen (canon_dir); 1472 1473 debugfile = xmalloc (strlen (debug_file_directory) + 1 1474 + i 1475 + strlen (DEBUG_SUBDIRECTORY) 1476 + strlen ("/") 1477 + strlen (debuglink) 1478 + 1); 1479 1480 /* First try in the same directory as the original file. */ 1481 strcpy (debugfile, dir); 1482 strcat (debugfile, debuglink); 1483 1484 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1485 return debugfile; 1486 1487 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */ 1488 strcpy (debugfile, dir); 1489 strcat (debugfile, DEBUG_SUBDIRECTORY); 1490 strcat (debugfile, "/"); 1491 strcat (debugfile, debuglink); 1492 1493 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1494 return debugfile; 1495 1496 /* Then try in the global debugfile directories. 1497 1498 Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will 1499 cause "/..." lookups. */ 1500 1501 debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory); 1502 back_to = make_cleanup_free_char_ptr_vec (debugdir_vec); 1503 1504 for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix) 1505 { 1506 strcpy (debugfile, debugdir); 1507 strcat (debugfile, "/"); 1508 strcat (debugfile, dir); 1509 strcat (debugfile, debuglink); 1510 1511 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1512 { 1513 do_cleanups (back_to); 1514 return debugfile; 1515 } 1516 1517 /* If the file is in the sysroot, try using its base path in the 1518 global debugfile directory. */ 1519 if (canon_dir != NULL 1520 && filename_ncmp (canon_dir, gdb_sysroot, 1521 strlen (gdb_sysroot)) == 0 1522 && IS_DIR_SEPARATOR (canon_dir[strlen (gdb_sysroot)])) 1523 { 1524 strcpy (debugfile, debugdir); 1525 strcat (debugfile, canon_dir + strlen (gdb_sysroot)); 1526 strcat (debugfile, "/"); 1527 strcat (debugfile, debuglink); 1528 1529 if (separate_debug_file_exists (debugfile, crc32, objfile)) 1530 { 1531 do_cleanups (back_to); 1532 return debugfile; 1533 } 1534 } 1535 } 1536 1537 do_cleanups (back_to); 1538 xfree (debugfile); 1539 return NULL; 1540} 1541 1542/* Modify PATH to contain only "[/]directory/" part of PATH. 1543 If there were no directory separators in PATH, PATH will be empty 1544 string on return. */ 1545 1546static void 1547terminate_after_last_dir_separator (char *path) 1548{ 1549 int i; 1550 1551 /* Strip off the final filename part, leaving the directory name, 1552 followed by a slash. The directory can be relative or absolute. */ 1553 for (i = strlen(path) - 1; i >= 0; i--) 1554 if (IS_DIR_SEPARATOR (path[i])) 1555 break; 1556 1557 /* If I is -1 then no directory is present there and DIR will be "". */ 1558 path[i + 1] = '\0'; 1559} 1560 1561/* Find separate debuginfo for OBJFILE (using .gnu_debuglink section). 1562 Returns pathname, or NULL. */ 1563 1564char * 1565find_separate_debug_file_by_debuglink (struct objfile *objfile) 1566{ 1567 char *debuglink; 1568 char *dir, *canon_dir; 1569 char *debugfile; 1570 unsigned long crc32; 1571 struct cleanup *cleanups; 1572 1573 debuglink = bfd_get_debug_link_info (objfile->obfd, &crc32); 1574 1575 if (debuglink == NULL) 1576 { 1577 /* There's no separate debug info, hence there's no way we could 1578 load it => no warning. */ 1579 return NULL; 1580 } 1581 1582 cleanups = make_cleanup (xfree, debuglink); 1583 dir = xstrdup (objfile_name (objfile)); 1584 make_cleanup (xfree, dir); 1585 terminate_after_last_dir_separator (dir); 1586 canon_dir = lrealpath (dir); 1587 1588 debugfile = find_separate_debug_file (dir, canon_dir, debuglink, 1589 crc32, objfile); 1590 xfree (canon_dir); 1591 1592 if (debugfile == NULL) 1593 { 1594 /* For PR gdb/9538, try again with realpath (if different from the 1595 original). */ 1596 1597 struct stat st_buf; 1598 1599 if (lstat (objfile_name (objfile), &st_buf) == 0 1600 && S_ISLNK (st_buf.st_mode)) 1601 { 1602 char *symlink_dir; 1603 1604 symlink_dir = lrealpath (objfile_name (objfile)); 1605 if (symlink_dir != NULL) 1606 { 1607 make_cleanup (xfree, symlink_dir); 1608 terminate_after_last_dir_separator (symlink_dir); 1609 if (strcmp (dir, symlink_dir) != 0) 1610 { 1611 /* Different directory, so try using it. */ 1612 debugfile = find_separate_debug_file (symlink_dir, 1613 symlink_dir, 1614 debuglink, 1615 crc32, 1616 objfile); 1617 } 1618 } 1619 } 1620 } 1621 1622 do_cleanups (cleanups); 1623 return debugfile; 1624} 1625 1626/* This is the symbol-file command. Read the file, analyze its 1627 symbols, and add a struct symtab to a symtab list. The syntax of 1628 the command is rather bizarre: 1629 1630 1. The function buildargv implements various quoting conventions 1631 which are undocumented and have little or nothing in common with 1632 the way things are quoted (or not quoted) elsewhere in GDB. 1633 1634 2. Options are used, which are not generally used in GDB (perhaps 1635 "set mapped on", "set readnow on" would be better) 1636 1637 3. The order of options matters, which is contrary to GNU 1638 conventions (because it is confusing and inconvenient). */ 1639 1640void 1641symbol_file_command (char *args, int from_tty) 1642{ 1643 dont_repeat (); 1644 1645 if (args == NULL) 1646 { 1647 symbol_file_clear (from_tty); 1648 } 1649 else 1650 { 1651 char **argv = gdb_buildargv (args); 1652 int flags = OBJF_USERLOADED; 1653 struct cleanup *cleanups; 1654 char *name = NULL; 1655 1656 cleanups = make_cleanup_freeargv (argv); 1657 while (*argv != NULL) 1658 { 1659 if (strcmp (*argv, "-readnow") == 0) 1660 flags |= OBJF_READNOW; 1661 else if (**argv == '-') 1662 error (_("unknown option `%s'"), *argv); 1663 else 1664 { 1665 symbol_file_add_main_1 (*argv, from_tty, flags); 1666 name = *argv; 1667 } 1668 1669 argv++; 1670 } 1671 1672 if (name == NULL) 1673 error (_("no symbol file name was specified")); 1674 1675 do_cleanups (cleanups); 1676 } 1677} 1678 1679/* Set the initial language. 1680 1681 FIXME: A better solution would be to record the language in the 1682 psymtab when reading partial symbols, and then use it (if known) to 1683 set the language. This would be a win for formats that encode the 1684 language in an easily discoverable place, such as DWARF. For 1685 stabs, we can jump through hoops looking for specially named 1686 symbols or try to intuit the language from the specific type of 1687 stabs we find, but we can't do that until later when we read in 1688 full symbols. */ 1689 1690void 1691set_initial_language (void) 1692{ 1693 enum language lang = main_language (); 1694 1695 if (lang == language_unknown) 1696 { 1697 char *name = main_name (); 1698 struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL); 1699 1700 if (sym != NULL) 1701 lang = SYMBOL_LANGUAGE (sym); 1702 } 1703 1704 if (lang == language_unknown) 1705 { 1706 /* Make C the default language */ 1707 lang = language_c; 1708 } 1709 1710 set_language (lang); 1711 expected_language = current_language; /* Don't warn the user. */ 1712} 1713 1714/* If NAME is a remote name open the file using remote protocol, otherwise 1715 open it normally. Returns a new reference to the BFD. On error, 1716 returns NULL with the BFD error set. */ 1717 1718bfd * 1719gdb_bfd_open_maybe_remote (const char *name) 1720{ 1721 bfd *result; 1722 1723 if (remote_filename_p (name)) 1724 result = remote_bfd_open (name, gnutarget); 1725 else 1726 result = gdb_bfd_open (name, gnutarget, -1); 1727 1728 return result; 1729} 1730 1731/* Open the file specified by NAME and hand it off to BFD for 1732 preliminary analysis. Return a newly initialized bfd *, which 1733 includes a newly malloc'd` copy of NAME (tilde-expanded and made 1734 absolute). In case of trouble, error() is called. */ 1735 1736bfd * 1737symfile_bfd_open (const char *cname) 1738{ 1739 bfd *sym_bfd; 1740 int desc; 1741 char *name, *absolute_name; 1742 struct cleanup *back_to; 1743 1744 if (remote_filename_p (cname)) 1745 { 1746 sym_bfd = remote_bfd_open (cname, gnutarget); 1747 if (!sym_bfd) 1748 error (_("`%s': can't open to read symbols: %s."), cname, 1749 bfd_errmsg (bfd_get_error ())); 1750 1751 if (!bfd_check_format (sym_bfd, bfd_object)) 1752 { 1753 make_cleanup_bfd_unref (sym_bfd); 1754 error (_("`%s': can't read symbols: %s."), cname, 1755 bfd_errmsg (bfd_get_error ())); 1756 } 1757 1758 return sym_bfd; 1759 } 1760 1761 name = tilde_expand (cname); /* Returns 1st new malloc'd copy. */ 1762 1763 /* Look down path for it, allocate 2nd new malloc'd copy. */ 1764 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, name, 1765 O_RDONLY | O_BINARY, &absolute_name); 1766#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__) 1767 if (desc < 0) 1768 { 1769 char *exename = alloca (strlen (name) + 5); 1770 1771 strcat (strcpy (exename, name), ".exe"); 1772 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, 1773 exename, O_RDONLY | O_BINARY, &absolute_name); 1774 } 1775#endif 1776 if (desc < 0) 1777 { 1778 make_cleanup (xfree, name); 1779 perror_with_name (name); 1780 } 1781 1782 xfree (name); 1783 name = absolute_name; 1784 back_to = make_cleanup (xfree, name); 1785 1786 sym_bfd = gdb_bfd_open (name, gnutarget, desc); 1787 if (!sym_bfd) 1788 error (_("`%s': can't open to read symbols: %s."), name, 1789 bfd_errmsg (bfd_get_error ())); 1790 bfd_set_cacheable (sym_bfd, 1); 1791 1792 if (!bfd_check_format (sym_bfd, bfd_object)) 1793 { 1794 make_cleanup_bfd_unref (sym_bfd); 1795 error (_("`%s': can't read symbols: %s."), name, 1796 bfd_errmsg (bfd_get_error ())); 1797 } 1798 1799 do_cleanups (back_to); 1800 1801 return sym_bfd; 1802} 1803 1804/* Return the section index for SECTION_NAME on OBJFILE. Return -1 if 1805 the section was not found. */ 1806 1807int 1808get_section_index (struct objfile *objfile, char *section_name) 1809{ 1810 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name); 1811 1812 if (sect) 1813 return sect->index; 1814 else 1815 return -1; 1816} 1817 1818/* Link SF into the global symtab_fns list. 1819 FLAVOUR is the file format that SF handles. 1820 Called on startup by the _initialize routine in each object file format 1821 reader, to register information about each format the reader is prepared 1822 to handle. */ 1823 1824void 1825add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *sf) 1826{ 1827 registered_sym_fns fns = { flavour, sf }; 1828 1829 VEC_safe_push (registered_sym_fns, symtab_fns, &fns); 1830} 1831 1832/* Initialize OBJFILE to read symbols from its associated BFD. It 1833 either returns or calls error(). The result is an initialized 1834 struct sym_fns in the objfile structure, that contains cached 1835 information about the symbol file. */ 1836 1837static const struct sym_fns * 1838find_sym_fns (bfd *abfd) 1839{ 1840 registered_sym_fns *rsf; 1841 enum bfd_flavour our_flavour = bfd_get_flavour (abfd); 1842 int i; 1843 1844 if (our_flavour == bfd_target_srec_flavour 1845 || our_flavour == bfd_target_ihex_flavour 1846 || our_flavour == bfd_target_tekhex_flavour) 1847 return NULL; /* No symbols. */ 1848 1849 for (i = 0; VEC_iterate (registered_sym_fns, symtab_fns, i, rsf); ++i) 1850 if (our_flavour == rsf->sym_flavour) 1851 return rsf->sym_fns; 1852 1853 error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."), 1854 bfd_get_target (abfd)); 1855} 1856 1857 1858/* This function runs the load command of our current target. */ 1859 1860static void 1861load_command (char *arg, int from_tty) 1862{ 1863 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 1864 1865 dont_repeat (); 1866 1867 /* The user might be reloading because the binary has changed. Take 1868 this opportunity to check. */ 1869 reopen_exec_file (); 1870 reread_symbols (); 1871 1872 if (arg == NULL) 1873 { 1874 char *parg; 1875 int count = 0; 1876 1877 parg = arg = get_exec_file (1); 1878 1879 /* Count how many \ " ' tab space there are in the name. */ 1880 while ((parg = strpbrk (parg, "\\\"'\t "))) 1881 { 1882 parg++; 1883 count++; 1884 } 1885 1886 if (count) 1887 { 1888 /* We need to quote this string so buildargv can pull it apart. */ 1889 char *temp = xmalloc (strlen (arg) + count + 1 ); 1890 char *ptemp = temp; 1891 char *prev; 1892 1893 make_cleanup (xfree, temp); 1894 1895 prev = parg = arg; 1896 while ((parg = strpbrk (parg, "\\\"'\t "))) 1897 { 1898 strncpy (ptemp, prev, parg - prev); 1899 ptemp += parg - prev; 1900 prev = parg++; 1901 *ptemp++ = '\\'; 1902 } 1903 strcpy (ptemp, prev); 1904 1905 arg = temp; 1906 } 1907 } 1908 1909 target_load (arg, from_tty); 1910 1911 /* After re-loading the executable, we don't really know which 1912 overlays are mapped any more. */ 1913 overlay_cache_invalid = 1; 1914 1915 do_cleanups (cleanup); 1916} 1917 1918/* This version of "load" should be usable for any target. Currently 1919 it is just used for remote targets, not inftarg.c or core files, 1920 on the theory that only in that case is it useful. 1921 1922 Avoiding xmodem and the like seems like a win (a) because we don't have 1923 to worry about finding it, and (b) On VMS, fork() is very slow and so 1924 we don't want to run a subprocess. On the other hand, I'm not sure how 1925 performance compares. */ 1926 1927static int validate_download = 0; 1928 1929/* Callback service function for generic_load (bfd_map_over_sections). */ 1930 1931static void 1932add_section_size_callback (bfd *abfd, asection *asec, void *data) 1933{ 1934 bfd_size_type *sum = data; 1935 1936 *sum += bfd_get_section_size (asec); 1937} 1938 1939/* Opaque data for load_section_callback. */ 1940struct load_section_data { 1941 CORE_ADDR load_offset; 1942 struct load_progress_data *progress_data; 1943 VEC(memory_write_request_s) *requests; 1944}; 1945 1946/* Opaque data for load_progress. */ 1947struct load_progress_data { 1948 /* Cumulative data. */ 1949 unsigned long write_count; 1950 unsigned long data_count; 1951 bfd_size_type total_size; 1952}; 1953 1954/* Opaque data for load_progress for a single section. */ 1955struct load_progress_section_data { 1956 struct load_progress_data *cumulative; 1957 1958 /* Per-section data. */ 1959 const char *section_name; 1960 ULONGEST section_sent; 1961 ULONGEST section_size; 1962 CORE_ADDR lma; 1963 gdb_byte *buffer; 1964}; 1965 1966/* Target write callback routine for progress reporting. */ 1967 1968static void 1969load_progress (ULONGEST bytes, void *untyped_arg) 1970{ 1971 struct load_progress_section_data *args = untyped_arg; 1972 struct load_progress_data *totals; 1973 1974 if (args == NULL) 1975 /* Writing padding data. No easy way to get at the cumulative 1976 stats, so just ignore this. */ 1977 return; 1978 1979 totals = args->cumulative; 1980 1981 if (bytes == 0 && args->section_sent == 0) 1982 { 1983 /* The write is just starting. Let the user know we've started 1984 this section. */ 1985 ui_out_message (current_uiout, 0, "Loading section %s, size %s lma %s\n", 1986 args->section_name, hex_string (args->section_size), 1987 paddress (target_gdbarch (), args->lma)); 1988 return; 1989 } 1990 1991 if (validate_download) 1992 { 1993 /* Broken memories and broken monitors manifest themselves here 1994 when bring new computers to life. This doubles already slow 1995 downloads. */ 1996 /* NOTE: cagney/1999-10-18: A more efficient implementation 1997 might add a verify_memory() method to the target vector and 1998 then use that. remote.c could implement that method using 1999 the ``qCRC'' packet. */ 2000 gdb_byte *check = xmalloc (bytes); 2001 struct cleanup *verify_cleanups = make_cleanup (xfree, check); 2002 2003 if (target_read_memory (args->lma, check, bytes) != 0) 2004 error (_("Download verify read failed at %s"), 2005 paddress (target_gdbarch (), args->lma)); 2006 if (memcmp (args->buffer, check, bytes) != 0) 2007 error (_("Download verify compare failed at %s"), 2008 paddress (target_gdbarch (), args->lma)); 2009 do_cleanups (verify_cleanups); 2010 } 2011 totals->data_count += bytes; 2012 args->lma += bytes; 2013 args->buffer += bytes; 2014 totals->write_count += 1; 2015 args->section_sent += bytes; 2016 if (check_quit_flag () 2017 || (deprecated_ui_load_progress_hook != NULL 2018 && deprecated_ui_load_progress_hook (args->section_name, 2019 args->section_sent))) 2020 error (_("Canceled the download")); 2021 2022 if (deprecated_show_load_progress != NULL) 2023 deprecated_show_load_progress (args->section_name, 2024 args->section_sent, 2025 args->section_size, 2026 totals->data_count, 2027 totals->total_size); 2028} 2029 2030/* Callback service function for generic_load (bfd_map_over_sections). */ 2031 2032static void 2033load_section_callback (bfd *abfd, asection *asec, void *data) 2034{ 2035 struct memory_write_request *new_request; 2036 struct load_section_data *args = data; 2037 struct load_progress_section_data *section_data; 2038 bfd_size_type size = bfd_get_section_size (asec); 2039 gdb_byte *buffer; 2040 const char *sect_name = bfd_get_section_name (abfd, asec); 2041 2042 if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0) 2043 return; 2044 2045 if (size == 0) 2046 return; 2047 2048 new_request = VEC_safe_push (memory_write_request_s, 2049 args->requests, NULL); 2050 memset (new_request, 0, sizeof (struct memory_write_request)); 2051 section_data = xcalloc (1, sizeof (struct load_progress_section_data)); 2052 new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset; 2053 new_request->end = new_request->begin + size; /* FIXME Should size 2054 be in instead? */ 2055 new_request->data = xmalloc (size); 2056 new_request->baton = section_data; 2057 2058 buffer = new_request->data; 2059 2060 section_data->cumulative = args->progress_data; 2061 section_data->section_name = sect_name; 2062 section_data->section_size = size; 2063 section_data->lma = new_request->begin; 2064 section_data->buffer = buffer; 2065 2066 bfd_get_section_contents (abfd, asec, buffer, 0, size); 2067} 2068 2069/* Clean up an entire memory request vector, including load 2070 data and progress records. */ 2071 2072static void 2073clear_memory_write_data (void *arg) 2074{ 2075 VEC(memory_write_request_s) **vec_p = arg; 2076 VEC(memory_write_request_s) *vec = *vec_p; 2077 int i; 2078 struct memory_write_request *mr; 2079 2080 for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i) 2081 { 2082 xfree (mr->data); 2083 xfree (mr->baton); 2084 } 2085 VEC_free (memory_write_request_s, vec); 2086} 2087 2088void 2089generic_load (const char *args, int from_tty) 2090{ 2091 bfd *loadfile_bfd; 2092 struct timeval start_time, end_time; 2093 char *filename; 2094 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0); 2095 struct load_section_data cbdata; 2096 struct load_progress_data total_progress; 2097 struct ui_out *uiout = current_uiout; 2098 2099 CORE_ADDR entry; 2100 char **argv; 2101 2102 memset (&cbdata, 0, sizeof (cbdata)); 2103 memset (&total_progress, 0, sizeof (total_progress)); 2104 cbdata.progress_data = &total_progress; 2105 2106 make_cleanup (clear_memory_write_data, &cbdata.requests); 2107 2108 if (args == NULL) 2109 error_no_arg (_("file to load")); 2110 2111 argv = gdb_buildargv (args); 2112 make_cleanup_freeargv (argv); 2113 2114 filename = tilde_expand (argv[0]); 2115 make_cleanup (xfree, filename); 2116 2117 if (argv[1] != NULL) 2118 { 2119 const char *endptr; 2120 2121 cbdata.load_offset = strtoulst (argv[1], &endptr, 0); 2122 2123 /* If the last word was not a valid number then 2124 treat it as a file name with spaces in. */ 2125 if (argv[1] == endptr) 2126 error (_("Invalid download offset:%s."), argv[1]); 2127 2128 if (argv[2] != NULL) 2129 error (_("Too many parameters.")); 2130 } 2131 2132 /* Open the file for loading. */ 2133 loadfile_bfd = gdb_bfd_open (filename, gnutarget, -1); 2134 if (loadfile_bfd == NULL) 2135 { 2136 perror_with_name (filename); 2137 return; 2138 } 2139 2140 make_cleanup_bfd_unref (loadfile_bfd); 2141 2142 if (!bfd_check_format (loadfile_bfd, bfd_object)) 2143 { 2144 error (_("\"%s\" is not an object file: %s"), filename, 2145 bfd_errmsg (bfd_get_error ())); 2146 } 2147 2148 bfd_map_over_sections (loadfile_bfd, add_section_size_callback, 2149 (void *) &total_progress.total_size); 2150 2151 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata); 2152 2153 gettimeofday (&start_time, NULL); 2154 2155 if (target_write_memory_blocks (cbdata.requests, flash_discard, 2156 load_progress) != 0) 2157 error (_("Load failed")); 2158 2159 gettimeofday (&end_time, NULL); 2160 2161 entry = bfd_get_start_address (loadfile_bfd); 2162 entry = gdbarch_addr_bits_remove (target_gdbarch (), entry); 2163 ui_out_text (uiout, "Start address "); 2164 ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch (), entry)); 2165 ui_out_text (uiout, ", load size "); 2166 ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count); 2167 ui_out_text (uiout, "\n"); 2168 /* We were doing this in remote-mips.c, I suspect it is right 2169 for other targets too. */ 2170 regcache_write_pc (get_current_regcache (), entry); 2171 2172 /* Reset breakpoints, now that we have changed the load image. For 2173 instance, breakpoints may have been set (or reset, by 2174 post_create_inferior) while connected to the target but before we 2175 loaded the program. In that case, the prologue analyzer could 2176 have read instructions from the target to find the right 2177 breakpoint locations. Loading has changed the contents of that 2178 memory. */ 2179 2180 breakpoint_re_set (); 2181 2182 /* FIXME: are we supposed to call symbol_file_add or not? According 2183 to a comment from remote-mips.c (where a call to symbol_file_add 2184 was commented out), making the call confuses GDB if more than one 2185 file is loaded in. Some targets do (e.g., remote-vx.c) but 2186 others don't (or didn't - perhaps they have all been deleted). */ 2187 2188 print_transfer_performance (gdb_stdout, total_progress.data_count, 2189 total_progress.write_count, 2190 &start_time, &end_time); 2191 2192 do_cleanups (old_cleanups); 2193} 2194 2195/* Report how fast the transfer went. */ 2196 2197void 2198print_transfer_performance (struct ui_file *stream, 2199 unsigned long data_count, 2200 unsigned long write_count, 2201 const struct timeval *start_time, 2202 const struct timeval *end_time) 2203{ 2204 ULONGEST time_count; 2205 struct ui_out *uiout = current_uiout; 2206 2207 /* Compute the elapsed time in milliseconds, as a tradeoff between 2208 accuracy and overflow. */ 2209 time_count = (end_time->tv_sec - start_time->tv_sec) * 1000; 2210 time_count += (end_time->tv_usec - start_time->tv_usec) / 1000; 2211 2212 ui_out_text (uiout, "Transfer rate: "); 2213 if (time_count > 0) 2214 { 2215 unsigned long rate = ((ULONGEST) data_count * 1000) / time_count; 2216 2217 if (ui_out_is_mi_like_p (uiout)) 2218 { 2219 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8); 2220 ui_out_text (uiout, " bits/sec"); 2221 } 2222 else if (rate < 1024) 2223 { 2224 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate); 2225 ui_out_text (uiout, " bytes/sec"); 2226 } 2227 else 2228 { 2229 ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024); 2230 ui_out_text (uiout, " KB/sec"); 2231 } 2232 } 2233 else 2234 { 2235 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8)); 2236 ui_out_text (uiout, " bits in <1 sec"); 2237 } 2238 if (write_count > 0) 2239 { 2240 ui_out_text (uiout, ", "); 2241 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count); 2242 ui_out_text (uiout, " bytes/write"); 2243 } 2244 ui_out_text (uiout, ".\n"); 2245} 2246 2247/* This function allows the addition of incrementally linked object files. 2248 It does not modify any state in the target, only in the debugger. */ 2249/* Note: ezannoni 2000-04-13 This function/command used to have a 2250 special case syntax for the rombug target (Rombug is the boot 2251 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the 2252 rombug case, the user doesn't need to supply a text address, 2253 instead a call to target_link() (in target.c) would supply the 2254 value to use. We are now discontinuing this type of ad hoc syntax. */ 2255 2256static void 2257add_symbol_file_command (char *args, int from_tty) 2258{ 2259 struct gdbarch *gdbarch = get_current_arch (); 2260 char *filename = NULL; 2261 int flags = OBJF_USERLOADED | OBJF_SHARED; 2262 char *arg; 2263 int section_index = 0; 2264 int argcnt = 0; 2265 int sec_num = 0; 2266 int i; 2267 int expecting_sec_name = 0; 2268 int expecting_sec_addr = 0; 2269 char **argv; 2270 struct objfile *objf; 2271 2272 struct sect_opt 2273 { 2274 char *name; 2275 char *value; 2276 }; 2277 2278 struct section_addr_info *section_addrs; 2279 struct sect_opt *sect_opts = NULL; 2280 size_t num_sect_opts = 0; 2281 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL); 2282 2283 num_sect_opts = 16; 2284 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts 2285 * sizeof (struct sect_opt)); 2286 2287 dont_repeat (); 2288 2289 if (args == NULL) 2290 error (_("add-symbol-file takes a file name and an address")); 2291 2292 argv = gdb_buildargv (args); 2293 make_cleanup_freeargv (argv); 2294 2295 for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt]) 2296 { 2297 /* Process the argument. */ 2298 if (argcnt == 0) 2299 { 2300 /* The first argument is the file name. */ 2301 filename = tilde_expand (arg); 2302 make_cleanup (xfree, filename); 2303 } 2304 else if (argcnt == 1) 2305 { 2306 /* The second argument is always the text address at which 2307 to load the program. */ 2308 sect_opts[section_index].name = ".text"; 2309 sect_opts[section_index].value = arg; 2310 if (++section_index >= num_sect_opts) 2311 { 2312 num_sect_opts *= 2; 2313 sect_opts = ((struct sect_opt *) 2314 xrealloc (sect_opts, 2315 num_sect_opts 2316 * sizeof (struct sect_opt))); 2317 } 2318 } 2319 else 2320 { 2321 /* It's an option (starting with '-') or it's an argument 2322 to an option. */ 2323 if (expecting_sec_name) 2324 { 2325 sect_opts[section_index].name = arg; 2326 expecting_sec_name = 0; 2327 } 2328 else if (expecting_sec_addr) 2329 { 2330 sect_opts[section_index].value = arg; 2331 expecting_sec_addr = 0; 2332 if (++section_index >= num_sect_opts) 2333 { 2334 num_sect_opts *= 2; 2335 sect_opts = ((struct sect_opt *) 2336 xrealloc (sect_opts, 2337 num_sect_opts 2338 * sizeof (struct sect_opt))); 2339 } 2340 } 2341 else if (strcmp (arg, "-readnow") == 0) 2342 flags |= OBJF_READNOW; 2343 else if (strcmp (arg, "-s") == 0) 2344 { 2345 expecting_sec_name = 1; 2346 expecting_sec_addr = 1; 2347 } 2348 else 2349 error (_("USAGE: add-symbol-file <filename> <textaddress>" 2350 " [-readnow] [-s <secname> <addr>]*")); 2351 } 2352 } 2353 2354 /* This command takes at least two arguments. The first one is a 2355 filename, and the second is the address where this file has been 2356 loaded. Abort now if this address hasn't been provided by the 2357 user. */ 2358 if (section_index < 1) 2359 error (_("The address where %s has been loaded is missing"), filename); 2360 2361 /* Print the prompt for the query below. And save the arguments into 2362 a sect_addr_info structure to be passed around to other 2363 functions. We have to split this up into separate print 2364 statements because hex_string returns a local static 2365 string. */ 2366 2367 printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename); 2368 section_addrs = alloc_section_addr_info (section_index); 2369 make_cleanup (xfree, section_addrs); 2370 for (i = 0; i < section_index; i++) 2371 { 2372 CORE_ADDR addr; 2373 char *val = sect_opts[i].value; 2374 char *sec = sect_opts[i].name; 2375 2376 addr = parse_and_eval_address (val); 2377 2378 /* Here we store the section offsets in the order they were 2379 entered on the command line. */ 2380 section_addrs->other[sec_num].name = sec; 2381 section_addrs->other[sec_num].addr = addr; 2382 printf_unfiltered ("\t%s_addr = %s\n", sec, 2383 paddress (gdbarch, addr)); 2384 sec_num++; 2385 2386 /* The object's sections are initialized when a 2387 call is made to build_objfile_section_table (objfile). 2388 This happens in reread_symbols. 2389 At this point, we don't know what file type this is, 2390 so we can't determine what section names are valid. */ 2391 } 2392 section_addrs->num_sections = sec_num; 2393 2394 if (from_tty && (!query ("%s", ""))) 2395 error (_("Not confirmed.")); 2396 2397 objf = symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0, 2398 section_addrs, flags); 2399 2400 add_target_sections_of_objfile (objf); 2401 2402 /* Getting new symbols may change our opinion about what is 2403 frameless. */ 2404 reinit_frame_cache (); 2405 do_cleanups (my_cleanups); 2406} 2407 2408 2409/* This function removes a symbol file that was added via add-symbol-file. */ 2410 2411static void 2412remove_symbol_file_command (char *args, int from_tty) 2413{ 2414 char **argv; 2415 struct objfile *objf = NULL; 2416 struct cleanup *my_cleanups; 2417 struct program_space *pspace = current_program_space; 2418 struct gdbarch *gdbarch = get_current_arch (); 2419 2420 dont_repeat (); 2421 2422 if (args == NULL) 2423 error (_("remove-symbol-file: no symbol file provided")); 2424 2425 my_cleanups = make_cleanup (null_cleanup, NULL); 2426 2427 argv = gdb_buildargv (args); 2428 2429 if (strcmp (argv[0], "-a") == 0) 2430 { 2431 /* Interpret the next argument as an address. */ 2432 CORE_ADDR addr; 2433 2434 if (argv[1] == NULL) 2435 error (_("Missing address argument")); 2436 2437 if (argv[2] != NULL) 2438 error (_("Junk after %s"), argv[1]); 2439 2440 addr = parse_and_eval_address (argv[1]); 2441 2442 ALL_OBJFILES (objf) 2443 { 2444 if ((objf->flags & OBJF_USERLOADED) != 0 2445 && (objf->flags & OBJF_SHARED) != 0 2446 && objf->pspace == pspace && is_addr_in_objfile (addr, objf)) 2447 break; 2448 } 2449 } 2450 else if (argv[0] != NULL) 2451 { 2452 /* Interpret the current argument as a file name. */ 2453 char *filename; 2454 2455 if (argv[1] != NULL) 2456 error (_("Junk after %s"), argv[0]); 2457 2458 filename = tilde_expand (argv[0]); 2459 make_cleanup (xfree, filename); 2460 2461 ALL_OBJFILES (objf) 2462 { 2463 if ((objf->flags & OBJF_USERLOADED) != 0 2464 && (objf->flags & OBJF_SHARED) != 0 2465 && objf->pspace == pspace 2466 && filename_cmp (filename, objfile_name (objf)) == 0) 2467 break; 2468 } 2469 } 2470 2471 if (objf == NULL) 2472 error (_("No symbol file found")); 2473 2474 if (from_tty 2475 && !query (_("Remove symbol table from file \"%s\"? "), 2476 objfile_name (objf))) 2477 error (_("Not confirmed.")); 2478 2479 free_objfile (objf); 2480 clear_symtab_users (0); 2481 2482 do_cleanups (my_cleanups); 2483} 2484 2485typedef struct objfile *objfilep; 2486 2487DEF_VEC_P (objfilep); 2488 2489/* Re-read symbols if a symbol-file has changed. */ 2490 2491void 2492reread_symbols (void) 2493{ 2494 struct objfile *objfile; 2495 long new_modtime; 2496 struct stat new_statbuf; 2497 int res; 2498 VEC (objfilep) *new_objfiles = NULL; 2499 struct cleanup *all_cleanups; 2500 2501 all_cleanups = make_cleanup (VEC_cleanup (objfilep), &new_objfiles); 2502 2503 /* With the addition of shared libraries, this should be modified, 2504 the load time should be saved in the partial symbol tables, since 2505 different tables may come from different source files. FIXME. 2506 This routine should then walk down each partial symbol table 2507 and see if the symbol table that it originates from has been changed. */ 2508 2509 for (objfile = object_files; objfile; objfile = objfile->next) 2510 { 2511 if (objfile->obfd == NULL) 2512 continue; 2513 2514 /* Separate debug objfiles are handled in the main objfile. */ 2515 if (objfile->separate_debug_objfile_backlink) 2516 continue; 2517 2518 /* If this object is from an archive (what you usually create with 2519 `ar', often called a `static library' on most systems, though 2520 a `shared library' on AIX is also an archive), then you should 2521 stat on the archive name, not member name. */ 2522 if (objfile->obfd->my_archive) 2523 res = stat (objfile->obfd->my_archive->filename, &new_statbuf); 2524 else 2525 res = stat (objfile_name (objfile), &new_statbuf); 2526 if (res != 0) 2527 { 2528 /* FIXME, should use print_sys_errmsg but it's not filtered. */ 2529 printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"), 2530 objfile_name (objfile)); 2531 continue; 2532 } 2533 new_modtime = new_statbuf.st_mtime; 2534 if (new_modtime != objfile->mtime) 2535 { 2536 struct cleanup *old_cleanups; 2537 struct section_offsets *offsets; 2538 int num_offsets; 2539 char *original_name; 2540 2541 printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"), 2542 objfile_name (objfile)); 2543 2544 /* There are various functions like symbol_file_add, 2545 symfile_bfd_open, syms_from_objfile, etc., which might 2546 appear to do what we want. But they have various other 2547 effects which we *don't* want. So we just do stuff 2548 ourselves. We don't worry about mapped files (for one thing, 2549 any mapped file will be out of date). */ 2550 2551 /* If we get an error, blow away this objfile (not sure if 2552 that is the correct response for things like shared 2553 libraries). */ 2554 old_cleanups = make_cleanup_free_objfile (objfile); 2555 /* We need to do this whenever any symbols go away. */ 2556 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/); 2557 2558 if (exec_bfd != NULL 2559 && filename_cmp (bfd_get_filename (objfile->obfd), 2560 bfd_get_filename (exec_bfd)) == 0) 2561 { 2562 /* Reload EXEC_BFD without asking anything. */ 2563 2564 exec_file_attach (bfd_get_filename (objfile->obfd), 0); 2565 } 2566 2567 /* Keep the calls order approx. the same as in free_objfile. */ 2568 2569 /* Free the separate debug objfiles. It will be 2570 automatically recreated by sym_read. */ 2571 free_objfile_separate_debug (objfile); 2572 2573 /* Remove any references to this objfile in the global 2574 value lists. */ 2575 preserve_values (objfile); 2576 2577 /* Nuke all the state that we will re-read. Much of the following 2578 code which sets things to NULL really is necessary to tell 2579 other parts of GDB that there is nothing currently there. 2580 2581 Try to keep the freeing order compatible with free_objfile. */ 2582 2583 if (objfile->sf != NULL) 2584 { 2585 (*objfile->sf->sym_finish) (objfile); 2586 } 2587 2588 clear_objfile_data (objfile); 2589 2590 /* Clean up any state BFD has sitting around. */ 2591 { 2592 struct bfd *obfd = objfile->obfd; 2593 char *obfd_filename; 2594 2595 obfd_filename = bfd_get_filename (objfile->obfd); 2596 /* Open the new BFD before freeing the old one, so that 2597 the filename remains live. */ 2598 objfile->obfd = gdb_bfd_open_maybe_remote (obfd_filename); 2599 if (objfile->obfd == NULL) 2600 { 2601 /* We have to make a cleanup and error here, rather 2602 than erroring later, because once we unref OBFD, 2603 OBFD_FILENAME will be freed. */ 2604 make_cleanup_bfd_unref (obfd); 2605 error (_("Can't open %s to read symbols."), obfd_filename); 2606 } 2607 gdb_bfd_unref (obfd); 2608 } 2609 2610 original_name = xstrdup (objfile->original_name); 2611 make_cleanup (xfree, original_name); 2612 2613 /* bfd_openr sets cacheable to true, which is what we want. */ 2614 if (!bfd_check_format (objfile->obfd, bfd_object)) 2615 error (_("Can't read symbols from %s: %s."), objfile_name (objfile), 2616 bfd_errmsg (bfd_get_error ())); 2617 2618 /* Save the offsets, we will nuke them with the rest of the 2619 objfile_obstack. */ 2620 num_offsets = objfile->num_sections; 2621 offsets = ((struct section_offsets *) 2622 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets))); 2623 memcpy (offsets, objfile->section_offsets, 2624 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2625 2626 /* FIXME: Do we have to free a whole linked list, or is this 2627 enough? */ 2628 if (objfile->global_psymbols.list) 2629 xfree (objfile->global_psymbols.list); 2630 memset (&objfile->global_psymbols, 0, 2631 sizeof (objfile->global_psymbols)); 2632 if (objfile->static_psymbols.list) 2633 xfree (objfile->static_psymbols.list); 2634 memset (&objfile->static_psymbols, 0, 2635 sizeof (objfile->static_psymbols)); 2636 2637 /* Free the obstacks for non-reusable objfiles. */ 2638 psymbol_bcache_free (objfile->psymbol_cache); 2639 objfile->psymbol_cache = psymbol_bcache_init (); 2640 obstack_free (&objfile->objfile_obstack, 0); 2641 objfile->sections = NULL; 2642 objfile->compunit_symtabs = NULL; 2643 objfile->psymtabs = NULL; 2644 objfile->psymtabs_addrmap = NULL; 2645 objfile->free_psymtabs = NULL; 2646 objfile->template_symbols = NULL; 2647 2648 /* obstack_init also initializes the obstack so it is 2649 empty. We could use obstack_specify_allocation but 2650 gdb_obstack.h specifies the alloc/dealloc functions. */ 2651 obstack_init (&objfile->objfile_obstack); 2652 2653 /* set_objfile_per_bfd potentially allocates the per-bfd 2654 data on the objfile's obstack (if sharing data across 2655 multiple users is not possible), so it's important to 2656 do it *after* the obstack has been initialized. */ 2657 set_objfile_per_bfd (objfile); 2658 2659 objfile->original_name = obstack_copy0 (&objfile->objfile_obstack, 2660 original_name, 2661 strlen (original_name)); 2662 2663 /* Reset the sym_fns pointer. The ELF reader can change it 2664 based on whether .gdb_index is present, and we need it to 2665 start over. PR symtab/15885 */ 2666 objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd)); 2667 2668 build_objfile_section_table (objfile); 2669 terminate_minimal_symbol_table (objfile); 2670 2671 /* We use the same section offsets as from last time. I'm not 2672 sure whether that is always correct for shared libraries. */ 2673 objfile->section_offsets = (struct section_offsets *) 2674 obstack_alloc (&objfile->objfile_obstack, 2675 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2676 memcpy (objfile->section_offsets, offsets, 2677 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 2678 objfile->num_sections = num_offsets; 2679 2680 /* What the hell is sym_new_init for, anyway? The concept of 2681 distinguishing between the main file and additional files 2682 in this way seems rather dubious. */ 2683 if (objfile == symfile_objfile) 2684 { 2685 (*objfile->sf->sym_new_init) (objfile); 2686 } 2687 2688 (*objfile->sf->sym_init) (objfile); 2689 clear_complaints (&symfile_complaints, 1, 1); 2690 2691 objfile->flags &= ~OBJF_PSYMTABS_READ; 2692 read_symbols (objfile, 0); 2693 2694 if (!objfile_has_symbols (objfile)) 2695 { 2696 wrap_here (""); 2697 printf_unfiltered (_("(no debugging symbols found)\n")); 2698 wrap_here (""); 2699 } 2700 2701 /* We're done reading the symbol file; finish off complaints. */ 2702 clear_complaints (&symfile_complaints, 0, 1); 2703 2704 /* Getting new symbols may change our opinion about what is 2705 frameless. */ 2706 2707 reinit_frame_cache (); 2708 2709 /* Discard cleanups as symbol reading was successful. */ 2710 discard_cleanups (old_cleanups); 2711 2712 /* If the mtime has changed between the time we set new_modtime 2713 and now, we *want* this to be out of date, so don't call stat 2714 again now. */ 2715 objfile->mtime = new_modtime; 2716 init_entry_point_info (objfile); 2717 2718 VEC_safe_push (objfilep, new_objfiles, objfile); 2719 } 2720 } 2721 2722 if (new_objfiles) 2723 { 2724 int ix; 2725 2726 /* Notify objfiles that we've modified objfile sections. */ 2727 objfiles_changed (); 2728 2729 clear_symtab_users (0); 2730 2731 /* clear_objfile_data for each objfile was called before freeing it and 2732 observer_notify_new_objfile (NULL) has been called by 2733 clear_symtab_users above. Notify the new files now. */ 2734 for (ix = 0; VEC_iterate (objfilep, new_objfiles, ix, objfile); ix++) 2735 observer_notify_new_objfile (objfile); 2736 2737 /* At least one objfile has changed, so we can consider that 2738 the executable we're debugging has changed too. */ 2739 observer_notify_executable_changed (); 2740 } 2741 2742 do_cleanups (all_cleanups); 2743} 2744 2745 2746typedef struct 2747{ 2748 char *ext; 2749 enum language lang; 2750} 2751filename_language; 2752 2753static filename_language *filename_language_table; 2754static int fl_table_size, fl_table_next; 2755 2756static void 2757add_filename_language (char *ext, enum language lang) 2758{ 2759 if (fl_table_next >= fl_table_size) 2760 { 2761 fl_table_size += 10; 2762 filename_language_table = 2763 xrealloc (filename_language_table, 2764 fl_table_size * sizeof (*filename_language_table)); 2765 } 2766 2767 filename_language_table[fl_table_next].ext = xstrdup (ext); 2768 filename_language_table[fl_table_next].lang = lang; 2769 fl_table_next++; 2770} 2771 2772static char *ext_args; 2773static void 2774show_ext_args (struct ui_file *file, int from_tty, 2775 struct cmd_list_element *c, const char *value) 2776{ 2777 fprintf_filtered (file, 2778 _("Mapping between filename extension " 2779 "and source language is \"%s\".\n"), 2780 value); 2781} 2782 2783static void 2784set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e) 2785{ 2786 int i; 2787 char *cp = ext_args; 2788 enum language lang; 2789 2790 /* First arg is filename extension, starting with '.' */ 2791 if (*cp != '.') 2792 error (_("'%s': Filename extension must begin with '.'"), ext_args); 2793 2794 /* Find end of first arg. */ 2795 while (*cp && !isspace (*cp)) 2796 cp++; 2797 2798 if (*cp == '\0') 2799 error (_("'%s': two arguments required -- " 2800 "filename extension and language"), 2801 ext_args); 2802 2803 /* Null-terminate first arg. */ 2804 *cp++ = '\0'; 2805 2806 /* Find beginning of second arg, which should be a source language. */ 2807 cp = skip_spaces (cp); 2808 2809 if (*cp == '\0') 2810 error (_("'%s': two arguments required -- " 2811 "filename extension and language"), 2812 ext_args); 2813 2814 /* Lookup the language from among those we know. */ 2815 lang = language_enum (cp); 2816 2817 /* Now lookup the filename extension: do we already know it? */ 2818 for (i = 0; i < fl_table_next; i++) 2819 if (0 == strcmp (ext_args, filename_language_table[i].ext)) 2820 break; 2821 2822 if (i >= fl_table_next) 2823 { 2824 /* New file extension. */ 2825 add_filename_language (ext_args, lang); 2826 } 2827 else 2828 { 2829 /* Redefining a previously known filename extension. */ 2830 2831 /* if (from_tty) */ 2832 /* query ("Really make files of type %s '%s'?", */ 2833 /* ext_args, language_str (lang)); */ 2834 2835 xfree (filename_language_table[i].ext); 2836 filename_language_table[i].ext = xstrdup (ext_args); 2837 filename_language_table[i].lang = lang; 2838 } 2839} 2840 2841static void 2842info_ext_lang_command (char *args, int from_tty) 2843{ 2844 int i; 2845 2846 printf_filtered (_("Filename extensions and the languages they represent:")); 2847 printf_filtered ("\n\n"); 2848 for (i = 0; i < fl_table_next; i++) 2849 printf_filtered ("\t%s\t- %s\n", 2850 filename_language_table[i].ext, 2851 language_str (filename_language_table[i].lang)); 2852} 2853 2854static void 2855init_filename_language_table (void) 2856{ 2857 if (fl_table_size == 0) /* Protect against repetition. */ 2858 { 2859 fl_table_size = 20; 2860 fl_table_next = 0; 2861 filename_language_table = 2862 xmalloc (fl_table_size * sizeof (*filename_language_table)); 2863 add_filename_language (".c", language_c); 2864 add_filename_language (".d", language_d); 2865 add_filename_language (".C", language_cplus); 2866 add_filename_language (".cc", language_cplus); 2867 add_filename_language (".cp", language_cplus); 2868 add_filename_language (".cpp", language_cplus); 2869 add_filename_language (".cxx", language_cplus); 2870 add_filename_language (".c++", language_cplus); 2871 add_filename_language (".java", language_java); 2872 add_filename_language (".class", language_java); 2873 add_filename_language (".m", language_objc); 2874 add_filename_language (".f", language_fortran); 2875 add_filename_language (".F", language_fortran); 2876 add_filename_language (".for", language_fortran); 2877 add_filename_language (".FOR", language_fortran); 2878 add_filename_language (".ftn", language_fortran); 2879 add_filename_language (".FTN", language_fortran); 2880 add_filename_language (".fpp", language_fortran); 2881 add_filename_language (".FPP", language_fortran); 2882 add_filename_language (".f90", language_fortran); 2883 add_filename_language (".F90", language_fortran); 2884 add_filename_language (".f95", language_fortran); 2885 add_filename_language (".F95", language_fortran); 2886 add_filename_language (".f03", language_fortran); 2887 add_filename_language (".F03", language_fortran); 2888 add_filename_language (".f08", language_fortran); 2889 add_filename_language (".F08", language_fortran); 2890 add_filename_language (".s", language_asm); 2891 add_filename_language (".sx", language_asm); 2892 add_filename_language (".S", language_asm); 2893 add_filename_language (".pas", language_pascal); 2894 add_filename_language (".p", language_pascal); 2895 add_filename_language (".pp", language_pascal); 2896 add_filename_language (".adb", language_ada); 2897 add_filename_language (".ads", language_ada); 2898 add_filename_language (".a", language_ada); 2899 add_filename_language (".ada", language_ada); 2900 add_filename_language (".dg", language_ada); 2901 } 2902} 2903 2904enum language 2905deduce_language_from_filename (const char *filename) 2906{ 2907 int i; 2908 char *cp; 2909 2910 if (filename != NULL) 2911 if ((cp = strrchr (filename, '.')) != NULL) 2912 for (i = 0; i < fl_table_next; i++) 2913 if (strcmp (cp, filename_language_table[i].ext) == 0) 2914 return filename_language_table[i].lang; 2915 2916 return language_unknown; 2917} 2918 2919/* Allocate and initialize a new symbol table. 2920 CUST is from the result of allocate_compunit_symtab. */ 2921 2922struct symtab * 2923allocate_symtab (struct compunit_symtab *cust, const char *filename) 2924{ 2925 struct objfile *objfile = cust->objfile; 2926 struct symtab *symtab 2927 = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab); 2928 2929 symtab->filename = bcache (filename, strlen (filename) + 1, 2930 objfile->per_bfd->filename_cache); 2931 symtab->fullname = NULL; 2932 symtab->language = deduce_language_from_filename (filename); 2933 2934 /* This can be very verbose with lots of headers. 2935 Only print at higher debug levels. */ 2936 if (symtab_create_debug >= 2) 2937 { 2938 /* Be a bit clever with debugging messages, and don't print objfile 2939 every time, only when it changes. */ 2940 static char *last_objfile_name = NULL; 2941 2942 if (last_objfile_name == NULL 2943 || strcmp (last_objfile_name, objfile_name (objfile)) != 0) 2944 { 2945 xfree (last_objfile_name); 2946 last_objfile_name = xstrdup (objfile_name (objfile)); 2947 fprintf_unfiltered (gdb_stdlog, 2948 "Creating one or more symtabs for objfile %s ...\n", 2949 last_objfile_name); 2950 } 2951 fprintf_unfiltered (gdb_stdlog, 2952 "Created symtab %s for module %s.\n", 2953 host_address_to_string (symtab), filename); 2954 } 2955 2956 /* Add it to CUST's list of symtabs. */ 2957 if (cust->filetabs == NULL) 2958 { 2959 cust->filetabs = symtab; 2960 cust->last_filetab = symtab; 2961 } 2962 else 2963 { 2964 cust->last_filetab->next = symtab; 2965 cust->last_filetab = symtab; 2966 } 2967 2968 /* Backlink to the containing compunit symtab. */ 2969 symtab->compunit_symtab = cust; 2970 2971 return symtab; 2972} 2973 2974/* Allocate and initialize a new compunit. 2975 NAME is the name of the main source file, if there is one, or some 2976 descriptive text if there are no source files. */ 2977 2978struct compunit_symtab * 2979allocate_compunit_symtab (struct objfile *objfile, const char *name) 2980{ 2981 struct compunit_symtab *cu = OBSTACK_ZALLOC (&objfile->objfile_obstack, 2982 struct compunit_symtab); 2983 const char *saved_name; 2984 2985 cu->objfile = objfile; 2986 2987 /* The name we record here is only for display/debugging purposes. 2988 Just save the basename to avoid path issues (too long for display, 2989 relative vs absolute, etc.). */ 2990 saved_name = lbasename (name); 2991 cu->name = obstack_copy0 (&objfile->objfile_obstack, saved_name, 2992 strlen (saved_name)); 2993 2994 COMPUNIT_DEBUGFORMAT (cu) = "unknown"; 2995 2996 if (symtab_create_debug) 2997 { 2998 fprintf_unfiltered (gdb_stdlog, 2999 "Created compunit symtab %s for %s.\n", 3000 host_address_to_string (cu), 3001 cu->name); 3002 } 3003 3004 return cu; 3005} 3006 3007/* Hook CU to the objfile it comes from. */ 3008 3009void 3010add_compunit_symtab_to_objfile (struct compunit_symtab *cu) 3011{ 3012 cu->next = cu->objfile->compunit_symtabs; 3013 cu->objfile->compunit_symtabs = cu; 3014} 3015 3016 3017/* Reset all data structures in gdb which may contain references to symbol 3018 table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */ 3019 3020void 3021clear_symtab_users (int add_flags) 3022{ 3023 /* Someday, we should do better than this, by only blowing away 3024 the things that really need to be blown. */ 3025 3026 /* Clear the "current" symtab first, because it is no longer valid. 3027 breakpoint_re_set may try to access the current symtab. */ 3028 clear_current_source_symtab_and_line (); 3029 3030 clear_displays (); 3031 clear_last_displayed_sal (); 3032 clear_pc_function_cache (); 3033 observer_notify_new_objfile (NULL); 3034 3035 /* Clear globals which might have pointed into a removed objfile. 3036 FIXME: It's not clear which of these are supposed to persist 3037 between expressions and which ought to be reset each time. */ 3038 expression_context_block = NULL; 3039 innermost_block = NULL; 3040 3041 /* Varobj may refer to old symbols, perform a cleanup. */ 3042 varobj_invalidate (); 3043 3044 /* Now that the various caches have been cleared, we can re_set 3045 our breakpoints without risking it using stale data. */ 3046 if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0) 3047 breakpoint_re_set (); 3048} 3049 3050static void 3051clear_symtab_users_cleanup (void *ignore) 3052{ 3053 clear_symtab_users (0); 3054} 3055 3056/* OVERLAYS: 3057 The following code implements an abstraction for debugging overlay sections. 3058 3059 The target model is as follows: 3060 1) The gnu linker will permit multiple sections to be mapped into the 3061 same VMA, each with its own unique LMA (or load address). 3062 2) It is assumed that some runtime mechanism exists for mapping the 3063 sections, one by one, from the load address into the VMA address. 3064 3) This code provides a mechanism for gdb to keep track of which 3065 sections should be considered to be mapped from the VMA to the LMA. 3066 This information is used for symbol lookup, and memory read/write. 3067 For instance, if a section has been mapped then its contents 3068 should be read from the VMA, otherwise from the LMA. 3069 3070 Two levels of debugger support for overlays are available. One is 3071 "manual", in which the debugger relies on the user to tell it which 3072 overlays are currently mapped. This level of support is 3073 implemented entirely in the core debugger, and the information about 3074 whether a section is mapped is kept in the objfile->obj_section table. 3075 3076 The second level of support is "automatic", and is only available if 3077 the target-specific code provides functionality to read the target's 3078 overlay mapping table, and translate its contents for the debugger 3079 (by updating the mapped state information in the obj_section tables). 3080 3081 The interface is as follows: 3082 User commands: 3083 overlay map <name> -- tell gdb to consider this section mapped 3084 overlay unmap <name> -- tell gdb to consider this section unmapped 3085 overlay list -- list the sections that GDB thinks are mapped 3086 overlay read-target -- get the target's state of what's mapped 3087 overlay off/manual/auto -- set overlay debugging state 3088 Functional interface: 3089 find_pc_mapped_section(pc): if the pc is in the range of a mapped 3090 section, return that section. 3091 find_pc_overlay(pc): find any overlay section that contains 3092 the pc, either in its VMA or its LMA 3093 section_is_mapped(sect): true if overlay is marked as mapped 3094 section_is_overlay(sect): true if section's VMA != LMA 3095 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA 3096 pc_in_unmapped_range(...): true if pc belongs to section's LMA 3097 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap 3098 overlay_mapped_address(...): map an address from section's LMA to VMA 3099 overlay_unmapped_address(...): map an address from section's VMA to LMA 3100 symbol_overlayed_address(...): Return a "current" address for symbol: 3101 either in VMA or LMA depending on whether 3102 the symbol's section is currently mapped. */ 3103 3104/* Overlay debugging state: */ 3105 3106enum overlay_debugging_state overlay_debugging = ovly_off; 3107int overlay_cache_invalid = 0; /* True if need to refresh mapped state. */ 3108 3109/* Function: section_is_overlay (SECTION) 3110 Returns true if SECTION has VMA not equal to LMA, ie. 3111 SECTION is loaded at an address different from where it will "run". */ 3112 3113int 3114section_is_overlay (struct obj_section *section) 3115{ 3116 if (overlay_debugging && section) 3117 { 3118 bfd *abfd = section->objfile->obfd; 3119 asection *bfd_section = section->the_bfd_section; 3120 3121 if (bfd_section_lma (abfd, bfd_section) != 0 3122 && bfd_section_lma (abfd, bfd_section) 3123 != bfd_section_vma (abfd, bfd_section)) 3124 return 1; 3125 } 3126 3127 return 0; 3128} 3129 3130/* Function: overlay_invalidate_all (void) 3131 Invalidate the mapped state of all overlay sections (mark it as stale). */ 3132 3133static void 3134overlay_invalidate_all (void) 3135{ 3136 struct objfile *objfile; 3137 struct obj_section *sect; 3138 3139 ALL_OBJSECTIONS (objfile, sect) 3140 if (section_is_overlay (sect)) 3141 sect->ovly_mapped = -1; 3142} 3143 3144/* Function: section_is_mapped (SECTION) 3145 Returns true if section is an overlay, and is currently mapped. 3146 3147 Access to the ovly_mapped flag is restricted to this function, so 3148 that we can do automatic update. If the global flag 3149 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call 3150 overlay_invalidate_all. If the mapped state of the particular 3151 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */ 3152 3153int 3154section_is_mapped (struct obj_section *osect) 3155{ 3156 struct gdbarch *gdbarch; 3157 3158 if (osect == 0 || !section_is_overlay (osect)) 3159 return 0; 3160 3161 switch (overlay_debugging) 3162 { 3163 default: 3164 case ovly_off: 3165 return 0; /* overlay debugging off */ 3166 case ovly_auto: /* overlay debugging automatic */ 3167 /* Unles there is a gdbarch_overlay_update function, 3168 there's really nothing useful to do here (can't really go auto). */ 3169 gdbarch = get_objfile_arch (osect->objfile); 3170 if (gdbarch_overlay_update_p (gdbarch)) 3171 { 3172 if (overlay_cache_invalid) 3173 { 3174 overlay_invalidate_all (); 3175 overlay_cache_invalid = 0; 3176 } 3177 if (osect->ovly_mapped == -1) 3178 gdbarch_overlay_update (gdbarch, osect); 3179 } 3180 /* fall thru to manual case */ 3181 case ovly_on: /* overlay debugging manual */ 3182 return osect->ovly_mapped == 1; 3183 } 3184} 3185 3186/* Function: pc_in_unmapped_range 3187 If PC falls into the lma range of SECTION, return true, else false. */ 3188 3189CORE_ADDR 3190pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section) 3191{ 3192 if (section_is_overlay (section)) 3193 { 3194 bfd *abfd = section->objfile->obfd; 3195 asection *bfd_section = section->the_bfd_section; 3196 3197 /* We assume the LMA is relocated by the same offset as the VMA. */ 3198 bfd_vma size = bfd_get_section_size (bfd_section); 3199 CORE_ADDR offset = obj_section_offset (section); 3200 3201 if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc 3202 && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size) 3203 return 1; 3204 } 3205 3206 return 0; 3207} 3208 3209/* Function: pc_in_mapped_range 3210 If PC falls into the vma range of SECTION, return true, else false. */ 3211 3212CORE_ADDR 3213pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section) 3214{ 3215 if (section_is_overlay (section)) 3216 { 3217 if (obj_section_addr (section) <= pc 3218 && pc < obj_section_endaddr (section)) 3219 return 1; 3220 } 3221 3222 return 0; 3223} 3224 3225/* Return true if the mapped ranges of sections A and B overlap, false 3226 otherwise. */ 3227 3228static int 3229sections_overlap (struct obj_section *a, struct obj_section *b) 3230{ 3231 CORE_ADDR a_start = obj_section_addr (a); 3232 CORE_ADDR a_end = obj_section_endaddr (a); 3233 CORE_ADDR b_start = obj_section_addr (b); 3234 CORE_ADDR b_end = obj_section_endaddr (b); 3235 3236 return (a_start < b_end && b_start < a_end); 3237} 3238 3239/* Function: overlay_unmapped_address (PC, SECTION) 3240 Returns the address corresponding to PC in the unmapped (load) range. 3241 May be the same as PC. */ 3242 3243CORE_ADDR 3244overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section) 3245{ 3246 if (section_is_overlay (section) && pc_in_mapped_range (pc, section)) 3247 { 3248 bfd *abfd = section->objfile->obfd; 3249 asection *bfd_section = section->the_bfd_section; 3250 3251 return pc + bfd_section_lma (abfd, bfd_section) 3252 - bfd_section_vma (abfd, bfd_section); 3253 } 3254 3255 return pc; 3256} 3257 3258/* Function: overlay_mapped_address (PC, SECTION) 3259 Returns the address corresponding to PC in the mapped (runtime) range. 3260 May be the same as PC. */ 3261 3262CORE_ADDR 3263overlay_mapped_address (CORE_ADDR pc, struct obj_section *section) 3264{ 3265 if (section_is_overlay (section) && pc_in_unmapped_range (pc, section)) 3266 { 3267 bfd *abfd = section->objfile->obfd; 3268 asection *bfd_section = section->the_bfd_section; 3269 3270 return pc + bfd_section_vma (abfd, bfd_section) 3271 - bfd_section_lma (abfd, bfd_section); 3272 } 3273 3274 return pc; 3275} 3276 3277/* Function: symbol_overlayed_address 3278 Return one of two addresses (relative to the VMA or to the LMA), 3279 depending on whether the section is mapped or not. */ 3280 3281CORE_ADDR 3282symbol_overlayed_address (CORE_ADDR address, struct obj_section *section) 3283{ 3284 if (overlay_debugging) 3285 { 3286 /* If the symbol has no section, just return its regular address. */ 3287 if (section == 0) 3288 return address; 3289 /* If the symbol's section is not an overlay, just return its 3290 address. */ 3291 if (!section_is_overlay (section)) 3292 return address; 3293 /* If the symbol's section is mapped, just return its address. */ 3294 if (section_is_mapped (section)) 3295 return address; 3296 /* 3297 * HOWEVER: if the symbol is in an overlay section which is NOT mapped, 3298 * then return its LOADED address rather than its vma address!! 3299 */ 3300 return overlay_unmapped_address (address, section); 3301 } 3302 return address; 3303} 3304 3305/* Function: find_pc_overlay (PC) 3306 Return the best-match overlay section for PC: 3307 If PC matches a mapped overlay section's VMA, return that section. 3308 Else if PC matches an unmapped section's VMA, return that section. 3309 Else if PC matches an unmapped section's LMA, return that section. */ 3310 3311struct obj_section * 3312find_pc_overlay (CORE_ADDR pc) 3313{ 3314 struct objfile *objfile; 3315 struct obj_section *osect, *best_match = NULL; 3316 3317 if (overlay_debugging) 3318 ALL_OBJSECTIONS (objfile, osect) 3319 if (section_is_overlay (osect)) 3320 { 3321 if (pc_in_mapped_range (pc, osect)) 3322 { 3323 if (section_is_mapped (osect)) 3324 return osect; 3325 else 3326 best_match = osect; 3327 } 3328 else if (pc_in_unmapped_range (pc, osect)) 3329 best_match = osect; 3330 } 3331 return best_match; 3332} 3333 3334/* Function: find_pc_mapped_section (PC) 3335 If PC falls into the VMA address range of an overlay section that is 3336 currently marked as MAPPED, return that section. Else return NULL. */ 3337 3338struct obj_section * 3339find_pc_mapped_section (CORE_ADDR pc) 3340{ 3341 struct objfile *objfile; 3342 struct obj_section *osect; 3343 3344 if (overlay_debugging) 3345 ALL_OBJSECTIONS (objfile, osect) 3346 if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect)) 3347 return osect; 3348 3349 return NULL; 3350} 3351 3352/* Function: list_overlays_command 3353 Print a list of mapped sections and their PC ranges. */ 3354 3355static void 3356list_overlays_command (char *args, int from_tty) 3357{ 3358 int nmapped = 0; 3359 struct objfile *objfile; 3360 struct obj_section *osect; 3361 3362 if (overlay_debugging) 3363 ALL_OBJSECTIONS (objfile, osect) 3364 if (section_is_mapped (osect)) 3365 { 3366 struct gdbarch *gdbarch = get_objfile_arch (objfile); 3367 const char *name; 3368 bfd_vma lma, vma; 3369 int size; 3370 3371 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section); 3372 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section); 3373 size = bfd_get_section_size (osect->the_bfd_section); 3374 name = bfd_section_name (objfile->obfd, osect->the_bfd_section); 3375 3376 printf_filtered ("Section %s, loaded at ", name); 3377 fputs_filtered (paddress (gdbarch, lma), gdb_stdout); 3378 puts_filtered (" - "); 3379 fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout); 3380 printf_filtered (", mapped at "); 3381 fputs_filtered (paddress (gdbarch, vma), gdb_stdout); 3382 puts_filtered (" - "); 3383 fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout); 3384 puts_filtered ("\n"); 3385 3386 nmapped++; 3387 } 3388 if (nmapped == 0) 3389 printf_filtered (_("No sections are mapped.\n")); 3390} 3391 3392/* Function: map_overlay_command 3393 Mark the named section as mapped (ie. residing at its VMA address). */ 3394 3395static void 3396map_overlay_command (char *args, int from_tty) 3397{ 3398 struct objfile *objfile, *objfile2; 3399 struct obj_section *sec, *sec2; 3400 3401 if (!overlay_debugging) 3402 error (_("Overlay debugging not enabled. Use " 3403 "either the 'overlay auto' or\n" 3404 "the 'overlay manual' command.")); 3405 3406 if (args == 0 || *args == 0) 3407 error (_("Argument required: name of an overlay section")); 3408 3409 /* First, find a section matching the user supplied argument. */ 3410 ALL_OBJSECTIONS (objfile, sec) 3411 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3412 { 3413 /* Now, check to see if the section is an overlay. */ 3414 if (!section_is_overlay (sec)) 3415 continue; /* not an overlay section */ 3416 3417 /* Mark the overlay as "mapped". */ 3418 sec->ovly_mapped = 1; 3419 3420 /* Next, make a pass and unmap any sections that are 3421 overlapped by this new section: */ 3422 ALL_OBJSECTIONS (objfile2, sec2) 3423 if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2)) 3424 { 3425 if (info_verbose) 3426 printf_unfiltered (_("Note: section %s unmapped by overlap\n"), 3427 bfd_section_name (objfile->obfd, 3428 sec2->the_bfd_section)); 3429 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2. */ 3430 } 3431 return; 3432 } 3433 error (_("No overlay section called %s"), args); 3434} 3435 3436/* Function: unmap_overlay_command 3437 Mark the overlay section as unmapped 3438 (ie. resident in its LMA address range, rather than the VMA range). */ 3439 3440static void 3441unmap_overlay_command (char *args, int from_tty) 3442{ 3443 struct objfile *objfile; 3444 struct obj_section *sec; 3445 3446 if (!overlay_debugging) 3447 error (_("Overlay debugging not enabled. " 3448 "Use either the 'overlay auto' or\n" 3449 "the 'overlay manual' command.")); 3450 3451 if (args == 0 || *args == 0) 3452 error (_("Argument required: name of an overlay section")); 3453 3454 /* First, find a section matching the user supplied argument. */ 3455 ALL_OBJSECTIONS (objfile, sec) 3456 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3457 { 3458 if (!sec->ovly_mapped) 3459 error (_("Section %s is not mapped"), args); 3460 sec->ovly_mapped = 0; 3461 return; 3462 } 3463 error (_("No overlay section called %s"), args); 3464} 3465 3466/* Function: overlay_auto_command 3467 A utility command to turn on overlay debugging. 3468 Possibly this should be done via a set/show command. */ 3469 3470static void 3471overlay_auto_command (char *args, int from_tty) 3472{ 3473 overlay_debugging = ovly_auto; 3474 enable_overlay_breakpoints (); 3475 if (info_verbose) 3476 printf_unfiltered (_("Automatic overlay debugging enabled.")); 3477} 3478 3479/* Function: overlay_manual_command 3480 A utility command to turn on overlay debugging. 3481 Possibly this should be done via a set/show command. */ 3482 3483static void 3484overlay_manual_command (char *args, int from_tty) 3485{ 3486 overlay_debugging = ovly_on; 3487 disable_overlay_breakpoints (); 3488 if (info_verbose) 3489 printf_unfiltered (_("Overlay debugging enabled.")); 3490} 3491 3492/* Function: overlay_off_command 3493 A utility command to turn on overlay debugging. 3494 Possibly this should be done via a set/show command. */ 3495 3496static void 3497overlay_off_command (char *args, int from_tty) 3498{ 3499 overlay_debugging = ovly_off; 3500 disable_overlay_breakpoints (); 3501 if (info_verbose) 3502 printf_unfiltered (_("Overlay debugging disabled.")); 3503} 3504 3505static void 3506overlay_load_command (char *args, int from_tty) 3507{ 3508 struct gdbarch *gdbarch = get_current_arch (); 3509 3510 if (gdbarch_overlay_update_p (gdbarch)) 3511 gdbarch_overlay_update (gdbarch, NULL); 3512 else 3513 error (_("This target does not know how to read its overlay state.")); 3514} 3515 3516/* Function: overlay_command 3517 A place-holder for a mis-typed command. */ 3518 3519/* Command list chain containing all defined "overlay" subcommands. */ 3520static struct cmd_list_element *overlaylist; 3521 3522static void 3523overlay_command (char *args, int from_tty) 3524{ 3525 printf_unfiltered 3526 ("\"overlay\" must be followed by the name of an overlay command.\n"); 3527 help_list (overlaylist, "overlay ", all_commands, gdb_stdout); 3528} 3529 3530/* Target Overlays for the "Simplest" overlay manager: 3531 3532 This is GDB's default target overlay layer. It works with the 3533 minimal overlay manager supplied as an example by Cygnus. The 3534 entry point is via a function pointer "gdbarch_overlay_update", 3535 so targets that use a different runtime overlay manager can 3536 substitute their own overlay_update function and take over the 3537 function pointer. 3538 3539 The overlay_update function pokes around in the target's data structures 3540 to see what overlays are mapped, and updates GDB's overlay mapping with 3541 this information. 3542 3543 In this simple implementation, the target data structures are as follows: 3544 unsigned _novlys; /# number of overlay sections #/ 3545 unsigned _ovly_table[_novlys][4] = { 3546 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/ 3547 {..., ..., ..., ...}, 3548 } 3549 unsigned _novly_regions; /# number of overlay regions #/ 3550 unsigned _ovly_region_table[_novly_regions][3] = { 3551 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/ 3552 {..., ..., ...}, 3553 } 3554 These functions will attempt to update GDB's mappedness state in the 3555 symbol section table, based on the target's mappedness state. 3556 3557 To do this, we keep a cached copy of the target's _ovly_table, and 3558 attempt to detect when the cached copy is invalidated. The main 3559 entry point is "simple_overlay_update(SECT), which looks up SECT in 3560 the cached table and re-reads only the entry for that section from 3561 the target (whenever possible). */ 3562 3563/* Cached, dynamically allocated copies of the target data structures: */ 3564static unsigned (*cache_ovly_table)[4] = 0; 3565static unsigned cache_novlys = 0; 3566static CORE_ADDR cache_ovly_table_base = 0; 3567enum ovly_index 3568 { 3569 VMA, SIZE, LMA, MAPPED 3570 }; 3571 3572/* Throw away the cached copy of _ovly_table. */ 3573 3574static void 3575simple_free_overlay_table (void) 3576{ 3577 if (cache_ovly_table) 3578 xfree (cache_ovly_table); 3579 cache_novlys = 0; 3580 cache_ovly_table = NULL; 3581 cache_ovly_table_base = 0; 3582} 3583 3584/* Read an array of ints of size SIZE from the target into a local buffer. 3585 Convert to host order. int LEN is number of ints. */ 3586 3587static void 3588read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, 3589 int len, int size, enum bfd_endian byte_order) 3590{ 3591 /* FIXME (alloca): Not safe if array is very large. */ 3592 gdb_byte *buf = alloca (len * size); 3593 int i; 3594 3595 read_memory (memaddr, buf, len * size); 3596 for (i = 0; i < len; i++) 3597 myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order); 3598} 3599 3600/* Find and grab a copy of the target _ovly_table 3601 (and _novlys, which is needed for the table's size). */ 3602 3603static int 3604simple_read_overlay_table (void) 3605{ 3606 struct bound_minimal_symbol novlys_msym; 3607 struct bound_minimal_symbol ovly_table_msym; 3608 struct gdbarch *gdbarch; 3609 int word_size; 3610 enum bfd_endian byte_order; 3611 3612 simple_free_overlay_table (); 3613 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL); 3614 if (! novlys_msym.minsym) 3615 { 3616 error (_("Error reading inferior's overlay table: " 3617 "couldn't find `_novlys' variable\n" 3618 "in inferior. Use `overlay manual' mode.")); 3619 return 0; 3620 } 3621 3622 ovly_table_msym = lookup_bound_minimal_symbol ("_ovly_table"); 3623 if (! ovly_table_msym.minsym) 3624 { 3625 error (_("Error reading inferior's overlay table: couldn't find " 3626 "`_ovly_table' array\n" 3627 "in inferior. Use `overlay manual' mode.")); 3628 return 0; 3629 } 3630 3631 gdbarch = get_objfile_arch (ovly_table_msym.objfile); 3632 word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 3633 byte_order = gdbarch_byte_order (gdbarch); 3634 3635 cache_novlys = read_memory_integer (BMSYMBOL_VALUE_ADDRESS (novlys_msym), 3636 4, byte_order); 3637 cache_ovly_table 3638 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table)); 3639 cache_ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym); 3640 read_target_long_array (cache_ovly_table_base, 3641 (unsigned int *) cache_ovly_table, 3642 cache_novlys * 4, word_size, byte_order); 3643 3644 return 1; /* SUCCESS */ 3645} 3646 3647/* Function: simple_overlay_update_1 3648 A helper function for simple_overlay_update. Assuming a cached copy 3649 of _ovly_table exists, look through it to find an entry whose vma, 3650 lma and size match those of OSECT. Re-read the entry and make sure 3651 it still matches OSECT (else the table may no longer be valid). 3652 Set OSECT's mapped state to match the entry. Return: 1 for 3653 success, 0 for failure. */ 3654 3655static int 3656simple_overlay_update_1 (struct obj_section *osect) 3657{ 3658 int i, size; 3659 bfd *obfd = osect->objfile->obfd; 3660 asection *bsect = osect->the_bfd_section; 3661 struct gdbarch *gdbarch = get_objfile_arch (osect->objfile); 3662 int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; 3663 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 3664 3665 size = bfd_get_section_size (osect->the_bfd_section); 3666 for (i = 0; i < cache_novlys; i++) 3667 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3668 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3669 /* && cache_ovly_table[i][SIZE] == size */ ) 3670 { 3671 read_target_long_array (cache_ovly_table_base + i * word_size, 3672 (unsigned int *) cache_ovly_table[i], 3673 4, word_size, byte_order); 3674 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3675 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3676 /* && cache_ovly_table[i][SIZE] == size */ ) 3677 { 3678 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3679 return 1; 3680 } 3681 else /* Warning! Warning! Target's ovly table has changed! */ 3682 return 0; 3683 } 3684 return 0; 3685} 3686 3687/* Function: simple_overlay_update 3688 If OSECT is NULL, then update all sections' mapped state 3689 (after re-reading the entire target _ovly_table). 3690 If OSECT is non-NULL, then try to find a matching entry in the 3691 cached ovly_table and update only OSECT's mapped state. 3692 If a cached entry can't be found or the cache isn't valid, then 3693 re-read the entire cache, and go ahead and update all sections. */ 3694 3695void 3696simple_overlay_update (struct obj_section *osect) 3697{ 3698 struct objfile *objfile; 3699 3700 /* Were we given an osect to look up? NULL means do all of them. */ 3701 if (osect) 3702 /* Have we got a cached copy of the target's overlay table? */ 3703 if (cache_ovly_table != NULL) 3704 { 3705 /* Does its cached location match what's currently in the 3706 symtab? */ 3707 struct bound_minimal_symbol minsym 3708 = lookup_minimal_symbol ("_ovly_table", NULL, NULL); 3709 3710 if (minsym.minsym == NULL) 3711 error (_("Error reading inferior's overlay table: couldn't " 3712 "find `_ovly_table' array\n" 3713 "in inferior. Use `overlay manual' mode.")); 3714 3715 if (cache_ovly_table_base == BMSYMBOL_VALUE_ADDRESS (minsym)) 3716 /* Then go ahead and try to look up this single section in 3717 the cache. */ 3718 if (simple_overlay_update_1 (osect)) 3719 /* Found it! We're done. */ 3720 return; 3721 } 3722 3723 /* Cached table no good: need to read the entire table anew. 3724 Or else we want all the sections, in which case it's actually 3725 more efficient to read the whole table in one block anyway. */ 3726 3727 if (! simple_read_overlay_table ()) 3728 return; 3729 3730 /* Now may as well update all sections, even if only one was requested. */ 3731 ALL_OBJSECTIONS (objfile, osect) 3732 if (section_is_overlay (osect)) 3733 { 3734 int i, size; 3735 bfd *obfd = osect->objfile->obfd; 3736 asection *bsect = osect->the_bfd_section; 3737 3738 size = bfd_get_section_size (bsect); 3739 for (i = 0; i < cache_novlys; i++) 3740 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3741 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3742 /* && cache_ovly_table[i][SIZE] == size */ ) 3743 { /* obj_section matches i'th entry in ovly_table. */ 3744 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3745 break; /* finished with inner for loop: break out. */ 3746 } 3747 } 3748} 3749 3750/* Set the output sections and output offsets for section SECTP in 3751 ABFD. The relocation code in BFD will read these offsets, so we 3752 need to be sure they're initialized. We map each section to itself, 3753 with no offset; this means that SECTP->vma will be honored. */ 3754 3755static void 3756symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy) 3757{ 3758 sectp->output_section = sectp; 3759 sectp->output_offset = 0; 3760} 3761 3762/* Default implementation for sym_relocate. */ 3763 3764bfd_byte * 3765default_symfile_relocate (struct objfile *objfile, asection *sectp, 3766 bfd_byte *buf) 3767{ 3768 /* Use sectp->owner instead of objfile->obfd. sectp may point to a 3769 DWO file. */ 3770 bfd *abfd = sectp->owner; 3771 3772 /* We're only interested in sections with relocation 3773 information. */ 3774 if ((sectp->flags & SEC_RELOC) == 0) 3775 return NULL; 3776 3777 /* We will handle section offsets properly elsewhere, so relocate as if 3778 all sections begin at 0. */ 3779 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL); 3780 3781 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); 3782} 3783 3784/* Relocate the contents of a debug section SECTP in ABFD. The 3785 contents are stored in BUF if it is non-NULL, or returned in a 3786 malloc'd buffer otherwise. 3787 3788 For some platforms and debug info formats, shared libraries contain 3789 relocations against the debug sections (particularly for DWARF-2; 3790 one affected platform is PowerPC GNU/Linux, although it depends on 3791 the version of the linker in use). Also, ELF object files naturally 3792 have unresolved relocations for their debug sections. We need to apply 3793 the relocations in order to get the locations of symbols correct. 3794 Another example that may require relocation processing, is the 3795 DWARF-2 .eh_frame section in .o files, although it isn't strictly a 3796 debug section. */ 3797 3798bfd_byte * 3799symfile_relocate_debug_section (struct objfile *objfile, 3800 asection *sectp, bfd_byte *buf) 3801{ 3802 gdb_assert (objfile->sf->sym_relocate); 3803 3804 return (*objfile->sf->sym_relocate) (objfile, sectp, buf); 3805} 3806 3807struct symfile_segment_data * 3808get_symfile_segment_data (bfd *abfd) 3809{ 3810 const struct sym_fns *sf = find_sym_fns (abfd); 3811 3812 if (sf == NULL) 3813 return NULL; 3814 3815 return sf->sym_segments (abfd); 3816} 3817 3818void 3819free_symfile_segment_data (struct symfile_segment_data *data) 3820{ 3821 xfree (data->segment_bases); 3822 xfree (data->segment_sizes); 3823 xfree (data->segment_info); 3824 xfree (data); 3825} 3826 3827/* Given: 3828 - DATA, containing segment addresses from the object file ABFD, and 3829 the mapping from ABFD's sections onto the segments that own them, 3830 and 3831 - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual 3832 segment addresses reported by the target, 3833 store the appropriate offsets for each section in OFFSETS. 3834 3835 If there are fewer entries in SEGMENT_BASES than there are segments 3836 in DATA, then apply SEGMENT_BASES' last entry to all the segments. 3837 3838 If there are more entries, then ignore the extra. The target may 3839 not be able to distinguish between an empty data segment and a 3840 missing data segment; a missing text segment is less plausible. */ 3841 3842int 3843symfile_map_offsets_to_segments (bfd *abfd, 3844 const struct symfile_segment_data *data, 3845 struct section_offsets *offsets, 3846 int num_segment_bases, 3847 const CORE_ADDR *segment_bases) 3848{ 3849 int i; 3850 asection *sect; 3851 3852 /* It doesn't make sense to call this function unless you have some 3853 segment base addresses. */ 3854 gdb_assert (num_segment_bases > 0); 3855 3856 /* If we do not have segment mappings for the object file, we 3857 can not relocate it by segments. */ 3858 gdb_assert (data != NULL); 3859 gdb_assert (data->num_segments > 0); 3860 3861 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 3862 { 3863 int which = data->segment_info[i]; 3864 3865 gdb_assert (0 <= which && which <= data->num_segments); 3866 3867 /* Don't bother computing offsets for sections that aren't 3868 loaded as part of any segment. */ 3869 if (! which) 3870 continue; 3871 3872 /* Use the last SEGMENT_BASES entry as the address of any extra 3873 segments mentioned in DATA->segment_info. */ 3874 if (which > num_segment_bases) 3875 which = num_segment_bases; 3876 3877 offsets->offsets[i] = (segment_bases[which - 1] 3878 - data->segment_bases[which - 1]); 3879 } 3880 3881 return 1; 3882} 3883 3884static void 3885symfile_find_segment_sections (struct objfile *objfile) 3886{ 3887 bfd *abfd = objfile->obfd; 3888 int i; 3889 asection *sect; 3890 struct symfile_segment_data *data; 3891 3892 data = get_symfile_segment_data (objfile->obfd); 3893 if (data == NULL) 3894 return; 3895 3896 if (data->num_segments != 1 && data->num_segments != 2) 3897 { 3898 free_symfile_segment_data (data); 3899 return; 3900 } 3901 3902 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) 3903 { 3904 int which = data->segment_info[i]; 3905 3906 if (which == 1) 3907 { 3908 if (objfile->sect_index_text == -1) 3909 objfile->sect_index_text = sect->index; 3910 3911 if (objfile->sect_index_rodata == -1) 3912 objfile->sect_index_rodata = sect->index; 3913 } 3914 else if (which == 2) 3915 { 3916 if (objfile->sect_index_data == -1) 3917 objfile->sect_index_data = sect->index; 3918 3919 if (objfile->sect_index_bss == -1) 3920 objfile->sect_index_bss = sect->index; 3921 } 3922 } 3923 3924 free_symfile_segment_data (data); 3925} 3926 3927/* Listen for free_objfile events. */ 3928 3929static void 3930symfile_free_objfile (struct objfile *objfile) 3931{ 3932 /* Remove the target sections owned by this objfile. */ 3933 if (objfile != NULL) 3934 remove_target_sections ((void *) objfile); 3935} 3936 3937/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method". 3938 Expand all symtabs that match the specified criteria. 3939 See quick_symbol_functions.expand_symtabs_matching for details. */ 3940 3941void 3942expand_symtabs_matching (expand_symtabs_file_matcher_ftype *file_matcher, 3943 expand_symtabs_symbol_matcher_ftype *symbol_matcher, 3944 enum search_domain kind, 3945 void *data) 3946{ 3947 struct objfile *objfile; 3948 3949 ALL_OBJFILES (objfile) 3950 { 3951 if (objfile->sf) 3952 objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher, 3953 symbol_matcher, kind, 3954 data); 3955 } 3956} 3957 3958/* Wrapper around the quick_symbol_functions map_symbol_filenames "method". 3959 Map function FUN over every file. 3960 See quick_symbol_functions.map_symbol_filenames for details. */ 3961 3962void 3963map_symbol_filenames (symbol_filename_ftype *fun, void *data, 3964 int need_fullname) 3965{ 3966 struct objfile *objfile; 3967 3968 ALL_OBJFILES (objfile) 3969 { 3970 if (objfile->sf) 3971 objfile->sf->qf->map_symbol_filenames (objfile, fun, data, 3972 need_fullname); 3973 } 3974} 3975 3976void 3977_initialize_symfile (void) 3978{ 3979 struct cmd_list_element *c; 3980 3981 observer_attach_free_objfile (symfile_free_objfile); 3982 3983 c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\ 3984Load symbol table from executable file FILE.\n\ 3985The `file' command can also load symbol tables, as well as setting the file\n\ 3986to execute."), &cmdlist); 3987 set_cmd_completer (c, filename_completer); 3988 3989 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\ 3990Load symbols from FILE, assuming FILE has been dynamically loaded.\n\ 3991Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\ 3992 ...]\nADDR is the starting address of the file's text.\n\ 3993The optional arguments are section-name section-address pairs and\n\ 3994should be specified if the data and bss segments are not contiguous\n\ 3995with the text. SECT is a section name to be loaded at SECT_ADDR."), 3996 &cmdlist); 3997 set_cmd_completer (c, filename_completer); 3998 3999 c = add_cmd ("remove-symbol-file", class_files, 4000 remove_symbol_file_command, _("\ 4001Remove a symbol file added via the add-symbol-file command.\n\ 4002Usage: remove-symbol-file FILENAME\n\ 4003 remove-symbol-file -a ADDRESS\n\ 4004The file to remove can be identified by its filename or by an address\n\ 4005that lies within the boundaries of this symbol file in memory."), 4006 &cmdlist); 4007 4008 c = add_cmd ("load", class_files, load_command, _("\ 4009Dynamically load FILE into the running program, and record its symbols\n\ 4010for access from GDB.\n\ 4011A load OFFSET may also be given."), &cmdlist); 4012 set_cmd_completer (c, filename_completer); 4013 4014 add_prefix_cmd ("overlay", class_support, overlay_command, 4015 _("Commands for debugging overlays."), &overlaylist, 4016 "overlay ", 0, &cmdlist); 4017 4018 add_com_alias ("ovly", "overlay", class_alias, 1); 4019 add_com_alias ("ov", "overlay", class_alias, 1); 4020 4021 add_cmd ("map-overlay", class_support, map_overlay_command, 4022 _("Assert that an overlay section is mapped."), &overlaylist); 4023 4024 add_cmd ("unmap-overlay", class_support, unmap_overlay_command, 4025 _("Assert that an overlay section is unmapped."), &overlaylist); 4026 4027 add_cmd ("list-overlays", class_support, list_overlays_command, 4028 _("List mappings of overlay sections."), &overlaylist); 4029 4030 add_cmd ("manual", class_support, overlay_manual_command, 4031 _("Enable overlay debugging."), &overlaylist); 4032 add_cmd ("off", class_support, overlay_off_command, 4033 _("Disable overlay debugging."), &overlaylist); 4034 add_cmd ("auto", class_support, overlay_auto_command, 4035 _("Enable automatic overlay debugging."), &overlaylist); 4036 add_cmd ("load-target", class_support, overlay_load_command, 4037 _("Read the overlay mapping state from the target."), &overlaylist); 4038 4039 /* Filename extension to source language lookup table: */ 4040 init_filename_language_table (); 4041 add_setshow_string_noescape_cmd ("extension-language", class_files, 4042 &ext_args, _("\ 4043Set mapping between filename extension and source language."), _("\ 4044Show mapping between filename extension and source language."), _("\ 4045Usage: set extension-language .foo bar"), 4046 set_ext_lang_command, 4047 show_ext_args, 4048 &setlist, &showlist); 4049 4050 add_info ("extensions", info_ext_lang_command, 4051 _("All filename extensions associated with a source language.")); 4052 4053 add_setshow_optional_filename_cmd ("debug-file-directory", class_support, 4054 &debug_file_directory, _("\ 4055Set the directories where separate debug symbols are searched for."), _("\ 4056Show the directories where separate debug symbols are searched for."), _("\ 4057Separate debug symbols are first searched for in the same\n\ 4058directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\ 4059and lastly at the path of the directory of the binary with\n\ 4060each global debug-file-directory component prepended."), 4061 NULL, 4062 show_debug_file_directory, 4063 &setlist, &showlist); 4064 4065 add_setshow_enum_cmd ("symbol-loading", no_class, 4066 print_symbol_loading_enums, &print_symbol_loading, 4067 _("\ 4068Set printing of symbol loading messages."), _("\ 4069Show printing of symbol loading messages."), _("\ 4070off == turn all messages off\n\ 4071brief == print messages for the executable,\n\ 4072 and brief messages for shared libraries\n\ 4073full == print messages for the executable,\n\ 4074 and messages for each shared library."), 4075 NULL, 4076 NULL, 4077 &setprintlist, &showprintlist); 4078} 4079