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 xfree (exec_filename
);
171 exec_filename
= NULL
;
175 /* This is the target_close implementation. Clears all target
176 sections and closes all executable bfds from all program spaces. */
179 exec_target::close ()
181 scoped_restore_current_program_space restore_pspace
;
183 for (struct program_space
*ss
: program_spaces
)
185 set_current_program_space (ss
);
186 current_target_sections
->clear ();
194 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
195 symfile_add_flags add_flags
)
197 struct gdb_exception prev_err
;
199 /* exec_file_attach and symbol_file_add_main may throw an error if the file
200 cannot be opened either locally or remotely.
202 This happens for example, when the file is first found in the local
203 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
204 exist in the target filesystem, or when the file does exist, but
207 Even without a symbol file, the remote-based debugging session should
208 continue normally instead of ending abruptly. Hence we catch thrown
209 errors/exceptions in the following code. */
212 /* We must do this step even if exec_file_host is NULL, so that
213 exec_file_attach will clear state. */
214 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
216 catch (gdb_exception_error
&err
)
218 if (err
.message
!= NULL
)
219 warning ("%s", err
.what ());
221 prev_err
= std::move (err
);
224 if (exec_file_host
!= NULL
)
228 symbol_file_add_main (exec_file_host
, add_flags
);
230 catch (const gdb_exception_error
&err
)
232 if (!exception_print_same (prev_err
, err
))
233 warning ("%s", err
.what ());
241 validate_exec_file (int from_tty
)
243 /* If user asked to ignore the mismatch, do nothing. */
244 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
247 const char *current_exec_file
= get_exec_file (0);
248 struct inferior
*inf
= current_inferior ();
249 /* Try to determine a filename from the process itself. */
250 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
251 bool build_id_mismatch
= false;
253 /* If we cannot validate the exec file, return. */
254 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
257 /* Try validating via build-id, if available. This is the most
260 /* In case current_exec_file was changed, reopen_exec_file ensures
261 an up to date build_id (will do nothing if the file timestamp
262 did not change). If exec file changed, reopen_exec_file has
263 allocated another file name, so get_exec_file again. */
265 current_exec_file
= get_exec_file (0);
267 const bfd_build_id
*exec_file_build_id
= build_id_bfd_get (exec_bfd
);
268 if (exec_file_build_id
!= nullptr)
270 /* Prepend the target prefix, to force gdb_bfd_open to open the
271 file on the remote file system (if indeed remote). */
272 std::string target_pid_exec_file
273 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
275 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
276 gnutarget
, -1, false));
279 const bfd_build_id
*target_exec_file_build_id
280 = build_id_bfd_get (abfd
.get ());
282 if (target_exec_file_build_id
!= nullptr)
284 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
285 && memcmp (exec_file_build_id
->data
,
286 target_exec_file_build_id
->data
,
287 exec_file_build_id
->size
) == 0)
293 build_id_mismatch
= true;
298 if (build_id_mismatch
)
300 std::string
exec_file_target (pid_exec_file
);
302 /* In case the exec file is not local, exec_file_target has to point at
303 the target file system. */
304 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
305 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
308 (_("Build ID mismatch between current exec-file %ps\n"
309 "and automatically determined exec-file %ps\n"
310 "exec-file-mismatch handling is currently \"%s\""),
311 styled_string (file_name_style
.style (), current_exec_file
),
312 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
313 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
314 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
316 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
319 add_flags
|= SYMFILE_VERBOSE
;
320 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
324 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
325 exec_file_attach (exec_file_target
.c_str (), from_tty
);
327 catch (gdb_exception_error
&err
)
329 warning (_("loading %ps %s"),
330 styled_string (file_name_style
.style (),
331 exec_file_target
.c_str ()),
332 err
.message
!= NULL
? err
.what () : "error");
341 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
343 char *exec_file_target
;
344 symfile_add_flags add_flags
= 0;
346 /* Do nothing if we already have an executable filename. */
347 if (get_exec_file (0) != NULL
)
350 /* Try to determine a filename from the process itself. */
351 exec_file_target
= target_pid_to_exec_file (pid
);
352 if (exec_file_target
== NULL
)
354 warning (_("No executable has been specified and target does not "
356 "determining executable automatically. "
357 "Try using the \"file\" command."));
361 gdb::unique_xmalloc_ptr
<char> exec_file_host
362 = exec_file_find (exec_file_target
, NULL
);
365 add_flags
|= SYMFILE_DEFER_BP_RESET
;
368 add_flags
|= SYMFILE_VERBOSE
;
370 /* Attempt to open the exec file. */
371 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
374 /* Set FILENAME as the new exec file.
376 This function is intended to be behave essentially the same
377 as exec_file_command, except that the latter will detect when
378 a target is being debugged, and will ask the user whether it
379 should be shut down first. (If the answer is "no", then the
380 new file is ignored.)
382 This file is used by exec_file_command, to do the work of opening
383 and processing the exec file after any prompting has happened.
385 And, it is used by child_attach, when the attach command was
386 given a pid but not a exec pathname, and the attach command could
387 figure out the pathname from the pid. (In this case, we shouldn't
388 ask the user whether the current target should be shut down --
389 we're supplying the exec pathname late for good reason.) */
392 exec_file_attach (const char *filename
, int from_tty
)
394 /* First, acquire a reference to the current exec_bfd. We release
395 this at the end of the function; but acquiring it now lets the
396 BFD cache return it if this call refers to the same file. */
397 gdb_bfd_ref_ptr exec_bfd_holder
= gdb_bfd_ref_ptr::new_reference (exec_bfd
);
399 /* Remove any previous exec file. */
402 /* Now open and digest the file the user requested, if any. */
407 printf_unfiltered (_("No executable file now.\n"));
409 set_gdbarch_from_file (NULL
);
413 int load_via_target
= 0;
414 const char *scratch_pathname
, *canonical_pathname
;
418 if (is_target_filename (filename
))
420 if (target_filesystem_is_local ())
421 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
426 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
429 /* gdb_bfd_fopen does not support "target:" filenames. */
431 warning (_("writing into executable files is "
432 "not supported for %s sysroots"),
433 TARGET_SYSROOT_PREFIX
);
435 scratch_pathname
= filename
;
437 canonical_pathname
= scratch_pathname
;
441 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
442 filename
, write_files
?
443 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
445 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
446 if (scratch_chan
< 0)
448 int first_errno
= errno
;
449 char *exename
= (char *) alloca (strlen (filename
) + 5);
451 strcat (strcpy (exename
, filename
), ".exe");
452 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
453 exename
, write_files
?
455 : O_RDONLY
| O_BINARY
,
457 if (scratch_chan
< 0)
461 if (scratch_chan
< 0)
462 perror_with_name (filename
);
464 scratch_pathname
= scratch_storage
.get ();
466 /* gdb_bfd_open (and its variants) prefers canonicalized
467 pathname for better BFD caching. */
468 canonical_storage
= gdb_realpath (scratch_pathname
);
469 canonical_pathname
= canonical_storage
.get ();
472 gdb_bfd_ref_ptr temp
;
473 if (write_files
&& !load_via_target
)
474 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
475 FOPEN_RUB
, scratch_chan
);
477 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
478 exec_bfd
= temp
.release ();
482 error (_("\"%ps\": could not open as an executable file: %s."),
483 styled_string (file_name_style
.style (), scratch_pathname
),
484 bfd_errmsg (bfd_get_error ()));
487 /* gdb_realpath_keepfile resolves symlinks on the local
488 filesystem and so cannot be used for "target:" files. */
489 gdb_assert (exec_filename
== NULL
);
491 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
493 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
495 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
497 /* Make sure to close exec_bfd, or else "run" might try to use
500 error (_("\"%ps\": not in executable format: %s"),
501 styled_string (file_name_style
.style (), scratch_pathname
),
502 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
505 target_section_table sections
= build_section_table (exec_bfd
);
507 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
511 set_gdbarch_from_file (exec_bfd
);
513 /* Add the executable's sections to the current address spaces'
514 list of sections. This possibly pushes the exec_ops
516 add_target_sections (&exec_bfd
, sections
);
518 /* Tell display code (if any) about the changed file name. */
519 if (deprecated_exec_file_display_hook
)
520 (*deprecated_exec_file_display_hook
) (filename
);
523 bfd_cache_close_all ();
524 gdb::observers::executable_changed
.notify ();
527 /* Process the first arg in ARGS as the new exec file.
529 Note that we have to explicitly ignore additional args, since we can
530 be called from file_command(), which also calls symbol_file_command()
531 which can take multiple args.
533 If ARGS is NULL, we just want to close the exec file. */
536 exec_file_command (const char *args
, int from_tty
)
538 if (from_tty
&& target_has_execution ()
539 && !query (_("A program is being debugged already.\n"
540 "Are you sure you want to change the file? ")))
541 error (_("File not changed."));
545 /* Scan through the args and pick up the first non option arg
548 gdb_argv
built_argv (args
);
549 char **argv
= built_argv
.get ();
551 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
555 error (_("No executable file name was specified"));
557 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
558 exec_file_attach (filename
.get (), from_tty
);
561 exec_file_attach (NULL
, from_tty
);
564 /* Set both the exec file and the symbol file, in one command.
565 What a novelty. Why did GDB go through four major releases before this
566 command was added? */
569 file_command (const char *arg
, int from_tty
)
571 /* FIXME, if we lose on reading the symbol file, we should revert
572 the exec file, but that's rough. */
573 exec_file_command (arg
, from_tty
);
574 symbol_file_command (arg
, from_tty
);
575 if (deprecated_file_changed_hook
)
576 deprecated_file_changed_hook (arg
);
580 /* Builds a section table, given args BFD, TABLE. */
583 build_section_table (struct bfd
*some_bfd
)
585 target_section_table table
;
587 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
591 /* Check the section flags, but do not discard zero-length
592 sections, since some symbols may still be attached to this
593 section. For instance, we encountered on sparc-solaris 2.10
594 a shared library with an empty .bss section to which a symbol
595 named "_end" was attached. The address of this symbol still
596 needs to be relocated. */
597 aflag
= bfd_section_flags (asect
);
598 if (!(aflag
& SEC_ALLOC
))
601 table
.emplace_back ();
602 target_section
§
= table
.back ();
604 sect
.the_bfd_section
= asect
;
605 sect
.addr
= bfd_section_vma (asect
);
606 sect
.endaddr
= sect
.addr
+ bfd_section_size (asect
);
612 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
613 current set of target sections. */
616 add_target_sections (void *owner
,
617 const target_section_table
§ions
)
619 target_section_table
*table
= current_target_sections
;
621 if (!sections
.empty ())
623 for (const target_section
&s
: sections
)
625 table
->push_back (s
);
626 table
->back ().owner
= owner
;
629 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
630 program_space
*curr_pspace
= current_program_space
;
632 /* If these are the first file sections we can provide memory
633 from, push the file_stratum target. Must do this in all
634 inferiors sharing the program space. */
635 for (inferior
*inf
: all_inferiors ())
637 if (inf
->pspace
!= curr_pspace
)
640 if (inf
->target_is_pushed (&exec_ops
))
643 switch_to_inferior_no_thread (inf
);
644 push_target (&exec_ops
);
649 /* Add the sections of OBJFILE to the current set of target sections. */
652 add_target_sections_of_objfile (struct objfile
*objfile
)
654 target_section_table
*table
= current_target_sections
;
655 struct obj_section
*osect
;
657 gdb_assert (objfile
!= nullptr);
659 /* Compute the number of sections to add. */
660 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
662 if (bfd_section_size (osect
->the_bfd_section
) == 0)
665 table
->emplace_back ();
666 target_section
&ts
= table
->back ();
667 ts
.addr
= obj_section_addr (osect
);
668 ts
.endaddr
= obj_section_endaddr (osect
);
669 ts
.the_bfd_section
= osect
->the_bfd_section
;
670 ts
.owner
= (void *) objfile
;
674 /* Remove all target sections owned by OWNER.
675 OWNER must be the same value passed to add_target_sections. */
678 remove_target_sections (void *owner
)
680 target_section_table
*table
= current_target_sections
;
682 gdb_assert (owner
!= NULL
);
684 auto it
= std::remove_if (table
->begin (),
686 [&] (target_section
§
)
688 return sect
.owner
== owner
;
690 table
->erase (it
, table
->end ());
692 /* If we don't have any more sections to read memory from,
693 remove the file_stratum target from the stack of each
694 inferior sharing the program space. */
697 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
698 program_space
*curr_pspace
= current_program_space
;
700 for (inferior
*inf
: all_inferiors ())
702 if (inf
->pspace
!= curr_pspace
)
705 if (!inf
->pspace
->target_sections
.empty ())
708 switch_to_inferior_no_thread (inf
);
709 unpush_target (&exec_ops
);
719 if (!current_program_space
->target_sections
.empty ())
720 push_target (&exec_ops
);
725 enum target_xfer_status
726 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
727 ULONGEST len
, ULONGEST
*xfered_len
)
729 /* It's unduly pedantic to refuse to look at the executable for
730 read-only pieces; so do the equivalent of readonly regions aka
732 if (exec_bfd
!= NULL
)
738 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
740 if ((s
->flags
& SEC_LOAD
) == 0
741 || (s
->flags
& SEC_READONLY
) == 0)
745 size
= bfd_section_size (s
);
746 if (vma
<= offset
&& offset
< (vma
+ size
))
750 amt
= (vma
+ size
) - offset
;
754 amt
= bfd_get_section_contents (exec_bfd
, s
,
755 readbuf
, offset
- vma
, amt
);
758 return TARGET_XFER_EOF
;
762 return TARGET_XFER_OK
;
768 /* Indicate failure to find the requested memory block. */
769 return TARGET_XFER_E_IO
;
772 /* Return all read-only memory ranges found in the target section
773 table defined by SECTIONS and SECTIONS_END, starting at (and
774 intersected with) MEMADDR for LEN bytes. */
776 static std::vector
<mem_range
>
777 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
778 const target_section_table
§ions
)
780 std::vector
<mem_range
> memory
;
782 for (const target_section
&p
: sections
)
784 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
787 /* Copy the meta-data, adjusted. */
788 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
790 ULONGEST lo1
, hi1
, lo2
, hi2
;
798 CORE_ADDR start
= std::max (lo1
, lo2
);
799 int length
= std::min (hi1
, hi2
) - start
;
801 memory
.emplace_back (start
, length
);
808 enum target_xfer_status
809 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
810 ULONGEST len
, ULONGEST
*xfered_len
)
812 target_section_table
*table
= target_get_section_table (&exec_ops
);
813 std::vector
<mem_range
> available_memory
814 = section_table_available_memory (offset
, len
, *table
);
816 normalize_mem_ranges (&available_memory
);
818 for (const mem_range
&r
: available_memory
)
820 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
823 enum target_xfer_status status
;
825 /* Get the intersection window. */
826 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
828 gdb_assert (end
- offset
<= len
);
830 if (offset
>= r
.start
)
831 status
= exec_read_partial_read_only (readbuf
, offset
,
836 *xfered_len
= r
.start
- offset
;
837 status
= TARGET_XFER_UNAVAILABLE
;
844 return TARGET_XFER_UNAVAILABLE
;
847 enum target_xfer_status
848 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
849 ULONGEST offset
, ULONGEST len
,
850 ULONGEST
*xfered_len
,
851 const target_section_table
§ions
,
852 gdb::function_view
<bool
853 (const struct target_section
*)> match_cb
)
856 ULONGEST memaddr
= offset
;
857 ULONGEST memend
= memaddr
+ len
;
859 gdb_assert (len
!= 0);
861 for (const target_section
&p
: sections
)
863 struct bfd_section
*asect
= p
.the_bfd_section
;
864 bfd
*abfd
= asect
->owner
;
866 if (match_cb
!= nullptr && !match_cb (&p
))
867 continue; /* not the section we need. */
868 if (memaddr
>= p
.addr
)
870 if (memend
<= p
.endaddr
)
872 /* Entire transfer is within this section. */
874 res
= bfd_set_section_contents (abfd
, asect
,
875 writebuf
, memaddr
- p
.addr
,
878 res
= bfd_get_section_contents (abfd
, asect
,
879 readbuf
, memaddr
- p
.addr
,
885 return TARGET_XFER_OK
;
888 return TARGET_XFER_EOF
;
890 else if (memaddr
>= p
.endaddr
)
892 /* This section ends before the transfer starts. */
897 /* This section overlaps the transfer. Just do half. */
898 len
= p
.endaddr
- memaddr
;
900 res
= bfd_set_section_contents (abfd
, asect
,
901 writebuf
, memaddr
- p
.addr
,
904 res
= bfd_get_section_contents (abfd
, asect
,
905 readbuf
, memaddr
- p
.addr
,
910 return TARGET_XFER_OK
;
913 return TARGET_XFER_EOF
;
918 return TARGET_XFER_EOF
; /* We can't help. */
921 target_section_table
*
922 exec_target::get_section_table ()
924 return current_target_sections
;
927 enum target_xfer_status
928 exec_target::xfer_partial (enum target_object object
,
929 const char *annex
, gdb_byte
*readbuf
,
930 const gdb_byte
*writebuf
,
931 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
933 target_section_table
*table
= get_section_table ();
935 if (object
== TARGET_OBJECT_MEMORY
)
936 return section_table_xfer_memory_partial (readbuf
, writebuf
,
937 offset
, len
, xfered_len
,
940 return TARGET_XFER_E_IO
;
945 print_section_info (target_section_table
*t
, bfd
*abfd
)
947 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
948 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
949 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
951 printf_filtered ("\t`%ps', ",
952 styled_string (file_name_style
.style (),
953 bfd_get_filename (abfd
)));
955 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
956 if (abfd
== exec_bfd
)
958 /* gcc-3.4 does not like the initialization in
959 <p == t->sections_end>. */
960 bfd_vma displacement
= 0;
964 for (const target_section
&p
: *t
)
966 struct bfd_section
*psect
= p
.the_bfd_section
;
968 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
969 != (SEC_ALLOC
| SEC_LOAD
))
972 if (bfd_section_vma (psect
) <= abfd
->start_address
973 && abfd
->start_address
< (bfd_section_vma (psect
)
974 + bfd_section_size (psect
)))
976 displacement
= p
.addr
- bfd_section_vma (psect
);
982 warning (_("Cannot find section for the entry point of %ps."),
983 styled_string (file_name_style
.style (),
984 bfd_get_filename (abfd
)));
986 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
987 bfd_get_start_address (abfd
)
989 printf_filtered (_("\tEntry point: %s\n"),
990 paddress (gdbarch
, entry_point
));
992 for (const target_section
&p
: *t
)
994 struct bfd_section
*psect
= p
.the_bfd_section
;
995 bfd
*pbfd
= psect
->owner
;
997 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
998 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
1000 /* FIXME: A format of "08l" is not wide enough for file offsets
1001 larger than 4GB. OTOH, making it "016l" isn't desirable either
1002 since most output will then be much wider than necessary. It
1003 may make sense to test the size of the file and choose the
1004 format string accordingly. */
1005 /* FIXME: i18n: Need to rewrite this sentence. */
1007 printf_filtered (" @ %s",
1008 hex_string_custom (psect
->filepos
, 8));
1009 printf_filtered (" is %s", bfd_section_name (psect
));
1011 printf_filtered (" in %ps",
1012 styled_string (file_name_style
.style (),
1013 bfd_get_filename (pbfd
)));
1014 printf_filtered ("\n");
1019 exec_target::files_info ()
1022 print_section_info (current_target_sections
, exec_bfd
);
1024 puts_filtered (_("\t<no file loaded>\n"));
1028 set_section_command (const char *args
, int from_tty
)
1030 const char *secname
;
1032 unsigned long secaddr
;
1037 error (_("Must specify section name and its virtual address"));
1039 /* Parse out section name. */
1040 for (secname
= args
; !isspace (*args
); args
++);
1041 seclen
= args
- secname
;
1043 /* Parse out new virtual address. */
1044 secaddr
= parse_and_eval_address (args
);
1046 for (target_section
&p
: *current_target_sections
)
1048 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1049 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1051 offset
= secaddr
- p
.addr
;
1053 p
.endaddr
+= offset
;
1055 exec_ops
.files_info ();
1059 if (seclen
>= sizeof (secprint
))
1060 seclen
= sizeof (secprint
) - 1;
1061 strncpy (secprint
, secname
, seclen
);
1062 secprint
[seclen
] = '\0';
1063 error (_("Section %s not found"), secprint
);
1066 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1070 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1072 for (target_section
&p
: *current_target_sections
)
1074 if (filename_cmp (filename
,
1075 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1076 && index
== p
.the_bfd_section
->index
)
1078 p
.endaddr
+= address
- p
.addr
;
1085 exec_target::has_memory ()
1087 /* We can provide memory if we have any file/target sections to read
1089 return !current_target_sections
->empty ();
1092 gdb::unique_xmalloc_ptr
<char>
1093 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1095 error (_("Can't create a corefile"));
1099 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1101 return objfile_find_memory_regions (this, func
, data
);
1104 void _initialize_exec ();
1108 struct cmd_list_element
*c
;
1112 c
= add_cmd ("file", class_files
, file_command
, _("\
1113 Use FILE as program to be debugged.\n\
1114 It is read for its symbols, for getting the contents of pure memory,\n\
1115 and it is the program executed when you use the `run' command.\n\
1116 If FILE cannot be found as specified, your execution directory path\n\
1117 ($PATH) is searched for a command of that name.\n\
1118 No arg means to have no executable file and no symbols."), &cmdlist
);
1119 set_cmd_completer (c
, filename_completer
);
1122 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1123 Use FILE as program for getting contents of pure memory.\n\
1124 If FILE cannot be found as specified, your execution directory path\n\
1125 is searched for a command of that name.\n\
1126 No arg means have no executable file."), &cmdlist
);
1127 set_cmd_completer (c
, filename_completer
);
1129 add_com ("section", class_files
, set_section_command
, _("\
1130 Change the base address of section SECTION of the exec file to ADDR.\n\
1131 This can be used if the exec file does not contain section addresses,\n\
1132 (such as in the a.out format), or when the addresses specified in the\n\
1133 file itself are wrong. Each section must be changed separately. The\n\
1134 ``info files'' command lists all the sections and their addresses."));
1136 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1137 Set writing into executable and core files."), _("\
1138 Show writing into executable and core files."), NULL
,
1141 &setlist
, &showlist
);
1143 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1144 exec_file_mismatch_names
,
1145 &exec_file_mismatch
,
1147 Set exec-file-mismatch handling (ask|warn|off)."),
1149 Show exec-file-mismatch handling (ask|warn|off)."),
1151 Specifies how to handle a mismatch between the current exec-file\n\
1152 loaded by GDB and the exec-file automatically determined when attaching\n\
1154 ask - warn the user and ask whether to load the determined exec-file.\n\
1155 warn - warn the user, but do not change the exec-file.\n\
1156 off - do not check for mismatch.\n\
1158 GDB detects a mismatch by comparing the build IDs of the files.\n\
1159 If the user confirms loading the determined exec-file, then its symbols\n\
1160 will be loaded as well."),
1161 set_exec_file_mismatch_command
,
1162 show_exec_file_mismatch_command
,
1163 &setlist
, &showlist
);
1165 add_target (exec_target_info
, exec_target_open
, filename_completer
);