1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2018 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
) (const char *);
50 /* Prototypes for local functions */
52 static void exec_files_info (struct target_ops
*);
54 static void init_exec_ops (void);
56 /* The target vector for executable files. */
58 static struct target_ops exec_ops
;
60 /* Whether to open exec and core files read-only or read-write. */
64 show_write_files (struct ui_file
*file
, int from_tty
,
65 struct cmd_list_element
*c
, const char *value
)
67 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
73 exec_open (const char *args
, int from_tty
)
75 target_preopen (from_tty
);
76 exec_file_attach (args
, from_tty
);
79 /* Close and clear exec_bfd. If we end up with no target sections to
80 read memory from, this unpushes the exec_ops target. */
91 /* Removing target sections may close the exec_ops target.
92 Clear exec_bfd before doing so to prevent recursion. */
96 remove_target_sections (&exec_bfd
);
98 xfree (exec_filename
);
103 /* This is the target_close implementation. Clears all target
104 sections and closes all executable bfds from all program spaces. */
107 exec_close_1 (struct target_ops
*self
)
109 struct program_space
*ss
;
110 scoped_restore_current_program_space restore_pspace
;
114 set_current_program_space (ss
);
115 clear_section_table (current_target_sections
);
121 exec_file_clear (int from_tty
)
123 /* Remove exec file. */
127 printf_unfiltered (_("No executable file now.\n"));
133 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
134 symfile_add_flags add_flags
)
136 struct cleanup
*old_chain
;
137 struct gdb_exception prev_err
= exception_none
;
139 old_chain
= make_cleanup (free_current_contents
, &prev_err
.message
);
141 /* exec_file_attach and symbol_file_add_main may throw an error if the file
142 cannot be opened either locally or remotely.
144 This happens for example, when the file is first found in the local
145 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
146 exist in the target filesystem, or when the file does exist, but
149 Even without a symbol file, the remote-based debugging session should
150 continue normally instead of ending abruptly. Hence we catch thrown
151 errors/exceptions in the following code. */
154 /* We must do this step even if exec_file_host is NULL, so that
155 exec_file_attach will clear state. */
156 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
158 CATCH (err
, RETURN_MASK_ERROR
)
160 if (err
.message
!= NULL
)
161 warning ("%s", err
.message
);
165 /* Save message so it doesn't get trashed by the catch below. */
166 if (err
.message
!= NULL
)
167 prev_err
.message
= xstrdup (err
.message
);
171 if (exec_file_host
!= NULL
)
175 symbol_file_add_main (exec_file_host
, add_flags
);
177 CATCH (err
, RETURN_MASK_ERROR
)
179 if (!exception_print_same (prev_err
, err
))
180 warning ("%s", err
.message
);
185 do_cleanups (old_chain
);
191 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
193 char *exec_file_target
;
194 symfile_add_flags add_flags
= 0;
196 /* Do nothing if we already have an executable filename. */
197 if (get_exec_file (0) != NULL
)
200 /* Try to determine a filename from the process itself. */
201 exec_file_target
= target_pid_to_exec_file (pid
);
202 if (exec_file_target
== NULL
)
204 warning (_("No executable has been specified and target does not "
206 "determining executable automatically. "
207 "Try using the \"file\" command."));
211 gdb::unique_xmalloc_ptr
<char> exec_file_host
212 = exec_file_find (exec_file_target
, NULL
);
215 add_flags
|= SYMFILE_DEFER_BP_RESET
;
218 add_flags
|= SYMFILE_VERBOSE
;
220 /* Attempt to open the exec file. */
221 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
224 /* Set FILENAME as the new exec file.
226 This function is intended to be behave essentially the same
227 as exec_file_command, except that the latter will detect when
228 a target is being debugged, and will ask the user whether it
229 should be shut down first. (If the answer is "no", then the
230 new file is ignored.)
232 This file is used by exec_file_command, to do the work of opening
233 and processing the exec file after any prompting has happened.
235 And, it is used by child_attach, when the attach command was
236 given a pid but not a exec pathname, and the attach command could
237 figure out the pathname from the pid. (In this case, we shouldn't
238 ask the user whether the current target should be shut down --
239 we're supplying the exec pathname late for good reason.) */
242 exec_file_attach (const char *filename
, int from_tty
)
244 /* First, acquire a reference to the current exec_bfd. We release
245 this at the end of the function; but acquiring it now lets the
246 BFD cache return it if this call refers to the same file. */
247 gdb_bfd_ref_ptr exec_bfd_holder
= new_bfd_ref (exec_bfd
);
249 /* Remove any previous exec file. */
252 /* Now open and digest the file the user requested, if any. */
257 printf_unfiltered (_("No executable file now.\n"));
259 set_gdbarch_from_file (NULL
);
263 int load_via_target
= 0;
264 const char *scratch_pathname
, *canonical_pathname
;
266 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
269 if (is_target_filename (filename
))
271 if (target_filesystem_is_local ())
272 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
277 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
280 /* gdb_bfd_fopen does not support "target:" filenames. */
282 warning (_("writing into executable files is "
283 "not supported for %s sysroots"),
284 TARGET_SYSROOT_PREFIX
);
286 scratch_pathname
= filename
;
288 canonical_pathname
= scratch_pathname
;
294 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
295 filename
, write_files
?
296 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
298 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
299 if (scratch_chan
< 0)
301 char *exename
= (char *) alloca (strlen (filename
) + 5);
303 strcat (strcpy (exename
, filename
), ".exe");
304 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
305 exename
, write_files
?
307 : O_RDONLY
| O_BINARY
,
311 if (scratch_chan
< 0)
312 perror_with_name (filename
);
314 scratch_storage
.reset (temp_pathname
);
315 scratch_pathname
= temp_pathname
;
317 /* gdb_bfd_open (and its variants) prefers canonicalized
318 pathname for better BFD caching. */
319 canonical_storage
= gdb_realpath (scratch_pathname
);
320 canonical_pathname
= canonical_storage
.get ();
323 gdb_bfd_ref_ptr temp
;
324 if (write_files
&& !load_via_target
)
325 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
326 FOPEN_RUB
, scratch_chan
);
328 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
329 exec_bfd
= temp
.release ();
333 error (_("\"%s\": could not open as an executable file: %s."),
334 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
337 /* gdb_realpath_keepfile resolves symlinks on the local
338 filesystem and so cannot be used for "target:" files. */
339 gdb_assert (exec_filename
== NULL
);
341 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
343 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
345 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
347 /* Make sure to close exec_bfd, or else "run" might try to use
350 error (_("\"%s\": not in executable format: %s"),
352 gdb_bfd_errmsg (bfd_get_error (), matching
));
355 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
357 /* Make sure to close exec_bfd, or else "run" might try to use
360 error (_("\"%s\": can't find the file sections: %s"),
361 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
364 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
368 set_gdbarch_from_file (exec_bfd
);
370 /* Add the executable's sections to the current address spaces'
371 list of sections. This possibly pushes the exec_ops
373 add_target_sections (&exec_bfd
, sections
, sections_end
);
376 /* Tell display code (if any) about the changed file name. */
377 if (deprecated_exec_file_display_hook
)
378 (*deprecated_exec_file_display_hook
) (filename
);
381 bfd_cache_close_all ();
382 observer_notify_executable_changed ();
385 /* Process the first arg in ARGS as the new exec file.
387 Note that we have to explicitly ignore additional args, since we can
388 be called from file_command(), which also calls symbol_file_command()
389 which can take multiple args.
391 If ARGS is NULL, we just want to close the exec file. */
394 exec_file_command (const char *args
, int from_tty
)
396 if (from_tty
&& target_has_execution
397 && !query (_("A program is being debugged already.\n"
398 "Are you sure you want to change the file? ")))
399 error (_("File not changed."));
403 /* Scan through the args and pick up the first non option arg
406 gdb_argv
built_argv (args
);
407 char **argv
= built_argv
.get ();
409 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
413 error (_("No executable file name was specified"));
415 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
416 exec_file_attach (filename
.get (), from_tty
);
419 exec_file_attach (NULL
, from_tty
);
422 /* Set both the exec file and the symbol file, in one command.
423 What a novelty. Why did GDB go through four major releases before this
424 command was added? */
427 file_command (const char *arg
, int from_tty
)
429 /* FIXME, if we lose on reading the symbol file, we should revert
430 the exec file, but that's rough. */
431 exec_file_command (arg
, from_tty
);
432 symbol_file_command (arg
, from_tty
);
433 if (deprecated_file_changed_hook
)
434 deprecated_file_changed_hook (arg
);
438 /* Locate all mappable sections of a BFD file.
439 table_pp_char is a char * to get it through bfd_map_over_sections;
440 we cast it back to its proper type. */
443 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
446 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
449 gdb_assert (abfd
== asect
->owner
);
451 /* Check the section flags, but do not discard zero-length sections, since
452 some symbols may still be attached to this section. For instance, we
453 encountered on sparc-solaris 2.10 a shared library with an empty .bss
454 section to which a symbol named "_end" was attached. The address
455 of this symbol still needs to be relocated. */
456 aflag
= bfd_get_section_flags (abfd
, asect
);
457 if (!(aflag
& SEC_ALLOC
))
460 (*table_pp
)->owner
= NULL
;
461 (*table_pp
)->the_bfd_section
= asect
;
462 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
463 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
470 clear_section_table (struct target_section_table
*table
)
472 xfree (table
->sections
);
473 table
->sections
= table
->sections_end
= NULL
;
476 /* Resize section table TABLE by ADJUSTMENT.
477 ADJUSTMENT may be negative, in which case the caller must have already
478 removed the sections being deleted.
479 Returns the old size. */
482 resize_section_table (struct target_section_table
*table
, int adjustment
)
487 old_count
= table
->sections_end
- table
->sections
;
489 new_count
= adjustment
+ old_count
;
493 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
495 table
->sections_end
= table
->sections
+ new_count
;
498 clear_section_table (table
);
503 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
504 Returns 0 if OK, 1 on error. */
507 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
508 struct target_section
**end
)
512 count
= bfd_count_sections (some_bfd
);
515 *start
= XNEWVEC (struct target_section
, count
);
517 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
518 if (*end
> *start
+ count
)
519 internal_error (__FILE__
, __LINE__
,
520 _("failed internal consistency check"));
521 /* We could realloc the table, but it probably loses for most files. */
525 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
526 current set of target sections. */
529 add_target_sections (void *owner
,
530 struct target_section
*sections
,
531 struct target_section
*sections_end
)
534 struct target_section_table
*table
= current_target_sections
;
536 count
= sections_end
- sections
;
540 int space
= resize_section_table (table
, count
);
543 for (i
= 0; i
< count
; ++i
)
545 table
->sections
[space
+ i
] = sections
[i
];
546 table
->sections
[space
+ i
].owner
= owner
;
549 /* If these are the first file sections we can provide memory
550 from, push the file_stratum target. */
551 if (!target_is_pushed (&exec_ops
))
552 push_target (&exec_ops
);
556 /* Add the sections of OBJFILE to the current set of target sections. */
559 add_target_sections_of_objfile (struct objfile
*objfile
)
561 struct target_section_table
*table
= current_target_sections
;
562 struct obj_section
*osect
;
565 struct target_section
*ts
;
570 /* Compute the number of sections to add. */
571 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
573 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
581 space
= resize_section_table (table
, count
);
583 ts
= table
->sections
+ space
;
585 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
587 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
590 gdb_assert (ts
< table
->sections
+ space
+ count
);
592 ts
->addr
= obj_section_addr (osect
);
593 ts
->endaddr
= obj_section_endaddr (osect
);
594 ts
->the_bfd_section
= osect
->the_bfd_section
;
595 ts
->owner
= (void *) objfile
;
601 /* Remove all target sections owned by OWNER.
602 OWNER must be the same value passed to add_target_sections. */
605 remove_target_sections (void *owner
)
607 struct target_section
*src
, *dest
;
608 struct target_section_table
*table
= current_target_sections
;
610 gdb_assert (owner
!= NULL
);
612 dest
= table
->sections
;
613 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
614 if (src
->owner
!= owner
)
616 /* Keep this section. */
622 /* If we've dropped any sections, resize the section table. */
627 old_count
= resize_section_table (table
, dest
- src
);
629 /* If we don't have any more sections to read memory from,
630 remove the file_stratum target from the stack. */
631 if (old_count
+ (dest
- src
) == 0)
633 struct program_space
*pspace
;
636 if (pspace
->target_sections
.sections
637 != pspace
->target_sections
.sections_end
)
640 unpush_target (&exec_ops
);
647 enum target_xfer_status
648 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
649 ULONGEST len
, ULONGEST
*xfered_len
)
651 /* It's unduly pedantic to refuse to look at the executable for
652 read-only pieces; so do the equivalent of readonly regions aka
654 if (exec_bfd
!= NULL
)
660 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
662 if ((s
->flags
& SEC_LOAD
) == 0
663 || (s
->flags
& SEC_READONLY
) == 0)
667 size
= bfd_get_section_size (s
);
668 if (vma
<= offset
&& offset
< (vma
+ size
))
672 amt
= (vma
+ size
) - offset
;
676 amt
= bfd_get_section_contents (exec_bfd
, s
,
677 readbuf
, offset
- vma
, amt
);
680 return TARGET_XFER_EOF
;
684 return TARGET_XFER_OK
;
690 /* Indicate failure to find the requested memory block. */
691 return TARGET_XFER_E_IO
;
694 /* Return all read-only memory ranges found in the target section
695 table defined by SECTIONS and SECTIONS_END, starting at (and
696 intersected with) MEMADDR for LEN bytes. */
698 static std::vector
<mem_range
>
699 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
700 struct target_section
*sections
,
701 struct target_section
*sections_end
)
703 std::vector
<mem_range
> memory
;
705 for (target_section
*p
= sections
; p
< sections_end
; p
++)
707 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
709 & SEC_READONLY
) == 0)
712 /* Copy the meta-data, adjusted. */
713 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
715 ULONGEST lo1
, hi1
, lo2
, hi2
;
723 CORE_ADDR start
= std::max (lo1
, lo2
);
724 int length
= std::min (hi1
, hi2
) - start
;
726 memory
.emplace_back (start
, length
);
733 enum target_xfer_status
734 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
735 ULONGEST len
, ULONGEST
*xfered_len
)
737 target_section_table
*table
= target_get_section_table (&exec_ops
);
738 std::vector
<mem_range
> available_memory
739 = section_table_available_memory (offset
, len
,
740 table
->sections
, table
->sections_end
);
742 normalize_mem_ranges (&available_memory
);
744 for (const mem_range
&r
: available_memory
)
746 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
749 enum target_xfer_status status
;
751 /* Get the intersection window. */
752 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
754 gdb_assert (end
- offset
<= len
);
756 if (offset
>= r
.start
)
757 status
= exec_read_partial_read_only (readbuf
, offset
,
762 *xfered_len
= r
.start
- offset
;
763 status
= TARGET_XFER_UNAVAILABLE
;
770 return TARGET_XFER_UNAVAILABLE
;
773 enum target_xfer_status
774 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
775 ULONGEST offset
, ULONGEST len
,
776 ULONGEST
*xfered_len
,
777 struct target_section
*sections
,
778 struct target_section
*sections_end
,
779 const char *section_name
)
782 struct target_section
*p
;
783 ULONGEST memaddr
= offset
;
784 ULONGEST memend
= memaddr
+ len
;
787 internal_error (__FILE__
, __LINE__
,
788 _("failed internal consistency check"));
790 for (p
= sections
; p
< sections_end
; p
++)
792 struct bfd_section
*asect
= p
->the_bfd_section
;
793 bfd
*abfd
= asect
->owner
;
795 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
796 continue; /* not the section we need. */
797 if (memaddr
>= p
->addr
)
799 if (memend
<= p
->endaddr
)
801 /* Entire transfer is within this section. */
803 res
= bfd_set_section_contents (abfd
, asect
,
804 writebuf
, memaddr
- p
->addr
,
807 res
= bfd_get_section_contents (abfd
, asect
,
808 readbuf
, memaddr
- p
->addr
,
814 return TARGET_XFER_OK
;
817 return TARGET_XFER_EOF
;
819 else if (memaddr
>= p
->endaddr
)
821 /* This section ends before the transfer starts. */
826 /* This section overlaps the transfer. Just do half. */
827 len
= p
->endaddr
- memaddr
;
829 res
= bfd_set_section_contents (abfd
, asect
,
830 writebuf
, memaddr
- p
->addr
,
833 res
= bfd_get_section_contents (abfd
, asect
,
834 readbuf
, memaddr
- p
->addr
,
839 return TARGET_XFER_OK
;
842 return TARGET_XFER_EOF
;
847 return TARGET_XFER_EOF
; /* We can't help. */
850 static struct target_section_table
*
851 exec_get_section_table (struct target_ops
*ops
)
853 return current_target_sections
;
856 static enum target_xfer_status
857 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
858 const char *annex
, gdb_byte
*readbuf
,
859 const gdb_byte
*writebuf
,
860 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
862 struct target_section_table
*table
= target_get_section_table (ops
);
864 if (object
== TARGET_OBJECT_MEMORY
)
865 return section_table_xfer_memory_partial (readbuf
, writebuf
,
866 offset
, len
, xfered_len
,
871 return TARGET_XFER_E_IO
;
876 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
878 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
879 struct target_section
*p
;
880 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
881 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
883 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
885 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
886 if (abfd
== exec_bfd
)
888 /* gcc-3.4 does not like the initialization in
889 <p == t->sections_end>. */
890 bfd_vma displacement
= 0;
893 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
895 struct bfd_section
*psect
= p
->the_bfd_section
;
896 bfd
*pbfd
= psect
->owner
;
898 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
899 != (SEC_ALLOC
| SEC_LOAD
))
902 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
903 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
904 + bfd_get_section_size (psect
)))
906 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
910 if (p
== t
->sections_end
)
911 warning (_("Cannot find section for the entry point of %s."),
912 bfd_get_filename (abfd
));
914 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
915 bfd_get_start_address (abfd
)
917 printf_filtered (_("\tEntry point: %s\n"),
918 paddress (gdbarch
, entry_point
));
920 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
922 struct bfd_section
*psect
= p
->the_bfd_section
;
923 bfd
*pbfd
= psect
->owner
;
925 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
926 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
928 /* FIXME: A format of "08l" is not wide enough for file offsets
929 larger than 4GB. OTOH, making it "016l" isn't desirable either
930 since most output will then be much wider than necessary. It
931 may make sense to test the size of the file and choose the
932 format string accordingly. */
933 /* FIXME: i18n: Need to rewrite this sentence. */
935 printf_filtered (" @ %s",
936 hex_string_custom (psect
->filepos
, 8));
937 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
939 printf_filtered (" in %s", bfd_get_filename (pbfd
));
940 printf_filtered ("\n");
945 exec_files_info (struct target_ops
*t
)
948 print_section_info (current_target_sections
, exec_bfd
);
950 puts_filtered (_("\t<no file loaded>\n"));
954 set_section_command (const char *args
, int from_tty
)
956 struct target_section
*p
;
959 unsigned long secaddr
;
962 struct target_section_table
*table
;
965 error (_("Must specify section name and its virtual address"));
967 /* Parse out section name. */
968 for (secname
= args
; !isspace (*args
); args
++);
969 seclen
= args
- secname
;
971 /* Parse out new virtual address. */
972 secaddr
= parse_and_eval_address (args
);
974 table
= current_target_sections
;
975 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
977 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
978 p
->the_bfd_section
), seclen
)
979 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
981 offset
= secaddr
- p
->addr
;
983 p
->endaddr
+= offset
;
985 exec_files_info (&exec_ops
);
989 if (seclen
>= sizeof (secprint
))
990 seclen
= sizeof (secprint
) - 1;
991 strncpy (secprint
, secname
, seclen
);
992 secprint
[seclen
] = '\0';
993 error (_("Section %s not found"), secprint
);
996 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1000 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1002 struct target_section
*p
;
1003 struct target_section_table
*table
;
1005 table
= current_target_sections
;
1006 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1008 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
1009 && index
== p
->the_bfd_section
->index
)
1011 p
->endaddr
+= address
- p
->addr
;
1017 /* If mourn is being called in all the right places, this could be say
1018 `gdb internal error' (since generic_mourn calls
1019 breakpoint_init_inferior). */
1022 ignore (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
1023 struct bp_target_info
*bp_tgt
)
1028 /* Implement the to_remove_breakpoint method. */
1031 exec_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
1032 struct bp_target_info
*bp_tgt
,
1033 enum remove_bp_reason reason
)
1039 exec_has_memory (struct target_ops
*ops
)
1041 /* We can provide memory if we have any file/target sections to read
1043 return (current_target_sections
->sections
1044 != current_target_sections
->sections_end
);
1048 exec_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
1050 error (_("Can't create a corefile"));
1053 /* Fill in the exec file target vector. Very few entries need to be
1057 init_exec_ops (void)
1059 exec_ops
.to_shortname
= "exec";
1060 exec_ops
.to_longname
= "Local exec file";
1061 exec_ops
.to_doc
= "Use an executable file as a target.\n\
1062 Specify the filename of the executable file.";
1063 exec_ops
.to_open
= exec_open
;
1064 exec_ops
.to_close
= exec_close_1
;
1065 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
1066 exec_ops
.to_get_section_table
= exec_get_section_table
;
1067 exec_ops
.to_files_info
= exec_files_info
;
1068 exec_ops
.to_insert_breakpoint
= ignore
;
1069 exec_ops
.to_remove_breakpoint
= exec_remove_breakpoint
;
1070 exec_ops
.to_stratum
= file_stratum
;
1071 exec_ops
.to_has_memory
= exec_has_memory
;
1072 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
1073 exec_ops
.to_find_memory_regions
= objfile_find_memory_regions
;
1074 exec_ops
.to_magic
= OPS_MAGIC
;
1078 _initialize_exec (void)
1080 struct cmd_list_element
*c
;
1086 c
= add_cmd ("file", class_files
, file_command
, _("\
1087 Use FILE as program to be debugged.\n\
1088 It is read for its symbols, for getting the contents of pure memory,\n\
1089 and it is the program executed when you use the `run' command.\n\
1090 If FILE cannot be found as specified, your execution directory path\n\
1091 ($PATH) is searched for a command of that name.\n\
1092 No arg means to have no executable file and no symbols."), &cmdlist
);
1093 set_cmd_completer (c
, filename_completer
);
1096 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1097 Use FILE as program for getting contents of pure memory.\n\
1098 If FILE cannot be found as specified, your execution directory path\n\
1099 is searched for a command of that name.\n\
1100 No arg means have no executable file."), &cmdlist
);
1101 set_cmd_completer (c
, filename_completer
);
1103 add_com ("section", class_files
, set_section_command
, _("\
1104 Change the base address of section SECTION of the exec file to ADDR.\n\
1105 This can be used if the exec file does not contain section addresses,\n\
1106 (such as in the a.out format), or when the addresses specified in the\n\
1107 file itself are wrong. Each section must be changed separately. The\n\
1108 ``info files'' command lists all the sections and their addresses."));
1110 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1111 Set writing into executable and core files."), _("\
1112 Show writing into executable and core files."), NULL
,
1115 &setlist
, &showlist
);
1117 add_target_with_completer (&exec_ops
, filename_completer
);