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 add_target_sections_of_objfile (struct objfile
*objfile
)
633 target_section_table
*table
= ¤t_program_space
->target_sections
;
634 struct obj_section
*osect
;
636 gdb_assert (objfile
!= nullptr);
638 /* Compute the number of sections to add. */
639 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
641 if (bfd_section_size (osect
->the_bfd_section
) == 0)
644 table
->emplace_back (obj_section_addr (osect
),
645 obj_section_endaddr (osect
),
646 osect
->the_bfd_section
, (void *) objfile
);
650 /* Remove all target sections owned by OWNER.
651 OWNER must be the same value passed to add_target_sections. */
654 program_space::remove_target_sections (void *owner
)
656 gdb_assert (owner
!= NULL
);
658 auto it
= std::remove_if (target_sections
.begin (),
659 target_sections
.end (),
660 [&] (target_section
§
)
662 return sect
.owner
== owner
;
664 target_sections
.erase (it
, target_sections
.end ());
666 /* If we don't have any more sections to read memory from,
667 remove the file_stratum target from the stack of each
668 inferior sharing the program space. */
669 if (target_sections
.empty ())
671 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
673 for (inferior
*inf
: all_inferiors ())
675 if (inf
->pspace
!= this)
678 switch_to_inferior_no_thread (inf
);
679 unpush_target (&exec_ops
);
689 if (!current_program_space
->target_sections
.empty ())
690 push_target (&exec_ops
);
695 enum target_xfer_status
696 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
697 ULONGEST len
, ULONGEST
*xfered_len
)
699 /* It's unduly pedantic to refuse to look at the executable for
700 read-only pieces; so do the equivalent of readonly regions aka
702 if (current_program_space
->exec_bfd () != NULL
)
708 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
710 if ((s
->flags
& SEC_LOAD
) == 0
711 || (s
->flags
& SEC_READONLY
) == 0)
715 size
= bfd_section_size (s
);
716 if (vma
<= offset
&& offset
< (vma
+ size
))
720 amt
= (vma
+ size
) - offset
;
724 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
725 readbuf
, offset
- vma
, amt
);
728 return TARGET_XFER_EOF
;
732 return TARGET_XFER_OK
;
738 /* Indicate failure to find the requested memory block. */
739 return TARGET_XFER_E_IO
;
742 /* Return all read-only memory ranges found in the target section
743 table defined by SECTIONS and SECTIONS_END, starting at (and
744 intersected with) MEMADDR for LEN bytes. */
746 static std::vector
<mem_range
>
747 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
748 const target_section_table
§ions
)
750 std::vector
<mem_range
> memory
;
752 for (const target_section
&p
: sections
)
754 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
757 /* Copy the meta-data, adjusted. */
758 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
760 ULONGEST lo1
, hi1
, lo2
, hi2
;
768 CORE_ADDR start
= std::max (lo1
, lo2
);
769 int length
= std::min (hi1
, hi2
) - start
;
771 memory
.emplace_back (start
, length
);
778 enum target_xfer_status
779 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
780 ULONGEST len
, ULONGEST
*xfered_len
)
782 target_section_table
*table
= target_get_section_table (&exec_ops
);
783 std::vector
<mem_range
> available_memory
784 = section_table_available_memory (offset
, len
, *table
);
786 normalize_mem_ranges (&available_memory
);
788 for (const mem_range
&r
: available_memory
)
790 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
793 enum target_xfer_status status
;
795 /* Get the intersection window. */
796 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
798 gdb_assert (end
- offset
<= len
);
800 if (offset
>= r
.start
)
801 status
= exec_read_partial_read_only (readbuf
, offset
,
806 *xfered_len
= r
.start
- offset
;
807 status
= TARGET_XFER_UNAVAILABLE
;
814 return TARGET_XFER_UNAVAILABLE
;
817 enum target_xfer_status
818 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
819 ULONGEST offset
, ULONGEST len
,
820 ULONGEST
*xfered_len
,
821 const target_section_table
§ions
,
822 gdb::function_view
<bool
823 (const struct target_section
*)> match_cb
)
826 ULONGEST memaddr
= offset
;
827 ULONGEST memend
= memaddr
+ len
;
829 gdb_assert (len
!= 0);
831 for (const target_section
&p
: sections
)
833 struct bfd_section
*asect
= p
.the_bfd_section
;
834 bfd
*abfd
= asect
->owner
;
836 if (match_cb
!= nullptr && !match_cb (&p
))
837 continue; /* not the section we need. */
838 if (memaddr
>= p
.addr
)
840 if (memend
<= p
.endaddr
)
842 /* Entire transfer is within this section. */
844 res
= bfd_set_section_contents (abfd
, asect
,
845 writebuf
, memaddr
- p
.addr
,
848 res
= bfd_get_section_contents (abfd
, asect
,
849 readbuf
, memaddr
- p
.addr
,
855 return TARGET_XFER_OK
;
858 return TARGET_XFER_EOF
;
860 else if (memaddr
>= p
.endaddr
)
862 /* This section ends before the transfer starts. */
867 /* This section overlaps the transfer. Just do half. */
868 len
= p
.endaddr
- memaddr
;
870 res
= bfd_set_section_contents (abfd
, asect
,
871 writebuf
, memaddr
- p
.addr
,
874 res
= bfd_get_section_contents (abfd
, asect
,
875 readbuf
, memaddr
- p
.addr
,
880 return TARGET_XFER_OK
;
883 return TARGET_XFER_EOF
;
888 return TARGET_XFER_EOF
; /* We can't help. */
891 target_section_table
*
892 exec_target::get_section_table ()
894 return ¤t_program_space
->target_sections
;
897 enum target_xfer_status
898 exec_target::xfer_partial (enum target_object object
,
899 const char *annex
, gdb_byte
*readbuf
,
900 const gdb_byte
*writebuf
,
901 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
903 target_section_table
*table
= get_section_table ();
905 if (object
== TARGET_OBJECT_MEMORY
)
906 return section_table_xfer_memory_partial (readbuf
, writebuf
,
907 offset
, len
, xfered_len
,
910 return TARGET_XFER_E_IO
;
915 print_section_info (target_section_table
*t
, bfd
*abfd
)
917 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
918 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
919 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
921 printf_filtered ("\t`%ps', ",
922 styled_string (file_name_style
.style (),
923 bfd_get_filename (abfd
)));
925 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
926 if (abfd
== current_program_space
->exec_bfd ())
928 /* gcc-3.4 does not like the initialization in
929 <p == t->sections_end>. */
930 bfd_vma displacement
= 0;
934 for (const target_section
&p
: *t
)
936 struct bfd_section
*psect
= p
.the_bfd_section
;
938 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
939 != (SEC_ALLOC
| SEC_LOAD
))
942 if (bfd_section_vma (psect
) <= abfd
->start_address
943 && abfd
->start_address
< (bfd_section_vma (psect
)
944 + bfd_section_size (psect
)))
946 displacement
= p
.addr
- bfd_section_vma (psect
);
952 warning (_("Cannot find section for the entry point of %ps."),
953 styled_string (file_name_style
.style (),
954 bfd_get_filename (abfd
)));
956 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
957 bfd_get_start_address (abfd
)
959 printf_filtered (_("\tEntry point: %s\n"),
960 paddress (gdbarch
, entry_point
));
962 for (const target_section
&p
: *t
)
964 struct bfd_section
*psect
= p
.the_bfd_section
;
965 bfd
*pbfd
= psect
->owner
;
967 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
968 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
970 /* FIXME: A format of "08l" is not wide enough for file offsets
971 larger than 4GB. OTOH, making it "016l" isn't desirable either
972 since most output will then be much wider than necessary. It
973 may make sense to test the size of the file and choose the
974 format string accordingly. */
975 /* FIXME: i18n: Need to rewrite this sentence. */
977 printf_filtered (" @ %s",
978 hex_string_custom (psect
->filepos
, 8));
979 printf_filtered (" is %s", bfd_section_name (psect
));
981 printf_filtered (" in %ps",
982 styled_string (file_name_style
.style (),
983 bfd_get_filename (pbfd
)));
984 printf_filtered ("\n");
989 exec_target::files_info ()
991 if (current_program_space
->exec_bfd ())
992 print_section_info (¤t_program_space
->target_sections
,
993 current_program_space
->exec_bfd ());
995 puts_filtered (_("\t<no file loaded>\n"));
999 set_section_command (const char *args
, int from_tty
)
1001 const char *secname
;
1003 unsigned long secaddr
;
1008 error (_("Must specify section name and its virtual address"));
1010 /* Parse out section name. */
1011 for (secname
= args
; !isspace (*args
); args
++);
1012 seclen
= args
- secname
;
1014 /* Parse out new virtual address. */
1015 secaddr
= parse_and_eval_address (args
);
1017 for (target_section
&p
: current_program_space
->target_sections
)
1019 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1020 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1022 offset
= secaddr
- p
.addr
;
1024 p
.endaddr
+= offset
;
1026 exec_ops
.files_info ();
1030 if (seclen
>= sizeof (secprint
))
1031 seclen
= sizeof (secprint
) - 1;
1032 strncpy (secprint
, secname
, seclen
);
1033 secprint
[seclen
] = '\0';
1034 error (_("Section %s not found"), secprint
);
1037 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1041 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1043 for (target_section
&p
: current_program_space
->target_sections
)
1045 if (filename_cmp (filename
,
1046 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1047 && index
== p
.the_bfd_section
->index
)
1049 p
.endaddr
+= address
- p
.addr
;
1056 exec_target::has_memory ()
1058 /* We can provide memory if we have any file/target sections to read
1060 return !current_program_space
->target_sections
.empty ();
1063 gdb::unique_xmalloc_ptr
<char>
1064 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1066 error (_("Can't create a corefile"));
1070 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1072 return objfile_find_memory_regions (this, func
, data
);
1075 void _initialize_exec ();
1079 struct cmd_list_element
*c
;
1083 c
= add_cmd ("file", class_files
, file_command
, _("\
1084 Use FILE as program to be debugged.\n\
1085 It is read for its symbols, for getting the contents of pure memory,\n\
1086 and it is the program executed when you use the `run' command.\n\
1087 If FILE cannot be found as specified, your execution directory path\n\
1088 ($PATH) is searched for a command of that name.\n\
1089 No arg means to have no executable file and no symbols."), &cmdlist
);
1090 set_cmd_completer (c
, filename_completer
);
1093 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1094 Use FILE as program for getting contents of pure memory.\n\
1095 If FILE cannot be found as specified, your execution directory path\n\
1096 is searched for a command of that name.\n\
1097 No arg means have no executable file."), &cmdlist
);
1098 set_cmd_completer (c
, filename_completer
);
1100 add_com ("section", class_files
, set_section_command
, _("\
1101 Change the base address of section SECTION of the exec file to ADDR.\n\
1102 This can be used if the exec file does not contain section addresses,\n\
1103 (such as in the a.out format), or when the addresses specified in the\n\
1104 file itself are wrong. Each section must be changed separately. The\n\
1105 ``info files'' command lists all the sections and their addresses."));
1107 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1108 Set writing into executable and core files."), _("\
1109 Show writing into executable and core files."), NULL
,
1112 &setlist
, &showlist
);
1114 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1115 exec_file_mismatch_names
,
1116 &exec_file_mismatch
,
1118 Set exec-file-mismatch handling (ask|warn|off)."),
1120 Show exec-file-mismatch handling (ask|warn|off)."),
1122 Specifies how to handle a mismatch between the current exec-file\n\
1123 loaded by GDB and the exec-file automatically determined when attaching\n\
1125 ask - warn the user and ask whether to load the determined exec-file.\n\
1126 warn - warn the user, but do not change the exec-file.\n\
1127 off - do not check for mismatch.\n\
1129 GDB detects a mismatch by comparing the build IDs of the files.\n\
1130 If the user confirms loading the determined exec-file, then its symbols\n\
1131 will be loaded as well."),
1132 set_exec_file_mismatch_command
,
1133 show_exec_file_mismatch_command
,
1134 &setlist
, &showlist
);
1136 add_target (exec_target_info
, exec_target_open
, filename_completer
);