1 /* Generic symbol file reading for the GNU debugger, GDB. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support, using pieces from other GDB modules. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25 #include "defs.h" 26 #include "bfdlink.h" 27 #include "symtab.h" 28 #include "gdbtypes.h" 29 #include "gdbcore.h" 30 #include "frame.h" 31 #include "target.h" 32 #include "value.h" 33 #include "symfile.h" 34 #include "objfiles.h" 35 #include "source.h" 36 #include "gdbcmd.h" 37 #include "breakpoint.h" 38 #include "language.h" 39 #include "complaints.h" 40 #include "demangle.h" 41 #include "inferior.h" /* for write_pc */ 42 #include "filenames.h" /* for DOSish file names */ 43 #include "gdb-stabs.h" 44 #include "gdb_obstack.h" 45 #include "completer.h" 46 #include "bcache.h" 47 #include "hashtab.h" 48 #include "readline/readline.h" 49 #include "gdb_assert.h" 50 #include "block.h" 51 52 #include <sys/types.h> 53 #include <fcntl.h> 54 #include "gdb_string.h" 55 #include "gdb_stat.h" 56 #include <ctype.h> 57 #include <time.h> 58 59 #ifndef O_BINARY 60 #define O_BINARY 0 61 #endif 62 63 int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num); 64 void (*deprecated_show_load_progress) (const char *section, 65 unsigned long section_sent, 66 unsigned long section_size, 67 unsigned long total_sent, 68 unsigned long total_size); 69 void (*deprecated_pre_add_symbol_hook) (const char *); 70 void (*deprecated_post_add_symbol_hook) (void); 71 void (*deprecated_target_new_objfile_hook) (struct objfile *); 72 73 static void clear_symtab_users_cleanup (void *ignore); 74 75 /* Global variables owned by this file */ 76 int readnow_symbol_files; /* Read full symbols immediately */ 77 78 /* External variables and functions referenced. */ 79 80 extern void report_transfer_performance (unsigned long, time_t, time_t); 81 82 /* Functions this file defines */ 83 84 #if 0 85 static int simple_read_overlay_region_table (void); 86 static void simple_free_overlay_region_table (void); 87 #endif 88 89 static void set_initial_language (void); 90 91 static void load_command (char *, int); 92 93 static void symbol_file_add_main_1 (char *args, int from_tty, int flags); 94 95 static void add_symbol_file_command (char *, int); 96 97 static void add_shared_symbol_files_command (char *, int); 98 99 static void reread_separate_symbols (struct objfile *objfile); 100 101 static void cashier_psymtab (struct partial_symtab *); 102 103 bfd *symfile_bfd_open (char *); 104 105 int get_section_index (struct objfile *, char *); 106 107 static void find_sym_fns (struct objfile *); 108 109 static void decrement_reading_symtab (void *); 110 111 static void overlay_invalidate_all (void); 112 113 static int overlay_is_mapped (struct obj_section *); 114 115 void list_overlays_command (char *, int); 116 117 void map_overlay_command (char *, int); 118 119 void unmap_overlay_command (char *, int); 120 121 static void overlay_auto_command (char *, int); 122 123 static void overlay_manual_command (char *, int); 124 125 static void overlay_off_command (char *, int); 126 127 static void overlay_load_command (char *, int); 128 129 static void overlay_command (char *, int); 130 131 static void simple_free_overlay_table (void); 132 133 static void read_target_long_array (CORE_ADDR, unsigned int *, int); 134 135 static int simple_read_overlay_table (void); 136 137 static int simple_overlay_update_1 (struct obj_section *); 138 139 static void add_filename_language (char *ext, enum language lang); 140 141 static void set_ext_lang_command (char *args, int from_tty); 142 143 static void info_ext_lang_command (char *args, int from_tty); 144 145 static char *find_separate_debug_file (struct objfile *objfile); 146 147 static void init_filename_language_table (void); 148 149 void _initialize_symfile (void); 150 151 /* List of all available sym_fns. On gdb startup, each object file reader 152 calls add_symtab_fns() to register information on each format it is 153 prepared to read. */ 154 155 static struct sym_fns *symtab_fns = NULL; 156 157 /* Flag for whether user will be reloading symbols multiple times. 158 Defaults to ON for VxWorks, otherwise OFF. */ 159 160 #ifdef SYMBOL_RELOADING_DEFAULT 161 int symbol_reloading = SYMBOL_RELOADING_DEFAULT; 162 #else 163 int symbol_reloading = 0; 164 #endif 165 166 /* If non-zero, shared library symbols will be added automatically 167 when the inferior is created, new libraries are loaded, or when 168 attaching to the inferior. This is almost always what users will 169 want to have happen; but for very large programs, the startup time 170 will be excessive, and so if this is a problem, the user can clear 171 this flag and then add the shared library symbols as needed. Note 172 that there is a potential for confusion, since if the shared 173 library symbols are not loaded, commands like "info fun" will *not* 174 report all the functions that are actually present. */ 175 176 int auto_solib_add = 1; 177 178 /* For systems that support it, a threshold size in megabytes. If 179 automatically adding a new library's symbol table to those already 180 known to the debugger would cause the total shared library symbol 181 size to exceed this threshhold, then the shlib's symbols are not 182 added. The threshold is ignored if the user explicitly asks for a 183 shlib to be added, such as when using the "sharedlibrary" 184 command. */ 185 186 int auto_solib_limit; 187 188 189 /* This compares two partial symbols by names, using strcmp_iw_ordered 190 for the comparison. */ 191 192 static int 193 compare_psymbols (const void *s1p, const void *s2p) 194 { 195 struct partial_symbol *const *s1 = s1p; 196 struct partial_symbol *const *s2 = s2p; 197 198 return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1), 199 SYMBOL_SEARCH_NAME (*s2)); 200 } 201 202 void 203 sort_pst_symbols (struct partial_symtab *pst) 204 { 205 /* Sort the global list; don't sort the static list */ 206 207 qsort (pst->objfile->global_psymbols.list + pst->globals_offset, 208 pst->n_global_syms, sizeof (struct partial_symbol *), 209 compare_psymbols); 210 } 211 212 /* Make a null terminated copy of the string at PTR with SIZE characters in 213 the obstack pointed to by OBSTACKP . Returns the address of the copy. 214 Note that the string at PTR does not have to be null terminated, I.E. it 215 may be part of a larger string and we are only saving a substring. */ 216 217 char * 218 obsavestring (const char *ptr, int size, struct obstack *obstackp) 219 { 220 char *p = (char *) obstack_alloc (obstackp, size + 1); 221 /* Open-coded memcpy--saves function call time. These strings are usually 222 short. FIXME: Is this really still true with a compiler that can 223 inline memcpy? */ 224 { 225 const char *p1 = ptr; 226 char *p2 = p; 227 const char *end = ptr + size; 228 while (p1 != end) 229 *p2++ = *p1++; 230 } 231 p[size] = 0; 232 return p; 233 } 234 235 /* Concatenate strings S1, S2 and S3; return the new string. Space is found 236 in the obstack pointed to by OBSTACKP. */ 237 238 char * 239 obconcat (struct obstack *obstackp, const char *s1, const char *s2, 240 const char *s3) 241 { 242 int len = strlen (s1) + strlen (s2) + strlen (s3) + 1; 243 char *val = (char *) obstack_alloc (obstackp, len); 244 strcpy (val, s1); 245 strcat (val, s2); 246 strcat (val, s3); 247 return val; 248 } 249 250 /* True if we are nested inside psymtab_to_symtab. */ 251 252 int currently_reading_symtab = 0; 253 254 static void 255 decrement_reading_symtab (void *dummy) 256 { 257 currently_reading_symtab--; 258 } 259 260 /* Get the symbol table that corresponds to a partial_symtab. 261 This is fast after the first time you do it. In fact, there 262 is an even faster macro PSYMTAB_TO_SYMTAB that does the fast 263 case inline. */ 264 265 struct symtab * 266 psymtab_to_symtab (struct partial_symtab *pst) 267 { 268 /* If it's been looked up before, return it. */ 269 if (pst->symtab) 270 return pst->symtab; 271 272 /* If it has not yet been read in, read it. */ 273 if (!pst->readin) 274 { 275 struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL); 276 currently_reading_symtab++; 277 (*pst->read_symtab) (pst); 278 do_cleanups (back_to); 279 } 280 281 return pst->symtab; 282 } 283 284 /* Remember the lowest-addressed loadable section we've seen. 285 This function is called via bfd_map_over_sections. 286 287 In case of equal vmas, the section with the largest size becomes the 288 lowest-addressed loadable section. 289 290 If the vmas and sizes are equal, the last section is considered the 291 lowest-addressed loadable section. */ 292 293 void 294 find_lowest_section (bfd *abfd, asection *sect, void *obj) 295 { 296 asection **lowest = (asection **) obj; 297 298 if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD)) 299 return; 300 if (!*lowest) 301 *lowest = sect; /* First loadable section */ 302 else if (bfd_section_vma (abfd, *lowest) > bfd_section_vma (abfd, sect)) 303 *lowest = sect; /* A lower loadable section */ 304 else if (bfd_section_vma (abfd, *lowest) == bfd_section_vma (abfd, sect) 305 && (bfd_section_size (abfd, (*lowest)) 306 <= bfd_section_size (abfd, sect))) 307 *lowest = sect; 308 } 309 310 /* Create a new section_addr_info, with room for NUM_SECTIONS. */ 311 312 struct section_addr_info * 313 alloc_section_addr_info (size_t num_sections) 314 { 315 struct section_addr_info *sap; 316 size_t size; 317 318 size = (sizeof (struct section_addr_info) 319 + sizeof (struct other_sections) * (num_sections - 1)); 320 sap = (struct section_addr_info *) xmalloc (size); 321 memset (sap, 0, size); 322 sap->num_sections = num_sections; 323 324 return sap; 325 } 326 327 328 /* Return a freshly allocated copy of ADDRS. The section names, if 329 any, are also freshly allocated copies of those in ADDRS. */ 330 struct section_addr_info * 331 copy_section_addr_info (struct section_addr_info *addrs) 332 { 333 struct section_addr_info *copy 334 = alloc_section_addr_info (addrs->num_sections); 335 int i; 336 337 copy->num_sections = addrs->num_sections; 338 for (i = 0; i < addrs->num_sections; i++) 339 { 340 copy->other[i].addr = addrs->other[i].addr; 341 if (addrs->other[i].name) 342 copy->other[i].name = xstrdup (addrs->other[i].name); 343 else 344 copy->other[i].name = NULL; 345 copy->other[i].sectindex = addrs->other[i].sectindex; 346 } 347 348 return copy; 349 } 350 351 352 353 /* Build (allocate and populate) a section_addr_info struct from 354 an existing section table. */ 355 356 extern struct section_addr_info * 357 build_section_addr_info_from_section_table (const struct section_table *start, 358 const struct section_table *end) 359 { 360 struct section_addr_info *sap; 361 const struct section_table *stp; 362 int oidx; 363 364 sap = alloc_section_addr_info (end - start); 365 366 for (stp = start, oidx = 0; stp != end; stp++) 367 { 368 if (bfd_get_section_flags (stp->bfd, 369 stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD) 370 && oidx < end - start) 371 { 372 sap->other[oidx].addr = stp->addr; 373 sap->other[oidx].name 374 = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section)); 375 sap->other[oidx].sectindex = stp->the_bfd_section->index; 376 oidx++; 377 } 378 } 379 380 return sap; 381 } 382 383 384 /* Free all memory allocated by build_section_addr_info_from_section_table. */ 385 386 extern void 387 free_section_addr_info (struct section_addr_info *sap) 388 { 389 int idx; 390 391 for (idx = 0; idx < sap->num_sections; idx++) 392 if (sap->other[idx].name) 393 xfree (sap->other[idx].name); 394 xfree (sap); 395 } 396 397 398 /* Initialize OBJFILE's sect_index_* members. */ 399 static void 400 init_objfile_sect_indices (struct objfile *objfile) 401 { 402 asection *sect; 403 int i; 404 405 sect = bfd_get_section_by_name (objfile->obfd, ".text"); 406 if (sect) 407 objfile->sect_index_text = sect->index; 408 409 sect = bfd_get_section_by_name (objfile->obfd, ".data"); 410 if (sect) 411 objfile->sect_index_data = sect->index; 412 413 sect = bfd_get_section_by_name (objfile->obfd, ".bss"); 414 if (sect) 415 objfile->sect_index_bss = sect->index; 416 417 sect = bfd_get_section_by_name (objfile->obfd, ".rodata"); 418 if (sect) 419 objfile->sect_index_rodata = sect->index; 420 421 /* This is where things get really weird... We MUST have valid 422 indices for the various sect_index_* members or gdb will abort. 423 So if for example, there is no ".text" section, we have to 424 accomodate that. Except when explicitly adding symbol files at 425 some address, section_offsets contains nothing but zeros, so it 426 doesn't matter which slot in section_offsets the individual 427 sect_index_* members index into. So if they are all zero, it is 428 safe to just point all the currently uninitialized indices to the 429 first slot. */ 430 431 for (i = 0; i < objfile->num_sections; i++) 432 { 433 if (ANOFFSET (objfile->section_offsets, i) != 0) 434 { 435 break; 436 } 437 } 438 if (i == objfile->num_sections) 439 { 440 if (objfile->sect_index_text == -1) 441 objfile->sect_index_text = 0; 442 if (objfile->sect_index_data == -1) 443 objfile->sect_index_data = 0; 444 if (objfile->sect_index_bss == -1) 445 objfile->sect_index_bss = 0; 446 if (objfile->sect_index_rodata == -1) 447 objfile->sect_index_rodata = 0; 448 } 449 } 450 451 452 /* Parse the user's idea of an offset for dynamic linking, into our idea 453 of how to represent it for fast symbol reading. This is the default 454 version of the sym_fns.sym_offsets function for symbol readers that 455 don't need to do anything special. It allocates a section_offsets table 456 for the objectfile OBJFILE and stuffs ADDR into all of the offsets. */ 457 458 void 459 default_symfile_offsets (struct objfile *objfile, 460 struct section_addr_info *addrs) 461 { 462 int i; 463 464 objfile->num_sections = bfd_count_sections (objfile->obfd); 465 objfile->section_offsets = (struct section_offsets *) 466 obstack_alloc (&objfile->objfile_obstack, 467 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 468 memset (objfile->section_offsets, 0, 469 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 470 471 /* Now calculate offsets for section that were specified by the 472 caller. */ 473 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++) 474 { 475 struct other_sections *osp ; 476 477 osp = &addrs->other[i] ; 478 if (osp->addr == 0) 479 continue; 480 481 /* Record all sections in offsets */ 482 /* The section_offsets in the objfile are here filled in using 483 the BFD index. */ 484 (objfile->section_offsets)->offsets[osp->sectindex] = osp->addr; 485 } 486 487 /* Remember the bfd indexes for the .text, .data, .bss and 488 .rodata sections. */ 489 init_objfile_sect_indices (objfile); 490 } 491 492 493 /* Process a symbol file, as either the main file or as a dynamically 494 loaded file. 495 496 OBJFILE is where the symbols are to be read from. 497 498 ADDRS is the list of section load addresses. If the user has given 499 an 'add-symbol-file' command, then this is the list of offsets and 500 addresses he or she provided as arguments to the command; or, if 501 we're handling a shared library, these are the actual addresses the 502 sections are loaded at, according to the inferior's dynamic linker 503 (as gleaned by GDB's shared library code). We convert each address 504 into an offset from the section VMA's as it appears in the object 505 file, and then call the file's sym_offsets function to convert this 506 into a format-specific offset table --- a `struct section_offsets'. 507 If ADDRS is non-zero, OFFSETS must be zero. 508 509 OFFSETS is a table of section offsets already in the right 510 format-specific representation. NUM_OFFSETS is the number of 511 elements present in OFFSETS->offsets. If OFFSETS is non-zero, we 512 assume this is the proper table the call to sym_offsets described 513 above would produce. Instead of calling sym_offsets, we just dump 514 it right into objfile->section_offsets. (When we're re-reading 515 symbols from an objfile, we don't have the original load address 516 list any more; all we have is the section offset table.) If 517 OFFSETS is non-zero, ADDRS must be zero. 518 519 MAINLINE is nonzero if this is the main symbol file, or zero if 520 it's an extra symbol file such as dynamically loaded code. 521 522 VERBO is nonzero if the caller has printed a verbose message about 523 the symbol reading (and complaints can be more terse about it). */ 524 525 void 526 syms_from_objfile (struct objfile *objfile, 527 struct section_addr_info *addrs, 528 struct section_offsets *offsets, 529 int num_offsets, 530 int mainline, 531 int verbo) 532 { 533 struct section_addr_info *local_addr = NULL; 534 struct cleanup *old_chain; 535 536 gdb_assert (! (addrs && offsets)); 537 538 init_entry_point_info (objfile); 539 find_sym_fns (objfile); 540 541 if (objfile->sf == NULL) 542 return; /* No symbols. */ 543 544 /* Make sure that partially constructed symbol tables will be cleaned up 545 if an error occurs during symbol reading. */ 546 old_chain = make_cleanup_free_objfile (objfile); 547 548 /* If ADDRS and OFFSETS are both NULL, put together a dummy address 549 list. We now establish the convention that an addr of zero means 550 no load address was specified. */ 551 if (! addrs && ! offsets) 552 { 553 local_addr 554 = alloc_section_addr_info (bfd_count_sections (objfile->obfd)); 555 make_cleanup (xfree, local_addr); 556 addrs = local_addr; 557 } 558 559 /* Now either addrs or offsets is non-zero. */ 560 561 if (mainline) 562 { 563 /* We will modify the main symbol table, make sure that all its users 564 will be cleaned up if an error occurs during symbol reading. */ 565 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/); 566 567 /* Since no error yet, throw away the old symbol table. */ 568 569 if (symfile_objfile != NULL) 570 { 571 free_objfile (symfile_objfile); 572 symfile_objfile = NULL; 573 } 574 575 /* Currently we keep symbols from the add-symbol-file command. 576 If the user wants to get rid of them, they should do "symbol-file" 577 without arguments first. Not sure this is the best behavior 578 (PR 2207). */ 579 580 (*objfile->sf->sym_new_init) (objfile); 581 } 582 583 /* Convert addr into an offset rather than an absolute address. 584 We find the lowest address of a loaded segment in the objfile, 585 and assume that <addr> is where that got loaded. 586 587 We no longer warn if the lowest section is not a text segment (as 588 happens for the PA64 port. */ 589 if (!mainline && addrs && addrs->other[0].name) 590 { 591 asection *lower_sect; 592 asection *sect; 593 CORE_ADDR lower_offset; 594 int i; 595 596 /* Find lowest loadable section to be used as starting point for 597 continguous sections. FIXME!! won't work without call to find 598 .text first, but this assumes text is lowest section. */ 599 lower_sect = bfd_get_section_by_name (objfile->obfd, ".text"); 600 if (lower_sect == NULL) 601 bfd_map_over_sections (objfile->obfd, find_lowest_section, 602 &lower_sect); 603 if (lower_sect == NULL) 604 warning ("no loadable sections found in added symbol-file %s", 605 objfile->name); 606 else 607 if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0) 608 warning ("Lowest section in %s is %s at %s", 609 objfile->name, 610 bfd_section_name (objfile->obfd, lower_sect), 611 paddr (bfd_section_vma (objfile->obfd, lower_sect))); 612 if (lower_sect != NULL) 613 lower_offset = bfd_section_vma (objfile->obfd, lower_sect); 614 else 615 lower_offset = 0; 616 617 /* Calculate offsets for the loadable sections. 618 FIXME! Sections must be in order of increasing loadable section 619 so that contiguous sections can use the lower-offset!!! 620 621 Adjust offsets if the segments are not contiguous. 622 If the section is contiguous, its offset should be set to 623 the offset of the highest loadable section lower than it 624 (the loadable section directly below it in memory). 625 this_offset = lower_offset = lower_addr - lower_orig_addr */ 626 627 for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++) 628 { 629 if (addrs->other[i].addr != 0) 630 { 631 sect = bfd_get_section_by_name (objfile->obfd, 632 addrs->other[i].name); 633 if (sect) 634 { 635 addrs->other[i].addr 636 -= bfd_section_vma (objfile->obfd, sect); 637 lower_offset = addrs->other[i].addr; 638 /* This is the index used by BFD. */ 639 addrs->other[i].sectindex = sect->index ; 640 } 641 else 642 { 643 warning ("section %s not found in %s", 644 addrs->other[i].name, 645 objfile->name); 646 addrs->other[i].addr = 0; 647 } 648 } 649 else 650 addrs->other[i].addr = lower_offset; 651 } 652 } 653 654 /* Initialize symbol reading routines for this objfile, allow complaints to 655 appear for this new file, and record how verbose to be, then do the 656 initial symbol reading for this file. */ 657 658 (*objfile->sf->sym_init) (objfile); 659 clear_complaints (&symfile_complaints, 1, verbo); 660 661 if (addrs) 662 (*objfile->sf->sym_offsets) (objfile, addrs); 663 else 664 { 665 size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets); 666 667 /* Just copy in the offset table directly as given to us. */ 668 objfile->num_sections = num_offsets; 669 objfile->section_offsets 670 = ((struct section_offsets *) 671 obstack_alloc (&objfile->objfile_obstack, size)); 672 memcpy (objfile->section_offsets, offsets, size); 673 674 init_objfile_sect_indices (objfile); 675 } 676 677 #ifndef DEPRECATED_IBM6000_TARGET 678 /* This is a SVR4/SunOS specific hack, I think. In any event, it 679 screws RS/6000. sym_offsets should be doing this sort of thing, 680 because it knows the mapping between bfd sections and 681 section_offsets. */ 682 /* This is a hack. As far as I can tell, section offsets are not 683 target dependent. They are all set to addr with a couple of 684 exceptions. The exceptions are sysvr4 shared libraries, whose 685 offsets are kept in solib structures anyway and rs6000 xcoff 686 which handles shared libraries in a completely unique way. 687 688 Section offsets are built similarly, except that they are built 689 by adding addr in all cases because there is no clear mapping 690 from section_offsets into actual sections. Note that solib.c 691 has a different algorithm for finding section offsets. 692 693 These should probably all be collapsed into some target 694 independent form of shared library support. FIXME. */ 695 696 if (addrs) 697 { 698 struct obj_section *s; 699 700 /* Map section offsets in "addr" back to the object's 701 sections by comparing the section names with bfd's 702 section names. Then adjust the section address by 703 the offset. */ /* for gdb/13815 */ 704 705 ALL_OBJFILE_OSECTIONS (objfile, s) 706 { 707 CORE_ADDR s_addr = 0; 708 int i; 709 710 for (i = 0; 711 !s_addr && i < addrs->num_sections && addrs->other[i].name; 712 i++) 713 if (strcmp (bfd_section_name (s->objfile->obfd, 714 s->the_bfd_section), 715 addrs->other[i].name) == 0) 716 s_addr = addrs->other[i].addr; /* end added for gdb/13815 */ 717 718 s->addr -= s->offset; 719 s->addr += s_addr; 720 s->endaddr -= s->offset; 721 s->endaddr += s_addr; 722 s->offset += s_addr; 723 } 724 } 725 #endif /* not DEPRECATED_IBM6000_TARGET */ 726 727 (*objfile->sf->sym_read) (objfile, mainline); 728 729 /* Don't allow char * to have a typename (else would get caddr_t). 730 Ditto void *. FIXME: Check whether this is now done by all the 731 symbol readers themselves (many of them now do), and if so remove 732 it from here. */ 733 734 TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0; 735 TYPE_NAME (lookup_pointer_type (builtin_type_void)) = 0; 736 737 /* Mark the objfile has having had initial symbol read attempted. Note 738 that this does not mean we found any symbols... */ 739 740 objfile->flags |= OBJF_SYMS; 741 742 /* Discard cleanups as symbol reading was successful. */ 743 744 discard_cleanups (old_chain); 745 } 746 747 /* Perform required actions after either reading in the initial 748 symbols for a new objfile, or mapping in the symbols from a reusable 749 objfile. */ 750 751 void 752 new_symfile_objfile (struct objfile *objfile, int mainline, int verbo) 753 { 754 755 /* If this is the main symbol file we have to clean up all users of the 756 old main symbol file. Otherwise it is sufficient to fixup all the 757 breakpoints that may have been redefined by this symbol file. */ 758 if (mainline) 759 { 760 /* OK, make it the "real" symbol file. */ 761 symfile_objfile = objfile; 762 763 clear_symtab_users (); 764 } 765 else 766 { 767 breakpoint_re_set (); 768 } 769 770 /* We're done reading the symbol file; finish off complaints. */ 771 clear_complaints (&symfile_complaints, 0, verbo); 772 } 773 774 /* Process a symbol file, as either the main file or as a dynamically 775 loaded file. 776 777 ABFD is a BFD already open on the file, as from symfile_bfd_open. 778 This BFD will be closed on error, and is always consumed by this function. 779 780 FROM_TTY says how verbose to be. 781 782 MAINLINE specifies whether this is the main symbol file, or whether 783 it's an extra symbol file such as dynamically loaded code. 784 785 ADDRS, OFFSETS, and NUM_OFFSETS are as described for 786 syms_from_objfile, above. ADDRS is ignored when MAINLINE is 787 non-zero. 788 789 Upon success, returns a pointer to the objfile that was added. 790 Upon failure, jumps back to command level (never returns). */ 791 static struct objfile * 792 symbol_file_add_with_addrs_or_offsets (bfd *abfd, int from_tty, 793 struct section_addr_info *addrs, 794 struct section_offsets *offsets, 795 int num_offsets, 796 int mainline, int flags) 797 { 798 struct objfile *objfile; 799 struct partial_symtab *psymtab; 800 char *debugfile; 801 struct section_addr_info *orig_addrs = NULL; 802 struct cleanup *my_cleanups; 803 const char *name = bfd_get_filename (abfd); 804 805 my_cleanups = make_cleanup_bfd_close (abfd); 806 807 /* Give user a chance to burp if we'd be 808 interactively wiping out any existing symbols. */ 809 810 if ((have_full_symbols () || have_partial_symbols ()) 811 && mainline 812 && from_tty 813 && !query ("Load new symbol table from \"%s\"? ", name)) 814 error ("Not confirmed."); 815 816 objfile = allocate_objfile (abfd, flags); 817 discard_cleanups (my_cleanups); 818 819 if (addrs) 820 { 821 orig_addrs = copy_section_addr_info (addrs); 822 make_cleanup_free_section_addr_info (orig_addrs); 823 } 824 825 /* We either created a new mapped symbol table, mapped an existing 826 symbol table file which has not had initial symbol reading 827 performed, or need to read an unmapped symbol table. */ 828 if (from_tty || info_verbose) 829 { 830 if (deprecated_pre_add_symbol_hook) 831 deprecated_pre_add_symbol_hook (name); 832 else 833 { 834 printf_unfiltered ("Reading symbols from %s...", name); 835 wrap_here (""); 836 gdb_flush (gdb_stdout); 837 } 838 } 839 syms_from_objfile (objfile, addrs, offsets, num_offsets, 840 mainline, from_tty); 841 842 /* We now have at least a partial symbol table. Check to see if the 843 user requested that all symbols be read on initial access via either 844 the gdb startup command line or on a per symbol file basis. Expand 845 all partial symbol tables for this objfile if so. */ 846 847 if ((flags & OBJF_READNOW) || readnow_symbol_files) 848 { 849 if (from_tty || info_verbose) 850 { 851 printf_unfiltered ("expanding to full symbols..."); 852 wrap_here (""); 853 gdb_flush (gdb_stdout); 854 } 855 856 for (psymtab = objfile->psymtabs; 857 psymtab != NULL; 858 psymtab = psymtab->next) 859 { 860 psymtab_to_symtab (psymtab); 861 } 862 } 863 864 debugfile = find_separate_debug_file (objfile); 865 if (debugfile) 866 { 867 if (addrs != NULL) 868 { 869 objfile->separate_debug_objfile 870 = symbol_file_add (debugfile, from_tty, orig_addrs, 0, flags); 871 } 872 else 873 { 874 objfile->separate_debug_objfile 875 = symbol_file_add (debugfile, from_tty, NULL, 0, flags); 876 } 877 objfile->separate_debug_objfile->separate_debug_objfile_backlink 878 = objfile; 879 880 /* Put the separate debug object before the normal one, this is so that 881 usage of the ALL_OBJFILES_SAFE macro will stay safe. */ 882 put_objfile_before (objfile->separate_debug_objfile, objfile); 883 884 xfree (debugfile); 885 } 886 887 if (!have_partial_symbols () && !have_full_symbols ()) 888 { 889 wrap_here (""); 890 printf_filtered ("(no debugging symbols found)"); 891 if (from_tty || info_verbose) 892 printf_filtered ("..."); 893 else 894 printf_filtered ("\n"); 895 wrap_here (""); 896 } 897 898 if (from_tty || info_verbose) 899 { 900 if (deprecated_post_add_symbol_hook) 901 deprecated_post_add_symbol_hook (); 902 else 903 { 904 printf_unfiltered ("done.\n"); 905 } 906 } 907 908 /* We print some messages regardless of whether 'from_tty || 909 info_verbose' is true, so make sure they go out at the right 910 time. */ 911 gdb_flush (gdb_stdout); 912 913 do_cleanups (my_cleanups); 914 915 if (objfile->sf == NULL) 916 return objfile; /* No symbols. */ 917 918 new_symfile_objfile (objfile, mainline, from_tty); 919 920 if (deprecated_target_new_objfile_hook) 921 deprecated_target_new_objfile_hook (objfile); 922 923 bfd_cache_close_all (); 924 return (objfile); 925 } 926 927 928 /* Process the symbol file ABFD, as either the main file or as a 929 dynamically loaded file. 930 931 See symbol_file_add_with_addrs_or_offsets's comments for 932 details. */ 933 struct objfile * 934 symbol_file_add_from_bfd (bfd *abfd, int from_tty, 935 struct section_addr_info *addrs, 936 int mainline, int flags) 937 { 938 return symbol_file_add_with_addrs_or_offsets (abfd, 939 from_tty, addrs, 0, 0, 940 mainline, flags); 941 } 942 943 944 /* Process a symbol file, as either the main file or as a dynamically 945 loaded file. See symbol_file_add_with_addrs_or_offsets's comments 946 for details. */ 947 struct objfile * 948 symbol_file_add (char *name, int from_tty, struct section_addr_info *addrs, 949 int mainline, int flags) 950 { 951 return symbol_file_add_from_bfd (symfile_bfd_open (name), from_tty, 952 addrs, mainline, flags); 953 } 954 955 956 /* Call symbol_file_add() with default values and update whatever is 957 affected by the loading of a new main(). 958 Used when the file is supplied in the gdb command line 959 and by some targets with special loading requirements. 960 The auxiliary function, symbol_file_add_main_1(), has the flags 961 argument for the switches that can only be specified in the symbol_file 962 command itself. */ 963 964 void 965 symbol_file_add_main (char *args, int from_tty) 966 { 967 symbol_file_add_main_1 (args, from_tty, 0); 968 } 969 970 static void 971 symbol_file_add_main_1 (char *args, int from_tty, int flags) 972 { 973 symbol_file_add (args, from_tty, NULL, 1, flags); 974 975 /* Getting new symbols may change our opinion about 976 what is frameless. */ 977 reinit_frame_cache (); 978 979 set_initial_language (); 980 } 981 982 void 983 symbol_file_clear (int from_tty) 984 { 985 if ((have_full_symbols () || have_partial_symbols ()) 986 && from_tty 987 && !query ("Discard symbol table from `%s'? ", 988 symfile_objfile->name)) 989 error ("Not confirmed."); 990 free_all_objfiles (); 991 992 /* solib descriptors may have handles to objfiles. Since their 993 storage has just been released, we'd better wipe the solib 994 descriptors as well. 995 */ 996 #if defined(SOLIB_RESTART) 997 SOLIB_RESTART (); 998 #endif 999 1000 symfile_objfile = NULL; 1001 if (from_tty) 1002 printf_unfiltered ("No symbol file now.\n"); 1003 } 1004 1005 static char * 1006 get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out) 1007 { 1008 asection *sect; 1009 bfd_size_type debuglink_size; 1010 unsigned long crc32; 1011 char *contents; 1012 int crc_offset; 1013 unsigned char *p; 1014 1015 sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink"); 1016 1017 if (sect == NULL) 1018 return NULL; 1019 1020 debuglink_size = bfd_section_size (objfile->obfd, sect); 1021 1022 contents = xmalloc (debuglink_size); 1023 bfd_get_section_contents (objfile->obfd, sect, contents, 1024 (file_ptr)0, (bfd_size_type)debuglink_size); 1025 1026 /* Crc value is stored after the filename, aligned up to 4 bytes. */ 1027 crc_offset = strlen (contents) + 1; 1028 crc_offset = (crc_offset + 3) & ~3; 1029 1030 crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset)); 1031 1032 *crc32_out = crc32; 1033 return contents; 1034 } 1035 1036 static int 1037 separate_debug_file_exists (const char *name, unsigned long crc) 1038 { 1039 unsigned long file_crc = 0; 1040 int fd; 1041 char buffer[8*1024]; 1042 int count; 1043 1044 fd = open (name, O_RDONLY | O_BINARY); 1045 if (fd < 0) 1046 return 0; 1047 1048 while ((count = read (fd, buffer, sizeof (buffer))) > 0) 1049 file_crc = gnu_debuglink_crc32 (file_crc, buffer, count); 1050 1051 close (fd); 1052 1053 return crc == file_crc; 1054 } 1055 1056 static char *debug_file_directory = NULL; 1057 1058 #if ! defined (DEBUG_SUBDIRECTORY) 1059 #define DEBUG_SUBDIRECTORY ".debug" 1060 #endif 1061 1062 static char * 1063 find_separate_debug_file (struct objfile *objfile) 1064 { 1065 asection *sect; 1066 char *basename; 1067 char *dir; 1068 char *debugfile; 1069 char *name_copy; 1070 bfd_size_type debuglink_size; 1071 unsigned long crc32; 1072 int i; 1073 1074 basename = get_debug_link_info (objfile, &crc32); 1075 1076 if (basename == NULL) 1077 return NULL; 1078 1079 dir = xstrdup (objfile->name); 1080 1081 /* Strip off the final filename part, leaving the directory name, 1082 followed by a slash. Objfile names should always be absolute and 1083 tilde-expanded, so there should always be a slash in there 1084 somewhere. */ 1085 for (i = strlen(dir) - 1; i >= 0; i--) 1086 { 1087 if (IS_DIR_SEPARATOR (dir[i])) 1088 break; 1089 } 1090 gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i])); 1091 dir[i+1] = '\0'; 1092 1093 debugfile = alloca (strlen (debug_file_directory) + 1 1094 + strlen (dir) 1095 + strlen (DEBUG_SUBDIRECTORY) 1096 + strlen ("/") 1097 + strlen (basename) 1098 + 1); 1099 1100 /* First try in the same directory as the original file. */ 1101 strcpy (debugfile, dir); 1102 strcat (debugfile, basename); 1103 1104 if (separate_debug_file_exists (debugfile, crc32)) 1105 { 1106 xfree (basename); 1107 xfree (dir); 1108 return xstrdup (debugfile); 1109 } 1110 1111 /* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */ 1112 strcpy (debugfile, dir); 1113 strcat (debugfile, DEBUG_SUBDIRECTORY); 1114 strcat (debugfile, "/"); 1115 strcat (debugfile, basename); 1116 1117 if (separate_debug_file_exists (debugfile, crc32)) 1118 { 1119 xfree (basename); 1120 xfree (dir); 1121 return xstrdup (debugfile); 1122 } 1123 1124 /* Then try in the global debugfile directory. */ 1125 strcpy (debugfile, debug_file_directory); 1126 strcat (debugfile, "/"); 1127 strcat (debugfile, dir); 1128 strcat (debugfile, basename); 1129 1130 if (separate_debug_file_exists (debugfile, crc32)) 1131 { 1132 xfree (basename); 1133 xfree (dir); 1134 return xstrdup (debugfile); 1135 } 1136 1137 xfree (basename); 1138 xfree (dir); 1139 return NULL; 1140 } 1141 1142 1143 /* This is the symbol-file command. Read the file, analyze its 1144 symbols, and add a struct symtab to a symtab list. The syntax of 1145 the command is rather bizarre--(1) buildargv implements various 1146 quoting conventions which are undocumented and have little or 1147 nothing in common with the way things are quoted (or not quoted) 1148 elsewhere in GDB, (2) options are used, which are not generally 1149 used in GDB (perhaps "set mapped on", "set readnow on" would be 1150 better), (3) the order of options matters, which is contrary to GNU 1151 conventions (because it is confusing and inconvenient). */ 1152 /* Note: ezannoni 2000-04-17. This function used to have support for 1153 rombug (see remote-os9k.c). It consisted of a call to target_link() 1154 (target.c) to get the address of the text segment from the target, 1155 and pass that to symbol_file_add(). This is no longer supported. */ 1156 1157 void 1158 symbol_file_command (char *args, int from_tty) 1159 { 1160 char **argv; 1161 char *name = NULL; 1162 struct cleanup *cleanups; 1163 int flags = OBJF_USERLOADED; 1164 1165 dont_repeat (); 1166 1167 if (args == NULL) 1168 { 1169 symbol_file_clear (from_tty); 1170 } 1171 else 1172 { 1173 if ((argv = buildargv (args)) == NULL) 1174 { 1175 nomem (0); 1176 } 1177 cleanups = make_cleanup_freeargv (argv); 1178 while (*argv != NULL) 1179 { 1180 if (strcmp (*argv, "-readnow") == 0) 1181 flags |= OBJF_READNOW; 1182 else if (**argv == '-') 1183 error ("unknown option `%s'", *argv); 1184 else 1185 { 1186 name = *argv; 1187 1188 symbol_file_add_main_1 (name, from_tty, flags); 1189 } 1190 argv++; 1191 } 1192 1193 if (name == NULL) 1194 { 1195 error ("no symbol file name was specified"); 1196 } 1197 do_cleanups (cleanups); 1198 } 1199 } 1200 1201 /* Set the initial language. 1202 1203 A better solution would be to record the language in the psymtab when reading 1204 partial symbols, and then use it (if known) to set the language. This would 1205 be a win for formats that encode the language in an easily discoverable place, 1206 such as DWARF. For stabs, we can jump through hoops looking for specially 1207 named symbols or try to intuit the language from the specific type of stabs 1208 we find, but we can't do that until later when we read in full symbols. 1209 FIXME. */ 1210 1211 static void 1212 set_initial_language (void) 1213 { 1214 struct partial_symtab *pst; 1215 enum language lang = language_unknown; 1216 1217 pst = find_main_psymtab (); 1218 if (pst != NULL) 1219 { 1220 if (pst->filename != NULL) 1221 { 1222 lang = deduce_language_from_filename (pst->filename); 1223 } 1224 if (lang == language_unknown) 1225 { 1226 /* Make C the default language */ 1227 lang = language_c; 1228 } 1229 set_language (lang); 1230 expected_language = current_language; /* Don't warn the user */ 1231 } 1232 } 1233 1234 /* Open file specified by NAME and hand it off to BFD for preliminary 1235 analysis. Result is a newly initialized bfd *, which includes a newly 1236 malloc'd` copy of NAME (tilde-expanded and made absolute). 1237 In case of trouble, error() is called. */ 1238 1239 bfd * 1240 symfile_bfd_open (char *name) 1241 { 1242 bfd *sym_bfd; 1243 int desc; 1244 char *absolute_name; 1245 1246 1247 1248 name = tilde_expand (name); /* Returns 1st new malloc'd copy */ 1249 1250 /* Look down path for it, allocate 2nd new malloc'd copy. */ 1251 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name, O_RDONLY | O_BINARY, 1252 0, &absolute_name); 1253 #if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__) 1254 if (desc < 0) 1255 { 1256 char *exename = alloca (strlen (name) + 5); 1257 strcat (strcpy (exename, name), ".exe"); 1258 desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename, 1259 O_RDONLY | O_BINARY, 0, &absolute_name); 1260 } 1261 #endif 1262 if (desc < 0) 1263 { 1264 make_cleanup (xfree, name); 1265 perror_with_name (name); 1266 } 1267 xfree (name); /* Free 1st new malloc'd copy */ 1268 name = absolute_name; /* Keep 2nd malloc'd copy in bfd */ 1269 /* It'll be freed in free_objfile(). */ 1270 1271 sym_bfd = bfd_fdopenr (name, gnutarget, desc); 1272 if (!sym_bfd) 1273 { 1274 close (desc); 1275 make_cleanup (xfree, name); 1276 error ("\"%s\": can't open to read symbols: %s.", name, 1277 bfd_errmsg (bfd_get_error ())); 1278 } 1279 bfd_set_cacheable (sym_bfd, 1); 1280 1281 if (!bfd_check_format (sym_bfd, bfd_object)) 1282 { 1283 /* FIXME: should be checking for errors from bfd_close (for one thing, 1284 on error it does not free all the storage associated with the 1285 bfd). */ 1286 bfd_close (sym_bfd); /* This also closes desc */ 1287 make_cleanup (xfree, name); 1288 error ("\"%s\": can't read symbols: %s.", name, 1289 bfd_errmsg (bfd_get_error ())); 1290 } 1291 return (sym_bfd); 1292 } 1293 1294 /* Return the section index for the given section name. Return -1 if 1295 the section was not found. */ 1296 int 1297 get_section_index (struct objfile *objfile, char *section_name) 1298 { 1299 asection *sect = bfd_get_section_by_name (objfile->obfd, section_name); 1300 if (sect) 1301 return sect->index; 1302 else 1303 return -1; 1304 } 1305 1306 /* Link a new symtab_fns into the global symtab_fns list. Called on gdb 1307 startup by the _initialize routine in each object file format reader, 1308 to register information about each format the the reader is prepared 1309 to handle. */ 1310 1311 void 1312 add_symtab_fns (struct sym_fns *sf) 1313 { 1314 sf->next = symtab_fns; 1315 symtab_fns = sf; 1316 } 1317 1318 1319 /* Initialize to read symbols from the symbol file sym_bfd. It either 1320 returns or calls error(). The result is an initialized struct sym_fns 1321 in the objfile structure, that contains cached information about the 1322 symbol file. */ 1323 1324 static void 1325 find_sym_fns (struct objfile *objfile) 1326 { 1327 struct sym_fns *sf; 1328 enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd); 1329 char *our_target = bfd_get_target (objfile->obfd); 1330 1331 if (our_flavour == bfd_target_srec_flavour 1332 || our_flavour == bfd_target_ihex_flavour 1333 || our_flavour == bfd_target_tekhex_flavour) 1334 return; /* No symbols. */ 1335 1336 for (sf = symtab_fns; sf != NULL; sf = sf->next) 1337 { 1338 if (our_flavour == sf->sym_flavour) 1339 { 1340 objfile->sf = sf; 1341 return; 1342 } 1343 } 1344 error ("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown.", 1345 bfd_get_target (objfile->obfd)); 1346 } 1347 1348 /* This function runs the load command of our current target. */ 1349 1350 static void 1351 load_command (char *arg, int from_tty) 1352 { 1353 if (arg == NULL) 1354 arg = get_exec_file (1); 1355 target_load (arg, from_tty); 1356 1357 /* After re-loading the executable, we don't really know which 1358 overlays are mapped any more. */ 1359 overlay_cache_invalid = 1; 1360 } 1361 1362 /* This version of "load" should be usable for any target. Currently 1363 it is just used for remote targets, not inftarg.c or core files, 1364 on the theory that only in that case is it useful. 1365 1366 Avoiding xmodem and the like seems like a win (a) because we don't have 1367 to worry about finding it, and (b) On VMS, fork() is very slow and so 1368 we don't want to run a subprocess. On the other hand, I'm not sure how 1369 performance compares. */ 1370 1371 static int download_write_size = 512; 1372 static int validate_download = 0; 1373 1374 /* Callback service function for generic_load (bfd_map_over_sections). */ 1375 1376 static void 1377 add_section_size_callback (bfd *abfd, asection *asec, void *data) 1378 { 1379 bfd_size_type *sum = data; 1380 1381 *sum += bfd_get_section_size (asec); 1382 } 1383 1384 /* Opaque data for load_section_callback. */ 1385 struct load_section_data { 1386 unsigned long load_offset; 1387 unsigned long write_count; 1388 unsigned long data_count; 1389 bfd_size_type total_size; 1390 }; 1391 1392 /* Callback service function for generic_load (bfd_map_over_sections). */ 1393 1394 static void 1395 load_section_callback (bfd *abfd, asection *asec, void *data) 1396 { 1397 struct load_section_data *args = data; 1398 1399 if (bfd_get_section_flags (abfd, asec) & SEC_LOAD) 1400 { 1401 bfd_size_type size = bfd_get_section_size (asec); 1402 if (size > 0) 1403 { 1404 char *buffer; 1405 struct cleanup *old_chain; 1406 CORE_ADDR lma = bfd_section_lma (abfd, asec) + args->load_offset; 1407 bfd_size_type block_size; 1408 int err; 1409 const char *sect_name = bfd_get_section_name (abfd, asec); 1410 bfd_size_type sent; 1411 1412 if (download_write_size > 0 && size > download_write_size) 1413 block_size = download_write_size; 1414 else 1415 block_size = size; 1416 1417 buffer = xmalloc (size); 1418 old_chain = make_cleanup (xfree, buffer); 1419 1420 /* Is this really necessary? I guess it gives the user something 1421 to look at during a long download. */ 1422 ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n", 1423 sect_name, paddr_nz (size), paddr_nz (lma)); 1424 1425 bfd_get_section_contents (abfd, asec, buffer, 0, size); 1426 1427 sent = 0; 1428 do 1429 { 1430 int len; 1431 bfd_size_type this_transfer = size - sent; 1432 1433 if (this_transfer >= block_size) 1434 this_transfer = block_size; 1435 len = target_write_memory_partial (lma, buffer, 1436 this_transfer, &err); 1437 if (err) 1438 break; 1439 if (validate_download) 1440 { 1441 /* Broken memories and broken monitors manifest 1442 themselves here when bring new computers to 1443 life. This doubles already slow downloads. */ 1444 /* NOTE: cagney/1999-10-18: A more efficient 1445 implementation might add a verify_memory() 1446 method to the target vector and then use 1447 that. remote.c could implement that method 1448 using the ``qCRC'' packet. */ 1449 char *check = xmalloc (len); 1450 struct cleanup *verify_cleanups = 1451 make_cleanup (xfree, check); 1452 1453 if (target_read_memory (lma, check, len) != 0) 1454 error ("Download verify read failed at 0x%s", 1455 paddr (lma)); 1456 if (memcmp (buffer, check, len) != 0) 1457 error ("Download verify compare failed at 0x%s", 1458 paddr (lma)); 1459 do_cleanups (verify_cleanups); 1460 } 1461 args->data_count += len; 1462 lma += len; 1463 buffer += len; 1464 args->write_count += 1; 1465 sent += len; 1466 if (quit_flag 1467 || (deprecated_ui_load_progress_hook != NULL 1468 && deprecated_ui_load_progress_hook (sect_name, sent))) 1469 error ("Canceled the download"); 1470 1471 if (deprecated_show_load_progress != NULL) 1472 deprecated_show_load_progress (sect_name, sent, size, 1473 args->data_count, 1474 args->total_size); 1475 } 1476 while (sent < size); 1477 1478 if (err != 0) 1479 error ("Memory access error while loading section %s.", sect_name); 1480 1481 do_cleanups (old_chain); 1482 } 1483 } 1484 } 1485 1486 void 1487 generic_load (char *args, int from_tty) 1488 { 1489 asection *s; 1490 bfd *loadfile_bfd; 1491 time_t start_time, end_time; /* Start and end times of download */ 1492 char *filename; 1493 struct cleanup *old_cleanups; 1494 char *offptr; 1495 struct load_section_data cbdata; 1496 CORE_ADDR entry; 1497 1498 cbdata.load_offset = 0; /* Offset to add to vma for each section. */ 1499 cbdata.write_count = 0; /* Number of writes needed. */ 1500 cbdata.data_count = 0; /* Number of bytes written to target memory. */ 1501 cbdata.total_size = 0; /* Total size of all bfd sectors. */ 1502 1503 /* Parse the input argument - the user can specify a load offset as 1504 a second argument. */ 1505 filename = xmalloc (strlen (args) + 1); 1506 old_cleanups = make_cleanup (xfree, filename); 1507 strcpy (filename, args); 1508 offptr = strchr (filename, ' '); 1509 if (offptr != NULL) 1510 { 1511 char *endptr; 1512 1513 cbdata.load_offset = strtoul (offptr, &endptr, 0); 1514 if (offptr == endptr) 1515 error ("Invalid download offset:%s\n", offptr); 1516 *offptr = '\0'; 1517 } 1518 else 1519 cbdata.load_offset = 0; 1520 1521 /* Open the file for loading. */ 1522 loadfile_bfd = bfd_openr (filename, gnutarget); 1523 if (loadfile_bfd == NULL) 1524 { 1525 perror_with_name (filename); 1526 return; 1527 } 1528 1529 /* FIXME: should be checking for errors from bfd_close (for one thing, 1530 on error it does not free all the storage associated with the 1531 bfd). */ 1532 make_cleanup_bfd_close (loadfile_bfd); 1533 1534 if (!bfd_check_format (loadfile_bfd, bfd_object)) 1535 { 1536 error ("\"%s\" is not an object file: %s", filename, 1537 bfd_errmsg (bfd_get_error ())); 1538 } 1539 1540 bfd_map_over_sections (loadfile_bfd, add_section_size_callback, 1541 (void *) &cbdata.total_size); 1542 1543 start_time = time (NULL); 1544 1545 bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata); 1546 1547 end_time = time (NULL); 1548 1549 entry = bfd_get_start_address (loadfile_bfd); 1550 ui_out_text (uiout, "Start address "); 1551 ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry)); 1552 ui_out_text (uiout, ", load size "); 1553 ui_out_field_fmt (uiout, "load-size", "%lu", cbdata.data_count); 1554 ui_out_text (uiout, "\n"); 1555 /* We were doing this in remote-mips.c, I suspect it is right 1556 for other targets too. */ 1557 write_pc (entry); 1558 1559 /* FIXME: are we supposed to call symbol_file_add or not? According 1560 to a comment from remote-mips.c (where a call to symbol_file_add 1561 was commented out), making the call confuses GDB if more than one 1562 file is loaded in. Some targets do (e.g., remote-vx.c) but 1563 others don't (or didn't - perhaps they have all been deleted). */ 1564 1565 print_transfer_performance (gdb_stdout, cbdata.data_count, 1566 cbdata.write_count, end_time - start_time); 1567 1568 do_cleanups (old_cleanups); 1569 } 1570 1571 /* Report how fast the transfer went. */ 1572 1573 /* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being 1574 replaced by print_transfer_performance (with a very different 1575 function signature). */ 1576 1577 void 1578 report_transfer_performance (unsigned long data_count, time_t start_time, 1579 time_t end_time) 1580 { 1581 print_transfer_performance (gdb_stdout, data_count, 1582 end_time - start_time, 0); 1583 } 1584 1585 void 1586 print_transfer_performance (struct ui_file *stream, 1587 unsigned long data_count, 1588 unsigned long write_count, 1589 unsigned long time_count) 1590 { 1591 ui_out_text (uiout, "Transfer rate: "); 1592 if (time_count > 0) 1593 { 1594 ui_out_field_fmt (uiout, "transfer-rate", "%lu", 1595 (data_count * 8) / time_count); 1596 ui_out_text (uiout, " bits/sec"); 1597 } 1598 else 1599 { 1600 ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8)); 1601 ui_out_text (uiout, " bits in <1 sec"); 1602 } 1603 if (write_count > 0) 1604 { 1605 ui_out_text (uiout, ", "); 1606 ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count); 1607 ui_out_text (uiout, " bytes/write"); 1608 } 1609 ui_out_text (uiout, ".\n"); 1610 } 1611 1612 /* This function allows the addition of incrementally linked object files. 1613 It does not modify any state in the target, only in the debugger. */ 1614 /* Note: ezannoni 2000-04-13 This function/command used to have a 1615 special case syntax for the rombug target (Rombug is the boot 1616 monitor for Microware's OS-9 / OS-9000, see remote-os9k.c). In the 1617 rombug case, the user doesn't need to supply a text address, 1618 instead a call to target_link() (in target.c) would supply the 1619 value to use. We are now discontinuing this type of ad hoc syntax. */ 1620 1621 static void 1622 add_symbol_file_command (char *args, int from_tty) 1623 { 1624 char *filename = NULL; 1625 int flags = OBJF_USERLOADED; 1626 char *arg; 1627 int expecting_option = 0; 1628 int section_index = 0; 1629 int argcnt = 0; 1630 int sec_num = 0; 1631 int i; 1632 int expecting_sec_name = 0; 1633 int expecting_sec_addr = 0; 1634 1635 struct sect_opt 1636 { 1637 char *name; 1638 char *value; 1639 }; 1640 1641 struct section_addr_info *section_addrs; 1642 struct sect_opt *sect_opts = NULL; 1643 size_t num_sect_opts = 0; 1644 struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL); 1645 1646 num_sect_opts = 16; 1647 sect_opts = (struct sect_opt *) xmalloc (num_sect_opts 1648 * sizeof (struct sect_opt)); 1649 1650 dont_repeat (); 1651 1652 if (args == NULL) 1653 error ("add-symbol-file takes a file name and an address"); 1654 1655 /* Make a copy of the string that we can safely write into. */ 1656 args = xstrdup (args); 1657 1658 while (*args != '\000') 1659 { 1660 /* Any leading spaces? */ 1661 while (isspace (*args)) 1662 args++; 1663 1664 /* Point arg to the beginning of the argument. */ 1665 arg = args; 1666 1667 /* Move args pointer over the argument. */ 1668 while ((*args != '\000') && !isspace (*args)) 1669 args++; 1670 1671 /* If there are more arguments, terminate arg and 1672 proceed past it. */ 1673 if (*args != '\000') 1674 *args++ = '\000'; 1675 1676 /* Now process the argument. */ 1677 if (argcnt == 0) 1678 { 1679 /* The first argument is the file name. */ 1680 filename = tilde_expand (arg); 1681 make_cleanup (xfree, filename); 1682 } 1683 else 1684 if (argcnt == 1) 1685 { 1686 /* The second argument is always the text address at which 1687 to load the program. */ 1688 sect_opts[section_index].name = ".text"; 1689 sect_opts[section_index].value = arg; 1690 if (++section_index > num_sect_opts) 1691 { 1692 num_sect_opts *= 2; 1693 sect_opts = ((struct sect_opt *) 1694 xrealloc (sect_opts, 1695 num_sect_opts 1696 * sizeof (struct sect_opt))); 1697 } 1698 } 1699 else 1700 { 1701 /* It's an option (starting with '-') or it's an argument 1702 to an option */ 1703 1704 if (*arg == '-') 1705 { 1706 if (strcmp (arg, "-readnow") == 0) 1707 flags |= OBJF_READNOW; 1708 else if (strcmp (arg, "-s") == 0) 1709 { 1710 expecting_sec_name = 1; 1711 expecting_sec_addr = 1; 1712 } 1713 } 1714 else 1715 { 1716 if (expecting_sec_name) 1717 { 1718 sect_opts[section_index].name = arg; 1719 expecting_sec_name = 0; 1720 } 1721 else 1722 if (expecting_sec_addr) 1723 { 1724 sect_opts[section_index].value = arg; 1725 expecting_sec_addr = 0; 1726 if (++section_index > num_sect_opts) 1727 { 1728 num_sect_opts *= 2; 1729 sect_opts = ((struct sect_opt *) 1730 xrealloc (sect_opts, 1731 num_sect_opts 1732 * sizeof (struct sect_opt))); 1733 } 1734 } 1735 else 1736 error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"); 1737 } 1738 } 1739 argcnt++; 1740 } 1741 1742 /* Print the prompt for the query below. And save the arguments into 1743 a sect_addr_info structure to be passed around to other 1744 functions. We have to split this up into separate print 1745 statements because hex_string returns a local static 1746 string. */ 1747 1748 printf_unfiltered ("add symbol table from file \"%s\" at\n", filename); 1749 section_addrs = alloc_section_addr_info (section_index); 1750 make_cleanup (xfree, section_addrs); 1751 for (i = 0; i < section_index; i++) 1752 { 1753 CORE_ADDR addr; 1754 char *val = sect_opts[i].value; 1755 char *sec = sect_opts[i].name; 1756 1757 addr = parse_and_eval_address (val); 1758 1759 /* Here we store the section offsets in the order they were 1760 entered on the command line. */ 1761 section_addrs->other[sec_num].name = sec; 1762 section_addrs->other[sec_num].addr = addr; 1763 printf_unfiltered ("\t%s_addr = %s\n", 1764 sec, hex_string ((unsigned long)addr)); 1765 sec_num++; 1766 1767 /* The object's sections are initialized when a 1768 call is made to build_objfile_section_table (objfile). 1769 This happens in reread_symbols. 1770 At this point, we don't know what file type this is, 1771 so we can't determine what section names are valid. */ 1772 } 1773 1774 if (from_tty && (!query ("%s", ""))) 1775 error ("Not confirmed."); 1776 1777 symbol_file_add (filename, from_tty, section_addrs, 0, flags); 1778 1779 /* Getting new symbols may change our opinion about what is 1780 frameless. */ 1781 reinit_frame_cache (); 1782 do_cleanups (my_cleanups); 1783 } 1784 1785 static void 1786 add_shared_symbol_files_command (char *args, int from_tty) 1787 { 1788 #ifdef ADD_SHARED_SYMBOL_FILES 1789 ADD_SHARED_SYMBOL_FILES (args, from_tty); 1790 #else 1791 error ("This command is not available in this configuration of GDB."); 1792 #endif 1793 } 1794 1795 /* Re-read symbols if a symbol-file has changed. */ 1796 void 1797 reread_symbols (void) 1798 { 1799 struct objfile *objfile; 1800 long new_modtime; 1801 int reread_one = 0; 1802 struct stat new_statbuf; 1803 int res; 1804 1805 /* With the addition of shared libraries, this should be modified, 1806 the load time should be saved in the partial symbol tables, since 1807 different tables may come from different source files. FIXME. 1808 This routine should then walk down each partial symbol table 1809 and see if the symbol table that it originates from has been changed */ 1810 1811 for (objfile = object_files; objfile; objfile = objfile->next) 1812 { 1813 if (objfile->obfd) 1814 { 1815 #ifdef DEPRECATED_IBM6000_TARGET 1816 /* If this object is from a shared library, then you should 1817 stat on the library name, not member name. */ 1818 1819 if (objfile->obfd->my_archive) 1820 res = stat (objfile->obfd->my_archive->filename, &new_statbuf); 1821 else 1822 #endif 1823 res = stat (objfile->name, &new_statbuf); 1824 if (res != 0) 1825 { 1826 /* FIXME, should use print_sys_errmsg but it's not filtered. */ 1827 printf_unfiltered ("`%s' has disappeared; keeping its symbols.\n", 1828 objfile->name); 1829 continue; 1830 } 1831 new_modtime = new_statbuf.st_mtime; 1832 if (new_modtime != objfile->mtime) 1833 { 1834 struct cleanup *old_cleanups; 1835 struct section_offsets *offsets; 1836 int num_offsets; 1837 char *obfd_filename; 1838 1839 printf_unfiltered ("`%s' has changed; re-reading symbols.\n", 1840 objfile->name); 1841 1842 /* There are various functions like symbol_file_add, 1843 symfile_bfd_open, syms_from_objfile, etc., which might 1844 appear to do what we want. But they have various other 1845 effects which we *don't* want. So we just do stuff 1846 ourselves. We don't worry about mapped files (for one thing, 1847 any mapped file will be out of date). */ 1848 1849 /* If we get an error, blow away this objfile (not sure if 1850 that is the correct response for things like shared 1851 libraries). */ 1852 old_cleanups = make_cleanup_free_objfile (objfile); 1853 /* We need to do this whenever any symbols go away. */ 1854 make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/); 1855 1856 /* Clean up any state BFD has sitting around. We don't need 1857 to close the descriptor but BFD lacks a way of closing the 1858 BFD without closing the descriptor. */ 1859 obfd_filename = bfd_get_filename (objfile->obfd); 1860 if (!bfd_close (objfile->obfd)) 1861 error ("Can't close BFD for %s: %s", objfile->name, 1862 bfd_errmsg (bfd_get_error ())); 1863 objfile->obfd = bfd_openr (obfd_filename, gnutarget); 1864 if (objfile->obfd == NULL) 1865 error ("Can't open %s to read symbols.", objfile->name); 1866 /* bfd_openr sets cacheable to true, which is what we want. */ 1867 if (!bfd_check_format (objfile->obfd, bfd_object)) 1868 error ("Can't read symbols from %s: %s.", objfile->name, 1869 bfd_errmsg (bfd_get_error ())); 1870 1871 /* Save the offsets, we will nuke them with the rest of the 1872 objfile_obstack. */ 1873 num_offsets = objfile->num_sections; 1874 offsets = ((struct section_offsets *) 1875 alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets))); 1876 memcpy (offsets, objfile->section_offsets, 1877 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 1878 1879 /* Nuke all the state that we will re-read. Much of the following 1880 code which sets things to NULL really is necessary to tell 1881 other parts of GDB that there is nothing currently there. */ 1882 1883 /* FIXME: Do we have to free a whole linked list, or is this 1884 enough? */ 1885 if (objfile->global_psymbols.list) 1886 xfree (objfile->global_psymbols.list); 1887 memset (&objfile->global_psymbols, 0, 1888 sizeof (objfile->global_psymbols)); 1889 if (objfile->static_psymbols.list) 1890 xfree (objfile->static_psymbols.list); 1891 memset (&objfile->static_psymbols, 0, 1892 sizeof (objfile->static_psymbols)); 1893 1894 /* Free the obstacks for non-reusable objfiles */ 1895 bcache_xfree (objfile->psymbol_cache); 1896 objfile->psymbol_cache = bcache_xmalloc (); 1897 bcache_xfree (objfile->macro_cache); 1898 objfile->macro_cache = bcache_xmalloc (); 1899 if (objfile->demangled_names_hash != NULL) 1900 { 1901 htab_delete (objfile->demangled_names_hash); 1902 objfile->demangled_names_hash = NULL; 1903 } 1904 obstack_free (&objfile->objfile_obstack, 0); 1905 objfile->sections = NULL; 1906 objfile->symtabs = NULL; 1907 objfile->psymtabs = NULL; 1908 objfile->free_psymtabs = NULL; 1909 objfile->cp_namespace_symtab = NULL; 1910 objfile->msymbols = NULL; 1911 objfile->sym_private = NULL; 1912 objfile->minimal_symbol_count = 0; 1913 memset (&objfile->msymbol_hash, 0, 1914 sizeof (objfile->msymbol_hash)); 1915 memset (&objfile->msymbol_demangled_hash, 0, 1916 sizeof (objfile->msymbol_demangled_hash)); 1917 objfile->fundamental_types = NULL; 1918 clear_objfile_data (objfile); 1919 if (objfile->sf != NULL) 1920 { 1921 (*objfile->sf->sym_finish) (objfile); 1922 } 1923 1924 /* We never make this a mapped file. */ 1925 objfile->md = NULL; 1926 objfile->psymbol_cache = bcache_xmalloc (); 1927 objfile->macro_cache = bcache_xmalloc (); 1928 /* obstack_init also initializes the obstack so it is 1929 empty. We could use obstack_specify_allocation but 1930 gdb_obstack.h specifies the alloc/dealloc 1931 functions. */ 1932 obstack_init (&objfile->objfile_obstack); 1933 if (build_objfile_section_table (objfile)) 1934 { 1935 error ("Can't find the file sections in `%s': %s", 1936 objfile->name, bfd_errmsg (bfd_get_error ())); 1937 } 1938 terminate_minimal_symbol_table (objfile); 1939 1940 /* We use the same section offsets as from last time. I'm not 1941 sure whether that is always correct for shared libraries. */ 1942 objfile->section_offsets = (struct section_offsets *) 1943 obstack_alloc (&objfile->objfile_obstack, 1944 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 1945 memcpy (objfile->section_offsets, offsets, 1946 SIZEOF_N_SECTION_OFFSETS (num_offsets)); 1947 objfile->num_sections = num_offsets; 1948 1949 /* What the hell is sym_new_init for, anyway? The concept of 1950 distinguishing between the main file and additional files 1951 in this way seems rather dubious. */ 1952 if (objfile == symfile_objfile) 1953 { 1954 (*objfile->sf->sym_new_init) (objfile); 1955 } 1956 1957 (*objfile->sf->sym_init) (objfile); 1958 clear_complaints (&symfile_complaints, 1, 1); 1959 /* The "mainline" parameter is a hideous hack; I think leaving it 1960 zero is OK since dbxread.c also does what it needs to do if 1961 objfile->global_psymbols.size is 0. */ 1962 (*objfile->sf->sym_read) (objfile, 0); 1963 if (!have_partial_symbols () && !have_full_symbols ()) 1964 { 1965 wrap_here (""); 1966 printf_unfiltered ("(no debugging symbols found)\n"); 1967 wrap_here (""); 1968 } 1969 objfile->flags |= OBJF_SYMS; 1970 1971 /* We're done reading the symbol file; finish off complaints. */ 1972 clear_complaints (&symfile_complaints, 0, 1); 1973 1974 /* Getting new symbols may change our opinion about what is 1975 frameless. */ 1976 1977 reinit_frame_cache (); 1978 1979 /* Discard cleanups as symbol reading was successful. */ 1980 discard_cleanups (old_cleanups); 1981 1982 /* If the mtime has changed between the time we set new_modtime 1983 and now, we *want* this to be out of date, so don't call stat 1984 again now. */ 1985 objfile->mtime = new_modtime; 1986 reread_one = 1; 1987 reread_separate_symbols (objfile); 1988 } 1989 } 1990 } 1991 1992 if (reread_one) 1993 clear_symtab_users (); 1994 } 1995 1996 1997 /* Handle separate debug info for OBJFILE, which has just been 1998 re-read: 1999 - If we had separate debug info before, but now we don't, get rid 2000 of the separated objfile. 2001 - If we didn't have separated debug info before, but now we do, 2002 read in the new separated debug info file. 2003 - If the debug link points to a different file, toss the old one 2004 and read the new one. 2005 This function does *not* handle the case where objfile is still 2006 using the same separate debug info file, but that file's timestamp 2007 has changed. That case should be handled by the loop in 2008 reread_symbols already. */ 2009 static void 2010 reread_separate_symbols (struct objfile *objfile) 2011 { 2012 char *debug_file; 2013 unsigned long crc32; 2014 2015 /* Does the updated objfile's debug info live in a 2016 separate file? */ 2017 debug_file = find_separate_debug_file (objfile); 2018 2019 if (objfile->separate_debug_objfile) 2020 { 2021 /* There are two cases where we need to get rid of 2022 the old separated debug info objfile: 2023 - if the new primary objfile doesn't have 2024 separated debug info, or 2025 - if the new primary objfile has separate debug 2026 info, but it's under a different filename. 2027 2028 If the old and new objfiles both have separate 2029 debug info, under the same filename, then we're 2030 okay --- if the separated file's contents have 2031 changed, we will have caught that when we 2032 visited it in this function's outermost 2033 loop. */ 2034 if (! debug_file 2035 || strcmp (debug_file, objfile->separate_debug_objfile->name) != 0) 2036 free_objfile (objfile->separate_debug_objfile); 2037 } 2038 2039 /* If the new objfile has separate debug info, and we 2040 haven't loaded it already, do so now. */ 2041 if (debug_file 2042 && ! objfile->separate_debug_objfile) 2043 { 2044 /* Use the same section offset table as objfile itself. 2045 Preserve the flags from objfile that make sense. */ 2046 objfile->separate_debug_objfile 2047 = (symbol_file_add_with_addrs_or_offsets 2048 (symfile_bfd_open (debug_file), 2049 info_verbose, /* from_tty: Don't override the default. */ 2050 0, /* No addr table. */ 2051 objfile->section_offsets, objfile->num_sections, 2052 0, /* Not mainline. See comments about this above. */ 2053 objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW 2054 | OBJF_USERLOADED))); 2055 objfile->separate_debug_objfile->separate_debug_objfile_backlink 2056 = objfile; 2057 } 2058 } 2059 2060 2061 2062 2063 2064 typedef struct 2065 { 2066 char *ext; 2067 enum language lang; 2068 } 2069 filename_language; 2070 2071 static filename_language *filename_language_table; 2072 static int fl_table_size, fl_table_next; 2073 2074 static void 2075 add_filename_language (char *ext, enum language lang) 2076 { 2077 if (fl_table_next >= fl_table_size) 2078 { 2079 fl_table_size += 10; 2080 filename_language_table = 2081 xrealloc (filename_language_table, 2082 fl_table_size * sizeof (*filename_language_table)); 2083 } 2084 2085 filename_language_table[fl_table_next].ext = xstrdup (ext); 2086 filename_language_table[fl_table_next].lang = lang; 2087 fl_table_next++; 2088 } 2089 2090 static char *ext_args; 2091 2092 static void 2093 set_ext_lang_command (char *args, int from_tty) 2094 { 2095 int i; 2096 char *cp = ext_args; 2097 enum language lang; 2098 2099 /* First arg is filename extension, starting with '.' */ 2100 if (*cp != '.') 2101 error ("'%s': Filename extension must begin with '.'", ext_args); 2102 2103 /* Find end of first arg. */ 2104 while (*cp && !isspace (*cp)) 2105 cp++; 2106 2107 if (*cp == '\0') 2108 error ("'%s': two arguments required -- filename extension and language", 2109 ext_args); 2110 2111 /* Null-terminate first arg */ 2112 *cp++ = '\0'; 2113 2114 /* Find beginning of second arg, which should be a source language. */ 2115 while (*cp && isspace (*cp)) 2116 cp++; 2117 2118 if (*cp == '\0') 2119 error ("'%s': two arguments required -- filename extension and language", 2120 ext_args); 2121 2122 /* Lookup the language from among those we know. */ 2123 lang = language_enum (cp); 2124 2125 /* Now lookup the filename extension: do we already know it? */ 2126 for (i = 0; i < fl_table_next; i++) 2127 if (0 == strcmp (ext_args, filename_language_table[i].ext)) 2128 break; 2129 2130 if (i >= fl_table_next) 2131 { 2132 /* new file extension */ 2133 add_filename_language (ext_args, lang); 2134 } 2135 else 2136 { 2137 /* redefining a previously known filename extension */ 2138 2139 /* if (from_tty) */ 2140 /* query ("Really make files of type %s '%s'?", */ 2141 /* ext_args, language_str (lang)); */ 2142 2143 xfree (filename_language_table[i].ext); 2144 filename_language_table[i].ext = xstrdup (ext_args); 2145 filename_language_table[i].lang = lang; 2146 } 2147 } 2148 2149 static void 2150 info_ext_lang_command (char *args, int from_tty) 2151 { 2152 int i; 2153 2154 printf_filtered ("Filename extensions and the languages they represent:"); 2155 printf_filtered ("\n\n"); 2156 for (i = 0; i < fl_table_next; i++) 2157 printf_filtered ("\t%s\t- %s\n", 2158 filename_language_table[i].ext, 2159 language_str (filename_language_table[i].lang)); 2160 } 2161 2162 static void 2163 init_filename_language_table (void) 2164 { 2165 if (fl_table_size == 0) /* protect against repetition */ 2166 { 2167 fl_table_size = 20; 2168 fl_table_next = 0; 2169 filename_language_table = 2170 xmalloc (fl_table_size * sizeof (*filename_language_table)); 2171 add_filename_language (".c", language_c); 2172 add_filename_language (".C", language_cplus); 2173 add_filename_language (".cc", language_cplus); 2174 add_filename_language (".cp", language_cplus); 2175 add_filename_language (".cpp", language_cplus); 2176 add_filename_language (".cxx", language_cplus); 2177 add_filename_language (".c++", language_cplus); 2178 add_filename_language (".java", language_java); 2179 add_filename_language (".class", language_java); 2180 add_filename_language (".m", language_objc); 2181 add_filename_language (".f", language_fortran); 2182 add_filename_language (".F", language_fortran); 2183 add_filename_language (".s", language_asm); 2184 add_filename_language (".S", language_asm); 2185 add_filename_language (".pas", language_pascal); 2186 add_filename_language (".p", language_pascal); 2187 add_filename_language (".pp", language_pascal); 2188 add_filename_language (".adb", language_ada); 2189 add_filename_language (".ads", language_ada); 2190 add_filename_language (".a", language_ada); 2191 add_filename_language (".ada", language_ada); 2192 } 2193 } 2194 2195 enum language 2196 deduce_language_from_filename (char *filename) 2197 { 2198 int i; 2199 char *cp; 2200 2201 if (filename != NULL) 2202 if ((cp = strrchr (filename, '.')) != NULL) 2203 for (i = 0; i < fl_table_next; i++) 2204 if (strcmp (cp, filename_language_table[i].ext) == 0) 2205 return filename_language_table[i].lang; 2206 2207 return language_unknown; 2208 } 2209 2210 /* allocate_symtab: 2211 2212 Allocate and partly initialize a new symbol table. Return a pointer 2213 to it. error() if no space. 2214 2215 Caller must set these fields: 2216 LINETABLE(symtab) 2217 symtab->blockvector 2218 symtab->dirname 2219 symtab->free_code 2220 symtab->free_ptr 2221 possibly free_named_symtabs (symtab->filename); 2222 */ 2223 2224 struct symtab * 2225 allocate_symtab (char *filename, struct objfile *objfile) 2226 { 2227 struct symtab *symtab; 2228 2229 symtab = (struct symtab *) 2230 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab)); 2231 memset (symtab, 0, sizeof (*symtab)); 2232 symtab->filename = obsavestring (filename, strlen (filename), 2233 &objfile->objfile_obstack); 2234 symtab->fullname = NULL; 2235 symtab->language = deduce_language_from_filename (filename); 2236 symtab->debugformat = obsavestring ("unknown", 7, 2237 &objfile->objfile_obstack); 2238 2239 /* Hook it to the objfile it comes from */ 2240 2241 symtab->objfile = objfile; 2242 symtab->next = objfile->symtabs; 2243 objfile->symtabs = symtab; 2244 2245 /* FIXME: This should go away. It is only defined for the Z8000, 2246 and the Z8000 definition of this macro doesn't have anything to 2247 do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just 2248 here for convenience. */ 2249 #ifdef INIT_EXTRA_SYMTAB_INFO 2250 INIT_EXTRA_SYMTAB_INFO (symtab); 2251 #endif 2252 2253 return (symtab); 2254 } 2255 2256 struct partial_symtab * 2257 allocate_psymtab (char *filename, struct objfile *objfile) 2258 { 2259 struct partial_symtab *psymtab; 2260 2261 if (objfile->free_psymtabs) 2262 { 2263 psymtab = objfile->free_psymtabs; 2264 objfile->free_psymtabs = psymtab->next; 2265 } 2266 else 2267 psymtab = (struct partial_symtab *) 2268 obstack_alloc (&objfile->objfile_obstack, 2269 sizeof (struct partial_symtab)); 2270 2271 memset (psymtab, 0, sizeof (struct partial_symtab)); 2272 psymtab->filename = obsavestring (filename, strlen (filename), 2273 &objfile->objfile_obstack); 2274 psymtab->symtab = NULL; 2275 2276 /* Prepend it to the psymtab list for the objfile it belongs to. 2277 Psymtabs are searched in most recent inserted -> least recent 2278 inserted order. */ 2279 2280 psymtab->objfile = objfile; 2281 psymtab->next = objfile->psymtabs; 2282 objfile->psymtabs = psymtab; 2283 #if 0 2284 { 2285 struct partial_symtab **prev_pst; 2286 psymtab->objfile = objfile; 2287 psymtab->next = NULL; 2288 prev_pst = &(objfile->psymtabs); 2289 while ((*prev_pst) != NULL) 2290 prev_pst = &((*prev_pst)->next); 2291 (*prev_pst) = psymtab; 2292 } 2293 #endif 2294 2295 return (psymtab); 2296 } 2297 2298 void 2299 discard_psymtab (struct partial_symtab *pst) 2300 { 2301 struct partial_symtab **prev_pst; 2302 2303 /* From dbxread.c: 2304 Empty psymtabs happen as a result of header files which don't 2305 have any symbols in them. There can be a lot of them. But this 2306 check is wrong, in that a psymtab with N_SLINE entries but 2307 nothing else is not empty, but we don't realize that. Fixing 2308 that without slowing things down might be tricky. */ 2309 2310 /* First, snip it out of the psymtab chain */ 2311 2312 prev_pst = &(pst->objfile->psymtabs); 2313 while ((*prev_pst) != pst) 2314 prev_pst = &((*prev_pst)->next); 2315 (*prev_pst) = pst->next; 2316 2317 /* Next, put it on a free list for recycling */ 2318 2319 pst->next = pst->objfile->free_psymtabs; 2320 pst->objfile->free_psymtabs = pst; 2321 } 2322 2323 2324 /* Reset all data structures in gdb which may contain references to symbol 2325 table data. */ 2326 2327 void 2328 clear_symtab_users (void) 2329 { 2330 /* Someday, we should do better than this, by only blowing away 2331 the things that really need to be blown. */ 2332 clear_value_history (); 2333 clear_displays (); 2334 clear_internalvars (); 2335 breakpoint_re_set (); 2336 set_default_breakpoint (0, 0, 0, 0); 2337 clear_current_source_symtab_and_line (); 2338 clear_pc_function_cache (); 2339 if (deprecated_target_new_objfile_hook) 2340 deprecated_target_new_objfile_hook (NULL); 2341 } 2342 2343 static void 2344 clear_symtab_users_cleanup (void *ignore) 2345 { 2346 clear_symtab_users (); 2347 } 2348 2349 /* clear_symtab_users_once: 2350 2351 This function is run after symbol reading, or from a cleanup. 2352 If an old symbol table was obsoleted, the old symbol table 2353 has been blown away, but the other GDB data structures that may 2354 reference it have not yet been cleared or re-directed. (The old 2355 symtab was zapped, and the cleanup queued, in free_named_symtab() 2356 below.) 2357 2358 This function can be queued N times as a cleanup, or called 2359 directly; it will do all the work the first time, and then will be a 2360 no-op until the next time it is queued. This works by bumping a 2361 counter at queueing time. Much later when the cleanup is run, or at 2362 the end of symbol processing (in case the cleanup is discarded), if 2363 the queued count is greater than the "done-count", we do the work 2364 and set the done-count to the queued count. If the queued count is 2365 less than or equal to the done-count, we just ignore the call. This 2366 is needed because reading a single .o file will often replace many 2367 symtabs (one per .h file, for example), and we don't want to reset 2368 the breakpoints N times in the user's face. 2369 2370 The reason we both queue a cleanup, and call it directly after symbol 2371 reading, is because the cleanup protects us in case of errors, but is 2372 discarded if symbol reading is successful. */ 2373 2374 #if 0 2375 /* FIXME: As free_named_symtabs is currently a big noop this function 2376 is no longer needed. */ 2377 static void clear_symtab_users_once (void); 2378 2379 static int clear_symtab_users_queued; 2380 static int clear_symtab_users_done; 2381 2382 static void 2383 clear_symtab_users_once (void) 2384 { 2385 /* Enforce once-per-`do_cleanups'-semantics */ 2386 if (clear_symtab_users_queued <= clear_symtab_users_done) 2387 return; 2388 clear_symtab_users_done = clear_symtab_users_queued; 2389 2390 clear_symtab_users (); 2391 } 2392 #endif 2393 2394 /* Delete the specified psymtab, and any others that reference it. */ 2395 2396 static void 2397 cashier_psymtab (struct partial_symtab *pst) 2398 { 2399 struct partial_symtab *ps, *pprev = NULL; 2400 int i; 2401 2402 /* Find its previous psymtab in the chain */ 2403 for (ps = pst->objfile->psymtabs; ps; ps = ps->next) 2404 { 2405 if (ps == pst) 2406 break; 2407 pprev = ps; 2408 } 2409 2410 if (ps) 2411 { 2412 /* Unhook it from the chain. */ 2413 if (ps == pst->objfile->psymtabs) 2414 pst->objfile->psymtabs = ps->next; 2415 else 2416 pprev->next = ps->next; 2417 2418 /* FIXME, we can't conveniently deallocate the entries in the 2419 partial_symbol lists (global_psymbols/static_psymbols) that 2420 this psymtab points to. These just take up space until all 2421 the psymtabs are reclaimed. Ditto the dependencies list and 2422 filename, which are all in the objfile_obstack. */ 2423 2424 /* We need to cashier any psymtab that has this one as a dependency... */ 2425 again: 2426 for (ps = pst->objfile->psymtabs; ps; ps = ps->next) 2427 { 2428 for (i = 0; i < ps->number_of_dependencies; i++) 2429 { 2430 if (ps->dependencies[i] == pst) 2431 { 2432 cashier_psymtab (ps); 2433 goto again; /* Must restart, chain has been munged. */ 2434 } 2435 } 2436 } 2437 } 2438 } 2439 2440 /* If a symtab or psymtab for filename NAME is found, free it along 2441 with any dependent breakpoints, displays, etc. 2442 Used when loading new versions of object modules with the "add-file" 2443 command. This is only called on the top-level symtab or psymtab's name; 2444 it is not called for subsidiary files such as .h files. 2445 2446 Return value is 1 if we blew away the environment, 0 if not. 2447 FIXME. The return value appears to never be used. 2448 2449 FIXME. I think this is not the best way to do this. We should 2450 work on being gentler to the environment while still cleaning up 2451 all stray pointers into the freed symtab. */ 2452 2453 int 2454 free_named_symtabs (char *name) 2455 { 2456 #if 0 2457 /* FIXME: With the new method of each objfile having it's own 2458 psymtab list, this function needs serious rethinking. In particular, 2459 why was it ever necessary to toss psymtabs with specific compilation 2460 unit filenames, as opposed to all psymtabs from a particular symbol 2461 file? -- fnf 2462 Well, the answer is that some systems permit reloading of particular 2463 compilation units. We want to blow away any old info about these 2464 compilation units, regardless of which objfiles they arrived in. --gnu. */ 2465 2466 struct symtab *s; 2467 struct symtab *prev; 2468 struct partial_symtab *ps; 2469 struct blockvector *bv; 2470 int blewit = 0; 2471 2472 /* We only wack things if the symbol-reload switch is set. */ 2473 if (!symbol_reloading) 2474 return 0; 2475 2476 /* Some symbol formats have trouble providing file names... */ 2477 if (name == 0 || *name == '\0') 2478 return 0; 2479 2480 /* Look for a psymtab with the specified name. */ 2481 2482 again2: 2483 for (ps = partial_symtab_list; ps; ps = ps->next) 2484 { 2485 if (strcmp (name, ps->filename) == 0) 2486 { 2487 cashier_psymtab (ps); /* Blow it away...and its little dog, too. */ 2488 goto again2; /* Must restart, chain has been munged */ 2489 } 2490 } 2491 2492 /* Look for a symtab with the specified name. */ 2493 2494 for (s = symtab_list; s; s = s->next) 2495 { 2496 if (strcmp (name, s->filename) == 0) 2497 break; 2498 prev = s; 2499 } 2500 2501 if (s) 2502 { 2503 if (s == symtab_list) 2504 symtab_list = s->next; 2505 else 2506 prev->next = s->next; 2507 2508 /* For now, queue a delete for all breakpoints, displays, etc., whether 2509 or not they depend on the symtab being freed. This should be 2510 changed so that only those data structures affected are deleted. */ 2511 2512 /* But don't delete anything if the symtab is empty. 2513 This test is necessary due to a bug in "dbxread.c" that 2514 causes empty symtabs to be created for N_SO symbols that 2515 contain the pathname of the object file. (This problem 2516 has been fixed in GDB 3.9x). */ 2517 2518 bv = BLOCKVECTOR (s); 2519 if (BLOCKVECTOR_NBLOCKS (bv) > 2 2520 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) 2521 || BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))) 2522 { 2523 complaint (&symfile_complaints, "Replacing old symbols for `%s'", 2524 name); 2525 clear_symtab_users_queued++; 2526 make_cleanup (clear_symtab_users_once, 0); 2527 blewit = 1; 2528 } 2529 else 2530 { 2531 complaint (&symfile_complaints, "Empty symbol table found for `%s'", 2532 name); 2533 } 2534 2535 free_symtab (s); 2536 } 2537 else 2538 { 2539 /* It is still possible that some breakpoints will be affected 2540 even though no symtab was found, since the file might have 2541 been compiled without debugging, and hence not be associated 2542 with a symtab. In order to handle this correctly, we would need 2543 to keep a list of text address ranges for undebuggable files. 2544 For now, we do nothing, since this is a fairly obscure case. */ 2545 ; 2546 } 2547 2548 /* FIXME, what about the minimal symbol table? */ 2549 return blewit; 2550 #else 2551 return (0); 2552 #endif 2553 } 2554 2555 /* Allocate and partially fill a partial symtab. It will be 2556 completely filled at the end of the symbol list. 2557 2558 FILENAME is the name of the symbol-file we are reading from. */ 2559 2560 struct partial_symtab * 2561 start_psymtab_common (struct objfile *objfile, 2562 struct section_offsets *section_offsets, char *filename, 2563 CORE_ADDR textlow, struct partial_symbol **global_syms, 2564 struct partial_symbol **static_syms) 2565 { 2566 struct partial_symtab *psymtab; 2567 2568 psymtab = allocate_psymtab (filename, objfile); 2569 psymtab->section_offsets = section_offsets; 2570 psymtab->textlow = textlow; 2571 psymtab->texthigh = psymtab->textlow; /* default */ 2572 psymtab->globals_offset = global_syms - objfile->global_psymbols.list; 2573 psymtab->statics_offset = static_syms - objfile->static_psymbols.list; 2574 return (psymtab); 2575 } 2576 2577 /* Add a symbol with a long value to a psymtab. 2578 Since one arg is a struct, we pass in a ptr and deref it (sigh). 2579 Return the partial symbol that has been added. */ 2580 2581 /* NOTE: carlton/2003-09-11: The reason why we return the partial 2582 symbol is so that callers can get access to the symbol's demangled 2583 name, which they don't have any cheap way to determine otherwise. 2584 (Currenly, dwarf2read.c is the only file who uses that information, 2585 though it's possible that other readers might in the future.) 2586 Elena wasn't thrilled about that, and I don't blame her, but we 2587 couldn't come up with a better way to get that information. If 2588 it's needed in other situations, we could consider breaking up 2589 SYMBOL_SET_NAMES to provide access to the demangled name lookup 2590 cache. */ 2591 2592 const struct partial_symbol * 2593 add_psymbol_to_list (char *name, int namelength, domain_enum domain, 2594 enum address_class class, 2595 struct psymbol_allocation_list *list, long val, /* Value as a long */ 2596 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */ 2597 enum language language, struct objfile *objfile) 2598 { 2599 struct partial_symbol *psym; 2600 char *buf = alloca (namelength + 1); 2601 /* psymbol is static so that there will be no uninitialized gaps in the 2602 structure which might contain random data, causing cache misses in 2603 bcache. */ 2604 static struct partial_symbol psymbol; 2605 2606 /* Create local copy of the partial symbol */ 2607 memcpy (buf, name, namelength); 2608 buf[namelength] = '\0'; 2609 /* val and coreaddr are mutually exclusive, one of them *will* be zero */ 2610 if (val != 0) 2611 { 2612 SYMBOL_VALUE (&psymbol) = val; 2613 } 2614 else 2615 { 2616 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr; 2617 } 2618 SYMBOL_SECTION (&psymbol) = 0; 2619 SYMBOL_LANGUAGE (&psymbol) = language; 2620 PSYMBOL_DOMAIN (&psymbol) = domain; 2621 PSYMBOL_CLASS (&psymbol) = class; 2622 2623 SYMBOL_SET_NAMES (&psymbol, buf, namelength, objfile); 2624 2625 /* Stash the partial symbol away in the cache */ 2626 psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol), 2627 objfile->psymbol_cache); 2628 2629 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */ 2630 if (list->next >= list->list + list->size) 2631 { 2632 extend_psymbol_list (list, objfile); 2633 } 2634 *list->next++ = psym; 2635 OBJSTAT (objfile, n_psyms++); 2636 2637 return psym; 2638 } 2639 2640 /* Add a symbol with a long value to a psymtab. This differs from 2641 * add_psymbol_to_list above in taking both a mangled and a demangled 2642 * name. */ 2643 2644 void 2645 add_psymbol_with_dem_name_to_list (char *name, int namelength, char *dem_name, 2646 int dem_namelength, domain_enum domain, 2647 enum address_class class, 2648 struct psymbol_allocation_list *list, long val, /* Value as a long */ 2649 CORE_ADDR coreaddr, /* Value as a CORE_ADDR */ 2650 enum language language, 2651 struct objfile *objfile) 2652 { 2653 struct partial_symbol *psym; 2654 char *buf = alloca (namelength + 1); 2655 /* psymbol is static so that there will be no uninitialized gaps in the 2656 structure which might contain random data, causing cache misses in 2657 bcache. */ 2658 static struct partial_symbol psymbol; 2659 2660 /* Create local copy of the partial symbol */ 2661 2662 memcpy (buf, name, namelength); 2663 buf[namelength] = '\0'; 2664 DEPRECATED_SYMBOL_NAME (&psymbol) = deprecated_bcache (buf, namelength + 1, 2665 objfile->psymbol_cache); 2666 2667 buf = alloca (dem_namelength + 1); 2668 memcpy (buf, dem_name, dem_namelength); 2669 buf[dem_namelength] = '\0'; 2670 2671 switch (language) 2672 { 2673 case language_c: 2674 case language_cplus: 2675 SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol) = 2676 deprecated_bcache (buf, dem_namelength + 1, objfile->psymbol_cache); 2677 break; 2678 /* FIXME What should be done for the default case? Ignoring for now. */ 2679 } 2680 2681 /* val and coreaddr are mutually exclusive, one of them *will* be zero */ 2682 if (val != 0) 2683 { 2684 SYMBOL_VALUE (&psymbol) = val; 2685 } 2686 else 2687 { 2688 SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr; 2689 } 2690 SYMBOL_SECTION (&psymbol) = 0; 2691 SYMBOL_LANGUAGE (&psymbol) = language; 2692 PSYMBOL_DOMAIN (&psymbol) = domain; 2693 PSYMBOL_CLASS (&psymbol) = class; 2694 SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language); 2695 2696 /* Stash the partial symbol away in the cache */ 2697 psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol), 2698 objfile->psymbol_cache); 2699 2700 /* Save pointer to partial symbol in psymtab, growing symtab if needed. */ 2701 if (list->next >= list->list + list->size) 2702 { 2703 extend_psymbol_list (list, objfile); 2704 } 2705 *list->next++ = psym; 2706 OBJSTAT (objfile, n_psyms++); 2707 } 2708 2709 /* Initialize storage for partial symbols. */ 2710 2711 void 2712 init_psymbol_list (struct objfile *objfile, int total_symbols) 2713 { 2714 /* Free any previously allocated psymbol lists. */ 2715 2716 if (objfile->global_psymbols.list) 2717 { 2718 xfree (objfile->global_psymbols.list); 2719 } 2720 if (objfile->static_psymbols.list) 2721 { 2722 xfree (objfile->static_psymbols.list); 2723 } 2724 2725 /* Current best guess is that approximately a twentieth 2726 of the total symbols (in a debugging file) are global or static 2727 oriented symbols */ 2728 2729 objfile->global_psymbols.size = total_symbols / 10; 2730 objfile->static_psymbols.size = total_symbols / 10; 2731 2732 if (objfile->global_psymbols.size > 0) 2733 { 2734 objfile->global_psymbols.next = 2735 objfile->global_psymbols.list = (struct partial_symbol **) 2736 xmalloc ((objfile->global_psymbols.size 2737 * sizeof (struct partial_symbol *))); 2738 } 2739 if (objfile->static_psymbols.size > 0) 2740 { 2741 objfile->static_psymbols.next = 2742 objfile->static_psymbols.list = (struct partial_symbol **) 2743 xmalloc ((objfile->static_psymbols.size 2744 * sizeof (struct partial_symbol *))); 2745 } 2746 } 2747 2748 /* OVERLAYS: 2749 The following code implements an abstraction for debugging overlay sections. 2750 2751 The target model is as follows: 2752 1) The gnu linker will permit multiple sections to be mapped into the 2753 same VMA, each with its own unique LMA (or load address). 2754 2) It is assumed that some runtime mechanism exists for mapping the 2755 sections, one by one, from the load address into the VMA address. 2756 3) This code provides a mechanism for gdb to keep track of which 2757 sections should be considered to be mapped from the VMA to the LMA. 2758 This information is used for symbol lookup, and memory read/write. 2759 For instance, if a section has been mapped then its contents 2760 should be read from the VMA, otherwise from the LMA. 2761 2762 Two levels of debugger support for overlays are available. One is 2763 "manual", in which the debugger relies on the user to tell it which 2764 overlays are currently mapped. This level of support is 2765 implemented entirely in the core debugger, and the information about 2766 whether a section is mapped is kept in the objfile->obj_section table. 2767 2768 The second level of support is "automatic", and is only available if 2769 the target-specific code provides functionality to read the target's 2770 overlay mapping table, and translate its contents for the debugger 2771 (by updating the mapped state information in the obj_section tables). 2772 2773 The interface is as follows: 2774 User commands: 2775 overlay map <name> -- tell gdb to consider this section mapped 2776 overlay unmap <name> -- tell gdb to consider this section unmapped 2777 overlay list -- list the sections that GDB thinks are mapped 2778 overlay read-target -- get the target's state of what's mapped 2779 overlay off/manual/auto -- set overlay debugging state 2780 Functional interface: 2781 find_pc_mapped_section(pc): if the pc is in the range of a mapped 2782 section, return that section. 2783 find_pc_overlay(pc): find any overlay section that contains 2784 the pc, either in its VMA or its LMA 2785 overlay_is_mapped(sect): true if overlay is marked as mapped 2786 section_is_overlay(sect): true if section's VMA != LMA 2787 pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA 2788 pc_in_unmapped_range(...): true if pc belongs to section's LMA 2789 sections_overlap(sec1, sec2): true if mapped sec1 and sec2 ranges overlap 2790 overlay_mapped_address(...): map an address from section's LMA to VMA 2791 overlay_unmapped_address(...): map an address from section's VMA to LMA 2792 symbol_overlayed_address(...): Return a "current" address for symbol: 2793 either in VMA or LMA depending on whether 2794 the symbol's section is currently mapped 2795 */ 2796 2797 /* Overlay debugging state: */ 2798 2799 enum overlay_debugging_state overlay_debugging = ovly_off; 2800 int overlay_cache_invalid = 0; /* True if need to refresh mapped state */ 2801 2802 /* Target vector for refreshing overlay mapped state */ 2803 static void simple_overlay_update (struct obj_section *); 2804 void (*target_overlay_update) (struct obj_section *) = simple_overlay_update; 2805 2806 /* Function: section_is_overlay (SECTION) 2807 Returns true if SECTION has VMA not equal to LMA, ie. 2808 SECTION is loaded at an address different from where it will "run". */ 2809 2810 int 2811 section_is_overlay (asection *section) 2812 { 2813 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */ 2814 2815 if (overlay_debugging) 2816 if (section && section->lma != 0 && 2817 section->vma != section->lma) 2818 return 1; 2819 2820 return 0; 2821 } 2822 2823 /* Function: overlay_invalidate_all (void) 2824 Invalidate the mapped state of all overlay sections (mark it as stale). */ 2825 2826 static void 2827 overlay_invalidate_all (void) 2828 { 2829 struct objfile *objfile; 2830 struct obj_section *sect; 2831 2832 ALL_OBJSECTIONS (objfile, sect) 2833 if (section_is_overlay (sect->the_bfd_section)) 2834 sect->ovly_mapped = -1; 2835 } 2836 2837 /* Function: overlay_is_mapped (SECTION) 2838 Returns true if section is an overlay, and is currently mapped. 2839 Private: public access is thru function section_is_mapped. 2840 2841 Access to the ovly_mapped flag is restricted to this function, so 2842 that we can do automatic update. If the global flag 2843 OVERLAY_CACHE_INVALID is set (by wait_for_inferior), then call 2844 overlay_invalidate_all. If the mapped state of the particular 2845 section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */ 2846 2847 static int 2848 overlay_is_mapped (struct obj_section *osect) 2849 { 2850 if (osect == 0 || !section_is_overlay (osect->the_bfd_section)) 2851 return 0; 2852 2853 switch (overlay_debugging) 2854 { 2855 default: 2856 case ovly_off: 2857 return 0; /* overlay debugging off */ 2858 case ovly_auto: /* overlay debugging automatic */ 2859 /* Unles there is a target_overlay_update function, 2860 there's really nothing useful to do here (can't really go auto) */ 2861 if (target_overlay_update) 2862 { 2863 if (overlay_cache_invalid) 2864 { 2865 overlay_invalidate_all (); 2866 overlay_cache_invalid = 0; 2867 } 2868 if (osect->ovly_mapped == -1) 2869 (*target_overlay_update) (osect); 2870 } 2871 /* fall thru to manual case */ 2872 case ovly_on: /* overlay debugging manual */ 2873 return osect->ovly_mapped == 1; 2874 } 2875 } 2876 2877 /* Function: section_is_mapped 2878 Returns true if section is an overlay, and is currently mapped. */ 2879 2880 int 2881 section_is_mapped (asection *section) 2882 { 2883 struct objfile *objfile; 2884 struct obj_section *osect; 2885 2886 if (overlay_debugging) 2887 if (section && section_is_overlay (section)) 2888 ALL_OBJSECTIONS (objfile, osect) 2889 if (osect->the_bfd_section == section) 2890 return overlay_is_mapped (osect); 2891 2892 return 0; 2893 } 2894 2895 /* Function: pc_in_unmapped_range 2896 If PC falls into the lma range of SECTION, return true, else false. */ 2897 2898 CORE_ADDR 2899 pc_in_unmapped_range (CORE_ADDR pc, asection *section) 2900 { 2901 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */ 2902 2903 int size; 2904 2905 if (overlay_debugging) 2906 if (section && section_is_overlay (section)) 2907 { 2908 size = bfd_get_section_size (section); 2909 if (section->lma <= pc && pc < section->lma + size) 2910 return 1; 2911 } 2912 return 0; 2913 } 2914 2915 /* Function: pc_in_mapped_range 2916 If PC falls into the vma range of SECTION, return true, else false. */ 2917 2918 CORE_ADDR 2919 pc_in_mapped_range (CORE_ADDR pc, asection *section) 2920 { 2921 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */ 2922 2923 int size; 2924 2925 if (overlay_debugging) 2926 if (section && section_is_overlay (section)) 2927 { 2928 size = bfd_get_section_size (section); 2929 if (section->vma <= pc && pc < section->vma + size) 2930 return 1; 2931 } 2932 return 0; 2933 } 2934 2935 2936 /* Return true if the mapped ranges of sections A and B overlap, false 2937 otherwise. */ 2938 static int 2939 sections_overlap (asection *a, asection *b) 2940 { 2941 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */ 2942 2943 CORE_ADDR a_start = a->vma; 2944 CORE_ADDR a_end = a->vma + bfd_get_section_size (a); 2945 CORE_ADDR b_start = b->vma; 2946 CORE_ADDR b_end = b->vma + bfd_get_section_size (b); 2947 2948 return (a_start < b_end && b_start < a_end); 2949 } 2950 2951 /* Function: overlay_unmapped_address (PC, SECTION) 2952 Returns the address corresponding to PC in the unmapped (load) range. 2953 May be the same as PC. */ 2954 2955 CORE_ADDR 2956 overlay_unmapped_address (CORE_ADDR pc, asection *section) 2957 { 2958 /* FIXME: need bfd *, so we can use bfd_section_lma methods. */ 2959 2960 if (overlay_debugging) 2961 if (section && section_is_overlay (section) && 2962 pc_in_mapped_range (pc, section)) 2963 return pc + section->lma - section->vma; 2964 2965 return pc; 2966 } 2967 2968 /* Function: overlay_mapped_address (PC, SECTION) 2969 Returns the address corresponding to PC in the mapped (runtime) range. 2970 May be the same as PC. */ 2971 2972 CORE_ADDR 2973 overlay_mapped_address (CORE_ADDR pc, asection *section) 2974 { 2975 /* FIXME: need bfd *, so we can use bfd_section_vma methods. */ 2976 2977 if (overlay_debugging) 2978 if (section && section_is_overlay (section) && 2979 pc_in_unmapped_range (pc, section)) 2980 return pc + section->vma - section->lma; 2981 2982 return pc; 2983 } 2984 2985 2986 /* Function: symbol_overlayed_address 2987 Return one of two addresses (relative to the VMA or to the LMA), 2988 depending on whether the section is mapped or not. */ 2989 2990 CORE_ADDR 2991 symbol_overlayed_address (CORE_ADDR address, asection *section) 2992 { 2993 if (overlay_debugging) 2994 { 2995 /* If the symbol has no section, just return its regular address. */ 2996 if (section == 0) 2997 return address; 2998 /* If the symbol's section is not an overlay, just return its address */ 2999 if (!section_is_overlay (section)) 3000 return address; 3001 /* If the symbol's section is mapped, just return its address */ 3002 if (section_is_mapped (section)) 3003 return address; 3004 /* 3005 * HOWEVER: if the symbol is in an overlay section which is NOT mapped, 3006 * then return its LOADED address rather than its vma address!! 3007 */ 3008 return overlay_unmapped_address (address, section); 3009 } 3010 return address; 3011 } 3012 3013 /* Function: find_pc_overlay (PC) 3014 Return the best-match overlay section for PC: 3015 If PC matches a mapped overlay section's VMA, return that section. 3016 Else if PC matches an unmapped section's VMA, return that section. 3017 Else if PC matches an unmapped section's LMA, return that section. */ 3018 3019 asection * 3020 find_pc_overlay (CORE_ADDR pc) 3021 { 3022 struct objfile *objfile; 3023 struct obj_section *osect, *best_match = NULL; 3024 3025 if (overlay_debugging) 3026 ALL_OBJSECTIONS (objfile, osect) 3027 if (section_is_overlay (osect->the_bfd_section)) 3028 { 3029 if (pc_in_mapped_range (pc, osect->the_bfd_section)) 3030 { 3031 if (overlay_is_mapped (osect)) 3032 return osect->the_bfd_section; 3033 else 3034 best_match = osect; 3035 } 3036 else if (pc_in_unmapped_range (pc, osect->the_bfd_section)) 3037 best_match = osect; 3038 } 3039 return best_match ? best_match->the_bfd_section : NULL; 3040 } 3041 3042 /* Function: find_pc_mapped_section (PC) 3043 If PC falls into the VMA address range of an overlay section that is 3044 currently marked as MAPPED, return that section. Else return NULL. */ 3045 3046 asection * 3047 find_pc_mapped_section (CORE_ADDR pc) 3048 { 3049 struct objfile *objfile; 3050 struct obj_section *osect; 3051 3052 if (overlay_debugging) 3053 ALL_OBJSECTIONS (objfile, osect) 3054 if (pc_in_mapped_range (pc, osect->the_bfd_section) && 3055 overlay_is_mapped (osect)) 3056 return osect->the_bfd_section; 3057 3058 return NULL; 3059 } 3060 3061 /* Function: list_overlays_command 3062 Print a list of mapped sections and their PC ranges */ 3063 3064 void 3065 list_overlays_command (char *args, int from_tty) 3066 { 3067 int nmapped = 0; 3068 struct objfile *objfile; 3069 struct obj_section *osect; 3070 3071 if (overlay_debugging) 3072 ALL_OBJSECTIONS (objfile, osect) 3073 if (overlay_is_mapped (osect)) 3074 { 3075 const char *name; 3076 bfd_vma lma, vma; 3077 int size; 3078 3079 vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section); 3080 lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section); 3081 size = bfd_get_section_size (osect->the_bfd_section); 3082 name = bfd_section_name (objfile->obfd, osect->the_bfd_section); 3083 3084 printf_filtered ("Section %s, loaded at ", name); 3085 print_address_numeric (lma, 1, gdb_stdout); 3086 puts_filtered (" - "); 3087 print_address_numeric (lma + size, 1, gdb_stdout); 3088 printf_filtered (", mapped at "); 3089 print_address_numeric (vma, 1, gdb_stdout); 3090 puts_filtered (" - "); 3091 print_address_numeric (vma + size, 1, gdb_stdout); 3092 puts_filtered ("\n"); 3093 3094 nmapped++; 3095 } 3096 if (nmapped == 0) 3097 printf_filtered ("No sections are mapped.\n"); 3098 } 3099 3100 /* Function: map_overlay_command 3101 Mark the named section as mapped (ie. residing at its VMA address). */ 3102 3103 void 3104 map_overlay_command (char *args, int from_tty) 3105 { 3106 struct objfile *objfile, *objfile2; 3107 struct obj_section *sec, *sec2; 3108 asection *bfdsec; 3109 3110 if (!overlay_debugging) 3111 error ("\ 3112 Overlay debugging not enabled. Use either the 'overlay auto' or\n\ 3113 the 'overlay manual' command."); 3114 3115 if (args == 0 || *args == 0) 3116 error ("Argument required: name of an overlay section"); 3117 3118 /* First, find a section matching the user supplied argument */ 3119 ALL_OBJSECTIONS (objfile, sec) 3120 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3121 { 3122 /* Now, check to see if the section is an overlay. */ 3123 bfdsec = sec->the_bfd_section; 3124 if (!section_is_overlay (bfdsec)) 3125 continue; /* not an overlay section */ 3126 3127 /* Mark the overlay as "mapped" */ 3128 sec->ovly_mapped = 1; 3129 3130 /* Next, make a pass and unmap any sections that are 3131 overlapped by this new section: */ 3132 ALL_OBJSECTIONS (objfile2, sec2) 3133 if (sec2->ovly_mapped 3134 && sec != sec2 3135 && sec->the_bfd_section != sec2->the_bfd_section 3136 && sections_overlap (sec->the_bfd_section, 3137 sec2->the_bfd_section)) 3138 { 3139 if (info_verbose) 3140 printf_unfiltered ("Note: section %s unmapped by overlap\n", 3141 bfd_section_name (objfile->obfd, 3142 sec2->the_bfd_section)); 3143 sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */ 3144 } 3145 return; 3146 } 3147 error ("No overlay section called %s", args); 3148 } 3149 3150 /* Function: unmap_overlay_command 3151 Mark the overlay section as unmapped 3152 (ie. resident in its LMA address range, rather than the VMA range). */ 3153 3154 void 3155 unmap_overlay_command (char *args, int from_tty) 3156 { 3157 struct objfile *objfile; 3158 struct obj_section *sec; 3159 3160 if (!overlay_debugging) 3161 error ("\ 3162 Overlay debugging not enabled. Use either the 'overlay auto' or\n\ 3163 the 'overlay manual' command."); 3164 3165 if (args == 0 || *args == 0) 3166 error ("Argument required: name of an overlay section"); 3167 3168 /* First, find a section matching the user supplied argument */ 3169 ALL_OBJSECTIONS (objfile, sec) 3170 if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args)) 3171 { 3172 if (!sec->ovly_mapped) 3173 error ("Section %s is not mapped", args); 3174 sec->ovly_mapped = 0; 3175 return; 3176 } 3177 error ("No overlay section called %s", args); 3178 } 3179 3180 /* Function: overlay_auto_command 3181 A utility command to turn on overlay debugging. 3182 Possibly this should be done via a set/show command. */ 3183 3184 static void 3185 overlay_auto_command (char *args, int from_tty) 3186 { 3187 overlay_debugging = ovly_auto; 3188 enable_overlay_breakpoints (); 3189 if (info_verbose) 3190 printf_unfiltered ("Automatic overlay debugging enabled."); 3191 } 3192 3193 /* Function: overlay_manual_command 3194 A utility command to turn on overlay debugging. 3195 Possibly this should be done via a set/show command. */ 3196 3197 static void 3198 overlay_manual_command (char *args, int from_tty) 3199 { 3200 overlay_debugging = ovly_on; 3201 disable_overlay_breakpoints (); 3202 if (info_verbose) 3203 printf_unfiltered ("Overlay debugging enabled."); 3204 } 3205 3206 /* Function: overlay_off_command 3207 A utility command to turn on overlay debugging. 3208 Possibly this should be done via a set/show command. */ 3209 3210 static void 3211 overlay_off_command (char *args, int from_tty) 3212 { 3213 overlay_debugging = ovly_off; 3214 disable_overlay_breakpoints (); 3215 if (info_verbose) 3216 printf_unfiltered ("Overlay debugging disabled."); 3217 } 3218 3219 static void 3220 overlay_load_command (char *args, int from_tty) 3221 { 3222 if (target_overlay_update) 3223 (*target_overlay_update) (NULL); 3224 else 3225 error ("This target does not know how to read its overlay state."); 3226 } 3227 3228 /* Function: overlay_command 3229 A place-holder for a mis-typed command */ 3230 3231 /* Command list chain containing all defined "overlay" subcommands. */ 3232 struct cmd_list_element *overlaylist; 3233 3234 static void 3235 overlay_command (char *args, int from_tty) 3236 { 3237 printf_unfiltered 3238 ("\"overlay\" must be followed by the name of an overlay command.\n"); 3239 help_list (overlaylist, "overlay ", -1, gdb_stdout); 3240 } 3241 3242 3243 /* Target Overlays for the "Simplest" overlay manager: 3244 3245 This is GDB's default target overlay layer. It works with the 3246 minimal overlay manager supplied as an example by Cygnus. The 3247 entry point is via a function pointer "target_overlay_update", 3248 so targets that use a different runtime overlay manager can 3249 substitute their own overlay_update function and take over the 3250 function pointer. 3251 3252 The overlay_update function pokes around in the target's data structures 3253 to see what overlays are mapped, and updates GDB's overlay mapping with 3254 this information. 3255 3256 In this simple implementation, the target data structures are as follows: 3257 unsigned _novlys; /# number of overlay sections #/ 3258 unsigned _ovly_table[_novlys][4] = { 3259 {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/ 3260 {..., ..., ..., ...}, 3261 } 3262 unsigned _novly_regions; /# number of overlay regions #/ 3263 unsigned _ovly_region_table[_novly_regions][3] = { 3264 {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/ 3265 {..., ..., ...}, 3266 } 3267 These functions will attempt to update GDB's mappedness state in the 3268 symbol section table, based on the target's mappedness state. 3269 3270 To do this, we keep a cached copy of the target's _ovly_table, and 3271 attempt to detect when the cached copy is invalidated. The main 3272 entry point is "simple_overlay_update(SECT), which looks up SECT in 3273 the cached table and re-reads only the entry for that section from 3274 the target (whenever possible). 3275 */ 3276 3277 /* Cached, dynamically allocated copies of the target data structures: */ 3278 static unsigned (*cache_ovly_table)[4] = 0; 3279 #if 0 3280 static unsigned (*cache_ovly_region_table)[3] = 0; 3281 #endif 3282 static unsigned cache_novlys = 0; 3283 #if 0 3284 static unsigned cache_novly_regions = 0; 3285 #endif 3286 static CORE_ADDR cache_ovly_table_base = 0; 3287 #if 0 3288 static CORE_ADDR cache_ovly_region_table_base = 0; 3289 #endif 3290 enum ovly_index 3291 { 3292 VMA, SIZE, LMA, MAPPED 3293 }; 3294 #define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT) 3295 3296 /* Throw away the cached copy of _ovly_table */ 3297 static void 3298 simple_free_overlay_table (void) 3299 { 3300 if (cache_ovly_table) 3301 xfree (cache_ovly_table); 3302 cache_novlys = 0; 3303 cache_ovly_table = NULL; 3304 cache_ovly_table_base = 0; 3305 } 3306 3307 #if 0 3308 /* Throw away the cached copy of _ovly_region_table */ 3309 static void 3310 simple_free_overlay_region_table (void) 3311 { 3312 if (cache_ovly_region_table) 3313 xfree (cache_ovly_region_table); 3314 cache_novly_regions = 0; 3315 cache_ovly_region_table = NULL; 3316 cache_ovly_region_table_base = 0; 3317 } 3318 #endif 3319 3320 /* Read an array of ints from the target into a local buffer. 3321 Convert to host order. int LEN is number of ints */ 3322 static void 3323 read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len) 3324 { 3325 /* FIXME (alloca): Not safe if array is very large. */ 3326 char *buf = alloca (len * TARGET_LONG_BYTES); 3327 int i; 3328 3329 read_memory (memaddr, buf, len * TARGET_LONG_BYTES); 3330 for (i = 0; i < len; i++) 3331 myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES * i + buf, 3332 TARGET_LONG_BYTES); 3333 } 3334 3335 /* Find and grab a copy of the target _ovly_table 3336 (and _novlys, which is needed for the table's size) */ 3337 static int 3338 simple_read_overlay_table (void) 3339 { 3340 struct minimal_symbol *novlys_msym, *ovly_table_msym; 3341 3342 simple_free_overlay_table (); 3343 novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL); 3344 if (! novlys_msym) 3345 { 3346 error ("Error reading inferior's overlay table: " 3347 "couldn't find `_novlys' variable\n" 3348 "in inferior. Use `overlay manual' mode."); 3349 return 0; 3350 } 3351 3352 ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL); 3353 if (! ovly_table_msym) 3354 { 3355 error ("Error reading inferior's overlay table: couldn't find " 3356 "`_ovly_table' array\n" 3357 "in inferior. Use `overlay manual' mode."); 3358 return 0; 3359 } 3360 3361 cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym), 4); 3362 cache_ovly_table 3363 = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table)); 3364 cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym); 3365 read_target_long_array (cache_ovly_table_base, 3366 (int *) cache_ovly_table, 3367 cache_novlys * 4); 3368 3369 return 1; /* SUCCESS */ 3370 } 3371 3372 #if 0 3373 /* Find and grab a copy of the target _ovly_region_table 3374 (and _novly_regions, which is needed for the table's size) */ 3375 static int 3376 simple_read_overlay_region_table (void) 3377 { 3378 struct minimal_symbol *msym; 3379 3380 simple_free_overlay_region_table (); 3381 msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL); 3382 if (msym != NULL) 3383 cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4); 3384 else 3385 return 0; /* failure */ 3386 cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12); 3387 if (cache_ovly_region_table != NULL) 3388 { 3389 msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL); 3390 if (msym != NULL) 3391 { 3392 cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym); 3393 read_target_long_array (cache_ovly_region_table_base, 3394 (int *) cache_ovly_region_table, 3395 cache_novly_regions * 3); 3396 } 3397 else 3398 return 0; /* failure */ 3399 } 3400 else 3401 return 0; /* failure */ 3402 return 1; /* SUCCESS */ 3403 } 3404 #endif 3405 3406 /* Function: simple_overlay_update_1 3407 A helper function for simple_overlay_update. Assuming a cached copy 3408 of _ovly_table exists, look through it to find an entry whose vma, 3409 lma and size match those of OSECT. Re-read the entry and make sure 3410 it still matches OSECT (else the table may no longer be valid). 3411 Set OSECT's mapped state to match the entry. Return: 1 for 3412 success, 0 for failure. */ 3413 3414 static int 3415 simple_overlay_update_1 (struct obj_section *osect) 3416 { 3417 int i, size; 3418 bfd *obfd = osect->objfile->obfd; 3419 asection *bsect = osect->the_bfd_section; 3420 3421 size = bfd_get_section_size (osect->the_bfd_section); 3422 for (i = 0; i < cache_novlys; i++) 3423 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3424 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3425 /* && cache_ovly_table[i][SIZE] == size */ ) 3426 { 3427 read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES, 3428 (int *) cache_ovly_table[i], 4); 3429 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3430 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3431 /* && cache_ovly_table[i][SIZE] == size */ ) 3432 { 3433 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3434 return 1; 3435 } 3436 else /* Warning! Warning! Target's ovly table has changed! */ 3437 return 0; 3438 } 3439 return 0; 3440 } 3441 3442 /* Function: simple_overlay_update 3443 If OSECT is NULL, then update all sections' mapped state 3444 (after re-reading the entire target _ovly_table). 3445 If OSECT is non-NULL, then try to find a matching entry in the 3446 cached ovly_table and update only OSECT's mapped state. 3447 If a cached entry can't be found or the cache isn't valid, then 3448 re-read the entire cache, and go ahead and update all sections. */ 3449 3450 static void 3451 simple_overlay_update (struct obj_section *osect) 3452 { 3453 struct objfile *objfile; 3454 3455 /* Were we given an osect to look up? NULL means do all of them. */ 3456 if (osect) 3457 /* Have we got a cached copy of the target's overlay table? */ 3458 if (cache_ovly_table != NULL) 3459 /* Does its cached location match what's currently in the symtab? */ 3460 if (cache_ovly_table_base == 3461 SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL))) 3462 /* Then go ahead and try to look up this single section in the cache */ 3463 if (simple_overlay_update_1 (osect)) 3464 /* Found it! We're done. */ 3465 return; 3466 3467 /* Cached table no good: need to read the entire table anew. 3468 Or else we want all the sections, in which case it's actually 3469 more efficient to read the whole table in one block anyway. */ 3470 3471 if (! simple_read_overlay_table ()) 3472 return; 3473 3474 /* Now may as well update all sections, even if only one was requested. */ 3475 ALL_OBJSECTIONS (objfile, osect) 3476 if (section_is_overlay (osect->the_bfd_section)) 3477 { 3478 int i, size; 3479 bfd *obfd = osect->objfile->obfd; 3480 asection *bsect = osect->the_bfd_section; 3481 3482 size = bfd_get_section_size (bsect); 3483 for (i = 0; i < cache_novlys; i++) 3484 if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect) 3485 && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect) 3486 /* && cache_ovly_table[i][SIZE] == size */ ) 3487 { /* obj_section matches i'th entry in ovly_table */ 3488 osect->ovly_mapped = cache_ovly_table[i][MAPPED]; 3489 break; /* finished with inner for loop: break out */ 3490 } 3491 } 3492 } 3493 3494 /* Set the output sections and output offsets for section SECTP in 3495 ABFD. The relocation code in BFD will read these offsets, so we 3496 need to be sure they're initialized. We map each section to itself, 3497 with no offset; this means that SECTP->vma will be honored. */ 3498 3499 static void 3500 symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy) 3501 { 3502 sectp->output_section = sectp; 3503 sectp->output_offset = 0; 3504 } 3505 3506 /* Relocate the contents of a debug section SECTP in ABFD. The 3507 contents are stored in BUF if it is non-NULL, or returned in a 3508 malloc'd buffer otherwise. 3509 3510 For some platforms and debug info formats, shared libraries contain 3511 relocations against the debug sections (particularly for DWARF-2; 3512 one affected platform is PowerPC GNU/Linux, although it depends on 3513 the version of the linker in use). Also, ELF object files naturally 3514 have unresolved relocations for their debug sections. We need to apply 3515 the relocations in order to get the locations of symbols correct. */ 3516 3517 bfd_byte * 3518 symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf) 3519 { 3520 /* We're only interested in debugging sections with relocation 3521 information. */ 3522 if ((sectp->flags & SEC_RELOC) == 0) 3523 return NULL; 3524 if ((sectp->flags & SEC_DEBUGGING) == 0) 3525 return NULL; 3526 3527 /* We will handle section offsets properly elsewhere, so relocate as if 3528 all sections begin at 0. */ 3529 bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL); 3530 3531 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); 3532 } 3533 3534 void 3535 _initialize_symfile (void) 3536 { 3537 struct cmd_list_element *c; 3538 3539 c = add_cmd ("symbol-file", class_files, symbol_file_command, 3540 "Load symbol table from executable file FILE.\n\ 3541 The `file' command can also load symbol tables, as well as setting the file\n\ 3542 to execute.", &cmdlist); 3543 set_cmd_completer (c, filename_completer); 3544 3545 c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, 3546 "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\ 3547 Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\ 3548 ADDR is the starting address of the file's text.\n\ 3549 The optional arguments are section-name section-address pairs and\n\ 3550 should be specified if the data and bss segments are not contiguous\n\ 3551 with the text. SECT is a section name to be loaded at SECT_ADDR.", 3552 &cmdlist); 3553 set_cmd_completer (c, filename_completer); 3554 3555 c = add_cmd ("add-shared-symbol-files", class_files, 3556 add_shared_symbol_files_command, 3557 "Load the symbols from shared objects in the dynamic linker's link map.", 3558 &cmdlist); 3559 c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1, 3560 &cmdlist); 3561 3562 c = add_cmd ("load", class_files, load_command, 3563 "Dynamically load FILE into the running program, and record its symbols\n\ 3564 for access from GDB.", &cmdlist); 3565 set_cmd_completer (c, filename_completer); 3566 3567 deprecated_add_show_from_set 3568 (add_set_cmd ("symbol-reloading", class_support, var_boolean, 3569 (char *) &symbol_reloading, 3570 "Set dynamic symbol table reloading multiple times in one run.", 3571 &setlist), 3572 &showlist); 3573 3574 add_prefix_cmd ("overlay", class_support, overlay_command, 3575 "Commands for debugging overlays.", &overlaylist, 3576 "overlay ", 0, &cmdlist); 3577 3578 add_com_alias ("ovly", "overlay", class_alias, 1); 3579 add_com_alias ("ov", "overlay", class_alias, 1); 3580 3581 add_cmd ("map-overlay", class_support, map_overlay_command, 3582 "Assert that an overlay section is mapped.", &overlaylist); 3583 3584 add_cmd ("unmap-overlay", class_support, unmap_overlay_command, 3585 "Assert that an overlay section is unmapped.", &overlaylist); 3586 3587 add_cmd ("list-overlays", class_support, list_overlays_command, 3588 "List mappings of overlay sections.", &overlaylist); 3589 3590 add_cmd ("manual", class_support, overlay_manual_command, 3591 "Enable overlay debugging.", &overlaylist); 3592 add_cmd ("off", class_support, overlay_off_command, 3593 "Disable overlay debugging.", &overlaylist); 3594 add_cmd ("auto", class_support, overlay_auto_command, 3595 "Enable automatic overlay debugging.", &overlaylist); 3596 add_cmd ("load-target", class_support, overlay_load_command, 3597 "Read the overlay mapping state from the target.", &overlaylist); 3598 3599 /* Filename extension to source language lookup table: */ 3600 init_filename_language_table (); 3601 c = add_set_cmd ("extension-language", class_files, var_string_noescape, 3602 (char *) &ext_args, 3603 "Set mapping between filename extension and source language.\n\ 3604 Usage: set extension-language .foo bar", 3605 &setlist); 3606 set_cmd_cfunc (c, set_ext_lang_command); 3607 3608 add_info ("extensions", info_ext_lang_command, 3609 "All filename extensions associated with a source language."); 3610 3611 deprecated_add_show_from_set 3612 (add_set_cmd ("download-write-size", class_obscure, 3613 var_integer, (char *) &download_write_size, 3614 "Set the write size used when downloading a program.\n" 3615 "Only used when downloading a program onto a remote\n" 3616 "target. Specify zero, or a negative value, to disable\n" 3617 "blocked writes. The actual size of each transfer is also\n" 3618 "limited by the size of the target packet and the memory\n" 3619 "cache.\n", 3620 &setlist), 3621 &showlist); 3622 3623 debug_file_directory = xstrdup (DEBUGDIR); 3624 c = (add_set_cmd 3625 ("debug-file-directory", class_support, var_string, 3626 (char *) &debug_file_directory, 3627 "Set the directory where separate debug symbols are searched for.\n" 3628 "Separate debug symbols are first searched for in the same\n" 3629 "directory as the binary, then in the `" DEBUG_SUBDIRECTORY 3630 "' subdirectory,\n" 3631 "and lastly at the path of the directory of the binary with\n" 3632 "the global debug-file directory prepended\n", 3633 &setlist)); 3634 deprecated_add_show_from_set (c, &showlist); 3635 set_cmd_completer (c, filename_completer); 3636 } 3637