gdb/exec.c

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