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     {
 678       /* gcc-3.4 does not like the initialization in <p == t->sections_end>.  */
 679       bfd_vma displacement = 0;
 680
 681       for (p = t->sections; p < t->sections_end; p++)
 682         {
 683           asection *asect = p->the_bfd_section;
 684
 685           if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
 686               != (SEC_ALLOC | SEC_LOAD))
 687             continue;
 688
 689           if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
 690               && abfd->start_address < (bfd_get_section_vma (abfd, asect)
 691                                         + bfd_get_section_size (asect)))
 692             {
 693               displacement = p->addr - bfd_get_section_vma (abfd, asect);
 694               break;
 695             }
 696         }
 697       if (p == t->sections_end)
 698         warning (_("Cannot find section for the entry point of %s.\n"),
 699                  bfd_get_filename (abfd));
 700
 701       printf_filtered (_("\tEntry point: %s\n"),
 702                        paddress (gdbarch, (bfd_get_start_address (abfd)
 703                                            + displacement)));
 704     }
 705   for (p = t->sections; p < t->sections_end; p++)
 706     {
 707       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 708       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 709
 710       /* FIXME: A format of "08l" is not wide enough for file offsets
 711          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 712          since most output will then be much wider than necessary.  It
 713          may make sense to test the size of the file and choose the
 714          format string accordingly.  */
 715       /* FIXME: i18n: Need to rewrite this sentence.  */
 716       if (info_verbose)
 717         printf_filtered (" @ %s",
 718                          hex_string_custom (p->the_bfd_section->filepos, 8));
 719       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 720       if (p->bfd != abfd)
 721         printf_filtered (" in %s", bfd_get_filename (p->bfd));
 722       printf_filtered ("\n");
 723     }
 724 }
 725
 726 static void
 727 exec_files_info (struct target_ops *t)
 728 {
 729   print_section_info (current_target_sections, exec_bfd);
 730
 731   if (vmap)
 732     {
 733       int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
 734       struct vmap *vp;
 735
 736       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
 737       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 738                          addr_size * 2, "tstart",
 739                          addr_size * 2, "tend",
 740                          addr_size * 2, "dstart",
 741                          addr_size * 2, "dend",
 742                          "section",
 743                          "file(member)");
 744
 745       for (vp = vmap; vp; vp = vp->nxt)
 746         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 747                            phex (vp->tstart, addr_size),
 748                            phex (vp->tend, addr_size),
 749                            phex (vp->dstart, addr_size),
 750                            phex (vp->dend, addr_size),
 751                            vp->name,
 752                            *vp->member ? "(" : "", vp->member,
 753                            *vp->member ? ")" : "");
 754     }
 755 }
 756
 757 static void
 758 set_section_command (char *args, int from_tty)
 759 {
 760   struct target_section *p;
 761   char *secname;
 762   unsigned seclen;
 763   unsigned long secaddr;
 764   char secprint[100];
 765   long offset;
 766   struct target_section_table *table;
 767
 768   if (args == 0)
 769     error (_("Must specify section name and its virtual address"));
 770
 771   /* Parse out section name */
 772   for (secname = args; !isspace (*args); args++);
 773   seclen = args - secname;
 774
 775   /* Parse out new virtual address */
 776   secaddr = parse_and_eval_address (args);
 777
 778   table = current_target_sections;
 779   for (p = table->sections; p < table->sections_end; p++)
 780     {
 781       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 782           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 783         {
 784           offset = secaddr - p->addr;
 785           p->addr += offset;
 786           p->endaddr += offset;
 787           if (from_tty)
 788             exec_files_info (&exec_ops);
 789           return;
 790         }
 791     }
 792   if (seclen >= sizeof (secprint))
 793     seclen = sizeof (secprint) - 1;
 794   strncpy (secprint, secname, seclen);
 795   secprint[seclen] = '\0';
 796   error (_("Section %s not found"), secprint);
 797 }
 798
 799 /* If we can find a section in FILENAME with BFD index INDEX, adjust
 800    it to ADDRESS.  */
 801
 802 void
 803 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 804 {
 805   struct target_section *p;
 806   struct target_section_table *table;
 807
 808   table = current_target_sections;
 809   for (p = table->sections; p < table->sections_end; p++)
 810     {
 811       if (strcmp (filename, p->bfd->filename) == 0
 812           && index == p->the_bfd_section->index)
 813         {
 814           p->endaddr += address - p->addr;
 815           p->addr = address;
 816         }
 817     }
 818 }
 819
 820 /* If mourn is being called in all the right places, this could be say
 821    `gdb internal error' (since generic_mourn calls
 822    breakpoint_init_inferior).  */
 823
 824 static int
 825 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 826 {
 827   return 0;
 828 }
 829
 830 static int
 831 exec_has_memory (struct target_ops *ops)
 832 {
 833   /* We can provide memory if we have any file/target sections to read
 834      from.  */
 835   return (current_target_sections->sections
 836           != current_target_sections->sections_end);
 837 }
 838
 839 /* Find mapped memory. */
 840
 841 extern void
 842 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
 843                                                     unsigned long,
 844                                                     int, int, int,
 845                                                     void *),
 846                                            void *))
 847 {
 848   exec_ops.to_find_memory_regions = func;
 849 }
 850
 851 static char *exec_make_note_section (bfd *, int *);
 852
 853 /* Fill in the exec file target vector.  Very few entries need to be
 854    defined.  */
 855
 856 static void
 857 init_exec_ops (void)
 858 {
 859   exec_ops.to_shortname = "exec";
 860   exec_ops.to_longname = "Local exec file";
 861   exec_ops.to_doc = "Use an executable file as a target.\n\
 862 Specify the filename of the executable file.";
 863   exec_ops.to_open = exec_open;
 864   exec_ops.to_close = exec_close_1;
 865   exec_ops.to_attach = find_default_attach;
 866   exec_ops.to_xfer_partial = exec_xfer_partial;
 867   exec_ops.to_get_section_table = exec_get_section_table;
 868   exec_ops.to_files_info = exec_files_info;
 869   exec_ops.to_insert_breakpoint = ignore;
 870   exec_ops.to_remove_breakpoint = ignore;
 871   exec_ops.to_create_inferior = find_default_create_inferior;
 872   exec_ops.to_stratum = file_stratum;
 873   exec_ops.to_has_memory = exec_has_memory;
 874   exec_ops.to_make_corefile_notes = exec_make_note_section;
 875   exec_ops.to_magic = OPS_MAGIC;
 876 }
 877
 878 void
 879 _initialize_exec (void)
 880 {
 881   struct cmd_list_element *c;
 882
 883   init_exec_ops ();
 884
 885   if (!dbx_commands)
 886     {
 887       c = add_cmd ("file", class_files, file_command, _("\
 888 Use FILE as program to be debugged.\n\
 889 It is read for its symbols, for getting the contents of pure memory,\n\
 890 and it is the program executed when you use the `run' command.\n\
 891 If FILE cannot be found as specified, your execution directory path\n\
 892 ($PATH) is searched for a command of that name.\n\
 893 No arg means to have no executable file and no symbols."), &cmdlist);
 894       set_cmd_completer (c, filename_completer);
 895     }
 896
 897   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
 898 Use FILE as program for getting contents of pure memory.\n\
 899 If FILE cannot be found as specified, your execution directory path\n\
 900 is searched for a command of that name.\n\
 901 No arg means have no executable file."), &cmdlist);
 902   set_cmd_completer (c, filename_completer);
 903
 904   add_com ("section", class_files, set_section_command, _("\
 905 Change the base address of section SECTION of the exec file to ADDR.\n\
 906 This can be used if the exec file does not contain section addresses,\n\
 907 (such as in the a.out format), or when the addresses specified in the\n\
 908 file itself are wrong.  Each section must be changed separately.  The\n\
 909 ``info files'' command lists all the sections and their addresses."));
 910
 911   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
 912 Set writing into executable and core files."), _("\
 913 Show writing into executable and core files."), NULL,
 914                            NULL,
 915                            show_write_files,
 916                            &setlist, &showlist);
 917
 918   add_target (&exec_ops);
 919 }
 920
 921 static char *
 922 exec_make_note_section (bfd *obfd, int *note_size)
 923 {
 924   error (_("Can't create a corefile"));
 925 }