1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2022 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 (__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 gdb_printf (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 for (struct program_space
*ss
: program_spaces
)
159 ss
->clear_target_sections ();
167 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
168 symfile_add_flags add_flags
)
170 struct gdb_exception prev_err
;
172 /* exec_file_attach and symbol_file_add_main may throw an error if the file
173 cannot be opened either locally or remotely.
175 This happens for example, when the file is first found in the local
176 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
177 exist in the target filesystem, or when the file does exist, but
180 Even without a symbol file, the remote-based debugging session should
181 continue normally instead of ending abruptly. Hence we catch thrown
182 errors/exceptions in the following code. */
185 /* We must do this step even if exec_file_host is NULL, so that
186 exec_file_attach will clear state. */
187 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
189 catch (gdb_exception_error
&err
)
191 if (err
.message
!= NULL
)
192 warning ("%s", err
.what ());
194 prev_err
= std::move (err
);
197 if (exec_file_host
!= NULL
)
201 symbol_file_add_main (exec_file_host
, add_flags
);
203 catch (const gdb_exception_error
&err
)
206 warning ("%s", err
.what ());
214 validate_exec_file (int from_tty
)
216 /* If user asked to ignore the mismatch, do nothing. */
217 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
220 const char *current_exec_file
= get_exec_file (0);
221 struct inferior
*inf
= current_inferior ();
222 /* Try to determine a filename from the process itself. */
223 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
224 bool build_id_mismatch
= false;
226 /* If we cannot validate the exec file, return. */
227 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
230 /* Try validating via build-id, if available. This is the most
233 /* In case current_exec_file was changed, reopen_exec_file ensures
234 an up to date build_id (will do nothing if the file timestamp
235 did not change). If exec file changed, reopen_exec_file has
236 allocated another file name, so get_exec_file again. */
238 current_exec_file
= get_exec_file (0);
240 const bfd_build_id
*exec_file_build_id
241 = build_id_bfd_get (current_program_space
->exec_bfd ());
242 if (exec_file_build_id
!= nullptr)
244 /* Prepend the target prefix, to force gdb_bfd_open to open the
245 file on the remote file system (if indeed remote). */
246 std::string target_pid_exec_file
247 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
249 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
250 gnutarget
, -1, false));
253 const bfd_build_id
*target_exec_file_build_id
254 = build_id_bfd_get (abfd
.get ());
256 if (target_exec_file_build_id
!= nullptr)
258 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
259 && memcmp (exec_file_build_id
->data
,
260 target_exec_file_build_id
->data
,
261 exec_file_build_id
->size
) == 0)
267 build_id_mismatch
= true;
272 if (build_id_mismatch
)
274 std::string
exec_file_target (pid_exec_file
);
276 /* In case the exec file is not local, exec_file_target has to point at
277 the target file system. */
278 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
279 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
282 (_("Build ID mismatch between current exec-file %ps\n"
283 "and automatically determined exec-file %ps\n"
284 "exec-file-mismatch handling is currently \"%s\""),
285 styled_string (file_name_style
.style (), current_exec_file
),
286 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
287 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
288 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
290 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
293 add_flags
|= SYMFILE_VERBOSE
;
294 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
298 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
299 exec_file_attach (exec_file_target
.c_str (), from_tty
);
301 catch (gdb_exception_error
&err
)
303 warning (_("loading %ps %s"),
304 styled_string (file_name_style
.style (),
305 exec_file_target
.c_str ()),
306 err
.message
!= NULL
? err
.what () : "error");
315 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
317 char *exec_file_target
;
318 symfile_add_flags add_flags
= 0;
320 /* Do nothing if we already have an executable filename. */
321 if (get_exec_file (0) != NULL
)
324 /* Try to determine a filename from the process itself. */
325 exec_file_target
= target_pid_to_exec_file (pid
);
326 if (exec_file_target
== NULL
)
328 warning (_("No executable has been specified and target does not "
330 "determining executable automatically. "
331 "Try using the \"file\" command."));
335 gdb::unique_xmalloc_ptr
<char> exec_file_host
336 = exec_file_find (exec_file_target
, NULL
);
339 add_flags
|= SYMFILE_DEFER_BP_RESET
;
342 add_flags
|= SYMFILE_VERBOSE
;
344 /* Attempt to open the exec file. */
345 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
348 /* Set FILENAME as the new exec file.
350 This function is intended to be behave essentially the same
351 as exec_file_command, except that the latter will detect when
352 a target is being debugged, and will ask the user whether it
353 should be shut down first. (If the answer is "no", then the
354 new file is ignored.)
356 This file is used by exec_file_command, to do the work of opening
357 and processing the exec file after any prompting has happened.
359 And, it is used by child_attach, when the attach command was
360 given a pid but not a exec pathname, and the attach command could
361 figure out the pathname from the pid. (In this case, we shouldn't
362 ask the user whether the current target should be shut down --
363 we're supplying the exec pathname late for good reason.) */
366 exec_file_attach (const char *filename
, int from_tty
)
368 /* First, acquire a reference to the exec_bfd. We release
369 this at the end of the function; but acquiring it now lets the
370 BFD cache return it if this call refers to the same file. */
371 gdb_bfd_ref_ptr exec_bfd_holder
372 = gdb_bfd_ref_ptr::new_reference (current_program_space
->exec_bfd ());
374 /* Remove any previous exec file. */
375 current_program_space
->exec_close ();
377 /* Now open and digest the file the user requested, if any. */
382 gdb_printf (_("No executable file now.\n"));
384 set_gdbarch_from_file (NULL
);
388 int load_via_target
= 0;
389 const char *scratch_pathname
, *canonical_pathname
;
393 if (is_target_filename (filename
))
395 if (target_filesystem_is_local ())
396 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
401 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
404 /* gdb_bfd_fopen does not support "target:" filenames. */
406 warning (_("writing into executable files is "
407 "not supported for %s sysroots"),
408 TARGET_SYSROOT_PREFIX
);
410 scratch_pathname
= filename
;
412 canonical_pathname
= scratch_pathname
;
416 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
417 filename
, write_files
?
418 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
420 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
421 if (scratch_chan
< 0)
423 int first_errno
= errno
;
424 char *exename
= (char *) alloca (strlen (filename
) + 5);
426 strcat (strcpy (exename
, filename
), ".exe");
427 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
428 exename
, write_files
?
430 : O_RDONLY
| O_BINARY
,
432 if (scratch_chan
< 0)
436 if (scratch_chan
< 0)
437 perror_with_name (filename
);
439 scratch_pathname
= scratch_storage
.get ();
441 /* gdb_bfd_open (and its variants) prefers canonicalized
442 pathname for better BFD caching. */
443 canonical_storage
= gdb_realpath (scratch_pathname
);
444 canonical_pathname
= canonical_storage
.get ();
447 gdb_bfd_ref_ptr temp
;
448 if (write_files
&& !load_via_target
)
449 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
450 FOPEN_RUB
, scratch_chan
);
452 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
453 current_program_space
->set_exec_bfd (std::move (temp
));
455 if (!current_program_space
->exec_bfd ())
457 error (_("\"%s\": could not open as an executable file: %s."),
458 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
461 /* gdb_realpath_keepfile resolves symlinks on the local
462 filesystem and so cannot be used for "target:" files. */
463 gdb_assert (current_program_space
->exec_filename
== nullptr);
465 current_program_space
->exec_filename
466 = (make_unique_xstrdup
467 (bfd_get_filename (current_program_space
->exec_bfd ())));
469 current_program_space
->exec_filename
470 = gdb_realpath_keepfile (scratch_pathname
);
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 target_section_table 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 (¤t_program_space
->ebfd
,
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 ();
504 gdb::observers::executable_changed
.notify ();
507 /* Process the first arg in ARGS as the new exec file.
509 Note that we have to explicitly ignore additional args, since we can
510 be called from file_command(), which also calls symbol_file_command()
511 which can take multiple args.
513 If ARGS is NULL, we just want to close the exec file. */
516 exec_file_command (const char *args
, int from_tty
)
518 if (from_tty
&& target_has_execution ()
519 && !query (_("A program is being debugged already.\n"
520 "Are you sure you want to change the file? ")))
521 error (_("File not changed."));
525 /* Scan through the args and pick up the first non option arg
528 gdb_argv
built_argv (args
);
529 char **argv
= built_argv
.get ();
531 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
535 error (_("No executable file name was specified"));
537 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
538 exec_file_attach (filename
.get (), from_tty
);
541 exec_file_attach (NULL
, from_tty
);
544 /* Set both the exec file and the symbol file, in one command.
545 What a novelty. Why did GDB go through four major releases before this
546 command was added? */
549 file_command (const char *arg
, int from_tty
)
551 /* FIXME, if we lose on reading the symbol file, we should revert
552 the exec file, but that's rough. */
553 exec_file_command (arg
, from_tty
);
554 symbol_file_command (arg
, from_tty
);
555 if (deprecated_file_changed_hook
)
556 deprecated_file_changed_hook (arg
);
560 /* Builds a section table, given args BFD, TABLE. */
563 build_section_table (struct bfd
*some_bfd
)
565 target_section_table table
;
567 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
571 /* Check the section flags, but do not discard zero-length
572 sections, since some symbols may still be attached to this
573 section. For instance, we encountered on sparc-solaris 2.10
574 a shared library with an empty .bss section to which a symbol
575 named "_end" was attached. The address of this symbol still
576 needs to be relocated. */
577 aflag
= bfd_section_flags (asect
);
578 if (!(aflag
& SEC_ALLOC
))
581 table
.emplace_back (bfd_section_vma (asect
),
582 bfd_section_vma (asect
) + bfd_section_size (asect
),
589 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
590 current set of target sections. */
593 program_space::add_target_sections (void *owner
,
594 const target_section_table
§ions
)
596 if (!sections
.empty ())
598 for (const target_section
&s
: sections
)
600 m_target_sections
.push_back (s
);
601 m_target_sections
.back ().owner
= owner
;
604 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
606 /* If these are the first file sections we can provide memory
607 from, push the file_stratum target. Must do this in all
608 inferiors sharing the program space. */
609 for (inferior
*inf
: all_inferiors ())
611 if (inf
->pspace
!= this)
614 if (inf
->target_is_pushed (&exec_ops
))
617 switch_to_inferior_no_thread (inf
);
618 inf
->push_target (&exec_ops
);
623 /* Add the sections of OBJFILE to the current set of target sections. */
626 program_space::add_target_sections (struct objfile
*objfile
)
628 struct obj_section
*osect
;
630 gdb_assert (objfile
!= nullptr);
632 /* Compute the number of sections to add. */
633 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
635 if (bfd_section_size (osect
->the_bfd_section
) == 0)
638 m_target_sections
.emplace_back (osect
->addr (), osect
->endaddr (),
639 osect
->the_bfd_section
, (void *) objfile
);
643 /* Remove all target sections owned by OWNER.
644 OWNER must be the same value passed to add_target_sections. */
647 program_space::remove_target_sections (void *owner
)
649 gdb_assert (owner
!= NULL
);
651 auto it
= std::remove_if (m_target_sections
.begin (),
652 m_target_sections
.end (),
653 [&] (target_section
§
)
655 return sect
.owner
== owner
;
657 m_target_sections
.erase (it
, m_target_sections
.end ());
659 /* If we don't have any more sections to read memory from,
660 remove the file_stratum target from the stack of each
661 inferior sharing the program space. */
662 if (m_target_sections
.empty ())
664 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
666 for (inferior
*inf
: all_inferiors ())
668 if (inf
->pspace
!= this)
671 switch_to_inferior_no_thread (inf
);
672 inf
->unpush_target (&exec_ops
);
680 exec_on_vfork (inferior
*vfork_child
)
682 if (!vfork_child
->pspace
->target_sections ().empty ())
683 vfork_child
->push_target (&exec_ops
);
688 enum target_xfer_status
689 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
690 ULONGEST len
, ULONGEST
*xfered_len
)
692 /* It's unduly pedantic to refuse to look at the executable for
693 read-only pieces; so do the equivalent of readonly regions aka
695 if (current_program_space
->exec_bfd () != NULL
)
701 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
703 if ((s
->flags
& SEC_LOAD
) == 0
704 || (s
->flags
& SEC_READONLY
) == 0)
708 size
= bfd_section_size (s
);
709 if (vma
<= offset
&& offset
< (vma
+ size
))
713 amt
= (vma
+ size
) - offset
;
717 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
718 readbuf
, offset
- vma
, amt
);
721 return TARGET_XFER_EOF
;
725 return TARGET_XFER_OK
;
731 /* Indicate failure to find the requested memory block. */
732 return TARGET_XFER_E_IO
;
735 /* Return all read-only memory ranges found in the target section
736 table defined by SECTIONS and SECTIONS_END, starting at (and
737 intersected with) MEMADDR for LEN bytes. */
739 static std::vector
<mem_range
>
740 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
741 const target_section_table
§ions
)
743 std::vector
<mem_range
> memory
;
745 for (const target_section
&p
: sections
)
747 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
750 /* Copy the meta-data, adjusted. */
751 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
753 ULONGEST lo1
, hi1
, lo2
, hi2
;
761 CORE_ADDR start
= std::max (lo1
, lo2
);
762 int length
= std::min (hi1
, hi2
) - start
;
764 memory
.emplace_back (start
, length
);
771 enum target_xfer_status
772 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
773 ULONGEST len
, ULONGEST
*xfered_len
)
775 const target_section_table
*table
776 = target_get_section_table (current_inferior ()->top_target ());
777 std::vector
<mem_range
> available_memory
778 = section_table_available_memory (offset
, len
, *table
);
780 normalize_mem_ranges (&available_memory
);
782 for (const mem_range
&r
: available_memory
)
784 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
787 enum target_xfer_status status
;
789 /* Get the intersection window. */
790 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
792 gdb_assert (end
- offset
<= len
);
794 if (offset
>= r
.start
)
795 status
= exec_read_partial_read_only (readbuf
, offset
,
800 *xfered_len
= r
.start
- offset
;
801 status
= TARGET_XFER_UNAVAILABLE
;
808 return TARGET_XFER_UNAVAILABLE
;
811 enum target_xfer_status
812 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
813 ULONGEST offset
, ULONGEST len
,
814 ULONGEST
*xfered_len
,
815 const target_section_table
§ions
,
816 gdb::function_view
<bool
817 (const struct target_section
*)> match_cb
)
820 ULONGEST memaddr
= offset
;
821 ULONGEST memend
= memaddr
+ len
;
823 gdb_assert (len
!= 0);
825 for (const target_section
&p
: sections
)
827 struct bfd_section
*asect
= p
.the_bfd_section
;
828 bfd
*abfd
= asect
->owner
;
830 if (match_cb
!= nullptr && !match_cb (&p
))
831 continue; /* not the section we need. */
832 if (memaddr
>= p
.addr
)
834 if (memend
<= p
.endaddr
)
836 /* Entire transfer is within this section. */
838 res
= bfd_set_section_contents (abfd
, asect
,
839 writebuf
, memaddr
- p
.addr
,
842 res
= bfd_get_section_contents (abfd
, asect
,
843 readbuf
, memaddr
- p
.addr
,
849 return TARGET_XFER_OK
;
852 return TARGET_XFER_EOF
;
854 else if (memaddr
>= p
.endaddr
)
856 /* This section ends before the transfer starts. */
861 /* This section overlaps the transfer. Just do half. */
862 len
= p
.endaddr
- memaddr
;
864 res
= bfd_set_section_contents (abfd
, asect
,
865 writebuf
, memaddr
- p
.addr
,
868 res
= bfd_get_section_contents (abfd
, asect
,
869 readbuf
, memaddr
- p
.addr
,
874 return TARGET_XFER_OK
;
877 return TARGET_XFER_EOF
;
882 return TARGET_XFER_EOF
; /* We can't help. */
885 enum target_xfer_status
886 exec_target::xfer_partial (enum target_object object
,
887 const char *annex
, gdb_byte
*readbuf
,
888 const gdb_byte
*writebuf
,
889 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
891 const target_section_table
*table
= target_get_section_table (this);
893 if (object
== TARGET_OBJECT_MEMORY
)
894 return section_table_xfer_memory_partial (readbuf
, writebuf
,
895 offset
, len
, xfered_len
,
898 return TARGET_XFER_E_IO
;
903 print_section_info (const target_section_table
*t
, bfd
*abfd
)
905 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
906 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
907 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
909 gdb_printf ("\t`%ps', ",
910 styled_string (file_name_style
.style (),
911 bfd_get_filename (abfd
)));
912 gdb_stdout
->wrap_here (8);
913 gdb_printf (_("file type %s.\n"), bfd_get_target (abfd
));
914 if (abfd
== current_program_space
->exec_bfd ())
916 /* gcc-3.4 does not like the initialization in
917 <p == t->sections_end>. */
918 bfd_vma displacement
= 0;
922 for (const target_section
&p
: *t
)
924 struct bfd_section
*psect
= p
.the_bfd_section
;
926 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
927 != (SEC_ALLOC
| SEC_LOAD
))
930 if (bfd_section_vma (psect
) <= abfd
->start_address
931 && abfd
->start_address
< (bfd_section_vma (psect
)
932 + bfd_section_size (psect
)))
934 displacement
= p
.addr
- bfd_section_vma (psect
);
940 warning (_("Cannot find section for the entry point of %ps."),
941 styled_string (file_name_style
.style (),
942 bfd_get_filename (abfd
)));
944 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
945 bfd_get_start_address (abfd
)
947 gdb_printf (_("\tEntry point: %s\n"),
948 paddress (gdbarch
, entry_point
));
950 for (const target_section
&p
: *t
)
952 struct bfd_section
*psect
= p
.the_bfd_section
;
953 bfd
*pbfd
= psect
->owner
;
955 gdb_printf ("\t%s", hex_string_custom (p
.addr
, wid
));
956 gdb_printf (" - %s", hex_string_custom (p
.endaddr
, wid
));
958 /* FIXME: A format of "08l" is not wide enough for file offsets
959 larger than 4GB. OTOH, making it "016l" isn't desirable either
960 since most output will then be much wider than necessary. It
961 may make sense to test the size of the file and choose the
962 format string accordingly. */
963 /* FIXME: i18n: Need to rewrite this sentence. */
966 hex_string_custom (psect
->filepos
, 8));
967 gdb_printf (" is %s", bfd_section_name (psect
));
969 gdb_printf (" in %ps",
970 styled_string (file_name_style
.style (),
971 bfd_get_filename (pbfd
)));
977 exec_target::files_info ()
979 if (current_program_space
->exec_bfd ())
980 print_section_info (¤t_program_space
->target_sections (),
981 current_program_space
->exec_bfd ());
983 gdb_puts (_("\t<no file loaded>\n"));
987 set_section_command (const char *args
, int from_tty
)
992 error (_("Must specify section name and its virtual address"));
994 /* Parse out section name. */
995 for (secname
= args
; !isspace (*args
); args
++);
996 unsigned seclen
= args
- secname
;
998 /* Parse out new virtual address. */
999 CORE_ADDR secaddr
= parse_and_eval_address (args
);
1001 for (target_section
&p
: current_program_space
->target_sections ())
1003 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1004 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1006 long offset
= secaddr
- p
.addr
;
1008 p
.endaddr
+= offset
;
1010 exec_ops
.files_info ();
1015 std::string
secprint (secname
, seclen
);
1016 error (_("Section %s not found"), secprint
.c_str ());
1019 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1023 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1025 for (target_section
&p
: current_program_space
->target_sections ())
1027 if (filename_cmp (filename
,
1028 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1029 && index
== p
.the_bfd_section
->index
)
1031 p
.endaddr
+= address
- p
.addr
;
1038 exec_target::has_memory ()
1040 /* We can provide memory if we have any file/target sections to read
1042 return !current_program_space
->target_sections ().empty ();
1045 gdb::unique_xmalloc_ptr
<char>
1046 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1048 error (_("Can't create a corefile"));
1052 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1054 return objfile_find_memory_regions (this, func
, data
);
1057 void _initialize_exec ();
1061 struct cmd_list_element
*c
;
1063 c
= add_cmd ("file", class_files
, file_command
, _("\
1064 Use FILE as program to be debugged.\n\
1065 It is read for its symbols, for getting the contents of pure memory,\n\
1066 and it is the program executed when you use the `run' command.\n\
1067 If FILE cannot be found as specified, your execution directory path\n\
1068 ($PATH) is searched for a command of that name.\n\
1069 No arg means to have no executable file and no symbols."), &cmdlist
);
1070 set_cmd_completer (c
, filename_completer
);
1072 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1073 Use FILE as program for getting contents of pure memory.\n\
1074 If FILE cannot be found as specified, your execution directory path\n\
1075 is searched for a command of that name.\n\
1076 No arg means have no executable file."), &cmdlist
);
1077 set_cmd_completer (c
, filename_completer
);
1079 add_com ("section", class_files
, set_section_command
, _("\
1080 Change the base address of section SECTION of the exec file to ADDR.\n\
1081 This can be used if the exec file does not contain section addresses,\n\
1082 (such as in the a.out format), or when the addresses specified in the\n\
1083 file itself are wrong. Each section must be changed separately. The\n\
1084 ``info files'' command lists all the sections and their addresses."));
1086 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1087 Set writing into executable and core files."), _("\
1088 Show writing into executable and core files."), NULL
,
1091 &setlist
, &showlist
);
1093 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1094 exec_file_mismatch_names
,
1095 &exec_file_mismatch
,
1097 Set exec-file-mismatch handling (ask|warn|off)."),
1099 Show exec-file-mismatch handling (ask|warn|off)."),
1101 Specifies how to handle a mismatch between the current exec-file\n\
1102 loaded by GDB and the exec-file automatically determined when attaching\n\
1104 ask - warn the user and ask whether to load the determined exec-file.\n\
1105 warn - warn the user, but do not change the exec-file.\n\
1106 off - do not check for mismatch.\n\
1108 GDB detects a mismatch by comparing the build IDs of the files.\n\
1109 If the user confirms loading the determined exec-file, then its symbols\n\
1110 will be loaded as well."),
1111 set_exec_file_mismatch_command
,
1112 show_exec_file_mismatch_command
,
1113 &setlist
, &showlist
);
1115 add_target (exec_target_info
, exec_target_open
, filename_completer
);