gdb/exec.c

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