1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "filenames.h"
29 #include "completer.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
40 #include "readline/readline.h"
48 void (*deprecated_file_changed_hook
) (char *);
50 /* Prototypes for local functions */
52 static void file_command (char *, int);
54 static void set_section_command (char *, int);
56 static void exec_files_info (struct target_ops
*);
58 static void init_exec_ops (void);
60 void _initialize_exec (void);
62 /* The target vector for executable files. */
64 static struct target_ops exec_ops
;
66 /* Whether to open exec and core files read-only or read-write. */
70 show_write_files (struct ui_file
*file
, int from_tty
,
71 struct cmd_list_element
*c
, const char *value
)
73 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
79 exec_open (char *args
, int from_tty
)
81 target_preopen (from_tty
);
82 exec_file_attach (args
, from_tty
);
85 /* Close and clear exec_bfd. If we end up with no target sections to
86 read memory from, this unpushes the exec_ops target. */
97 /* Removing target sections may close the exec_ops target.
98 Clear exec_bfd before doing so to prevent recursion. */
102 remove_target_sections (&exec_bfd
);
104 xfree (exec_filename
);
105 exec_filename
= NULL
;
109 /* This is the target_close implementation. Clears all target
110 sections and closes all executable bfds from all program spaces. */
113 exec_close_1 (struct target_ops
*self
)
115 struct program_space
*ss
;
116 struct cleanup
*old_chain
;
118 old_chain
= save_current_program_space ();
121 set_current_program_space (ss
);
122 clear_section_table (current_target_sections
);
126 do_cleanups (old_chain
);
130 exec_file_clear (int from_tty
)
132 /* Remove exec file. */
136 printf_unfiltered (_("No executable file now.\n"));
139 /* Set FILENAME as the new exec file.
141 This function is intended to be behave essentially the same
142 as exec_file_command, except that the latter will detect when
143 a target is being debugged, and will ask the user whether it
144 should be shut down first. (If the answer is "no", then the
145 new file is ignored.)
147 This file is used by exec_file_command, to do the work of opening
148 and processing the exec file after any prompting has happened.
150 And, it is used by child_attach, when the attach command was
151 given a pid but not a exec pathname, and the attach command could
152 figure out the pathname from the pid. (In this case, we shouldn't
153 ask the user whether the current target should be shut down --
154 we're supplying the exec pathname late for good reason.) */
157 exec_file_attach (char *filename
, int from_tty
)
159 struct cleanup
*cleanups
;
161 /* First, acquire a reference to the current exec_bfd. We release
162 this at the end of the function; but acquiring it now lets the
163 BFD cache return it if this call refers to the same file. */
164 gdb_bfd_ref (exec_bfd
);
165 cleanups
= make_cleanup_bfd_unref (exec_bfd
);
167 /* Remove any previous exec file. */
170 /* Now open and digest the file the user requested, if any. */
175 printf_unfiltered (_("No executable file now.\n"));
177 set_gdbarch_from_file (NULL
);
181 char *scratch_pathname
, *canonical_pathname
;
183 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
186 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, filename
,
187 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
189 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
190 if (scratch_chan
< 0)
192 char *exename
= alloca (strlen (filename
) + 5);
194 strcat (strcpy (exename
, filename
), ".exe");
195 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
196 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
200 if (scratch_chan
< 0)
201 perror_with_name (filename
);
203 make_cleanup (xfree
, scratch_pathname
);
205 /* gdb_bfd_open (and its variants) prefers canonicalized pathname for
206 better BFD caching. */
207 canonical_pathname
= gdb_realpath (scratch_pathname
);
208 make_cleanup (xfree
, canonical_pathname
);
211 exec_bfd
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
212 FOPEN_RUB
, scratch_chan
);
214 exec_bfd
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
218 error (_("\"%s\": could not open as an executable file: %s"),
219 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
222 gdb_assert (exec_filename
== NULL
);
223 exec_filename
= gdb_realpath_keepfile (scratch_pathname
);
225 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
227 /* Make sure to close exec_bfd, or else "run" might try to use
230 error (_("\"%s\": not in executable format: %s"),
232 gdb_bfd_errmsg (bfd_get_error (), matching
));
235 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
237 /* Make sure to close exec_bfd, or else "run" might try to use
240 error (_("\"%s\": can't find the file sections: %s"),
241 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
244 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
248 set_gdbarch_from_file (exec_bfd
);
250 /* Add the executable's sections to the current address spaces'
251 list of sections. This possibly pushes the exec_ops
253 add_target_sections (&exec_bfd
, sections
, sections_end
);
256 /* Tell display code (if any) about the changed file name. */
257 if (deprecated_exec_file_display_hook
)
258 (*deprecated_exec_file_display_hook
) (filename
);
261 do_cleanups (cleanups
);
263 bfd_cache_close_all ();
264 observer_notify_executable_changed ();
267 /* Process the first arg in ARGS as the new exec file.
269 Note that we have to explicitly ignore additional args, since we can
270 be called from file_command(), which also calls symbol_file_command()
271 which can take multiple args.
273 If ARGS is NULL, we just want to close the exec file. */
276 exec_file_command (char *args
, int from_tty
)
281 if (from_tty
&& target_has_execution
282 && !query (_("A program is being debugged already.\n"
283 "Are you sure you want to change the file? ")))
284 error (_("File not changed."));
288 struct cleanup
*cleanups
;
290 /* Scan through the args and pick up the first non option arg
293 argv
= gdb_buildargv (args
);
294 cleanups
= make_cleanup_freeargv (argv
);
296 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
300 error (_("No executable file name was specified"));
302 filename
= tilde_expand (*argv
);
303 make_cleanup (xfree
, filename
);
304 exec_file_attach (filename
, from_tty
);
306 do_cleanups (cleanups
);
309 exec_file_attach (NULL
, from_tty
);
312 /* Set both the exec file and the symbol file, in one command.
313 What a novelty. Why did GDB go through four major releases before this
314 command was added? */
317 file_command (char *arg
, int from_tty
)
319 /* FIXME, if we lose on reading the symbol file, we should revert
320 the exec file, but that's rough. */
321 exec_file_command (arg
, from_tty
);
322 symbol_file_command (arg
, from_tty
);
323 if (deprecated_file_changed_hook
)
324 deprecated_file_changed_hook (arg
);
328 /* Locate all mappable sections of a BFD file.
329 table_pp_char is a char * to get it through bfd_map_over_sections;
330 we cast it back to its proper type. */
333 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
336 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
339 gdb_assert (abfd
== asect
->owner
);
341 /* Check the section flags, but do not discard zero-length sections, since
342 some symbols may still be attached to this section. For instance, we
343 encountered on sparc-solaris 2.10 a shared library with an empty .bss
344 section to which a symbol named "_end" was attached. The address
345 of this symbol still needs to be relocated. */
346 aflag
= bfd_get_section_flags (abfd
, asect
);
347 if (!(aflag
& SEC_ALLOC
))
350 (*table_pp
)->owner
= NULL
;
351 (*table_pp
)->the_bfd_section
= asect
;
352 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
353 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
360 clear_section_table (struct target_section_table
*table
)
362 xfree (table
->sections
);
363 table
->sections
= table
->sections_end
= NULL
;
366 /* Resize section table TABLE by ADJUSTMENT.
367 ADJUSTMENT may be negative, in which case the caller must have already
368 removed the sections being deleted.
369 Returns the old size. */
372 resize_section_table (struct target_section_table
*table
, int adjustment
)
377 old_count
= table
->sections_end
- table
->sections
;
379 new_count
= adjustment
+ old_count
;
383 table
->sections
= xrealloc (table
->sections
,
384 sizeof (struct target_section
) * new_count
);
385 table
->sections_end
= table
->sections
+ new_count
;
388 clear_section_table (table
);
393 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
394 Returns 0 if OK, 1 on error. */
397 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
398 struct target_section
**end
)
402 count
= bfd_count_sections (some_bfd
);
405 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
407 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
408 if (*end
> *start
+ count
)
409 internal_error (__FILE__
, __LINE__
,
410 _("failed internal consistency check"));
411 /* We could realloc the table, but it probably loses for most files. */
415 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
416 current set of target sections. */
419 add_target_sections (void *owner
,
420 struct target_section
*sections
,
421 struct target_section
*sections_end
)
424 struct target_section_table
*table
= current_target_sections
;
426 count
= sections_end
- sections
;
430 int space
= resize_section_table (table
, count
);
433 for (i
= 0; i
< count
; ++i
)
435 table
->sections
[space
+ i
] = sections
[i
];
436 table
->sections
[space
+ i
].owner
= owner
;
439 /* If these are the first file sections we can provide memory
440 from, push the file_stratum target. */
441 if (!target_is_pushed (&exec_ops
))
442 push_target (&exec_ops
);
446 /* Add the sections of OBJFILE to the current set of target sections. */
449 add_target_sections_of_objfile (struct objfile
*objfile
)
451 struct target_section_table
*table
= current_target_sections
;
452 struct obj_section
*osect
;
455 struct target_section
*ts
;
460 /* Compute the number of sections to add. */
461 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
463 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
471 space
= resize_section_table (table
, count
);
473 ts
= table
->sections
+ space
;
475 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
477 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
480 gdb_assert (ts
< table
->sections
+ space
+ count
);
482 ts
->addr
= obj_section_addr (osect
);
483 ts
->endaddr
= obj_section_endaddr (osect
);
484 ts
->the_bfd_section
= osect
->the_bfd_section
;
485 ts
->owner
= (void *) objfile
;
491 /* Remove all target sections owned by OWNER.
492 OWNER must be the same value passed to add_target_sections. */
495 remove_target_sections (void *owner
)
497 struct target_section
*src
, *dest
;
498 struct target_section_table
*table
= current_target_sections
;
500 gdb_assert (owner
!= NULL
);
502 dest
= table
->sections
;
503 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
504 if (src
->owner
!= owner
)
506 /* Keep this section. */
512 /* If we've dropped any sections, resize the section table. */
517 old_count
= resize_section_table (table
, dest
- src
);
519 /* If we don't have any more sections to read memory from,
520 remove the file_stratum target from the stack. */
521 if (old_count
+ (dest
- src
) == 0)
523 struct program_space
*pspace
;
526 if (pspace
->target_sections
.sections
527 != pspace
->target_sections
.sections_end
)
530 unpush_target (&exec_ops
);
537 enum target_xfer_status
538 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
539 ULONGEST len
, ULONGEST
*xfered_len
)
541 /* It's unduly pedantic to refuse to look at the executable for
542 read-only pieces; so do the equivalent of readonly regions aka
544 if (exec_bfd
!= NULL
)
550 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
552 if ((s
->flags
& SEC_LOAD
) == 0
553 || (s
->flags
& SEC_READONLY
) == 0)
557 size
= bfd_get_section_size (s
);
558 if (vma
<= offset
&& offset
< (vma
+ size
))
562 amt
= (vma
+ size
) - offset
;
566 amt
= bfd_get_section_contents (exec_bfd
, s
,
567 readbuf
, offset
- vma
, amt
);
570 return TARGET_XFER_EOF
;
574 return TARGET_XFER_OK
;
580 /* Indicate failure to find the requested memory block. */
581 return TARGET_XFER_E_IO
;
584 /* Appends all read-only memory ranges found in the target section
585 table defined by SECTIONS and SECTIONS_END, starting at (and
586 intersected with) MEMADDR for LEN bytes. Returns the augmented
589 static VEC(mem_range_s
) *
590 section_table_available_memory (VEC(mem_range_s
) *memory
,
591 CORE_ADDR memaddr
, ULONGEST len
,
592 struct target_section
*sections
,
593 struct target_section
*sections_end
)
595 struct target_section
*p
;
597 for (p
= sections
; p
< sections_end
; p
++)
599 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
601 & SEC_READONLY
) == 0)
604 /* Copy the meta-data, adjusted. */
605 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
607 ULONGEST lo1
, hi1
, lo2
, hi2
;
616 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
618 r
->start
= max (lo1
, lo2
);
619 r
->length
= min (hi1
, hi2
) - r
->start
;
626 enum target_xfer_status
627 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
628 ULONGEST len
, ULONGEST
*xfered_len
)
630 VEC(mem_range_s
) *available_memory
= NULL
;
631 struct target_section_table
*table
;
632 struct cleanup
*old_chain
;
636 table
= target_get_section_table (&exec_ops
);
637 available_memory
= section_table_available_memory (available_memory
,
640 table
->sections_end
);
642 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
),
645 normalize_mem_ranges (available_memory
);
648 VEC_iterate (mem_range_s
, available_memory
, i
, r
);
651 if (mem_ranges_overlap (r
->start
, r
->length
, offset
, len
))
654 enum target_xfer_status status
;
656 /* Get the intersection window. */
657 end
= min (offset
+ len
, r
->start
+ r
->length
);
659 gdb_assert (end
- offset
<= len
);
661 if (offset
>= r
->start
)
662 status
= exec_read_partial_read_only (readbuf
, offset
,
667 *xfered_len
= r
->start
- offset
;
668 status
= TARGET_XFER_UNAVAILABLE
;
670 do_cleanups (old_chain
);
674 do_cleanups (old_chain
);
677 return TARGET_XFER_UNAVAILABLE
;
680 enum target_xfer_status
681 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
682 ULONGEST offset
, ULONGEST len
,
683 ULONGEST
*xfered_len
,
684 struct target_section
*sections
,
685 struct target_section
*sections_end
,
686 const char *section_name
)
689 struct target_section
*p
;
690 ULONGEST memaddr
= offset
;
691 ULONGEST memend
= memaddr
+ len
;
694 internal_error (__FILE__
, __LINE__
,
695 _("failed internal consistency check"));
697 for (p
= sections
; p
< sections_end
; p
++)
699 struct bfd_section
*asect
= p
->the_bfd_section
;
700 bfd
*abfd
= asect
->owner
;
702 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
703 continue; /* not the section we need. */
704 if (memaddr
>= p
->addr
)
706 if (memend
<= p
->endaddr
)
708 /* Entire transfer is within this section. */
710 res
= bfd_set_section_contents (abfd
, asect
,
711 writebuf
, memaddr
- p
->addr
,
714 res
= bfd_get_section_contents (abfd
, asect
,
715 readbuf
, memaddr
- p
->addr
,
721 return TARGET_XFER_OK
;
724 return TARGET_XFER_EOF
;
726 else if (memaddr
>= p
->endaddr
)
728 /* This section ends before the transfer starts. */
733 /* This section overlaps the transfer. Just do half. */
734 len
= p
->endaddr
- memaddr
;
736 res
= bfd_set_section_contents (abfd
, asect
,
737 writebuf
, memaddr
- p
->addr
,
740 res
= bfd_get_section_contents (abfd
, asect
,
741 readbuf
, memaddr
- p
->addr
,
746 return TARGET_XFER_OK
;
749 return TARGET_XFER_EOF
;
754 return TARGET_XFER_EOF
; /* We can't help. */
757 static struct target_section_table
*
758 exec_get_section_table (struct target_ops
*ops
)
760 return current_target_sections
;
763 static enum target_xfer_status
764 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
765 const char *annex
, gdb_byte
*readbuf
,
766 const gdb_byte
*writebuf
,
767 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
769 struct target_section_table
*table
= target_get_section_table (ops
);
771 if (object
== TARGET_OBJECT_MEMORY
)
772 return section_table_xfer_memory_partial (readbuf
, writebuf
,
773 offset
, len
, xfered_len
,
778 return TARGET_XFER_E_IO
;
783 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
785 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
786 struct target_section
*p
;
787 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
788 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
790 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
792 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
793 if (abfd
== exec_bfd
)
795 /* gcc-3.4 does not like the initialization in
796 <p == t->sections_end>. */
797 bfd_vma displacement
= 0;
800 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
802 struct bfd_section
*psect
= p
->the_bfd_section
;
803 bfd
*pbfd
= psect
->owner
;
805 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
806 != (SEC_ALLOC
| SEC_LOAD
))
809 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
810 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
811 + bfd_get_section_size (psect
)))
813 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
817 if (p
== t
->sections_end
)
818 warning (_("Cannot find section for the entry point of %s."),
819 bfd_get_filename (abfd
));
821 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
822 bfd_get_start_address (abfd
)
824 printf_filtered (_("\tEntry point: %s\n"),
825 paddress (gdbarch
, entry_point
));
827 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
829 struct bfd_section
*psect
= p
->the_bfd_section
;
830 bfd
*pbfd
= psect
->owner
;
832 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
833 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
835 /* FIXME: A format of "08l" is not wide enough for file offsets
836 larger than 4GB. OTOH, making it "016l" isn't desirable either
837 since most output will then be much wider than necessary. It
838 may make sense to test the size of the file and choose the
839 format string accordingly. */
840 /* FIXME: i18n: Need to rewrite this sentence. */
842 printf_filtered (" @ %s",
843 hex_string_custom (psect
->filepos
, 8));
844 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
846 printf_filtered (" in %s", bfd_get_filename (pbfd
));
847 printf_filtered ("\n");
852 exec_files_info (struct target_ops
*t
)
855 print_section_info (current_target_sections
, exec_bfd
);
857 puts_filtered (_("\t<no file loaded>\n"));
861 set_section_command (char *args
, int from_tty
)
863 struct target_section
*p
;
866 unsigned long secaddr
;
869 struct target_section_table
*table
;
872 error (_("Must specify section name and its virtual address"));
874 /* Parse out section name. */
875 for (secname
= args
; !isspace (*args
); args
++);
876 seclen
= args
- secname
;
878 /* Parse out new virtual address. */
879 secaddr
= parse_and_eval_address (args
);
881 table
= current_target_sections
;
882 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
884 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
885 p
->the_bfd_section
), seclen
)
886 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
888 offset
= secaddr
- p
->addr
;
890 p
->endaddr
+= offset
;
892 exec_files_info (&exec_ops
);
896 if (seclen
>= sizeof (secprint
))
897 seclen
= sizeof (secprint
) - 1;
898 strncpy (secprint
, secname
, seclen
);
899 secprint
[seclen
] = '\0';
900 error (_("Section %s not found"), secprint
);
903 /* If we can find a section in FILENAME with BFD index INDEX, adjust
907 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
909 struct target_section
*p
;
910 struct target_section_table
*table
;
912 table
= current_target_sections
;
913 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
915 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
916 && index
== p
->the_bfd_section
->index
)
918 p
->endaddr
+= address
- p
->addr
;
924 /* If mourn is being called in all the right places, this could be say
925 `gdb internal error' (since generic_mourn calls
926 breakpoint_init_inferior). */
929 ignore (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
930 struct bp_target_info
*bp_tgt
)
936 exec_has_memory (struct target_ops
*ops
)
938 /* We can provide memory if we have any file/target sections to read
940 return (current_target_sections
->sections
941 != current_target_sections
->sections_end
);
945 exec_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
947 error (_("Can't create a corefile"));
950 /* Fill in the exec file target vector. Very few entries need to be
956 exec_ops
.to_shortname
= "exec";
957 exec_ops
.to_longname
= "Local exec file";
958 exec_ops
.to_doc
= "Use an executable file as a target.\n\
959 Specify the filename of the executable file.";
960 exec_ops
.to_open
= exec_open
;
961 exec_ops
.to_close
= exec_close_1
;
962 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
963 exec_ops
.to_get_section_table
= exec_get_section_table
;
964 exec_ops
.to_files_info
= exec_files_info
;
965 exec_ops
.to_insert_breakpoint
= ignore
;
966 exec_ops
.to_remove_breakpoint
= ignore
;
967 exec_ops
.to_stratum
= file_stratum
;
968 exec_ops
.to_has_memory
= exec_has_memory
;
969 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
970 exec_ops
.to_find_memory_regions
= objfile_find_memory_regions
;
971 exec_ops
.to_magic
= OPS_MAGIC
;
975 _initialize_exec (void)
977 struct cmd_list_element
*c
;
983 c
= add_cmd ("file", class_files
, file_command
, _("\
984 Use FILE as program to be debugged.\n\
985 It is read for its symbols, for getting the contents of pure memory,\n\
986 and it is the program executed when you use the `run' command.\n\
987 If FILE cannot be found as specified, your execution directory path\n\
988 ($PATH) is searched for a command of that name.\n\
989 No arg means to have no executable file and no symbols."), &cmdlist
);
990 set_cmd_completer (c
, filename_completer
);
993 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
994 Use FILE as program for getting contents of pure memory.\n\
995 If FILE cannot be found as specified, your execution directory path\n\
996 is searched for a command of that name.\n\
997 No arg means have no executable file."), &cmdlist
);
998 set_cmd_completer (c
, filename_completer
);
1000 add_com ("section", class_files
, set_section_command
, _("\
1001 Change the base address of section SECTION of the exec file to ADDR.\n\
1002 This can be used if the exec file does not contain section addresses,\n\
1003 (such as in the a.out format), or when the addresses specified in the\n\
1004 file itself are wrong. Each section must be changed separately. The\n\
1005 ``info files'' command lists all the sections and their addresses."));
1007 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1008 Set writing into executable and core files."), _("\
1009 Show writing into executable and core files."), NULL
,
1012 &setlist
, &showlist
);
1014 add_target_with_completer (&exec_ops
, filename_completer
);