1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2023 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"
52 #include "gdbsupport/buildargv.h"
54 void (*deprecated_file_changed_hook
) (const char *);
56 static const target_info exec_target_info
= {
58 N_("Local exec file"),
59 N_("Use an executable file as a target.\n\
60 Specify the filename of the executable file.")
63 /* The target vector for executable files. */
65 struct exec_target final
: public target_ops
67 const target_info
&info () const override
68 { return exec_target_info
; }
70 strata
stratum () const override
{ return file_stratum
; }
72 void close () override
;
73 enum target_xfer_status
xfer_partial (enum target_object object
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, ULONGEST len
,
78 ULONGEST
*xfered_len
) 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
)
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 (_("Unrecognized exec-file-mismatch setting: \"%s\""),
131 /* Whether to open exec and core files read-only or read-write. */
133 bool write_files
= false;
135 show_write_files (struct ui_file
*file
, int from_tty
,
136 struct cmd_list_element
*c
, const char *value
)
138 gdb_printf (file
, _("Writing into executable and core files is %s.\n"),
144 exec_target_open (const char *args
, int from_tty
)
146 target_preopen (from_tty
);
147 exec_file_attach (args
, from_tty
);
150 /* This is the target_close implementation. Clears all target
151 sections and closes all executable bfds from all program spaces. */
154 exec_target::close ()
156 for (struct program_space
*ss
: program_spaces
)
158 ss
->clear_target_sections ();
166 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
167 symfile_add_flags add_flags
)
169 struct gdb_exception prev_err
;
171 /* exec_file_attach and symbol_file_add_main may throw an error if the file
172 cannot be opened either locally or remotely.
174 This happens for example, when the file is first found in the local
175 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
176 exist in the target filesystem, or when the file does exist, but
179 Even without a symbol file, the remote-based debugging session should
180 continue normally instead of ending abruptly. Hence we catch thrown
181 errors/exceptions in the following code. */
184 /* We must do this step even if exec_file_host is NULL, so that
185 exec_file_attach will clear state. */
186 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
188 catch (gdb_exception_error
&err
)
190 if (err
.message
!= NULL
)
191 warning ("%s", err
.what ());
193 prev_err
= std::move (err
);
196 if (exec_file_host
!= NULL
)
200 symbol_file_add_main (exec_file_host
, add_flags
);
202 catch (const gdb_exception_error
&err
)
205 warning ("%s", err
.what ());
213 validate_exec_file (int from_tty
)
215 /* If user asked to ignore the mismatch, do nothing. */
216 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
219 const char *current_exec_file
= get_exec_file (0);
220 struct inferior
*inf
= current_inferior ();
221 /* Try to determine a filename from the process itself. */
222 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
223 bool build_id_mismatch
= false;
225 /* If we cannot validate the exec file, return. */
226 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
229 /* Try validating via build-id, if available. This is the most
232 /* In case current_exec_file was changed, reopen_exec_file ensures
233 an up to date build_id (will do nothing if the file timestamp
234 did not change). If exec file changed, reopen_exec_file has
235 allocated another file name, so get_exec_file again. */
237 current_exec_file
= get_exec_file (0);
239 const bfd_build_id
*exec_file_build_id
240 = build_id_bfd_get (current_program_space
->exec_bfd ());
241 if (exec_file_build_id
!= nullptr)
243 /* Prepend the target prefix, to force gdb_bfd_open to open the
244 file on the remote file system (if indeed remote). */
245 std::string target_pid_exec_file
246 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
248 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
249 gnutarget
, -1, false));
252 const bfd_build_id
*target_exec_file_build_id
253 = build_id_bfd_get (abfd
.get ());
255 if (target_exec_file_build_id
!= nullptr)
257 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
258 && memcmp (exec_file_build_id
->data
,
259 target_exec_file_build_id
->data
,
260 exec_file_build_id
->size
) == 0)
266 build_id_mismatch
= true;
271 if (build_id_mismatch
)
273 std::string
exec_file_target (pid_exec_file
);
275 /* In case the exec file is not local, exec_file_target has to point at
276 the target file system. */
277 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
278 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
281 (_("Build ID mismatch between current exec-file %ps\n"
282 "and automatically determined exec-file %ps\n"
283 "exec-file-mismatch handling is currently \"%s\""),
284 styled_string (file_name_style
.style (), current_exec_file
),
285 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
286 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
287 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
289 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
292 add_flags
|= SYMFILE_VERBOSE
;
293 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
297 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
298 exec_file_attach (exec_file_target
.c_str (), from_tty
);
300 catch (gdb_exception_error
&err
)
302 warning (_("loading %ps %s"),
303 styled_string (file_name_style
.style (),
304 exec_file_target
.c_str ()),
305 err
.message
!= NULL
? err
.what () : "error");
314 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
316 const char *exec_file_target
;
317 symfile_add_flags add_flags
= 0;
319 /* Do nothing if we already have an executable filename. */
320 if (get_exec_file (0) != NULL
)
323 /* Try to determine a filename from the process itself. */
324 exec_file_target
= target_pid_to_exec_file (pid
);
325 if (exec_file_target
== NULL
)
327 warning (_("No executable has been specified and target does not "
329 "determining executable automatically. "
330 "Try using the \"file\" command."));
334 gdb::unique_xmalloc_ptr
<char> exec_file_host
335 = exec_file_find (exec_file_target
, NULL
);
338 add_flags
|= SYMFILE_DEFER_BP_RESET
;
341 add_flags
|= SYMFILE_VERBOSE
;
343 /* Attempt to open the exec file. */
344 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
347 /* Set FILENAME as the new exec file.
349 This function is intended to be behave essentially the same
350 as exec_file_command, except that the latter will detect when
351 a target is being debugged, and will ask the user whether it
352 should be shut down first. (If the answer is "no", then the
353 new file is ignored.)
355 This file is used by exec_file_command, to do the work of opening
356 and processing the exec file after any prompting has happened.
358 And, it is used by child_attach, when the attach command was
359 given a pid but not a exec pathname, and the attach command could
360 figure out the pathname from the pid. (In this case, we shouldn't
361 ask the user whether the current target should be shut down --
362 we're supplying the exec pathname late for good reason.) */
365 exec_file_attach (const char *filename
, int from_tty
)
367 /* First, acquire a reference to the exec_bfd. We release
368 this at the end of the function; but acquiring it now lets the
369 BFD cache return it if this call refers to the same file. */
370 gdb_bfd_ref_ptr exec_bfd_holder
371 = gdb_bfd_ref_ptr::new_reference (current_program_space
->exec_bfd ());
373 /* Remove any previous exec file. */
374 current_program_space
->exec_close ();
376 /* Now open and digest the file the user requested, if any. */
381 gdb_printf (_("No executable file now.\n"));
383 set_gdbarch_from_file (NULL
);
387 int load_via_target
= 0;
388 const char *scratch_pathname
, *canonical_pathname
;
392 if (is_target_filename (filename
))
394 if (target_filesystem_is_local ())
395 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
400 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
403 /* gdb_bfd_fopen does not support "target:" filenames. */
405 warning (_("writing into executable files is "
406 "not supported for %s sysroots"),
407 TARGET_SYSROOT_PREFIX
);
409 scratch_pathname
= filename
;
411 canonical_pathname
= scratch_pathname
;
415 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
416 filename
, write_files
?
417 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
419 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
420 if (scratch_chan
< 0)
422 int first_errno
= errno
;
423 char *exename
= (char *) alloca (strlen (filename
) + 5);
425 strcat (strcpy (exename
, filename
), ".exe");
426 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
427 exename
, write_files
?
429 : O_RDONLY
| O_BINARY
,
431 if (scratch_chan
< 0)
435 if (scratch_chan
< 0)
436 perror_with_name (filename
);
438 scratch_pathname
= scratch_storage
.get ();
440 /* gdb_bfd_open (and its variants) prefers canonicalized
441 pathname for better BFD caching. */
442 canonical_storage
= gdb_realpath (scratch_pathname
);
443 canonical_pathname
= canonical_storage
.get ();
446 gdb_bfd_ref_ptr temp
;
447 if (write_files
&& !load_via_target
)
448 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
449 FOPEN_RUB
, scratch_chan
);
451 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
452 current_program_space
->set_exec_bfd (std::move (temp
));
454 if (!current_program_space
->exec_bfd ())
456 error (_("\"%s\": could not open as an executable file: %s."),
457 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
460 /* gdb_realpath_keepfile resolves symlinks on the local
461 filesystem and so cannot be used for "target:" files. */
462 gdb_assert (current_program_space
->exec_filename
== nullptr);
464 current_program_space
->exec_filename
465 = (make_unique_xstrdup
466 (bfd_get_filename (current_program_space
->exec_bfd ())));
468 current_program_space
->exec_filename
469 = make_unique_xstrdup (gdb_realpath_keepfile
470 (scratch_pathname
).c_str ());
472 if (!bfd_check_format_matches (current_program_space
->exec_bfd (),
473 bfd_object
, &matching
))
475 /* Make sure to close exec_bfd, or else "run" might try to use
477 current_program_space
->exec_close ();
478 error (_("\"%s\": not in executable format: %s"), scratch_pathname
,
479 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
482 std::vector
<target_section
> sections
483 = build_section_table (current_program_space
->exec_bfd ());
485 current_program_space
->ebfd_mtime
486 = bfd_get_mtime (current_program_space
->exec_bfd ());
490 set_gdbarch_from_file (current_program_space
->exec_bfd ());
492 /* Add the executable's sections to the current address spaces'
493 list of sections. This possibly pushes the exec_ops
495 current_program_space
->add_target_sections
496 (current_program_space
->ebfd
.get (), sections
);
498 /* Tell display code (if any) about the changed file name. */
499 if (deprecated_exec_file_display_hook
)
500 (*deprecated_exec_file_display_hook
) (filename
);
503 bfd_cache_close_all ();
505 /* Are are loading the same executable? */
506 bfd
*prev_bfd
= exec_bfd_holder
.get ();
507 bfd
*curr_bfd
= current_program_space
->exec_bfd ();
508 bool reload_p
= (((prev_bfd
!= nullptr) == (curr_bfd
!= nullptr))
509 && (prev_bfd
== nullptr
510 || (strcmp (bfd_get_filename (prev_bfd
),
511 bfd_get_filename (curr_bfd
)) == 0)));
513 gdb::observers::executable_changed
.notify (current_program_space
, reload_p
);
516 /* Process the first arg in ARGS as the new exec file.
518 Note that we have to explicitly ignore additional args, since we can
519 be called from file_command(), which also calls symbol_file_command()
520 which can take multiple args.
522 If ARGS is NULL, we just want to close the exec file. */
525 exec_file_command (const char *args
, int from_tty
)
527 if (from_tty
&& target_has_execution ()
528 && !query (_("A program is being debugged already.\n"
529 "Are you sure you want to change the file? ")))
530 error (_("File not changed."));
534 /* Scan through the args and pick up the first non option arg
537 gdb_argv
built_argv (args
);
538 char **argv
= built_argv
.get ();
540 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
544 error (_("No executable file name was specified"));
546 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
547 exec_file_attach (filename
.get (), from_tty
);
550 exec_file_attach (NULL
, from_tty
);
553 /* Set both the exec file and the symbol file, in one command.
554 What a novelty. Why did GDB go through four major releases before this
555 command was added? */
558 file_command (const char *arg
, int from_tty
)
560 /* FIXME, if we lose on reading the symbol file, we should revert
561 the exec file, but that's rough. */
562 exec_file_command (arg
, from_tty
);
563 symbol_file_command (arg
, from_tty
);
564 if (deprecated_file_changed_hook
)
565 deprecated_file_changed_hook (arg
);
569 /* Builds a section table, given args BFD, TABLE. */
571 std::vector
<target_section
>
572 build_section_table (struct bfd
*some_bfd
)
574 std::vector
<target_section
> table
;
576 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
580 /* Check the section flags, but do not discard zero-length
581 sections, since some symbols may still be attached to this
582 section. For instance, we encountered on sparc-solaris 2.10
583 a shared library with an empty .bss section to which a symbol
584 named "_end" was attached. The address of this symbol still
585 needs to be relocated. */
586 aflag
= bfd_section_flags (asect
);
587 if (!(aflag
& SEC_ALLOC
))
590 table
.emplace_back (bfd_section_vma (asect
),
591 bfd_section_vma (asect
) + bfd_section_size (asect
),
598 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
599 current set of target sections. */
602 program_space::add_target_sections
603 (target_section_owner owner
, const std::vector
<target_section
> §ions
)
605 if (!sections
.empty ())
607 for (const target_section
&s
: sections
)
609 m_target_sections
.push_back (s
);
610 m_target_sections
.back ().owner
= owner
;
613 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
615 /* If these are the first file sections we can provide memory
616 from, push the file_stratum target. Must do this in all
617 inferiors sharing the program space. */
618 for (inferior
*inf
: all_inferiors ())
620 if (inf
->pspace
!= this)
623 if (inf
->target_is_pushed (&exec_ops
))
626 switch_to_inferior_no_thread (inf
);
627 inf
->push_target (&exec_ops
);
632 /* Add the sections of OBJFILE to the current set of target sections. */
635 program_space::add_target_sections (struct objfile
*objfile
)
637 gdb_assert (objfile
!= nullptr);
639 /* Compute the number of sections to add. */
640 for (obj_section
*osect
: objfile
->sections ())
642 if (bfd_section_size (osect
->the_bfd_section
) == 0)
645 m_target_sections
.emplace_back (osect
->addr (), osect
->endaddr (),
646 osect
->the_bfd_section
, 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 (target_section_owner owner
)
656 gdb_assert (owner
.v () != nullptr);
658 auto it
= std::remove_if (m_target_sections
.begin (),
659 m_target_sections
.end (),
660 [&] (target_section
§
)
662 return sect
.owner
.v () == owner
.v ();
664 m_target_sections
.erase (it
, m_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 (m_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 inf
->unpush_target (&exec_ops
);
687 exec_on_vfork (inferior
*vfork_child
)
689 if (!vfork_child
->pspace
->target_sections ().empty ())
690 vfork_child
->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 std::vector
<target_section
> §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 const std::vector
<target_section
> *table
783 = target_get_section_table (current_inferior ()->top_target ());
784 std::vector
<mem_range
> available_memory
785 = section_table_available_memory (offset
, len
, *table
);
787 normalize_mem_ranges (&available_memory
);
789 for (const mem_range
&r
: available_memory
)
791 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
794 enum target_xfer_status status
;
796 /* Get the intersection window. */
797 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
799 gdb_assert (end
- offset
<= len
);
801 if (offset
>= r
.start
)
802 status
= exec_read_partial_read_only (readbuf
, offset
,
807 *xfered_len
= r
.start
- offset
;
808 status
= TARGET_XFER_UNAVAILABLE
;
815 return TARGET_XFER_UNAVAILABLE
;
818 enum target_xfer_status
819 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
820 ULONGEST offset
, ULONGEST len
,
821 ULONGEST
*xfered_len
,
822 const std::vector
<target_section
> §ions
,
823 gdb::function_view
<bool
824 (const struct target_section
*)> match_cb
)
827 ULONGEST memaddr
= offset
;
828 ULONGEST memend
= memaddr
+ len
;
830 gdb_assert (len
!= 0);
832 for (const target_section
&p
: sections
)
834 struct bfd_section
*asect
= p
.the_bfd_section
;
835 bfd
*abfd
= asect
->owner
;
837 if (match_cb
!= nullptr && !match_cb (&p
))
838 continue; /* not the section we need. */
839 if (memaddr
>= p
.addr
)
841 if (memend
<= p
.endaddr
)
843 /* Entire transfer is within this section. */
845 res
= bfd_set_section_contents (abfd
, asect
,
846 writebuf
, memaddr
- p
.addr
,
849 res
= bfd_get_section_contents (abfd
, asect
,
850 readbuf
, memaddr
- p
.addr
,
856 return TARGET_XFER_OK
;
859 return TARGET_XFER_EOF
;
861 else if (memaddr
>= p
.endaddr
)
863 /* This section ends before the transfer starts. */
868 /* This section overlaps the transfer. Just do half. */
869 len
= p
.endaddr
- memaddr
;
871 res
= bfd_set_section_contents (abfd
, asect
,
872 writebuf
, memaddr
- p
.addr
,
875 res
= bfd_get_section_contents (abfd
, asect
,
876 readbuf
, memaddr
- p
.addr
,
881 return TARGET_XFER_OK
;
884 return TARGET_XFER_EOF
;
889 return TARGET_XFER_EOF
; /* We can't help. */
892 enum target_xfer_status
893 exec_target::xfer_partial (enum target_object object
,
894 const char *annex
, gdb_byte
*readbuf
,
895 const gdb_byte
*writebuf
,
896 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
898 const std::vector
<target_section
> *table
= target_get_section_table (this);
900 if (object
== TARGET_OBJECT_MEMORY
)
901 return section_table_xfer_memory_partial (readbuf
, writebuf
,
902 offset
, len
, xfered_len
,
905 return TARGET_XFER_E_IO
;
910 print_section_info (const std::vector
<target_section
> *t
, bfd
*abfd
)
912 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
913 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
914 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
916 gdb_printf ("\t`%ps', ",
917 styled_string (file_name_style
.style (),
918 bfd_get_filename (abfd
)));
919 gdb_stdout
->wrap_here (8);
920 gdb_printf (_("file type %s.\n"), bfd_get_target (abfd
));
921 if (abfd
== current_program_space
->exec_bfd ())
923 /* gcc-3.4 does not like the initialization in
924 <p == t->sections_end>. */
925 bfd_vma displacement
= 0;
929 for (const target_section
&p
: *t
)
931 struct bfd_section
*psect
= p
.the_bfd_section
;
933 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
934 != (SEC_ALLOC
| SEC_LOAD
))
937 if (bfd_section_vma (psect
) <= abfd
->start_address
938 && abfd
->start_address
< (bfd_section_vma (psect
)
939 + bfd_section_size (psect
)))
941 displacement
= p
.addr
- bfd_section_vma (psect
);
947 warning (_("Cannot find section for the entry point of %ps."),
948 styled_string (file_name_style
.style (),
949 bfd_get_filename (abfd
)));
951 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
952 bfd_get_start_address (abfd
)
954 gdb_printf (_("\tEntry point: %s\n"),
955 paddress (gdbarch
, entry_point
));
957 for (const target_section
&p
: *t
)
959 struct bfd_section
*psect
= p
.the_bfd_section
;
960 bfd
*pbfd
= psect
->owner
;
962 gdb_printf ("\t%s", hex_string_custom (p
.addr
, wid
));
963 gdb_printf (" - %s", hex_string_custom (p
.endaddr
, wid
));
965 /* FIXME: A format of "08l" is not wide enough for file offsets
966 larger than 4GB. OTOH, making it "016l" isn't desirable either
967 since most output will then be much wider than necessary. It
968 may make sense to test the size of the file and choose the
969 format string accordingly. */
970 /* FIXME: i18n: Need to rewrite this sentence. */
973 hex_string_custom (psect
->filepos
, 8));
974 gdb_printf (" is %s", bfd_section_name (psect
));
976 gdb_printf (" in %ps",
977 styled_string (file_name_style
.style (),
978 bfd_get_filename (pbfd
)));
984 exec_target::files_info ()
986 if (current_program_space
->exec_bfd ())
987 print_section_info (¤t_program_space
->target_sections (),
988 current_program_space
->exec_bfd ());
990 gdb_puts (_("\t<no file loaded>\n"));
994 set_section_command (const char *args
, int from_tty
)
999 error (_("Must specify section name and its virtual address"));
1001 /* Parse out section name. */
1002 for (secname
= args
; !isspace (*args
); args
++);
1003 unsigned seclen
= args
- secname
;
1005 /* Parse out new virtual address. */
1006 CORE_ADDR secaddr
= parse_and_eval_address (args
);
1008 for (target_section
&p
: current_program_space
->target_sections ())
1010 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1011 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1013 long offset
= secaddr
- p
.addr
;
1015 p
.endaddr
+= offset
;
1017 exec_ops
.files_info ();
1022 std::string
secprint (secname
, seclen
);
1023 error (_("Section %s not found"), secprint
.c_str ());
1026 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1030 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1032 for (target_section
&p
: current_program_space
->target_sections ())
1034 if (filename_cmp (filename
,
1035 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1036 && index
== p
.the_bfd_section
->index
)
1038 p
.endaddr
+= address
- p
.addr
;
1045 exec_target::has_memory ()
1047 /* We can provide memory if we have any file/target sections to read
1049 return !current_program_space
->target_sections ().empty ();
1052 gdb::unique_xmalloc_ptr
<char>
1053 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1055 error (_("Can't create a corefile"));
1059 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1061 return objfile_find_memory_regions (this, func
, data
);
1064 void _initialize_exec ();
1068 struct cmd_list_element
*c
;
1070 c
= add_cmd ("file", class_files
, file_command
, _("\
1071 Use FILE as program to be debugged.\n\
1072 It is read for its symbols, for getting the contents of pure memory,\n\
1073 and it is the program executed when you use the `run' command.\n\
1074 If FILE cannot be found as specified, your execution directory path\n\
1075 ($PATH) is searched for a command of that name.\n\
1076 No arg means to have no executable file and no symbols."), &cmdlist
);
1077 set_cmd_completer (c
, filename_completer
);
1079 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1080 Use FILE as program for getting contents of pure memory.\n\
1081 If FILE cannot be found as specified, your execution directory path\n\
1082 is searched for a command of that name.\n\
1083 No arg means have no executable file."), &cmdlist
);
1084 set_cmd_completer (c
, filename_completer
);
1086 add_com ("section", class_files
, set_section_command
, _("\
1087 Change the base address of section SECTION of the exec file to ADDR.\n\
1088 This can be used if the exec file does not contain section addresses,\n\
1089 (such as in the a.out format), or when the addresses specified in the\n\
1090 file itself are wrong. Each section must be changed separately. The\n\
1091 ``info files'' command lists all the sections and their addresses."));
1093 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1094 Set writing into executable and core files."), _("\
1095 Show writing into executable and core files."), NULL
,
1098 &setlist
, &showlist
);
1100 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1101 exec_file_mismatch_names
,
1102 &exec_file_mismatch
,
1104 Set exec-file-mismatch handling (ask|warn|off)."),
1106 Show exec-file-mismatch handling (ask|warn|off)."),
1108 Specifies how to handle a mismatch between the current exec-file\n\
1109 loaded by GDB and the exec-file automatically determined when attaching\n\
1111 ask - warn the user and ask whether to load the determined exec-file.\n\
1112 warn - warn the user, but do not change the exec-file.\n\
1113 off - do not check for mismatch.\n\
1115 GDB detects a mismatch by comparing the build IDs of the files.\n\
1116 If the user confirms loading the determined exec-file, then its symbols\n\
1117 will be loaded as well."),
1118 set_exec_file_mismatch_command
,
1119 show_exec_file_mismatch_command
,
1120 &setlist
, &showlist
);
1122 add_target (exec_target_info
, exec_target_open
, filename_completer
);