gdb/exec.c

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