gdb/exec.c

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