gdb/exec.c

   1 /* Work with executable files, for GDB.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
   5    Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "target.h"
  28 #include "gdbcmd.h"
  29 #include "language.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "completer.h"
  33 #include "value.h"
  34 #include "exec.h"
  35
  36 #ifdef USG
  37 #include <sys/types.h>
  38 #endif
  39
  40 #include <fcntl.h>
  41 #include "readline/readline.h"
  42 #include "gdb_string.h"
  43
  44 #include "gdbcore.h"
  45
  46 #include <ctype.h>
  47 #include "gdb_stat.h"
  48 #ifndef O_BINARY
  49 #define O_BINARY 0
  50 #endif
  51
  52 #include "xcoffsolib.h"
  53
  54 struct vmap *map_vmap (bfd *, bfd *);
  55
  56 void (*deprecated_file_changed_hook) (char *);
  57
  58 /* Prototypes for local functions */
  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 int ignore (CORE_ADDR, char *);
  69
  70 static void init_exec_ops (void);
  71
  72 void _initialize_exec (void);
  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 struct vmap *vmap;
  87
  88 void
  89 exec_open (char *args, int from_tty)
  90 {
  91   target_preopen (from_tty);
  92   exec_file_attach (args, from_tty);
  93 }
  94
  95 static void
  96 exec_close (int quitting)
  97 {
  98   int need_symtab_cleanup = 0;
  99   struct vmap *vp, *nxt;
 100
 101   for (nxt = vmap; nxt != NULL;)
 102     {
 103       vp = nxt;
 104       nxt = vp->nxt;
 105
 106       /* if there is an objfile associated with this bfd,
 107          free_objfile() will do proper cleanup of objfile *and* bfd. */
 108
 109       if (vp->objfile)
 110         {
 111           free_objfile (vp->objfile);
 112           need_symtab_cleanup = 1;
 113         }
 114       else if (vp->bfd != exec_bfd)
 115         /* FIXME-leak: We should be freeing vp->name too, I think.  */
 116         if (!bfd_close (vp->bfd))
 117           warning ("cannot close \"%s\": %s",
 118                    vp->name, bfd_errmsg (bfd_get_error ()));
 119
 120       /* FIXME: This routine is #if 0'd in symfile.c.  What should we
 121          be doing here?  Should we just free everything in
 122          vp->objfile->symtabs?  Should free_objfile do that?
 123          FIXME-as-well: free_objfile already free'd vp->name, so it isn't
 124          valid here.  */
 125       free_named_symtabs (vp->name);
 126       xfree (vp);
 127     }
 128
 129   vmap = NULL;
 130
 131   if (exec_bfd)
 132     {
 133       char *name = bfd_get_filename (exec_bfd);
 134
 135       if (!bfd_close (exec_bfd))
 136         warning ("cannot close \"%s\": %s",
 137                  name, bfd_errmsg (bfd_get_error ()));
 138       xfree (name);
 139       exec_bfd = NULL;
 140     }
 141
 142   if (exec_ops.to_sections)
 143     {
 144       xfree (exec_ops.to_sections);
 145       exec_ops.to_sections = NULL;
 146       exec_ops.to_sections_end = NULL;
 147     }
 148 }
 149
 150 void
 151 exec_file_clear (int from_tty)
 152 {
 153   /* Remove exec file.  */
 154   unpush_target (&exec_ops);
 155
 156   if (from_tty)
 157     printf_unfiltered ("No executable file now.\n");
 158 }
 159
 160 /*  Process the first arg in ARGS as the new exec file.
 161
 162    This function is intended to be behave essentially the same
 163    as exec_file_command, except that the latter will detect when
 164    a target is being debugged, and will ask the user whether it
 165    should be shut down first.  (If the answer is "no", then the
 166    new file is ignored.)
 167
 168    This file is used by exec_file_command, to do the work of opening
 169    and processing the exec file after any prompting has happened.
 170
 171    And, it is used by child_attach, when the attach command was
 172    given a pid but not a exec pathname, and the attach command could
 173    figure out the pathname from the pid.  (In this case, we shouldn't
 174    ask the user whether the current target should be shut down --
 175    we're supplying the exec pathname late for good reason.)
 176
 177    ARGS is assumed to be the filename. */
 178
 179 void
 180 exec_file_attach (char *filename, int from_tty)
 181 {
 182   /* Remove any previous exec file.  */
 183   unpush_target (&exec_ops);
 184
 185   /* Now open and digest the file the user requested, if any.  */
 186
 187   if (!filename)
 188     {
 189       if (from_tty)
 190         printf_unfiltered ("No executable file now.\n");
 191     }
 192   else
 193     {
 194       char *scratch_pathname;
 195       int scratch_chan;
 196
 197       scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
 198                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 199                             &scratch_pathname);
 200 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 201       if (scratch_chan < 0)
 202         {
 203           char *exename = alloca (strlen (filename) + 5);
 204           strcat (strcpy (exename, filename), ".exe");
 205           scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
 206              write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 207              &scratch_pathname);
 208         }
 209 #endif
 210       if (scratch_chan < 0)
 211         perror_with_name (filename);
 212       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 213
 214       if (!exec_bfd)
 215         error ("\"%s\": could not open as an executable file: %s",
 216                scratch_pathname, bfd_errmsg (bfd_get_error ()));
 217
 218       /* At this point, scratch_pathname and exec_bfd->name both point to the
 219          same malloc'd string.  However exec_close() will attempt to free it
 220          via the exec_bfd->name pointer, so we need to make another copy and
 221          leave exec_bfd as the new owner of the original copy. */
 222       scratch_pathname = xstrdup (scratch_pathname);
 223       make_cleanup (xfree, scratch_pathname);
 224
 225       if (!bfd_check_format (exec_bfd, bfd_object))
 226         {
 227           /* Make sure to close exec_bfd, or else "run" might try to use
 228              it.  */
 229           exec_close (0);
 230           error ("\"%s\": not in executable format: %s",
 231                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 232         }
 233
 234       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 235          way to accomplish.  */
 236 #ifdef DEPRECATED_IBM6000_TARGET
 237       /* Setup initial vmap. */
 238
 239       map_vmap (exec_bfd, 0);
 240       if (vmap == NULL)
 241         {
 242           /* Make sure to close exec_bfd, or else "run" might try to use
 243              it.  */
 244           exec_close (0);
 245           error ("\"%s\": can't find the file sections: %s",
 246                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 247         }
 248 #endif /* DEPRECATED_IBM6000_TARGET */
 249
 250       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 251                                &exec_ops.to_sections_end))
 252         {
 253           /* Make sure to close exec_bfd, or else "run" might try to use
 254              it.  */
 255           exec_close (0);
 256           error ("\"%s\": can't find the file sections: %s",
 257                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 258         }
 259
 260 #ifdef DEPRECATED_HPUX_TEXT_END
 261       DEPRECATED_HPUX_TEXT_END (&exec_ops);
 262 #endif
 263
 264       validate_files ();
 265
 266       set_gdbarch_from_file (exec_bfd);
 267
 268       push_target (&exec_ops);
 269
 270       /* Tell display code (if any) about the changed file name.  */
 271       if (deprecated_exec_file_display_hook)
 272         (*deprecated_exec_file_display_hook) (filename);
 273     }
 274   bfd_cache_close_all ();
 275 }
 276
 277 /*  Process the first arg in ARGS as the new exec file.
 278
 279    Note that we have to explicitly ignore additional args, since we can
 280    be called from file_command(), which also calls symbol_file_command()
 281    which can take multiple args.
 282
 283    If ARGS is NULL, we just want to close the exec file. */
 284
 285 static void
 286 exec_file_command (char *args, int from_tty)
 287 {
 288   char **argv;
 289   char *filename;
 290
 291   target_preopen (from_tty);
 292
 293   if (args)
 294     {
 295       /* Scan through the args and pick up the first non option arg
 296          as the filename.  */
 297
 298       argv = buildargv (args);
 299       if (argv == NULL)
 300         nomem (0);
 301
 302       make_cleanup_freeargv (argv);
 303
 304       for (; (*argv != NULL) && (**argv == '-'); argv++)
 305         {;
 306         }
 307       if (*argv == NULL)
 308         error ("No executable file name was specified");
 309
 310       filename = tilde_expand (*argv);
 311       make_cleanup (xfree, filename);
 312       exec_file_attach (filename, from_tty);
 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 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 (struct 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 (struct bfd *abfd, struct bfd_section *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 (DEPRECATED_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 (DEPRECATED_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   asection *section = NULL;
 460
 461   if (len <= 0)
 462     internal_error (__FILE__, __LINE__, "failed internal consistency check");
 463
 464   if (overlay_debugging)
 465     {
 466       section = find_pc_overlay (memaddr);
 467       if (pc_in_unmapped_range (memaddr, section))
 468         memaddr = overlay_mapped_address (memaddr, section);
 469     }
 470
 471   memend = memaddr + len;
 472   nextsectaddr = memend;
 473
 474   for (p = target->to_sections; p < target->to_sections_end; p++)
 475     {
 476       if (overlay_debugging && section && p->the_bfd_section &&
 477           strcmp (section->name, p->the_bfd_section->name) != 0)
 478         continue;               /* not the section we need */
 479       if (memaddr >= p->addr)
 480         {
 481           if (memend <= p->endaddr)
 482             {
 483               /* Entire transfer is within this section.  */
 484               if (write)
 485                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 486                                                 myaddr, memaddr - p->addr,
 487                                                 len);
 488               else
 489                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 490                                                 myaddr, memaddr - p->addr,
 491                                                 len);
 492               return (res != 0) ? len : 0;
 493             }
 494           else if (memaddr >= p->endaddr)
 495             {
 496               /* This section ends before the transfer starts.  */
 497               continue;
 498             }
 499           else
 500             {
 501               /* This section overlaps the transfer.  Just do half.  */
 502               len = p->endaddr - memaddr;
 503               if (write)
 504                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 505                                                 myaddr, memaddr - p->addr,
 506                                                 len);
 507               else
 508                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 509                                                 myaddr, memaddr - p->addr,
 510                                                 len);
 511               return (res != 0) ? len : 0;
 512             }
 513         }
 514       else
 515         nextsectaddr = min (nextsectaddr, p->addr);
 516     }
 517
 518   if (nextsectaddr >= memend)
 519     return 0;                   /* We can't help */
 520   else
 521     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 522 }
 523 \f
 524
 525 void
 526 print_section_info (struct target_ops *t, bfd *abfd)
 527 {
 528   struct section_table *p;
 529   /* FIXME: "016l" is not wide enough when TARGET_ADDR_BIT > 64.  */
 530   char *fmt = TARGET_ADDR_BIT <= 32 ? "08l" : "016l";
 531
 532   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 533   wrap_here ("        ");
 534   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
 535   if (abfd == exec_bfd)
 536     {
 537       printf_filtered ("\tEntry point: ");
 538       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 539       printf_filtered ("\n");
 540     }
 541   for (p = t->to_sections; p < t->to_sections_end; p++)
 542     {
 543       printf_filtered ("\t%s", local_hex_string_custom (p->addr, fmt));
 544       printf_filtered (" - %s", local_hex_string_custom (p->endaddr, fmt));
 545
 546       /* FIXME: A format of "08l" is not wide enough for file offsets
 547          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 548          since most output will then be much wider than necessary.  It
 549          may make sense to test the size of the file and choose the
 550          format string accordingly.  */
 551       if (info_verbose)
 552         printf_filtered (" @ %s",
 553                          local_hex_string_custom (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 (struct target_ops *t)
 565 {
 566   print_section_info (t, exec_bfd);
 567
 568   if (vmap)
 569     {
 570       struct vmap *vp;
 571
 572       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
 573       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 574                          strlen_paddr (), "tstart",
 575                          strlen_paddr (), "tend",
 576                          strlen_paddr (), "dstart",
 577                          strlen_paddr (), "dend",
 578                          "section",
 579                          "file(member)");
 580
 581       for (vp = vmap; vp; vp = vp->nxt)
 582         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 583                            paddr (vp->tstart),
 584                            paddr (vp->tend),
 585                            paddr (vp->dstart),
 586                            paddr (vp->dend),
 587                            vp->name,
 588                            *vp->member ? "(" : "", vp->member,
 589                            *vp->member ? ")" : "");
 590     }
 591 }
 592
 593 /* msnyder 5/21/99:
 594    exec_set_section_offsets sets the offsets of all the sections
 595    in the exec objfile.  */
 596
 597 void
 598 exec_set_section_offsets (bfd_signed_vma text_off, bfd_signed_vma data_off,
 599                           bfd_signed_vma bss_off)
 600 {
 601   struct section_table *sect;
 602
 603   for (sect = exec_ops.to_sections;
 604        sect < exec_ops.to_sections_end;
 605        sect++)
 606     {
 607       flagword flags;
 608
 609       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
 610
 611       if (flags & SEC_CODE)
 612         {
 613           sect->addr += text_off;
 614           sect->endaddr += text_off;
 615         }
 616       else if (flags & (SEC_DATA | SEC_LOAD))
 617         {
 618           sect->addr += data_off;
 619           sect->endaddr += data_off;
 620         }
 621       else if (flags & SEC_ALLOC)
 622         {
 623           sect->addr += bss_off;
 624           sect->endaddr += bss_off;
 625         }
 626     }
 627 }
 628
 629 static void
 630 set_section_command (char *args, int from_tty)
 631 {
 632   struct section_table *p;
 633   char *secname;
 634   unsigned seclen;
 635   unsigned long secaddr;
 636   char secprint[100];
 637   long offset;
 638
 639   if (args == 0)
 640     error ("Must specify section name and its virtual address");
 641
 642   /* Parse out section name */
 643   for (secname = args; !isspace (*args); args++);
 644   seclen = args - secname;
 645
 646   /* Parse out new virtual address */
 647   secaddr = parse_and_eval_address (args);
 648
 649   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 650     {
 651       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 652           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 653         {
 654           offset = secaddr - p->addr;
 655           p->addr += offset;
 656           p->endaddr += offset;
 657           if (from_tty)
 658             exec_files_info (&exec_ops);
 659           return;
 660         }
 661     }
 662   if (seclen >= sizeof (secprint))
 663     seclen = sizeof (secprint) - 1;
 664   strncpy (secprint, secname, seclen);
 665   secprint[seclen] = '\0';
 666   error ("Section %s not found", secprint);
 667 }
 668
 669 /* If mourn is being called in all the right places, this could be say
 670    `gdb internal error' (since generic_mourn calls
 671    breakpoint_init_inferior).  */
 672
 673 static int
 674 ignore (CORE_ADDR addr, char *contents)
 675 {
 676   return 0;
 677 }
 678
 679 /* Find mapped memory. */
 680
 681 extern void
 682 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
 683                                                     unsigned long,
 684                                                     int, int, int,
 685                                                     void *),
 686                                            void *))
 687 {
 688   exec_ops.to_find_memory_regions = func;
 689 }
 690
 691 static char *exec_make_note_section (bfd *, int *);
 692
 693 /* Fill in the exec file target vector.  Very few entries need to be
 694    defined.  */
 695
 696 static void
 697 init_exec_ops (void)
 698 {
 699   exec_ops.to_shortname = "exec";
 700   exec_ops.to_longname = "Local exec file";
 701   exec_ops.to_doc = "Use an executable file as a target.\n\
 702 Specify the filename of the executable file.";
 703   exec_ops.to_open = exec_open;
 704   exec_ops.to_close = exec_close;
 705   exec_ops.to_attach = find_default_attach;
 706   exec_ops.to_xfer_memory = xfer_memory;
 707   exec_ops.to_files_info = exec_files_info;
 708   exec_ops.to_insert_breakpoint = ignore;
 709   exec_ops.to_remove_breakpoint = ignore;
 710   exec_ops.to_create_inferior = find_default_create_inferior;
 711   exec_ops.to_stratum = file_stratum;
 712   exec_ops.to_has_memory = 1;
 713   exec_ops.to_make_corefile_notes = exec_make_note_section;
 714   exec_ops.to_magic = OPS_MAGIC;
 715 }
 716
 717 void
 718 _initialize_exec (void)
 719 {
 720   struct cmd_list_element *c;
 721
 722   init_exec_ops ();
 723
 724   if (!dbx_commands)
 725     {
 726       c = add_cmd ("file", class_files, file_command,
 727                    "Use FILE as program to be debugged.\n\
 728 It is read for its symbols, for getting the contents of pure memory,\n\
 729 and it is the program executed when you use the `run' command.\n\
 730 If FILE cannot be found as specified, your execution directory path\n\
 731 ($PATH) is searched for a command of that name.\n\
 732 No arg means to have no executable file and no symbols.", &cmdlist);
 733       set_cmd_completer (c, filename_completer);
 734     }
 735
 736   c = add_cmd ("exec-file", class_files, exec_file_command,
 737                "Use FILE as program for getting contents of pure memory.\n\
 738 If FILE cannot be found as specified, your execution directory path\n\
 739 is searched for a command of that name.\n\
 740 No arg means have no executable file.", &cmdlist);
 741   set_cmd_completer (c, filename_completer);
 742
 743   add_com ("section", class_files, set_section_command,
 744            "Change the base address of section SECTION of the exec file to ADDR.\n\
 745 This can be used if the exec file does not contain section addresses,\n\
 746 (such as in the a.out format), or when the addresses specified in the\n\
 747 file itself are wrong.  Each section must be changed separately.  The\n\
 748 ``info files'' command lists all the sections and their addresses.");
 749
 750   deprecated_add_show_from_set
 751     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
 752                   "Set writing into executable and core files.",
 753                   &setlist),
 754      &showlist);
 755
 756   add_target (&exec_ops);
 757 }
 758
 759 static char *
 760 exec_make_note_section (bfd *obfd, int *note_size)
 761 {
 762   error ("Can't create a corefile");
 763 }