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