gdb/exec.c

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