gdb/exec.c

   1 /* Work with executable files, for GDB.
   2
   3    Copyright (C) 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., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, 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 #include "observer.h"
  36
  37 #include <fcntl.h>
  38 #include "readline/readline.h"
  39 #include "gdb_string.h"
  40
  41 #include "gdbcore.h"
  42
  43 #include <ctype.h>
  44 #include "gdb_stat.h"
  45
  46 #include "xcoffsolib.h"
  47
  48 struct vmap *map_vmap (bfd *, bfd *);
  49
  50 void (*deprecated_file_changed_hook) (char *);
  51
  52 /* Prototypes for local functions */
  53
  54 static void exec_close (int);
  55
  56 static void file_command (char *, int);
  57
  58 static void set_section_command (char *, int);
  59
  60 static void exec_files_info (struct target_ops *);
  61
  62 static void init_exec_ops (void);
  63
  64 void _initialize_exec (void);
  65
  66 /* The target vector for executable files.  */
  67
  68 struct target_ops exec_ops;
  69
  70 /* The Binary File Descriptor handle for the executable file.  */
  71
  72 bfd *exec_bfd = NULL;
  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     }
 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_fopen (scratch_pathname, gnutarget,
 213                             write_files ? FOPEN_RUB : FOPEN_RB,
 214                             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       validate_files ();
 263
 264       set_gdbarch_from_file (exec_bfd);
 265
 266       push_target (&exec_ops);
 267
 268       /* Tell display code (if any) about the changed file name.  */
 269       if (deprecated_exec_file_display_hook)
 270         (*deprecated_exec_file_display_hook) (filename);
 271     }
 272   bfd_cache_close_all ();
 273   observer_notify_executable_changed (NULL);
 274 }
 275
 276 /*  Process the first arg in ARGS as the new exec file.
 277
 278    Note that we have to explicitly ignore additional args, since we can
 279    be called from file_command(), which also calls symbol_file_command()
 280    which can take multiple args.
 281
 282    If ARGS is NULL, we just want to close the exec file. */
 283
 284 static void
 285 exec_file_command (char *args, int from_tty)
 286 {
 287   char **argv;
 288   char *filename;
 289
 290   if (from_tty && target_has_execution
 291       && !query (_("A program is being debugged already.\n"
 292                    "Are you sure you want to change the file? ")))
 293     error (_("File not changed."));
 294
 295   if (args)
 296     {
 297       /* Scan through the args and pick up the first non option arg
 298          as the filename.  */
 299
 300       argv = buildargv (args);
 301       if (argv == NULL)
 302         nomem (0);
 303
 304       make_cleanup_freeargv (argv);
 305
 306       for (; (*argv != NULL) && (**argv == '-'); argv++)
 307         {;
 308         }
 309       if (*argv == NULL)
 310         error (_("No executable file name was specified"));
 311
 312       filename = tilde_expand (*argv);
 313       make_cleanup (xfree, filename);
 314       exec_file_attach (filename, from_tty);
 315     }
 316   else
 317     exec_file_attach (NULL, from_tty);
 318 }
 319
 320 /* Set both the exec file and the symbol file, in one command.
 321    What a novelty.  Why did GDB go through four major releases before this
 322    command was added?  */
 323
 324 static void
 325 file_command (char *arg, int from_tty)
 326 {
 327   /* FIXME, if we lose on reading the symbol file, we should revert
 328      the exec file, but that's rough.  */
 329   exec_file_command (arg, from_tty);
 330   symbol_file_command (arg, from_tty);
 331   if (deprecated_file_changed_hook)
 332     deprecated_file_changed_hook (arg);
 333 }
 334 \f
 335
 336 /* Locate all mappable sections of a BFD file.
 337    table_pp_char is a char * to get it through bfd_map_over_sections;
 338    we cast it back to its proper type.  */
 339
 340 static void
 341 add_to_section_table (bfd *abfd, struct bfd_section *asect,
 342                       void *table_pp_char)
 343 {
 344   struct section_table **table_pp = (struct section_table **) table_pp_char;
 345   flagword aflag;
 346
 347   aflag = bfd_get_section_flags (abfd, asect);
 348   if (!(aflag & SEC_ALLOC))
 349     return;
 350   if (0 == bfd_section_size (abfd, asect))
 351     return;
 352   (*table_pp)->bfd = abfd;
 353   (*table_pp)->the_bfd_section = asect;
 354   (*table_pp)->addr = bfd_section_vma (abfd, asect);
 355   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
 356   (*table_pp)++;
 357 }
 358
 359 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
 360    Returns 0 if OK, 1 on error.  */
 361
 362 int
 363 build_section_table (struct bfd *some_bfd, struct section_table **start,
 364                      struct section_table **end)
 365 {
 366   unsigned count;
 367
 368   count = bfd_count_sections (some_bfd);
 369   if (*start)
 370     xfree (* start);
 371   *start = (struct section_table *) xmalloc (count * sizeof (**start));
 372   *end = *start;
 373   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
 374   if (*end > *start + count)
 375     internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 376   /* We could realloc the table, but it probably loses for most files.  */
 377   return 0;
 378 }
 379 \f
 380 static void
 381 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
 382 {
 383   struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
 384   struct vmap *vp;
 385
 386   vp = vmap_bfd->pvmap;
 387
 388   if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
 389     return;
 390
 391   if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
 392     {
 393       vp->tstart = bfd_section_vma (abfd, sect);
 394       vp->tend = vp->tstart + bfd_section_size (abfd, sect);
 395       vp->tvma = bfd_section_vma (abfd, sect);
 396       vp->toffs = sect->filepos;
 397     }
 398   else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
 399     {
 400       vp->dstart = bfd_section_vma (abfd, sect);
 401       vp->dend = vp->dstart + bfd_section_size (abfd, sect);
 402       vp->dvma = bfd_section_vma (abfd, sect);
 403     }
 404   /* Silently ignore other types of sections. (FIXME?)  */
 405 }
 406
 407 /* Make a vmap for ABFD which might be a member of the archive ARCH.
 408    Return the new vmap.  */
 409
 410 struct vmap *
 411 map_vmap (bfd *abfd, bfd *arch)
 412 {
 413   struct vmap_and_bfd vmap_bfd;
 414   struct vmap *vp, **vpp;
 415
 416   vp = (struct vmap *) xmalloc (sizeof (*vp));
 417   memset ((char *) vp, '\0', sizeof (*vp));
 418   vp->nxt = 0;
 419   vp->bfd = abfd;
 420   vp->name = bfd_get_filename (arch ? arch : abfd);
 421   vp->member = arch ? bfd_get_filename (abfd) : "";
 422
 423   vmap_bfd.pbfd = arch;
 424   vmap_bfd.pvmap = vp;
 425   bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
 426
 427   /* Find the end of the list and append. */
 428   for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
 429     ;
 430   *vpp = vp;
 431
 432   return vp;
 433 }
 434 \f
 435 /* Read or write the exec file.
 436
 437    Args are address within a BFD file, address within gdb address-space,
 438    length, and a flag indicating whether to read or write.
 439
 440    Result is a length:
 441
 442    0:    We cannot handle this address and length.
 443    > 0:  We have handled N bytes starting at this address.
 444    (If N == length, we did it all.)  We might be able
 445    to handle more bytes beyond this length, but no
 446    promises.
 447    < 0:  We cannot handle this address, but if somebody
 448    else handles (-N) bytes, we can start from there.
 449
 450    The same routine is used to handle both core and exec files;
 451    we just tail-call it with more arguments to select between them.  */
 452
 453 int
 454 xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
 455              struct mem_attrib *attrib, struct target_ops *target)
 456 {
 457   int res;
 458   struct section_table *p;
 459   CORE_ADDR nextsectaddr, memend;
 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   nextsectaddr = memend;
 474
 475   for (p = target->to_sections; p < target->to_sections_end; p++)
 476     {
 477       if (overlay_debugging && section && p->the_bfd_section &&
 478           strcmp (section->name, p->the_bfd_section->name) != 0)
 479         continue;               /* not the section we need */
 480       if (memaddr >= p->addr)
 481         {
 482           if (memend <= p->endaddr)
 483             {
 484               /* Entire transfer is within this section.  */
 485               if (write)
 486                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 487                                                 myaddr, memaddr - p->addr,
 488                                                 len);
 489               else
 490                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 491                                                 myaddr, memaddr - p->addr,
 492                                                 len);
 493               return (res != 0) ? len : 0;
 494             }
 495           else if (memaddr >= p->endaddr)
 496             {
 497               /* This section ends before the transfer starts.  */
 498               continue;
 499             }
 500           else
 501             {
 502               /* This section overlaps the transfer.  Just do half.  */
 503               len = p->endaddr - memaddr;
 504               if (write)
 505                 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
 506                                                 myaddr, memaddr - p->addr,
 507                                                 len);
 508               else
 509                 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
 510                                                 myaddr, memaddr - p->addr,
 511                                                 len);
 512               return (res != 0) ? len : 0;
 513             }
 514         }
 515       else
 516         nextsectaddr = min (nextsectaddr, p->addr);
 517     }
 518
 519   if (nextsectaddr >= memend)
 520     return 0;                   /* We can't help */
 521   else
 522     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
 523 }
 524 \f
 525
 526 void
 527 print_section_info (struct target_ops *t, bfd *abfd)
 528 {
 529   struct section_table *p;
 530   /* FIXME: 16 is not wide enough when TARGET_ADDR_BIT > 64.  */
 531   int wid = TARGET_ADDR_BIT <= 32 ? 8 : 16;
 532
 533   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
 534   wrap_here ("        ");
 535   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
 536   if (abfd == exec_bfd)
 537     {
 538       printf_filtered (_("\tEntry point: "));
 539       deprecated_print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
 540       printf_filtered ("\n");
 541     }
 542   for (p = t->to_sections; p < t->to_sections_end; p++)
 543     {
 544       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
 545       printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
 546
 547       /* FIXME: A format of "08l" is not wide enough for file offsets
 548          larger than 4GB.  OTOH, making it "016l" isn't desirable either
 549          since most output will then be much wider than necessary.  It
 550          may make sense to test the size of the file and choose the
 551          format string accordingly.  */
 552       /* FIXME: i18n: Need to rewrite this sentence.  */
 553       if (info_verbose)
 554         printf_filtered (" @ %s",
 555                          hex_string_custom (p->the_bfd_section->filepos, 8));
 556       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
 557       if (p->bfd != abfd)
 558         printf_filtered (" in %s", bfd_get_filename (p->bfd));
 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 we can find a section in FILENAME with BFD index INDEX, and the
 670    user has not assigned an address to it yet (via "set section"), adjust it
 671    to ADDRESS.  */
 672
 673 void
 674 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
 675 {
 676   struct section_table *p;
 677
 678   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
 679     {
 680       if (strcmp (filename, p->bfd->filename) == 0
 681           && index == p->the_bfd_section->index
 682           && p->addr == 0)
 683         {
 684           p->addr = address;
 685           p->endaddr += address;
 686         }
 687     }
 688 }
 689
 690 /* If mourn is being called in all the right places, this could be say
 691    `gdb internal error' (since generic_mourn calls
 692    breakpoint_init_inferior).  */
 693
 694 static int
 695 ignore (struct bp_target_info *bp_tgt)
 696 {
 697   return 0;
 698 }
 699
 700 /* Find mapped memory. */
 701
 702 extern void
 703 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
 704                                                     unsigned long,
 705                                                     int, int, int,
 706                                                     void *),
 707                                            void *))
 708 {
 709   exec_ops.to_find_memory_regions = func;
 710 }
 711
 712 static char *exec_make_note_section (bfd *, int *);
 713
 714 /* Fill in the exec file target vector.  Very few entries need to be
 715    defined.  */
 716
 717 static void
 718 init_exec_ops (void)
 719 {
 720   exec_ops.to_shortname = "exec";
 721   exec_ops.to_longname = "Local exec file";
 722   exec_ops.to_doc = "Use an executable file as a target.\n\
 723 Specify the filename of the executable file.";
 724   exec_ops.to_open = exec_open;
 725   exec_ops.to_close = exec_close;
 726   exec_ops.to_attach = find_default_attach;
 727   exec_ops.deprecated_xfer_memory = xfer_memory;
 728   exec_ops.to_files_info = exec_files_info;
 729   exec_ops.to_insert_breakpoint = ignore;
 730   exec_ops.to_remove_breakpoint = ignore;
 731   exec_ops.to_create_inferior = find_default_create_inferior;
 732   exec_ops.to_stratum = file_stratum;
 733   exec_ops.to_has_memory = 1;
 734   exec_ops.to_make_corefile_notes = exec_make_note_section;
 735   exec_ops.to_magic = OPS_MAGIC;
 736 }
 737
 738 void
 739 _initialize_exec (void)
 740 {
 741   struct cmd_list_element *c;
 742
 743   init_exec_ops ();
 744
 745   if (!dbx_commands)
 746     {
 747       c = add_cmd ("file", class_files, file_command, _("\
 748 Use FILE as program to be debugged.\n\
 749 It is read for its symbols, for getting the contents of pure memory,\n\
 750 and it is the program executed when you use the `run' command.\n\
 751 If FILE cannot be found as specified, your execution directory path\n\
 752 ($PATH) is searched for a command of that name.\n\
 753 No arg means to have no executable file and no symbols."), &cmdlist);
 754       set_cmd_completer (c, filename_completer);
 755     }
 756
 757   c = add_cmd ("exec-file", class_files, exec_file_command, _("\
 758 Use FILE as program for getting contents of pure memory.\n\
 759 If FILE cannot be found as specified, your execution directory path\n\
 760 is searched for a command of that name.\n\
 761 No arg means have no executable file."), &cmdlist);
 762   set_cmd_completer (c, filename_completer);
 763
 764   add_com ("section", class_files, set_section_command, _("\
 765 Change the base address of section SECTION of the exec file to ADDR.\n\
 766 This can be used if the exec file does not contain section addresses,\n\
 767 (such as in the a.out format), or when the addresses specified in the\n\
 768 file itself are wrong.  Each section must be changed separately.  The\n\
 769 ``info files'' command lists all the sections and their addresses."));
 770
 771   add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
 772 Set writing into executable and core files."), _("\
 773 Show writing into executable and core files."), NULL,
 774                            NULL,
 775                            show_write_files,
 776                            &setlist, &showlist);
 777
 778   add_target (&exec_ops);
 779 }
 780
 781 static char *
 782 exec_make_note_section (bfd *obfd, int *note_size)
 783 {
 784   error (_("Can't create a corefile"));
 785 }