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