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