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