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