1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2020 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 target_section_table
*get_section_table () 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
)
106 fprintf_filtered (gdb_stdout
,
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 fprintf_filtered (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 /* Close and clear exec_bfd. If we end up with no target sections to
152 read memory from, this unpushes the exec_ops target. */
159 bfd
*abfd
= exec_bfd
;
161 gdb_bfd_unref (abfd
);
163 /* Removing target sections may close the exec_ops target.
164 Clear exec_bfd before doing so to prevent recursion. */
168 remove_target_sections (&exec_bfd
);
170 current_program_space
->exec_filename
.reset (nullptr);
174 /* This is the target_close implementation. Clears all target
175 sections and closes all executable bfds from all program spaces. */
178 exec_target::close ()
180 scoped_restore_current_program_space restore_pspace
;
182 for (struct program_space
*ss
: program_spaces
)
184 set_current_program_space (ss
);
185 current_target_sections
->clear ();
193 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
194 symfile_add_flags add_flags
)
196 struct gdb_exception prev_err
;
198 /* exec_file_attach and symbol_file_add_main may throw an error if the file
199 cannot be opened either locally or remotely.
201 This happens for example, when the file is first found in the local
202 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
203 exist in the target filesystem, or when the file does exist, but
206 Even without a symbol file, the remote-based debugging session should
207 continue normally instead of ending abruptly. Hence we catch thrown
208 errors/exceptions in the following code. */
211 /* We must do this step even if exec_file_host is NULL, so that
212 exec_file_attach will clear state. */
213 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
215 catch (gdb_exception_error
&err
)
217 if (err
.message
!= NULL
)
218 warning ("%s", err
.what ());
220 prev_err
= std::move (err
);
223 if (exec_file_host
!= NULL
)
227 symbol_file_add_main (exec_file_host
, add_flags
);
229 catch (const gdb_exception_error
&err
)
231 if (!exception_print_same (prev_err
, err
))
232 warning ("%s", err
.what ());
240 validate_exec_file (int from_tty
)
242 /* If user asked to ignore the mismatch, do nothing. */
243 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
246 const char *current_exec_file
= get_exec_file (0);
247 struct inferior
*inf
= current_inferior ();
248 /* Try to determine a filename from the process itself. */
249 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
250 bool build_id_mismatch
= false;
252 /* If we cannot validate the exec file, return. */
253 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
256 /* Try validating via build-id, if available. This is the most
259 /* In case current_exec_file was changed, reopen_exec_file ensures
260 an up to date build_id (will do nothing if the file timestamp
261 did not change). If exec file changed, reopen_exec_file has
262 allocated another file name, so get_exec_file again. */
264 current_exec_file
= get_exec_file (0);
266 const bfd_build_id
*exec_file_build_id
= build_id_bfd_get (exec_bfd
);
267 if (exec_file_build_id
!= nullptr)
269 /* Prepend the target prefix, to force gdb_bfd_open to open the
270 file on the remote file system (if indeed remote). */
271 std::string target_pid_exec_file
272 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
274 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
275 gnutarget
, -1, false));
278 const bfd_build_id
*target_exec_file_build_id
279 = build_id_bfd_get (abfd
.get ());
281 if (target_exec_file_build_id
!= nullptr)
283 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
284 && memcmp (exec_file_build_id
->data
,
285 target_exec_file_build_id
->data
,
286 exec_file_build_id
->size
) == 0)
292 build_id_mismatch
= true;
297 if (build_id_mismatch
)
299 std::string
exec_file_target (pid_exec_file
);
301 /* In case the exec file is not local, exec_file_target has to point at
302 the target file system. */
303 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
304 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
307 (_("Build ID mismatch between current exec-file %ps\n"
308 "and automatically determined exec-file %ps\n"
309 "exec-file-mismatch handling is currently \"%s\""),
310 styled_string (file_name_style
.style (), current_exec_file
),
311 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
312 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
313 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
315 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
318 add_flags
|= SYMFILE_VERBOSE
;
319 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
323 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
324 exec_file_attach (exec_file_target
.c_str (), from_tty
);
326 catch (gdb_exception_error
&err
)
328 warning (_("loading %ps %s"),
329 styled_string (file_name_style
.style (),
330 exec_file_target
.c_str ()),
331 err
.message
!= NULL
? err
.what () : "error");
340 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
342 char *exec_file_target
;
343 symfile_add_flags add_flags
= 0;
345 /* Do nothing if we already have an executable filename. */
346 if (get_exec_file (0) != NULL
)
349 /* Try to determine a filename from the process itself. */
350 exec_file_target
= target_pid_to_exec_file (pid
);
351 if (exec_file_target
== NULL
)
353 warning (_("No executable has been specified and target does not "
355 "determining executable automatically. "
356 "Try using the \"file\" command."));
360 gdb::unique_xmalloc_ptr
<char> exec_file_host
361 = exec_file_find (exec_file_target
, NULL
);
364 add_flags
|= SYMFILE_DEFER_BP_RESET
;
367 add_flags
|= SYMFILE_VERBOSE
;
369 /* Attempt to open the exec file. */
370 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
373 /* Set FILENAME as the new exec file.
375 This function is intended to be behave essentially the same
376 as exec_file_command, except that the latter will detect when
377 a target is being debugged, and will ask the user whether it
378 should be shut down first. (If the answer is "no", then the
379 new file is ignored.)
381 This file is used by exec_file_command, to do the work of opening
382 and processing the exec file after any prompting has happened.
384 And, it is used by child_attach, when the attach command was
385 given a pid but not a exec pathname, and the attach command could
386 figure out the pathname from the pid. (In this case, we shouldn't
387 ask the user whether the current target should be shut down --
388 we're supplying the exec pathname late for good reason.) */
391 exec_file_attach (const char *filename
, int from_tty
)
393 /* First, acquire a reference to the current exec_bfd. We release
394 this at the end of the function; but acquiring it now lets the
395 BFD cache return it if this call refers to the same file. */
396 gdb_bfd_ref_ptr exec_bfd_holder
= gdb_bfd_ref_ptr::new_reference (exec_bfd
);
398 /* Remove any previous exec file. */
401 /* Now open and digest the file the user requested, if any. */
406 printf_unfiltered (_("No executable file now.\n"));
408 set_gdbarch_from_file (NULL
);
412 int load_via_target
= 0;
413 const char *scratch_pathname
, *canonical_pathname
;
417 if (is_target_filename (filename
))
419 if (target_filesystem_is_local ())
420 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
425 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
428 /* gdb_bfd_fopen does not support "target:" filenames. */
430 warning (_("writing into executable files is "
431 "not supported for %s sysroots"),
432 TARGET_SYSROOT_PREFIX
);
434 scratch_pathname
= filename
;
436 canonical_pathname
= scratch_pathname
;
440 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
441 filename
, write_files
?
442 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
444 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
445 if (scratch_chan
< 0)
447 int first_errno
= errno
;
448 char *exename
= (char *) alloca (strlen (filename
) + 5);
450 strcat (strcpy (exename
, filename
), ".exe");
451 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
452 exename
, write_files
?
454 : O_RDONLY
| O_BINARY
,
456 if (scratch_chan
< 0)
460 if (scratch_chan
< 0)
461 perror_with_name (filename
);
463 scratch_pathname
= scratch_storage
.get ();
465 /* gdb_bfd_open (and its variants) prefers canonicalized
466 pathname for better BFD caching. */
467 canonical_storage
= gdb_realpath (scratch_pathname
);
468 canonical_pathname
= canonical_storage
.get ();
471 gdb_bfd_ref_ptr temp
;
472 if (write_files
&& !load_via_target
)
473 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
474 FOPEN_RUB
, scratch_chan
);
476 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
477 exec_bfd
= temp
.release ();
481 error (_("\"%ps\": could not open as an executable file: %s."),
482 styled_string (file_name_style
.style (), scratch_pathname
),
483 bfd_errmsg (bfd_get_error ()));
486 /* gdb_realpath_keepfile resolves symlinks on the local
487 filesystem and so cannot be used for "target:" files. */
488 gdb_assert (current_program_space
->exec_filename
== nullptr);
490 current_program_space
->exec_filename
491 = make_unique_xstrdup (bfd_get_filename (exec_bfd
));
493 current_program_space
->exec_filename
494 = gdb_realpath_keepfile (scratch_pathname
);
496 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
498 /* Make sure to close exec_bfd, or else "run" might try to use
501 error (_("\"%ps\": not in executable format: %s"),
502 styled_string (file_name_style
.style (), scratch_pathname
),
503 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
506 target_section_table sections
= build_section_table (exec_bfd
);
508 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
512 set_gdbarch_from_file (exec_bfd
);
514 /* Add the executable's sections to the current address spaces'
515 list of sections. This possibly pushes the exec_ops
517 add_target_sections (&exec_bfd
, sections
);
519 /* Tell display code (if any) about the changed file name. */
520 if (deprecated_exec_file_display_hook
)
521 (*deprecated_exec_file_display_hook
) (filename
);
524 bfd_cache_close_all ();
525 gdb::observers::executable_changed
.notify ();
528 /* Process the first arg in ARGS as the new exec file.
530 Note that we have to explicitly ignore additional args, since we can
531 be called from file_command(), which also calls symbol_file_command()
532 which can take multiple args.
534 If ARGS is NULL, we just want to close the exec file. */
537 exec_file_command (const char *args
, int from_tty
)
539 if (from_tty
&& target_has_execution ()
540 && !query (_("A program is being debugged already.\n"
541 "Are you sure you want to change the file? ")))
542 error (_("File not changed."));
546 /* Scan through the args and pick up the first non option arg
549 gdb_argv
built_argv (args
);
550 char **argv
= built_argv
.get ();
552 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
556 error (_("No executable file name was specified"));
558 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
559 exec_file_attach (filename
.get (), from_tty
);
562 exec_file_attach (NULL
, from_tty
);
565 /* Set both the exec file and the symbol file, in one command.
566 What a novelty. Why did GDB go through four major releases before this
567 command was added? */
570 file_command (const char *arg
, int from_tty
)
572 /* FIXME, if we lose on reading the symbol file, we should revert
573 the exec file, but that's rough. */
574 exec_file_command (arg
, from_tty
);
575 symbol_file_command (arg
, from_tty
);
576 if (deprecated_file_changed_hook
)
577 deprecated_file_changed_hook (arg
);
581 /* Builds a section table, given args BFD, TABLE. */
584 build_section_table (struct bfd
*some_bfd
)
586 target_section_table table
;
588 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
592 /* Check the section flags, but do not discard zero-length
593 sections, since some symbols may still be attached to this
594 section. For instance, we encountered on sparc-solaris 2.10
595 a shared library with an empty .bss section to which a symbol
596 named "_end" was attached. The address of this symbol still
597 needs to be relocated. */
598 aflag
= bfd_section_flags (asect
);
599 if (!(aflag
& SEC_ALLOC
))
602 table
.emplace_back (bfd_section_vma (asect
),
603 bfd_section_vma (asect
) + bfd_section_size (asect
),
610 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
611 current set of target sections. */
614 add_target_sections (void *owner
,
615 const target_section_table
§ions
)
617 target_section_table
*table
= current_target_sections
;
619 if (!sections
.empty ())
621 for (const target_section
&s
: sections
)
623 table
->push_back (s
);
624 table
->back ().owner
= owner
;
627 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
628 program_space
*curr_pspace
= current_program_space
;
630 /* If these are the first file sections we can provide memory
631 from, push the file_stratum target. Must do this in all
632 inferiors sharing the program space. */
633 for (inferior
*inf
: all_inferiors ())
635 if (inf
->pspace
!= curr_pspace
)
638 if (inf
->target_is_pushed (&exec_ops
))
641 switch_to_inferior_no_thread (inf
);
642 push_target (&exec_ops
);
647 /* Add the sections of OBJFILE to the current set of target sections. */
650 add_target_sections_of_objfile (struct objfile
*objfile
)
652 target_section_table
*table
= current_target_sections
;
653 struct obj_section
*osect
;
655 gdb_assert (objfile
!= nullptr);
657 /* Compute the number of sections to add. */
658 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
660 if (bfd_section_size (osect
->the_bfd_section
) == 0)
663 table
->emplace_back (obj_section_addr (osect
),
664 obj_section_endaddr (osect
),
665 osect
->the_bfd_section
, (void *) objfile
);
669 /* Remove all target sections owned by OWNER.
670 OWNER must be the same value passed to add_target_sections. */
673 remove_target_sections (void *owner
)
675 target_section_table
*table
= current_target_sections
;
677 gdb_assert (owner
!= NULL
);
679 auto it
= std::remove_if (table
->begin (),
681 [&] (target_section
§
)
683 return sect
.owner
== owner
;
685 table
->erase (it
, table
->end ());
687 /* If we don't have any more sections to read memory from,
688 remove the file_stratum target from the stack of each
689 inferior sharing the program space. */
692 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
693 program_space
*curr_pspace
= current_program_space
;
695 for (inferior
*inf
: all_inferiors ())
697 if (inf
->pspace
!= curr_pspace
)
700 if (!inf
->pspace
->target_sections
.empty ())
703 switch_to_inferior_no_thread (inf
);
704 unpush_target (&exec_ops
);
714 if (!current_program_space
->target_sections
.empty ())
715 push_target (&exec_ops
);
720 enum target_xfer_status
721 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
722 ULONGEST len
, ULONGEST
*xfered_len
)
724 /* It's unduly pedantic to refuse to look at the executable for
725 read-only pieces; so do the equivalent of readonly regions aka
727 if (exec_bfd
!= NULL
)
733 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
735 if ((s
->flags
& SEC_LOAD
) == 0
736 || (s
->flags
& SEC_READONLY
) == 0)
740 size
= bfd_section_size (s
);
741 if (vma
<= offset
&& offset
< (vma
+ size
))
745 amt
= (vma
+ size
) - offset
;
749 amt
= bfd_get_section_contents (exec_bfd
, s
,
750 readbuf
, offset
- vma
, amt
);
753 return TARGET_XFER_EOF
;
757 return TARGET_XFER_OK
;
763 /* Indicate failure to find the requested memory block. */
764 return TARGET_XFER_E_IO
;
767 /* Return all read-only memory ranges found in the target section
768 table defined by SECTIONS and SECTIONS_END, starting at (and
769 intersected with) MEMADDR for LEN bytes. */
771 static std::vector
<mem_range
>
772 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
773 const target_section_table
§ions
)
775 std::vector
<mem_range
> memory
;
777 for (const target_section
&p
: sections
)
779 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
782 /* Copy the meta-data, adjusted. */
783 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
785 ULONGEST lo1
, hi1
, lo2
, hi2
;
793 CORE_ADDR start
= std::max (lo1
, lo2
);
794 int length
= std::min (hi1
, hi2
) - start
;
796 memory
.emplace_back (start
, length
);
803 enum target_xfer_status
804 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
805 ULONGEST len
, ULONGEST
*xfered_len
)
807 target_section_table
*table
= target_get_section_table (&exec_ops
);
808 std::vector
<mem_range
> available_memory
809 = section_table_available_memory (offset
, len
, *table
);
811 normalize_mem_ranges (&available_memory
);
813 for (const mem_range
&r
: available_memory
)
815 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
818 enum target_xfer_status status
;
820 /* Get the intersection window. */
821 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
823 gdb_assert (end
- offset
<= len
);
825 if (offset
>= r
.start
)
826 status
= exec_read_partial_read_only (readbuf
, offset
,
831 *xfered_len
= r
.start
- offset
;
832 status
= TARGET_XFER_UNAVAILABLE
;
839 return TARGET_XFER_UNAVAILABLE
;
842 enum target_xfer_status
843 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
844 ULONGEST offset
, ULONGEST len
,
845 ULONGEST
*xfered_len
,
846 const target_section_table
§ions
,
847 gdb::function_view
<bool
848 (const struct target_section
*)> match_cb
)
851 ULONGEST memaddr
= offset
;
852 ULONGEST memend
= memaddr
+ len
;
854 gdb_assert (len
!= 0);
856 for (const target_section
&p
: sections
)
858 struct bfd_section
*asect
= p
.the_bfd_section
;
859 bfd
*abfd
= asect
->owner
;
861 if (match_cb
!= nullptr && !match_cb (&p
))
862 continue; /* not the section we need. */
863 if (memaddr
>= p
.addr
)
865 if (memend
<= p
.endaddr
)
867 /* Entire transfer is within this section. */
869 res
= bfd_set_section_contents (abfd
, asect
,
870 writebuf
, memaddr
- p
.addr
,
873 res
= bfd_get_section_contents (abfd
, asect
,
874 readbuf
, memaddr
- p
.addr
,
880 return TARGET_XFER_OK
;
883 return TARGET_XFER_EOF
;
885 else if (memaddr
>= p
.endaddr
)
887 /* This section ends before the transfer starts. */
892 /* This section overlaps the transfer. Just do half. */
893 len
= p
.endaddr
- memaddr
;
895 res
= bfd_set_section_contents (abfd
, asect
,
896 writebuf
, memaddr
- p
.addr
,
899 res
= bfd_get_section_contents (abfd
, asect
,
900 readbuf
, memaddr
- p
.addr
,
905 return TARGET_XFER_OK
;
908 return TARGET_XFER_EOF
;
913 return TARGET_XFER_EOF
; /* We can't help. */
916 target_section_table
*
917 exec_target::get_section_table ()
919 return current_target_sections
;
922 enum target_xfer_status
923 exec_target::xfer_partial (enum target_object object
,
924 const char *annex
, gdb_byte
*readbuf
,
925 const gdb_byte
*writebuf
,
926 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
928 target_section_table
*table
= get_section_table ();
930 if (object
== TARGET_OBJECT_MEMORY
)
931 return section_table_xfer_memory_partial (readbuf
, writebuf
,
932 offset
, len
, xfered_len
,
935 return TARGET_XFER_E_IO
;
940 print_section_info (target_section_table
*t
, bfd
*abfd
)
942 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
943 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
944 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
946 printf_filtered ("\t`%ps', ",
947 styled_string (file_name_style
.style (),
948 bfd_get_filename (abfd
)));
950 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
951 if (abfd
== exec_bfd
)
953 /* gcc-3.4 does not like the initialization in
954 <p == t->sections_end>. */
955 bfd_vma displacement
= 0;
959 for (const target_section
&p
: *t
)
961 struct bfd_section
*psect
= p
.the_bfd_section
;
963 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
964 != (SEC_ALLOC
| SEC_LOAD
))
967 if (bfd_section_vma (psect
) <= abfd
->start_address
968 && abfd
->start_address
< (bfd_section_vma (psect
)
969 + bfd_section_size (psect
)))
971 displacement
= p
.addr
- bfd_section_vma (psect
);
977 warning (_("Cannot find section for the entry point of %ps."),
978 styled_string (file_name_style
.style (),
979 bfd_get_filename (abfd
)));
981 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
982 bfd_get_start_address (abfd
)
984 printf_filtered (_("\tEntry point: %s\n"),
985 paddress (gdbarch
, entry_point
));
987 for (const target_section
&p
: *t
)
989 struct bfd_section
*psect
= p
.the_bfd_section
;
990 bfd
*pbfd
= psect
->owner
;
992 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
993 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
995 /* FIXME: A format of "08l" is not wide enough for file offsets
996 larger than 4GB. OTOH, making it "016l" isn't desirable either
997 since most output will then be much wider than necessary. It
998 may make sense to test the size of the file and choose the
999 format string accordingly. */
1000 /* FIXME: i18n: Need to rewrite this sentence. */
1002 printf_filtered (" @ %s",
1003 hex_string_custom (psect
->filepos
, 8));
1004 printf_filtered (" is %s", bfd_section_name (psect
));
1006 printf_filtered (" in %ps",
1007 styled_string (file_name_style
.style (),
1008 bfd_get_filename (pbfd
)));
1009 printf_filtered ("\n");
1014 exec_target::files_info ()
1017 print_section_info (current_target_sections
, exec_bfd
);
1019 puts_filtered (_("\t<no file loaded>\n"));
1023 set_section_command (const char *args
, int from_tty
)
1025 const char *secname
;
1027 unsigned long secaddr
;
1032 error (_("Must specify section name and its virtual address"));
1034 /* Parse out section name. */
1035 for (secname
= args
; !isspace (*args
); args
++);
1036 seclen
= args
- secname
;
1038 /* Parse out new virtual address. */
1039 secaddr
= parse_and_eval_address (args
);
1041 for (target_section
&p
: *current_target_sections
)
1043 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1044 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1046 offset
= secaddr
- p
.addr
;
1048 p
.endaddr
+= offset
;
1050 exec_ops
.files_info ();
1054 if (seclen
>= sizeof (secprint
))
1055 seclen
= sizeof (secprint
) - 1;
1056 strncpy (secprint
, secname
, seclen
);
1057 secprint
[seclen
] = '\0';
1058 error (_("Section %s not found"), secprint
);
1061 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1065 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1067 for (target_section
&p
: *current_target_sections
)
1069 if (filename_cmp (filename
,
1070 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1071 && index
== p
.the_bfd_section
->index
)
1073 p
.endaddr
+= address
- p
.addr
;
1080 exec_target::has_memory ()
1082 /* We can provide memory if we have any file/target sections to read
1084 return !current_target_sections
->empty ();
1087 gdb::unique_xmalloc_ptr
<char>
1088 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1090 error (_("Can't create a corefile"));
1094 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1096 return objfile_find_memory_regions (this, func
, data
);
1099 void _initialize_exec ();
1103 struct cmd_list_element
*c
;
1107 c
= add_cmd ("file", class_files
, file_command
, _("\
1108 Use FILE as program to be debugged.\n\
1109 It is read for its symbols, for getting the contents of pure memory,\n\
1110 and it is the program executed when you use the `run' command.\n\
1111 If FILE cannot be found as specified, your execution directory path\n\
1112 ($PATH) is searched for a command of that name.\n\
1113 No arg means to have no executable file and no symbols."), &cmdlist
);
1114 set_cmd_completer (c
, filename_completer
);
1117 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1118 Use FILE as program for getting contents of pure memory.\n\
1119 If FILE cannot be found as specified, your execution directory path\n\
1120 is searched for a command of that name.\n\
1121 No arg means have no executable file."), &cmdlist
);
1122 set_cmd_completer (c
, filename_completer
);
1124 add_com ("section", class_files
, set_section_command
, _("\
1125 Change the base address of section SECTION of the exec file to ADDR.\n\
1126 This can be used if the exec file does not contain section addresses,\n\
1127 (such as in the a.out format), or when the addresses specified in the\n\
1128 file itself are wrong. Each section must be changed separately. The\n\
1129 ``info files'' command lists all the sections and their addresses."));
1131 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1132 Set writing into executable and core files."), _("\
1133 Show writing into executable and core files."), NULL
,
1136 &setlist
, &showlist
);
1138 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1139 exec_file_mismatch_names
,
1140 &exec_file_mismatch
,
1142 Set exec-file-mismatch handling (ask|warn|off)."),
1144 Show exec-file-mismatch handling (ask|warn|off)."),
1146 Specifies how to handle a mismatch between the current exec-file\n\
1147 loaded by GDB and the exec-file automatically determined when attaching\n\
1149 ask - warn the user and ask whether to load the determined exec-file.\n\
1150 warn - warn the user, but do not change the exec-file.\n\
1151 off - do not check for mismatch.\n\
1153 GDB detects a mismatch by comparing the build IDs of the files.\n\
1154 If the user confirms loading the determined exec-file, then its symbols\n\
1155 will be loaded as well."),
1156 set_exec_file_mismatch_command
,
1157 show_exec_file_mismatch_command
,
1158 &setlist
, &showlist
);
1160 add_target (exec_target_info
, exec_target_open
, filename_completer
);