1 /* Work with executable files, for GDB. 2 3 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 4 1998, 1999, 2000, 2001, 2002, 2003, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "frame.h" 24 #include "inferior.h" 25 #include "target.h" 26 #include "gdbcmd.h" 27 #include "language.h" 28 #include "filenames.h" 29 #include "symfile.h" 30 #include "objfiles.h" 31 #include "completer.h" 32 #include "value.h" 33 #include "exec.h" 34 #include "observer.h" 35 #include "arch-utils.h" 36 #include "gdbthread.h" 37 #include "progspace.h" 38 39 #include <fcntl.h> 40 #include "readline/readline.h" 41 #include "gdb_string.h" 42 43 #include "gdbcore.h" 44 45 #include <ctype.h> 46 #include "gdb_stat.h" 47 48 #include "xcoffsolib.h" 49 50 struct vmap *map_vmap (bfd *, bfd *); 51 52 void (*deprecated_file_changed_hook) (char *); 53 54 /* Prototypes for local functions */ 55 56 static void file_command (char *, int); 57 58 static void set_section_command (char *, int); 59 60 static void exec_files_info (struct target_ops *); 61 62 static void init_exec_ops (void); 63 64 void _initialize_exec (void); 65 66 /* The target vector for executable files. */ 67 68 struct target_ops exec_ops; 69 70 /* True if the exec target is pushed on the stack. */ 71 static int using_exec_ops; 72 73 /* Whether to open exec and core files read-only or read-write. */ 74 75 int write_files = 0; 76 static void 77 show_write_files (struct ui_file *file, int from_tty, 78 struct cmd_list_element *c, const char *value) 79 { 80 fprintf_filtered (file, _("Writing into executable and core files is %s.\n"), 81 value); 82 } 83 84 85 struct vmap *vmap; 86 87 static void 88 exec_open (char *args, int from_tty) 89 { 90 target_preopen (from_tty); 91 exec_file_attach (args, from_tty); 92 } 93 94 /* Close and clear exec_bfd. If we end up with no target sections to 95 read memory from, this unpushes the exec_ops target. */ 96 97 void 98 exec_close (void) 99 { 100 if (exec_bfd) 101 { 102 bfd *abfd = exec_bfd; 103 char *name = bfd_get_filename (abfd); 104 105 gdb_bfd_close_or_warn (abfd); 106 xfree (name); 107 108 /* Removing target sections may close the exec_ops target. 109 Clear exec_bfd before doing so to prevent recursion. */ 110 exec_bfd = NULL; 111 exec_bfd_mtime = 0; 112 113 remove_target_sections (abfd); 114 } 115 } 116 117 /* This is the target_close implementation. Clears all target 118 sections and closes all executable bfds from all program spaces. */ 119 120 static void 121 exec_close_1 (int quitting) 122 { 123 int need_symtab_cleanup = 0; 124 struct vmap *vp, *nxt; 125 126 using_exec_ops = 0; 127 128 for (nxt = vmap; nxt != NULL;) 129 { 130 vp = nxt; 131 nxt = vp->nxt; 132 133 /* if there is an objfile associated with this bfd, 134 free_objfile() will do proper cleanup of objfile *and* bfd. */ 135 136 if (vp->objfile) 137 { 138 free_objfile (vp->objfile); 139 need_symtab_cleanup = 1; 140 } 141 else if (vp->bfd != exec_bfd) 142 /* FIXME-leak: We should be freeing vp->name too, I think. */ 143 gdb_bfd_close_or_warn (vp->bfd); 144 145 xfree (vp); 146 } 147 148 vmap = NULL; 149 150 { 151 struct program_space *ss; 152 struct cleanup *old_chain; 153 154 old_chain = save_current_program_space (); 155 ALL_PSPACES (ss) 156 { 157 set_current_program_space (ss); 158 159 /* Delete all target sections. */ 160 resize_section_table 161 (current_target_sections, 162 -resize_section_table (current_target_sections, 0)); 163 164 exec_close (); 165 } 166 167 do_cleanups (old_chain); 168 } 169 } 170 171 void 172 exec_file_clear (int from_tty) 173 { 174 /* Remove exec file. */ 175 exec_close (); 176 177 if (from_tty) 178 printf_unfiltered (_("No executable file now.\n")); 179 } 180 181 /* Set FILENAME as the new exec file. 182 183 This function is intended to be behave essentially the same 184 as exec_file_command, except that the latter will detect when 185 a target is being debugged, and will ask the user whether it 186 should be shut down first. (If the answer is "no", then the 187 new file is ignored.) 188 189 This file is used by exec_file_command, to do the work of opening 190 and processing the exec file after any prompting has happened. 191 192 And, it is used by child_attach, when the attach command was 193 given a pid but not a exec pathname, and the attach command could 194 figure out the pathname from the pid. (In this case, we shouldn't 195 ask the user whether the current target should be shut down -- 196 we're supplying the exec pathname late for good reason.) */ 197 198 void 199 exec_file_attach (char *filename, int from_tty) 200 { 201 /* Remove any previous exec file. */ 202 exec_close (); 203 204 /* Now open and digest the file the user requested, if any. */ 205 206 if (!filename) 207 { 208 if (from_tty) 209 printf_unfiltered (_("No executable file now.\n")); 210 211 set_gdbarch_from_file (NULL); 212 } 213 else 214 { 215 struct cleanup *cleanups; 216 char *scratch_pathname; 217 int scratch_chan; 218 struct target_section *sections = NULL, *sections_end = NULL; 219 char **matching; 220 221 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename, 222 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 223 &scratch_pathname); 224 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__) 225 if (scratch_chan < 0) 226 { 227 char *exename = alloca (strlen (filename) + 5); 228 229 strcat (strcpy (exename, filename), ".exe"); 230 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename, 231 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 232 &scratch_pathname); 233 } 234 #endif 235 if (scratch_chan < 0) 236 perror_with_name (filename); 237 exec_bfd = bfd_fopen (scratch_pathname, gnutarget, 238 write_files ? FOPEN_RUB : FOPEN_RB, 239 scratch_chan); 240 241 if (!exec_bfd) 242 { 243 close (scratch_chan); 244 error (_("\"%s\": could not open as an executable file: %s"), 245 scratch_pathname, bfd_errmsg (bfd_get_error ())); 246 } 247 248 /* At this point, scratch_pathname and exec_bfd->name both point to the 249 same malloc'd string. However exec_close() will attempt to free it 250 via the exec_bfd->name pointer, so we need to make another copy and 251 leave exec_bfd as the new owner of the original copy. */ 252 scratch_pathname = xstrdup (scratch_pathname); 253 cleanups = make_cleanup (xfree, scratch_pathname); 254 255 if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching)) 256 { 257 /* Make sure to close exec_bfd, or else "run" might try to use 258 it. */ 259 exec_close (); 260 error (_("\"%s\": not in executable format: %s"), 261 scratch_pathname, 262 gdb_bfd_errmsg (bfd_get_error (), matching)); 263 } 264 265 /* FIXME - This should only be run for RS6000, but the ifdef is a poor 266 way to accomplish. */ 267 #ifdef DEPRECATED_IBM6000_TARGET 268 /* Setup initial vmap. */ 269 270 map_vmap (exec_bfd, 0); 271 if (vmap == NULL) 272 { 273 /* Make sure to close exec_bfd, or else "run" might try to use 274 it. */ 275 exec_close (); 276 error (_("\"%s\": can't find the file sections: %s"), 277 scratch_pathname, bfd_errmsg (bfd_get_error ())); 278 } 279 #endif /* DEPRECATED_IBM6000_TARGET */ 280 281 if (build_section_table (exec_bfd, §ions, §ions_end)) 282 { 283 /* Make sure to close exec_bfd, or else "run" might try to use 284 it. */ 285 exec_close (); 286 error (_("\"%s\": can't find the file sections: %s"), 287 scratch_pathname, bfd_errmsg (bfd_get_error ())); 288 } 289 290 exec_bfd_mtime = bfd_get_mtime (exec_bfd); 291 292 validate_files (); 293 294 set_gdbarch_from_file (exec_bfd); 295 296 /* Add the executable's sections to the current address spaces' 297 list of sections. This possibly pushes the exec_ops 298 target. */ 299 add_target_sections (sections, sections_end); 300 xfree (sections); 301 302 /* Tell display code (if any) about the changed file name. */ 303 if (deprecated_exec_file_display_hook) 304 (*deprecated_exec_file_display_hook) (filename); 305 306 do_cleanups (cleanups); 307 } 308 bfd_cache_close_all (); 309 observer_notify_executable_changed (); 310 } 311 312 /* Process the first arg in ARGS as the new exec file. 313 314 Note that we have to explicitly ignore additional args, since we can 315 be called from file_command(), which also calls symbol_file_command() 316 which can take multiple args. 317 318 If ARGS is NULL, we just want to close the exec file. */ 319 320 static void 321 exec_file_command (char *args, int from_tty) 322 { 323 char **argv; 324 char *filename; 325 326 if (from_tty && target_has_execution 327 && !query (_("A program is being debugged already.\n" 328 "Are you sure you want to change the file? "))) 329 error (_("File not changed.")); 330 331 if (args) 332 { 333 struct cleanup *cleanups; 334 335 /* Scan through the args and pick up the first non option arg 336 as the filename. */ 337 338 argv = gdb_buildargv (args); 339 cleanups = make_cleanup_freeargv (argv); 340 341 for (; (*argv != NULL) && (**argv == '-'); argv++) 342 {; 343 } 344 if (*argv == NULL) 345 error (_("No executable file name was specified")); 346 347 filename = tilde_expand (*argv); 348 make_cleanup (xfree, filename); 349 exec_file_attach (filename, from_tty); 350 351 do_cleanups (cleanups); 352 } 353 else 354 exec_file_attach (NULL, from_tty); 355 } 356 357 /* Set both the exec file and the symbol file, in one command. 358 What a novelty. Why did GDB go through four major releases before this 359 command was added? */ 360 361 static void 362 file_command (char *arg, int from_tty) 363 { 364 /* FIXME, if we lose on reading the symbol file, we should revert 365 the exec file, but that's rough. */ 366 exec_file_command (arg, from_tty); 367 symbol_file_command (arg, from_tty); 368 if (deprecated_file_changed_hook) 369 deprecated_file_changed_hook (arg); 370 } 371 372 373 /* Locate all mappable sections of a BFD file. 374 table_pp_char is a char * to get it through bfd_map_over_sections; 375 we cast it back to its proper type. */ 376 377 static void 378 add_to_section_table (bfd *abfd, struct bfd_section *asect, 379 void *table_pp_char) 380 { 381 struct target_section **table_pp = (struct target_section **) table_pp_char; 382 flagword aflag; 383 384 /* Check the section flags, but do not discard zero-length sections, since 385 some symbols may still be attached to this section. For instance, we 386 encountered on sparc-solaris 2.10 a shared library with an empty .bss 387 section to which a symbol named "_end" was attached. The address 388 of this symbol still needs to be relocated. */ 389 aflag = bfd_get_section_flags (abfd, asect); 390 if (!(aflag & SEC_ALLOC)) 391 return; 392 393 (*table_pp)->bfd = abfd; 394 (*table_pp)->the_bfd_section = asect; 395 (*table_pp)->addr = bfd_section_vma (abfd, asect); 396 (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect); 397 (*table_pp)++; 398 } 399 400 int 401 resize_section_table (struct target_section_table *table, int num_added) 402 { 403 int old_count; 404 int new_count; 405 406 old_count = table->sections_end - table->sections; 407 408 if (!num_added) 409 return old_count; 410 411 new_count = num_added + old_count; 412 413 if (new_count) 414 { 415 table->sections = xrealloc (table->sections, 416 sizeof (struct target_section) * new_count); 417 table->sections_end = table->sections + new_count; 418 } 419 else 420 { 421 xfree (table->sections); 422 table->sections = table->sections_end = NULL; 423 } 424 425 return old_count; 426 } 427 428 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR. 429 Returns 0 if OK, 1 on error. */ 430 431 int 432 build_section_table (struct bfd *some_bfd, struct target_section **start, 433 struct target_section **end) 434 { 435 unsigned count; 436 437 count = bfd_count_sections (some_bfd); 438 if (*start) 439 xfree (* start); 440 *start = (struct target_section *) xmalloc (count * sizeof (**start)); 441 *end = *start; 442 bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end); 443 if (*end > *start + count) 444 internal_error (__FILE__, __LINE__, 445 _("failed internal consistency check")); 446 /* We could realloc the table, but it probably loses for most files. */ 447 return 0; 448 } 449 450 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the 451 current set of target sections. */ 452 453 void 454 add_target_sections (struct target_section *sections, 455 struct target_section *sections_end) 456 { 457 int count; 458 struct target_section_table *table = current_target_sections; 459 460 count = sections_end - sections; 461 462 if (count > 0) 463 { 464 int space = resize_section_table (table, count); 465 466 memcpy (table->sections + space, 467 sections, count * sizeof (sections[0])); 468 469 /* If these are the first file sections we can provide memory 470 from, push the file_stratum target. */ 471 if (!using_exec_ops) 472 { 473 using_exec_ops = 1; 474 push_target (&exec_ops); 475 } 476 } 477 } 478 479 /* Remove all target sections taken from ABFD. */ 480 481 void 482 remove_target_sections (bfd *abfd) 483 { 484 struct target_section *src, *dest; 485 struct target_section_table *table = current_target_sections; 486 487 dest = table->sections; 488 for (src = table->sections; src < table->sections_end; src++) 489 if (src->bfd != abfd) 490 { 491 /* Keep this section. */ 492 if (dest < src) 493 *dest = *src; 494 dest++; 495 } 496 497 /* If we've dropped any sections, resize the section table. */ 498 if (dest < src) 499 { 500 int old_count; 501 502 old_count = resize_section_table (table, dest - src); 503 504 /* If we don't have any more sections to read memory from, 505 remove the file_stratum target from the stack. */ 506 if (old_count + (dest - src) == 0) 507 { 508 struct program_space *pspace; 509 510 ALL_PSPACES (pspace) 511 if (pspace->target_sections.sections 512 != pspace->target_sections.sections_end) 513 return; 514 515 unpush_target (&exec_ops); 516 } 517 } 518 } 519 520 521 static void 522 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3) 523 { 524 struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3; 525 struct vmap *vp; 526 527 vp = vmap_bfd->pvmap; 528 529 if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0) 530 return; 531 532 if (strcmp (bfd_section_name (abfd, sect), ".text") == 0) 533 { 534 vp->tstart = bfd_section_vma (abfd, sect); 535 vp->tend = vp->tstart + bfd_section_size (abfd, sect); 536 vp->tvma = bfd_section_vma (abfd, sect); 537 vp->toffs = sect->filepos; 538 } 539 else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0) 540 { 541 vp->dstart = bfd_section_vma (abfd, sect); 542 vp->dend = vp->dstart + bfd_section_size (abfd, sect); 543 vp->dvma = bfd_section_vma (abfd, sect); 544 } 545 /* Silently ignore other types of sections. (FIXME?) */ 546 } 547 548 /* Make a vmap for ABFD which might be a member of the archive ARCH. 549 Return the new vmap. */ 550 551 struct vmap * 552 map_vmap (bfd *abfd, bfd *arch) 553 { 554 struct vmap_and_bfd vmap_bfd; 555 struct vmap *vp, **vpp; 556 557 vp = (struct vmap *) xmalloc (sizeof (*vp)); 558 memset ((char *) vp, '\0', sizeof (*vp)); 559 vp->nxt = 0; 560 vp->bfd = abfd; 561 vp->name = bfd_get_filename (arch ? arch : abfd); 562 vp->member = arch ? bfd_get_filename (abfd) : ""; 563 564 vmap_bfd.pbfd = arch; 565 vmap_bfd.pvmap = vp; 566 bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd); 567 568 /* Find the end of the list and append. */ 569 for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt) 570 ; 571 *vpp = vp; 572 573 return vp; 574 } 575 576 577 VEC(mem_range_s) * 578 section_table_available_memory (VEC(mem_range_s) *memory, 579 CORE_ADDR memaddr, ULONGEST len, 580 struct target_section *sections, 581 struct target_section *sections_end) 582 { 583 struct target_section *p; 584 585 for (p = sections; p < sections_end; p++) 586 { 587 if ((bfd_get_section_flags (p->bfd, p->the_bfd_section) 588 & SEC_READONLY) == 0) 589 continue; 590 591 /* Copy the meta-data, adjusted. */ 592 if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len)) 593 { 594 ULONGEST lo1, hi1, lo2, hi2; 595 struct mem_range *r; 596 597 lo1 = memaddr; 598 hi1 = memaddr + len; 599 600 lo2 = p->addr; 601 hi2 = p->endaddr; 602 603 r = VEC_safe_push (mem_range_s, memory, NULL); 604 605 r->start = max (lo1, lo2); 606 r->length = min (hi1, hi2) - r->start; 607 } 608 } 609 610 return memory; 611 } 612 613 int 614 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf, 615 ULONGEST offset, LONGEST len, 616 struct target_section *sections, 617 struct target_section *sections_end, 618 const char *section_name) 619 { 620 int res; 621 struct target_section *p; 622 ULONGEST memaddr = offset; 623 ULONGEST memend = memaddr + len; 624 625 if (len <= 0) 626 internal_error (__FILE__, __LINE__, 627 _("failed internal consistency check")); 628 629 for (p = sections; p < sections_end; p++) 630 { 631 if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0) 632 continue; /* not the section we need. */ 633 if (memaddr >= p->addr) 634 { 635 if (memend <= p->endaddr) 636 { 637 /* Entire transfer is within this section. */ 638 if (writebuf) 639 res = bfd_set_section_contents (p->bfd, p->the_bfd_section, 640 writebuf, memaddr - p->addr, 641 len); 642 else 643 res = bfd_get_section_contents (p->bfd, p->the_bfd_section, 644 readbuf, memaddr - p->addr, 645 len); 646 return (res != 0) ? len : 0; 647 } 648 else if (memaddr >= p->endaddr) 649 { 650 /* This section ends before the transfer starts. */ 651 continue; 652 } 653 else 654 { 655 /* This section overlaps the transfer. Just do half. */ 656 len = p->endaddr - memaddr; 657 if (writebuf) 658 res = bfd_set_section_contents (p->bfd, p->the_bfd_section, 659 writebuf, memaddr - p->addr, 660 len); 661 else 662 res = bfd_get_section_contents (p->bfd, p->the_bfd_section, 663 readbuf, memaddr - p->addr, 664 len); 665 return (res != 0) ? len : 0; 666 } 667 } 668 } 669 670 return 0; /* We can't help. */ 671 } 672 673 struct target_section_table * 674 exec_get_section_table (struct target_ops *ops) 675 { 676 return current_target_sections; 677 } 678 679 static LONGEST 680 exec_xfer_partial (struct target_ops *ops, enum target_object object, 681 const char *annex, gdb_byte *readbuf, 682 const gdb_byte *writebuf, 683 ULONGEST offset, LONGEST len) 684 { 685 struct target_section_table *table = target_get_section_table (ops); 686 687 if (object == TARGET_OBJECT_MEMORY) 688 return section_table_xfer_memory_partial (readbuf, writebuf, 689 offset, len, 690 table->sections, 691 table->sections_end, 692 NULL); 693 else 694 return -1; 695 } 696 697 698 void 699 print_section_info (struct target_section_table *t, bfd *abfd) 700 { 701 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd); 702 struct target_section *p; 703 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */ 704 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16; 705 706 printf_filtered ("\t`%s', ", bfd_get_filename (abfd)); 707 wrap_here (" "); 708 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd)); 709 if (abfd == exec_bfd) 710 { 711 /* gcc-3.4 does not like the initialization in 712 <p == t->sections_end>. */ 713 bfd_vma displacement = 0; 714 bfd_vma entry_point; 715 716 for (p = t->sections; p < t->sections_end; p++) 717 { 718 asection *asect = p->the_bfd_section; 719 720 if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD)) 721 != (SEC_ALLOC | SEC_LOAD)) 722 continue; 723 724 if (bfd_get_section_vma (abfd, asect) <= abfd->start_address 725 && abfd->start_address < (bfd_get_section_vma (abfd, asect) 726 + bfd_get_section_size (asect))) 727 { 728 displacement = p->addr - bfd_get_section_vma (abfd, asect); 729 break; 730 } 731 } 732 if (p == t->sections_end) 733 warning (_("Cannot find section for the entry point of %s."), 734 bfd_get_filename (abfd)); 735 736 entry_point = gdbarch_addr_bits_remove (gdbarch, 737 bfd_get_start_address (abfd) 738 + displacement); 739 printf_filtered (_("\tEntry point: %s\n"), 740 paddress (gdbarch, entry_point)); 741 } 742 for (p = t->sections; p < t->sections_end; p++) 743 { 744 printf_filtered ("\t%s", hex_string_custom (p->addr, wid)); 745 printf_filtered (" - %s", hex_string_custom (p->endaddr, wid)); 746 747 /* FIXME: A format of "08l" is not wide enough for file offsets 748 larger than 4GB. OTOH, making it "016l" isn't desirable either 749 since most output will then be much wider than necessary. It 750 may make sense to test the size of the file and choose the 751 format string accordingly. */ 752 /* FIXME: i18n: Need to rewrite this sentence. */ 753 if (info_verbose) 754 printf_filtered (" @ %s", 755 hex_string_custom (p->the_bfd_section->filepos, 8)); 756 printf_filtered (" is %s", bfd_section_name (p->bfd, 757 p->the_bfd_section)); 758 if (p->bfd != abfd) 759 printf_filtered (" in %s", bfd_get_filename (p->bfd)); 760 printf_filtered ("\n"); 761 } 762 } 763 764 static void 765 exec_files_info (struct target_ops *t) 766 { 767 print_section_info (current_target_sections, exec_bfd); 768 769 if (vmap) 770 { 771 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8; 772 struct vmap *vp; 773 774 printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name); 775 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n", 776 addr_size * 2, "tstart", 777 addr_size * 2, "tend", 778 addr_size * 2, "dstart", 779 addr_size * 2, "dend", 780 "section", 781 "file(member)"); 782 783 for (vp = vmap; vp; vp = vp->nxt) 784 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n", 785 phex (vp->tstart, addr_size), 786 phex (vp->tend, addr_size), 787 phex (vp->dstart, addr_size), 788 phex (vp->dend, addr_size), 789 vp->name, 790 *vp->member ? "(" : "", vp->member, 791 *vp->member ? ")" : ""); 792 } 793 } 794 795 static void 796 set_section_command (char *args, int from_tty) 797 { 798 struct target_section *p; 799 char *secname; 800 unsigned seclen; 801 unsigned long secaddr; 802 char secprint[100]; 803 long offset; 804 struct target_section_table *table; 805 806 if (args == 0) 807 error (_("Must specify section name and its virtual address")); 808 809 /* Parse out section name. */ 810 for (secname = args; !isspace (*args); args++); 811 seclen = args - secname; 812 813 /* Parse out new virtual address. */ 814 secaddr = parse_and_eval_address (args); 815 816 table = current_target_sections; 817 for (p = table->sections; p < table->sections_end; p++) 818 { 819 if (!strncmp (secname, bfd_section_name (exec_bfd, 820 p->the_bfd_section), seclen) 821 && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0') 822 { 823 offset = secaddr - p->addr; 824 p->addr += offset; 825 p->endaddr += offset; 826 if (from_tty) 827 exec_files_info (&exec_ops); 828 return; 829 } 830 } 831 if (seclen >= sizeof (secprint)) 832 seclen = sizeof (secprint) - 1; 833 strncpy (secprint, secname, seclen); 834 secprint[seclen] = '\0'; 835 error (_("Section %s not found"), secprint); 836 } 837 838 /* If we can find a section in FILENAME with BFD index INDEX, adjust 839 it to ADDRESS. */ 840 841 void 842 exec_set_section_address (const char *filename, int index, CORE_ADDR address) 843 { 844 struct target_section *p; 845 struct target_section_table *table; 846 847 table = current_target_sections; 848 for (p = table->sections; p < table->sections_end; p++) 849 { 850 if (filename_cmp (filename, p->bfd->filename) == 0 851 && index == p->the_bfd_section->index) 852 { 853 p->endaddr += address - p->addr; 854 p->addr = address; 855 } 856 } 857 } 858 859 /* If mourn is being called in all the right places, this could be say 860 `gdb internal error' (since generic_mourn calls 861 breakpoint_init_inferior). */ 862 863 static int 864 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) 865 { 866 return 0; 867 } 868 869 static int 870 exec_has_memory (struct target_ops *ops) 871 { 872 /* We can provide memory if we have any file/target sections to read 873 from. */ 874 return (current_target_sections->sections 875 != current_target_sections->sections_end); 876 } 877 878 /* Find mapped memory. */ 879 880 extern void 881 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *)) 882 { 883 exec_ops.to_find_memory_regions = func; 884 } 885 886 static char *exec_make_note_section (bfd *, int *); 887 888 /* Fill in the exec file target vector. Very few entries need to be 889 defined. */ 890 891 static void 892 init_exec_ops (void) 893 { 894 exec_ops.to_shortname = "exec"; 895 exec_ops.to_longname = "Local exec file"; 896 exec_ops.to_doc = "Use an executable file as a target.\n\ 897 Specify the filename of the executable file."; 898 exec_ops.to_open = exec_open; 899 exec_ops.to_close = exec_close_1; 900 exec_ops.to_attach = find_default_attach; 901 exec_ops.to_xfer_partial = exec_xfer_partial; 902 exec_ops.to_get_section_table = exec_get_section_table; 903 exec_ops.to_files_info = exec_files_info; 904 exec_ops.to_insert_breakpoint = ignore; 905 exec_ops.to_remove_breakpoint = ignore; 906 exec_ops.to_create_inferior = find_default_create_inferior; 907 exec_ops.to_stratum = file_stratum; 908 exec_ops.to_has_memory = exec_has_memory; 909 exec_ops.to_make_corefile_notes = exec_make_note_section; 910 exec_ops.to_magic = OPS_MAGIC; 911 } 912 913 void 914 _initialize_exec (void) 915 { 916 struct cmd_list_element *c; 917 918 init_exec_ops (); 919 920 if (!dbx_commands) 921 { 922 c = add_cmd ("file", class_files, file_command, _("\ 923 Use FILE as program to be debugged.\n\ 924 It is read for its symbols, for getting the contents of pure memory,\n\ 925 and it is the program executed when you use the `run' command.\n\ 926 If FILE cannot be found as specified, your execution directory path\n\ 927 ($PATH) is searched for a command of that name.\n\ 928 No arg means to have no executable file and no symbols."), &cmdlist); 929 set_cmd_completer (c, filename_completer); 930 } 931 932 c = add_cmd ("exec-file", class_files, exec_file_command, _("\ 933 Use FILE as program for getting contents of pure memory.\n\ 934 If FILE cannot be found as specified, your execution directory path\n\ 935 is searched for a command of that name.\n\ 936 No arg means have no executable file."), &cmdlist); 937 set_cmd_completer (c, filename_completer); 938 939 add_com ("section", class_files, set_section_command, _("\ 940 Change the base address of section SECTION of the exec file to ADDR.\n\ 941 This can be used if the exec file does not contain section addresses,\n\ 942 (such as in the a.out format), or when the addresses specified in the\n\ 943 file itself are wrong. Each section must be changed separately. The\n\ 944 ``info files'' command lists all the sections and their addresses.")); 945 946 add_setshow_boolean_cmd ("write", class_support, &write_files, _("\ 947 Set writing into executable and core files."), _("\ 948 Show writing into executable and core files."), NULL, 949 NULL, 950 show_write_files, 951 &setlist, &showlist); 952 953 add_target (&exec_ops); 954 } 955 956 static char * 957 exec_make_note_section (bfd *obfd, int *note_size) 958 { 959 error (_("Can't create a corefile")); 960 } 961