gdb/exec.c

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