contrib/gdb-7/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, 2011
   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 "filenames.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "completer.h"
  32 #include "value.h"
  33 #include "exec.h"
  34 #include "observer.h"
  35 #include "arch-utils.h"
  36 #include "gdbthread.h"
  37 #include "progspace.h"
  38
  39 #include <fcntl.h>
  40 #include "readline/readline.h"
  41 #include "gdb_string.h"
  42
  43 #include "gdbcore.h"
  44
  45 #include <ctype.h>
  46 #include "gdb_stat.h"
  47
  48 #include "xcoffsolib.h"
  49
  50 struct vmap *map_vmap (bfd *, bfd *);
  51
  52 void (*deprecated_file_changed_hook) (char *);
  53
  54 /* Prototypes for local functions */
  55
  56 static void file_command (char *, int);
  57
  58 static void set_section_command (char *, int);
  59
  60 static void exec_files_info (struct target_ops *);
  61
  62 static void init_exec_ops (void);
  63
  64 void _initialize_exec (void);
  65
  66 /* The target vector for executable files.  */
  67
  68 struct target_ops exec_ops;
  69
  70 /* True if the exec target is pushed on the stack.  */
  71 static int using_exec_ops;
  72
  73 /* Whether to open exec and core files read-only or read-write.  */
  74
  75 int write_files = 0;
  76 static void
  77 show_write_files (struct ui_file *file, int from_tty,
  78                   struct cmd_list_element *c, const char *value)
  79 {
  80   fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
  81                     value);
  82 }
  83
  84
  85 struct vmap *vmap;
  86
  87 static void
  88 exec_open (char *args, int from_tty)
  89 {
  90   target_preopen (from_tty);
  91   exec_file_attach (args, from_tty);
  92 }
  93
  94 /* Close and clear exec_bfd.  If we end up with no target sections to
  95    read memory from, this unpushes the exec_ops target.  */
  96
  97 void
  98 exec_close (void)
  99 {
 100   if (exec_bfd)
 101     {
 102       bfd *abfd = exec_bfd;
 103       char *name = bfd_get_filename (abfd);
 104
 105       gdb_bfd_close_or_warn (abfd);
 106       xfree (name);
 107
 108       /* Removing target sections may close the exec_ops target.
 109          Clear exec_bfd before doing so to prevent recursion.  */
 110       exec_bfd = NULL;
 111       exec_bfd_mtime = 0;
 112
 113       remove_target_sections (abfd);
 114     }
 115 }
 116
 117 /* This is the target_close implementation.  Clears all target
 118    sections and closes all executable bfds from all program spaces.  */
 119
 120 static void
 121 exec_close_1 (int quitting)
 122 {
 123   int need_symtab_cleanup = 0;
 124   struct vmap *vp, *nxt;
 125
 126   using_exec_ops = 0;
 127
 128   for (nxt = vmap; nxt != NULL;)
 129     {
 130       vp = nxt;
 131       nxt = vp->nxt;
 132
 133       /* if there is an objfile associated with this bfd,
 134          free_objfile() will do proper cleanup of objfile *and* bfd.  */
 135
 136       if (vp->objfile)
 137         {
 138           free_objfile (vp->objfile);
 139           need_symtab_cleanup = 1;
 140         }
 141       else if (vp->bfd != exec_bfd)
 142         /* FIXME-leak: We should be freeing vp->name too, I think.  */
 143         gdb_bfd_close_or_warn (vp->bfd);
 144
 145       xfree (vp);
 146     }
 147
 148   vmap = NULL;
 149
 150   {
 151     struct program_space *ss;
 152     struct cleanup *old_chain;
 153
 154     old_chain = save_current_program_space ();
 155     ALL_PSPACES (ss)
 156     {
 157       set_current_program_space (ss);
 158
 159       /* Delete all target sections.  */
 160       resize_section_table
 161         (current_target_sections,
 162          -resize_section_table (current_target_sections, 0));
 163
 164       exec_close ();
 165     }
 166
 167     do_cleanups (old_chain);
 168   }
 169 }
 170
 171 void
 172 exec_file_clear (int from_tty)
 173 {
 174   /* Remove exec file.  */
 175   exec_close ();
 176
 177   if (from_tty)
 178     printf_unfiltered (_("No executable file now.\n"));
 179 }
 180
 181 /* Set FILENAME as the new exec file.
 182
 183    This function is intended to be behave essentially the same
 184    as exec_file_command, except that the latter will detect when
 185    a target is being debugged, and will ask the user whether it
 186    should be shut down first.  (If the answer is "no", then the
 187    new file is ignored.)
 188
 189    This file is used by exec_file_command, to do the work of opening
 190    and processing the exec file after any prompting has happened.
 191
 192    And, it is used by child_attach, when the attach command was
 193    given a pid but not a exec pathname, and the attach command could
 194    figure out the pathname from the pid.  (In this case, we shouldn't
 195    ask the user whether the current target should be shut down --
 196    we're supplying the exec pathname late for good reason.)  */
 197
 198 void
 199 exec_file_attach (char *filename, int from_tty)
 200 {
 201   /* Remove any previous exec file.  */
 202   exec_close ();
 203
 204   /* Now open and digest the file the user requested, if any.  */
 205
 206   if (!filename)
 207     {
 208       if (from_tty)
 209         printf_unfiltered (_("No executable file now.\n"));
 210
 211       set_gdbarch_from_file (NULL);
 212     }
 213   else
 214     {
 215       struct cleanup *cleanups;
 216       char *scratch_pathname;
 217       int scratch_chan;
 218       struct target_section *sections = NULL, *sections_end = NULL;
 219       char **matching;
 220
 221       scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
 222                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
 223                             &scratch_pathname);
 224 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 225       if (scratch_chan < 0)
 226         {
 227           char *exename = alloca (strlen (filename) + 5);
 228
 229           strcat (strcpy (exename, filename), ".exe");
 230           scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
 231              write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
 232              &scratch_pathname);
 233         }
 234 #endif
 235       if (scratch_chan < 0)
 236         perror_with_name (filename);
 237       exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
 238                             write_files ? FOPEN_RUB : FOPEN_RB,
 239                             scratch_chan);
 240
 241       if (!exec_bfd)
 242         {
 243           close (scratch_chan);
 244           error (_("\"%s\": could not open as an executable file: %s"),
 245                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 246         }
 247
 248       /* At this point, scratch_pathname and exec_bfd->name both point to the
 249          same malloc'd string.  However exec_close() will attempt to free it
 250          via the exec_bfd->name pointer, so we need to make another copy and
 251          leave exec_bfd as the new owner of the original copy.  */
 252       scratch_pathname = xstrdup (scratch_pathname);
 253       cleanups = make_cleanup (xfree, scratch_pathname);
 254
 255       if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
 256         {
 257           /* Make sure to close exec_bfd, or else "run" might try to use
 258              it.  */
 259           exec_close ();
 260           error (_("\"%s\": not in executable format: %s"),
 261                  scratch_pathname,
 262                  gdb_bfd_errmsg (bfd_get_error (), matching));
 263         }
 264
 265       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 266          way to accomplish.  */
 267 #ifdef DEPRECATED_IBM6000_TARGET
 268       /* Setup initial vmap.  */
 269
 270       map_vmap (exec_bfd, 0);
 271       if (vmap == NULL)
 272         {
 273           /* Make sure to close exec_bfd, or else "run" might try to use
 274              it.  */
 275           exec_close ();
 276           error (_("\"%s\": can't find the file sections: %s"),
 277                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 278         }
 279 #endif /* DEPRECATED_IBM6000_TARGET */
 280
 281       if (build_section_table (exec_bfd, &sections, &sections_end))
 282         {
 283           /* Make sure to close exec_bfd, or else "run" might try to use
 284              it.  */
 285           exec_close ();
 286           error (_("\"%s\": can't find the file sections: %s"),
 287                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 288         }
 289
 290       exec_bfd_mtime = bfd_get_mtime (exec_bfd);
 291
 292       validate_files ();
 293
 294       set_gdbarch_from_file (exec_bfd);
 295
 296       /* Add the executable's sections to the current address spaces'
 297          list of sections.  This possibly pushes the exec_ops
 298          target.  */
 299       add_target_sections (sections, sections_end);
 300       xfree (sections);
 301
 302       /* Tell display code (if any) about the changed file name.  */
 303       if (deprecated_exec_file_display_hook)
 304         (*deprecated_exec_file_display_hook) (filename);
 305
 306       do_cleanups (cleanups);
 307     }
 308   bfd_cache_close_all ();
 309   observer_notify_executable_changed ();
 310 }
 311
 312 /*  Process the first arg in ARGS as the new exec file.
 313
 314    Note that we have to explicitly ignore additional args, since we can
 315    be called from file_command(), which also calls symbol_file_command()
 316    which can take multiple args.
 317
 318    If ARGS is NULL, we just want to close the exec file.  */
 319
 320 static void
 321 exec_file_command (char *args, int from_tty)
 322 {
 323   char **argv;
 324   char *filename;
 325
 326   if (from_tty && target_has_execution
 327       && !query (_("A program is being debugged already.\n"
 328                    "Are you sure you want to change the file? ")))
 329     error (_("File not changed."));
 330
 331   if (args)
 332     {
 333       struct cleanup *cleanups;
 334
 335       /* Scan through the args and pick up the first non option arg
 336          as the filename.  */
 337
 338       argv = gdb_buildargv (args);
 339       cleanups = make_cleanup_freeargv (argv);
 340
 341       for (; (*argv != NULL) && (**argv == '-'); argv++)
 342         {;
 343         }
 344       if (*argv == NULL)
 345         error (_("No executable file name was specified"));
 346
 347       filename = tilde_expand (*argv);
 348       make_cleanup (xfree, filename);
 349       exec_file_attach (filename, from_tty);
 350
 351       do_cleanups (cleanups);
 352     }
 353   else
 354     exec_file_attach (NULL, from_tty);
 355 }
 356
 357 /* Set both the exec file and the symbol file, in one command.
 358    What a novelty.  Why did GDB go through four major releases before this
 359    command was added?  */
 360
 361 static void
 362 file_command (char *arg, int from_tty)
 363 {
 364   /* FIXME, if we lose on reading the symbol file, we should revert
 365      the exec file, but that's rough.  */
 366   exec_file_command (arg, from_tty);
 367   symbol_file_command (arg, from_tty);
 368   if (deprecated_file_changed_hook)
 369     deprecated_file_changed_hook (arg);
 370 }
 371 \f
 372
 373 /* Locate all mappable sections of a BFD file.
 374    table_pp_char is a char * to get it through bfd_map_over_sections;
 375    we cast it back to its proper type.  */
 376
 377 static void
 378 add_to_section_table (bfd *abfd, struct bfd_section *asect,
 379                       void *table_pp_char)
 380 {
 381   struct target_section **table_pp = (struct target_section **) table_pp_char;
 382   flagword aflag;
 383
 384   /* Check the section flags, but do not discard zero-length sections, since
 385      some symbols may still be attached to this section.  For instance, we
 386      encountered on sparc-solaris 2.10 a shared library with an empty .bss
 387      section to which a symbol named "_end" was attached.  The address
 388      of this symbol still needs to be relocated.  */
 389   aflag = bfd_get_section_flags (abfd, asect);
 390   if (!(aflag & SEC_ALLOC))
 391     return;
 392
 393   (*table_pp)->bfd = abfd;
 394   (*table_pp)->the_bfd_section = asect;
 395   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 396   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 397   (*table_pp)++;
 398 }
 399
 400 int
 401 resize_section_table (struct target_section_table *table, int num_added)
 402 {
 403   int old_count;
 404   int new_count;
 405
 406   old_count = table->sections_end - table->sections;
 407
 408   if (!num_added)
 409     return old_count;
 410
 411   new_count = num_added + old_count;
 412
 413   if (new_count)
 414     {
 415       table->sections = xrealloc (table->sections,
 416                                   sizeof (struct target_section) * new_count);
 417       table->sections_end = table->sections + new_count;
 418     }
 419   else
 420     {
 421       xfree (table->sections);
 422       table->sections = table->sections_end = NULL;
 423     }
 424
 425   return old_count;
 426 }
 427
 428 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 429    Returns 0 if OK, 1 on error.  */
 430
 431 int
 432 build_section_table (struct bfd *some_bfd, struct target_section **start,
 433                      struct target_section **end)
 434 {
 435   unsigned count;
 436
 437   count = bfd_count_sections (some_bfd);
 438   if (*start)
 439     xfree (* start);
 440   *start = (struct target_section *) xmalloc (count * sizeof (**start));
 441   *end = *start;
 442   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 443   if (*end > *start + count)
 444     internal_error (__FILE__, __LINE__,
 445                     _("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
 466       memcpy (table->sections + space,
 467               sections, count * sizeof (sections[0]));
 468
 469       /* If these are the first file sections we can provide memory
 470          from, push the file_stratum target.  */
 471       if (!using_exec_ops)
 472         {
 473           using_exec_ops = 1;
 474           push_target (&exec_ops);
 475         }
 476     }
 477 }
 478
 479 /* Remove all target sections taken from ABFD.  */
 480
 481 void
 482 remove_target_sections (bfd *abfd)
 483 {
 484   struct target_section *src, *dest;
 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 VEC(mem_range_s) *
 578 section_table_available_memory (VEC(mem_range_s) *memory,
 579                                 CORE_ADDR memaddr, ULONGEST len,
 580                                 struct target_section *sections,
 581                                 struct target_section *sections_end)
 582 {
 583   struct target_section *p;
 584
 585   for (p = sections; p < sections_end; p++)
 586     {
 587       if ((bfd_get_section_flags (p->bfd, p->the_bfd_section)
 588            & SEC_READONLY) == 0)
 589         continue;
 590
 591       /* Copy the meta-data, adjusted.  */
 592       if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
 593         {
 594           ULONGEST lo1, hi1, lo2, hi2;
 595           struct mem_range *r;
 596
 597           lo1 = memaddr;
 598           hi1 = memaddr + len;
 599
 600           lo2 = p->addr;
 601           hi2 = p->endaddr;
 602
 603           r = VEC_safe_push (mem_range_s, memory, NULL);
 604
 605           r->start = max (lo1, lo2);
 606           r->length = min (hi1, hi2) - r->start;
 607         }
 608     }
 609
 610   return memory;
 611 }
 612
 613 int
 614 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
 615                                    ULONGEST offset, LONGEST len,
 616                                    struct target_section *sections,
 617                                    struct target_section *sections_end,
 618                                    const char *section_name)
 619 {
 620   int res;
 621   struct target_section *p;
 622   ULONGEST memaddr = offset;
 623   ULONGEST memend = memaddr + len;
 624
 625   if (len <= 0)
 626     internal_error (__FILE__, __LINE__,
 627                     _("failed internal consistency check"));
 628
 629   for (p = sections; p < sections_end; p++)
 630     {
 631       if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0)
 632         continue;               /* not the section we need.  */
 633       if (memaddr >= p->addr)
 634         {
 635           if (memend <= p->endaddr)
 636             {
 637               /* Entire transfer is within this section.  */
 638               if (writebuf)
 639                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 640                                                 writebuf, memaddr - p->addr,
 641                                                 len);
 642               else
 643                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 644                                                 readbuf, memaddr - p->addr,
 645                                                 len);
 646               return (res != 0) ? len : 0;
 647             }
 648           else if (memaddr >= p->endaddr)
 649             {
 650               /* This section ends before the transfer starts.  */
 651               continue;
 652             }
 653           else
 654             {
 655               /* This section overlaps the transfer.  Just do half.  */
 656               len = p->endaddr - memaddr;
 657               if (writebuf)
 658                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 659                                                 writebuf, memaddr - p->addr,
 660                                                 len);
 661               else
 662                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 663                                                 readbuf, memaddr - p->addr,
 664                                                 len);
 665               return (res != 0) ? len : 0;
 666             }
 667         }
 668     }
 669
 670   return 0;                     /* We can't help.  */
 671 }
 672
 673 struct target_section_table *
 674 exec_get_section_table (struct target_ops *ops)
 675 {
 676   return current_target_sections;
 677 }
 678
 679 static LONGEST
 680 exec_xfer_partial (struct target_ops *ops, enum target_object object,
 681                    const char *annex, gdb_byte *readbuf,
 682                    const gdb_byte *writebuf,
 683                    ULONGEST offset, LONGEST len)
 684 {
 685   struct target_section_table *table = target_get_section_table (ops);
 686
 687   if (object == TARGET_OBJECT_MEMORY)
 688     return section_table_xfer_memory_partial (readbuf, writebuf,
 689                                               offset, len,
 690                                               table->sections,
 691                                               table->sections_end,
 692                                               NULL);
 693   else
 694     return -1;
 695 }
 696 \f
 697
 698 void
 699 print_section_info (struct target_section_table *t, bfd *abfd)
 700 {
 701   struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
 702   struct target_section *p;
 703   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 704   int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
 705
 706   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 707   wrap_here ("        ");
 708   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 709   if (abfd == exec_bfd)
 710     {
 711       /* gcc-3.4 does not like the initialization in
 712          <p == t->sections_end>.  */
 713       bfd_vma displacement = 0;
 714       bfd_vma entry_point;
 715
 716       for (p = t->sections; p < t->sections_end; p++)
 717         {
 718           asection *asect = p->the_bfd_section;
 719
 720           if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
 721               != (SEC_ALLOC | SEC_LOAD))
 722             continue;
 723
 724           if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
 725               && abfd->start_address < (bfd_get_section_vma (abfd, asect)
 726                                         + bfd_get_section_size (asect)))
 727             {
 728               displacement = p->addr - bfd_get_section_vma (abfd, asect);
 729               break;
 730             }
 731         }
 732       if (p == t->sections_end)
 733         warning (_("Cannot find section for the entry point of %s."),
 734                  bfd_get_filename (abfd));
 735
 736       entry_point = gdbarch_addr_bits_remove (gdbarch,
 737                                               bfd_get_start_address (abfd)
 738                                                 + displacement);
 739       printf_filtered (_("\tEntry point: %s\n"),
 740                        paddress (gdbarch, entry_point));
 741     }
 742   for (p = t->sections; p < t->sections_end; p++)
 743     {
 744       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 745       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 746
 747       /* FIXME: A format of "08l" is not wide enough for file offsets
 748          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 749          since most output will then be much wider than necessary.  It
 750          may make sense to test the size of the file and choose the
 751          format string accordingly.  */
 752       /* FIXME: i18n: Need to rewrite this sentence.  */
 753       if (info_verbose)
 754         printf_filtered (" @ %s",
 755                          hex_string_custom (p->the_bfd_section->filepos, 8));
 756       printf_filtered (" is %s", bfd_section_name (p->bfd,
 757                                                    p->the_bfd_section));
 758       if (p->bfd != abfd)
 759         printf_filtered (" in %s", bfd_get_filename (p->bfd));
 760       printf_filtered ("\n");
 761     }
 762 }
 763
 764 static void
 765 exec_files_info (struct target_ops *t)
 766 {
 767   print_section_info (current_target_sections, exec_bfd);
 768
 769   if (vmap)
 770     {
 771       int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
 772       struct vmap *vp;
 773
 774       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
 775       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 776                          addr_size * 2, "tstart",
 777                          addr_size * 2, "tend",
 778                          addr_size * 2, "dstart",
 779                          addr_size * 2, "dend",
 780                          "section",
 781                          "file(member)");
 782
 783       for (vp = vmap; vp; vp = vp->nxt)
 784         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 785                            phex (vp->tstart, addr_size),
 786                            phex (vp->tend, addr_size),
 787                            phex (vp->dstart, addr_size),
 788                            phex (vp->dend, addr_size),
 789                            vp->name,
 790                            *vp->member ? "(" : "", vp->member,
 791                            *vp->member ? ")" : "");
 792     }
 793 }
 794
 795 static void
 796 set_section_command (char *args, int from_tty)
 797 {
 798   struct target_section *p;
 799   char *secname;
 800   unsigned seclen;
 801   unsigned long secaddr;
 802   char secprint[100];
 803   long offset;
 804   struct target_section_table *table;
 805
 806   if (args == 0)
 807     error (_("Must specify section name and its virtual address"));
 808
 809   /* Parse out section name.  */
 810   for (secname = args; !isspace (*args); args++);
 811   seclen = args - secname;
 812
 813   /* Parse out new virtual address.  */
 814   secaddr = parse_and_eval_address (args);
 815
 816   table = current_target_sections;
 817   for (p = table->sections; p < table->sections_end; p++)
 818     {
 819       if (!strncmp (secname, bfd_section_name (exec_bfd,
 820                                                p->the_bfd_section), seclen)
 821           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 822         {
 823           offset = secaddr - p->addr;
 824           p->addr += offset;
 825           p->endaddr += offset;
 826           if (from_tty)
 827             exec_files_info (&exec_ops);
 828           return;
 829         }
 830     }
 831   if (seclen >= sizeof (secprint))
 832     seclen = sizeof (secprint) - 1;
 833   strncpy (secprint, secname, seclen);
 834   secprint[seclen] = '\0';
 835   error (_("Section %s not found"), secprint);
 836 }
 837
 838 /* If we can find a section in FILENAME with BFD index INDEX, adjust
 839    it to ADDRESS.  */
 840
 841 void
 842 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 843 {
 844   struct target_section *p;
 845   struct target_section_table *table;
 846
 847   table = current_target_sections;
 848   for (p = table->sections; p < table->sections_end; p++)
 849     {
 850       if (filename_cmp (filename, p->bfd->filename) == 0
 851           && index == p->the_bfd_section->index)
 852         {
 853           p->endaddr += address - p->addr;
 854           p->addr = address;
 855         }
 856     }
 857 }
 858
 859 /* If mourn is being called in all the right places, this could be say
 860    `gdb internal error' (since generic_mourn calls
 861    breakpoint_init_inferior).  */
 862
 863 static int
 864 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 865 {
 866   return 0;
 867 }
 868
 869 static int
 870 exec_has_memory (struct target_ops *ops)
 871 {
 872   /* We can provide memory if we have any file/target sections to read
 873      from.  */
 874   return (current_target_sections->sections
 875           != current_target_sections->sections_end);
 876 }
 877
 878 /* Find mapped memory.  */
 879
 880 extern void
 881 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *))
 882 {
 883   exec_ops.to_find_memory_regions = func;
 884 }
 885
 886 static char *exec_make_note_section (bfd *, int *);
 887
 888 /* Fill in the exec file target vector.  Very few entries need to be
 889    defined.  */
 890
 891 static void
 892 init_exec_ops (void)
 893 {
 894   exec_ops.to_shortname = "exec";
 895   exec_ops.to_longname = "Local exec file";
 896   exec_ops.to_doc = "Use an executable file as a target.\n\
 897 Specify the filename of the executable file.";
 898   exec_ops.to_open = exec_open;
 899   exec_ops.to_close = exec_close_1;
 900   exec_ops.to_attach = find_default_attach;
 901   exec_ops.to_xfer_partial = exec_xfer_partial;
 902   exec_ops.to_get_section_table = exec_get_section_table;
 903   exec_ops.to_files_info = exec_files_info;
 904   exec_ops.to_insert_breakpoint = ignore;
 905   exec_ops.to_remove_breakpoint = ignore;
 906   exec_ops.to_create_inferior = find_default_create_inferior;
 907   exec_ops.to_stratum = file_stratum;
 908   exec_ops.to_has_memory = exec_has_memory;
 909   exec_ops.to_make_corefile_notes = exec_make_note_section;
 910   exec_ops.to_magic = OPS_MAGIC;
 911 }
 912
 913 void
 914 _initialize_exec (void)
 915 {
 916   struct cmd_list_element *c;
 917
 918   init_exec_ops ();
 919
 920   if (!dbx_commands)
 921     {
 922       c = add_cmd ("file", class_files, file_command, _("\
 923 Use FILE as program to be debugged.\n\
 924 It is read for its symbols, for getting the contents of pure memory,\n\
 925 and it is the program executed when you use the `run' command.\n\
 926 If FILE cannot be found as specified, your execution directory path\n\
 927 ($PATH) is searched for a command of that name.\n\
 928 No arg means to have no executable file and no symbols."), &cmdlist);
 929       set_cmd_completer (c, filename_completer);
 930     }
 931
 932   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
 933 Use FILE as program for getting contents of pure memory.\n\
 934 If FILE cannot be found as specified, your execution directory path\n\
 935 is searched for a command of that name.\n\
 936 No arg means have no executable file."), &cmdlist);
 937   set_cmd_completer (c, filename_completer);
 938
 939   add_com ("section", class_files, set_section_command, _("\
 940 Change the base address of section SECTION of the exec file to ADDR.\n\
 941 This can be used if the exec file does not contain section addresses,\n\
 942 (such as in the a.out format), or when the addresses specified in the\n\
 943 file itself are wrong.  Each section must be changed separately.  The\n\
 944 ``info files'' command lists all the sections and their addresses."));
 945
 946   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
 947 Set writing into executable and core files."), _("\
 948 Show writing into executable and core files."), NULL,
 949                            NULL,
 950                            show_write_files,
 951                            &setlist, &showlist);
 952
 953   add_target (&exec_ops);
 954 }
 955
 956 static char *
 957 exec_make_note_section (bfd *obfd, int *note_size)
 958 {
 959   error (_("Can't create a corefile"));
 960 }