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