gdb/exec.c

   1 /* Work with executable files, for GDB.
   2
   3    Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2002, 2003, 2007, 2008, 2009
   5    Free Software Foundation, 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 3 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, see <http://www.gnu.org/licenses/>.  */
  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 #include "completer.h"
  31 #include "value.h"
  32 #include "exec.h"
  33 #include "observer.h"
  34 #include "arch-utils.h"
  35
  36 #include <fcntl.h>
  37 #include "readline/readline.h"
  38 #include "gdb_string.h"
  39
  40 #include "gdbcore.h"
  41
  42 #include <ctype.h>
  43 #include "gdb_stat.h"
  44
  45 #include "xcoffsolib.h"
  46
  47 struct vmap *map_vmap (bfd *, bfd *);
  48
  49 void (*deprecated_file_changed_hook) (char *);
  50
  51 /* Prototypes for local functions */
  52
  53 static void exec_close (int);
  54
  55 static void file_command (char *, int);
  56
  57 static void set_section_command (char *, int);
  58
  59 static void exec_files_info (struct target_ops *);
  60
  61 static void init_exec_ops (void);
  62
  63 void _initialize_exec (void);
  64
  65 /* The target vector for executable files.  */
  66
  67 struct target_ops exec_ops;
  68
  69 /* The Binary File Descriptor handle for the executable file.  */
  70
  71 bfd *exec_bfd = NULL;
  72 long exec_bfd_mtime = 0;
  73
  74 /* Whether to open exec and core files read-only or read-write.  */
  75
  76 int write_files = 0;
  77 static void
  78 show_write_files (struct ui_file *file, int from_tty,
  79                   struct cmd_list_element *c, const char *value)
  80 {
  81   fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
  82                     value);
  83 }
  84
  85
  86 struct vmap *vmap;
  87
  88 static 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       exec_bfd_mtime = 0;
 141     }
 142
 143   if (exec_ops.to_sections)
 144     {
 145       xfree (exec_ops.to_sections);
 146       exec_ops.to_sections = NULL;
 147       exec_ops.to_sections_end = NULL;
 148     }
 149 }
 150
 151 void
 152 exec_file_clear (int from_tty)
 153 {
 154   /* Remove exec file.  */
 155   unpush_target (&exec_ops);
 156
 157   if (from_tty)
 158     printf_unfiltered (_("No executable file now.\n"));
 159 }
 160
 161 /*  Process the first arg in ARGS as the new exec file.
 162
 163    This function is intended to be behave essentially the same
 164    as exec_file_command, except that the latter will detect when
 165    a target is being debugged, and will ask the user whether it
 166    should be shut down first.  (If the answer is "no", then the
 167    new file is ignored.)
 168
 169    This file is used by exec_file_command, to do the work of opening
 170    and processing the exec file after any prompting has happened.
 171
 172    And, it is used by child_attach, when the attach command was
 173    given a pid but not a exec pathname, and the attach command could
 174    figure out the pathname from the pid.  (In this case, we shouldn't
 175    ask the user whether the current target should be shut down --
 176    we're supplying the exec pathname late for good reason.)
 177
 178    ARGS is assumed to be the filename. */
 179
 180 void
 181 exec_file_attach (char *filename, int from_tty)
 182 {
 183   /* Remove any previous exec file.  */
 184   unpush_target (&exec_ops);
 185
 186   /* Now open and digest the file the user requested, if any.  */
 187
 188   if (!filename)
 189     {
 190       if (from_tty)
 191         printf_unfiltered (_("No executable file now.\n"));
 192
 193       set_gdbarch_from_file (NULL);
 194     }
 195   else
 196     {
 197       char *scratch_pathname;
 198       int scratch_chan;
 199
 200       scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, 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"), OPF_TRY_CWD_FIRST, exename,
 209              write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 210              &scratch_pathname);
 211         }
 212 #endif
 213       if (scratch_chan < 0)
 214         perror_with_name (filename);
 215       exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
 216                             write_files ? FOPEN_RUB : FOPEN_RB,
 217                             scratch_chan);
 218
 219       if (!exec_bfd)
 220         {
 221           close (scratch_chan);
 222           error (_("\"%s\": could not open as an executable file: %s"),
 223                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 224         }
 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 (xfree, 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 DEPRECATED_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 /* DEPRECATED_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       exec_bfd_mtime = bfd_get_mtime (exec_bfd);
 269
 270       validate_files ();
 271
 272       set_gdbarch_from_file (exec_bfd);
 273
 274       push_target (&exec_ops);
 275
 276       /* Tell display code (if any) about the changed file name.  */
 277       if (deprecated_exec_file_display_hook)
 278         (*deprecated_exec_file_display_hook) (filename);
 279     }
 280   bfd_cache_close_all ();
 281   observer_notify_executable_changed ();
 282 }
 283
 284 /*  Process the first arg in ARGS as the new exec file.
 285
 286    Note that we have to explicitly ignore additional args, since we can
 287    be called from file_command(), which also calls symbol_file_command()
 288    which can take multiple args.
 289
 290    If ARGS is NULL, we just want to close the exec file. */
 291
 292 static void
 293 exec_file_command (char *args, int from_tty)
 294 {
 295   char **argv;
 296   char *filename;
 297
 298   if (from_tty && target_has_execution
 299       && !query (_("A program is being debugged already.\n"
 300                    "Are you sure you want to change the file? ")))
 301     error (_("File not changed."));
 302
 303   if (args)
 304     {
 305       /* Scan through the args and pick up the first non option arg
 306          as the filename.  */
 307
 308       argv = gdb_buildargv (args);
 309       make_cleanup_freeargv (argv);
 310
 311       for (; (*argv != NULL) && (**argv == '-'); argv++)
 312         {;
 313         }
 314       if (*argv == NULL)
 315         error (_("No executable file name was specified"));
 316
 317       filename = tilde_expand (*argv);
 318       make_cleanup (xfree, filename);
 319       exec_file_attach (filename, from_tty);
 320     }
 321   else
 322     exec_file_attach (NULL, from_tty);
 323 }
 324
 325 /* Set both the exec file and the symbol file, in one command.
 326    What a novelty.  Why did GDB go through four major releases before this
 327    command was added?  */
 328
 329 static void
 330 file_command (char *arg, int from_tty)
 331 {
 332   /* FIXME, if we lose on reading the symbol file, we should revert
 333      the exec file, but that's rough.  */
 334   exec_file_command (arg, from_tty);
 335   symbol_file_command (arg, from_tty);
 336   if (deprecated_file_changed_hook)
 337     deprecated_file_changed_hook (arg);
 338 }
 339 \f
 340
 341 /* Locate all mappable sections of a BFD file.
 342    table_pp_char is a char * to get it through bfd_map_over_sections;
 343    we cast it back to its proper type.  */
 344
 345 static void
 346 add_to_section_table (bfd *abfd, struct bfd_section *asect,
 347                       void *table_pp_char)
 348 {
 349   struct section_table **table_pp = (struct section_table **) table_pp_char;
 350   flagword aflag;
 351
 352   /* Check the section flags, but do not discard zero-length sections, since
 353      some symbols may still be attached to this section.  For instance, we
 354      encountered on sparc-solaris 2.10 a shared library with an empty .bss
 355      section to which a symbol named "_end" was attached.  The address
 356      of this symbol still needs to be relocated.  */
 357   aflag = bfd_get_section_flags (abfd, asect);
 358   if (!(aflag & SEC_ALLOC))
 359     return;
 360
 361   (*table_pp)->bfd = abfd;
 362   (*table_pp)->the_bfd_section = asect;
 363   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 364   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 365   (*table_pp)++;
 366 }
 367
 368 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 369    Returns 0 if OK, 1 on error.  */
 370
 371 int
 372 build_section_table (struct bfd *some_bfd, struct section_table **start,
 373                      struct section_table **end)
 374 {
 375   unsigned count;
 376
 377   count = bfd_count_sections (some_bfd);
 378   if (*start)
 379     xfree (* start);
 380   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 381   *end = *start;
 382   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 383   if (*end > *start + count)
 384     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 385   /* We could realloc the table, but it probably loses for most files.  */
 386   return 0;
 387 }
 388 \f
 389 static void
 390 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
 391 {
 392   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 393   struct vmap *vp;
 394
 395   vp = vmap_bfd->pvmap;
 396
 397   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 398     return;
 399
 400   if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
 401     {
 402       vp->tstart = bfd_section_vma (abfd, sect);
 403       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 404       vp->tvma = bfd_section_vma (abfd, sect);
 405       vp->toffs = sect->filepos;
 406     }
 407   else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
 408     {
 409       vp->dstart = bfd_section_vma (abfd, sect);
 410       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 411       vp->dvma = bfd_section_vma (abfd, sect);
 412     }
 413   /* Silently ignore other types of sections. (FIXME?)  */
 414 }
 415
 416 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 417    Return the new vmap.  */
 418
 419 struct vmap *
 420 map_vmap (bfd *abfd, bfd *arch)
 421 {
 422   struct vmap_and_bfd vmap_bfd;
 423   struct vmap *vp, **vpp;
 424
 425   vp = (struct vmap *) xmalloc (sizeof (*vp));
 426   memset ((char *) vp, '\0', sizeof (*vp));
 427   vp->nxt = 0;
 428   vp->bfd = abfd;
 429   vp->name = bfd_get_filename (arch ? arch : abfd);
 430   vp->member = arch ? bfd_get_filename (abfd) : "";
 431
 432   vmap_bfd.pbfd = arch;
 433   vmap_bfd.pvmap = vp;
 434   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 435
 436   /* Find the end of the list and append. */
 437   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 438     ;
 439   *vpp = vp;
 440
 441   return vp;
 442 }
 443 \f
 444 /* Read or write the exec file.
 445
 446    Args are address within a BFD file, address within gdb address-space,
 447    length, and a flag indicating whether to read or write.
 448
 449    Result is a length:
 450
 451    0:    We cannot handle this address and length.
 452    > 0:  We have handled N bytes starting at this address.
 453    (If N == length, we did it all.)  We might be able
 454    to handle more bytes beyond this length, but no
 455    promises.
 456    < 0:  We cannot handle this address, but if somebody
 457    else handles (-N) bytes, we can start from there.
 458
 459    The same routine is used to handle both core and exec files;
 460    we just tail-call it with more arguments to select between them.  */
 461
 462 int
 463 xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
 464              struct mem_attrib *attrib, struct target_ops *target)
 465 {
 466   int res;
 467   struct section_table *p;
 468   CORE_ADDR nextsectaddr, memend;
 469   struct obj_section *section = NULL;
 470
 471   if (len <= 0)
 472     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 473
 474   if (overlay_debugging)
 475     {
 476       section = find_pc_overlay (memaddr);
 477       if (pc_in_unmapped_range (memaddr, section))
 478         memaddr = overlay_mapped_address (memaddr, section);
 479     }
 480
 481   memend = memaddr + len;
 482   nextsectaddr = memend;
 483
 484   for (p = target->to_sections; p < target->to_sections_end; p++)
 485     {
 486       if (overlay_debugging && section
 487           && strcmp (section->the_bfd_section->name,
 488                      p->the_bfd_section->name) != 0)
 489         continue;               /* not the section we need */
 490       if (memaddr >= p->addr)
 491         {
 492           if (memend <= p->endaddr)
 493             {
 494               /* Entire transfer is within this section.  */
 495               if (write)
 496                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 497                                                 myaddr, memaddr - p->addr,
 498                                                 len);
 499               else
 500                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 501                                                 myaddr, memaddr - p->addr,
 502                                                 len);
 503               return (res != 0) ? len : 0;
 504             }
 505           else if (memaddr >= p->endaddr)
 506             {
 507               /* This section ends before the transfer starts.  */
 508               continue;
 509             }
 510           else
 511             {
 512               /* This section overlaps the transfer.  Just do half.  */
 513               len = p->endaddr - memaddr;
 514               if (write)
 515                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 516                                                 myaddr, memaddr - p->addr,
 517                                                 len);
 518               else
 519                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 520                                                 myaddr, memaddr - p->addr,
 521                                                 len);
 522               return (res != 0) ? len : 0;
 523             }
 524         }
 525       else
 526         nextsectaddr = min (nextsectaddr, p->addr);
 527     }
 528
 529   if (nextsectaddr >= memend)
 530     return 0;                   /* We can't help */
 531   else
 532     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 533 }
 534 \f
 535
 536 void
 537 print_section_info (struct target_ops *t, bfd *abfd)
 538 {
 539   struct section_table *p;
 540   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 541   int wid = gdbarch_addr_bit (gdbarch_from_bfd (abfd)) <= 32 ? 8 : 16;
 542
 543   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 544   wrap_here ("        ");
 545   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 546   if (abfd == exec_bfd)
 547     printf_filtered (_("\tEntry point: %s\n"),
 548                      paddress (bfd_get_start_address (abfd)));
 549   for (p = t->to_sections; p < t->to_sections_end; p++)
 550     {
 551       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 552       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 553
 554       /* FIXME: A format of "08l" is not wide enough for file offsets
 555          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 556          since most output will then be much wider than necessary.  It
 557          may make sense to test the size of the file and choose the
 558          format string accordingly.  */
 559       /* FIXME: i18n: Need to rewrite this sentence.  */
 560       if (info_verbose)
 561         printf_filtered (" @ %s",
 562                          hex_string_custom (p->the_bfd_section->filepos, 8));
 563       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 564       if (p->bfd != abfd)
 565         printf_filtered (" in %s", bfd_get_filename (p->bfd));
 566       printf_filtered ("\n");
 567     }
 568 }
 569
 570 static void
 571 exec_files_info (struct target_ops *t)
 572 {
 573   print_section_info (t, exec_bfd);
 574
 575   if (vmap)
 576     {
 577       struct vmap *vp;
 578
 579       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
 580       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 581                          strlen_paddr (), "tstart",
 582                          strlen_paddr (), "tend",
 583                          strlen_paddr (), "dstart",
 584                          strlen_paddr (), "dend",
 585                          "section",
 586                          "file(member)");
 587
 588       for (vp = vmap; vp; vp = vp->nxt)
 589         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 590                            paddr (vp->tstart),
 591                            paddr (vp->tend),
 592                            paddr (vp->dstart),
 593                            paddr (vp->dend),
 594                            vp->name,
 595                            *vp->member ? "(" : "", vp->member,
 596                            *vp->member ? ")" : "");
 597     }
 598 }
 599
 600 static void
 601 set_section_command (char *args, int from_tty)
 602 {
 603   struct section_table *p;
 604   char *secname;
 605   unsigned seclen;
 606   unsigned long secaddr;
 607   char secprint[100];
 608   long offset;
 609
 610   if (args == 0)
 611     error (_("Must specify section name and its virtual address"));
 612
 613   /* Parse out section name */
 614   for (secname = args; !isspace (*args); args++);
 615   seclen = args - secname;
 616
 617   /* Parse out new virtual address */
 618   secaddr = parse_and_eval_address (args);
 619
 620   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 621     {
 622       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 623           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 624         {
 625           offset = secaddr - p->addr;
 626           p->addr += offset;
 627           p->endaddr += offset;
 628           if (from_tty)
 629             exec_files_info (&exec_ops);
 630           return;
 631         }
 632     }
 633   if (seclen >= sizeof (secprint))
 634     seclen = sizeof (secprint) - 1;
 635   strncpy (secprint, secname, seclen);
 636   secprint[seclen] = '\0';
 637   error (_("Section %s not found"), secprint);
 638 }
 639
 640 /* If we can find a section in FILENAME with BFD index INDEX, adjust
 641    it to ADDRESS.  */
 642
 643 void
 644 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 645 {
 646   struct section_table *p;
 647
 648   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 649     {
 650       if (strcmp (filename, p->bfd->filename) == 0
 651           && index == p->the_bfd_section->index)
 652         {
 653           p->endaddr += address - p->addr;
 654           p->addr = address;
 655         }
 656     }
 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 (struct bp_target_info *bp_tgt)
 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.deprecated_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_setshow_boolean_cmd ("write", class_support, &write_files, _("\
 741 Set writing into executable and core files."), _("\
 742 Show writing into executable and core files."), NULL,
 743                            NULL,
 744                            show_write_files,
 745                            &setlist, &showlist);
 746
 747   add_target (&exec_ops);
 748 }
 749
 750 static char *
 751 exec_make_note_section (bfd *obfd, int *note_size)
 752 {
 753   error (_("Can't create a corefile"));
 754 }