This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / gdb / exec.c
1 /* Work with executable files, for GDB. 
2    Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1997, 1998
3    Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
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
31 #ifdef USG
32 #include <sys/types.h>
33 #endif
34
35 #include <fcntl.h>
36 #include "gdb_string.h"
37
38 #include "gdbcore.h"
39
40 #include <ctype.h>
41 #include "gdb_stat.h"
42 #ifndef O_BINARY
43 #define O_BINARY 0
44 #endif
45
46 #include "xcoffsolib.h"
47
48 struct vmap *map_vmap PARAMS ((bfd *, bfd *));
49
50 void (*file_changed_hook) PARAMS ((char *));
51
52 /* Prototypes for local functions */
53
54 static void add_to_section_table PARAMS ((bfd *, sec_ptr, PTR));
55
56 static void exec_close PARAMS ((int));
57
58 static void file_command PARAMS ((char *, int));
59
60 static void set_section_command PARAMS ((char *, int));
61
62 static void exec_files_info PARAMS ((struct target_ops *));
63
64 static void bfdsec_to_vmap PARAMS ((bfd *, sec_ptr, PTR));
65
66 static int ignore PARAMS ((CORE_ADDR, char *));
67
68 static void init_exec_ops PARAMS ((void));
69
70 void _initialize_exec PARAMS ((void));
71
72 extern int info_verbose;
73
74 /* The target vector for executable files.  */
75
76 struct target_ops exec_ops;
77
78 /* The Binary File Descriptor handle for the executable file.  */
79
80 bfd *exec_bfd = NULL;
81
82 /* Whether to open exec and core files read-only or read-write.  */
83
84 int write_files = 0;
85
86 /* Text start and end addresses (KLUDGE) if needed */
87
88 #ifndef NEED_TEXT_START_END
89 #define NEED_TEXT_START_END (0)
90 #endif
91 CORE_ADDR text_start = 0;
92 CORE_ADDR text_end = 0;
93
94 struct vmap *vmap;
95
96 /* ARGSUSED */
97 static void
98 exec_close (quitting)
99      int quitting;
100 {
101   int need_symtab_cleanup = 0;
102   struct vmap *vp, *nxt;
103
104   for (nxt = vmap; nxt != NULL;)
105     {
106       vp = nxt;
107       nxt = vp->nxt;
108
109       /* if there is an objfile associated with this bfd,
110          free_objfile() will do proper cleanup of objfile *and* bfd. */
111
112       if (vp->objfile)
113         {
114           free_objfile (vp->objfile);
115           need_symtab_cleanup = 1;
116         }
117       else if (vp->bfd != exec_bfd)
118         /* FIXME-leak: We should be freeing vp->name too, I think.  */
119         if (!bfd_close (vp->bfd))
120           warning ("cannot close \"%s\": %s",
121                    vp->name, bfd_errmsg (bfd_get_error ()));
122
123       /* FIXME: This routine is #if 0'd in symfile.c.  What should we
124          be doing here?  Should we just free everything in
125          vp->objfile->symtabs?  Should free_objfile do that?
126          FIXME-as-well: free_objfile already free'd vp->name, so it isn't
127          valid here.  */
128       free_named_symtabs (vp->name);
129       free (vp);
130     }
131
132   vmap = NULL;
133
134   if (exec_bfd)
135     {
136       char *name = bfd_get_filename (exec_bfd);
137
138       if (!bfd_close (exec_bfd))
139         warning ("cannot close \"%s\": %s",
140                  name, bfd_errmsg (bfd_get_error ()));
141       free (name);
142       exec_bfd = NULL;
143     }
144
145   if (exec_ops.to_sections)
146     {
147       free ((PTR) exec_ops.to_sections);
148       exec_ops.to_sections = NULL;
149       exec_ops.to_sections_end = NULL;
150     }
151 }
152
153 /*  Process the first arg in ARGS as the new exec file.
154
155    This function is intended to be behave essentially the same
156    as exec_file_command, except that the latter will detect when
157    a target is being debugged, and will ask the user whether it
158    should be shut down first.  (If the answer is "no", then the
159    new file is ignored.)
160
161    This file is used by exec_file_command, to do the work of opening
162    and processing the exec file after any prompting has happened.
163
164    And, it is used by child_attach, when the attach command was
165    given a pid but not a exec pathname, and the attach command could
166    figure out the pathname from the pid.  (In this case, we shouldn't
167    ask the user whether the current target should be shut down --
168    we're supplying the exec pathname late for good reason.) */
169
170 void
171 exec_file_attach (args, from_tty)
172      char *args;
173      int from_tty;
174 {
175   char **argv;
176   char *filename;
177
178   /* Remove any previous exec file.  */
179   unpush_target (&exec_ops);
180
181   /* Now open and digest the file the user requested, if any.  */
182
183   if (args)
184     {
185       char *scratch_pathname;
186       int scratch_chan;
187
188       /* Scan through the args and pick up the first non option arg
189          as the filename.  */
190
191       argv = buildargv (args);
192       if (argv == NULL)
193         nomem (0);
194
195       make_cleanup_freeargv (argv);
196
197       for (; (*argv != NULL) && (**argv == '-'); argv++)
198         {;
199         }
200       if (*argv == NULL)
201         error ("no exec file name was specified");
202
203       filename = tilde_expand (*argv);
204       make_cleanup (free, filename);
205
206       scratch_chan = openp (getenv ("PATH"), 1, filename,
207                    write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
208                             &scratch_pathname);
209 #if defined(__GO32__) || defined(_WIN32)
210       if (scratch_chan < 0)
211         {
212           char *exename = alloca (strlen (filename) + 5);
213           strcat (strcpy (exename, filename), ".exe");
214           scratch_chan = openp (getenv ("PATH"), 1, exename, write_files ?
215              O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0, &scratch_pathname);
216         }
217 #endif
218       if (scratch_chan < 0)
219         perror_with_name (filename);
220       exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
221
222       if (!exec_bfd)
223         error ("\"%s\": could not open as an executable file: %s",
224                scratch_pathname, bfd_errmsg (bfd_get_error ()));
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 = strdup (scratch_pathname);
231       make_cleanup (free, 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 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 /* 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       /* text_end is sometimes used for where to put call dummies.  A
269          few ports use these for other purposes too.  */
270       if (NEED_TEXT_START_END)
271         {
272           struct section_table *p;
273
274           /* Set text_start to the lowest address of the start of any
275              readonly code section and set text_end to the highest
276              address of the end of any readonly code section.  */
277           /* FIXME: The comment above does not match the code.  The
278              code checks for sections with are either code *or*
279              readonly.  */
280           text_start = ~(CORE_ADDR) 0;
281           text_end = (CORE_ADDR) 0;
282           for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
283             if (bfd_get_section_flags (p->bfd, p->the_bfd_section)
284                 & (SEC_CODE | SEC_READONLY))
285               {
286                 if (text_start > p->addr)
287                   text_start = p->addr;
288                 if (text_end < p->endaddr)
289                   text_end = p->endaddr;
290               }
291         }
292
293       validate_files ();
294
295       set_gdbarch_from_file (exec_bfd);
296
297       push_target (&exec_ops);
298
299       /* Tell display code (if any) about the changed file name.  */
300       if (exec_file_display_hook)
301         (*exec_file_display_hook) (filename);
302     }
303   else if (from_tty)
304     printf_unfiltered ("No executable file now.\n");
305 }
306
307 /*  Process the first arg in ARGS as the new exec file.
308
309    Note that we have to explicitly ignore additional args, since we can
310    be called from file_command(), which also calls symbol_file_command()
311    which can take multiple args. */
312
313 void
314 exec_file_command (args, from_tty)
315      char *args;
316      int from_tty;
317 {
318   char **argv;
319   char *filename;
320
321   target_preopen (from_tty);
322
323   exec_file_attach (args, from_tty);
324 }
325
326 /* Set both the exec file and the symbol file, in one command.  
327    What a novelty.  Why did GDB go through four major releases before this
328    command was added?  */
329
330 static void
331 file_command (arg, from_tty)
332      char *arg;
333      int from_tty;
334 {
335   /* FIXME, if we lose on reading the symbol file, we should revert
336      the exec file, but that's rough.  */
337   exec_file_command (arg, from_tty);
338   symbol_file_command (arg, from_tty);
339   if (file_changed_hook)
340     file_changed_hook (arg);
341 }
342 \f
343
344 /* Locate all mappable sections of a BFD file. 
345    table_pp_char is a char * to get it through bfd_map_over_sections;
346    we cast it back to its proper type.  */
347
348 static void
349 add_to_section_table (abfd, asect, table_pp_char)
350      bfd *abfd;
351      sec_ptr asect;
352      PTR table_pp_char;
353 {
354   struct section_table **table_pp = (struct section_table **) table_pp_char;
355   flagword aflag;
356
357   aflag = bfd_get_section_flags (abfd, asect);
358   if (!(aflag & SEC_ALLOC))
359     return;
360   if (0 == bfd_section_size (abfd, asect))
361     return;
362   (*table_pp)->bfd = abfd;
363   (*table_pp)->the_bfd_section = asect;
364   (*table_pp)->addr = bfd_section_vma (abfd, asect);
365   (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
366   (*table_pp)++;
367 }
368
369 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
370    Returns 0 if OK, 1 on error.  */
371
372 int
373 build_section_table (some_bfd, start, end)
374      bfd *some_bfd;
375      struct section_table **start, **end;
376 {
377   unsigned count;
378
379   count = bfd_count_sections (some_bfd);
380   if (*start)
381     free ((PTR) * start);
382   *start = (struct section_table *) xmalloc (count * sizeof (**start));
383   *end = *start;
384   bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
385   if (*end > *start + count)
386     abort ();
387   /* We could realloc the table, but it probably loses for most files.  */
388   return 0;
389 }
390 \f
391 static void
392 bfdsec_to_vmap (abfd, sect, arg3)
393      bfd *abfd;
394      sec_ptr sect;
395      PTR 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 (STREQ (bfd_section_name (abfd, sect), ".text"))
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 (STREQ (bfd_section_name (abfd, sect), ".data"))
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 (abfd, arch)
426      bfd *abfd;
427      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 (memaddr, myaddr, len, write, target)
471      CORE_ADDR memaddr;
472      char *myaddr;
473      int len;
474      int write;
475      struct target_ops *target;
476 {
477   boolean res;
478   struct section_table *p;
479   CORE_ADDR nextsectaddr, memend;
480   boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
481   asection *section;
482
483   if (len <= 0)
484     abort ();
485
486   if (overlay_debugging)
487     {
488       section = find_pc_overlay (memaddr);
489       if (pc_in_unmapped_range (memaddr, section))
490         memaddr = overlay_mapped_address (memaddr, section);
491     }
492
493   memend = memaddr + len;
494   xfer_fn = write ? bfd_set_section_contents : bfd_get_section_contents;
495   nextsectaddr = memend;
496
497 #if 0                           /* Stu's implementation */
498 /* If a section has been specified, try to use it.  Note that we cannot use the
499    specified section directly.  This is because it usually comes from the
500    symbol file, which may be different from the exec or core file.  Instead, we
501    have to lookup the specified section by name in the bfd associated with
502    to_sections.  */
503
504   if (target_memory_bfd_section)
505     {
506       asection *s;
507       bfd *abfd;
508       asection *target_section;
509       bfd *target_bfd;
510
511       s = target_memory_bfd_section;
512       abfd = s->owner;
513
514       target_bfd = target->to_sections->bfd;
515       target_section = bfd_get_section_by_name (target_bfd, bfd_section_name (abfd, s));
516
517       if (target_section)
518         {
519           bfd_vma sec_addr;
520           bfd_size_type sec_size;
521
522           sec_addr = bfd_section_vma (target_bfd, target_section);
523           sec_size = target_section->_raw_size;
524
525           /* Make sure the requested memory starts inside the section.  */
526
527           if (memaddr >= sec_addr
528               && memaddr < sec_addr + sec_size)
529             {
530               /* Cut back length in case request overflows the end of the section. */
531               len = min (len, sec_addr + sec_size - memaddr);
532
533               res = xfer_fn (target_bfd, target_section, myaddr, memaddr - sec_addr, len);
534
535               return res ? len : 0;
536             }
537         }
538     }
539 #endif /* 0, Stu's implementation */
540   for (p = target->to_sections; p < target->to_sections_end; p++)
541     {
542       if (overlay_debugging && section && p->the_bfd_section &&
543           strcmp (section->name, p->the_bfd_section->name) != 0)
544         continue;               /* not the section we need */
545       if (memaddr >= p->addr)
546         if (memend <= p->endaddr)
547           {
548             /* Entire transfer is within this section.  */
549             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
550                            memaddr - p->addr, len);
551             return (res != 0) ? len : 0;
552           }
553         else if (memaddr >= p->endaddr)
554           {
555             /* This section ends before the transfer starts.  */
556             continue;
557           }
558         else
559           {
560             /* This section overlaps the transfer.  Just do half.  */
561             len = p->endaddr - memaddr;
562             res = xfer_fn (p->bfd, p->the_bfd_section, myaddr,
563                            memaddr - p->addr, len);
564             return (res != 0) ? len : 0;
565           }
566       else
567         nextsectaddr = min (nextsectaddr, p->addr);
568     }
569
570   if (nextsectaddr >= memend)
571     return 0;                   /* We can't help */
572   else
573     return -(nextsectaddr - memaddr);   /* Next boundary where we can help */
574 }
575 \f
576
577 void
578 print_section_info (t, abfd)
579      struct target_ops *t;
580      bfd *abfd;
581 {
582   struct section_table *p;
583
584   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
585   wrap_here ("        ");
586   printf_filtered ("file type %s.\n", bfd_get_target (abfd));
587   if (abfd == exec_bfd)
588     {
589       printf_filtered ("\tEntry point: ");
590       print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
591       printf_filtered ("\n");
592     }
593   for (p = t->to_sections; p < t->to_sections_end; p++)
594     {
595       /* FIXME-32x64 need a print_address_numeric with field width */
596       printf_filtered ("\t%s", local_hex_string_custom ((unsigned long) p->addr, "08l"));
597       printf_filtered (" - %s", local_hex_string_custom ((unsigned long) p->endaddr, "08l"));
598       if (info_verbose)
599         printf_filtered (" @ %s",
600                          local_hex_string_custom ((unsigned long) p->the_bfd_section->filepos, "08l"));
601       printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
602       if (p->bfd != abfd)
603         {
604           printf_filtered (" in %s", bfd_get_filename (p->bfd));
605         }
606       printf_filtered ("\n");
607     }
608 }
609
610 static void
611 exec_files_info (t)
612      struct target_ops *t;
613 {
614   print_section_info (t, exec_bfd);
615
616   if (vmap)
617     {
618       struct vmap *vp;
619
620       printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
621       printf_unfiltered ("\t  %8.8s   %8.8s   %8.8s   %8.8s %8.8s %s\n",
622                          "tstart", "tend", "dstart", "dend", "section",
623                          "file(member)");
624
625       for (vp = vmap; vp; vp = vp->nxt)
626         printf_unfiltered ("\t0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x %s%s%s%s\n",
627                        vp->tstart, vp->tend, vp->dstart, vp->dend, vp->name,
628                            *vp->member ? "(" : "", vp->member,
629                            *vp->member ? ")" : "");
630     }
631 }
632
633 /* msnyder 5/21/99:
634    exec_set_section_offsets sets the offsets of all the sections
635    in the exec objfile.  */
636
637 void
638 exec_set_section_offsets (text_off, data_off, bss_off)
639      bfd_signed_vma text_off;
640      bfd_signed_vma data_off;
641      bfd_signed_vma bss_off;
642 {
643   struct section_table *sect;
644
645   for (sect = exec_ops.to_sections;
646        sect < exec_ops.to_sections_end;
647        sect++)
648     {
649       flagword flags;
650
651       flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
652
653       if (flags & SEC_CODE)
654         {
655           sect->addr += text_off;
656           sect->endaddr += text_off;
657         }
658       else if (flags & (SEC_DATA | SEC_LOAD))
659         {
660           sect->addr += data_off;
661           sect->endaddr += data_off;
662         }
663       else if (flags & SEC_ALLOC)
664         {
665           sect->addr += bss_off;
666           sect->endaddr += bss_off;
667         }
668     }
669 }
670
671 static void
672 set_section_command (args, from_tty)
673      char *args;
674      int from_tty;
675 {
676   struct section_table *p;
677   char *secname;
678   unsigned seclen;
679   unsigned long secaddr;
680   char secprint[100];
681   long offset;
682
683   if (args == 0)
684     error ("Must specify section name and its virtual address");
685
686   /* Parse out section name */
687   for (secname = args; !isspace (*args); args++);
688   seclen = args - secname;
689
690   /* Parse out new virtual address */
691   secaddr = parse_and_eval_address (args);
692
693   for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
694     {
695       if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
696           && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
697         {
698           offset = secaddr - p->addr;
699           p->addr += offset;
700           p->endaddr += offset;
701           if (from_tty)
702             exec_files_info (&exec_ops);
703           return;
704         }
705     }
706   if (seclen >= sizeof (secprint))
707     seclen = sizeof (secprint) - 1;
708   strncpy (secprint, secname, seclen);
709   secprint[seclen] = '\0';
710   error ("Section %s not found", secprint);
711 }
712
713 /* If mourn is being called in all the right places, this could be say
714    `gdb internal error' (since generic_mourn calls
715    breakpoint_init_inferior).  */
716
717 static int
718 ignore (addr, contents)
719      CORE_ADDR addr;
720      char *contents;
721 {
722   return 0;
723 }
724
725 /* Fill in the exec file target vector.  Very few entries need to be
726    defined.  */
727
728 void
729 init_exec_ops ()
730 {
731   exec_ops.to_shortname = "exec";
732   exec_ops.to_longname = "Local exec file";
733   exec_ops.to_doc = "Use an executable file as a target.\n\
734 Specify the filename of the executable file.";
735   exec_ops.to_open = exec_file_command;
736   exec_ops.to_close = exec_close;
737   exec_ops.to_attach = find_default_attach;
738   exec_ops.to_require_attach = find_default_require_attach;
739   exec_ops.to_require_detach = find_default_require_detach;
740   exec_ops.to_xfer_memory = xfer_memory;
741   exec_ops.to_files_info = exec_files_info;
742   exec_ops.to_insert_breakpoint = ignore;
743   exec_ops.to_remove_breakpoint = ignore;
744   exec_ops.to_create_inferior = find_default_create_inferior;
745   exec_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
746   exec_ops.to_stratum = file_stratum;
747   exec_ops.to_has_memory = 1;
748   exec_ops.to_magic = OPS_MAGIC;
749 }
750
751 void
752 _initialize_exec ()
753 {
754   struct cmd_list_element *c;
755
756   init_exec_ops ();
757
758   if (!dbx_commands)
759     {
760       c = add_cmd ("file", class_files, file_command,
761                    "Use FILE as program to be debugged.\n\
762 It is read for its symbols, for getting the contents of pure memory,\n\
763 and it is the program executed when you use the `run' command.\n\
764 If FILE cannot be found as specified, your execution directory path\n\
765 ($PATH) is searched for a command of that name.\n\
766 No arg means to have no executable file and no symbols.", &cmdlist);
767       c->completer = filename_completer;
768     }
769
770   c = add_cmd ("exec-file", class_files, exec_file_command,
771                "Use FILE as program for getting contents of pure memory.\n\
772 If FILE cannot be found as specified, your execution directory path\n\
773 is searched for a command of that name.\n\
774 No arg means have no executable file.", &cmdlist);
775   c->completer = filename_completer;
776
777   add_com ("section", class_files, set_section_command,
778            "Change the base address of section SECTION of the exec file to ADDR.\n\
779 This can be used if the exec file does not contain section addresses,\n\
780 (such as in the a.out format), or when the addresses specified in the\n\
781 file itself are wrong.  Each section must be changed separately.  The\n\
782 ``info files'' command lists all the sections and their addresses.");
783
784   add_show_from_set
785     (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
786                   "Set writing into executable and core files.",
787                   &setlist),
788      &showlist);
789
790   add_target (&exec_ops);
791 }