gdb/exec.c

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