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       struct cleanup *cleanups;
 198       char *scratch_pathname;
 199       int scratch_chan;
 200
 201       scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
 202                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 203                             &scratch_pathname);
 204 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 205       if (scratch_chan < 0)
 206         {
 207           char *exename = alloca (strlen (filename) + 5);
 208           strcat (strcpy (exename, filename), ".exe");
 209           scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
 210              write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
 211              &scratch_pathname);
 212         }
 213 #endif
 214       if (scratch_chan < 0)
 215         perror_with_name (filename);
 216       exec_bfd = bfd_fopen (scratch_pathname, gnutarget,
 217                             write_files ? FOPEN_RUB : FOPEN_RB,
 218                             scratch_chan);
 219
 220       if (!exec_bfd)
 221         {
 222           close (scratch_chan);
 223           error (_("\"%s\": could not open as an executable file: %s"),
 224                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 225         }
 226
 227       /* At this point, scratch_pathname and exec_bfd->name both point to the
 228          same malloc'd string.  However exec_close() will attempt to free it
 229          via the exec_bfd->name pointer, so we need to make another copy and
 230          leave exec_bfd as the new owner of the original copy. */
 231       scratch_pathname = xstrdup (scratch_pathname);
 232       cleanups = make_cleanup (xfree, scratch_pathname);
 233
 234       if (!bfd_check_format (exec_bfd, bfd_object))
 235         {
 236           /* Make sure to close exec_bfd, or else "run" might try to use
 237              it.  */
 238           exec_close (0);
 239           error (_("\"%s\": not in executable format: %s"),
 240                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 241         }
 242
 243       /* FIXME - This should only be run for RS6000, but the ifdef is a poor
 244          way to accomplish.  */
 245 #ifdef DEPRECATED_IBM6000_TARGET
 246       /* Setup initial vmap. */
 247
 248       map_vmap (exec_bfd, 0);
 249       if (vmap == NULL)
 250         {
 251           /* Make sure to close exec_bfd, or else "run" might try to use
 252              it.  */
 253           exec_close (0);
 254           error (_("\"%s\": can't find the file sections: %s"),
 255                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 256         }
 257 #endif /* DEPRECATED_IBM6000_TARGET */
 258
 259       if (build_section_table (exec_bfd, &exec_ops.to_sections,
 260                                &exec_ops.to_sections_end))
 261         {
 262           /* Make sure to close exec_bfd, or else "run" might try to use
 263              it.  */
 264           exec_close (0);
 265           error (_("\"%s\": can't find the file sections: %s"),
 266                  scratch_pathname, bfd_errmsg (bfd_get_error ()));
 267         }
 268
 269       exec_bfd_mtime = bfd_get_mtime (exec_bfd);
 270
 271       validate_files ();
 272
 273       set_gdbarch_from_file (exec_bfd);
 274
 275       push_target (&exec_ops);
 276
 277       /* Tell display code (if any) about the changed file name.  */
 278       if (deprecated_exec_file_display_hook)
 279         (*deprecated_exec_file_display_hook) (filename);
 280
 281       do_cleanups (cleanups);
 282     }
 283   bfd_cache_close_all ();
 284   observer_notify_executable_changed ();
 285 }
 286
 287 /*  Process the first arg in ARGS as the new exec file.
 288
 289    Note that we have to explicitly ignore additional args, since we can
 290    be called from file_command(), which also calls symbol_file_command()
 291    which can take multiple args.
 292
 293    If ARGS is NULL, we just want to close the exec file. */
 294
 295 static void
 296 exec_file_command (char *args, int from_tty)
 297 {
 298   char **argv;
 299   char *filename;
 300
 301   if (from_tty && target_has_execution
 302       && !query (_("A program is being debugged already.\n"
 303                    "Are you sure you want to change the file? ")))
 304     error (_("File not changed."));
 305
 306   if (args)
 307     {
 308       struct cleanup *cleanups;
 309
 310       /* Scan through the args and pick up the first non option arg
 311          as the filename.  */
 312
 313       argv = gdb_buildargv (args);
 314       cleanups = make_cleanup_freeargv (argv);
 315
 316       for (; (*argv != NULL) && (**argv == '-'); argv++)
 317         {;
 318         }
 319       if (*argv == NULL)
 320         error (_("No executable file name was specified"));
 321
 322       filename = tilde_expand (*argv);
 323       make_cleanup (xfree, filename);
 324       exec_file_attach (filename, from_tty);
 325
 326       do_cleanups (cleanups);
 327     }
 328   else
 329     exec_file_attach (NULL, from_tty);
 330 }
 331
 332 /* Set both the exec file and the symbol file, in one command.
 333    What a novelty.  Why did GDB go through four major releases before this
 334    command was added?  */
 335
 336 static void
 337 file_command (char *arg, int from_tty)
 338 {
 339   /* FIXME, if we lose on reading the symbol file, we should revert
 340      the exec file, but that's rough.  */
 341   exec_file_command (arg, from_tty);
 342   symbol_file_command (arg, from_tty);
 343   if (deprecated_file_changed_hook)
 344     deprecated_file_changed_hook (arg);
 345 }
 346 \f
 347
 348 /* Locate all mappable sections of a BFD file.
 349    table_pp_char is a char * to get it through bfd_map_over_sections;
 350    we cast it back to its proper type.  */
 351
 352 static void
 353 add_to_section_table (bfd *abfd, struct bfd_section *asect,
 354                       void *table_pp_char)
 355 {
 356   struct section_table **table_pp = (struct section_table **) table_pp_char;
 357   flagword aflag;
 358
 359   /* Check the section flags, but do not discard zero-length sections, since
 360      some symbols may still be attached to this section.  For instance, we
 361      encountered on sparc-solaris 2.10 a shared library with an empty .bss
 362      section to which a symbol named "_end" was attached.  The address
 363      of this symbol still needs to be relocated.  */
 364   aflag = bfd_get_section_flags (abfd, asect);
 365   if (!(aflag & SEC_ALLOC))
 366     return;
 367
 368   (*table_pp)->bfd = abfd;
 369   (*table_pp)->the_bfd_section = asect;
 370   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 371   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 372   (*table_pp)++;
 373 }
 374
 375 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 376    Returns 0 if OK, 1 on error.  */
 377
 378 int
 379 build_section_table (struct bfd *some_bfd, struct section_table **start,
 380                      struct section_table **end)
 381 {
 382   unsigned count;
 383
 384   count = bfd_count_sections (some_bfd);
 385   if (*start)
 386     xfree (* start);
 387   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 388   *end = *start;
 389   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 390   if (*end > *start + count)
 391     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 392   /* We could realloc the table, but it probably loses for most files.  */
 393   return 0;
 394 }
 395 \f
 396 static void
 397 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
 398 {
 399   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 400   struct vmap *vp;
 401
 402   vp = vmap_bfd->pvmap;
 403
 404   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 405     return;
 406
 407   if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
 408     {
 409       vp->tstart = bfd_section_vma (abfd, sect);
 410       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 411       vp->tvma = bfd_section_vma (abfd, sect);
 412       vp->toffs = sect->filepos;
 413     }
 414   else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
 415     {
 416       vp->dstart = bfd_section_vma (abfd, sect);
 417       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 418       vp->dvma = bfd_section_vma (abfd, sect);
 419     }
 420   /* Silently ignore other types of sections. (FIXME?)  */
 421 }
 422
 423 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 424    Return the new vmap.  */
 425
 426 struct vmap *
 427 map_vmap (bfd *abfd, bfd *arch)
 428 {
 429   struct vmap_and_bfd vmap_bfd;
 430   struct vmap *vp, **vpp;
 431
 432   vp = (struct vmap *) xmalloc (sizeof (*vp));
 433   memset ((char *) vp, '\0', sizeof (*vp));
 434   vp->nxt = 0;
 435   vp->bfd = abfd;
 436   vp->name = bfd_get_filename (arch ? arch : abfd);
 437   vp->member = arch ? bfd_get_filename (abfd) : "";
 438
 439   vmap_bfd.pbfd = arch;
 440   vmap_bfd.pvmap = vp;
 441   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 442
 443   /* Find the end of the list and append. */
 444   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 445     ;
 446   *vpp = vp;
 447
 448   return vp;
 449 }
 450 \f
 451 /* Read or write the exec file.
 452
 453    Args are address within a BFD file, address within gdb address-space,
 454    length, and a flag indicating whether to read or write.
 455
 456    Result is a length:
 457
 458    0:    We cannot handle this address and length.
 459    > 0:  We have handled N bytes starting at this address.
 460    (If N == length, we did it all.)  We might be able
 461    to handle more bytes beyond this length, but no
 462    promises.
 463    < 0:  We cannot handle this address, but if somebody
 464    else handles (-N) bytes, we can start from there.
 465
 466    The same routine is used to handle both core and exec files;
 467    we just tail-call it with more arguments to select between them.  */
 468
 469 int
 470 xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
 471              struct mem_attrib *attrib, struct target_ops *target)
 472 {
 473   int res;
 474   struct section_table *p;
 475   CORE_ADDR nextsectaddr, memend;
 476   struct obj_section *section = NULL;
 477
 478   if (len <= 0)
 479     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 480
 481   if (overlay_debugging)
 482     {
 483       section = find_pc_overlay (memaddr);
 484       if (pc_in_unmapped_range (memaddr, section))
 485         memaddr = overlay_mapped_address (memaddr, section);
 486     }
 487
 488   memend = memaddr + len;
 489   nextsectaddr = memend;
 490
 491   for (p = target->to_sections; p < target->to_sections_end; p++)
 492     {
 493       if (overlay_debugging && section
 494           && strcmp (section->the_bfd_section->name,
 495                      p->the_bfd_section->name) != 0)
 496         continue;               /* not the section we need */
 497       if (memaddr >= p->addr)
 498         {
 499           if (memend <= p->endaddr)
 500             {
 501               /* Entire transfer is within this section.  */
 502               if (write)
 503                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 504                                                 myaddr, memaddr - p->addr,
 505                                                 len);
 506               else
 507                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 508                                                 myaddr, memaddr - p->addr,
 509                                                 len);
 510               return (res != 0) ? len : 0;
 511             }
 512           else if (memaddr >= p->endaddr)
 513             {
 514               /* This section ends before the transfer starts.  */
 515               continue;
 516             }
 517           else
 518             {
 519               /* This section overlaps the transfer.  Just do half.  */
 520               len = p->endaddr - memaddr;
 521               if (write)
 522                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 523                                                 myaddr, memaddr - p->addr,
 524                                                 len);
 525               else
 526                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 527                                                 myaddr, memaddr - p->addr,
 528                                                 len);
 529               return (res != 0) ? len : 0;
 530             }
 531         }
 532       else
 533         nextsectaddr = min (nextsectaddr, p->addr);
 534     }
 535
 536   if (nextsectaddr >= memend)
 537     return 0;                   /* We can't help */
 538   else
 539     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 540 }
 541 \f
 542
 543 void
 544 print_section_info (struct target_ops *t, bfd *abfd)
 545 {
 546   struct section_table *p;
 547   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
 548   int wid = gdbarch_addr_bit (gdbarch_from_bfd (abfd)) <= 32 ? 8 : 16;
 549
 550   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 551   wrap_here ("        ");
 552   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 553   if (abfd == exec_bfd)
 554     printf_filtered (_("\tEntry point: %s\n"),
 555                      paddress (bfd_get_start_address (abfd)));
 556   for (p = t->to_sections; p < t->to_sections_end; p++)
 557     {
 558       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 559       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 560
 561       /* FIXME: A format of "08l" is not wide enough for file offsets
 562          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 563          since most output will then be much wider than necessary.  It
 564          may make sense to test the size of the file and choose the
 565          format string accordingly.  */
 566       /* FIXME: i18n: Need to rewrite this sentence.  */
 567       if (info_verbose)
 568         printf_filtered (" @ %s",
 569                          hex_string_custom (p->the_bfd_section->filepos, 8));
 570       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 571       if (p->bfd != abfd)
 572         printf_filtered (" in %s", bfd_get_filename (p->bfd));
 573       printf_filtered ("\n");
 574     }
 575 }
 576
 577 static void
 578 exec_files_info (struct target_ops *t)
 579 {
 580   print_section_info (t, exec_bfd);
 581
 582   if (vmap)
 583     {
 584       struct vmap *vp;
 585
 586       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
 587       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
 588                          strlen_paddr (), "tstart",
 589                          strlen_paddr (), "tend",
 590                          strlen_paddr (), "dstart",
 591                          strlen_paddr (), "dend",
 592                          "section",
 593                          "file(member)");
 594
 595       for (vp = vmap; vp; vp = vp->nxt)
 596         printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
 597                            paddr (vp->tstart),
 598                            paddr (vp->tend),
 599                            paddr (vp->dstart),
 600                            paddr (vp->dend),
 601                            vp->name,
 602                            *vp->member ? "(" : "", vp->member,
 603                            *vp->member ? ")" : "");
 604     }
 605 }
 606
 607 static void
 608 set_section_command (char *args, int from_tty)
 609 {
 610   struct section_table *p;
 611   char *secname;
 612   unsigned seclen;
 613   unsigned long secaddr;
 614   char secprint[100];
 615   long offset;
 616
 617   if (args == 0)
 618     error (_("Must specify section name and its virtual address"));
 619
 620   /* Parse out section name */
 621   for (secname = args; !isspace (*args); args++);
 622   seclen = args - secname;
 623
 624   /* Parse out new virtual address */
 625   secaddr = parse_and_eval_address (args);
 626
 627   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 628     {
 629       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
 630           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
 631         {
 632           offset = secaddr - p->addr;
 633           p->addr += offset;
 634           p->endaddr += offset;
 635           if (from_tty)
 636             exec_files_info (&exec_ops);
 637           return;
 638         }
 639     }
 640   if (seclen >= sizeof (secprint))
 641     seclen = sizeof (secprint) - 1;
 642   strncpy (secprint, secname, seclen);
 643   secprint[seclen] = '\0';
 644   error (_("Section %s not found"), secprint);
 645 }
 646
 647 /* If we can find a section in FILENAME with BFD index INDEX, adjust
 648    it to ADDRESS.  */
 649
 650 void
 651 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 652 {
 653   struct section_table *p;
 654
 655   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 656     {
 657       if (strcmp (filename, p->bfd->filename) == 0
 658           && index == p->the_bfd_section->index)
 659         {
 660           p->endaddr += address - p->addr;
 661           p->addr = address;
 662         }
 663     }
 664 }
 665
 666 /* If mourn is being called in all the right places, this could be say
 667    `gdb internal error' (since generic_mourn calls
 668    breakpoint_init_inferior).  */
 669
 670 static int
 671 ignore (struct bp_target_info *bp_tgt)
 672 {
 673   return 0;
 674 }
 675
 676 /* Find mapped memory. */
 677
 678 extern void
 679 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
 680                                                     unsigned long,
 681                                                     int, int, int,
 682                                                     void *),
 683                                            void *))
 684 {
 685   exec_ops.to_find_memory_regions = func;
 686 }
 687
 688 static char *exec_make_note_section (bfd *, int *);
 689
 690 /* Fill in the exec file target vector.  Very few entries need to be
 691    defined.  */
 692
 693 static void
 694 init_exec_ops (void)
 695 {
 696   exec_ops.to_shortname = "exec";
 697   exec_ops.to_longname = "Local exec file";
 698   exec_ops.to_doc = "Use an executable file as a target.\n\
 699 Specify the filename of the executable file.";
 700   exec_ops.to_open = exec_open;
 701   exec_ops.to_close = exec_close;
 702   exec_ops.to_attach = find_default_attach;
 703   exec_ops.deprecated_xfer_memory = xfer_memory;
 704   exec_ops.to_files_info = exec_files_info;
 705   exec_ops.to_insert_breakpoint = ignore;
 706   exec_ops.to_remove_breakpoint = ignore;
 707   exec_ops.to_create_inferior = find_default_create_inferior;
 708   exec_ops.to_stratum = file_stratum;
 709   exec_ops.to_has_memory = 1;
 710   exec_ops.to_make_corefile_notes = exec_make_note_section;
 711   exec_ops.to_magic = OPS_MAGIC;
 712 }
 713
 714 void
 715 _initialize_exec (void)
 716 {
 717   struct cmd_list_element *c;
 718
 719   init_exec_ops ();
 720
 721   if (!dbx_commands)
 722     {
 723       c = add_cmd ("file", class_files, file_command, _("\
 724 Use FILE as program to be debugged.\n\
 725 It is read for its symbols, for getting the contents of pure memory,\n\
 726 and it is the program executed when you use the `run' command.\n\
 727 If FILE cannot be found as specified, your execution directory path\n\
 728 ($PATH) is searched for a command of that name.\n\
 729 No arg means to have no executable file and no symbols."), &cmdlist);
 730       set_cmd_completer (c, filename_completer);
 731     }
 732
 733   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
 734 Use FILE as program for getting contents of pure memory.\n\
 735 If FILE cannot be found as specified, your execution directory path\n\
 736 is searched for a command of that name.\n\
 737 No arg means have no executable file."), &cmdlist);
 738   set_cmd_completer (c, filename_completer);
 739
 740   add_com ("section", class_files, set_section_command, _("\
 741 Change the base address of section SECTION of the exec file to ADDR.\n\
 742 This can be used if the exec file does not contain section addresses,\n\
 743 (such as in the a.out format), or when the addresses specified in the\n\
 744 file itself are wrong.  Each section must be changed separately.  The\n\
 745 ``info files'' command lists all the sections and their addresses."));
 746
 747   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
 748 Set writing into executable and core files."), _("\
 749 Show writing into executable and core files."), NULL,
 750                            NULL,
 751                            show_write_files,
 752                            &setlist, &showlist);
 753
 754   add_target (&exec_ops);
 755 }
 756
 757 static char *
 758 exec_make_note_section (bfd *obfd, int *note_size)
 759 {
 760   error (_("Can't create a corefile"));
 761 }