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 /* This is the target_close implementation. Clears all target
152 sections and closes all executable bfds from all program spaces. */
155 exec_target::close ()
157 scoped_restore_current_program_space restore_pspace
;
159 for (struct program_space
*ss
: program_spaces
)
161 set_current_program_space (ss
);
162 ss
->target_sections
.clear ();
170 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
171 symfile_add_flags add_flags
)
173 struct gdb_exception prev_err
;
175 /* exec_file_attach and symbol_file_add_main may throw an error if the file
176 cannot be opened either locally or remotely.
178 This happens for example, when the file is first found in the local
179 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
180 exist in the target filesystem, or when the file does exist, but
183 Even without a symbol file, the remote-based debugging session should
184 continue normally instead of ending abruptly. Hence we catch thrown
185 errors/exceptions in the following code. */
188 /* We must do this step even if exec_file_host is NULL, so that
189 exec_file_attach will clear state. */
190 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
192 catch (gdb_exception_error
&err
)
194 if (err
.message
!= NULL
)
195 warning ("%s", err
.what ());
197 prev_err
= std::move (err
);
200 if (exec_file_host
!= NULL
)
204 symbol_file_add_main (exec_file_host
, add_flags
);
206 catch (const gdb_exception_error
&err
)
208 if (!exception_print_same (prev_err
, err
))
209 warning ("%s", err
.what ());
217 validate_exec_file (int from_tty
)
219 /* If user asked to ignore the mismatch, do nothing. */
220 if (exec_file_mismatch_mode
== exec_file_mismatch_off
)
223 const char *current_exec_file
= get_exec_file (0);
224 struct inferior
*inf
= current_inferior ();
225 /* Try to determine a filename from the process itself. */
226 const char *pid_exec_file
= target_pid_to_exec_file (inf
->pid
);
227 bool build_id_mismatch
= false;
229 /* If we cannot validate the exec file, return. */
230 if (current_exec_file
== NULL
|| pid_exec_file
== NULL
)
233 /* Try validating via build-id, if available. This is the most
236 /* In case current_exec_file was changed, reopen_exec_file ensures
237 an up to date build_id (will do nothing if the file timestamp
238 did not change). If exec file changed, reopen_exec_file has
239 allocated another file name, so get_exec_file again. */
241 current_exec_file
= get_exec_file (0);
243 const bfd_build_id
*exec_file_build_id
244 = build_id_bfd_get (current_program_space
->exec_bfd ());
245 if (exec_file_build_id
!= nullptr)
247 /* Prepend the target prefix, to force gdb_bfd_open to open the
248 file on the remote file system (if indeed remote). */
249 std::string target_pid_exec_file
250 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
252 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
253 gnutarget
, -1, false));
256 const bfd_build_id
*target_exec_file_build_id
257 = build_id_bfd_get (abfd
.get ());
259 if (target_exec_file_build_id
!= nullptr)
261 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
262 && memcmp (exec_file_build_id
->data
,
263 target_exec_file_build_id
->data
,
264 exec_file_build_id
->size
) == 0)
270 build_id_mismatch
= true;
275 if (build_id_mismatch
)
277 std::string
exec_file_target (pid_exec_file
);
279 /* In case the exec file is not local, exec_file_target has to point at
280 the target file system. */
281 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
282 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
285 (_("Build ID mismatch between current exec-file %ps\n"
286 "and automatically determined exec-file %ps\n"
287 "exec-file-mismatch handling is currently \"%s\""),
288 styled_string (file_name_style
.style (), current_exec_file
),
289 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
290 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
291 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
293 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
296 add_flags
|= SYMFILE_VERBOSE
;
297 add_flags
|= SYMFILE_ALWAYS_CONFIRM
;
301 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
302 exec_file_attach (exec_file_target
.c_str (), from_tty
);
304 catch (gdb_exception_error
&err
)
306 warning (_("loading %ps %s"),
307 styled_string (file_name_style
.style (),
308 exec_file_target
.c_str ()),
309 err
.message
!= NULL
? err
.what () : "error");
318 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
320 char *exec_file_target
;
321 symfile_add_flags add_flags
= 0;
323 /* Do nothing if we already have an executable filename. */
324 if (get_exec_file (0) != NULL
)
327 /* Try to determine a filename from the process itself. */
328 exec_file_target
= target_pid_to_exec_file (pid
);
329 if (exec_file_target
== NULL
)
331 warning (_("No executable has been specified and target does not "
333 "determining executable automatically. "
334 "Try using the \"file\" command."));
338 gdb::unique_xmalloc_ptr
<char> exec_file_host
339 = exec_file_find (exec_file_target
, NULL
);
342 add_flags
|= SYMFILE_DEFER_BP_RESET
;
345 add_flags
|= SYMFILE_VERBOSE
;
347 /* Attempt to open the exec file. */
348 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
351 /* Set FILENAME as the new exec file.
353 This function is intended to be behave essentially the same
354 as exec_file_command, except that the latter will detect when
355 a target is being debugged, and will ask the user whether it
356 should be shut down first. (If the answer is "no", then the
357 new file is ignored.)
359 This file is used by exec_file_command, to do the work of opening
360 and processing the exec file after any prompting has happened.
362 And, it is used by child_attach, when the attach command was
363 given a pid but not a exec pathname, and the attach command could
364 figure out the pathname from the pid. (In this case, we shouldn't
365 ask the user whether the current target should be shut down --
366 we're supplying the exec pathname late for good reason.) */
369 exec_file_attach (const char *filename
, int from_tty
)
371 /* First, acquire a reference to the exec_bfd. We release
372 this at the end of the function; but acquiring it now lets the
373 BFD cache return it if this call refers to the same file. */
374 gdb_bfd_ref_ptr exec_bfd_holder
375 = gdb_bfd_ref_ptr::new_reference (current_program_space
->exec_bfd ());
377 /* Remove any previous exec file. */
378 current_program_space
->exec_close ();
380 /* Now open and digest the file the user requested, if any. */
385 printf_unfiltered (_("No executable file now.\n"));
387 set_gdbarch_from_file (NULL
);
391 int load_via_target
= 0;
392 const char *scratch_pathname
, *canonical_pathname
;
396 if (is_target_filename (filename
))
398 if (target_filesystem_is_local ())
399 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
404 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
407 /* gdb_bfd_fopen does not support "target:" filenames. */
409 warning (_("writing into executable files is "
410 "not supported for %s sysroots"),
411 TARGET_SYSROOT_PREFIX
);
413 scratch_pathname
= filename
;
415 canonical_pathname
= scratch_pathname
;
419 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
420 filename
, write_files
?
421 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
423 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
424 if (scratch_chan
< 0)
426 int first_errno
= errno
;
427 char *exename
= (char *) alloca (strlen (filename
) + 5);
429 strcat (strcpy (exename
, filename
), ".exe");
430 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
431 exename
, write_files
?
433 : O_RDONLY
| O_BINARY
,
435 if (scratch_chan
< 0)
439 if (scratch_chan
< 0)
440 perror_with_name (filename
);
442 scratch_pathname
= scratch_storage
.get ();
444 /* gdb_bfd_open (and its variants) prefers canonicalized
445 pathname for better BFD caching. */
446 canonical_storage
= gdb_realpath (scratch_pathname
);
447 canonical_pathname
= canonical_storage
.get ();
450 gdb_bfd_ref_ptr temp
;
451 if (write_files
&& !load_via_target
)
452 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
453 FOPEN_RUB
, scratch_chan
);
455 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
456 current_program_space
->set_exec_bfd (std::move (temp
));
458 if (!current_program_space
->exec_bfd ())
460 error (_("\"%ps\": could not open as an executable file: %s."),
461 styled_string (file_name_style
.style (), scratch_pathname
),
462 bfd_errmsg (bfd_get_error ()));
465 /* gdb_realpath_keepfile resolves symlinks on the local
466 filesystem and so cannot be used for "target:" files. */
467 gdb_assert (current_program_space
->exec_filename
== nullptr);
469 current_program_space
->exec_filename
470 = (make_unique_xstrdup
471 (bfd_get_filename (current_program_space
->exec_bfd ())));
473 current_program_space
->exec_filename
474 = gdb_realpath_keepfile (scratch_pathname
);
476 if (!bfd_check_format_matches (current_program_space
->exec_bfd (),
477 bfd_object
, &matching
))
479 /* Make sure to close exec_bfd, or else "run" might try to use
481 current_program_space
->exec_close ();
482 error (_("\"%ps\": not in executable format: %s"),
483 styled_string (file_name_style
.style (), scratch_pathname
),
484 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
487 target_section_table sections
488 = build_section_table (current_program_space
->exec_bfd ());
490 current_program_space
->ebfd_mtime
491 = bfd_get_mtime (current_program_space
->exec_bfd ());
495 set_gdbarch_from_file (current_program_space
->exec_bfd ());
497 /* Add the executable's sections to the current address spaces'
498 list of sections. This possibly pushes the exec_ops
500 add_target_sections (¤t_program_space
->ebfd
, sections
);
502 /* Tell display code (if any) about the changed file name. */
503 if (deprecated_exec_file_display_hook
)
504 (*deprecated_exec_file_display_hook
) (filename
);
507 bfd_cache_close_all ();
508 gdb::observers::executable_changed
.notify ();
511 /* Process the first arg in ARGS as the new exec file.
513 Note that we have to explicitly ignore additional args, since we can
514 be called from file_command(), which also calls symbol_file_command()
515 which can take multiple args.
517 If ARGS is NULL, we just want to close the exec file. */
520 exec_file_command (const char *args
, int from_tty
)
522 if (from_tty
&& target_has_execution ()
523 && !query (_("A program is being debugged already.\n"
524 "Are you sure you want to change the file? ")))
525 error (_("File not changed."));
529 /* Scan through the args and pick up the first non option arg
532 gdb_argv
built_argv (args
);
533 char **argv
= built_argv
.get ();
535 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
539 error (_("No executable file name was specified"));
541 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
542 exec_file_attach (filename
.get (), from_tty
);
545 exec_file_attach (NULL
, from_tty
);
548 /* Set both the exec file and the symbol file, in one command.
549 What a novelty. Why did GDB go through four major releases before this
550 command was added? */
553 file_command (const char *arg
, int from_tty
)
555 /* FIXME, if we lose on reading the symbol file, we should revert
556 the exec file, but that's rough. */
557 exec_file_command (arg
, from_tty
);
558 symbol_file_command (arg
, from_tty
);
559 if (deprecated_file_changed_hook
)
560 deprecated_file_changed_hook (arg
);
564 /* Builds a section table, given args BFD, TABLE. */
567 build_section_table (struct bfd
*some_bfd
)
569 target_section_table table
;
571 for (asection
*asect
: gdb_bfd_sections (some_bfd
))
575 /* Check the section flags, but do not discard zero-length
576 sections, since some symbols may still be attached to this
577 section. For instance, we encountered on sparc-solaris 2.10
578 a shared library with an empty .bss section to which a symbol
579 named "_end" was attached. The address of this symbol still
580 needs to be relocated. */
581 aflag
= bfd_section_flags (asect
);
582 if (!(aflag
& SEC_ALLOC
))
585 table
.emplace_back (bfd_section_vma (asect
),
586 bfd_section_vma (asect
) + bfd_section_size (asect
),
593 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
594 current set of target sections. */
597 add_target_sections (void *owner
,
598 const target_section_table
§ions
)
600 target_section_table
*table
= ¤t_program_space
->target_sections
;
602 if (!sections
.empty ())
604 for (const target_section
&s
: sections
)
606 table
->push_back (s
);
607 table
->back ().owner
= owner
;
610 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
611 program_space
*curr_pspace
= current_program_space
;
613 /* If these are the first file sections we can provide memory
614 from, push the file_stratum target. Must do this in all
615 inferiors sharing the program space. */
616 for (inferior
*inf
: all_inferiors ())
618 if (inf
->pspace
!= curr_pspace
)
621 if (inf
->target_is_pushed (&exec_ops
))
624 switch_to_inferior_no_thread (inf
);
625 push_target (&exec_ops
);
630 /* Add the sections of OBJFILE to the current set of target sections. */
633 add_target_sections_of_objfile (struct objfile
*objfile
)
635 target_section_table
*table
= ¤t_program_space
->target_sections
;
636 struct obj_section
*osect
;
638 gdb_assert (objfile
!= nullptr);
640 /* Compute the number of sections to add. */
641 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
643 if (bfd_section_size (osect
->the_bfd_section
) == 0)
646 table
->emplace_back (obj_section_addr (osect
),
647 obj_section_endaddr (osect
),
648 osect
->the_bfd_section
, (void *) objfile
);
652 /* Remove all target sections owned by OWNER.
653 OWNER must be the same value passed to add_target_sections. */
656 program_space::remove_target_sections (void *owner
)
658 gdb_assert (owner
!= NULL
);
660 auto it
= std::remove_if (target_sections
.begin (),
661 target_sections
.end (),
662 [&] (target_section
§
)
664 return sect
.owner
== owner
;
666 target_sections
.erase (it
, target_sections
.end ());
668 /* If we don't have any more sections to read memory from,
669 remove the file_stratum target from the stack of each
670 inferior sharing the program space. */
671 if (target_sections
.empty ())
673 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
675 for (inferior
*inf
: all_inferiors ())
677 if (inf
->pspace
!= this)
680 switch_to_inferior_no_thread (inf
);
681 unpush_target (&exec_ops
);
691 if (!current_program_space
->target_sections
.empty ())
692 push_target (&exec_ops
);
697 enum target_xfer_status
698 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
699 ULONGEST len
, ULONGEST
*xfered_len
)
701 /* It's unduly pedantic to refuse to look at the executable for
702 read-only pieces; so do the equivalent of readonly regions aka
704 if (current_program_space
->exec_bfd () != NULL
)
710 for (s
= current_program_space
->exec_bfd ()->sections
; s
; s
= s
->next
)
712 if ((s
->flags
& SEC_LOAD
) == 0
713 || (s
->flags
& SEC_READONLY
) == 0)
717 size
= bfd_section_size (s
);
718 if (vma
<= offset
&& offset
< (vma
+ size
))
722 amt
= (vma
+ size
) - offset
;
726 amt
= bfd_get_section_contents (current_program_space
->exec_bfd (), s
,
727 readbuf
, offset
- vma
, amt
);
730 return TARGET_XFER_EOF
;
734 return TARGET_XFER_OK
;
740 /* Indicate failure to find the requested memory block. */
741 return TARGET_XFER_E_IO
;
744 /* Return all read-only memory ranges found in the target section
745 table defined by SECTIONS and SECTIONS_END, starting at (and
746 intersected with) MEMADDR for LEN bytes. */
748 static std::vector
<mem_range
>
749 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
750 const target_section_table
§ions
)
752 std::vector
<mem_range
> memory
;
754 for (const target_section
&p
: sections
)
756 if ((bfd_section_flags (p
.the_bfd_section
) & SEC_READONLY
) == 0)
759 /* Copy the meta-data, adjusted. */
760 if (mem_ranges_overlap (p
.addr
, p
.endaddr
- p
.addr
, memaddr
, len
))
762 ULONGEST lo1
, hi1
, lo2
, hi2
;
770 CORE_ADDR start
= std::max (lo1
, lo2
);
771 int length
= std::min (hi1
, hi2
) - start
;
773 memory
.emplace_back (start
, length
);
780 enum target_xfer_status
781 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
782 ULONGEST len
, ULONGEST
*xfered_len
)
784 target_section_table
*table
= target_get_section_table (&exec_ops
);
785 std::vector
<mem_range
> available_memory
786 = section_table_available_memory (offset
, len
, *table
);
788 normalize_mem_ranges (&available_memory
);
790 for (const mem_range
&r
: available_memory
)
792 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
795 enum target_xfer_status status
;
797 /* Get the intersection window. */
798 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
800 gdb_assert (end
- offset
<= len
);
802 if (offset
>= r
.start
)
803 status
= exec_read_partial_read_only (readbuf
, offset
,
808 *xfered_len
= r
.start
- offset
;
809 status
= TARGET_XFER_UNAVAILABLE
;
816 return TARGET_XFER_UNAVAILABLE
;
819 enum target_xfer_status
820 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
821 ULONGEST offset
, ULONGEST len
,
822 ULONGEST
*xfered_len
,
823 const target_section_table
§ions
,
824 gdb::function_view
<bool
825 (const struct target_section
*)> match_cb
)
828 ULONGEST memaddr
= offset
;
829 ULONGEST memend
= memaddr
+ len
;
831 gdb_assert (len
!= 0);
833 for (const target_section
&p
: sections
)
835 struct bfd_section
*asect
= p
.the_bfd_section
;
836 bfd
*abfd
= asect
->owner
;
838 if (match_cb
!= nullptr && !match_cb (&p
))
839 continue; /* not the section we need. */
840 if (memaddr
>= p
.addr
)
842 if (memend
<= p
.endaddr
)
844 /* Entire transfer is within this section. */
846 res
= bfd_set_section_contents (abfd
, asect
,
847 writebuf
, memaddr
- p
.addr
,
850 res
= bfd_get_section_contents (abfd
, asect
,
851 readbuf
, memaddr
- p
.addr
,
857 return TARGET_XFER_OK
;
860 return TARGET_XFER_EOF
;
862 else if (memaddr
>= p
.endaddr
)
864 /* This section ends before the transfer starts. */
869 /* This section overlaps the transfer. Just do half. */
870 len
= p
.endaddr
- memaddr
;
872 res
= bfd_set_section_contents (abfd
, asect
,
873 writebuf
, memaddr
- p
.addr
,
876 res
= bfd_get_section_contents (abfd
, asect
,
877 readbuf
, memaddr
- p
.addr
,
882 return TARGET_XFER_OK
;
885 return TARGET_XFER_EOF
;
890 return TARGET_XFER_EOF
; /* We can't help. */
893 target_section_table
*
894 exec_target::get_section_table ()
896 return ¤t_program_space
->target_sections
;
899 enum target_xfer_status
900 exec_target::xfer_partial (enum target_object object
,
901 const char *annex
, gdb_byte
*readbuf
,
902 const gdb_byte
*writebuf
,
903 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
905 target_section_table
*table
= get_section_table ();
907 if (object
== TARGET_OBJECT_MEMORY
)
908 return section_table_xfer_memory_partial (readbuf
, writebuf
,
909 offset
, len
, xfered_len
,
912 return TARGET_XFER_E_IO
;
917 print_section_info (target_section_table
*t
, bfd
*abfd
)
919 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
920 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
921 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
923 printf_filtered ("\t`%ps', ",
924 styled_string (file_name_style
.style (),
925 bfd_get_filename (abfd
)));
927 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
928 if (abfd
== current_program_space
->exec_bfd ())
930 /* gcc-3.4 does not like the initialization in
931 <p == t->sections_end>. */
932 bfd_vma displacement
= 0;
936 for (const target_section
&p
: *t
)
938 struct bfd_section
*psect
= p
.the_bfd_section
;
940 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
941 != (SEC_ALLOC
| SEC_LOAD
))
944 if (bfd_section_vma (psect
) <= abfd
->start_address
945 && abfd
->start_address
< (bfd_section_vma (psect
)
946 + bfd_section_size (psect
)))
948 displacement
= p
.addr
- bfd_section_vma (psect
);
954 warning (_("Cannot find section for the entry point of %ps."),
955 styled_string (file_name_style
.style (),
956 bfd_get_filename (abfd
)));
958 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
959 bfd_get_start_address (abfd
)
961 printf_filtered (_("\tEntry point: %s\n"),
962 paddress (gdbarch
, entry_point
));
964 for (const target_section
&p
: *t
)
966 struct bfd_section
*psect
= p
.the_bfd_section
;
967 bfd
*pbfd
= psect
->owner
;
969 printf_filtered ("\t%s", hex_string_custom (p
.addr
, wid
));
970 printf_filtered (" - %s", hex_string_custom (p
.endaddr
, wid
));
972 /* FIXME: A format of "08l" is not wide enough for file offsets
973 larger than 4GB. OTOH, making it "016l" isn't desirable either
974 since most output will then be much wider than necessary. It
975 may make sense to test the size of the file and choose the
976 format string accordingly. */
977 /* FIXME: i18n: Need to rewrite this sentence. */
979 printf_filtered (" @ %s",
980 hex_string_custom (psect
->filepos
, 8));
981 printf_filtered (" is %s", bfd_section_name (psect
));
983 printf_filtered (" in %ps",
984 styled_string (file_name_style
.style (),
985 bfd_get_filename (pbfd
)));
986 printf_filtered ("\n");
991 exec_target::files_info ()
993 if (current_program_space
->exec_bfd ())
994 print_section_info (¤t_program_space
->target_sections
,
995 current_program_space
->exec_bfd ());
997 puts_filtered (_("\t<no file loaded>\n"));
1001 set_section_command (const char *args
, int from_tty
)
1003 const char *secname
;
1005 unsigned long secaddr
;
1010 error (_("Must specify section name and its virtual address"));
1012 /* Parse out section name. */
1013 for (secname
= args
; !isspace (*args
); args
++);
1014 seclen
= args
- secname
;
1016 /* Parse out new virtual address. */
1017 secaddr
= parse_and_eval_address (args
);
1019 for (target_section
&p
: current_program_space
->target_sections
)
1021 if (!strncmp (secname
, bfd_section_name (p
.the_bfd_section
), seclen
)
1022 && bfd_section_name (p
.the_bfd_section
)[seclen
] == '\0')
1024 offset
= secaddr
- p
.addr
;
1026 p
.endaddr
+= offset
;
1028 exec_ops
.files_info ();
1032 if (seclen
>= sizeof (secprint
))
1033 seclen
= sizeof (secprint
) - 1;
1034 strncpy (secprint
, secname
, seclen
);
1035 secprint
[seclen
] = '\0';
1036 error (_("Section %s not found"), secprint
);
1039 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1043 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1045 for (target_section
&p
: current_program_space
->target_sections
)
1047 if (filename_cmp (filename
,
1048 bfd_get_filename (p
.the_bfd_section
->owner
)) == 0
1049 && index
== p
.the_bfd_section
->index
)
1051 p
.endaddr
+= address
- p
.addr
;
1058 exec_target::has_memory ()
1060 /* We can provide memory if we have any file/target sections to read
1062 return !current_program_space
->target_sections
.empty ();
1065 gdb::unique_xmalloc_ptr
<char>
1066 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1068 error (_("Can't create a corefile"));
1072 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1074 return objfile_find_memory_regions (this, func
, data
);
1077 void _initialize_exec ();
1081 struct cmd_list_element
*c
;
1085 c
= add_cmd ("file", class_files
, file_command
, _("\
1086 Use FILE as program to be debugged.\n\
1087 It is read for its symbols, for getting the contents of pure memory,\n\
1088 and it is the program executed when you use the `run' command.\n\
1089 If FILE cannot be found as specified, your execution directory path\n\
1090 ($PATH) is searched for a command of that name.\n\
1091 No arg means to have no executable file and no symbols."), &cmdlist
);
1092 set_cmd_completer (c
, filename_completer
);
1095 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1096 Use FILE as program for getting contents of pure memory.\n\
1097 If FILE cannot be found as specified, your execution directory path\n\
1098 is searched for a command of that name.\n\
1099 No arg means have no executable file."), &cmdlist
);
1100 set_cmd_completer (c
, filename_completer
);
1102 add_com ("section", class_files
, set_section_command
, _("\
1103 Change the base address of section SECTION of the exec file to ADDR.\n\
1104 This can be used if the exec file does not contain section addresses,\n\
1105 (such as in the a.out format), or when the addresses specified in the\n\
1106 file itself are wrong. Each section must be changed separately. The\n\
1107 ``info files'' command lists all the sections and their addresses."));
1109 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1110 Set writing into executable and core files."), _("\
1111 Show writing into executable and core files."), NULL
,
1114 &setlist
, &showlist
);
1116 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1117 exec_file_mismatch_names
,
1118 &exec_file_mismatch
,
1120 Set exec-file-mismatch handling (ask|warn|off)."),
1122 Show exec-file-mismatch handling (ask|warn|off)."),
1124 Specifies how to handle a mismatch between the current exec-file\n\
1125 loaded by GDB and the exec-file automatically determined when attaching\n\
1127 ask - warn the user and ask whether to load the determined exec-file.\n\
1128 warn - warn the user, but do not change the exec-file.\n\
1129 off - do not check for mismatch.\n\
1131 GDB detects a mismatch by comparing the build IDs of the files.\n\
1132 If the user confirms loading the determined exec-file, then its symbols\n\
1133 will be loaded as well."),
1134 set_exec_file_mismatch_command
,
1135 show_exec_file_mismatch_command
,
1136 &setlist
, &showlist
);
1138 add_target (exec_target_info
, exec_target_open
, filename_completer
);