1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "filenames.h"
29 #include "completer.h"
32 #include "observable.h"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
36 #include "progspace-and-thread.h"
43 #include "readline/tilde.h"
50 #include "gdbsupport/pathstuff.h"
51 #include "cli/cli-style.h"
53 void (*deprecated_file_changed_hook
) (const char *);
55 static const target_info exec_target_info
= {
57 N_("Local exec file"),
58 N_("Use an executable file as a target.\n\
59 Specify the filename of the executable file.")
62 /* The target vector for executable files. */
64 struct exec_target final
: public target_ops
66 const target_info
&info () const override
67 { return exec_target_info
; }
69 strata
stratum () const override
{ return file_stratum
; }
71 void close () override
;
72 enum target_xfer_status
xfer_partial (enum target_object object
,
75 const gdb_byte
*writebuf
,
76 ULONGEST offset
, ULONGEST len
,
77 ULONGEST
*xfered_len
) override
;
78 void files_info () override
;
80 bool has_memory () override
;
81 gdb::unique_xmalloc_ptr
<char> make_corefile_notes (bfd
*, int *) override
;
82 int find_memory_regions (find_memory_region_ftype func
, void *data
) override
;
85 static exec_target exec_ops
;
87 /* How to handle a mismatch between the current exec file and the exec
88 file determined from target. */
90 static const char *const exec_file_mismatch_names
[]
91 = {"ask", "warn", "off", NULL
};
92 enum exec_file_mismatch_mode
94 exec_file_mismatch_ask
, exec_file_mismatch_warn
, exec_file_mismatch_off
96 static const char *exec_file_mismatch
= exec_file_mismatch_names
[0];
97 static enum exec_file_mismatch_mode exec_file_mismatch_mode
98 = exec_file_mismatch_ask
;
102 show_exec_file_mismatch_command (struct ui_file
*file
, int from_tty
,
103 struct cmd_list_element
*c
, const char *value
)
105 fprintf_filtered (gdb_stdout
,
106 _("exec-file-mismatch handling is currently \"%s\".\n"),
107 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
110 /* Set command. Change the setting for range checking. */
112 set_exec_file_mismatch_command (const char *ignore
,
113 int from_tty
, struct cmd_list_element
*c
)
115 for (enum exec_file_mismatch_mode mode
= exec_file_mismatch_ask
;
117 mode
= static_cast<enum exec_file_mismatch_mode
>(1 + (int) mode
))
119 if (strcmp (exec_file_mismatch
, exec_file_mismatch_names
[mode
]) == 0)
121 exec_file_mismatch_mode
= mode
;
124 if (mode
== exec_file_mismatch_off
)
125 internal_error (__FILE__
, __LINE__
,
126 _("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 fprintf_filtered (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
)
204 if (!exception_print_same (prev_err
, 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 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 printf_unfiltered (_("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 (_("\"%ps\": could not open as an executable file: %s."),
457 styled_string (file_name_style
.style (), scratch_pathname
),
458 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 (_("\"%ps\": not in executable format: %s"),
479 styled_string (file_name_style
.style (), scratch_pathname
),
480 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
483 target_section_table sections
484 = build_section_table (current_program_space
->exec_bfd ());
486 current_program_space
->ebfd_mtime
487 = bfd_get_mtime (current_program_space
->exec_bfd ());
491 set_gdbarch_from_file (current_program_space
->exec_bfd ());
493 /* Add the executable's sections to the current address spaces'
494 list of sections. This possibly pushes the exec_ops
496 current_program_space
->add_target_sections (¤t_program_space
->ebfd
,
499 /* Tell display code (if any) about the changed file name. */
500 if (deprecated_exec_file_display_hook
)
501 (*deprecated_exec_file_display_hook
) (filename
);
504 bfd_cache_close_all ();
505 gdb::observers::executable_changed
.notify ();
508 /* Process the first arg in ARGS as the new exec file.
510 Note that we have to explicitly ignore additional args, since we can
511 be called from file_command(), which also calls symbol_file_command()
512 which can take multiple args.
514 If ARGS is NULL, we just want to close the exec file. */
517 exec_file_command (const char *args
, int from_tty
)
519 if (from_tty
&& target_has_execution ()
520 && !query (_("A program is being debugged already.\n"
521 "Are you sure you want to change the file? ")))
522 error (_("File not changed."));
526 /* Scan through the args and pick up the first non option arg
529 gdb_argv
built_argv (args
);
530 char **argv
= built_argv
.get ();
532 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
536 error (_("No executable file name was specified"));
538 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
539 exec_file_attach (filename
.get (), from_tty
);
542 exec_file_attach (NULL
, from_tty
);
545 /* Set both the exec file and the symbol file, in one command.
546 What a novelty. Why did GDB go through four major releases before this
547 command was added? */
550 file_command (const char *arg
, int from_tty
)
552 /* FIXME, if we lose on reading the symbol file, we should revert
553 the exec file, but that's rough. */
554 exec_file_command (arg
, from_tty
);
555 symbol_file_command (arg
, from_tty
);
556 if (deprecated_file_changed_hook
)
557 deprecated_file_changed_hook (arg
);
561 /* Builds a section table, given args BFD, TABLE. */
564 build_section_table (struct bfd
*some_bfd
)
566 target_section_table table
;
568 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
572 /* Check the section flags, but do not discard zero-length
573 sections, since some symbols may still be attached to this
574 section. For instance, we encountered on sparc-solaris 2.10
575 a shared library with an empty .bss section to which a symbol
576 named "_end" was attached. The address of this symbol still
577 needs to be relocated. */
578 aflag
= bfd_section_flags (asect
);
579 if (!(aflag
& SEC_ALLOC
))
582 table
.emplace_back (bfd_section_vma (asect
),
583 bfd_section_vma (asect
) + bfd_section_size (asect
),
590 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
591 current set of target sections. */
594 program_space::add_target_sections (void *owner
,
595 const target_section_table
§ions
)
597 if (!sections
.empty ())
599 for (const target_section
&s
: sections
)
601 m_target_sections
.push_back (s
);
602 m_target_sections
.back ().owner
= owner
;
605 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
607 /* If these are the first file sections we can provide memory
608 from, push the file_stratum target. Must do this in all
609 inferiors sharing the program space. */
610 for (inferior
*inf
: all_inferiors ())
612 if (inf
->pspace
!= this)
615 if (inf
->target_is_pushed (&exec_ops
))
618 switch_to_inferior_no_thread (inf
);
619 inf
->push_target (&exec_ops
);
624 /* Add the sections of OBJFILE to the current set of target sections. */
627 program_space::add_target_sections (struct objfile
*objfile
)
629 struct obj_section
*osect
;
631 gdb_assert (objfile
!= nullptr);
633 /* Compute the number of sections to add. */
634 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
636 if (bfd_section_size (osect
->the_bfd_section
) == 0)
639 m_target_sections
.emplace_back (osect
->addr (), osect
->endaddr (),
640 osect
->the_bfd_section
, (void *) objfile
);
644 /* Remove all target sections owned by OWNER.
645 OWNER must be the same value passed to add_target_sections. */
648 program_space::remove_target_sections (void *owner
)
650 gdb_assert (owner
!= NULL
);
652 auto it
= std::remove_if (m_target_sections
.begin (),
653 m_target_sections
.end (),
654 [&] (target_section
§
)
656 return sect
.owner
== owner
;
658 m_target_sections
.erase (it
, m_target_sections
.end ());
660 /* If we don't have any more sections to read memory from,
661 remove the file_stratum target from the stack of each
662 inferior sharing the program space. */
663 if (m_target_sections
.empty ())
665 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
667 for (inferior
*inf
: all_inferiors ())
669 if (inf
->pspace
!= this)
672 switch_to_inferior_no_thread (inf
);
673 inf
->unpush_target (&exec_ops
);
683 if (!current_program_space
->target_sections ().empty ())
684 current_inferior ()->push_target (&exec_ops
);
689 enum target_xfer_status
690 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
691 ULONGEST len
, ULONGEST
*xfered_len
)
693 /* It's unduly pedantic to refuse to look at the executable for
694 read-only pieces; so do the equivalent of readonly regions aka
696 if (current_program_space
->exec_bfd () != NULL
)
702 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
704 if ((s
->flags
& SEC_LOAD
) == 0
705 || (s
->flags
& SEC_READONLY
) == 0)
709 size
= bfd_section_size (s
);
710 if (vma
<= offset
&& offset
< (vma
+ size
))
714 amt
= (vma
+ size
) - offset
;
718 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
719 readbuf
, offset
- vma
, amt
);
722 return TARGET_XFER_EOF
;
726 return TARGET_XFER_OK
;
732 /* Indicate failure to find the requested memory block. */
733 return TARGET_XFER_E_IO
;
736 /* Return all read-only memory ranges found in the target section
737 table defined by SECTIONS and SECTIONS_END, starting at (and
738 intersected with) MEMADDR for LEN bytes. */
740 static std::vector
<mem_range
>
741 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
742 const target_section_table
§ions
)
744 std::vector
<mem_range
> memory
;
746 for (const target_section
&p
: sections
)
748 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
751 /* Copy the meta-data, adjusted. */
752 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
754 ULONGEST lo1
, hi1
, lo2
, hi2
;
762 CORE_ADDR start
= std::max (lo1
, lo2
);
763 int length
= std::min (hi1
, hi2
) - start
;
765 memory
.emplace_back (start
, length
);
772 enum target_xfer_status
773 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
774 ULONGEST len
, ULONGEST
*xfered_len
)
776 const target_section_table
*table
777 = target_get_section_table (current_inferior ()->top_target ());
778 std::vector
<mem_range
> available_memory
779 = section_table_available_memory (offset
, len
, *table
);
781 normalize_mem_ranges (&available_memory
);
783 for (const mem_range
&r
: available_memory
)
785 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
788 enum target_xfer_status status
;
790 /* Get the intersection window. */
791 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
793 gdb_assert (end
- offset
<= len
);
795 if (offset
>= r
.start
)
796 status
= exec_read_partial_read_only (readbuf
, offset
,
801 *xfered_len
= r
.start
- offset
;
802 status
= TARGET_XFER_UNAVAILABLE
;
809 return TARGET_XFER_UNAVAILABLE
;
812 enum target_xfer_status
813 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
814 ULONGEST offset
, ULONGEST len
,
815 ULONGEST
*xfered_len
,
816 const target_section_table
§ions
,
817 gdb::function_view
<bool
818 (const struct target_section
*)> match_cb
)
821 ULONGEST memaddr
= offset
;
822 ULONGEST memend
= memaddr
+ len
;
824 gdb_assert (len
!= 0);
826 for (const target_section
&p
: sections
)
828 struct bfd_section
*asect
= p
.the_bfd_section
;
829 bfd
*abfd
= asect
->owner
;
831 if (match_cb
!= nullptr && !match_cb (&p
))
832 continue; /* not the section we need. */
833 if (memaddr
>= p
.addr
)
835 if (memend
<= p
.endaddr
)
837 /* Entire transfer is within this section. */
839 res
= bfd_set_section_contents (abfd
, asect
,
840 writebuf
, memaddr
- p
.addr
,
843 res
= bfd_get_section_contents (abfd
, asect
,
844 readbuf
, memaddr
- p
.addr
,
850 return TARGET_XFER_OK
;
853 return TARGET_XFER_EOF
;
855 else if (memaddr
>= p
.endaddr
)
857 /* This section ends before the transfer starts. */
862 /* This section overlaps the transfer. Just do half. */
863 len
= p
.endaddr
- memaddr
;
865 res
= bfd_set_section_contents (abfd
, asect
,
866 writebuf
, memaddr
- p
.addr
,
869 res
= bfd_get_section_contents (abfd
, asect
,
870 readbuf
, memaddr
- p
.addr
,
875 return TARGET_XFER_OK
;
878 return TARGET_XFER_EOF
;
883 return TARGET_XFER_EOF
; /* We can't help. */
886 enum target_xfer_status
887 exec_target::xfer_partial (enum target_object object
,
888 const char *annex
, gdb_byte
*readbuf
,
889 const gdb_byte
*writebuf
,
890 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
892 const target_section_table
*table
= target_get_section_table (this);
894 if (object
== TARGET_OBJECT_MEMORY
)
895 return section_table_xfer_memory_partial (readbuf
, writebuf
,
896 offset
, len
, xfered_len
,
899 return TARGET_XFER_E_IO
;
904 print_section_info (const target_section_table
*t
, bfd
*abfd
)
906 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
907 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
908 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
910 printf_filtered ("\t`%ps', ",
911 styled_string (file_name_style
.style (),
912 bfd_get_filename (abfd
)));
914 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
915 if (abfd
== current_program_space
->exec_bfd ())
917 /* gcc-3.4 does not like the initialization in
918 <p == t->sections_end>. */
919 bfd_vma displacement
= 0;
923 for (const target_section
&p
: *t
)
925 struct bfd_section
*psect
= p
.the_bfd_section
;
927 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
928 != (SEC_ALLOC
| SEC_LOAD
))
931 if (bfd_section_vma (psect
) <= abfd
->start_address
932 && abfd
->start_address
< (bfd_section_vma (psect
)
933 + bfd_section_size (psect
)))
935 displacement
= p
.addr
- bfd_section_vma (psect
);
941 warning (_("Cannot find section for the entry point of %ps."),
942 styled_string (file_name_style
.style (),
943 bfd_get_filename (abfd
)));
945 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
946 bfd_get_start_address (abfd
)
948 printf_filtered (_("\tEntry point: %s\n"),
949 paddress (gdbarch
, entry_point
));
951 for (const target_section
&p
: *t
)
953 struct bfd_section
*psect
= p
.the_bfd_section
;
954 bfd
*pbfd
= psect
->owner
;
956 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
957 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
959 /* FIXME: A format of "08l" is not wide enough for file offsets
960 larger than 4GB. OTOH, making it "016l" isn't desirable either
961 since most output will then be much wider than necessary. It
962 may make sense to test the size of the file and choose the
963 format string accordingly. */
964 /* FIXME: i18n: Need to rewrite this sentence. */
966 printf_filtered (" @ %s",
967 hex_string_custom (psect
->filepos
, 8));
968 printf_filtered (" is %s", bfd_section_name (psect
));
970 printf_filtered (" in %ps",
971 styled_string (file_name_style
.style (),
972 bfd_get_filename (pbfd
)));
973 printf_filtered ("\n");
978 exec_target::files_info ()
980 if (current_program_space
->exec_bfd ())
981 print_section_info (¤t_program_space
->target_sections (),
982 current_program_space
->exec_bfd ());
984 puts_filtered (_("\t<no file loaded>\n"));
988 set_section_command (const char *args
, int from_tty
)
993 error (_("Must specify section name and its virtual address"));
995 /* Parse out section name. */
996 for (secname
= args
; !isspace (*args
); args
++);
997 unsigned seclen
= args
- secname
;
999 /* Parse out new virtual address. */
1000 CORE_ADDR secaddr
= parse_and_eval_address (args
);
1002 for (target_section
&p
: current_program_space
->target_sections ())
1004 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1005 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1007 long offset
= secaddr
- p
.addr
;
1009 p
.endaddr
+= offset
;
1011 exec_ops
.files_info ();
1016 std::string
secprint (secname
, seclen
);
1017 error (_("Section %s not found"), secprint
.c_str ());
1020 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1024 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1026 for (target_section
&p
: current_program_space
->target_sections ())
1028 if (filename_cmp (filename
,
1029 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1030 && index
== p
.the_bfd_section
->index
)
1032 p
.endaddr
+= address
- p
.addr
;
1039 exec_target::has_memory ()
1041 /* We can provide memory if we have any file/target sections to read
1043 return !current_program_space
->target_sections ().empty ();
1046 gdb::unique_xmalloc_ptr
<char>
1047 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1049 error (_("Can't create a corefile"));
1053 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1055 return objfile_find_memory_regions (this, func
, data
);
1058 void _initialize_exec ();
1062 struct cmd_list_element
*c
;
1066 c
= add_cmd ("file", class_files
, file_command
, _("\
1067 Use FILE as program to be debugged.\n\
1068 It is read for its symbols, for getting the contents of pure memory,\n\
1069 and it is the program executed when you use the `run' command.\n\
1070 If FILE cannot be found as specified, your execution directory path\n\
1071 ($PATH) is searched for a command of that name.\n\
1072 No arg means to have no executable file and no symbols."), &cmdlist
);
1073 set_cmd_completer (c
, filename_completer
);
1076 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1077 Use FILE as program for getting contents of pure memory.\n\
1078 If FILE cannot be found as specified, your execution directory path\n\
1079 is searched for a command of that name.\n\
1080 No arg means have no executable file."), &cmdlist
);
1081 set_cmd_completer (c
, filename_completer
);
1083 add_com ("section", class_files
, set_section_command
, _("\
1084 Change the base address of section SECTION of the exec file to ADDR.\n\
1085 This can be used if the exec file does not contain section addresses,\n\
1086 (such as in the a.out format), or when the addresses specified in the\n\
1087 file itself are wrong. Each section must be changed separately. The\n\
1088 ``info files'' command lists all the sections and their addresses."));
1090 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1091 Set writing into executable and core files."), _("\
1092 Show writing into executable and core files."), NULL
,
1095 &setlist
, &showlist
);
1097 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1098 exec_file_mismatch_names
,
1099 &exec_file_mismatch
,
1101 Set exec-file-mismatch handling (ask|warn|off)."),
1103 Show exec-file-mismatch handling (ask|warn|off)."),
1105 Specifies how to handle a mismatch between the current exec-file\n\
1106 loaded by GDB and the exec-file automatically determined when attaching\n\
1108 ask - warn the user and ask whether to load the determined exec-file.\n\
1109 warn - warn the user, but do not change the exec-file.\n\
1110 off - do not check for mismatch.\n\
1112 GDB detects a mismatch by comparing the build IDs of the files.\n\
1113 If the user confirms loading the determined exec-file, then its symbols\n\
1114 will be loaded as well."),
1115 set_exec_file_mismatch_command
,
1116 show_exec_file_mismatch_command
,
1117 &setlist
, &showlist
);
1119 add_target (exec_target_info
, exec_target_open
, filename_completer
);