gdb/exec.c

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