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