1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2015 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"
46 void (*deprecated_file_changed_hook
) (char *);
48 /* Prototypes for local functions */
50 static void file_command (char *, int);
52 static void set_section_command (char *, int);
54 static void exec_files_info (struct target_ops
*);
56 static void init_exec_ops (void);
58 void _initialize_exec (void);
60 /* The target vector for executable files. */
62 static struct target_ops exec_ops
;
64 /* Whether to open exec and core files read-only or read-write. */
68 show_write_files (struct ui_file
*file
, int from_tty
,
69 struct cmd_list_element
*c
, const char *value
)
71 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
77 exec_open (const char *args
, int from_tty
)
79 target_preopen (from_tty
);
80 exec_file_attach (args
, from_tty
);
83 /* Close and clear exec_bfd. If we end up with no target sections to
84 read memory from, this unpushes the exec_ops target. */
95 /* Removing target sections may close the exec_ops target.
96 Clear exec_bfd before doing so to prevent recursion. */
100 remove_target_sections (&exec_bfd
);
102 xfree (exec_filename
);
103 exec_filename
= NULL
;
107 /* This is the target_close implementation. Clears all target
108 sections and closes all executable bfds from all program spaces. */
111 exec_close_1 (struct target_ops
*self
)
113 struct program_space
*ss
;
114 struct cleanup
*old_chain
;
116 old_chain
= save_current_program_space ();
119 set_current_program_space (ss
);
120 clear_section_table (current_target_sections
);
124 do_cleanups (old_chain
);
128 exec_file_clear (int from_tty
)
130 /* Remove exec file. */
134 printf_unfiltered (_("No executable file now.\n"));
137 /* Set FILENAME as the new exec file.
139 This function is intended to be behave essentially the same
140 as exec_file_command, except that the latter will detect when
141 a target is being debugged, and will ask the user whether it
142 should be shut down first. (If the answer is "no", then the
143 new file is ignored.)
145 This file is used by exec_file_command, to do the work of opening
146 and processing the exec file after any prompting has happened.
148 And, it is used by child_attach, when the attach command was
149 given a pid but not a exec pathname, and the attach command could
150 figure out the pathname from the pid. (In this case, we shouldn't
151 ask the user whether the current target should be shut down --
152 we're supplying the exec pathname late for good reason.) */
155 exec_file_attach (const char *filename
, int from_tty
)
157 struct cleanup
*cleanups
;
159 /* First, acquire a reference to the current exec_bfd. We release
160 this at the end of the function; but acquiring it now lets the
161 BFD cache return it if this call refers to the same file. */
162 gdb_bfd_ref (exec_bfd
);
163 cleanups
= make_cleanup_bfd_unref (exec_bfd
);
165 /* Remove any previous exec file. */
168 /* Now open and digest the file the user requested, if any. */
173 printf_unfiltered (_("No executable file now.\n"));
175 set_gdbarch_from_file (NULL
);
179 int load_via_target
= 0;
180 char *scratch_pathname
, *canonical_pathname
;
182 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
185 if (is_target_filename (filename
))
187 if (target_filesystem_is_local ())
188 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
195 /* gdb_bfd_fopen does not support "target:" filenames. */
197 warning (_("writing into executable files is "
198 "not supported for %s sysroots"),
199 TARGET_SYSROOT_PREFIX
);
201 scratch_pathname
= xstrdup (filename
);
202 make_cleanup (xfree
, scratch_pathname
);
206 canonical_pathname
= scratch_pathname
;
210 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
211 filename
, write_files
?
212 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
214 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
215 if (scratch_chan
< 0)
217 char *exename
= alloca (strlen (filename
) + 5);
219 strcat (strcpy (exename
, filename
), ".exe");
220 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
221 exename
, write_files
?
223 : O_RDONLY
| O_BINARY
,
227 if (scratch_chan
< 0)
228 perror_with_name (filename
);
230 make_cleanup (xfree
, scratch_pathname
);
232 /* gdb_bfd_open (and its variants) prefers canonicalized
233 pathname for better BFD caching. */
234 canonical_pathname
= gdb_realpath (scratch_pathname
);
235 make_cleanup (xfree
, canonical_pathname
);
238 if (write_files
&& !load_via_target
)
239 exec_bfd
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
240 FOPEN_RUB
, scratch_chan
);
242 exec_bfd
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
246 error (_("\"%s\": could not open as an executable file: %s"),
247 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
250 /* gdb_realpath_keepfile resolves symlinks on the local
251 filesystem and so cannot be used for "target:" files. */
252 gdb_assert (exec_filename
== NULL
);
254 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
256 exec_filename
= gdb_realpath_keepfile (scratch_pathname
);
258 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
260 /* Make sure to close exec_bfd, or else "run" might try to use
263 error (_("\"%s\": not in executable format: %s"),
265 gdb_bfd_errmsg (bfd_get_error (), matching
));
268 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
270 /* Make sure to close exec_bfd, or else "run" might try to use
273 error (_("\"%s\": can't find the file sections: %s"),
274 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
277 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
281 set_gdbarch_from_file (exec_bfd
);
283 /* Add the executable's sections to the current address spaces'
284 list of sections. This possibly pushes the exec_ops
286 add_target_sections (&exec_bfd
, sections
, sections_end
);
289 /* Tell display code (if any) about the changed file name. */
290 if (deprecated_exec_file_display_hook
)
291 (*deprecated_exec_file_display_hook
) (filename
);
294 do_cleanups (cleanups
);
296 bfd_cache_close_all ();
297 observer_notify_executable_changed ();
300 /* Process the first arg in ARGS as the new exec file.
302 Note that we have to explicitly ignore additional args, since we can
303 be called from file_command(), which also calls symbol_file_command()
304 which can take multiple args.
306 If ARGS is NULL, we just want to close the exec file. */
309 exec_file_command (char *args
, int from_tty
)
314 if (from_tty
&& target_has_execution
315 && !query (_("A program is being debugged already.\n"
316 "Are you sure you want to change the file? ")))
317 error (_("File not changed."));
321 struct cleanup
*cleanups
;
323 /* Scan through the args and pick up the first non option arg
326 argv
= gdb_buildargv (args
);
327 cleanups
= make_cleanup_freeargv (argv
);
329 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
333 error (_("No executable file name was specified"));
335 filename
= tilde_expand (*argv
);
336 make_cleanup (xfree
, filename
);
337 exec_file_attach (filename
, from_tty
);
339 do_cleanups (cleanups
);
342 exec_file_attach (NULL
, from_tty
);
345 /* Set both the exec file and the symbol file, in one command.
346 What a novelty. Why did GDB go through four major releases before this
347 command was added? */
350 file_command (char *arg
, int from_tty
)
352 /* FIXME, if we lose on reading the symbol file, we should revert
353 the exec file, but that's rough. */
354 exec_file_command (arg
, from_tty
);
355 symbol_file_command (arg
, from_tty
);
356 if (deprecated_file_changed_hook
)
357 deprecated_file_changed_hook (arg
);
361 /* Locate all mappable sections of a BFD file.
362 table_pp_char is a char * to get it through bfd_map_over_sections;
363 we cast it back to its proper type. */
366 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
369 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
372 gdb_assert (abfd
== asect
->owner
);
374 /* Check the section flags, but do not discard zero-length sections, since
375 some symbols may still be attached to this section. For instance, we
376 encountered on sparc-solaris 2.10 a shared library with an empty .bss
377 section to which a symbol named "_end" was attached. The address
378 of this symbol still needs to be relocated. */
379 aflag
= bfd_get_section_flags (abfd
, asect
);
380 if (!(aflag
& SEC_ALLOC
))
383 (*table_pp
)->owner
= NULL
;
384 (*table_pp
)->the_bfd_section
= asect
;
385 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
386 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
393 clear_section_table (struct target_section_table
*table
)
395 xfree (table
->sections
);
396 table
->sections
= table
->sections_end
= NULL
;
399 /* Resize section table TABLE by ADJUSTMENT.
400 ADJUSTMENT may be negative, in which case the caller must have already
401 removed the sections being deleted.
402 Returns the old size. */
405 resize_section_table (struct target_section_table
*table
, int adjustment
)
410 old_count
= table
->sections_end
- table
->sections
;
412 new_count
= adjustment
+ old_count
;
416 table
->sections
= xrealloc (table
->sections
,
417 sizeof (struct target_section
) * new_count
);
418 table
->sections_end
= table
->sections
+ new_count
;
421 clear_section_table (table
);
426 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
427 Returns 0 if OK, 1 on error. */
430 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
431 struct target_section
**end
)
435 count
= bfd_count_sections (some_bfd
);
438 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
440 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
441 if (*end
> *start
+ count
)
442 internal_error (__FILE__
, __LINE__
,
443 _("failed internal consistency check"));
444 /* We could realloc the table, but it probably loses for most files. */
448 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
449 current set of target sections. */
452 add_target_sections (void *owner
,
453 struct target_section
*sections
,
454 struct target_section
*sections_end
)
457 struct target_section_table
*table
= current_target_sections
;
459 count
= sections_end
- sections
;
463 int space
= resize_section_table (table
, count
);
466 for (i
= 0; i
< count
; ++i
)
468 table
->sections
[space
+ i
] = sections
[i
];
469 table
->sections
[space
+ i
].owner
= owner
;
472 /* If these are the first file sections we can provide memory
473 from, push the file_stratum target. */
474 if (!target_is_pushed (&exec_ops
))
475 push_target (&exec_ops
);
479 /* Add the sections of OBJFILE to the current set of target sections. */
482 add_target_sections_of_objfile (struct objfile
*objfile
)
484 struct target_section_table
*table
= current_target_sections
;
485 struct obj_section
*osect
;
488 struct target_section
*ts
;
493 /* Compute the number of sections to add. */
494 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
496 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
504 space
= resize_section_table (table
, count
);
506 ts
= table
->sections
+ space
;
508 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
510 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
513 gdb_assert (ts
< table
->sections
+ space
+ count
);
515 ts
->addr
= obj_section_addr (osect
);
516 ts
->endaddr
= obj_section_endaddr (osect
);
517 ts
->the_bfd_section
= osect
->the_bfd_section
;
518 ts
->owner
= (void *) objfile
;
524 /* Remove all target sections owned by OWNER.
525 OWNER must be the same value passed to add_target_sections. */
528 remove_target_sections (void *owner
)
530 struct target_section
*src
, *dest
;
531 struct target_section_table
*table
= current_target_sections
;
533 gdb_assert (owner
!= NULL
);
535 dest
= table
->sections
;
536 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
537 if (src
->owner
!= owner
)
539 /* Keep this section. */
545 /* If we've dropped any sections, resize the section table. */
550 old_count
= resize_section_table (table
, dest
- src
);
552 /* If we don't have any more sections to read memory from,
553 remove the file_stratum target from the stack. */
554 if (old_count
+ (dest
- src
) == 0)
556 struct program_space
*pspace
;
559 if (pspace
->target_sections
.sections
560 != pspace
->target_sections
.sections_end
)
563 unpush_target (&exec_ops
);
570 enum target_xfer_status
571 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
572 ULONGEST len
, ULONGEST
*xfered_len
)
574 /* It's unduly pedantic to refuse to look at the executable for
575 read-only pieces; so do the equivalent of readonly regions aka
577 if (exec_bfd
!= NULL
)
583 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
585 if ((s
->flags
& SEC_LOAD
) == 0
586 || (s
->flags
& SEC_READONLY
) == 0)
590 size
= bfd_get_section_size (s
);
591 if (vma
<= offset
&& offset
< (vma
+ size
))
595 amt
= (vma
+ size
) - offset
;
599 amt
= bfd_get_section_contents (exec_bfd
, s
,
600 readbuf
, offset
- vma
, amt
);
603 return TARGET_XFER_EOF
;
607 return TARGET_XFER_OK
;
613 /* Indicate failure to find the requested memory block. */
614 return TARGET_XFER_E_IO
;
617 /* Appends all read-only memory ranges found in the target section
618 table defined by SECTIONS and SECTIONS_END, starting at (and
619 intersected with) MEMADDR for LEN bytes. Returns the augmented
622 static VEC(mem_range_s
) *
623 section_table_available_memory (VEC(mem_range_s
) *memory
,
624 CORE_ADDR memaddr
, ULONGEST len
,
625 struct target_section
*sections
,
626 struct target_section
*sections_end
)
628 struct target_section
*p
;
630 for (p
= sections
; p
< sections_end
; p
++)
632 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
634 & SEC_READONLY
) == 0)
637 /* Copy the meta-data, adjusted. */
638 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
640 ULONGEST lo1
, hi1
, lo2
, hi2
;
649 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
651 r
->start
= max (lo1
, lo2
);
652 r
->length
= min (hi1
, hi2
) - r
->start
;
659 enum target_xfer_status
660 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
661 ULONGEST len
, ULONGEST
*xfered_len
)
663 VEC(mem_range_s
) *available_memory
= NULL
;
664 struct target_section_table
*table
;
665 struct cleanup
*old_chain
;
669 table
= target_get_section_table (&exec_ops
);
670 available_memory
= section_table_available_memory (available_memory
,
673 table
->sections_end
);
675 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
),
678 normalize_mem_ranges (available_memory
);
681 VEC_iterate (mem_range_s
, available_memory
, i
, r
);
684 if (mem_ranges_overlap (r
->start
, r
->length
, offset
, len
))
687 enum target_xfer_status status
;
689 /* Get the intersection window. */
690 end
= min (offset
+ len
, r
->start
+ r
->length
);
692 gdb_assert (end
- offset
<= len
);
694 if (offset
>= r
->start
)
695 status
= exec_read_partial_read_only (readbuf
, offset
,
700 *xfered_len
= r
->start
- offset
;
701 status
= TARGET_XFER_UNAVAILABLE
;
703 do_cleanups (old_chain
);
707 do_cleanups (old_chain
);
710 return TARGET_XFER_UNAVAILABLE
;
713 enum target_xfer_status
714 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
715 ULONGEST offset
, ULONGEST len
,
716 ULONGEST
*xfered_len
,
717 struct target_section
*sections
,
718 struct target_section
*sections_end
,
719 const char *section_name
)
722 struct target_section
*p
;
723 ULONGEST memaddr
= offset
;
724 ULONGEST memend
= memaddr
+ len
;
727 internal_error (__FILE__
, __LINE__
,
728 _("failed internal consistency check"));
730 for (p
= sections
; p
< sections_end
; p
++)
732 struct bfd_section
*asect
= p
->the_bfd_section
;
733 bfd
*abfd
= asect
->owner
;
735 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
736 continue; /* not the section we need. */
737 if (memaddr
>= p
->addr
)
739 if (memend
<= p
->endaddr
)
741 /* Entire transfer is within this section. */
743 res
= bfd_set_section_contents (abfd
, asect
,
744 writebuf
, memaddr
- p
->addr
,
747 res
= bfd_get_section_contents (abfd
, asect
,
748 readbuf
, memaddr
- p
->addr
,
754 return TARGET_XFER_OK
;
757 return TARGET_XFER_EOF
;
759 else if (memaddr
>= p
->endaddr
)
761 /* This section ends before the transfer starts. */
766 /* This section overlaps the transfer. Just do half. */
767 len
= p
->endaddr
- memaddr
;
769 res
= bfd_set_section_contents (abfd
, asect
,
770 writebuf
, memaddr
- p
->addr
,
773 res
= bfd_get_section_contents (abfd
, asect
,
774 readbuf
, memaddr
- p
->addr
,
779 return TARGET_XFER_OK
;
782 return TARGET_XFER_EOF
;
787 return TARGET_XFER_EOF
; /* We can't help. */
790 static struct target_section_table
*
791 exec_get_section_table (struct target_ops
*ops
)
793 return current_target_sections
;
796 static enum target_xfer_status
797 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
798 const char *annex
, gdb_byte
*readbuf
,
799 const gdb_byte
*writebuf
,
800 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
802 struct target_section_table
*table
= target_get_section_table (ops
);
804 if (object
== TARGET_OBJECT_MEMORY
)
805 return section_table_xfer_memory_partial (readbuf
, writebuf
,
806 offset
, len
, xfered_len
,
811 return TARGET_XFER_E_IO
;
816 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
818 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
819 struct target_section
*p
;
820 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
821 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
823 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
825 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
826 if (abfd
== exec_bfd
)
828 /* gcc-3.4 does not like the initialization in
829 <p == t->sections_end>. */
830 bfd_vma displacement
= 0;
833 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
835 struct bfd_section
*psect
= p
->the_bfd_section
;
836 bfd
*pbfd
= psect
->owner
;
838 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
839 != (SEC_ALLOC
| SEC_LOAD
))
842 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
843 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
844 + bfd_get_section_size (psect
)))
846 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
850 if (p
== t
->sections_end
)
851 warning (_("Cannot find section for the entry point of %s."),
852 bfd_get_filename (abfd
));
854 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
855 bfd_get_start_address (abfd
)
857 printf_filtered (_("\tEntry point: %s\n"),
858 paddress (gdbarch
, entry_point
));
860 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
862 struct bfd_section
*psect
= p
->the_bfd_section
;
863 bfd
*pbfd
= psect
->owner
;
865 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
866 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
868 /* FIXME: A format of "08l" is not wide enough for file offsets
869 larger than 4GB. OTOH, making it "016l" isn't desirable either
870 since most output will then be much wider than necessary. It
871 may make sense to test the size of the file and choose the
872 format string accordingly. */
873 /* FIXME: i18n: Need to rewrite this sentence. */
875 printf_filtered (" @ %s",
876 hex_string_custom (psect
->filepos
, 8));
877 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
879 printf_filtered (" in %s", bfd_get_filename (pbfd
));
880 printf_filtered ("\n");
885 exec_files_info (struct target_ops
*t
)
888 print_section_info (current_target_sections
, exec_bfd
);
890 puts_filtered (_("\t<no file loaded>\n"));
894 set_section_command (char *args
, int from_tty
)
896 struct target_section
*p
;
899 unsigned long secaddr
;
902 struct target_section_table
*table
;
905 error (_("Must specify section name and its virtual address"));
907 /* Parse out section name. */
908 for (secname
= args
; !isspace (*args
); args
++);
909 seclen
= args
- secname
;
911 /* Parse out new virtual address. */
912 secaddr
= parse_and_eval_address (args
);
914 table
= current_target_sections
;
915 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
917 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
918 p
->the_bfd_section
), seclen
)
919 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
921 offset
= secaddr
- p
->addr
;
923 p
->endaddr
+= offset
;
925 exec_files_info (&exec_ops
);
929 if (seclen
>= sizeof (secprint
))
930 seclen
= sizeof (secprint
) - 1;
931 strncpy (secprint
, secname
, seclen
);
932 secprint
[seclen
] = '\0';
933 error (_("Section %s not found"), secprint
);
936 /* If we can find a section in FILENAME with BFD index INDEX, adjust
940 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
942 struct target_section
*p
;
943 struct target_section_table
*table
;
945 table
= current_target_sections
;
946 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
948 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
949 && index
== p
->the_bfd_section
->index
)
951 p
->endaddr
+= address
- p
->addr
;
957 /* If mourn is being called in all the right places, this could be say
958 `gdb internal error' (since generic_mourn calls
959 breakpoint_init_inferior). */
962 ignore (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
963 struct bp_target_info
*bp_tgt
)
969 exec_has_memory (struct target_ops
*ops
)
971 /* We can provide memory if we have any file/target sections to read
973 return (current_target_sections
->sections
974 != current_target_sections
->sections_end
);
978 exec_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
980 error (_("Can't create a corefile"));
983 /* Fill in the exec file target vector. Very few entries need to be
989 exec_ops
.to_shortname
= "exec";
990 exec_ops
.to_longname
= "Local exec file";
991 exec_ops
.to_doc
= "Use an executable file as a target.\n\
992 Specify the filename of the executable file.";
993 exec_ops
.to_open
= exec_open
;
994 exec_ops
.to_close
= exec_close_1
;
995 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
996 exec_ops
.to_get_section_table
= exec_get_section_table
;
997 exec_ops
.to_files_info
= exec_files_info
;
998 exec_ops
.to_insert_breakpoint
= ignore
;
999 exec_ops
.to_remove_breakpoint
= ignore
;
1000 exec_ops
.to_stratum
= file_stratum
;
1001 exec_ops
.to_has_memory
= exec_has_memory
;
1002 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
1003 exec_ops
.to_find_memory_regions
= objfile_find_memory_regions
;
1004 exec_ops
.to_magic
= OPS_MAGIC
;
1008 _initialize_exec (void)
1010 struct cmd_list_element
*c
;
1016 c
= add_cmd ("file", class_files
, file_command
, _("\
1017 Use FILE as program to be debugged.\n\
1018 It is read for its symbols, for getting the contents of pure memory,\n\
1019 and it is the program executed when you use the `run' command.\n\
1020 If FILE cannot be found as specified, your execution directory path\n\
1021 ($PATH) is searched for a command of that name.\n\
1022 No arg means to have no executable file and no symbols."), &cmdlist
);
1023 set_cmd_completer (c
, filename_completer
);
1026 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1027 Use FILE as program for getting contents of pure memory.\n\
1028 If FILE cannot be found as specified, your execution directory path\n\
1029 is searched for a command of that name.\n\
1030 No arg means have no executable file."), &cmdlist
);
1031 set_cmd_completer (c
, filename_completer
);
1033 add_com ("section", class_files
, set_section_command
, _("\
1034 Change the base address of section SECTION of the exec file to ADDR.\n\
1035 This can be used if the exec file does not contain section addresses,\n\
1036 (such as in the a.out format), or when the addresses specified in the\n\
1037 file itself are wrong. Each section must be changed separately. The\n\
1038 ``info files'' command lists all the sections and their addresses."));
1040 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1041 Set writing into executable and core files."), _("\
1042 Show writing into executable and core files."), NULL
,
1045 &setlist
, &showlist
);
1047 add_target_with_completer (&exec_ops
, filename_completer
);