1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2020 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"
32 #include "observable.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
36 #include "progspace-and-thread.h"
43 #include "readline/tilde.h"
50 #include "gdbsupport/pathstuff.h"
51 #include "cli/cli-style.h"
53 void (*deprecated_file_changed_hook
) (const char *);
55 static const target_info exec_target_info
= {
57 N_("Local exec file"),
58 N_("Use an executable file as a target.\n\
59 Specify the filename of the executable file.")
62 /* The target vector for executable files. */
64 struct exec_target final
: public target_ops
66 const target_info
&info () const override
67 { return exec_target_info
; }
69 strata
stratum () const override
{ return file_stratum
; }
71 void close () override
;
72 enum target_xfer_status
xfer_partial (enum target_object object
,
75 const gdb_byte
*writebuf
,
76 ULONGEST offset
, ULONGEST len
,
77 ULONGEST
*xfered_len
) override
;
78 target_section_table
*get_section_table () override
;
79 void files_info () override
;
81 bool has_memory () override
;
82 gdb::unique_xmalloc_ptr
<char> make_corefile_notes (bfd
*, int *) override
;
83 int find_memory_regions (find_memory_region_ftype func
, void *data
) override
;
86 static exec_target exec_ops
;
88 /* How to handle a mismatch between the current exec file and the exec
89 file determined from target. */
91 static const char *const exec_file_mismatch_names
[]
92 = {"ask", "warn", "off", NULL
};
93 enum exec_file_mismatch_mode
95 exec_file_mismatch_ask
, exec_file_mismatch_warn
, exec_file_mismatch_off
97 static const char *exec_file_mismatch
= exec_file_mismatch_names
[0];
98 static enum exec_file_mismatch_mode exec_file_mismatch_mode
99 = exec_file_mismatch_ask
;
103 show_exec_file_mismatch_command (struct ui_file
*file
, int from_tty
,
104 struct cmd_list_element
*c
, const char *value
)
106 fprintf_filtered (gdb_stdout
,
107 _("exec-file-mismatch handling is currently \"%s\".\n"),
108 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
111 /* Set command. Change the setting for range checking. */
113 set_exec_file_mismatch_command (const char *ignore
,
114 int from_tty
, struct cmd_list_element
*c
)
116 for (enum exec_file_mismatch_mode mode
= exec_file_mismatch_ask
;
118 mode
= static_cast<enum exec_file_mismatch_mode
>(1 + (int) mode
))
120 if (strcmp (exec_file_mismatch
, exec_file_mismatch_names
[mode
]) == 0)
122 exec_file_mismatch_mode
= mode
;
125 if (mode
== exec_file_mismatch_off
)
126 internal_error (__FILE__
, __LINE__
,
127 _("Unrecognized exec-file-mismatch setting: \"%s\""),
132 /* Whether to open exec and core files read-only or read-write. */
134 bool write_files
= false;
136 show_write_files (struct ui_file
*file
, int from_tty
,
137 struct cmd_list_element
*c
, const char *value
)
139 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
145 exec_target_open (const char *args
, int from_tty
)
147 target_preopen (from_tty
);
148 exec_file_attach (args
, from_tty
);
151 /* This is the target_close implementation. Clears all target
152 sections and closes all executable bfds from all program spaces. */
155 exec_target::close ()
157 scoped_restore_current_program_space restore_pspace
;
159 for (struct program_space
*ss
: program_spaces
)
161 set_current_program_space (ss
);
162 ss
->target_sections
.clear ();
170 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
171 symfile_add_flags add_flags
)
173 struct gdb_exception prev_err
;
175 /* exec_file_attach and symbol_file_add_main may throw an error if the file
176 cannot be opened either locally or remotely.
178 This happens for example, when the file is first found in the local
179 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
180 exist in the target filesystem, or when the file does exist, but
183 Even without a symbol file, the remote-based debugging session should
184 continue normally instead of ending abruptly. Hence we catch thrown
185 errors/exceptions in the following code. */
188 /* We must do this step even if exec_file_host is NULL, so that
189 exec_file_attach will clear state. */
190 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
192 catch (gdb_exception_error
&err
)
194 if (err
.message
!= NULL
)
195 warning ("%s", err
.what ());
197 prev_err
= std::move (err
);
200 if (exec_file_host
!= NULL
)
204 symbol_file_add_main (exec_file_host
, add_flags
);
206 catch (const gdb_exception_error
&err
)
208 if (!exception_print_same (prev_err
, err
))
209 warning ("%s", err
.what ());
217 validate_exec_file (int from_tty
)
219 /* If user asked to ignore the mismatch, do nothing. */
220 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
223 const char *current_exec_file
= get_exec_file (0);
224 struct inferior
*inf
= current_inferior ();
225 /* Try to determine a filename from the process itself. */
226 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
227 bool build_id_mismatch
= false;
229 /* If we cannot validate the exec file, return. */
230 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
233 /* Try validating via build-id, if available. This is the most
236 /* In case current_exec_file was changed, reopen_exec_file ensures
237 an up to date build_id (will do nothing if the file timestamp
238 did not change). If exec file changed, reopen_exec_file has
239 allocated another file name, so get_exec_file again. */
241 current_exec_file
= get_exec_file (0);
243 const bfd_build_id
*exec_file_build_id
244 = build_id_bfd_get (current_program_space
->exec_bfd ());
245 if (exec_file_build_id
!= nullptr)
247 /* Prepend the target prefix, to force gdb_bfd_open to open the
248 file on the remote file system (if indeed remote). */
249 std::string target_pid_exec_file
250 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
252 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
253 gnutarget
, -1, false));
256 const bfd_build_id
*target_exec_file_build_id
257 = build_id_bfd_get (abfd
.get ());
259 if (target_exec_file_build_id
!= nullptr)
261 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
262 && memcmp (exec_file_build_id
->data
,
263 target_exec_file_build_id
->data
,
264 exec_file_build_id
->size
) == 0)
270 build_id_mismatch
= true;
275 if (build_id_mismatch
)
277 std::string
exec_file_target (pid_exec_file
);
279 /* In case the exec file is not local, exec_file_target has to point at
280 the target file system. */
281 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
282 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
285 (_("Build ID mismatch between current exec-file %ps\n"
286 "and automatically determined exec-file %ps\n"
287 "exec-file-mismatch handling is currently \"%s\""),
288 styled_string (file_name_style
.style (), current_exec_file
),
289 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
290 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
291 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
293 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
296 add_flags
|= SYMFILE_VERBOSE
;
297 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
301 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
302 exec_file_attach (exec_file_target
.c_str (), from_tty
);
304 catch (gdb_exception_error
&err
)
306 warning (_("loading %ps %s"),
307 styled_string (file_name_style
.style (),
308 exec_file_target
.c_str ()),
309 err
.message
!= NULL
? err
.what () : "error");
318 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
320 char *exec_file_target
;
321 symfile_add_flags add_flags
= 0;
323 /* Do nothing if we already have an executable filename. */
324 if (get_exec_file (0) != NULL
)
327 /* Try to determine a filename from the process itself. */
328 exec_file_target
= target_pid_to_exec_file (pid
);
329 if (exec_file_target
== NULL
)
331 warning (_("No executable has been specified and target does not "
333 "determining executable automatically. "
334 "Try using the \"file\" command."));
338 gdb::unique_xmalloc_ptr
<char> exec_file_host
339 = exec_file_find (exec_file_target
, NULL
);
342 add_flags
|= SYMFILE_DEFER_BP_RESET
;
345 add_flags
|= SYMFILE_VERBOSE
;
347 /* Attempt to open the exec file. */
348 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
351 /* Set FILENAME as the new exec file.
353 This function is intended to be behave essentially the same
354 as exec_file_command, except that the latter will detect when
355 a target is being debugged, and will ask the user whether it
356 should be shut down first. (If the answer is "no", then the
357 new file is ignored.)
359 This file is used by exec_file_command, to do the work of opening
360 and processing the exec file after any prompting has happened.
362 And, it is used by child_attach, when the attach command was
363 given a pid but not a exec pathname, and the attach command could
364 figure out the pathname from the pid. (In this case, we shouldn't
365 ask the user whether the current target should be shut down --
366 we're supplying the exec pathname late for good reason.) */
369 exec_file_attach (const char *filename
, int from_tty
)
371 /* First, acquire a reference to the exec_bfd. We release
372 this at the end of the function; but acquiring it now lets the
373 BFD cache return it if this call refers to the same file. */
374 gdb_bfd_ref_ptr exec_bfd_holder
375 = gdb_bfd_ref_ptr::new_reference (current_program_space
->exec_bfd ());
377 /* Remove any previous exec file. */
378 current_program_space
->exec_close ();
380 /* Now open and digest the file the user requested, if any. */
385 printf_unfiltered (_("No executable file now.\n"));
387 set_gdbarch_from_file (NULL
);
391 int load_via_target
= 0;
392 const char *scratch_pathname
, *canonical_pathname
;
396 if (is_target_filename (filename
))
398 if (target_filesystem_is_local ())
399 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
404 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
407 /* gdb_bfd_fopen does not support "target:" filenames. */
409 warning (_("writing into executable files is "
410 "not supported for %s sysroots"),
411 TARGET_SYSROOT_PREFIX
);
413 scratch_pathname
= filename
;
415 canonical_pathname
= scratch_pathname
;
419 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
420 filename
, write_files
?
421 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
423 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
424 if (scratch_chan
< 0)
426 int first_errno
= errno
;
427 char *exename
= (char *) alloca (strlen (filename
) + 5);
429 strcat (strcpy (exename
, filename
), ".exe");
430 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
431 exename
, write_files
?
433 : O_RDONLY
| O_BINARY
,
435 if (scratch_chan
< 0)
439 if (scratch_chan
< 0)
440 perror_with_name (filename
);
442 scratch_pathname
= scratch_storage
.get ();
444 /* gdb_bfd_open (and its variants) prefers canonicalized
445 pathname for better BFD caching. */
446 canonical_storage
= gdb_realpath (scratch_pathname
);
447 canonical_pathname
= canonical_storage
.get ();
450 gdb_bfd_ref_ptr temp
;
451 if (write_files
&& !load_via_target
)
452 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
453 FOPEN_RUB
, scratch_chan
);
455 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
456 current_program_space
->set_exec_bfd (std::move (temp
));
458 if (!current_program_space
->exec_bfd ())
460 error (_("\"%ps\": could not open as an executable file: %s."),
461 styled_string (file_name_style
.style (), scratch_pathname
),
462 bfd_errmsg (bfd_get_error ()));
465 /* gdb_realpath_keepfile resolves symlinks on the local
466 filesystem and so cannot be used for "target:" files. */
467 gdb_assert (current_program_space
->exec_filename
== nullptr);
469 current_program_space
->exec_filename
470 = (make_unique_xstrdup
471 (bfd_get_filename (current_program_space
->exec_bfd ())));
473 current_program_space
->exec_filename
474 = gdb_realpath_keepfile (scratch_pathname
);
476 if (!bfd_check_format_matches (current_program_space
->exec_bfd (),
477 bfd_object
, &matching
))
479 /* Make sure to close exec_bfd, or else "run" might try to use
481 current_program_space
->exec_close ();
482 error (_("\"%ps\": not in executable format: %s"),
483 styled_string (file_name_style
.style (), scratch_pathname
),
484 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
487 target_section_table sections
488 = build_section_table (current_program_space
->exec_bfd ());
490 current_program_space
->ebfd_mtime
491 = bfd_get_mtime (current_program_space
->exec_bfd ());
495 set_gdbarch_from_file (current_program_space
->exec_bfd ());
497 /* Add the executable's sections to the current address spaces'
498 list of sections. This possibly pushes the exec_ops
500 current_program_space
->add_target_sections (¤t_program_space
->ebfd
,
503 /* Tell display code (if any) about the changed file name. */
504 if (deprecated_exec_file_display_hook
)
505 (*deprecated_exec_file_display_hook
) (filename
);
508 bfd_cache_close_all ();
509 gdb::observers::executable_changed
.notify ();
512 /* Process the first arg in ARGS as the new exec file.
514 Note that we have to explicitly ignore additional args, since we can
515 be called from file_command(), which also calls symbol_file_command()
516 which can take multiple args.
518 If ARGS is NULL, we just want to close the exec file. */
521 exec_file_command (const char *args
, int from_tty
)
523 if (from_tty
&& target_has_execution ()
524 && !query (_("A program is being debugged already.\n"
525 "Are you sure you want to change the file? ")))
526 error (_("File not changed."));
530 /* Scan through the args and pick up the first non option arg
533 gdb_argv
built_argv (args
);
534 char **argv
= built_argv
.get ();
536 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
540 error (_("No executable file name was specified"));
542 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
543 exec_file_attach (filename
.get (), from_tty
);
546 exec_file_attach (NULL
, from_tty
);
549 /* Set both the exec file and the symbol file, in one command.
550 What a novelty. Why did GDB go through four major releases before this
551 command was added? */
554 file_command (const char *arg
, int from_tty
)
556 /* FIXME, if we lose on reading the symbol file, we should revert
557 the exec file, but that's rough. */
558 exec_file_command (arg
, from_tty
);
559 symbol_file_command (arg
, from_tty
);
560 if (deprecated_file_changed_hook
)
561 deprecated_file_changed_hook (arg
);
565 /* Builds a section table, given args BFD, TABLE. */
568 build_section_table (struct bfd
*some_bfd
)
570 target_section_table table
;
572 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
576 /* Check the section flags, but do not discard zero-length
577 sections, since some symbols may still be attached to this
578 section. For instance, we encountered on sparc-solaris 2.10
579 a shared library with an empty .bss section to which a symbol
580 named "_end" was attached. The address of this symbol still
581 needs to be relocated. */
582 aflag
= bfd_section_flags (asect
);
583 if (!(aflag
& SEC_ALLOC
))
586 table
.emplace_back (bfd_section_vma (asect
),
587 bfd_section_vma (asect
) + bfd_section_size (asect
),
594 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
595 current set of target sections. */
598 program_space::add_target_sections (void *owner
,
599 const target_section_table
§ions
)
601 if (!sections
.empty ())
603 for (const target_section
&s
: sections
)
605 target_sections
.push_back (s
);
606 target_sections
.back ().owner
= owner
;
609 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
611 /* If these are the first file sections we can provide memory
612 from, push the file_stratum target. Must do this in all
613 inferiors sharing the program space. */
614 for (inferior
*inf
: all_inferiors ())
616 if (inf
->pspace
!= this)
619 if (inf
->target_is_pushed (&exec_ops
))
622 switch_to_inferior_no_thread (inf
);
623 push_target (&exec_ops
);
628 /* Add the sections of OBJFILE to the current set of target sections. */
631 program_space::add_target_sections (struct objfile
*objfile
)
633 struct obj_section
*osect
;
635 gdb_assert (objfile
!= nullptr);
637 /* Compute the number of sections to add. */
638 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
640 if (bfd_section_size (osect
->the_bfd_section
) == 0)
643 target_sections
.emplace_back (obj_section_addr (osect
),
644 obj_section_endaddr (osect
),
645 osect
->the_bfd_section
, (void *) objfile
);
649 /* Remove all target sections owned by OWNER.
650 OWNER must be the same value passed to add_target_sections. */
653 program_space::remove_target_sections (void *owner
)
655 gdb_assert (owner
!= NULL
);
657 auto it
= std::remove_if (target_sections
.begin (),
658 target_sections
.end (),
659 [&] (target_section
§
)
661 return sect
.owner
== owner
;
663 target_sections
.erase (it
, target_sections
.end ());
665 /* If we don't have any more sections to read memory from,
666 remove the file_stratum target from the stack of each
667 inferior sharing the program space. */
668 if (target_sections
.empty ())
670 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
672 for (inferior
*inf
: all_inferiors ())
674 if (inf
->pspace
!= this)
677 switch_to_inferior_no_thread (inf
);
678 unpush_target (&exec_ops
);
688 if (!current_program_space
->target_sections
.empty ())
689 push_target (&exec_ops
);
694 enum target_xfer_status
695 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
696 ULONGEST len
, ULONGEST
*xfered_len
)
698 /* It's unduly pedantic to refuse to look at the executable for
699 read-only pieces; so do the equivalent of readonly regions aka
701 if (current_program_space
->exec_bfd () != NULL
)
707 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
709 if ((s
->flags
& SEC_LOAD
) == 0
710 || (s
->flags
& SEC_READONLY
) == 0)
714 size
= bfd_section_size (s
);
715 if (vma
<= offset
&& offset
< (vma
+ size
))
719 amt
= (vma
+ size
) - offset
;
723 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
724 readbuf
, offset
- vma
, amt
);
727 return TARGET_XFER_EOF
;
731 return TARGET_XFER_OK
;
737 /* Indicate failure to find the requested memory block. */
738 return TARGET_XFER_E_IO
;
741 /* Return all read-only memory ranges found in the target section
742 table defined by SECTIONS and SECTIONS_END, starting at (and
743 intersected with) MEMADDR for LEN bytes. */
745 static std::vector
<mem_range
>
746 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
747 const target_section_table
§ions
)
749 std::vector
<mem_range
> memory
;
751 for (const target_section
&p
: sections
)
753 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
756 /* Copy the meta-data, adjusted. */
757 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
759 ULONGEST lo1
, hi1
, lo2
, hi2
;
767 CORE_ADDR start
= std::max (lo1
, lo2
);
768 int length
= std::min (hi1
, hi2
) - start
;
770 memory
.emplace_back (start
, length
);
777 enum target_xfer_status
778 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
779 ULONGEST len
, ULONGEST
*xfered_len
)
781 target_section_table
*table
= target_get_section_table (&exec_ops
);
782 std::vector
<mem_range
> available_memory
783 = section_table_available_memory (offset
, len
, *table
);
785 normalize_mem_ranges (&available_memory
);
787 for (const mem_range
&r
: available_memory
)
789 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
792 enum target_xfer_status status
;
794 /* Get the intersection window. */
795 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
797 gdb_assert (end
- offset
<= len
);
799 if (offset
>= r
.start
)
800 status
= exec_read_partial_read_only (readbuf
, offset
,
805 *xfered_len
= r
.start
- offset
;
806 status
= TARGET_XFER_UNAVAILABLE
;
813 return TARGET_XFER_UNAVAILABLE
;
816 enum target_xfer_status
817 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
818 ULONGEST offset
, ULONGEST len
,
819 ULONGEST
*xfered_len
,
820 const target_section_table
§ions
,
821 gdb::function_view
<bool
822 (const struct target_section
*)> match_cb
)
825 ULONGEST memaddr
= offset
;
826 ULONGEST memend
= memaddr
+ len
;
828 gdb_assert (len
!= 0);
830 for (const target_section
&p
: sections
)
832 struct bfd_section
*asect
= p
.the_bfd_section
;
833 bfd
*abfd
= asect
->owner
;
835 if (match_cb
!= nullptr && !match_cb (&p
))
836 continue; /* not the section we need. */
837 if (memaddr
>= p
.addr
)
839 if (memend
<= p
.endaddr
)
841 /* Entire transfer is within this section. */
843 res
= bfd_set_section_contents (abfd
, asect
,
844 writebuf
, memaddr
- p
.addr
,
847 res
= bfd_get_section_contents (abfd
, asect
,
848 readbuf
, memaddr
- p
.addr
,
854 return TARGET_XFER_OK
;
857 return TARGET_XFER_EOF
;
859 else if (memaddr
>= p
.endaddr
)
861 /* This section ends before the transfer starts. */
866 /* This section overlaps the transfer. Just do half. */
867 len
= p
.endaddr
- memaddr
;
869 res
= bfd_set_section_contents (abfd
, asect
,
870 writebuf
, memaddr
- p
.addr
,
873 res
= bfd_get_section_contents (abfd
, asect
,
874 readbuf
, memaddr
- p
.addr
,
879 return TARGET_XFER_OK
;
882 return TARGET_XFER_EOF
;
887 return TARGET_XFER_EOF
; /* We can't help. */
890 target_section_table
*
891 exec_target::get_section_table ()
893 return ¤t_program_space
->target_sections
;
896 enum target_xfer_status
897 exec_target::xfer_partial (enum target_object object
,
898 const char *annex
, gdb_byte
*readbuf
,
899 const gdb_byte
*writebuf
,
900 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
902 target_section_table
*table
= get_section_table ();
904 if (object
== TARGET_OBJECT_MEMORY
)
905 return section_table_xfer_memory_partial (readbuf
, writebuf
,
906 offset
, len
, xfered_len
,
909 return TARGET_XFER_E_IO
;
914 print_section_info (target_section_table
*t
, bfd
*abfd
)
916 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
917 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
918 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
920 printf_filtered ("\t`%ps', ",
921 styled_string (file_name_style
.style (),
922 bfd_get_filename (abfd
)));
924 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
925 if (abfd
== current_program_space
->exec_bfd ())
927 /* gcc-3.4 does not like the initialization in
928 <p == t->sections_end>. */
929 bfd_vma displacement
= 0;
933 for (const target_section
&p
: *t
)
935 struct bfd_section
*psect
= p
.the_bfd_section
;
937 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
938 != (SEC_ALLOC
| SEC_LOAD
))
941 if (bfd_section_vma (psect
) <= abfd
->start_address
942 && abfd
->start_address
< (bfd_section_vma (psect
)
943 + bfd_section_size (psect
)))
945 displacement
= p
.addr
- bfd_section_vma (psect
);
951 warning (_("Cannot find section for the entry point of %ps."),
952 styled_string (file_name_style
.style (),
953 bfd_get_filename (abfd
)));
955 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
956 bfd_get_start_address (abfd
)
958 printf_filtered (_("\tEntry point: %s\n"),
959 paddress (gdbarch
, entry_point
));
961 for (const target_section
&p
: *t
)
963 struct bfd_section
*psect
= p
.the_bfd_section
;
964 bfd
*pbfd
= psect
->owner
;
966 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
967 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
969 /* FIXME: A format of "08l" is not wide enough for file offsets
970 larger than 4GB. OTOH, making it "016l" isn't desirable either
971 since most output will then be much wider than necessary. It
972 may make sense to test the size of the file and choose the
973 format string accordingly. */
974 /* FIXME: i18n: Need to rewrite this sentence. */
976 printf_filtered (" @ %s",
977 hex_string_custom (psect
->filepos
, 8));
978 printf_filtered (" is %s", bfd_section_name (psect
));
980 printf_filtered (" in %ps",
981 styled_string (file_name_style
.style (),
982 bfd_get_filename (pbfd
)));
983 printf_filtered ("\n");
988 exec_target::files_info ()
990 if (current_program_space
->exec_bfd ())
991 print_section_info (¤t_program_space
->target_sections
,
992 current_program_space
->exec_bfd ());
994 puts_filtered (_("\t<no file loaded>\n"));
998 set_section_command (const char *args
, int from_tty
)
1000 const char *secname
;
1002 unsigned long secaddr
;
1007 error (_("Must specify section name and its virtual address"));
1009 /* Parse out section name. */
1010 for (secname
= args
; !isspace (*args
); args
++);
1011 seclen
= args
- secname
;
1013 /* Parse out new virtual address. */
1014 secaddr
= parse_and_eval_address (args
);
1016 for (target_section
&p
: current_program_space
->target_sections
)
1018 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1019 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1021 offset
= secaddr
- p
.addr
;
1023 p
.endaddr
+= offset
;
1025 exec_ops
.files_info ();
1029 if (seclen
>= sizeof (secprint
))
1030 seclen
= sizeof (secprint
) - 1;
1031 strncpy (secprint
, secname
, seclen
);
1032 secprint
[seclen
] = '\0';
1033 error (_("Section %s not found"), secprint
);
1036 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1040 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1042 for (target_section
&p
: current_program_space
->target_sections
)
1044 if (filename_cmp (filename
,
1045 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1046 && index
== p
.the_bfd_section
->index
)
1048 p
.endaddr
+= address
- p
.addr
;
1055 exec_target::has_memory ()
1057 /* We can provide memory if we have any file/target sections to read
1059 return !current_program_space
->target_sections
.empty ();
1062 gdb::unique_xmalloc_ptr
<char>
1063 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1065 error (_("Can't create a corefile"));
1069 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1071 return objfile_find_memory_regions (this, func
, data
);
1074 void _initialize_exec ();
1078 struct cmd_list_element
*c
;
1082 c
= add_cmd ("file", class_files
, file_command
, _("\
1083 Use FILE as program to be debugged.\n\
1084 It is read for its symbols, for getting the contents of pure memory,\n\
1085 and it is the program executed when you use the `run' command.\n\
1086 If FILE cannot be found as specified, your execution directory path\n\
1087 ($PATH) is searched for a command of that name.\n\
1088 No arg means to have no executable file and no symbols."), &cmdlist
);
1089 set_cmd_completer (c
, filename_completer
);
1092 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1093 Use FILE as program for getting contents of pure memory.\n\
1094 If FILE cannot be found as specified, your execution directory path\n\
1095 is searched for a command of that name.\n\
1096 No arg means have no executable file."), &cmdlist
);
1097 set_cmd_completer (c
, filename_completer
);
1099 add_com ("section", class_files
, set_section_command
, _("\
1100 Change the base address of section SECTION of the exec file to ADDR.\n\
1101 This can be used if the exec file does not contain section addresses,\n\
1102 (such as in the a.out format), or when the addresses specified in the\n\
1103 file itself are wrong. Each section must be changed separately. The\n\
1104 ``info files'' command lists all the sections and their addresses."));
1106 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1107 Set writing into executable and core files."), _("\
1108 Show writing into executable and core files."), NULL
,
1111 &setlist
, &showlist
);
1113 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1114 exec_file_mismatch_names
,
1115 &exec_file_mismatch
,
1117 Set exec-file-mismatch handling (ask|warn|off)."),
1119 Show exec-file-mismatch handling (ask|warn|off)."),
1121 Specifies how to handle a mismatch between the current exec-file\n\
1122 loaded by GDB and the exec-file automatically determined when attaching\n\
1124 ask - warn the user and ask whether to load the determined exec-file.\n\
1125 warn - warn the user, but do not change the exec-file.\n\
1126 off - do not check for mismatch.\n\
1128 GDB detects a mismatch by comparing the build IDs of the files.\n\
1129 If the user confirms loading the determined exec-file, then its symbols\n\
1130 will be loaded as well."),
1131 set_exec_file_mismatch_command
,
1132 show_exec_file_mismatch_command
,
1133 &setlist
, &showlist
);
1135 add_target (exec_target_info
, exec_target_open
, filename_completer
);