gdb/exec.c

   1 /* Work with executable files, for GDB.
   2    Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1997, 1998
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "target.h"
  26 #include "gdbcmd.h"
  27 #include "language.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30
  31 #ifdef USG
  32 #include <sys/types.h>
  33 #endif
  34
  35 #include <fcntl.h>
  36 #include "gdb_string.h"
  37
  38 #include "gdbcore.h"
  39
  40 #include <ctype.h>
  41 #include "gdb_stat.h"
  42 #ifndef O_BINARY
  43 #define O_BINARY 0
  44 #endif
  45
  46 #include "xcoffsolib.h"
  47
  48 struct vmap *map_vmap (bfd *, bfd *);
  49
  50 void (*file_changed_hook) PARAMS ((char *));
  51
  52 /* Prototypes for local functions */
  53
  54 static void add_to_section_table (bfd *, sec_ptr, PTR);
  55
  56 static void exec_close (int);
  57
  58 static void file_command (char *, int);
  59
  60 static void set_section_command (char *, int);
  61
  62 static void exec_files_info (struct target_ops *);
  63
  64 static void bfdsec_to_vmap (bfd *, sec_ptr, PTR);
  65
  66 static int ignore (CORE_ADDR, char *);
  67
  68 static void init_exec_ops (void);
  69
  70 void _initialize_exec (void);
  71
  72 extern int info_verbose;
  73
  74 /* The target vector for executable files.  */
  75
  76 struct target_ops exec_ops;
  77
  78 /* The Binary File Descriptor handle for the executable file.  */
  79
  80 bfd *exec_bfd = NULL;
  81
  82 /* Whether to open exec and core files read-only or read-write.  */
  83
  84 int write_files = 0;
  85
  86 /* Text start and end addresses (KLUDGE) if needed */
  87
  88 #ifndef NEED_TEXT_START_END
  89 #define NEED_TEXT_START_END (0)
  90 #endif
  91 CORE_ADDR text_start = 0;
  92 CORE_ADDR text_end = 0;
  93
  94 struct vmap *vmap;
  95
  96 /* ARGSUSED */
  97 static void
  98 exec_close (quitting)
  99      int quitting;
 100 {
 101   int need_symtab_cleanup = 0;
 102   struct vmap *vp, *nxt;
 103
 104   for (nxt = vmap; nxt != NULL;)
 105     {
 106       vp = nxt;
 107       nxt = vp->nxt;
 108
 109       /* if there is an objfile associated with this bfd,
 110          free_objfile() will do proper cleanup of objfile *and* bfd. */
 111
 112       if (vp->objfile)
 113         {
 114           free_objfile (vp->objfile);
 115           need_symtab_cleanup = 1;
 116         }
 117       else if (vp->bfd != exec_bfd)
 118         /* FIXME-leak: We should be freeing vp->name too, I think.  */
 119         if (!bfd_close (vp->bfd))
 120           warning ("cannot close \"%s\": %s",
 121                    vp->name, bfd_errmsg (bfd_get_error ()));
 122
 123       /* FIXME: This routine is #if 0'd in symfile.c.  What should we
 124          be doing here?  Should we just free everything in
 125          vp->objfile->symtabs?  Should free_objfile do that?
 126          FIXME-as-well: free_objfile already free'd vp->name, so it isn't
 127          valid here.  */
 128       free_named_symtabs (vp->name);
 129       free (vp);
 130     }
 131
 132   vmap = NULL;
 133
 134   if (exec_bfd)
 135     {
 136       char *name = bfd_get_filename (exec_bfd);
 137
 138       if (!bfd_close (exec_bfd))
 139         warning ("cannot close \"%s\": %s",
 140                  name, bfd_errmsg (bfd_get_error ()));
 141       free (name);
 142       exec_bfd = NULL;
 143     }
 144
 145   if (exec_ops.to_sections)
 146     {
 147       free ((PTR) exec_ops.to_sections);
 148       exec_ops.to_sections = NULL;
 149       exec_ops.to_sections_end = NULL;
 150     }
 151 }
 152
 153 /*  Process the first arg in ARGS as the new exec file.
 154
 155    This function is intended to be behave essentially the same
 156    as exec_file_command, except that the latter will detect when
 157    a target is being debugged, and will ask the user whether it
 158    should be shut down first.  (If the answer is "no", then the
 159    new file is ignored.)
 160
 161    This file is used by exec_file_command, to do the work of opening
 162    and processing the exec file after any prompting has happened.
 163
 164    And, it is used by child_attach, when the attach command was
 165    given a pid but not a exec pathname, and the attach command could
 166    figure out the pathname from the pid.  (In this case, we shouldn't
 167    ask the user whether the current target should be shut down --
 168    we're supplying the exec pathname late for good reason.) */
 169
 170 void
 171 exec_file_attach (args, from_tty)
 172      char *args;
 173      int from_tty;
 174 {
 175   char **argv;
 176   char *filename;
 177
 178   /* Remove any previous exec file.  */
 179   unpush_target (&exec_ops);
 180
 181   /* Now open and digest the file the user requested, if any.  */
 182
 183   if (args)
 184     {
 185       char *scratch_pathname;
 186       int scratch_chan;
 187
 188       /* Scan through the args and pick up the first non option arg
 189          as the filename.  */
 190
 191       argv = buildargv (args);
 192       if (argv == NULL)
 193         nomem (0);
 194
 195       make_cleanup_freeargv (argv);
 196
 197       for (; (*argv != NULL) && (**argv == '-'); argv++)
 198         {;
 199         }
 200       if (*argv == NULL)
 201         error ("No executable file name was specified");
 202
 203       filename = tilde_expand (*argv);
 204       make_cleanup (free, filename);
 205
 206       scratch_chan = openp (getenv ("PATH"), 1, filename,
 207                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 208                             &scratch_pathname);
 209 #if defined(__GO32__) || defined(_WIN32)
 210       if (scratch_chan < 0)
 211         {
 212           char *exename = alloca (strlen (filename) + 5);
 213           strcat (strcpy (exename, filename), ".exe");
 214           scratch_chan = openp (getenv ("PATH"), 1, exename, write_files ?
 215              O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0, &scratch_pathname);
 216         }
 217 #endif
 218       if (scratch_chan < 0)
 219         perror_with_name (filename);
 220       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 221
 222       if (!exec_bfd)
 223         error ("\"%s\": could not open as an executable file: %s",
 224                scratch_pathname, bfd_errmsg (bfd_get_error ()));
 225
 226       /* At this point, scratch_pathname and exec_bfd->name both point to the
 227          same malloc'd string.  However exec_close() will attempt to free it
 228          via the exec_bfd->name pointer, so we need to make another copy and
 229          leave exec_bfd as the new owner of the original copy. */
 230       scratch_pathname = xstrdup (scratch_pathname);
 231       make_cleanup (free, scratch_pathname);
 232
 233       if (!bfd_check_format (exec_bfd, bfd_object))
 234         {
 235           /* Make sure to close exec_bfd, or else "run" might try to use
 236              it.  */
 237           exec_close (0);
 238           error ("\"%s\": not in executable format: %s",
 239                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 240         }
 241
 242       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 243          way to accomplish.  */
 244 #ifdef IBM6000_TARGET
 245       /* Setup initial vmap. */
 246
 247       map_vmap (exec_bfd, 0);
 248       if (vmap == NULL)
 249         {
 250           /* Make sure to close exec_bfd, or else "run" might try to use
 251              it.  */
 252           exec_close (0);
 253           error ("\"%s\": can't find the file sections: %s",
 254                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 255         }
 256 #endif /* IBM6000_TARGET */
 257
 258       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 259                                &exec_ops.to_sections_end))
 260         {
 261           /* Make sure to close exec_bfd, or else "run" might try to use
 262              it.  */
 263           exec_close (0);
 264           error ("\"%s\": can't find the file sections: %s",
 265                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 266         }
 267
 268       /* text_end is sometimes used for where to put call dummies.  A
 269          few ports use these for other purposes too.  */
 270       if (NEED_TEXT_START_END)
 271         {
 272           struct section_table *p;
 273
 274           /* Set text_start to the lowest address of the start of any
 275              readonly code section and set text_end to the highest
 276              address of the end of any readonly code section.  */
 277           /* FIXME: The comment above does not match the code.  The
 278              code checks for sections with are either code *or*
 279              readonly.  */
 280           text_start = ~(CORE_ADDR) 0;
 281           text_end = (CORE_ADDR) 0;
 282           for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 283             if (bfd_get_section_flags (p->bfd, p->the_bfd_section)
 284                 & (SEC_CODE | SEC_READONLY))
 285               {
 286                 if (text_start > p->addr)
 287                   text_start = p->addr;
 288                 if (text_end < p->endaddr)
 289                   text_end = p->endaddr;
 290               }
 291         }
 292
 293       validate_files ();
 294
 295       set_gdbarch_from_file (exec_bfd);
 296
 297       push_target (&exec_ops);
 298
 299       /* Tell display code (if any) about the changed file name.  */
 300       if (exec_file_display_hook)
 301         (*exec_file_display_hook) (filename);
 302     }
 303   else if (from_tty)
 304     printf_unfiltered ("No executable file now.\n");
 305 }
 306
 307 /*  Process the first arg in ARGS as the new exec file.
 308
 309    Note that we have to explicitly ignore additional args, since we can
 310    be called from file_command(), which also calls symbol_file_command()
 311    which can take multiple args. */
 312
 313 void
 314 exec_file_command (args, from_tty)
 315      char *args;
 316      int from_tty;
 317 {
 318   target_preopen (from_tty);
 319   exec_file_attach (args, from_tty);
 320 }
 321
 322 /* Set both the exec file and the symbol file, in one command.
 323    What a novelty.  Why did GDB go through four major releases before this
 324    command was added?  */
 325
 326 static void
 327 file_command (arg, from_tty)
 328      char *arg;
 329      int from_tty;
 330 {
 331   /* FIXME, if we lose on reading the symbol file, we should revert
 332      the exec file, but that's rough.  */
 333   exec_file_command (arg, from_tty);
 334   symbol_file_command (arg, from_tty);
 335   if (file_changed_hook)
 336     file_changed_hook (arg);
 337 }
 338 \f
 339
 340 /* Locate all mappable sections of a BFD file.
 341    table_pp_char is a char * to get it through bfd_map_over_sections;
 342    we cast it back to its proper type.  */
 343
 344 static void
 345 add_to_section_table (abfd, asect, table_pp_char)
 346      bfd *abfd;
 347      sec_ptr asect;
 348      PTR table_pp_char;
 349 {
 350   struct section_table **table_pp = (struct section_table **) table_pp_char;
 351   flagword aflag;
 352
 353   aflag = bfd_get_section_flags (abfd, asect);
 354   if (!(aflag & SEC_ALLOC))
 355     return;
 356   if (0 == bfd_section_size (abfd, asect))
 357     return;
 358   (*table_pp)->bfd = abfd;
 359   (*table_pp)->the_bfd_section = asect;
 360   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 361   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 362   (*table_pp)++;
 363 }
 364
 365 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 366    Returns 0 if OK, 1 on error.  */
 367
 368 int
 369 build_section_table (some_bfd, start, end)
 370      bfd *some_bfd;
 371      struct section_table **start, **end;
 372 {
 373   unsigned count;
 374
 375   count = bfd_count_sections (some_bfd);
 376   if (*start)
 377     free ((PTR) * start);
 378   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 379   *end = *start;
 380   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 381   if (*end > *start + count)
 382     abort ();
 383   /* We could realloc the table, but it probably loses for most files.  */
 384   return 0;
 385 }
 386 \f
 387 static void
 388 bfdsec_to_vmap (abfd, sect, arg3)
 389      bfd *abfd;
 390      sec_ptr sect;
 391      PTR arg3;
 392 {
 393   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 394   struct vmap *vp;
 395
 396   vp = vmap_bfd->pvmap;
 397
 398   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 399     return;
 400
 401   if (STREQ (bfd_section_name (abfd, sect), ".text"))
 402     {
 403       vp->tstart = bfd_section_vma (abfd, sect);
 404       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 405       vp->tvma = bfd_section_vma (abfd, sect);
 406       vp->toffs = sect->filepos;
 407     }
 408   else if (STREQ (bfd_section_name (abfd, sect), ".data"))
 409     {
 410       vp->dstart = bfd_section_vma (abfd, sect);
 411       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 412       vp->dvma = bfd_section_vma (abfd, sect);
 413     }
 414   /* Silently ignore other types of sections. (FIXME?)  */
 415 }
 416
 417 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 418    Return the new vmap.  */
 419
 420 struct vmap *
 421 map_vmap (abfd, arch)
 422      bfd *abfd;
 423      bfd *arch;
 424 {
 425   struct vmap_and_bfd vmap_bfd;
 426   struct vmap *vp, **vpp;
 427
 428   vp = (struct vmap *) xmalloc (sizeof (*vp));
 429   memset ((char *) vp, '\0', sizeof (*vp));
 430   vp->nxt = 0;
 431   vp->bfd = abfd;
 432   vp->name = bfd_get_filename (arch ? arch : abfd);
 433   vp->member = arch ? bfd_get_filename (abfd) : "";
 434
 435   vmap_bfd.pbfd = arch;
 436   vmap_bfd.pvmap = vp;
 437   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 438
 439   /* Find the end of the list and append. */
 440   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 441     ;
 442   *vpp = vp;
 443
 444   return vp;
 445 }
 446 \f
 447 /* Read or write the exec file.
 448
 449    Args are address within a BFD file, address within gdb address-space,
 450    length, and a flag indicating whether to read or write.
 451
 452    Result is a length:
 453
 454    0:    We cannot handle this address and length.
 455    > 0:  We have handled N bytes starting at this address.
 456    (If N == length, we did it all.)  We might be able
 457    to handle more bytes beyond this length, but no
 458    promises.
 459    < 0:  We cannot handle this address, but if somebody
 460    else handles (-N) bytes, we can start from there.
 461
 462    The same routine is used to handle both core and exec files;
 463    we just tail-call it with more arguments to select between them.  */
 464
 465 int
 466 xfer_memory (memaddr, myaddr, len, write, target)
 467      CORE_ADDR memaddr;
 468      char *myaddr;
 469      int len;
 470      int write;
 471      struct target_ops *target;
 472 {
 473   boolean res;
 474   struct section_table *p;
 475   CORE_ADDR nextsectaddr, memend;
 476   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 477   asection *section;
 478
 479   if (len <= 0)
 480     abort ();
 481
 482   if (overlay_debugging)
 483     {
 484       section = find_pc_overlay (memaddr);
 485       if (pc_in_unmapped_range (memaddr, section))
 486         memaddr = overlay_mapped_address (memaddr, section);
 487     }
 488
 489   memend = memaddr + len;
 490   xfer_fn = write ? bfd_set_section_contents : bfd_get_section_contents;
 491   nextsectaddr = memend;
 492
 493   for (p = target->to_sections; p < target->to_sections_end; p++)
 494     {
 495       if (overlay_debugging && section && p->the_bfd_section &&
 496           strcmp (section->name, p->the_bfd_section->name) != 0)
 497         continue;               /* not the section we need */
 498       if (memaddr >= p->addr)
 499         if (memend <= p->endaddr)
 500           {
 501             /* Entire transfer is within this section.  */
 502             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 503                            memaddr - p->addr, len);
 504             return (res != 0) ? len : 0;
 505           }
 506         else if (memaddr >= p->endaddr)
 507           {
 508             /* This section ends before the transfer starts.  */
 509             continue;
 510           }
 511         else
 512           {
 513             /* This section overlaps the transfer.  Just do half.  */
 514             len = p->endaddr - memaddr;
 515             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
 516                            memaddr - p->addr, len);
 517             return (res != 0) ? len : 0;
 518           }
 519       else
 520         nextsectaddr = min (nextsectaddr, p->addr);
 521     }
 522
 523   if (nextsectaddr >= memend)
 524     return 0;                   /* We can't help */
 525   else
 526     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 527 }
 528 \f
 529
 530 void
 531 print_section_info (t, abfd)
 532      struct target_ops *t;
 533      bfd *abfd;
 534 {
 535   struct section_table *p;
 536
 537   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 538   wrap_here ("        ");
 539   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
 540   if (abfd == exec_bfd)
 541     {
 542       printf_filtered ("\tEntry point: ");
 543       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 544       printf_filtered ("\n");
 545     }
 546   for (p = t->to_sections; p < t->to_sections_end; p++)
 547     {
 548       /* FIXME-32x64 need a print_address_numeric with field width */
 549       printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
 550       printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
 551       if (info_verbose)
 552         printf_filtered (" @ %s",
 553                          local_hex_string_custom ((unsigned long) p->the_bfd_section->filepos, "08l"));
 554       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 555       if (p->bfd != abfd)
 556         {
 557           printf_filtered (" in %s", bfd_get_filename (p->bfd));
 558         }
 559       printf_filtered ("\n");
 560     }
 561 }
 562
 563 static void
 564 exec_files_info (t)
 565      struct target_ops *t;
 566 {
 567   print_section_info (t, exec_bfd);
 568
 569   if (vmap)
 570     {
 571       struct vmap *vp;
 572
 573       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
 574       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 575                          strlen_paddr (), "tstart",
 576                          strlen_paddr (), "tend",
 577                          strlen_paddr (), "dstart",
 578                          strlen_paddr (), "dend",
 579                          "section",
 580                          "file(member)");
 581
 582       for (vp = vmap; vp; vp = vp->nxt)
 583         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 584                            paddr (vp->tstart),
 585                            paddr (vp->tend),
 586                            paddr (vp->dstart),
 587                            paddr (vp->dend),
 588                            vp->name,
 589                            *vp->member ? "(" : "", vp->member,
 590                            *vp->member ? ")" : "");
 591     }
 592 }
 593
 594 /* msnyder 5/21/99:
 595    exec_set_section_offsets sets the offsets of all the sections
 596    in the exec objfile.  */
 597
 598 void
 599 exec_set_section_offsets (text_off, data_off, bss_off)
 600      bfd_signed_vma text_off;
 601      bfd_signed_vma data_off;
 602      bfd_signed_vma bss_off;
 603 {
 604   struct section_table *sect;
 605
 606   for (sect = exec_ops.to_sections;
 607        sect < exec_ops.to_sections_end;
 608        sect++)
 609     {
 610       flagword flags;
 611
 612       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
 613
 614       if (flags & SEC_CODE)
 615         {
 616           sect->addr += text_off;
 617           sect->endaddr += text_off;
 618         }
 619       else if (flags & (SEC_DATA | SEC_LOAD))
 620         {
 621           sect->addr += data_off;
 622           sect->endaddr += data_off;
 623         }
 624       else if (flags & SEC_ALLOC)
 625         {
 626           sect->addr += bss_off;
 627           sect->endaddr += bss_off;
 628         }
 629     }
 630 }
 631
 632 static void
 633 set_section_command (args, from_tty)
 634      char *args;
 635      int from_tty;
 636 {
 637   struct section_table *p;
 638   char *secname;
 639   unsigned seclen;
 640   unsigned long secaddr;
 641   char secprint[100];
 642   long offset;
 643
 644   if (args == 0)
 645     error ("Must specify section name and its virtual address");
 646
 647   /* Parse out section name */
 648   for (secname = args; !isspace (*args); args++);
 649   seclen = args - secname;
 650
 651   /* Parse out new virtual address */
 652   secaddr = parse_and_eval_address (args);
 653
 654   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 655     {
 656       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 657           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 658         {
 659           offset = secaddr - p->addr;
 660           p->addr += offset;
 661           p->endaddr += offset;
 662           if (from_tty)
 663             exec_files_info (&exec_ops);
 664           return;
 665         }
 666     }
 667   if (seclen >= sizeof (secprint))
 668     seclen = sizeof (secprint) - 1;
 669   strncpy (secprint, secname, seclen);
 670   secprint[seclen] = '\0';
 671   error ("Section %s not found", secprint);
 672 }
 673
 674 /* If mourn is being called in all the right places, this could be say
 675    `gdb internal error' (since generic_mourn calls
 676    breakpoint_init_inferior).  */
 677
 678 static int
 679 ignore (addr, contents)
 680      CORE_ADDR addr;
 681      char *contents;
 682 {
 683   return 0;
 684 }
 685
 686 /* Fill in the exec file target vector.  Very few entries need to be
 687    defined.  */
 688
 689 void
 690 init_exec_ops ()
 691 {
 692   exec_ops.to_shortname = "exec";
 693   exec_ops.to_longname = "Local exec file";
 694   exec_ops.to_doc = "Use an executable file as a target.\n\
 695 Specify the filename of the executable file.";
 696   exec_ops.to_open = exec_file_command;
 697   exec_ops.to_close = exec_close;
 698   exec_ops.to_attach = find_default_attach;
 699   exec_ops.to_require_attach = find_default_require_attach;
 700   exec_ops.to_require_detach = find_default_require_detach;
 701   exec_ops.to_xfer_memory = xfer_memory;
 702   exec_ops.to_files_info = exec_files_info;
 703   exec_ops.to_insert_breakpoint = ignore;
 704   exec_ops.to_remove_breakpoint = ignore;
 705   exec_ops.to_create_inferior = find_default_create_inferior;
 706   exec_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 707   exec_ops.to_stratum = file_stratum;
 708   exec_ops.to_has_memory = 1;
 709   exec_ops.to_magic = OPS_MAGIC;
 710 }
 711
 712 void
 713 _initialize_exec ()
 714 {
 715   struct cmd_list_element *c;
 716
 717   init_exec_ops ();
 718
 719   if (!dbx_commands)
 720     {
 721       c = add_cmd ("file", class_files, file_command,
 722                    "Use FILE as program to be debugged.\n\
 723 It is read for its symbols, for getting the contents of pure memory,\n\
 724 and it is the program executed when you use the `run' command.\n\
 725 If FILE cannot be found as specified, your execution directory path\n\
 726 ($PATH) is searched for a command of that name.\n\
 727 No arg means to have no executable file and no symbols.", &cmdlist);
 728       c->completer = filename_completer;
 729     }
 730
 731   c = add_cmd ("exec-file", class_files, exec_file_command,
 732                "Use FILE as program for getting contents of pure memory.\n\
 733 If FILE cannot be found as specified, your execution directory path\n\
 734 is searched for a command of that name.\n\
 735 No arg means have no executable file.", &cmdlist);
 736   c->completer = filename_completer;
 737
 738   add_com ("section", class_files, set_section_command,
 739            "Change the base address of section SECTION of the exec file to ADDR.\n\
 740 This can be used if the exec file does not contain section addresses,\n\
 741 (such as in the a.out format), or when the addresses specified in the\n\
 742 file itself are wrong.  Each section must be changed separately.  The\n\
 743 ``info files'' command lists all the sections and their addresses.");
 744
 745   add_show_from_set
 746     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
 747                   "Set writing into executable and core files.",
 748                   &setlist),
 749      &showlist);
 750
 751   add_target (&exec_ops);
 752 }