gdb/exec.c

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