gdb/exec.c

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