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
259 const bfd_build_id
*exec_file_build_id
= build_id_bfd_get (exec_bfd
);
260 if (exec_file_build_id
!= nullptr)
262 /* Prepend the target prefix, to force gdb_bfd_open to open the
263 file on the remote file system (if indeed remote). */
264 std::string target_pid_exec_file
265 = std::string (TARGET_SYSROOT_PREFIX
) + pid_exec_file
;
267 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (target_pid_exec_file
.c_str (),
268 gnutarget
, -1, false));
271 const bfd_build_id
*target_exec_file_build_id
272 = build_id_bfd_get (abfd
.get ());
274 if (target_exec_file_build_id
!= nullptr)
276 if (exec_file_build_id
->size
== target_exec_file_build_id
->size
277 && memcmp (exec_file_build_id
->data
,
278 target_exec_file_build_id
->data
,
279 exec_file_build_id
->size
) == 0)
285 build_id_mismatch
= true;
290 if (build_id_mismatch
)
292 std::string
exec_file_target (pid_exec_file
);
294 /* In case the exec file is not local, exec_file_target has to point at
295 the target file system. */
296 if (is_target_filename (current_exec_file
) && !target_filesystem_is_local ())
297 exec_file_target
= TARGET_SYSROOT_PREFIX
+ exec_file_target
;
300 (_("Mismatch between current exec-file %ps\n"
301 "and automatically determined exec-file %ps\n"
302 "exec-file-mismatch handling is currently \"%s\""),
303 styled_string (file_name_style
.style (), current_exec_file
),
304 styled_string (file_name_style
.style (), exec_file_target
.c_str ()),
305 exec_file_mismatch_names
[exec_file_mismatch_mode
]);
306 if (exec_file_mismatch_mode
== exec_file_mismatch_ask
)
308 symfile_add_flags add_flags
= SYMFILE_MAINLINE
;
310 add_flags
|= SYMFILE_VERBOSE
;
313 symbol_file_add_main (exec_file_target
.c_str (), add_flags
);
314 exec_file_attach (exec_file_target
.c_str (), from_tty
);
316 catch (gdb_exception_error
&err
)
318 warning (_("loading %ps %s"),
319 styled_string (file_name_style
.style (),
320 exec_file_target
.c_str ()),
321 err
.message
!= NULL
? err
.what () : "error");
330 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
332 char *exec_file_target
;
333 symfile_add_flags add_flags
= 0;
335 /* Do nothing if we already have an executable filename. */
336 if (get_exec_file (0) != NULL
)
339 /* Try to determine a filename from the process itself. */
340 exec_file_target
= target_pid_to_exec_file (pid
);
341 if (exec_file_target
== NULL
)
343 warning (_("No executable has been specified and target does not "
345 "determining executable automatically. "
346 "Try using the \"file\" command."));
350 gdb::unique_xmalloc_ptr
<char> exec_file_host
351 = exec_file_find (exec_file_target
, NULL
);
354 add_flags
|= SYMFILE_DEFER_BP_RESET
;
357 add_flags
|= SYMFILE_VERBOSE
;
359 /* Attempt to open the exec file. */
360 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
363 /* Set FILENAME as the new exec file.
365 This function is intended to be behave essentially the same
366 as exec_file_command, except that the latter will detect when
367 a target is being debugged, and will ask the user whether it
368 should be shut down first. (If the answer is "no", then the
369 new file is ignored.)
371 This file is used by exec_file_command, to do the work of opening
372 and processing the exec file after any prompting has happened.
374 And, it is used by child_attach, when the attach command was
375 given a pid but not a exec pathname, and the attach command could
376 figure out the pathname from the pid. (In this case, we shouldn't
377 ask the user whether the current target should be shut down --
378 we're supplying the exec pathname late for good reason.) */
381 exec_file_attach (const char *filename
, int from_tty
)
383 /* First, acquire a reference to the current exec_bfd. We release
384 this at the end of the function; but acquiring it now lets the
385 BFD cache return it if this call refers to the same file. */
386 gdb_bfd_ref_ptr exec_bfd_holder
= gdb_bfd_ref_ptr::new_reference (exec_bfd
);
388 /* Remove any previous exec file. */
391 /* Now open and digest the file the user requested, if any. */
396 printf_unfiltered (_("No executable file now.\n"));
398 set_gdbarch_from_file (NULL
);
402 int load_via_target
= 0;
403 const char *scratch_pathname
, *canonical_pathname
;
405 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
408 if (is_target_filename (filename
))
410 if (target_filesystem_is_local ())
411 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
416 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
419 /* gdb_bfd_fopen does not support "target:" filenames. */
421 warning (_("writing into executable files is "
422 "not supported for %s sysroots"),
423 TARGET_SYSROOT_PREFIX
);
425 scratch_pathname
= filename
;
427 canonical_pathname
= scratch_pathname
;
431 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
432 filename
, write_files
?
433 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
435 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
436 if (scratch_chan
< 0)
438 int first_errno
= errno
;
439 char *exename
= (char *) alloca (strlen (filename
) + 5);
441 strcat (strcpy (exename
, filename
), ".exe");
442 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
443 exename
, write_files
?
445 : O_RDONLY
| O_BINARY
,
447 if (scratch_chan
< 0)
451 if (scratch_chan
< 0)
452 perror_with_name (filename
);
454 scratch_pathname
= scratch_storage
.get ();
456 /* gdb_bfd_open (and its variants) prefers canonicalized
457 pathname for better BFD caching. */
458 canonical_storage
= gdb_realpath (scratch_pathname
);
459 canonical_pathname
= canonical_storage
.get ();
462 gdb_bfd_ref_ptr temp
;
463 if (write_files
&& !load_via_target
)
464 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
465 FOPEN_RUB
, scratch_chan
);
467 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
468 exec_bfd
= temp
.release ();
472 error (_("\"%ps\": could not open as an executable file: %s."),
473 styled_string (file_name_style
.style (), scratch_pathname
),
474 bfd_errmsg (bfd_get_error ()));
477 /* gdb_realpath_keepfile resolves symlinks on the local
478 filesystem and so cannot be used for "target:" files. */
479 gdb_assert (exec_filename
== NULL
);
481 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
483 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
485 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
487 /* Make sure to close exec_bfd, or else "run" might try to use
490 error (_("\"%ps\": not in executable format: %s"),
491 styled_string (file_name_style
.style (), scratch_pathname
),
492 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
495 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
497 /* Make sure to close exec_bfd, or else "run" might try to use
500 error (_("\"%ps\": can't find the file sections: %s"),
501 styled_string (file_name_style
.style (), scratch_pathname
),
502 bfd_errmsg (bfd_get_error ()));
505 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
509 set_gdbarch_from_file (exec_bfd
);
511 /* Add the executable's sections to the current address spaces'
512 list of sections. This possibly pushes the exec_ops
514 add_target_sections (&exec_bfd
, sections
, sections_end
);
517 /* Tell display code (if any) about the changed file name. */
518 if (deprecated_exec_file_display_hook
)
519 (*deprecated_exec_file_display_hook
) (filename
);
522 bfd_cache_close_all ();
523 gdb::observers::executable_changed
.notify ();
526 /* Process the first arg in ARGS as the new exec file.
528 Note that we have to explicitly ignore additional args, since we can
529 be called from file_command(), which also calls symbol_file_command()
530 which can take multiple args.
532 If ARGS is NULL, we just want to close the exec file. */
535 exec_file_command (const char *args
, int from_tty
)
537 if (from_tty
&& target_has_execution
538 && !query (_("A program is being debugged already.\n"
539 "Are you sure you want to change the file? ")))
540 error (_("File not changed."));
544 /* Scan through the args and pick up the first non option arg
547 gdb_argv
built_argv (args
);
548 char **argv
= built_argv
.get ();
550 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
554 error (_("No executable file name was specified"));
556 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
557 exec_file_attach (filename
.get (), from_tty
);
560 exec_file_attach (NULL
, from_tty
);
563 /* Set both the exec file and the symbol file, in one command.
564 What a novelty. Why did GDB go through four major releases before this
565 command was added? */
568 file_command (const char *arg
, int from_tty
)
570 /* FIXME, if we lose on reading the symbol file, we should revert
571 the exec file, but that's rough. */
572 exec_file_command (arg
, from_tty
);
573 symbol_file_command (arg
, from_tty
);
574 if (deprecated_file_changed_hook
)
575 deprecated_file_changed_hook (arg
);
579 /* Locate all mappable sections of a BFD file.
580 table_pp_char is a char * to get it through bfd_map_over_sections;
581 we cast it back to its proper type. */
584 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
587 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
590 gdb_assert (abfd
== asect
->owner
);
592 /* Check the section flags, but do not discard zero-length sections, since
593 some symbols may still be attached to this section. For instance, we
594 encountered on sparc-solaris 2.10 a shared library with an empty .bss
595 section to which a symbol named "_end" was attached. The address
596 of this symbol still needs to be relocated. */
597 aflag
= bfd_section_flags (asect
);
598 if (!(aflag
& SEC_ALLOC
))
601 (*table_pp
)->owner
= NULL
;
602 (*table_pp
)->the_bfd_section
= asect
;
603 (*table_pp
)->addr
= bfd_section_vma (asect
);
604 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (asect
);
611 clear_section_table (struct target_section_table
*table
)
613 xfree (table
->sections
);
614 table
->sections
= table
->sections_end
= NULL
;
617 /* Resize section table TABLE by ADJUSTMENT.
618 ADJUSTMENT may be negative, in which case the caller must have already
619 removed the sections being deleted.
620 Returns the old size. */
623 resize_section_table (struct target_section_table
*table
, int adjustment
)
628 old_count
= table
->sections_end
- table
->sections
;
630 new_count
= adjustment
+ old_count
;
634 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
636 table
->sections_end
= table
->sections
+ new_count
;
639 clear_section_table (table
);
644 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
645 Returns 0 if OK, 1 on error. */
648 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
649 struct target_section
**end
)
653 count
= bfd_count_sections (some_bfd
);
655 *start
= XNEWVEC (struct target_section
, count
);
657 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
659 gdb_assert (*end
<= *start
+ count
);
661 /* We could realloc the table, but it probably loses for most files. */
665 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
666 current set of target sections. */
669 add_target_sections (void *owner
,
670 struct target_section
*sections
,
671 struct target_section
*sections_end
)
674 struct target_section_table
*table
= current_target_sections
;
676 count
= sections_end
- sections
;
680 int space
= resize_section_table (table
, count
);
683 for (i
= 0; i
< count
; ++i
)
685 table
->sections
[space
+ i
] = sections
[i
];
686 table
->sections
[space
+ i
].owner
= owner
;
689 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
690 program_space
*curr_pspace
= current_program_space
;
692 /* If these are the first file sections we can provide memory
693 from, push the file_stratum target. Must do this in all
694 inferiors sharing the program space. */
695 for (inferior
*inf
: all_inferiors ())
697 if (inf
->pspace
!= curr_pspace
)
700 if (inf
->target_is_pushed (&exec_ops
))
703 switch_to_inferior_no_thread (inf
);
704 push_target (&exec_ops
);
709 /* Add the sections of OBJFILE to the current set of target sections. */
712 add_target_sections_of_objfile (struct objfile
*objfile
)
714 struct target_section_table
*table
= current_target_sections
;
715 struct obj_section
*osect
;
718 struct target_section
*ts
;
723 /* Compute the number of sections to add. */
724 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
726 if (bfd_section_size (osect
->the_bfd_section
) == 0)
734 space
= resize_section_table (table
, count
);
736 ts
= table
->sections
+ space
;
738 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
740 if (bfd_section_size (osect
->the_bfd_section
) == 0)
743 gdb_assert (ts
< table
->sections
+ space
+ count
);
745 ts
->addr
= obj_section_addr (osect
);
746 ts
->endaddr
= obj_section_endaddr (osect
);
747 ts
->the_bfd_section
= osect
->the_bfd_section
;
748 ts
->owner
= (void *) objfile
;
754 /* Remove all target sections owned by OWNER.
755 OWNER must be the same value passed to add_target_sections. */
758 remove_target_sections (void *owner
)
760 struct target_section
*src
, *dest
;
761 struct target_section_table
*table
= current_target_sections
;
763 gdb_assert (owner
!= NULL
);
765 dest
= table
->sections
;
766 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
767 if (src
->owner
!= owner
)
769 /* Keep this section. */
775 /* If we've dropped any sections, resize the section table. */
780 old_count
= resize_section_table (table
, dest
- src
);
782 /* If we don't have any more sections to read memory from,
783 remove the file_stratum target from the stack of each
784 inferior sharing the program space. */
785 if (old_count
+ (dest
- src
) == 0)
787 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
788 program_space
*curr_pspace
= current_program_space
;
790 for (inferior
*inf
: all_inferiors ())
792 if (inf
->pspace
!= curr_pspace
)
795 if (inf
->pspace
->target_sections
.sections
796 != inf
->pspace
->target_sections
.sections_end
)
799 switch_to_inferior_no_thread (inf
);
800 unpush_target (&exec_ops
);
811 if (current_program_space
->target_sections
.sections
812 != current_program_space
->target_sections
.sections_end
)
813 push_target (&exec_ops
);
818 enum target_xfer_status
819 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
820 ULONGEST len
, ULONGEST
*xfered_len
)
822 /* It's unduly pedantic to refuse to look at the executable for
823 read-only pieces; so do the equivalent of readonly regions aka
825 if (exec_bfd
!= NULL
)
831 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
833 if ((s
->flags
& SEC_LOAD
) == 0
834 || (s
->flags
& SEC_READONLY
) == 0)
838 size
= bfd_section_size (s
);
839 if (vma
<= offset
&& offset
< (vma
+ size
))
843 amt
= (vma
+ size
) - offset
;
847 amt
= bfd_get_section_contents (exec_bfd
, s
,
848 readbuf
, offset
- vma
, amt
);
851 return TARGET_XFER_EOF
;
855 return TARGET_XFER_OK
;
861 /* Indicate failure to find the requested memory block. */
862 return TARGET_XFER_E_IO
;
865 /* Return all read-only memory ranges found in the target section
866 table defined by SECTIONS and SECTIONS_END, starting at (and
867 intersected with) MEMADDR for LEN bytes. */
869 static std::vector
<mem_range
>
870 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
871 struct target_section
*sections
,
872 struct target_section
*sections_end
)
874 std::vector
<mem_range
> memory
;
876 for (target_section
*p
= sections
; p
< sections_end
; p
++)
878 if ((bfd_section_flags (p
->the_bfd_section
) & SEC_READONLY
) == 0)
881 /* Copy the meta-data, adjusted. */
882 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
884 ULONGEST lo1
, hi1
, lo2
, hi2
;
892 CORE_ADDR start
= std::max (lo1
, lo2
);
893 int length
= std::min (hi1
, hi2
) - start
;
895 memory
.emplace_back (start
, length
);
902 enum target_xfer_status
903 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
904 ULONGEST len
, ULONGEST
*xfered_len
)
906 target_section_table
*table
= target_get_section_table (&exec_ops
);
907 std::vector
<mem_range
> available_memory
908 = section_table_available_memory (offset
, len
,
909 table
->sections
, table
->sections_end
);
911 normalize_mem_ranges (&available_memory
);
913 for (const mem_range
&r
: available_memory
)
915 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
918 enum target_xfer_status status
;
920 /* Get the intersection window. */
921 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
923 gdb_assert (end
- offset
<= len
);
925 if (offset
>= r
.start
)
926 status
= exec_read_partial_read_only (readbuf
, offset
,
931 *xfered_len
= r
.start
- offset
;
932 status
= TARGET_XFER_UNAVAILABLE
;
939 return TARGET_XFER_UNAVAILABLE
;
942 enum target_xfer_status
943 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
944 ULONGEST offset
, ULONGEST len
,
945 ULONGEST
*xfered_len
,
946 struct target_section
*sections
,
947 struct target_section
*sections_end
,
948 const char *section_name
)
951 struct target_section
*p
;
952 ULONGEST memaddr
= offset
;
953 ULONGEST memend
= memaddr
+ len
;
955 gdb_assert (len
!= 0);
957 for (p
= sections
; p
< sections_end
; p
++)
959 struct bfd_section
*asect
= p
->the_bfd_section
;
960 bfd
*abfd
= asect
->owner
;
962 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
963 continue; /* not the section we need. */
964 if (memaddr
>= p
->addr
)
966 if (memend
<= p
->endaddr
)
968 /* Entire transfer is within this section. */
970 res
= bfd_set_section_contents (abfd
, asect
,
971 writebuf
, memaddr
- p
->addr
,
974 res
= bfd_get_section_contents (abfd
, asect
,
975 readbuf
, memaddr
- p
->addr
,
981 return TARGET_XFER_OK
;
984 return TARGET_XFER_EOF
;
986 else if (memaddr
>= p
->endaddr
)
988 /* This section ends before the transfer starts. */
993 /* This section overlaps the transfer. Just do half. */
994 len
= p
->endaddr
- memaddr
;
996 res
= bfd_set_section_contents (abfd
, asect
,
997 writebuf
, memaddr
- p
->addr
,
1000 res
= bfd_get_section_contents (abfd
, asect
,
1001 readbuf
, memaddr
- p
->addr
,
1006 return TARGET_XFER_OK
;
1009 return TARGET_XFER_EOF
;
1014 return TARGET_XFER_EOF
; /* We can't help. */
1017 struct target_section_table
*
1018 exec_target::get_section_table ()
1020 return current_target_sections
;
1023 enum target_xfer_status
1024 exec_target::xfer_partial (enum target_object object
,
1025 const char *annex
, gdb_byte
*readbuf
,
1026 const gdb_byte
*writebuf
,
1027 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1029 struct target_section_table
*table
= get_section_table ();
1031 if (object
== TARGET_OBJECT_MEMORY
)
1032 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1033 offset
, len
, xfered_len
,
1035 table
->sections_end
,
1038 return TARGET_XFER_E_IO
;
1043 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
1045 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
1046 struct target_section
*p
;
1047 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
1048 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
1050 printf_filtered ("\t`%ps', ",
1051 styled_string (file_name_style
.style (),
1052 bfd_get_filename (abfd
)));
1054 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
1055 if (abfd
== exec_bfd
)
1057 /* gcc-3.4 does not like the initialization in
1058 <p == t->sections_end>. */
1059 bfd_vma displacement
= 0;
1060 bfd_vma entry_point
;
1062 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1064 struct bfd_section
*psect
= p
->the_bfd_section
;
1066 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
1067 != (SEC_ALLOC
| SEC_LOAD
))
1070 if (bfd_section_vma (psect
) <= abfd
->start_address
1071 && abfd
->start_address
< (bfd_section_vma (psect
)
1072 + bfd_section_size (psect
)))
1074 displacement
= p
->addr
- bfd_section_vma (psect
);
1078 if (p
== t
->sections_end
)
1079 warning (_("Cannot find section for the entry point of %ps."),
1080 styled_string (file_name_style
.style (),
1081 bfd_get_filename (abfd
)));
1083 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
1084 bfd_get_start_address (abfd
)
1086 printf_filtered (_("\tEntry point: %s\n"),
1087 paddress (gdbarch
, entry_point
));
1089 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1091 struct bfd_section
*psect
= p
->the_bfd_section
;
1092 bfd
*pbfd
= psect
->owner
;
1094 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
1095 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
1097 /* FIXME: A format of "08l" is not wide enough for file offsets
1098 larger than 4GB. OTOH, making it "016l" isn't desirable either
1099 since most output will then be much wider than necessary. It
1100 may make sense to test the size of the file and choose the
1101 format string accordingly. */
1102 /* FIXME: i18n: Need to rewrite this sentence. */
1104 printf_filtered (" @ %s",
1105 hex_string_custom (psect
->filepos
, 8));
1106 printf_filtered (" is %s", bfd_section_name (psect
));
1108 printf_filtered (" in %ps",
1109 styled_string (file_name_style
.style (),
1110 bfd_get_filename (pbfd
)));
1111 printf_filtered ("\n");
1116 exec_target::files_info ()
1119 print_section_info (current_target_sections
, exec_bfd
);
1121 puts_filtered (_("\t<no file loaded>\n"));
1125 set_section_command (const char *args
, int from_tty
)
1127 struct target_section
*p
;
1128 const char *secname
;
1130 unsigned long secaddr
;
1133 struct target_section_table
*table
;
1136 error (_("Must specify section name and its virtual address"));
1138 /* Parse out section name. */
1139 for (secname
= args
; !isspace (*args
); args
++);
1140 seclen
= args
- secname
;
1142 /* Parse out new virtual address. */
1143 secaddr
= parse_and_eval_address (args
);
1145 table
= current_target_sections
;
1146 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1148 if (!strncmp (secname
, bfd_section_name (p
->the_bfd_section
), seclen
)
1149 && bfd_section_name (p
->the_bfd_section
)[seclen
] == '\0')
1151 offset
= secaddr
- p
->addr
;
1153 p
->endaddr
+= offset
;
1155 exec_ops
.files_info ();
1159 if (seclen
>= sizeof (secprint
))
1160 seclen
= sizeof (secprint
) - 1;
1161 strncpy (secprint
, secname
, seclen
);
1162 secprint
[seclen
] = '\0';
1163 error (_("Section %s not found"), secprint
);
1166 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1170 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1172 struct target_section
*p
;
1173 struct target_section_table
*table
;
1175 table
= current_target_sections
;
1176 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1178 if (filename_cmp (filename
,
1179 bfd_get_filename (p
->the_bfd_section
->owner
)) == 0
1180 && index
== p
->the_bfd_section
->index
)
1182 p
->endaddr
+= address
- p
->addr
;
1189 exec_target::has_memory ()
1191 /* We can provide memory if we have any file/target sections to read
1193 return (current_target_sections
->sections
1194 != current_target_sections
->sections_end
);
1198 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1200 error (_("Can't create a corefile"));
1204 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1206 return objfile_find_memory_regions (this, func
, data
);
1209 void _initialize_exec ();
1213 struct cmd_list_element
*c
;
1217 c
= add_cmd ("file", class_files
, file_command
, _("\
1218 Use FILE as program to be debugged.\n\
1219 It is read for its symbols, for getting the contents of pure memory,\n\
1220 and it is the program executed when you use the `run' command.\n\
1221 If FILE cannot be found as specified, your execution directory path\n\
1222 ($PATH) is searched for a command of that name.\n\
1223 No arg means to have no executable file and no symbols."), &cmdlist
);
1224 set_cmd_completer (c
, filename_completer
);
1227 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1228 Use FILE as program for getting contents of pure memory.\n\
1229 If FILE cannot be found as specified, your execution directory path\n\
1230 is searched for a command of that name.\n\
1231 No arg means have no executable file."), &cmdlist
);
1232 set_cmd_completer (c
, filename_completer
);
1234 add_com ("section", class_files
, set_section_command
, _("\
1235 Change the base address of section SECTION of the exec file to ADDR.\n\
1236 This can be used if the exec file does not contain section addresses,\n\
1237 (such as in the a.out format), or when the addresses specified in the\n\
1238 file itself are wrong. Each section must be changed separately. The\n\
1239 ``info files'' command lists all the sections and their addresses."));
1241 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1242 Set writing into executable and core files."), _("\
1243 Show writing into executable and core files."), NULL
,
1246 &setlist
, &showlist
);
1248 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1249 exec_file_mismatch_names
,
1250 &exec_file_mismatch
,
1252 Set exec-file-mismatch handling (ask|warn|off)."),
1254 Show exec-file-mismatch handling (ask|warn|off)."),
1256 Specifies how to handle a mismatch between the current exec-file\n\
1257 loaded by GDB and the exec-file automatically determined when attaching\n\
1259 ask - warn the user and ask whether to load the determined exec-file.\n\
1260 warn - warn the user, but do not change the exec-file.\n\
1261 off - do not check for mismatch."),
1262 set_exec_file_mismatch_command
,
1263 show_exec_file_mismatch_command
,
1264 &setlist
, &showlist
);
1266 add_target (exec_target_info
, exec_target_open
, filename_completer
);