1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2019 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"
41 #include "readline/readline.h"
48 #include "common/pathstuff.h"
50 void (*deprecated_file_changed_hook
) (const char *);
52 static const target_info exec_target_info
= {
54 N_("Local exec file"),
55 N_("Use an executable file as a target.\n\
56 Specify the filename of the executable file.")
59 /* The target vector for executable files. */
61 struct exec_target final
: public target_ops
63 const target_info
&info () const override
64 { return exec_target_info
; }
66 strata
stratum () const override
{ return file_stratum
; }
68 void close () override
;
69 enum target_xfer_status
xfer_partial (enum target_object object
,
72 const gdb_byte
*writebuf
,
73 ULONGEST offset
, ULONGEST len
,
74 ULONGEST
*xfered_len
) override
;
75 struct target_section_table
*get_section_table () override
;
76 void files_info () override
;
78 bool has_memory () override
;
79 char *make_corefile_notes (bfd
*, int *) override
;
80 int find_memory_regions (find_memory_region_ftype func
, void *data
) override
;
83 static exec_target exec_ops
;
85 /* Whether to open exec and core files read-only or read-write. */
89 show_write_files (struct ui_file
*file
, int from_tty
,
90 struct cmd_list_element
*c
, const char *value
)
92 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
98 exec_target_open (const char *args
, int from_tty
)
100 target_preopen (from_tty
);
101 exec_file_attach (args
, from_tty
);
104 /* Close and clear exec_bfd. If we end up with no target sections to
105 read memory from, this unpushes the exec_ops target. */
112 bfd
*abfd
= exec_bfd
;
114 gdb_bfd_unref (abfd
);
116 /* Removing target sections may close the exec_ops target.
117 Clear exec_bfd before doing so to prevent recursion. */
121 remove_target_sections (&exec_bfd
);
123 xfree (exec_filename
);
124 exec_filename
= NULL
;
128 /* This is the target_close implementation. Clears all target
129 sections and closes all executable bfds from all program spaces. */
132 exec_target::close ()
134 struct program_space
*ss
;
135 scoped_restore_current_program_space restore_pspace
;
139 set_current_program_space (ss
);
140 clear_section_table (current_target_sections
);
148 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
149 symfile_add_flags add_flags
)
151 struct gdb_exception prev_err
= exception_none
;
153 /* exec_file_attach and symbol_file_add_main may throw an error if the file
154 cannot be opened either locally or remotely.
156 This happens for example, when the file is first found in the local
157 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
158 exist in the target filesystem, or when the file does exist, but
161 Even without a symbol file, the remote-based debugging session should
162 continue normally instead of ending abruptly. Hence we catch thrown
163 errors/exceptions in the following code. */
166 /* We must do this step even if exec_file_host is NULL, so that
167 exec_file_attach will clear state. */
168 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
170 CATCH (err
, RETURN_MASK_ERROR
)
172 if (err
.message
!= NULL
)
173 warning ("%s", err
.what ());
179 if (exec_file_host
!= NULL
)
183 symbol_file_add_main (exec_file_host
, add_flags
);
185 CATCH (err
, RETURN_MASK_ERROR
)
187 if (!exception_print_same (prev_err
, err
))
188 warning ("%s", err
.what ());
197 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
199 char *exec_file_target
;
200 symfile_add_flags add_flags
= 0;
202 /* Do nothing if we already have an executable filename. */
203 if (get_exec_file (0) != NULL
)
206 /* Try to determine a filename from the process itself. */
207 exec_file_target
= target_pid_to_exec_file (pid
);
208 if (exec_file_target
== NULL
)
210 warning (_("No executable has been specified and target does not "
212 "determining executable automatically. "
213 "Try using the \"file\" command."));
217 gdb::unique_xmalloc_ptr
<char> exec_file_host
218 = exec_file_find (exec_file_target
, NULL
);
221 add_flags
|= SYMFILE_DEFER_BP_RESET
;
224 add_flags
|= SYMFILE_VERBOSE
;
226 /* Attempt to open the exec file. */
227 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
230 /* Set FILENAME as the new exec file.
232 This function is intended to be behave essentially the same
233 as exec_file_command, except that the latter will detect when
234 a target is being debugged, and will ask the user whether it
235 should be shut down first. (If the answer is "no", then the
236 new file is ignored.)
238 This file is used by exec_file_command, to do the work of opening
239 and processing the exec file after any prompting has happened.
241 And, it is used by child_attach, when the attach command was
242 given a pid but not a exec pathname, and the attach command could
243 figure out the pathname from the pid. (In this case, we shouldn't
244 ask the user whether the current target should be shut down --
245 we're supplying the exec pathname late for good reason.) */
248 exec_file_attach (const char *filename
, int from_tty
)
250 /* First, acquire a reference to the current exec_bfd. We release
251 this at the end of the function; but acquiring it now lets the
252 BFD cache return it if this call refers to the same file. */
253 gdb_bfd_ref_ptr exec_bfd_holder
= gdb_bfd_ref_ptr::new_reference (exec_bfd
);
255 /* Remove any previous exec file. */
258 /* Now open and digest the file the user requested, if any. */
263 printf_unfiltered (_("No executable file now.\n"));
265 set_gdbarch_from_file (NULL
);
269 int load_via_target
= 0;
270 const char *scratch_pathname
, *canonical_pathname
;
272 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
275 if (is_target_filename (filename
))
277 if (target_filesystem_is_local ())
278 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
283 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
286 /* gdb_bfd_fopen does not support "target:" filenames. */
288 warning (_("writing into executable files is "
289 "not supported for %s sysroots"),
290 TARGET_SYSROOT_PREFIX
);
292 scratch_pathname
= filename
;
294 canonical_pathname
= scratch_pathname
;
298 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
299 filename
, write_files
?
300 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
302 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
303 if (scratch_chan
< 0)
305 char *exename
= (char *) alloca (strlen (filename
) + 5);
307 strcat (strcpy (exename
, filename
), ".exe");
308 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
309 exename
, write_files
?
311 : O_RDONLY
| O_BINARY
,
315 if (scratch_chan
< 0)
316 perror_with_name (filename
);
318 scratch_pathname
= scratch_storage
.get ();
320 /* gdb_bfd_open (and its variants) prefers canonicalized
321 pathname for better BFD caching. */
322 canonical_storage
= gdb_realpath (scratch_pathname
);
323 canonical_pathname
= canonical_storage
.get ();
326 gdb_bfd_ref_ptr temp
;
327 if (write_files
&& !load_via_target
)
328 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
329 FOPEN_RUB
, scratch_chan
);
331 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
332 exec_bfd
= temp
.release ();
336 error (_("\"%s\": could not open as an executable file: %s."),
337 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
340 /* gdb_realpath_keepfile resolves symlinks on the local
341 filesystem and so cannot be used for "target:" files. */
342 gdb_assert (exec_filename
== NULL
);
344 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
346 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
348 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
350 /* Make sure to close exec_bfd, or else "run" might try to use
353 error (_("\"%s\": not in executable format: %s"),
355 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
358 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
360 /* Make sure to close exec_bfd, or else "run" might try to use
363 error (_("\"%s\": can't find the file sections: %s"),
364 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
367 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
371 set_gdbarch_from_file (exec_bfd
);
373 /* Add the executable's sections to the current address spaces'
374 list of sections. This possibly pushes the exec_ops
376 add_target_sections (&exec_bfd
, sections
, sections_end
);
379 /* Tell display code (if any) about the changed file name. */
380 if (deprecated_exec_file_display_hook
)
381 (*deprecated_exec_file_display_hook
) (filename
);
384 bfd_cache_close_all ();
385 gdb::observers::executable_changed
.notify ();
388 /* Process the first arg in ARGS as the new exec file.
390 Note that we have to explicitly ignore additional args, since we can
391 be called from file_command(), which also calls symbol_file_command()
392 which can take multiple args.
394 If ARGS is NULL, we just want to close the exec file. */
397 exec_file_command (const char *args
, int from_tty
)
399 if (from_tty
&& target_has_execution
400 && !query (_("A program is being debugged already.\n"
401 "Are you sure you want to change the file? ")))
402 error (_("File not changed."));
406 /* Scan through the args and pick up the first non option arg
409 gdb_argv
built_argv (args
);
410 char **argv
= built_argv
.get ();
412 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
416 error (_("No executable file name was specified"));
418 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
419 exec_file_attach (filename
.get (), from_tty
);
422 exec_file_attach (NULL
, from_tty
);
425 /* Set both the exec file and the symbol file, in one command.
426 What a novelty. Why did GDB go through four major releases before this
427 command was added? */
430 file_command (const char *arg
, int from_tty
)
432 /* FIXME, if we lose on reading the symbol file, we should revert
433 the exec file, but that's rough. */
434 exec_file_command (arg
, from_tty
);
435 symbol_file_command (arg
, from_tty
);
436 if (deprecated_file_changed_hook
)
437 deprecated_file_changed_hook (arg
);
441 /* Locate all mappable sections of a BFD file.
442 table_pp_char is a char * to get it through bfd_map_over_sections;
443 we cast it back to its proper type. */
446 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
449 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
452 gdb_assert (abfd
== asect
->owner
);
454 /* Check the section flags, but do not discard zero-length sections, since
455 some symbols may still be attached to this section. For instance, we
456 encountered on sparc-solaris 2.10 a shared library with an empty .bss
457 section to which a symbol named "_end" was attached. The address
458 of this symbol still needs to be relocated. */
459 aflag
= bfd_get_section_flags (abfd
, asect
);
460 if (!(aflag
& SEC_ALLOC
))
463 (*table_pp
)->owner
= NULL
;
464 (*table_pp
)->the_bfd_section
= asect
;
465 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
466 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
473 clear_section_table (struct target_section_table
*table
)
475 xfree (table
->sections
);
476 table
->sections
= table
->sections_end
= NULL
;
479 /* Resize section table TABLE by ADJUSTMENT.
480 ADJUSTMENT may be negative, in which case the caller must have already
481 removed the sections being deleted.
482 Returns the old size. */
485 resize_section_table (struct target_section_table
*table
, int adjustment
)
490 old_count
= table
->sections_end
- table
->sections
;
492 new_count
= adjustment
+ old_count
;
496 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
498 table
->sections_end
= table
->sections
+ new_count
;
501 clear_section_table (table
);
506 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
507 Returns 0 if OK, 1 on error. */
510 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
511 struct target_section
**end
)
515 count
= bfd_count_sections (some_bfd
);
518 *start
= XNEWVEC (struct target_section
, count
);
520 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
521 if (*end
> *start
+ count
)
522 internal_error (__FILE__
, __LINE__
,
523 _("failed internal consistency check"));
524 /* We could realloc the table, but it probably loses for most files. */
528 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
529 current set of target sections. */
532 add_target_sections (void *owner
,
533 struct target_section
*sections
,
534 struct target_section
*sections_end
)
537 struct target_section_table
*table
= current_target_sections
;
539 count
= sections_end
- sections
;
543 int space
= resize_section_table (table
, count
);
546 for (i
= 0; i
< count
; ++i
)
548 table
->sections
[space
+ i
] = sections
[i
];
549 table
->sections
[space
+ i
].owner
= owner
;
552 /* If these are the first file sections we can provide memory
553 from, push the file_stratum target. */
554 if (!target_is_pushed (&exec_ops
))
555 push_target (&exec_ops
);
559 /* Add the sections of OBJFILE to the current set of target sections. */
562 add_target_sections_of_objfile (struct objfile
*objfile
)
564 struct target_section_table
*table
= current_target_sections
;
565 struct obj_section
*osect
;
568 struct target_section
*ts
;
573 /* Compute the number of sections to add. */
574 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
576 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
584 space
= resize_section_table (table
, count
);
586 ts
= table
->sections
+ space
;
588 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
590 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
593 gdb_assert (ts
< table
->sections
+ space
+ count
);
595 ts
->addr
= obj_section_addr (osect
);
596 ts
->endaddr
= obj_section_endaddr (osect
);
597 ts
->the_bfd_section
= osect
->the_bfd_section
;
598 ts
->owner
= (void *) objfile
;
604 /* Remove all target sections owned by OWNER.
605 OWNER must be the same value passed to add_target_sections. */
608 remove_target_sections (void *owner
)
610 struct target_section
*src
, *dest
;
611 struct target_section_table
*table
= current_target_sections
;
613 gdb_assert (owner
!= NULL
);
615 dest
= table
->sections
;
616 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
617 if (src
->owner
!= owner
)
619 /* Keep this section. */
625 /* If we've dropped any sections, resize the section table. */
630 old_count
= resize_section_table (table
, dest
- src
);
632 /* If we don't have any more sections to read memory from,
633 remove the file_stratum target from the stack. */
634 if (old_count
+ (dest
- src
) == 0)
636 struct program_space
*pspace
;
639 if (pspace
->target_sections
.sections
640 != pspace
->target_sections
.sections_end
)
643 unpush_target (&exec_ops
);
650 enum target_xfer_status
651 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
652 ULONGEST len
, ULONGEST
*xfered_len
)
654 /* It's unduly pedantic to refuse to look at the executable for
655 read-only pieces; so do the equivalent of readonly regions aka
657 if (exec_bfd
!= NULL
)
663 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
665 if ((s
->flags
& SEC_LOAD
) == 0
666 || (s
->flags
& SEC_READONLY
) == 0)
670 size
= bfd_get_section_size (s
);
671 if (vma
<= offset
&& offset
< (vma
+ size
))
675 amt
= (vma
+ size
) - offset
;
679 amt
= bfd_get_section_contents (exec_bfd
, s
,
680 readbuf
, offset
- vma
, amt
);
683 return TARGET_XFER_EOF
;
687 return TARGET_XFER_OK
;
693 /* Indicate failure to find the requested memory block. */
694 return TARGET_XFER_E_IO
;
697 /* Return all read-only memory ranges found in the target section
698 table defined by SECTIONS and SECTIONS_END, starting at (and
699 intersected with) MEMADDR for LEN bytes. */
701 static std::vector
<mem_range
>
702 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
703 struct target_section
*sections
,
704 struct target_section
*sections_end
)
706 std::vector
<mem_range
> memory
;
708 for (target_section
*p
= sections
; p
< sections_end
; p
++)
710 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
712 & SEC_READONLY
) == 0)
715 /* Copy the meta-data, adjusted. */
716 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
718 ULONGEST lo1
, hi1
, lo2
, hi2
;
726 CORE_ADDR start
= std::max (lo1
, lo2
);
727 int length
= std::min (hi1
, hi2
) - start
;
729 memory
.emplace_back (start
, length
);
736 enum target_xfer_status
737 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
738 ULONGEST len
, ULONGEST
*xfered_len
)
740 target_section_table
*table
= target_get_section_table (&exec_ops
);
741 std::vector
<mem_range
> available_memory
742 = section_table_available_memory (offset
, len
,
743 table
->sections
, table
->sections_end
);
745 normalize_mem_ranges (&available_memory
);
747 for (const mem_range
&r
: available_memory
)
749 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
752 enum target_xfer_status status
;
754 /* Get the intersection window. */
755 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
757 gdb_assert (end
- offset
<= len
);
759 if (offset
>= r
.start
)
760 status
= exec_read_partial_read_only (readbuf
, offset
,
765 *xfered_len
= r
.start
- offset
;
766 status
= TARGET_XFER_UNAVAILABLE
;
773 return TARGET_XFER_UNAVAILABLE
;
776 enum target_xfer_status
777 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
778 ULONGEST offset
, ULONGEST len
,
779 ULONGEST
*xfered_len
,
780 struct target_section
*sections
,
781 struct target_section
*sections_end
,
782 const char *section_name
)
785 struct target_section
*p
;
786 ULONGEST memaddr
= offset
;
787 ULONGEST memend
= memaddr
+ len
;
790 internal_error (__FILE__
, __LINE__
,
791 _("failed internal consistency check"));
793 for (p
= sections
; p
< sections_end
; p
++)
795 struct bfd_section
*asect
= p
->the_bfd_section
;
796 bfd
*abfd
= asect
->owner
;
798 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
799 continue; /* not the section we need. */
800 if (memaddr
>= p
->addr
)
802 if (memend
<= p
->endaddr
)
804 /* Entire transfer is within this section. */
806 res
= bfd_set_section_contents (abfd
, asect
,
807 writebuf
, memaddr
- p
->addr
,
810 res
= bfd_get_section_contents (abfd
, asect
,
811 readbuf
, memaddr
- p
->addr
,
817 return TARGET_XFER_OK
;
820 return TARGET_XFER_EOF
;
822 else if (memaddr
>= p
->endaddr
)
824 /* This section ends before the transfer starts. */
829 /* This section overlaps the transfer. Just do half. */
830 len
= p
->endaddr
- memaddr
;
832 res
= bfd_set_section_contents (abfd
, asect
,
833 writebuf
, memaddr
- p
->addr
,
836 res
= bfd_get_section_contents (abfd
, asect
,
837 readbuf
, memaddr
- p
->addr
,
842 return TARGET_XFER_OK
;
845 return TARGET_XFER_EOF
;
850 return TARGET_XFER_EOF
; /* We can't help. */
853 struct target_section_table
*
854 exec_target::get_section_table ()
856 return current_target_sections
;
859 enum target_xfer_status
860 exec_target::xfer_partial (enum target_object object
,
861 const char *annex
, gdb_byte
*readbuf
,
862 const gdb_byte
*writebuf
,
863 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
865 struct target_section_table
*table
= get_section_table ();
867 if (object
== TARGET_OBJECT_MEMORY
)
868 return section_table_xfer_memory_partial (readbuf
, writebuf
,
869 offset
, len
, xfered_len
,
874 return TARGET_XFER_E_IO
;
879 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
881 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
882 struct target_section
*p
;
883 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
884 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
886 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
888 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
889 if (abfd
== exec_bfd
)
891 /* gcc-3.4 does not like the initialization in
892 <p == t->sections_end>. */
893 bfd_vma displacement
= 0;
896 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
898 struct bfd_section
*psect
= p
->the_bfd_section
;
899 bfd
*pbfd
= psect
->owner
;
901 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
902 != (SEC_ALLOC
| SEC_LOAD
))
905 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
906 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
907 + bfd_get_section_size (psect
)))
909 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
913 if (p
== t
->sections_end
)
914 warning (_("Cannot find section for the entry point of %s."),
915 bfd_get_filename (abfd
));
917 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
918 bfd_get_start_address (abfd
)
920 printf_filtered (_("\tEntry point: %s\n"),
921 paddress (gdbarch
, entry_point
));
923 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
925 struct bfd_section
*psect
= p
->the_bfd_section
;
926 bfd
*pbfd
= psect
->owner
;
928 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
929 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
931 /* FIXME: A format of "08l" is not wide enough for file offsets
932 larger than 4GB. OTOH, making it "016l" isn't desirable either
933 since most output will then be much wider than necessary. It
934 may make sense to test the size of the file and choose the
935 format string accordingly. */
936 /* FIXME: i18n: Need to rewrite this sentence. */
938 printf_filtered (" @ %s",
939 hex_string_custom (psect
->filepos
, 8));
940 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
942 printf_filtered (" in %s", bfd_get_filename (pbfd
));
943 printf_filtered ("\n");
948 exec_target::files_info ()
951 print_section_info (current_target_sections
, exec_bfd
);
953 puts_filtered (_("\t<no file loaded>\n"));
957 set_section_command (const char *args
, int from_tty
)
959 struct target_section
*p
;
962 unsigned long secaddr
;
965 struct target_section_table
*table
;
968 error (_("Must specify section name and its virtual address"));
970 /* Parse out section name. */
971 for (secname
= args
; !isspace (*args
); args
++);
972 seclen
= args
- secname
;
974 /* Parse out new virtual address. */
975 secaddr
= parse_and_eval_address (args
);
977 table
= current_target_sections
;
978 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
980 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
981 p
->the_bfd_section
), seclen
)
982 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
984 offset
= secaddr
- p
->addr
;
986 p
->endaddr
+= offset
;
988 exec_ops
.files_info ();
992 if (seclen
>= sizeof (secprint
))
993 seclen
= sizeof (secprint
) - 1;
994 strncpy (secprint
, secname
, seclen
);
995 secprint
[seclen
] = '\0';
996 error (_("Section %s not found"), secprint
);
999 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1003 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1005 struct target_section
*p
;
1006 struct target_section_table
*table
;
1008 table
= current_target_sections
;
1009 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1011 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
1012 && index
== p
->the_bfd_section
->index
)
1014 p
->endaddr
+= address
- p
->addr
;
1021 exec_target::has_memory ()
1023 /* We can provide memory if we have any file/target sections to read
1025 return (current_target_sections
->sections
1026 != current_target_sections
->sections_end
);
1030 exec_target::make_corefile_notes (bfd
*obfd
, int *note_size
)
1032 error (_("Can't create a corefile"));
1036 exec_target::find_memory_regions (find_memory_region_ftype func
, void *data
)
1038 return objfile_find_memory_regions (this, func
, data
);
1042 _initialize_exec (void)
1044 struct cmd_list_element
*c
;
1048 c
= add_cmd ("file", class_files
, file_command
, _("\
1049 Use FILE as program to be debugged.\n\
1050 It is read for its symbols, for getting the contents of pure memory,\n\
1051 and it is the program executed when you use the `run' command.\n\
1052 If FILE cannot be found as specified, your execution directory path\n\
1053 ($PATH) is searched for a command of that name.\n\
1054 No arg means to have no executable file and no symbols."), &cmdlist
);
1055 set_cmd_completer (c
, filename_completer
);
1058 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1059 Use FILE as program for getting contents of pure memory.\n\
1060 If FILE cannot be found as specified, your execution directory path\n\
1061 is searched for a command of that name.\n\
1062 No arg means have no executable file."), &cmdlist
);
1063 set_cmd_completer (c
, filename_completer
);
1065 add_com ("section", class_files
, set_section_command
, _("\
1066 Change the base address of section SECTION of the exec file to ADDR.\n\
1067 This can be used if the exec file does not contain section addresses,\n\
1068 (such as in the a.out format), or when the addresses specified in the\n\
1069 file itself are wrong. Each section must be changed separately. The\n\
1070 ``info files'' command lists all the sections and their addresses."));
1072 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1073 Set writing into executable and core files."), _("\
1074 Show writing into executable and core files."), NULL
,
1077 &setlist
, &showlist
);
1079 add_target (exec_target_info
, exec_target_open
, filename_completer
);