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