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