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 struct target_section_table
*get_section_table () override
;
79 void files_info () override
;
81 bool has_memory () override
;
82 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 clear_section_table (current_target_sections
);
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 (_("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
;
318 add_flags
|= SYMFILE_VERBOSE
;
321 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
322 exec_file_attach (exec_file_target
.c_str (), from_tty
);
324 catch (gdb_exception_error
&err
)
326 warning (_("loading %ps %s"),
327 styled_string (file_name_style
.style (),
328 exec_file_target
.c_str ()),
329 err
.message
!= NULL
? err
.what () : "error");
338 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
340 char *exec_file_target
;
341 symfile_add_flags add_flags
= 0;
343 /* Do nothing if we already have an executable filename. */
344 if (get_exec_file (0) != NULL
)
347 /* Try to determine a filename from the process itself. */
348 exec_file_target
= target_pid_to_exec_file (pid
);
349 if (exec_file_target
== NULL
)
351 warning (_("No executable has been specified and target does not "
353 "determining executable automatically. "
354 "Try using the \"file\" command."));
358 gdb::unique_xmalloc_ptr
<char> exec_file_host
359 = exec_file_find (exec_file_target
, NULL
);
362 add_flags
|= SYMFILE_DEFER_BP_RESET
;
365 add_flags
|= SYMFILE_VERBOSE
;
367 /* Attempt to open the exec file. */
368 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
371 /* Set FILENAME as the new exec file.
373 This function is intended to be behave essentially the same
374 as exec_file_command, except that the latter will detect when
375 a target is being debugged, and will ask the user whether it
376 should be shut down first. (If the answer is "no", then the
377 new file is ignored.)
379 This file is used by exec_file_command, to do the work of opening
380 and processing the exec file after any prompting has happened.
382 And, it is used by child_attach, when the attach command was
383 given a pid but not a exec pathname, and the attach command could
384 figure out the pathname from the pid. (In this case, we shouldn't
385 ask the user whether the current target should be shut down --
386 we're supplying the exec pathname late for good reason.) */
389 exec_file_attach (const char *filename
, int from_tty
)
391 /* First, acquire a reference to the current exec_bfd. We release
392 this at the end of the function; but acquiring it now lets the
393 BFD cache return it if this call refers to the same file. */
394 gdb_bfd_ref_ptr exec_bfd_holder
= gdb_bfd_ref_ptr::new_reference (exec_bfd
);
396 /* Remove any previous exec file. */
399 /* Now open and digest the file the user requested, if any. */
404 printf_unfiltered (_("No executable file now.\n"));
406 set_gdbarch_from_file (NULL
);
410 int load_via_target
= 0;
411 const char *scratch_pathname
, *canonical_pathname
;
413 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
416 if (is_target_filename (filename
))
418 if (target_filesystem_is_local ())
419 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
424 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
427 /* gdb_bfd_fopen does not support "target:" filenames. */
429 warning (_("writing into executable files is "
430 "not supported for %s sysroots"),
431 TARGET_SYSROOT_PREFIX
);
433 scratch_pathname
= filename
;
435 canonical_pathname
= scratch_pathname
;
439 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
440 filename
, write_files
?
441 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
443 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
444 if (scratch_chan
< 0)
446 int first_errno
= errno
;
447 char *exename
= (char *) alloca (strlen (filename
) + 5);
449 strcat (strcpy (exename
, filename
), ".exe");
450 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
451 exename
, write_files
?
453 : O_RDONLY
| O_BINARY
,
455 if (scratch_chan
< 0)
459 if (scratch_chan
< 0)
460 perror_with_name (filename
);
462 scratch_pathname
= scratch_storage
.get ();
464 /* gdb_bfd_open (and its variants) prefers canonicalized
465 pathname for better BFD caching. */
466 canonical_storage
= gdb_realpath (scratch_pathname
);
467 canonical_pathname
= canonical_storage
.get ();
470 gdb_bfd_ref_ptr temp
;
471 if (write_files
&& !load_via_target
)
472 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
473 FOPEN_RUB
, scratch_chan
);
475 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
476 exec_bfd
= temp
.release ();
480 error (_("\"%ps\": could not open as an executable file: %s."),
481 styled_string (file_name_style
.style (), scratch_pathname
),
482 bfd_errmsg (bfd_get_error ()));
485 /* gdb_realpath_keepfile resolves symlinks on the local
486 filesystem and so cannot be used for "target:" files. */
487 gdb_assert (exec_filename
== NULL
);
489 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
491 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
493 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
495 /* Make sure to close exec_bfd, or else "run" might try to use
498 error (_("\"%ps\": not in executable format: %s"),
499 styled_string (file_name_style
.style (), scratch_pathname
),
500 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
503 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
505 /* Make sure to close exec_bfd, or else "run" might try to use
508 error (_("\"%ps\": can't find the file sections: %s"),
509 styled_string (file_name_style
.style (), scratch_pathname
),
510 bfd_errmsg (bfd_get_error ()));
513 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
517 set_gdbarch_from_file (exec_bfd
);
519 /* Add the executable's sections to the current address spaces'
520 list of sections. This possibly pushes the exec_ops
522 add_target_sections (&exec_bfd
, sections
, sections_end
);
525 /* Tell display code (if any) about the changed file name. */
526 if (deprecated_exec_file_display_hook
)
527 (*deprecated_exec_file_display_hook
) (filename
);
530 bfd_cache_close_all ();
531 gdb::observers::executable_changed
.notify ();
534 /* Process the first arg in ARGS as the new exec file.
536 Note that we have to explicitly ignore additional args, since we can
537 be called from file_command(), which also calls symbol_file_command()
538 which can take multiple args.
540 If ARGS is NULL, we just want to close the exec file. */
543 exec_file_command (const char *args
, int from_tty
)
545 if (from_tty
&& target_has_execution
546 && !query (_("A program is being debugged already.\n"
547 "Are you sure you want to change the file? ")))
548 error (_("File not changed."));
552 /* Scan through the args and pick up the first non option arg
555 gdb_argv
built_argv (args
);
556 char **argv
= built_argv
.get ();
558 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
562 error (_("No executable file name was specified"));
564 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
565 exec_file_attach (filename
.get (), from_tty
);
568 exec_file_attach (NULL
, from_tty
);
571 /* Set both the exec file and the symbol file, in one command.
572 What a novelty. Why did GDB go through four major releases before this
573 command was added? */
576 file_command (const char *arg
, int from_tty
)
578 /* FIXME, if we lose on reading the symbol file, we should revert
579 the exec file, but that's rough. */
580 exec_file_command (arg
, from_tty
);
581 symbol_file_command (arg
, from_tty
);
582 if (deprecated_file_changed_hook
)
583 deprecated_file_changed_hook (arg
);
587 /* Locate all mappable sections of a BFD file.
588 table_pp_char is a char * to get it through bfd_map_over_sections;
589 we cast it back to its proper type. */
592 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
595 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
598 gdb_assert (abfd
== asect
->owner
);
600 /* Check the section flags, but do not discard zero-length sections, since
601 some symbols may still be attached to this section. For instance, we
602 encountered on sparc-solaris 2.10 a shared library with an empty .bss
603 section to which a symbol named "_end" was attached. The address
604 of this symbol still needs to be relocated. */
605 aflag
= bfd_section_flags (asect
);
606 if (!(aflag
& SEC_ALLOC
))
609 (*table_pp
)->owner
= NULL
;
610 (*table_pp
)->the_bfd_section
= asect
;
611 (*table_pp
)->addr
= bfd_section_vma (asect
);
612 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (asect
);
619 clear_section_table (struct target_section_table
*table
)
621 xfree (table
->sections
);
622 table
->sections
= table
->sections_end
= NULL
;
625 /* Resize section table TABLE by ADJUSTMENT.
626 ADJUSTMENT may be negative, in which case the caller must have already
627 removed the sections being deleted.
628 Returns the old size. */
631 resize_section_table (struct target_section_table
*table
, int adjustment
)
636 old_count
= table
->sections_end
- table
->sections
;
638 new_count
= adjustment
+ old_count
;
642 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
644 table
->sections_end
= table
->sections
+ new_count
;
647 clear_section_table (table
);
652 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
653 Returns 0 if OK, 1 on error. */
656 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
657 struct target_section
**end
)
661 count
= bfd_count_sections (some_bfd
);
663 *start
= XNEWVEC (struct target_section
, count
);
665 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
667 gdb_assert (*end
<= *start
+ count
);
669 /* We could realloc the table, but it probably loses for most files. */
673 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
674 current set of target sections. */
677 add_target_sections (void *owner
,
678 struct target_section
*sections
,
679 struct target_section
*sections_end
)
682 struct target_section_table
*table
= current_target_sections
;
684 count
= sections_end
- sections
;
688 int space
= resize_section_table (table
, count
);
691 for (i
= 0; i
< count
; ++i
)
693 table
->sections
[space
+ i
] = sections
[i
];
694 table
->sections
[space
+ i
].owner
= owner
;
697 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
698 program_space
*curr_pspace
= current_program_space
;
700 /* If these are the first file sections we can provide memory
701 from, push the file_stratum target. Must do this in all
702 inferiors sharing the program space. */
703 for (inferior
*inf
: all_inferiors ())
705 if (inf
->pspace
!= curr_pspace
)
708 if (inf
->target_is_pushed (&exec_ops
))
711 switch_to_inferior_no_thread (inf
);
712 push_target (&exec_ops
);
717 /* Add the sections of OBJFILE to the current set of target sections. */
720 add_target_sections_of_objfile (struct objfile
*objfile
)
722 struct target_section_table
*table
= current_target_sections
;
723 struct obj_section
*osect
;
726 struct target_section
*ts
;
731 /* Compute the number of sections to add. */
732 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
734 if (bfd_section_size (osect
->the_bfd_section
) == 0)
742 space
= resize_section_table (table
, count
);
744 ts
= table
->sections
+ space
;
746 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
748 if (bfd_section_size (osect
->the_bfd_section
) == 0)
751 gdb_assert (ts
< table
->sections
+ space
+ count
);
753 ts
->addr
= obj_section_addr (osect
);
754 ts
->endaddr
= obj_section_endaddr (osect
);
755 ts
->the_bfd_section
= osect
->the_bfd_section
;
756 ts
->owner
= (void *) objfile
;
762 /* Remove all target sections owned by OWNER.
763 OWNER must be the same value passed to add_target_sections. */
766 remove_target_sections (void *owner
)
768 struct target_section
*src
, *dest
;
769 struct target_section_table
*table
= current_target_sections
;
771 gdb_assert (owner
!= NULL
);
773 dest
= table
->sections
;
774 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
775 if (src
->owner
!= owner
)
777 /* Keep this section. */
783 /* If we've dropped any sections, resize the section table. */
788 old_count
= resize_section_table (table
, dest
- src
);
790 /* If we don't have any more sections to read memory from,
791 remove the file_stratum target from the stack of each
792 inferior sharing the program space. */
793 if (old_count
+ (dest
- src
) == 0)
795 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
796 program_space
*curr_pspace
= current_program_space
;
798 for (inferior
*inf
: all_inferiors ())
800 if (inf
->pspace
!= curr_pspace
)
803 if (inf
->pspace
->target_sections
.sections
804 != inf
->pspace
->target_sections
.sections_end
)
807 switch_to_inferior_no_thread (inf
);
808 unpush_target (&exec_ops
);
819 if (current_program_space
->target_sections
.sections
820 != current_program_space
->target_sections
.sections_end
)
821 push_target (&exec_ops
);
826 enum target_xfer_status
827 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
828 ULONGEST len
, ULONGEST
*xfered_len
)
830 /* It's unduly pedantic to refuse to look at the executable for
831 read-only pieces; so do the equivalent of readonly regions aka
833 if (exec_bfd
!= NULL
)
839 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
841 if ((s
->flags
& SEC_LOAD
) == 0
842 || (s
->flags
& SEC_READONLY
) == 0)
846 size
= bfd_section_size (s
);
847 if (vma
<= offset
&& offset
< (vma
+ size
))
851 amt
= (vma
+ size
) - offset
;
855 amt
= bfd_get_section_contents (exec_bfd
, s
,
856 readbuf
, offset
- vma
, amt
);
859 return TARGET_XFER_EOF
;
863 return TARGET_XFER_OK
;
869 /* Indicate failure to find the requested memory block. */
870 return TARGET_XFER_E_IO
;
873 /* Return all read-only memory ranges found in the target section
874 table defined by SECTIONS and SECTIONS_END, starting at (and
875 intersected with) MEMADDR for LEN bytes. */
877 static std::vector
<mem_range
>
878 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
879 struct target_section
*sections
,
880 struct target_section
*sections_end
)
882 std::vector
<mem_range
> memory
;
884 for (target_section
*p
= sections
; p
< sections_end
; p
++)
886 if ((bfd_section_flags (p
->the_bfd_section
) & SEC_READONLY
) == 0)
889 /* Copy the meta-data, adjusted. */
890 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
892 ULONGEST lo1
, hi1
, lo2
, hi2
;
900 CORE_ADDR start
= std::max (lo1
, lo2
);
901 int length
= std::min (hi1
, hi2
) - start
;
903 memory
.emplace_back (start
, length
);
910 enum target_xfer_status
911 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
912 ULONGEST len
, ULONGEST
*xfered_len
)
914 target_section_table
*table
= target_get_section_table (&exec_ops
);
915 std::vector
<mem_range
> available_memory
916 = section_table_available_memory (offset
, len
,
917 table
->sections
, table
->sections_end
);
919 normalize_mem_ranges (&available_memory
);
921 for (const mem_range
&r
: available_memory
)
923 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
926 enum target_xfer_status status
;
928 /* Get the intersection window. */
929 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
931 gdb_assert (end
- offset
<= len
);
933 if (offset
>= r
.start
)
934 status
= exec_read_partial_read_only (readbuf
, offset
,
939 *xfered_len
= r
.start
- offset
;
940 status
= TARGET_XFER_UNAVAILABLE
;
947 return TARGET_XFER_UNAVAILABLE
;
950 enum target_xfer_status
951 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
952 ULONGEST offset
, ULONGEST len
,
953 ULONGEST
*xfered_len
,
954 struct target_section
*sections
,
955 struct target_section
*sections_end
,
956 const char *section_name
)
959 struct target_section
*p
;
960 ULONGEST memaddr
= offset
;
961 ULONGEST memend
= memaddr
+ len
;
963 gdb_assert (len
!= 0);
965 for (p
= sections
; p
< sections_end
; p
++)
967 struct bfd_section
*asect
= p
->the_bfd_section
;
968 bfd
*abfd
= asect
->owner
;
970 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
971 continue; /* not the section we need. */
972 if (memaddr
>= p
->addr
)
974 if (memend
<= p
->endaddr
)
976 /* Entire transfer is within this section. */
978 res
= bfd_set_section_contents (abfd
, asect
,
979 writebuf
, memaddr
- p
->addr
,
982 res
= bfd_get_section_contents (abfd
, asect
,
983 readbuf
, memaddr
- p
->addr
,
989 return TARGET_XFER_OK
;
992 return TARGET_XFER_EOF
;
994 else if (memaddr
>= p
->endaddr
)
996 /* This section ends before the transfer starts. */
1001 /* This section overlaps the transfer. Just do half. */
1002 len
= p
->endaddr
- memaddr
;
1004 res
= bfd_set_section_contents (abfd
, asect
,
1005 writebuf
, memaddr
- p
->addr
,
1008 res
= bfd_get_section_contents (abfd
, asect
,
1009 readbuf
, memaddr
- p
->addr
,
1014 return TARGET_XFER_OK
;
1017 return TARGET_XFER_EOF
;
1022 return TARGET_XFER_EOF
; /* We can't help. */
1025 struct target_section_table
*
1026 exec_target::get_section_table ()
1028 return current_target_sections
;
1031 enum target_xfer_status
1032 exec_target::xfer_partial (enum target_object object
,
1033 const char *annex
, gdb_byte
*readbuf
,
1034 const gdb_byte
*writebuf
,
1035 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1037 struct target_section_table
*table
= get_section_table ();
1039 if (object
== TARGET_OBJECT_MEMORY
)
1040 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1041 offset
, len
, xfered_len
,
1043 table
->sections_end
,
1046 return TARGET_XFER_E_IO
;
1051 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
1053 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
1054 struct target_section
*p
;
1055 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
1056 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
1058 printf_filtered ("\t`%ps', ",
1059 styled_string (file_name_style
.style (),
1060 bfd_get_filename (abfd
)));
1062 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
1063 if (abfd
== exec_bfd
)
1065 /* gcc-3.4 does not like the initialization in
1066 <p == t->sections_end>. */
1067 bfd_vma displacement
= 0;
1068 bfd_vma entry_point
;
1070 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1072 struct bfd_section
*psect
= p
->the_bfd_section
;
1074 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
1075 != (SEC_ALLOC
| SEC_LOAD
))
1078 if (bfd_section_vma (psect
) <= abfd
->start_address
1079 && abfd
->start_address
< (bfd_section_vma (psect
)
1080 + bfd_section_size (psect
)))
1082 displacement
= p
->addr
- bfd_section_vma (psect
);
1086 if (p
== t
->sections_end
)
1087 warning (_("Cannot find section for the entry point of %ps."),
1088 styled_string (file_name_style
.style (),
1089 bfd_get_filename (abfd
)));
1091 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
1092 bfd_get_start_address (abfd
)
1094 printf_filtered (_("\tEntry point: %s\n"),
1095 paddress (gdbarch
, entry_point
));
1097 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1099 struct bfd_section
*psect
= p
->the_bfd_section
;
1100 bfd
*pbfd
= psect
->owner
;
1102 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
1103 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
1105 /* FIXME: A format of "08l" is not wide enough for file offsets
1106 larger than 4GB. OTOH, making it "016l" isn't desirable either
1107 since most output will then be much wider than necessary. It
1108 may make sense to test the size of the file and choose the
1109 format string accordingly. */
1110 /* FIXME: i18n: Need to rewrite this sentence. */
1112 printf_filtered (" @ %s",
1113 hex_string_custom (psect
->filepos
, 8));
1114 printf_filtered (" is %s", bfd_section_name (psect
));
1116 printf_filtered (" in %ps",
1117 styled_string (file_name_style
.style (),
1118 bfd_get_filename (pbfd
)));
1119 printf_filtered ("\n");
1124 exec_target::files_info ()
1127 print_section_info (current_target_sections
, exec_bfd
);
1129 puts_filtered (_("\t<no file loaded>\n"));
1133 set_section_command (const char *args
, int from_tty
)
1135 struct target_section
*p
;
1136 const char *secname
;
1138 unsigned long secaddr
;
1141 struct target_section_table
*table
;
1144 error (_("Must specify section name and its virtual address"));
1146 /* Parse out section name. */
1147 for (secname
= args
; !isspace (*args
); args
++);
1148 seclen
= args
- secname
;
1150 /* Parse out new virtual address. */
1151 secaddr
= parse_and_eval_address (args
);
1153 table
= current_target_sections
;
1154 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1156 if (!strncmp (secname
, bfd_section_name (p
->the_bfd_section
), seclen
)
1157 && bfd_section_name (p
->the_bfd_section
)[seclen
] == '\0')
1159 offset
= secaddr
- p
->addr
;
1161 p
->endaddr
+= offset
;
1163 exec_ops
.files_info ();
1167 if (seclen
>= sizeof (secprint
))
1168 seclen
= sizeof (secprint
) - 1;
1169 strncpy (secprint
, secname
, seclen
);
1170 secprint
[seclen
] = '\0';
1171 error (_("Section %s not found"), secprint
);
1174 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1178 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1180 struct target_section
*p
;
1181 struct target_section_table
*table
;
1183 table
= current_target_sections
;
1184 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1186 if (filename_cmp (filename
,
1187 bfd_get_filename (p
->the_bfd_section
->owner
)) == 0
1188 && index
== p
->the_bfd_section
->index
)
1190 p
->endaddr
+= address
- p
->addr
;
1197 exec_target::has_memory ()
1199 /* We can provide memory if we have any file/target sections to read
1201 return (current_target_sections
->sections
1202 != current_target_sections
->sections_end
);
1206 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1208 error (_("Can't create a corefile"));
1212 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1214 return objfile_find_memory_regions (this, func
, data
);
1217 void _initialize_exec ();
1221 struct cmd_list_element
*c
;
1225 c
= add_cmd ("file", class_files
, file_command
, _("\
1226 Use FILE as program to be debugged.\n\
1227 It is read for its symbols, for getting the contents of pure memory,\n\
1228 and it is the program executed when you use the `run' command.\n\
1229 If FILE cannot be found as specified, your execution directory path\n\
1230 ($PATH) is searched for a command of that name.\n\
1231 No arg means to have no executable file and no symbols."), &cmdlist
);
1232 set_cmd_completer (c
, filename_completer
);
1235 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1236 Use FILE as program for getting contents of pure memory.\n\
1237 If FILE cannot be found as specified, your execution directory path\n\
1238 is searched for a command of that name.\n\
1239 No arg means have no executable file."), &cmdlist
);
1240 set_cmd_completer (c
, filename_completer
);
1242 add_com ("section", class_files
, set_section_command
, _("\
1243 Change the base address of section SECTION of the exec file to ADDR.\n\
1244 This can be used if the exec file does not contain section addresses,\n\
1245 (such as in the a.out format), or when the addresses specified in the\n\
1246 file itself are wrong. Each section must be changed separately. The\n\
1247 ``info files'' command lists all the sections and their addresses."));
1249 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1250 Set writing into executable and core files."), _("\
1251 Show writing into executable and core files."), NULL
,
1254 &setlist
, &showlist
);
1256 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1257 exec_file_mismatch_names
,
1258 &exec_file_mismatch
,
1260 Set exec-file-mismatch handling (ask|warn|off)."),
1262 Show exec-file-mismatch handling (ask|warn|off)."),
1264 Specifies how to handle a mismatch between the current exec-file\n\
1265 loaded by GDB and the exec-file automatically determined when attaching\n\
1267 ask - warn the user and ask whether to load the determined exec-file.\n\
1268 warn - warn the user, but do not change the exec-file.\n\
1269 off - do not check for mismatch."),
1270 set_exec_file_mismatch_command
,
1271 show_exec_file_mismatch_command
,
1272 &setlist
, &showlist
);
1274 add_target (exec_target_info
, exec_target_open
, filename_completer
);