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