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