gdb/exec.c

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