gdb/exec.c

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