gdb/exec.c

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