gdb/exec.c

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