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 char *exename
= (char *) alloca (strlen (filename
) + 5);
440 strcat (strcpy (exename
, filename
), ".exe");
441 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
442 exename
, write_files
?
444 : O_RDONLY
| O_BINARY
,
448 if (scratch_chan
< 0)
449 perror_with_name (filename
);
451 scratch_pathname
= scratch_storage
.get ();
453 /* gdb_bfd_open (and its variants) prefers canonicalized
454 pathname for better BFD caching. */
455 canonical_storage
= gdb_realpath (scratch_pathname
);
456 canonical_pathname
= canonical_storage
.get ();
459 gdb_bfd_ref_ptr temp
;
460 if (write_files
&& !load_via_target
)
461 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
462 FOPEN_RUB
, scratch_chan
);
464 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
465 exec_bfd
= temp
.release ();
469 error (_("\"%ps\": could not open as an executable file: %s."),
470 styled_string (file_name_style
.style (), scratch_pathname
),
471 bfd_errmsg (bfd_get_error ()));
474 /* gdb_realpath_keepfile resolves symlinks on the local
475 filesystem and so cannot be used for "target:" files. */
476 gdb_assert (exec_filename
== NULL
);
478 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
480 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
482 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
484 /* Make sure to close exec_bfd, or else "run" might try to use
487 error (_("\"%ps\": not in executable format: %s"),
488 styled_string (file_name_style
.style (), scratch_pathname
),
489 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
492 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
494 /* Make sure to close exec_bfd, or else "run" might try to use
497 error (_("\"%ps\": can't find the file sections: %s"),
498 styled_string (file_name_style
.style (), scratch_pathname
),
499 bfd_errmsg (bfd_get_error ()));
502 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
506 set_gdbarch_from_file (exec_bfd
);
508 /* Add the executable's sections to the current address spaces'
509 list of sections. This possibly pushes the exec_ops
511 add_target_sections (&exec_bfd
, sections
, sections_end
);
514 /* Tell display code (if any) about the changed file name. */
515 if (deprecated_exec_file_display_hook
)
516 (*deprecated_exec_file_display_hook
) (filename
);
519 bfd_cache_close_all ();
520 gdb::observers::executable_changed
.notify ();
523 /* Process the first arg in ARGS as the new exec file.
525 Note that we have to explicitly ignore additional args, since we can
526 be called from file_command(), which also calls symbol_file_command()
527 which can take multiple args.
529 If ARGS is NULL, we just want to close the exec file. */
532 exec_file_command (const char *args
, int from_tty
)
534 if (from_tty
&& target_has_execution
535 && !query (_("A program is being debugged already.\n"
536 "Are you sure you want to change the file? ")))
537 error (_("File not changed."));
541 /* Scan through the args and pick up the first non option arg
544 gdb_argv
built_argv (args
);
545 char **argv
= built_argv
.get ();
547 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
551 error (_("No executable file name was specified"));
553 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
554 exec_file_attach (filename
.get (), from_tty
);
557 exec_file_attach (NULL
, from_tty
);
560 /* Set both the exec file and the symbol file, in one command.
561 What a novelty. Why did GDB go through four major releases before this
562 command was added? */
565 file_command (const char *arg
, int from_tty
)
567 /* FIXME, if we lose on reading the symbol file, we should revert
568 the exec file, but that's rough. */
569 exec_file_command (arg
, from_tty
);
570 symbol_file_command (arg
, from_tty
);
571 if (deprecated_file_changed_hook
)
572 deprecated_file_changed_hook (arg
);
576 /* Locate all mappable sections of a BFD file.
577 table_pp_char is a char * to get it through bfd_map_over_sections;
578 we cast it back to its proper type. */
581 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
584 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
587 gdb_assert (abfd
== asect
->owner
);
589 /* Check the section flags, but do not discard zero-length sections, since
590 some symbols may still be attached to this section. For instance, we
591 encountered on sparc-solaris 2.10 a shared library with an empty .bss
592 section to which a symbol named "_end" was attached. The address
593 of this symbol still needs to be relocated. */
594 aflag
= bfd_section_flags (asect
);
595 if (!(aflag
& SEC_ALLOC
))
598 (*table_pp
)->owner
= NULL
;
599 (*table_pp
)->the_bfd_section
= asect
;
600 (*table_pp
)->addr
= bfd_section_vma (asect
);
601 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (asect
);
608 clear_section_table (struct target_section_table
*table
)
610 xfree (table
->sections
);
611 table
->sections
= table
->sections_end
= NULL
;
614 /* Resize section table TABLE by ADJUSTMENT.
615 ADJUSTMENT may be negative, in which case the caller must have already
616 removed the sections being deleted.
617 Returns the old size. */
620 resize_section_table (struct target_section_table
*table
, int adjustment
)
625 old_count
= table
->sections_end
- table
->sections
;
627 new_count
= adjustment
+ old_count
;
631 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
633 table
->sections_end
= table
->sections
+ new_count
;
636 clear_section_table (table
);
641 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
642 Returns 0 if OK, 1 on error. */
645 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
646 struct target_section
**end
)
650 count
= bfd_count_sections (some_bfd
);
652 *start
= XNEWVEC (struct target_section
, count
);
654 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
656 gdb_assert (*end
<= *start
+ count
);
658 /* We could realloc the table, but it probably loses for most files. */
662 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
663 current set of target sections. */
666 add_target_sections (void *owner
,
667 struct target_section
*sections
,
668 struct target_section
*sections_end
)
671 struct target_section_table
*table
= current_target_sections
;
673 count
= sections_end
- sections
;
677 int space
= resize_section_table (table
, count
);
680 for (i
= 0; i
< count
; ++i
)
682 table
->sections
[space
+ i
] = sections
[i
];
683 table
->sections
[space
+ i
].owner
= owner
;
686 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
687 program_space
*curr_pspace
= current_program_space
;
689 /* If these are the first file sections we can provide memory
690 from, push the file_stratum target. Must do this in all
691 inferiors sharing the program space. */
692 for (inferior
*inf
: all_inferiors ())
694 if (inf
->pspace
!= curr_pspace
)
697 if (inf
->target_is_pushed (&exec_ops
))
700 switch_to_inferior_no_thread (inf
);
701 push_target (&exec_ops
);
706 /* Add the sections of OBJFILE to the current set of target sections. */
709 add_target_sections_of_objfile (struct objfile
*objfile
)
711 struct target_section_table
*table
= current_target_sections
;
712 struct obj_section
*osect
;
715 struct target_section
*ts
;
720 /* Compute the number of sections to add. */
721 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
723 if (bfd_section_size (osect
->the_bfd_section
) == 0)
731 space
= resize_section_table (table
, count
);
733 ts
= table
->sections
+ space
;
735 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
737 if (bfd_section_size (osect
->the_bfd_section
) == 0)
740 gdb_assert (ts
< table
->sections
+ space
+ count
);
742 ts
->addr
= obj_section_addr (osect
);
743 ts
->endaddr
= obj_section_endaddr (osect
);
744 ts
->the_bfd_section
= osect
->the_bfd_section
;
745 ts
->owner
= (void *) objfile
;
751 /* Remove all target sections owned by OWNER.
752 OWNER must be the same value passed to add_target_sections. */
755 remove_target_sections (void *owner
)
757 struct target_section
*src
, *dest
;
758 struct target_section_table
*table
= current_target_sections
;
760 gdb_assert (owner
!= NULL
);
762 dest
= table
->sections
;
763 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
764 if (src
->owner
!= owner
)
766 /* Keep this section. */
772 /* If we've dropped any sections, resize the section table. */
777 old_count
= resize_section_table (table
, dest
- src
);
779 /* If we don't have any more sections to read memory from,
780 remove the file_stratum target from the stack of each
781 inferior sharing the program space. */
782 if (old_count
+ (dest
- src
) == 0)
784 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
785 program_space
*curr_pspace
= current_program_space
;
787 for (inferior
*inf
: all_inferiors ())
789 if (inf
->pspace
!= curr_pspace
)
792 if (inf
->pspace
->target_sections
.sections
793 != inf
->pspace
->target_sections
.sections_end
)
796 switch_to_inferior_no_thread (inf
);
797 unpush_target (&exec_ops
);
808 if (current_program_space
->target_sections
.sections
809 != current_program_space
->target_sections
.sections_end
)
810 push_target (&exec_ops
);
815 enum target_xfer_status
816 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
817 ULONGEST len
, ULONGEST
*xfered_len
)
819 /* It's unduly pedantic to refuse to look at the executable for
820 read-only pieces; so do the equivalent of readonly regions aka
822 if (exec_bfd
!= NULL
)
828 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
830 if ((s
->flags
& SEC_LOAD
) == 0
831 || (s
->flags
& SEC_READONLY
) == 0)
835 size
= bfd_section_size (s
);
836 if (vma
<= offset
&& offset
< (vma
+ size
))
840 amt
= (vma
+ size
) - offset
;
844 amt
= bfd_get_section_contents (exec_bfd
, s
,
845 readbuf
, offset
- vma
, amt
);
848 return TARGET_XFER_EOF
;
852 return TARGET_XFER_OK
;
858 /* Indicate failure to find the requested memory block. */
859 return TARGET_XFER_E_IO
;
862 /* Return all read-only memory ranges found in the target section
863 table defined by SECTIONS and SECTIONS_END, starting at (and
864 intersected with) MEMADDR for LEN bytes. */
866 static std::vector
<mem_range
>
867 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
868 struct target_section
*sections
,
869 struct target_section
*sections_end
)
871 std::vector
<mem_range
> memory
;
873 for (target_section
*p
= sections
; p
< sections_end
; p
++)
875 if ((bfd_section_flags (p
->the_bfd_section
) & SEC_READONLY
) == 0)
878 /* Copy the meta-data, adjusted. */
879 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
881 ULONGEST lo1
, hi1
, lo2
, hi2
;
889 CORE_ADDR start
= std::max (lo1
, lo2
);
890 int length
= std::min (hi1
, hi2
) - start
;
892 memory
.emplace_back (start
, length
);
899 enum target_xfer_status
900 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
901 ULONGEST len
, ULONGEST
*xfered_len
)
903 target_section_table
*table
= target_get_section_table (&exec_ops
);
904 std::vector
<mem_range
> available_memory
905 = section_table_available_memory (offset
, len
,
906 table
->sections
, table
->sections_end
);
908 normalize_mem_ranges (&available_memory
);
910 for (const mem_range
&r
: available_memory
)
912 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
915 enum target_xfer_status status
;
917 /* Get the intersection window. */
918 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
920 gdb_assert (end
- offset
<= len
);
922 if (offset
>= r
.start
)
923 status
= exec_read_partial_read_only (readbuf
, offset
,
928 *xfered_len
= r
.start
- offset
;
929 status
= TARGET_XFER_UNAVAILABLE
;
936 return TARGET_XFER_UNAVAILABLE
;
939 enum target_xfer_status
940 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
941 ULONGEST offset
, ULONGEST len
,
942 ULONGEST
*xfered_len
,
943 struct target_section
*sections
,
944 struct target_section
*sections_end
,
945 const char *section_name
)
948 struct target_section
*p
;
949 ULONGEST memaddr
= offset
;
950 ULONGEST memend
= memaddr
+ len
;
952 gdb_assert (len
!= 0);
954 for (p
= sections
; p
< sections_end
; p
++)
956 struct bfd_section
*asect
= p
->the_bfd_section
;
957 bfd
*abfd
= asect
->owner
;
959 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
960 continue; /* not the section we need. */
961 if (memaddr
>= p
->addr
)
963 if (memend
<= p
->endaddr
)
965 /* Entire transfer is within this section. */
967 res
= bfd_set_section_contents (abfd
, asect
,
968 writebuf
, memaddr
- p
->addr
,
971 res
= bfd_get_section_contents (abfd
, asect
,
972 readbuf
, memaddr
- p
->addr
,
978 return TARGET_XFER_OK
;
981 return TARGET_XFER_EOF
;
983 else if (memaddr
>= p
->endaddr
)
985 /* This section ends before the transfer starts. */
990 /* This section overlaps the transfer. Just do half. */
991 len
= p
->endaddr
- memaddr
;
993 res
= bfd_set_section_contents (abfd
, asect
,
994 writebuf
, memaddr
- p
->addr
,
997 res
= bfd_get_section_contents (abfd
, asect
,
998 readbuf
, memaddr
- p
->addr
,
1003 return TARGET_XFER_OK
;
1006 return TARGET_XFER_EOF
;
1011 return TARGET_XFER_EOF
; /* We can't help. */
1014 struct target_section_table
*
1015 exec_target::get_section_table ()
1017 return current_target_sections
;
1020 enum target_xfer_status
1021 exec_target::xfer_partial (enum target_object object
,
1022 const char *annex
, gdb_byte
*readbuf
,
1023 const gdb_byte
*writebuf
,
1024 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
1026 struct target_section_table
*table
= get_section_table ();
1028 if (object
== TARGET_OBJECT_MEMORY
)
1029 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1030 offset
, len
, xfered_len
,
1032 table
->sections_end
,
1035 return TARGET_XFER_E_IO
;
1040 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
1042 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
1043 struct target_section
*p
;
1044 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
1045 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
1047 printf_filtered ("\t`%ps', ",
1048 styled_string (file_name_style
.style (),
1049 bfd_get_filename (abfd
)));
1051 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
1052 if (abfd
== exec_bfd
)
1054 /* gcc-3.4 does not like the initialization in
1055 <p == t->sections_end>. */
1056 bfd_vma displacement
= 0;
1057 bfd_vma entry_point
;
1059 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1061 struct bfd_section
*psect
= p
->the_bfd_section
;
1063 if ((bfd_section_flags (psect
) & (SEC_ALLOC
| SEC_LOAD
))
1064 != (SEC_ALLOC
| SEC_LOAD
))
1067 if (bfd_section_vma (psect
) <= abfd
->start_address
1068 && abfd
->start_address
< (bfd_section_vma (psect
)
1069 + bfd_section_size (psect
)))
1071 displacement
= p
->addr
- bfd_section_vma (psect
);
1075 if (p
== t
->sections_end
)
1076 warning (_("Cannot find section for the entry point of %ps."),
1077 styled_string (file_name_style
.style (),
1078 bfd_get_filename (abfd
)));
1080 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
1081 bfd_get_start_address (abfd
)
1083 printf_filtered (_("\tEntry point: %s\n"),
1084 paddress (gdbarch
, entry_point
));
1086 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
1088 struct bfd_section
*psect
= p
->the_bfd_section
;
1089 bfd
*pbfd
= psect
->owner
;
1091 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
1092 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
1094 /* FIXME: A format of "08l" is not wide enough for file offsets
1095 larger than 4GB. OTOH, making it "016l" isn't desirable either
1096 since most output will then be much wider than necessary. It
1097 may make sense to test the size of the file and choose the
1098 format string accordingly. */
1099 /* FIXME: i18n: Need to rewrite this sentence. */
1101 printf_filtered (" @ %s",
1102 hex_string_custom (psect
->filepos
, 8));
1103 printf_filtered (" is %s", bfd_section_name (psect
));
1105 printf_filtered (" in %ps",
1106 styled_string (file_name_style
.style (),
1107 bfd_get_filename (pbfd
)));
1108 printf_filtered ("\n");
1113 exec_target::files_info ()
1116 print_section_info (current_target_sections
, exec_bfd
);
1118 puts_filtered (_("\t<no file loaded>\n"));
1122 set_section_command (const char *args
, int from_tty
)
1124 struct target_section
*p
;
1125 const char *secname
;
1127 unsigned long secaddr
;
1130 struct target_section_table
*table
;
1133 error (_("Must specify section name and its virtual address"));
1135 /* Parse out section name. */
1136 for (secname
= args
; !isspace (*args
); args
++);
1137 seclen
= args
- secname
;
1139 /* Parse out new virtual address. */
1140 secaddr
= parse_and_eval_address (args
);
1142 table
= current_target_sections
;
1143 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1145 if (!strncmp (secname
, bfd_section_name (p
->the_bfd_section
), seclen
)
1146 && bfd_section_name (p
->the_bfd_section
)[seclen
] == '\0')
1148 offset
= secaddr
- p
->addr
;
1150 p
->endaddr
+= offset
;
1152 exec_ops
.files_info ();
1156 if (seclen
>= sizeof (secprint
))
1157 seclen
= sizeof (secprint
) - 1;
1158 strncpy (secprint
, secname
, seclen
);
1159 secprint
[seclen
] = '\0';
1160 error (_("Section %s not found"), secprint
);
1163 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1167 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1169 struct target_section
*p
;
1170 struct target_section_table
*table
;
1172 table
= current_target_sections
;
1173 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1175 if (filename_cmp (filename
,
1176 bfd_get_filename (p
->the_bfd_section
->owner
)) == 0
1177 && index
== p
->the_bfd_section
->index
)
1179 p
->endaddr
+= address
- p
->addr
;
1186 exec_target::has_memory ()
1188 /* We can provide memory if we have any file/target sections to read
1190 return (current_target_sections
->sections
1191 != current_target_sections
->sections_end
);
1195 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1197 error (_("Can't create a corefile"));
1201 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1203 return objfile_find_memory_regions (this, func
, data
);
1206 void _initialize_exec ();
1210 struct cmd_list_element
*c
;
1214 c
= add_cmd ("file", class_files
, file_command
, _("\
1215 Use FILE as program to be debugged.\n\
1216 It is read for its symbols, for getting the contents of pure memory,\n\
1217 and it is the program executed when you use the `run' command.\n\
1218 If FILE cannot be found as specified, your execution directory path\n\
1219 ($PATH) is searched for a command of that name.\n\
1220 No arg means to have no executable file and no symbols."), &cmdlist
);
1221 set_cmd_completer (c
, filename_completer
);
1224 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1225 Use FILE as program for getting contents of pure memory.\n\
1226 If FILE cannot be found as specified, your execution directory path\n\
1227 is searched for a command of that name.\n\
1228 No arg means have no executable file."), &cmdlist
);
1229 set_cmd_completer (c
, filename_completer
);
1231 add_com ("section", class_files
, set_section_command
, _("\
1232 Change the base address of section SECTION of the exec file to ADDR.\n\
1233 This can be used if the exec file does not contain section addresses,\n\
1234 (such as in the a.out format), or when the addresses specified in the\n\
1235 file itself are wrong. Each section must be changed separately. The\n\
1236 ``info files'' command lists all the sections and their addresses."));
1238 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1239 Set writing into executable and core files."), _("\
1240 Show writing into executable and core files."), NULL
,
1243 &setlist
, &showlist
);
1245 add_setshow_enum_cmd ("exec-file-mismatch", class_support
,
1246 exec_file_mismatch_names
,
1247 &exec_file_mismatch
,
1249 Set exec-file-mismatch handling (ask|warn|off)."),
1251 Show exec-file-mismatch handling (ask|warn|off)."),
1253 Specifies how to handle a mismatch between the current exec-file\n\
1254 loaded by GDB and the exec-file automatically determined when attaching\n\
1256 ask - warn the user and ask whether to load the determined exec-file.\n\
1257 warn - warn the user, but do not change the exec-file.\n\
1258 off - do not check for mismatch."),
1259 set_exec_file_mismatch_command
,
1260 show_exec_file_mismatch_command
,
1261 &setlist
, &showlist
);
1263 add_target (exec_target_info
, exec_target_open
, filename_completer
);