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 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
);