1/* Work with executable files, for GDB. 2 3 Copyright (C) 1988-2020 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 "observable.h" 33#include "arch-utils.h" 34#include "gdbthread.h" 35#include "progspace.h" 36#include "progspace-and-thread.h" 37#include "gdb_bfd.h" 38#include "gcore.h" 39#include "source.h" 40#include "build-id.h" 41 42#include <fcntl.h> 43#include "readline/tilde.h" 44#include "gdbcore.h" 45 46#include <ctype.h> 47#include <sys/stat.h> 48#include "solist.h" 49#include <algorithm> 50#include "gdbsupport/pathstuff.h" 51#include "cli/cli-style.h" 52 53void (*deprecated_file_changed_hook) (const char *); 54 55static const target_info exec_target_info = { 56 "exec", 57 N_("Local exec file"), 58 N_("Use an executable file as a target.\n\ 59Specify the filename of the executable file.") 60}; 61 62/* The target vector for executable files. */ 63 64struct exec_target final : public target_ops 65{ 66 const target_info &info () const override 67 { return exec_target_info; } 68 69 strata stratum () const override { return file_stratum; } 70 71 void close () override; 72 enum target_xfer_status xfer_partial (enum target_object object, 73 const char *annex, 74 gdb_byte *readbuf, 75 const gdb_byte *writebuf, 76 ULONGEST offset, ULONGEST len, 77 ULONGEST *xfered_len) override; 78 struct target_section_table *get_section_table () override; 79 void files_info () override; 80 81 bool has_memory () override; 82 char *make_corefile_notes (bfd *, int *) override; 83 int find_memory_regions (find_memory_region_ftype func, void *data) override; 84}; 85 86static exec_target exec_ops; 87 88/* How to handle a mismatch between the current exec file and the exec 89 file determined from target. */ 90 91static const char *const exec_file_mismatch_names[] 92 = {"ask", "warn", "off", NULL }; 93enum exec_file_mismatch_mode 94 { 95 exec_file_mismatch_ask, exec_file_mismatch_warn, exec_file_mismatch_off 96 }; 97static const char *exec_file_mismatch = exec_file_mismatch_names[0]; 98static enum exec_file_mismatch_mode exec_file_mismatch_mode 99 = exec_file_mismatch_ask; 100 101/* Show command. */ 102static void 103show_exec_file_mismatch_command (struct ui_file *file, int from_tty, 104 struct cmd_list_element *c, const char *value) 105{ 106 fprintf_filtered (gdb_stdout, 107 _("exec-file-mismatch handling is currently \"%s\".\n"), 108 exec_file_mismatch_names[exec_file_mismatch_mode]); 109} 110 111/* Set command. Change the setting for range checking. */ 112static void 113set_exec_file_mismatch_command (const char *ignore, 114 int from_tty, struct cmd_list_element *c) 115{ 116 for (enum exec_file_mismatch_mode mode = exec_file_mismatch_ask; 117 ; 118 mode = static_cast<enum exec_file_mismatch_mode>(1 + (int) mode)) 119 { 120 if (strcmp (exec_file_mismatch, exec_file_mismatch_names[mode]) == 0) 121 { 122 exec_file_mismatch_mode = mode; 123 return; 124 } 125 if (mode == exec_file_mismatch_off) 126 internal_error (__FILE__, __LINE__, 127 _("Unrecognized exec-file-mismatch setting: \"%s\""), 128 exec_file_mismatch); 129 } 130} 131 132/* Whether to open exec and core files read-only or read-write. */ 133 134bool write_files = false; 135static void 136show_write_files (struct ui_file *file, int from_tty, 137 struct cmd_list_element *c, const char *value) 138{ 139 fprintf_filtered (file, _("Writing into executable and core files is %s.\n"), 140 value); 141} 142 143 144static void 145exec_target_open (const char *args, int from_tty) 146{ 147 target_preopen (from_tty); 148 exec_file_attach (args, from_tty); 149} 150 151/* Close and clear exec_bfd. If we end up with no target sections to 152 read memory from, this unpushes the exec_ops target. */ 153 154void 155exec_close (void) 156{ 157 if (exec_bfd) 158 { 159 bfd *abfd = exec_bfd; 160 161 gdb_bfd_unref (abfd); 162 163 /* Removing target sections may close the exec_ops target. 164 Clear exec_bfd before doing so to prevent recursion. */ 165 exec_bfd = NULL; 166 exec_bfd_mtime = 0; 167 168 remove_target_sections (&exec_bfd); 169 170 xfree (exec_filename); 171 exec_filename = NULL; 172 } 173} 174 175/* This is the target_close implementation. Clears all target 176 sections and closes all executable bfds from all program spaces. */ 177 178void 179exec_target::close () 180{ 181 scoped_restore_current_program_space restore_pspace; 182 183 for (struct program_space *ss : program_spaces) 184 { 185 set_current_program_space (ss); 186 clear_section_table (current_target_sections); 187 exec_close (); 188 } 189} 190 191/* See gdbcore.h. */ 192 193void 194try_open_exec_file (const char *exec_file_host, struct inferior *inf, 195 symfile_add_flags add_flags) 196{ 197 struct gdb_exception prev_err; 198 199 /* exec_file_attach and symbol_file_add_main may throw an error if the file 200 cannot be opened either locally or remotely. 201 202 This happens for example, when the file is first found in the local 203 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't 204 exist in the target filesystem, or when the file does exist, but 205 is not readable. 206 207 Even without a symbol file, the remote-based debugging session should 208 continue normally instead of ending abruptly. Hence we catch thrown 209 errors/exceptions in the following code. */ 210 try 211 { 212 /* We must do this step even if exec_file_host is NULL, so that 213 exec_file_attach will clear state. */ 214 exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE); 215 } 216 catch (gdb_exception_error &err) 217 { 218 if (err.message != NULL) 219 warning ("%s", err.what ()); 220 221 prev_err = std::move (err); 222 } 223 224 if (exec_file_host != NULL) 225 { 226 try 227 { 228 symbol_file_add_main (exec_file_host, add_flags); 229 } 230 catch (const gdb_exception_error &err) 231 { 232 if (!exception_print_same (prev_err, err)) 233 warning ("%s", err.what ()); 234 } 235 } 236} 237 238/* See gdbcore.h. */ 239 240void 241validate_exec_file (int from_tty) 242{ 243 /* If user asked to ignore the mismatch, do nothing. */ 244 if (exec_file_mismatch_mode == exec_file_mismatch_off) 245 return; 246 247 const char *current_exec_file = get_exec_file (0); 248 struct inferior *inf = current_inferior (); 249 /* Try to determine a filename from the process itself. */ 250 const char *pid_exec_file = target_pid_to_exec_file (inf->pid); 251 bool build_id_mismatch = false; 252 253 /* If we cannot validate the exec file, return. */ 254 if (current_exec_file == NULL || pid_exec_file == NULL) 255 return; 256 257 /* Try validating via build-id, if available. This is the most 258 reliable check. */ 259 260 /* In case current_exec_file was changed, reopen_exec_file ensures 261 an up to date build_id (will do nothing if the file timestamp 262 did not change). If exec file changed, reopen_exec_file has 263 allocated another file name, so get_exec_file again. */ 264 reopen_exec_file (); 265 current_exec_file = get_exec_file (0); 266 267 const bfd_build_id *exec_file_build_id = build_id_bfd_get (exec_bfd); 268 if (exec_file_build_id != nullptr) 269 { 270 /* Prepend the target prefix, to force gdb_bfd_open to open the 271 file on the remote file system (if indeed remote). */ 272 std::string target_pid_exec_file 273 = std::string (TARGET_SYSROOT_PREFIX) + pid_exec_file; 274 275 gdb_bfd_ref_ptr abfd (gdb_bfd_open (target_pid_exec_file.c_str (), 276 gnutarget, -1, false)); 277 if (abfd != nullptr) 278 { 279 const bfd_build_id *target_exec_file_build_id 280 = build_id_bfd_get (abfd.get ()); 281 282 if (target_exec_file_build_id != nullptr) 283 { 284 if (exec_file_build_id->size == target_exec_file_build_id->size 285 && memcmp (exec_file_build_id->data, 286 target_exec_file_build_id->data, 287 exec_file_build_id->size) == 0) 288 { 289 /* Match. */ 290 return; 291 } 292 else 293 build_id_mismatch = true; 294 } 295 } 296 } 297 298 if (build_id_mismatch) 299 { 300 std::string exec_file_target (pid_exec_file); 301 302 /* In case the exec file is not local, exec_file_target has to point at 303 the target file system. */ 304 if (is_target_filename (current_exec_file) && !target_filesystem_is_local ()) 305 exec_file_target = TARGET_SYSROOT_PREFIX + exec_file_target; 306 307 warning 308 (_("Build ID mismatch between current exec-file %ps\n" 309 "and automatically determined exec-file %ps\n" 310 "exec-file-mismatch handling is currently \"%s\""), 311 styled_string (file_name_style.style (), current_exec_file), 312 styled_string (file_name_style.style (), exec_file_target.c_str ()), 313 exec_file_mismatch_names[exec_file_mismatch_mode]); 314 if (exec_file_mismatch_mode == exec_file_mismatch_ask) 315 { 316 symfile_add_flags add_flags = SYMFILE_MAINLINE; 317 if (from_tty) 318 { 319 add_flags |= SYMFILE_VERBOSE; 320 add_flags |= SYMFILE_ALWAYS_CONFIRM; 321 } 322 try 323 { 324 symbol_file_add_main (exec_file_target.c_str (), add_flags); 325 exec_file_attach (exec_file_target.c_str (), from_tty); 326 } 327 catch (gdb_exception_error &err) 328 { 329 warning (_("loading %ps %s"), 330 styled_string (file_name_style.style (), 331 exec_file_target.c_str ()), 332 err.message != NULL ? err.what () : "error"); 333 } 334 } 335 } 336} 337 338/* See gdbcore.h. */ 339 340void 341exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty) 342{ 343 char *exec_file_target; 344 symfile_add_flags add_flags = 0; 345 346 /* Do nothing if we already have an executable filename. */ 347 if (get_exec_file (0) != NULL) 348 return; 349 350 /* Try to determine a filename from the process itself. */ 351 exec_file_target = target_pid_to_exec_file (pid); 352 if (exec_file_target == NULL) 353 { 354 warning (_("No executable has been specified and target does not " 355 "support\n" 356 "determining executable automatically. " 357 "Try using the \"file\" command.")); 358 return; 359 } 360 361 gdb::unique_xmalloc_ptr<char> exec_file_host 362 = exec_file_find (exec_file_target, NULL); 363 364 if (defer_bp_reset) 365 add_flags |= SYMFILE_DEFER_BP_RESET; 366 367 if (from_tty) 368 add_flags |= SYMFILE_VERBOSE; 369 370 /* Attempt to open the exec file. */ 371 try_open_exec_file (exec_file_host.get (), current_inferior (), add_flags); 372} 373 374/* Set FILENAME as the new exec file. 375 376 This function is intended to be behave essentially the same 377 as exec_file_command, except that the latter will detect when 378 a target is being debugged, and will ask the user whether it 379 should be shut down first. (If the answer is "no", then the 380 new file is ignored.) 381 382 This file is used by exec_file_command, to do the work of opening 383 and processing the exec file after any prompting has happened. 384 385 And, it is used by child_attach, when the attach command was 386 given a pid but not a exec pathname, and the attach command could 387 figure out the pathname from the pid. (In this case, we shouldn't 388 ask the user whether the current target should be shut down -- 389 we're supplying the exec pathname late for good reason.) */ 390 391void 392exec_file_attach (const char *filename, int from_tty) 393{ 394 /* First, acquire a reference to the current exec_bfd. We release 395 this at the end of the function; but acquiring it now lets the 396 BFD cache return it if this call refers to the same file. */ 397 gdb_bfd_ref_ptr exec_bfd_holder = gdb_bfd_ref_ptr::new_reference (exec_bfd); 398 399 /* Remove any previous exec file. */ 400 exec_close (); 401 402 /* Now open and digest the file the user requested, if any. */ 403 404 if (!filename) 405 { 406 if (from_tty) 407 printf_unfiltered (_("No executable file now.\n")); 408 409 set_gdbarch_from_file (NULL); 410 } 411 else 412 { 413 int load_via_target = 0; 414 const char *scratch_pathname, *canonical_pathname; 415 int scratch_chan; 416 struct target_section *sections = NULL, *sections_end = NULL; 417 char **matching; 418 419 if (is_target_filename (filename)) 420 { 421 if (target_filesystem_is_local ()) 422 filename += strlen (TARGET_SYSROOT_PREFIX); 423 else 424 load_via_target = 1; 425 } 426 427 gdb::unique_xmalloc_ptr<char> canonical_storage, scratch_storage; 428 if (load_via_target) 429 { 430 /* gdb_bfd_fopen does not support "target:" filenames. */ 431 if (write_files) 432 warning (_("writing into executable files is " 433 "not supported for %s sysroots"), 434 TARGET_SYSROOT_PREFIX); 435 436 scratch_pathname = filename; 437 scratch_chan = -1; 438 canonical_pathname = scratch_pathname; 439 } 440 else 441 { 442 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, 443 filename, write_files ? 444 O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 445 &scratch_storage); 446#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__) 447 if (scratch_chan < 0) 448 { 449 int first_errno = errno; 450 char *exename = (char *) alloca (strlen (filename) + 5); 451 452 strcat (strcpy (exename, filename), ".exe"); 453 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, 454 exename, write_files ? 455 O_RDWR | O_BINARY 456 : O_RDONLY | O_BINARY, 457 &scratch_storage); 458 if (scratch_chan < 0) 459 errno = first_errno; 460 } 461#endif 462 if (scratch_chan < 0) 463 perror_with_name (filename); 464 465 scratch_pathname = scratch_storage.get (); 466 467 /* gdb_bfd_open (and its variants) prefers canonicalized 468 pathname for better BFD caching. */ 469 canonical_storage = gdb_realpath (scratch_pathname); 470 canonical_pathname = canonical_storage.get (); 471 } 472 473 gdb_bfd_ref_ptr temp; 474 if (write_files && !load_via_target) 475 temp = gdb_bfd_fopen (canonical_pathname, gnutarget, 476 FOPEN_RUB, scratch_chan); 477 else 478 temp = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan); 479 exec_bfd = temp.release (); 480 481 if (!exec_bfd) 482 { 483 error (_("\"%ps\": could not open as an executable file: %s."), 484 styled_string (file_name_style.style (), scratch_pathname), 485 bfd_errmsg (bfd_get_error ())); 486 } 487 488 /* gdb_realpath_keepfile resolves symlinks on the local 489 filesystem and so cannot be used for "target:" files. */ 490 gdb_assert (exec_filename == NULL); 491 if (load_via_target) 492 exec_filename = xstrdup (bfd_get_filename (exec_bfd)); 493 else 494 exec_filename = gdb_realpath_keepfile (scratch_pathname).release (); 495 496 if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching)) 497 { 498 /* Make sure to close exec_bfd, or else "run" might try to use 499 it. */ 500 exec_close (); 501 error (_("\"%ps\": not in executable format: %s"), 502 styled_string (file_name_style.style (), scratch_pathname), 503 gdb_bfd_errmsg (bfd_get_error (), matching).c_str ()); 504 } 505 506 if (build_section_table (exec_bfd, §ions, §ions_end)) 507 { 508 /* Make sure to close exec_bfd, or else "run" might try to use 509 it. */ 510 exec_close (); 511 error (_("\"%ps\": can't find the file sections: %s"), 512 styled_string (file_name_style.style (), scratch_pathname), 513 bfd_errmsg (bfd_get_error ())); 514 } 515 516 exec_bfd_mtime = bfd_get_mtime (exec_bfd); 517 518 validate_files (); 519 520 set_gdbarch_from_file (exec_bfd); 521 522 /* Add the executable's sections to the current address spaces' 523 list of sections. This possibly pushes the exec_ops 524 target. */ 525 add_target_sections (&exec_bfd, sections, sections_end); 526 xfree (sections); 527 528 /* Tell display code (if any) about the changed file name. */ 529 if (deprecated_exec_file_display_hook) 530 (*deprecated_exec_file_display_hook) (filename); 531 } 532 533 bfd_cache_close_all (); 534 gdb::observers::executable_changed.notify (); 535} 536 537/* Process the first arg in ARGS as the new exec file. 538 539 Note that we have to explicitly ignore additional args, since we can 540 be called from file_command(), which also calls symbol_file_command() 541 which can take multiple args. 542 543 If ARGS is NULL, we just want to close the exec file. */ 544 545static void 546exec_file_command (const char *args, int from_tty) 547{ 548 if (from_tty && target_has_execution 549 && !query (_("A program is being debugged already.\n" 550 "Are you sure you want to change the file? "))) 551 error (_("File not changed.")); 552 553 if (args) 554 { 555 /* Scan through the args and pick up the first non option arg 556 as the filename. */ 557 558 gdb_argv built_argv (args); 559 char **argv = built_argv.get (); 560 561 for (; (*argv != NULL) && (**argv == '-'); argv++) 562 {; 563 } 564 if (*argv == NULL) 565 error (_("No executable file name was specified")); 566 567 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv)); 568 exec_file_attach (filename.get (), from_tty); 569 } 570 else 571 exec_file_attach (NULL, from_tty); 572} 573 574/* Set both the exec file and the symbol file, in one command. 575 What a novelty. Why did GDB go through four major releases before this 576 command was added? */ 577 578static void 579file_command (const char *arg, int from_tty) 580{ 581 /* FIXME, if we lose on reading the symbol file, we should revert 582 the exec file, but that's rough. */ 583 exec_file_command (arg, from_tty); 584 symbol_file_command (arg, from_tty); 585 if (deprecated_file_changed_hook) 586 deprecated_file_changed_hook (arg); 587} 588 589 590/* Locate all mappable sections of a BFD file. 591 table_pp_char is a char * to get it through bfd_map_over_sections; 592 we cast it back to its proper type. */ 593 594static void 595add_to_section_table (bfd *abfd, struct bfd_section *asect, 596 void *table_pp_char) 597{ 598 struct target_section **table_pp = (struct target_section **) table_pp_char; 599 flagword aflag; 600 601 gdb_assert (abfd == asect->owner); 602 603 /* Check the section flags, but do not discard zero-length sections, since 604 some symbols may still be attached to this section. For instance, we 605 encountered on sparc-solaris 2.10 a shared library with an empty .bss 606 section to which a symbol named "_end" was attached. The address 607 of this symbol still needs to be relocated. */ 608 aflag = bfd_section_flags (asect); 609 if (!(aflag & SEC_ALLOC)) 610 return; 611 612 (*table_pp)->owner = NULL; 613 (*table_pp)->the_bfd_section = asect; 614 (*table_pp)->addr = bfd_section_vma (asect); 615 (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (asect); 616 (*table_pp)++; 617} 618 619/* See exec.h. */ 620 621void 622clear_section_table (struct target_section_table *table) 623{ 624 xfree (table->sections); 625 table->sections = table->sections_end = NULL; 626} 627 628/* Resize section table TABLE by ADJUSTMENT. 629 ADJUSTMENT may be negative, in which case the caller must have already 630 removed the sections being deleted. 631 Returns the old size. */ 632 633static int 634resize_section_table (struct target_section_table *table, int adjustment) 635{ 636 int old_count; 637 int new_count; 638 639 old_count = table->sections_end - table->sections; 640 641 new_count = adjustment + old_count; 642 643 if (new_count) 644 { 645 table->sections = XRESIZEVEC (struct target_section, table->sections, 646 new_count); 647 table->sections_end = table->sections + new_count; 648 } 649 else 650 clear_section_table (table); 651 652 return old_count; 653} 654 655/* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR. 656 Returns 0 if OK, 1 on error. */ 657 658int 659build_section_table (struct bfd *some_bfd, struct target_section **start, 660 struct target_section **end) 661{ 662 unsigned count; 663 664 count = bfd_count_sections (some_bfd); 665 xfree (*start); 666 *start = XNEWVEC (struct target_section, count); 667 *end = *start; 668 bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end); 669 670 gdb_assert (*end <= *start + count); 671 672 /* We could realloc the table, but it probably loses for most files. */ 673 return 0; 674} 675 676/* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the 677 current set of target sections. */ 678 679void 680add_target_sections (void *owner, 681 struct target_section *sections, 682 struct target_section *sections_end) 683{ 684 int count; 685 struct target_section_table *table = current_target_sections; 686 687 count = sections_end - sections; 688 689 if (count > 0) 690 { 691 int space = resize_section_table (table, count); 692 int i; 693 694 for (i = 0; i < count; ++i) 695 { 696 table->sections[space + i] = sections[i]; 697 table->sections[space + i].owner = owner; 698 } 699 700 scoped_restore_current_pspace_and_thread restore_pspace_thread; 701 program_space *curr_pspace = current_program_space; 702 703 /* If these are the first file sections we can provide memory 704 from, push the file_stratum target. Must do this in all 705 inferiors sharing the program space. */ 706 for (inferior *inf : all_inferiors ()) 707 { 708 if (inf->pspace != curr_pspace) 709 continue; 710 711 if (inf->target_is_pushed (&exec_ops)) 712 continue; 713 714 switch_to_inferior_no_thread (inf); 715 push_target (&exec_ops); 716 } 717 } 718} 719 720/* Add the sections of OBJFILE to the current set of target sections. */ 721 722void 723add_target_sections_of_objfile (struct objfile *objfile) 724{ 725 struct target_section_table *table = current_target_sections; 726 struct obj_section *osect; 727 int space; 728 unsigned count = 0; 729 struct target_section *ts; 730 731 if (objfile == NULL) 732 return; 733 734 /* Compute the number of sections to add. */ 735 ALL_OBJFILE_OSECTIONS (objfile, osect) 736 { 737 if (bfd_section_size (osect->the_bfd_section) == 0) 738 continue; 739 count++; 740 } 741 742 if (count == 0) 743 return; 744 745 space = resize_section_table (table, count); 746 747 ts = table->sections + space; 748 749 ALL_OBJFILE_OSECTIONS (objfile, osect) 750 { 751 if (bfd_section_size (osect->the_bfd_section) == 0) 752 continue; 753 754 gdb_assert (ts < table->sections + space + count); 755 756 ts->addr = obj_section_addr (osect); 757 ts->endaddr = obj_section_endaddr (osect); 758 ts->the_bfd_section = osect->the_bfd_section; 759 ts->owner = (void *) objfile; 760 761 ts++; 762 } 763} 764 765/* Remove all target sections owned by OWNER. 766 OWNER must be the same value passed to add_target_sections. */ 767 768void 769remove_target_sections (void *owner) 770{ 771 struct target_section *src, *dest; 772 struct target_section_table *table = current_target_sections; 773 774 gdb_assert (owner != NULL); 775 776 dest = table->sections; 777 for (src = table->sections; src < table->sections_end; src++) 778 if (src->owner != owner) 779 { 780 /* Keep this section. */ 781 if (dest < src) 782 *dest = *src; 783 dest++; 784 } 785 786 /* If we've dropped any sections, resize the section table. */ 787 if (dest < src) 788 { 789 int old_count; 790 791 old_count = resize_section_table (table, dest - src); 792 793 /* If we don't have any more sections to read memory from, 794 remove the file_stratum target from the stack of each 795 inferior sharing the program space. */ 796 if (old_count + (dest - src) == 0) 797 { 798 scoped_restore_current_pspace_and_thread restore_pspace_thread; 799 program_space *curr_pspace = current_program_space; 800 801 for (inferior *inf : all_inferiors ()) 802 { 803 if (inf->pspace != curr_pspace) 804 continue; 805 806 if (inf->pspace->target_sections.sections 807 != inf->pspace->target_sections.sections_end) 808 continue; 809 810 switch_to_inferior_no_thread (inf); 811 unpush_target (&exec_ops); 812 } 813 } 814 } 815} 816 817/* See exec.h. */ 818 819void 820exec_on_vfork () 821{ 822 if (current_program_space->target_sections.sections 823 != current_program_space->target_sections.sections_end) 824 push_target (&exec_ops); 825} 826 827 828 829enum target_xfer_status 830exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset, 831 ULONGEST len, ULONGEST *xfered_len) 832{ 833 /* It's unduly pedantic to refuse to look at the executable for 834 read-only pieces; so do the equivalent of readonly regions aka 835 QTro packet. */ 836 if (exec_bfd != NULL) 837 { 838 asection *s; 839 bfd_size_type size; 840 bfd_vma vma; 841 842 for (s = exec_bfd->sections; s; s = s->next) 843 { 844 if ((s->flags & SEC_LOAD) == 0 845 || (s->flags & SEC_READONLY) == 0) 846 continue; 847 848 vma = s->vma; 849 size = bfd_section_size (s); 850 if (vma <= offset && offset < (vma + size)) 851 { 852 ULONGEST amt; 853 854 amt = (vma + size) - offset; 855 if (amt > len) 856 amt = len; 857 858 amt = bfd_get_section_contents (exec_bfd, s, 859 readbuf, offset - vma, amt); 860 861 if (amt == 0) 862 return TARGET_XFER_EOF; 863 else 864 { 865 *xfered_len = amt; 866 return TARGET_XFER_OK; 867 } 868 } 869 } 870 } 871 872 /* Indicate failure to find the requested memory block. */ 873 return TARGET_XFER_E_IO; 874} 875 876/* Return all read-only memory ranges found in the target section 877 table defined by SECTIONS and SECTIONS_END, starting at (and 878 intersected with) MEMADDR for LEN bytes. */ 879 880static std::vector<mem_range> 881section_table_available_memory (CORE_ADDR memaddr, ULONGEST len, 882 struct target_section *sections, 883 struct target_section *sections_end) 884{ 885 std::vector<mem_range> memory; 886 887 for (target_section *p = sections; p < sections_end; p++) 888 { 889 if ((bfd_section_flags (p->the_bfd_section) & SEC_READONLY) == 0) 890 continue; 891 892 /* Copy the meta-data, adjusted. */ 893 if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len)) 894 { 895 ULONGEST lo1, hi1, lo2, hi2; 896 897 lo1 = memaddr; 898 hi1 = memaddr + len; 899 900 lo2 = p->addr; 901 hi2 = p->endaddr; 902 903 CORE_ADDR start = std::max (lo1, lo2); 904 int length = std::min (hi1, hi2) - start; 905 906 memory.emplace_back (start, length); 907 } 908 } 909 910 return memory; 911} 912 913enum target_xfer_status 914section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset, 915 ULONGEST len, ULONGEST *xfered_len) 916{ 917 target_section_table *table = target_get_section_table (&exec_ops); 918 std::vector<mem_range> available_memory 919 = section_table_available_memory (offset, len, 920 table->sections, table->sections_end); 921 922 normalize_mem_ranges (&available_memory); 923 924 for (const mem_range &r : available_memory) 925 { 926 if (mem_ranges_overlap (r.start, r.length, offset, len)) 927 { 928 CORE_ADDR end; 929 enum target_xfer_status status; 930 931 /* Get the intersection window. */ 932 end = std::min<CORE_ADDR> (offset + len, r.start + r.length); 933 934 gdb_assert (end - offset <= len); 935 936 if (offset >= r.start) 937 status = exec_read_partial_read_only (readbuf, offset, 938 end - offset, 939 xfered_len); 940 else 941 { 942 *xfered_len = r.start - offset; 943 status = TARGET_XFER_UNAVAILABLE; 944 } 945 return status; 946 } 947 } 948 949 *xfered_len = len; 950 return TARGET_XFER_UNAVAILABLE; 951} 952 953enum target_xfer_status 954section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf, 955 ULONGEST offset, ULONGEST len, 956 ULONGEST *xfered_len, 957 struct target_section *sections, 958 struct target_section *sections_end, 959 gdb::function_view<bool 960 (const struct target_section *)> match_cb) 961{ 962 int res; 963 struct target_section *p; 964 ULONGEST memaddr = offset; 965 ULONGEST memend = memaddr + len; 966 967 gdb_assert (len != 0); 968 969 for (p = sections; p < sections_end; p++) 970 { 971 struct bfd_section *asect = p->the_bfd_section; 972 bfd *abfd = asect->owner; 973 974 if (match_cb != nullptr && !match_cb (p)) 975 continue; /* not the section we need. */ 976 if (memaddr >= p->addr) 977 { 978 if (memend <= p->endaddr) 979 { 980 /* Entire transfer is within this section. */ 981 if (writebuf) 982 res = bfd_set_section_contents (abfd, asect, 983 writebuf, memaddr - p->addr, 984 len); 985 else 986 res = bfd_get_section_contents (abfd, asect, 987 readbuf, memaddr - p->addr, 988 len); 989 990 if (res != 0) 991 { 992 *xfered_len = len; 993 return TARGET_XFER_OK; 994 } 995 else 996 return TARGET_XFER_EOF; 997 } 998 else if (memaddr >= p->endaddr) 999 { 1000 /* This section ends before the transfer starts. */ 1001 continue; 1002 } 1003 else 1004 { 1005 /* This section overlaps the transfer. Just do half. */ 1006 len = p->endaddr - memaddr; 1007 if (writebuf) 1008 res = bfd_set_section_contents (abfd, asect, 1009 writebuf, memaddr - p->addr, 1010 len); 1011 else 1012 res = bfd_get_section_contents (abfd, asect, 1013 readbuf, memaddr - p->addr, 1014 len); 1015 if (res != 0) 1016 { 1017 *xfered_len = len; 1018 return TARGET_XFER_OK; 1019 } 1020 else 1021 return TARGET_XFER_EOF; 1022 } 1023 } 1024 } 1025 1026 return TARGET_XFER_EOF; /* We can't help. */ 1027} 1028 1029struct target_section_table * 1030exec_target::get_section_table () 1031{ 1032 return current_target_sections; 1033} 1034 1035enum target_xfer_status 1036exec_target::xfer_partial (enum target_object object, 1037 const char *annex, gdb_byte *readbuf, 1038 const gdb_byte *writebuf, 1039 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) 1040{ 1041 struct target_section_table *table = get_section_table (); 1042 1043 if (object == TARGET_OBJECT_MEMORY) 1044 return section_table_xfer_memory_partial (readbuf, writebuf, 1045 offset, len, xfered_len, 1046 table->sections, 1047 table->sections_end); 1048 else 1049 return TARGET_XFER_E_IO; 1050} 1051 1052 1053void 1054print_section_info (struct target_section_table *t, bfd *abfd) 1055{ 1056 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd); 1057 struct target_section *p; 1058 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */ 1059 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16; 1060 1061 printf_filtered ("\t`%ps', ", 1062 styled_string (file_name_style.style (), 1063 bfd_get_filename (abfd))); 1064 wrap_here (" "); 1065 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd)); 1066 if (abfd == exec_bfd) 1067 { 1068 /* gcc-3.4 does not like the initialization in 1069 <p == t->sections_end>. */ 1070 bfd_vma displacement = 0; 1071 bfd_vma entry_point; 1072 1073 for (p = t->sections; p < t->sections_end; p++) 1074 { 1075 struct bfd_section *psect = p->the_bfd_section; 1076 1077 if ((bfd_section_flags (psect) & (SEC_ALLOC | SEC_LOAD)) 1078 != (SEC_ALLOC | SEC_LOAD)) 1079 continue; 1080 1081 if (bfd_section_vma (psect) <= abfd->start_address 1082 && abfd->start_address < (bfd_section_vma (psect) 1083 + bfd_section_size (psect))) 1084 { 1085 displacement = p->addr - bfd_section_vma (psect); 1086 break; 1087 } 1088 } 1089 if (p == t->sections_end) 1090 warning (_("Cannot find section for the entry point of %ps."), 1091 styled_string (file_name_style.style (), 1092 bfd_get_filename (abfd))); 1093 1094 entry_point = gdbarch_addr_bits_remove (gdbarch, 1095 bfd_get_start_address (abfd) 1096 + displacement); 1097 printf_filtered (_("\tEntry point: %s\n"), 1098 paddress (gdbarch, entry_point)); 1099 } 1100 for (p = t->sections; p < t->sections_end; p++) 1101 { 1102 struct bfd_section *psect = p->the_bfd_section; 1103 bfd *pbfd = psect->owner; 1104 1105 printf_filtered ("\t%s", hex_string_custom (p->addr, wid)); 1106 printf_filtered (" - %s", hex_string_custom (p->endaddr, wid)); 1107 1108 /* FIXME: A format of "08l" is not wide enough for file offsets 1109 larger than 4GB. OTOH, making it "016l" isn't desirable either 1110 since most output will then be much wider than necessary. It 1111 may make sense to test the size of the file and choose the 1112 format string accordingly. */ 1113 /* FIXME: i18n: Need to rewrite this sentence. */ 1114 if (info_verbose) 1115 printf_filtered (" @ %s", 1116 hex_string_custom (psect->filepos, 8)); 1117 printf_filtered (" is %s", bfd_section_name (psect)); 1118 if (pbfd != abfd) 1119 printf_filtered (" in %ps", 1120 styled_string (file_name_style.style (), 1121 bfd_get_filename (pbfd))); 1122 printf_filtered ("\n"); 1123 } 1124} 1125 1126void 1127exec_target::files_info () 1128{ 1129 if (exec_bfd) 1130 print_section_info (current_target_sections, exec_bfd); 1131 else 1132 puts_filtered (_("\t<no file loaded>\n")); 1133} 1134 1135static void 1136set_section_command (const char *args, int from_tty) 1137{ 1138 struct target_section *p; 1139 const char *secname; 1140 unsigned seclen; 1141 unsigned long secaddr; 1142 char secprint[100]; 1143 long offset; 1144 struct target_section_table *table; 1145 1146 if (args == 0) 1147 error (_("Must specify section name and its virtual address")); 1148 1149 /* Parse out section name. */ 1150 for (secname = args; !isspace (*args); args++); 1151 seclen = args - secname; 1152 1153 /* Parse out new virtual address. */ 1154 secaddr = parse_and_eval_address (args); 1155 1156 table = current_target_sections; 1157 for (p = table->sections; p < table->sections_end; p++) 1158 { 1159 if (!strncmp (secname, bfd_section_name (p->the_bfd_section), seclen) 1160 && bfd_section_name (p->the_bfd_section)[seclen] == '\0') 1161 { 1162 offset = secaddr - p->addr; 1163 p->addr += offset; 1164 p->endaddr += offset; 1165 if (from_tty) 1166 exec_ops.files_info (); 1167 return; 1168 } 1169 } 1170 if (seclen >= sizeof (secprint)) 1171 seclen = sizeof (secprint) - 1; 1172 strncpy (secprint, secname, seclen); 1173 secprint[seclen] = '\0'; 1174 error (_("Section %s not found"), secprint); 1175} 1176 1177/* If we can find a section in FILENAME with BFD index INDEX, adjust 1178 it to ADDRESS. */ 1179 1180void 1181exec_set_section_address (const char *filename, int index, CORE_ADDR address) 1182{ 1183 struct target_section *p; 1184 struct target_section_table *table; 1185 1186 table = current_target_sections; 1187 for (p = table->sections; p < table->sections_end; p++) 1188 { 1189 if (filename_cmp (filename, 1190 bfd_get_filename (p->the_bfd_section->owner)) == 0 1191 && index == p->the_bfd_section->index) 1192 { 1193 p->endaddr += address - p->addr; 1194 p->addr = address; 1195 } 1196 } 1197} 1198 1199bool 1200exec_target::has_memory () 1201{ 1202 /* We can provide memory if we have any file/target sections to read 1203 from. */ 1204 return (current_target_sections->sections 1205 != current_target_sections->sections_end); 1206} 1207 1208char * 1209exec_target::make_corefile_notes (bfd *obfd, int *note_size) 1210{ 1211 error (_("Can't create a corefile")); 1212} 1213 1214int 1215exec_target::find_memory_regions (find_memory_region_ftype func, void *data) 1216{ 1217 return objfile_find_memory_regions (this, func, data); 1218} 1219 1220void _initialize_exec (); 1221void 1222_initialize_exec () 1223{ 1224 struct cmd_list_element *c; 1225 1226 if (!dbx_commands) 1227 { 1228 c = add_cmd ("file", class_files, file_command, _("\ 1229Use FILE as program to be debugged.\n\ 1230It is read for its symbols, for getting the contents of pure memory,\n\ 1231and it is the program executed when you use the `run' command.\n\ 1232If FILE cannot be found as specified, your execution directory path\n\ 1233($PATH) is searched for a command of that name.\n\ 1234No arg means to have no executable file and no symbols."), &cmdlist); 1235 set_cmd_completer (c, filename_completer); 1236 } 1237 1238 c = add_cmd ("exec-file", class_files, exec_file_command, _("\ 1239Use FILE as program for getting contents of pure memory.\n\ 1240If FILE cannot be found as specified, your execution directory path\n\ 1241is searched for a command of that name.\n\ 1242No arg means have no executable file."), &cmdlist); 1243 set_cmd_completer (c, filename_completer); 1244 1245 add_com ("section", class_files, set_section_command, _("\ 1246Change the base address of section SECTION of the exec file to ADDR.\n\ 1247This can be used if the exec file does not contain section addresses,\n\ 1248(such as in the a.out format), or when the addresses specified in the\n\ 1249file itself are wrong. Each section must be changed separately. The\n\ 1250``info files'' command lists all the sections and their addresses.")); 1251 1252 add_setshow_boolean_cmd ("write", class_support, &write_files, _("\ 1253Set writing into executable and core files."), _("\ 1254Show writing into executable and core files."), NULL, 1255 NULL, 1256 show_write_files, 1257 &setlist, &showlist); 1258 1259 add_setshow_enum_cmd ("exec-file-mismatch", class_support, 1260 exec_file_mismatch_names, 1261 &exec_file_mismatch, 1262 _("\ 1263Set exec-file-mismatch handling (ask|warn|off)."), 1264 _("\ 1265Show exec-file-mismatch handling (ask|warn|off)."), 1266 _("\ 1267Specifies how to handle a mismatch between the current exec-file\n\ 1268loaded by GDB and the exec-file automatically determined when attaching\n\ 1269to a process:\n\n\ 1270 ask - warn the user and ask whether to load the determined exec-file.\n\ 1271 warn - warn the user, but do not change the exec-file.\n\ 1272 off - do not check for mismatch.\n\ 1273\n\ 1274GDB detects a mismatch by comparing the build IDs of the files.\n\ 1275If the user confirms loading the determined exec-file, then its symbols\n\ 1276will be loaded as well."), 1277 set_exec_file_mismatch_command, 1278 show_exec_file_mismatch_command, 1279 &setlist, &showlist); 1280 1281 add_target (exec_target_info, exec_target_open, filename_completer); 1282} 1283