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