gdb/exec.c

   1 /* Work with executable files, for GDB.
   2
   3    Copyright (C) 1988-2022 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 #include "gdbsupport/buildargv.h"
  53
  54 void (*deprecated_file_changed_hook) (const char *);
  55
  56 static const target_info exec_target_info = {
  57   "exec",
  58   N_("Local exec file"),
  59   N_("Use an executable file as a target.\n\
  60 Specify the filename of the executable file.")
  61 };
  62
  63 /* The target vector for executable files.  */
  64
  65 struct exec_target final : public target_ops
  66 {
  67   const target_info &info () const override
  68   { return exec_target_info; }
  69
  70   strata stratum () const override { return file_stratum; }
  71
  72   void close () override;
  73   enum target_xfer_status xfer_partial (enum target_object object,
  74                                         const char *annex,
  75                                         gdb_byte *readbuf,
  76                                         const gdb_byte *writebuf,
  77                                         ULONGEST offset, ULONGEST len,
  78                                         ULONGEST *xfered_len) 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 (file,
 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->clear_target_sections ();
 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 (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_filtered (_("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 (_("\"%s\": could not open as an executable file: %s."),
 458                  scratch_pathname, 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 (_("\"%s\": not in executable format: %s"), scratch_pathname,
 479                  gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
 480         }
 481
 482           target_section_table sections
 483           = build_section_table (current_program_space->exec_bfd ());
 484
 485       current_program_space->ebfd_mtime
 486         = bfd_get_mtime (current_program_space->exec_bfd ());
 487
 488       validate_files ();
 489
 490       set_gdbarch_from_file (current_program_space->exec_bfd ());
 491
 492       /* Add the executable's sections to the current address spaces'
 493          list of sections.  This possibly pushes the exec_ops
 494          target.  */
 495       current_program_space->add_target_sections (&current_program_space->ebfd,
 496                                                   sections);
 497
 498       /* Tell display code (if any) about the changed file name.  */
 499       if (deprecated_exec_file_display_hook)
 500         (*deprecated_exec_file_display_hook) (filename);
 501     }
 502
 503   bfd_cache_close_all ();
 504   gdb::observers::executable_changed.notify ();
 505 }
 506
 507 /*  Process the first arg in ARGS as the new exec file.
 508
 509    Note that we have to explicitly ignore additional args, since we can
 510    be called from file_command(), which also calls symbol_file_command()
 511    which can take multiple args.
 512
 513    If ARGS is NULL, we just want to close the exec file.  */
 514
 515 static void
 516 exec_file_command (const char *args, int from_tty)
 517 {
 518   if (from_tty && target_has_execution ()
 519       && !query (_("A program is being debugged already.\n"
 520                    "Are you sure you want to change the file? ")))
 521     error (_("File not changed."));
 522
 523   if (args)
 524     {
 525       /* Scan through the args and pick up the first non option arg
 526          as the filename.  */
 527
 528       gdb_argv built_argv (args);
 529       char **argv = built_argv.get ();
 530
 531       for (; (*argv != NULL) && (**argv == '-'); argv++)
 532         {;
 533         }
 534       if (*argv == NULL)
 535         error (_("No executable file name was specified"));
 536
 537       gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv));
 538       exec_file_attach (filename.get (), from_tty);
 539     }
 540   else
 541     exec_file_attach (NULL, from_tty);
 542 }
 543
 544 /* Set both the exec file and the symbol file, in one command.
 545    What a novelty.  Why did GDB go through four major releases before this
 546    command was added?  */
 547
 548 static void
 549 file_command (const char *arg, int from_tty)
 550 {
 551   /* FIXME, if we lose on reading the symbol file, we should revert
 552      the exec file, but that's rough.  */
 553   exec_file_command (arg, from_tty);
 554   symbol_file_command (arg, from_tty);
 555   if (deprecated_file_changed_hook)
 556     deprecated_file_changed_hook (arg);
 557 }
 558 \f
 559
 560 /* Builds a section table, given args BFD, TABLE.  */
 561
 562 target_section_table
 563 build_section_table (struct bfd *some_bfd)
 564 {
 565   target_section_table table;
 566
 567   for (asection *asect : gdb_bfd_sections (some_bfd))
 568     {
 569       flagword aflag;
 570
 571       /* Check the section flags, but do not discard zero-length
 572          sections, since some symbols may still be attached to this
 573          section.  For instance, we encountered on sparc-solaris 2.10
 574          a shared library with an empty .bss section to which a symbol
 575          named "_end" was attached.  The address of this symbol still
 576          needs to be relocated.  */
 577       aflag = bfd_section_flags (asect);
 578       if (!(aflag & SEC_ALLOC))
 579         continue;
 580
 581       table.emplace_back (bfd_section_vma (asect),
 582                           bfd_section_vma (asect) + bfd_section_size (asect),
 583                           asect);
 584     }
 585
 586   return table;
 587 }
 588
 589 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
 590    current set of target sections.  */
 591
 592 void
 593 program_space::add_target_sections (void *owner,
 594                                     const target_section_table &sections)
 595 {
 596   if (!sections.empty ())
 597     {
 598       for (const target_section &s : sections)
 599         {
 600           m_target_sections.push_back (s);
 601           m_target_sections.back ().owner = owner;
 602         }
 603
 604       scoped_restore_current_pspace_and_thread restore_pspace_thread;
 605
 606       /* If these are the first file sections we can provide memory
 607          from, push the file_stratum target.  Must do this in all
 608          inferiors sharing the program space.  */
 609       for (inferior *inf : all_inferiors ())
 610         {
 611           if (inf->pspace != this)
 612             continue;
 613
 614           if (inf->target_is_pushed (&exec_ops))
 615             continue;
 616
 617           switch_to_inferior_no_thread (inf);
 618           inf->push_target (&exec_ops);
 619         }
 620     }
 621 }
 622
 623 /* Add the sections of OBJFILE to the current set of target sections.  */
 624
 625 void
 626 program_space::add_target_sections (struct objfile *objfile)
 627 {
 628   struct obj_section *osect;
 629
 630   gdb_assert (objfile != nullptr);
 631
 632   /* Compute the number of sections to add.  */
 633   ALL_OBJFILE_OSECTIONS (objfile, osect)
 634     {
 635       if (bfd_section_size (osect->the_bfd_section) == 0)
 636         continue;
 637
 638       m_target_sections.emplace_back (osect->addr (), osect->endaddr (),
 639                                       osect->the_bfd_section, (void *) objfile);
 640     }
 641 }
 642
 643 /* Remove all target sections owned by OWNER.
 644    OWNER must be the same value passed to add_target_sections.  */
 645
 646 void
 647 program_space::remove_target_sections (void *owner)
 648 {
 649   gdb_assert (owner != NULL);
 650
 651   auto it = std::remove_if (m_target_sections.begin (),
 652                             m_target_sections.end (),
 653                             [&] (target_section &sect)
 654                             {
 655                               return sect.owner == owner;
 656                             });
 657   m_target_sections.erase (it, m_target_sections.end ());
 658
 659   /* If we don't have any more sections to read memory from,
 660      remove the file_stratum target from the stack of each
 661      inferior sharing the program space.  */
 662   if (m_target_sections.empty ())
 663     {
 664       scoped_restore_current_pspace_and_thread restore_pspace_thread;
 665
 666       for (inferior *inf : all_inferiors ())
 667         {
 668           if (inf->pspace != this)
 669             continue;
 670
 671           switch_to_inferior_no_thread (inf);
 672           inf->unpush_target (&exec_ops);
 673         }
 674     }
 675 }
 676
 677 /* See exec.h.  */
 678
 679 void
 680 exec_on_vfork (inferior *vfork_child)
 681 {
 682   if (!vfork_child->pspace->target_sections ().empty ())
 683     vfork_child->push_target (&exec_ops);
 684 }
 685
 686 \f
 687
 688 enum target_xfer_status
 689 exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset,
 690                              ULONGEST len, ULONGEST *xfered_len)
 691 {
 692   /* It's unduly pedantic to refuse to look at the executable for
 693      read-only pieces; so do the equivalent of readonly regions aka
 694      QTro packet.  */
 695   if (current_program_space->exec_bfd () != NULL)
 696     {
 697       asection *s;
 698       bfd_size_type size;
 699       bfd_vma vma;
 700
 701       for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
 702         {
 703           if ((s->flags & SEC_LOAD) == 0
 704               || (s->flags & SEC_READONLY) == 0)
 705             continue;
 706
 707           vma = s->vma;
 708           size = bfd_section_size (s);
 709           if (vma <= offset && offset < (vma + size))
 710             {
 711               ULONGEST amt;
 712
 713               amt = (vma + size) - offset;
 714               if (amt > len)
 715                 amt = len;
 716
 717               amt = bfd_get_section_contents (current_program_space->exec_bfd (), s,
 718                                               readbuf, offset - vma, amt);
 719
 720               if (amt == 0)
 721                 return TARGET_XFER_EOF;
 722               else
 723                 {
 724                   *xfered_len = amt;
 725                   return TARGET_XFER_OK;
 726                 }
 727             }
 728         }
 729     }
 730
 731   /* Indicate failure to find the requested memory block.  */
 732   return TARGET_XFER_E_IO;
 733 }
 734
 735 /* Return all read-only memory ranges found in the target section
 736    table defined by SECTIONS and SECTIONS_END, starting at (and
 737    intersected with) MEMADDR for LEN bytes.  */
 738
 739 static std::vector<mem_range>
 740 section_table_available_memory (CORE_ADDR memaddr, ULONGEST len,
 741                                 const target_section_table &sections)
 742 {
 743   std::vector<mem_range> memory;
 744
 745   for (const target_section &p : sections)
 746     {
 747       if ((bfd_section_flags (p.the_bfd_section) & SEC_READONLY) == 0)
 748         continue;
 749
 750       /* Copy the meta-data, adjusted.  */
 751       if (mem_ranges_overlap (p.addr, p.endaddr - p.addr, memaddr, len))
 752         {
 753           ULONGEST lo1, hi1, lo2, hi2;
 754
 755           lo1 = memaddr;
 756           hi1 = memaddr + len;
 757
 758           lo2 = p.addr;
 759           hi2 = p.endaddr;
 760
 761           CORE_ADDR start = std::max (lo1, lo2);
 762           int length = std::min (hi1, hi2) - start;
 763
 764           memory.emplace_back (start, length);
 765         }
 766     }
 767
 768   return memory;
 769 }
 770
 771 enum target_xfer_status
 772 section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
 773                                      ULONGEST len, ULONGEST *xfered_len)
 774 {
 775   const target_section_table *table
 776     = target_get_section_table (current_inferior ()->top_target ());
 777   std::vector<mem_range> available_memory
 778     = section_table_available_memory (offset, len, *table);
 779
 780   normalize_mem_ranges (&available_memory);
 781
 782   for (const mem_range &r : available_memory)
 783     {
 784       if (mem_ranges_overlap (r.start, r.length, offset, len))
 785         {
 786           CORE_ADDR end;
 787           enum target_xfer_status status;
 788
 789           /* Get the intersection window.  */
 790           end = std::min<CORE_ADDR> (offset + len, r.start + r.length);
 791
 792           gdb_assert (end - offset <= len);
 793
 794           if (offset >= r.start)
 795             status = exec_read_partial_read_only (readbuf, offset,
 796                                                   end - offset,
 797                                                   xfered_len);
 798           else
 799             {
 800               *xfered_len = r.start - offset;
 801               status = TARGET_XFER_UNAVAILABLE;
 802             }
 803           return status;
 804         }
 805     }
 806
 807   *xfered_len = len;
 808   return TARGET_XFER_UNAVAILABLE;
 809 }
 810
 811 enum target_xfer_status
 812 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
 813                                    ULONGEST offset, ULONGEST len,
 814                                    ULONGEST *xfered_len,
 815                                    const target_section_table &sections,
 816                                    gdb::function_view<bool
 817                                      (const struct target_section *)> match_cb)
 818 {
 819   int res;
 820   ULONGEST memaddr = offset;
 821   ULONGEST memend = memaddr + len;
 822
 823   gdb_assert (len != 0);
 824
 825   for (const target_section &p : sections)
 826     {
 827       struct bfd_section *asect = p.the_bfd_section;
 828       bfd *abfd = asect->owner;
 829
 830       if (match_cb != nullptr && !match_cb (&p))
 831         continue;               /* not the section we need.  */
 832       if (memaddr >= p.addr)
 833         {
 834           if (memend <= p.endaddr)
 835             {
 836               /* Entire transfer is within this section.  */
 837               if (writebuf)
 838                 res = bfd_set_section_contents (abfd, asect,
 839                                                 writebuf, memaddr - p.addr,
 840                                                 len);
 841               else
 842                 res = bfd_get_section_contents (abfd, asect,
 843                                                 readbuf, memaddr - p.addr,
 844                                                 len);
 845
 846               if (res != 0)
 847                 {
 848                   *xfered_len = len;
 849                   return TARGET_XFER_OK;
 850                 }
 851               else
 852                 return TARGET_XFER_EOF;
 853             }
 854           else if (memaddr >= p.endaddr)
 855             {
 856               /* This section ends before the transfer starts.  */
 857               continue;
 858             }
 859           else
 860             {
 861               /* This section overlaps the transfer.  Just do half.  */
 862               len = p.endaddr - memaddr;
 863               if (writebuf)
 864                 res = bfd_set_section_contents (abfd, asect,
 865                                                 writebuf, memaddr - p.addr,
 866                                                 len);
 867               else
 868                 res = bfd_get_section_contents (abfd, asect,
 869                                                 readbuf, memaddr - p.addr,
 870                                                 len);
 871               if (res != 0)
 872                 {
 873                   *xfered_len = len;
 874                   return TARGET_XFER_OK;
 875                 }
 876               else
 877                 return TARGET_XFER_EOF;
 878             }
 879         }
 880     }
 881
 882   return TARGET_XFER_EOF;               /* We can't help.  */
 883 }
 884
 885 enum target_xfer_status
 886 exec_target::xfer_partial (enum target_object object,
 887                            const char *annex, gdb_byte *readbuf,
 888                            const gdb_byte *writebuf,
 889                            ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 890 {
 891   const target_section_table *table = target_get_section_table (this);
 892
 893   if (object == TARGET_OBJECT_MEMORY)
 894     return section_table_xfer_memory_partial (readbuf, writebuf,
 895                                               offset, len, xfered_len,
 896                                               *table);
 897   else
 898     return TARGET_XFER_E_IO;
 899 }
 900 \f
 901
 902 void
 903 print_section_info (const target_section_table *t, bfd *abfd)
 904 {
 905   struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 906   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 907   int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
 908
 909   printf_filtered ("\t`%ps', ",
 910                    styled_string (file_name_style.style (),
 911                                   bfd_get_filename (abfd)));
 912   gdb_stdout->wrap_here (8);
 913   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 914   if (abfd == current_program_space->exec_bfd ())
 915     {
 916       /* gcc-3.4 does not like the initialization in
 917          <p == t->sections_end>.  */
 918       bfd_vma displacement = 0;
 919       bfd_vma entry_point;
 920       bool found = false;
 921
 922       for (const target_section &p : *t)
 923         {
 924           struct bfd_section *psect = p.the_bfd_section;
 925
 926           if ((bfd_section_flags (psect) & (SEC_ALLOC | SEC_LOAD))
 927               != (SEC_ALLOC | SEC_LOAD))
 928             continue;
 929
 930           if (bfd_section_vma (psect) <= abfd->start_address
 931               && abfd->start_address < (bfd_section_vma (psect)
 932                                         + bfd_section_size (psect)))
 933             {
 934               displacement = p.addr - bfd_section_vma (psect);
 935               found = true;
 936               break;
 937             }
 938         }
 939       if (!found)
 940         warning (_("Cannot find section for the entry point of %ps."),
 941                  styled_string (file_name_style.style (),
 942                                 bfd_get_filename (abfd)));
 943
 944       entry_point = gdbarch_addr_bits_remove (gdbarch,
 945                                               bfd_get_start_address (abfd)
 946                                                 + displacement);
 947       printf_filtered (_("\tEntry point: %s\n"),
 948                        paddress (gdbarch, entry_point));
 949     }
 950   for (const target_section &p : *t)
 951     {
 952       struct bfd_section *psect = p.the_bfd_section;
 953       bfd *pbfd = psect->owner;
 954
 955       printf_filtered ("\t%s", hex_string_custom (p.addr, wid));
 956       printf_filtered (" - %s", hex_string_custom (p.endaddr, wid));
 957
 958       /* FIXME: A format of "08l" is not wide enough for file offsets
 959          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 960          since most output will then be much wider than necessary.  It
 961          may make sense to test the size of the file and choose the
 962          format string accordingly.  */
 963       /* FIXME: i18n: Need to rewrite this sentence.  */
 964       if (info_verbose)
 965         printf_filtered (" @ %s",
 966                          hex_string_custom (psect->filepos, 8));
 967       printf_filtered (" is %s", bfd_section_name (psect));
 968       if (pbfd != abfd)
 969         printf_filtered (" in %ps",
 970                          styled_string (file_name_style.style (),
 971                                         bfd_get_filename (pbfd)));
 972       printf_filtered ("\n");
 973     }
 974 }
 975
 976 void
 977 exec_target::files_info ()
 978 {
 979   if (current_program_space->exec_bfd ())
 980     print_section_info (&current_program_space->target_sections (),
 981                         current_program_space->exec_bfd ());
 982   else
 983     puts_filtered (_("\t<no file loaded>\n"));
 984 }
 985
 986 static void
 987 set_section_command (const char *args, int from_tty)
 988 {
 989   const char *secname;
 990
 991   if (args == 0)
 992     error (_("Must specify section name and its virtual address"));
 993
 994   /* Parse out section name.  */
 995   for (secname = args; !isspace (*args); args++);
 996   unsigned seclen = args - secname;
 997
 998   /* Parse out new virtual address.  */
 999   CORE_ADDR secaddr = parse_and_eval_address (args);
1000
1001   for (target_section &p : current_program_space->target_sections ())
1002     {
1003       if (!strncmp (secname, bfd_section_name (p.the_bfd_section), seclen)
1004           && bfd_section_name (p.the_bfd_section)[seclen] == '\0')
1005         {
1006           long offset = secaddr - p.addr;
1007           p.addr += offset;
1008           p.endaddr += offset;
1009           if (from_tty)
1010             exec_ops.files_info ();
1011           return;
1012         }
1013     }
1014
1015   std::string secprint (secname, seclen);
1016   error (_("Section %s not found"), secprint.c_str ());
1017 }
1018
1019 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1020    it to ADDRESS.  */
1021
1022 void
1023 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
1024 {
1025   for (target_section &p : current_program_space->target_sections ())
1026     {
1027       if (filename_cmp (filename,
1028                         bfd_get_filename (p.the_bfd_section->owner)) == 0
1029           && index == p.the_bfd_section->index)
1030         {
1031           p.endaddr += address - p.addr;
1032           p.addr = address;
1033         }
1034     }
1035 }
1036
1037 bool
1038 exec_target::has_memory ()
1039 {
1040   /* We can provide memory if we have any file/target sections to read
1041      from.  */
1042   return !current_program_space->target_sections ().empty ();
1043 }
1044
1045 gdb::unique_xmalloc_ptr<char>
1046 exec_target::make_corefile_notes (bfd *obfd, int *note_size)
1047 {
1048   error (_("Can't create a corefile"));
1049 }
1050
1051 int
1052 exec_target::find_memory_regions (find_memory_region_ftype func, void *data)
1053 {
1054   return objfile_find_memory_regions (this, func, data);
1055 }
1056
1057 void _initialize_exec ();
1058 void
1059 _initialize_exec ()
1060 {
1061   struct cmd_list_element *c;
1062
1063   if (!dbx_commands)
1064     {
1065       c = add_cmd ("file", class_files, file_command, _("\
1066 Use FILE as program to be debugged.\n\
1067 It is read for its symbols, for getting the contents of pure memory,\n\
1068 and it is the program executed when you use the `run' command.\n\
1069 If FILE cannot be found as specified, your execution directory path\n\
1070 ($PATH) is searched for a command of that name.\n\
1071 No arg means to have no executable file and no symbols."), &cmdlist);
1072       set_cmd_completer (c, filename_completer);
1073     }
1074
1075   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
1076 Use FILE as program for getting contents of pure memory.\n\
1077 If FILE cannot be found as specified, your execution directory path\n\
1078 is searched for a command of that name.\n\
1079 No arg means have no executable file."), &cmdlist);
1080   set_cmd_completer (c, filename_completer);
1081
1082   add_com ("section", class_files, set_section_command, _("\
1083 Change the base address of section SECTION of the exec file to ADDR.\n\
1084 This can be used if the exec file does not contain section addresses,\n\
1085 (such as in the a.out format), or when the addresses specified in the\n\
1086 file itself are wrong.  Each section must be changed separately.  The\n\
1087 ``info files'' command lists all the sections and their addresses."));
1088
1089   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
1090 Set writing into executable and core files."), _("\
1091 Show writing into executable and core files."), NULL,
1092                            NULL,
1093                            show_write_files,
1094                            &setlist, &showlist);
1095
1096   add_setshow_enum_cmd ("exec-file-mismatch", class_support,
1097                         exec_file_mismatch_names,
1098                         &exec_file_mismatch,
1099                         _("\
1100 Set exec-file-mismatch handling (ask|warn|off)."),
1101                         _("\
1102 Show exec-file-mismatch handling (ask|warn|off)."),
1103                         _("\
1104 Specifies how to handle a mismatch between the current exec-file\n\
1105 loaded by GDB and the exec-file automatically determined when attaching\n\
1106 to a process:\n\n\
1107  ask  - warn the user and ask whether to load the determined exec-file.\n\
1108  warn - warn the user, but do not change the exec-file.\n\
1109  off  - do not check for mismatch.\n\
1110 \n\
1111 GDB detects a mismatch by comparing the build IDs of the files.\n\
1112 If the user confirms loading the determined exec-file, then its symbols\n\
1113 will be loaded as well."),
1114                         set_exec_file_mismatch_command,
1115                         show_exec_file_mismatch_command,
1116                         &setlist, &showlist);
1117
1118   add_target (exec_target_info, exec_target_open, filename_completer);
1119 }