gdb/exec.c

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