gdb/exec.c

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