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 gdb_assert (objfile
!= nullptr);
630 /* Compute the number of sections to add. */
631 for (obj_section
*osect
: objfile
->sections ())
633 if (bfd_section_size (osect
->the_bfd_section
) == 0)
636 m_target_sections
.emplace_back (osect
->addr (), osect
->endaddr (),
637 osect
->the_bfd_section
, (void *) objfile
);
641 /* Remove all target sections owned by OWNER.
642 OWNER must be the same value passed to add_target_sections. */
645 program_space::remove_target_sections (void *owner
)
647 gdb_assert (owner
!= NULL
);
649 auto it
= std::remove_if (m_target_sections
.begin (),
650 m_target_sections
.end (),
651 [&] (target_section
§
)
653 return sect
.owner
== owner
;
655 m_target_sections
.erase (it
, m_target_sections
.end ());
657 /* If we don't have any more sections to read memory from,
658 remove the file_stratum target from the stack of each
659 inferior sharing the program space. */
660 if (m_target_sections
.empty ())
662 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
664 for (inferior
*inf
: all_inferiors ())
666 if (inf
->pspace
!= this)
669 switch_to_inferior_no_thread (inf
);
670 inf
->unpush_target (&exec_ops
);
678 exec_on_vfork (inferior
*vfork_child
)
680 if (!vfork_child
->pspace
->target_sections ().empty ())
681 vfork_child
->push_target (&exec_ops
);
686 enum target_xfer_status
687 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
688 ULONGEST len
, ULONGEST
*xfered_len
)
690 /* It's unduly pedantic to refuse to look at the executable for
691 read-only pieces; so do the equivalent of readonly regions aka
693 if (current_program_space
->exec_bfd () != NULL
)
699 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
701 if ((s
->flags
& SEC_LOAD
) == 0
702 || (s
->flags
& SEC_READONLY
) == 0)
706 size
= bfd_section_size (s
);
707 if (vma
<= offset
&& offset
< (vma
+ size
))
711 amt
= (vma
+ size
) - offset
;
715 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
716 readbuf
, offset
- vma
, amt
);
719 return TARGET_XFER_EOF
;
723 return TARGET_XFER_OK
;
729 /* Indicate failure to find the requested memory block. */
730 return TARGET_XFER_E_IO
;
733 /* Return all read-only memory ranges found in the target section
734 table defined by SECTIONS and SECTIONS_END, starting at (and
735 intersected with) MEMADDR for LEN bytes. */
737 static std::vector
<mem_range
>
738 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
739 const target_section_table
§ions
)
741 std::vector
<mem_range
> memory
;
743 for (const target_section
&p
: sections
)
745 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
748 /* Copy the meta-data, adjusted. */
749 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
751 ULONGEST lo1
, hi1
, lo2
, hi2
;
759 CORE_ADDR start
= std::max (lo1
, lo2
);
760 int length
= std::min (hi1
, hi2
) - start
;
762 memory
.emplace_back (start
, length
);
769 enum target_xfer_status
770 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
771 ULONGEST len
, ULONGEST
*xfered_len
)
773 const target_section_table
*table
774 = target_get_section_table (current_inferior ()->top_target ());
775 std::vector
<mem_range
> available_memory
776 = section_table_available_memory (offset
, len
, *table
);
778 normalize_mem_ranges (&available_memory
);
780 for (const mem_range
&r
: available_memory
)
782 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
785 enum target_xfer_status status
;
787 /* Get the intersection window. */
788 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
790 gdb_assert (end
- offset
<= len
);
792 if (offset
>= r
.start
)
793 status
= exec_read_partial_read_only (readbuf
, offset
,
798 *xfered_len
= r
.start
- offset
;
799 status
= TARGET_XFER_UNAVAILABLE
;
806 return TARGET_XFER_UNAVAILABLE
;
809 enum target_xfer_status
810 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
811 ULONGEST offset
, ULONGEST len
,
812 ULONGEST
*xfered_len
,
813 const target_section_table
§ions
,
814 gdb::function_view
<bool
815 (const struct target_section
*)> match_cb
)
818 ULONGEST memaddr
= offset
;
819 ULONGEST memend
= memaddr
+ len
;
821 gdb_assert (len
!= 0);
823 for (const target_section
&p
: sections
)
825 struct bfd_section
*asect
= p
.the_bfd_section
;
826 bfd
*abfd
= asect
->owner
;
828 if (match_cb
!= nullptr && !match_cb (&p
))
829 continue; /* not the section we need. */
830 if (memaddr
>= p
.addr
)
832 if (memend
<= p
.endaddr
)
834 /* Entire transfer is within this section. */
836 res
= bfd_set_section_contents (abfd
, asect
,
837 writebuf
, memaddr
- p
.addr
,
840 res
= bfd_get_section_contents (abfd
, asect
,
841 readbuf
, memaddr
- p
.addr
,
847 return TARGET_XFER_OK
;
850 return TARGET_XFER_EOF
;
852 else if (memaddr
>= p
.endaddr
)
854 /* This section ends before the transfer starts. */
859 /* This section overlaps the transfer. Just do half. */
860 len
= p
.endaddr
- memaddr
;
862 res
= bfd_set_section_contents (abfd
, asect
,
863 writebuf
, memaddr
- p
.addr
,
866 res
= bfd_get_section_contents (abfd
, asect
,
867 readbuf
, memaddr
- p
.addr
,
872 return TARGET_XFER_OK
;
875 return TARGET_XFER_EOF
;
880 return TARGET_XFER_EOF
; /* We can't help. */
883 enum target_xfer_status
884 exec_target::xfer_partial (enum target_object object
,
885 const char *annex
, gdb_byte
*readbuf
,
886 const gdb_byte
*writebuf
,
887 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
889 const target_section_table
*table
= target_get_section_table (this);
891 if (object
== TARGET_OBJECT_MEMORY
)
892 return section_table_xfer_memory_partial (readbuf
, writebuf
,
893 offset
, len
, xfered_len
,
896 return TARGET_XFER_E_IO
;
901 print_section_info (const target_section_table
*t
, bfd
*abfd
)
903 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
904 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
905 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
907 gdb_printf ("\t`%ps', ",
908 styled_string (file_name_style
.style (),
909 bfd_get_filename (abfd
)));
910 gdb_stdout
->wrap_here (8);
911 gdb_printf (_("file type %s.\n"), bfd_get_target (abfd
));
912 if (abfd
== current_program_space
->exec_bfd ())
914 /* gcc-3.4 does not like the initialization in
915 <p == t->sections_end>. */
916 bfd_vma displacement
= 0;
920 for (const target_section
&p
: *t
)
922 struct bfd_section
*psect
= p
.the_bfd_section
;
924 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
925 != (SEC_ALLOC
| SEC_LOAD
))
928 if (bfd_section_vma (psect
) <= abfd
->start_address
929 && abfd
->start_address
< (bfd_section_vma (psect
)
930 + bfd_section_size (psect
)))
932 displacement
= p
.addr
- bfd_section_vma (psect
);
938 warning (_("Cannot find section for the entry point of %ps."),
939 styled_string (file_name_style
.style (),
940 bfd_get_filename (abfd
)));
942 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
943 bfd_get_start_address (abfd
)
945 gdb_printf (_("\tEntry point: %s\n"),
946 paddress (gdbarch
, entry_point
));
948 for (const target_section
&p
: *t
)
950 struct bfd_section
*psect
= p
.the_bfd_section
;
951 bfd
*pbfd
= psect
->owner
;
953 gdb_printf ("\t%s", hex_string_custom (p
.addr
, wid
));
954 gdb_printf (" - %s", hex_string_custom (p
.endaddr
, wid
));
956 /* FIXME: A format of "08l" is not wide enough for file offsets
957 larger than 4GB. OTOH, making it "016l" isn't desirable either
958 since most output will then be much wider than necessary. It
959 may make sense to test the size of the file and choose the
960 format string accordingly. */
961 /* FIXME: i18n: Need to rewrite this sentence. */
964 hex_string_custom (psect
->filepos
, 8));
965 gdb_printf (" is %s", bfd_section_name (psect
));
967 gdb_printf (" in %ps",
968 styled_string (file_name_style
.style (),
969 bfd_get_filename (pbfd
)));
975 exec_target::files_info ()
977 if (current_program_space
->exec_bfd ())
978 print_section_info (¤t_program_space
->target_sections (),
979 current_program_space
->exec_bfd ());
981 gdb_puts (_("\t<no file loaded>\n"));
985 set_section_command (const char *args
, int from_tty
)
990 error (_("Must specify section name and its virtual address"));
992 /* Parse out section name. */
993 for (secname
= args
; !isspace (*args
); args
++);
994 unsigned seclen
= args
- secname
;
996 /* Parse out new virtual address. */
997 CORE_ADDR secaddr
= parse_and_eval_address (args
);
999 for (target_section
&p
: current_program_space
->target_sections ())
1001 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1002 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1004 long offset
= secaddr
- p
.addr
;
1006 p
.endaddr
+= offset
;
1008 exec_ops
.files_info ();
1013 std::string
secprint (secname
, seclen
);
1014 error (_("Section %s not found"), secprint
.c_str ());
1017 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1021 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1023 for (target_section
&p
: current_program_space
->target_sections ())
1025 if (filename_cmp (filename
,
1026 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1027 && index
== p
.the_bfd_section
->index
)
1029 p
.endaddr
+= address
- p
.addr
;
1036 exec_target::has_memory ()
1038 /* We can provide memory if we have any file/target sections to read
1040 return !current_program_space
->target_sections ().empty ();
1043 gdb::unique_xmalloc_ptr
<char>
1044 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1046 error (_("Can't create a corefile"));
1050 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1052 return objfile_find_memory_regions (this, func
, data
);
1055 void _initialize_exec ();
1059 struct cmd_list_element
*c
;
1061 c
= add_cmd ("file", class_files
, file_command
, _("\
1062 Use FILE as program to be debugged.\n\
1063 It is read for its symbols, for getting the contents of pure memory,\n\
1064 and it is the program executed when you use the `run' command.\n\
1065 If FILE cannot be found as specified, your execution directory path\n\
1066 ($PATH) is searched for a command of that name.\n\
1067 No arg means to have no executable file and no symbols."), &cmdlist
);
1068 set_cmd_completer (c
, filename_completer
);
1070 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1071 Use FILE as program for getting contents of pure memory.\n\
1072 If FILE cannot be found as specified, your execution directory path\n\
1073 is searched for a command of that name.\n\
1074 No arg means have no executable file."), &cmdlist
);
1075 set_cmd_completer (c
, filename_completer
);
1077 add_com ("section", class_files
, set_section_command
, _("\
1078 Change the base address of section SECTION of the exec file to ADDR.\n\
1079 This can be used if the exec file does not contain section addresses,\n\
1080 (such as in the a.out format), or when the addresses specified in the\n\
1081 file itself are wrong. Each section must be changed separately. The\n\
1082 ``info files'' command lists all the sections and their addresses."));
1084 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1085 Set writing into executable and core files."), _("\
1086 Show writing into executable and core files."), NULL
,
1089 &setlist
, &showlist
);
1091 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1092 exec_file_mismatch_names
,
1093 &exec_file_mismatch
,
1095 Set exec-file-mismatch handling (ask|warn|off)."),
1097 Show exec-file-mismatch handling (ask|warn|off)."),
1099 Specifies how to handle a mismatch between the current exec-file\n\
1100 loaded by GDB and the exec-file automatically determined when attaching\n\
1102 ask - warn the user and ask whether to load the determined exec-file.\n\
1103 warn - warn the user, but do not change the exec-file.\n\
1104 off - do not check for mismatch.\n\
1106 GDB detects a mismatch by comparing the build IDs of the files.\n\
1107 If the user confirms loading the determined exec-file, then its symbols\n\
1108 will be loaded as well."),
1109 set_exec_file_mismatch_command
,
1110 show_exec_file_mismatch_command
,
1111 &setlist
, &showlist
);
1113 add_target (exec_target_info
, exec_target_open
, filename_completer
);