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