1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2018 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"
33 #include "arch-utils.h"
34 #include "gdbthread.h"
35 #include "progspace.h"
41 #include "readline/readline.h"
49 void (*deprecated_file_changed_hook
) (const char *);
51 /* Prototypes for local functions */
53 static void exec_files_info (struct target_ops
*);
55 static void init_exec_ops (void);
57 /* The target vector for executable files. */
59 static struct target_ops exec_ops
;
61 /* Whether to open exec and core files read-only or read-write. */
65 show_write_files (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
74 exec_open (const char *args
, int from_tty
)
76 target_preopen (from_tty
);
77 exec_file_attach (args
, from_tty
);
80 /* Close and clear exec_bfd. If we end up with no target sections to
81 read memory from, this unpushes the exec_ops target. */
92 /* Removing target sections may close the exec_ops target.
93 Clear exec_bfd before doing so to prevent recursion. */
97 remove_target_sections (&exec_bfd
);
99 xfree (exec_filename
);
100 exec_filename
= NULL
;
104 /* This is the target_close implementation. Clears all target
105 sections and closes all executable bfds from all program spaces. */
108 exec_close_1 (struct target_ops
*self
)
110 struct program_space
*ss
;
111 scoped_restore_current_program_space restore_pspace
;
115 set_current_program_space (ss
);
116 clear_section_table (current_target_sections
);
122 exec_file_clear (int from_tty
)
124 /* Remove exec file. */
128 printf_unfiltered (_("No executable file now.\n"));
134 try_open_exec_file (const char *exec_file_host
, struct inferior
*inf
,
135 symfile_add_flags add_flags
)
137 struct cleanup
*old_chain
;
138 struct gdb_exception prev_err
= exception_none
;
140 old_chain
= make_cleanup (free_current_contents
, &prev_err
.message
);
142 /* exec_file_attach and symbol_file_add_main may throw an error if the file
143 cannot be opened either locally or remotely.
145 This happens for example, when the file is first found in the local
146 sysroot (above), and then disappears (a TOCTOU race), or when it doesn't
147 exist in the target filesystem, or when the file does exist, but
150 Even without a symbol file, the remote-based debugging session should
151 continue normally instead of ending abruptly. Hence we catch thrown
152 errors/exceptions in the following code. */
155 /* We must do this step even if exec_file_host is NULL, so that
156 exec_file_attach will clear state. */
157 exec_file_attach (exec_file_host
, add_flags
& SYMFILE_VERBOSE
);
159 CATCH (err
, RETURN_MASK_ERROR
)
161 if (err
.message
!= NULL
)
162 warning ("%s", err
.message
);
166 /* Save message so it doesn't get trashed by the catch below. */
167 if (err
.message
!= NULL
)
168 prev_err
.message
= xstrdup (err
.message
);
172 if (exec_file_host
!= NULL
)
176 symbol_file_add_main (exec_file_host
, add_flags
);
178 CATCH (err
, RETURN_MASK_ERROR
)
180 if (!exception_print_same (prev_err
, err
))
181 warning ("%s", err
.message
);
186 do_cleanups (old_chain
);
192 exec_file_locate_attach (int pid
, int defer_bp_reset
, int from_tty
)
194 char *exec_file_target
;
195 symfile_add_flags add_flags
= 0;
197 /* Do nothing if we already have an executable filename. */
198 if (get_exec_file (0) != NULL
)
201 /* Try to determine a filename from the process itself. */
202 exec_file_target
= target_pid_to_exec_file (pid
);
203 if (exec_file_target
== NULL
)
205 warning (_("No executable has been specified and target does not "
207 "determining executable automatically. "
208 "Try using the \"file\" command."));
212 gdb::unique_xmalloc_ptr
<char> exec_file_host
213 = exec_file_find (exec_file_target
, NULL
);
216 add_flags
|= SYMFILE_DEFER_BP_RESET
;
219 add_flags
|= SYMFILE_VERBOSE
;
221 /* Attempt to open the exec file. */
222 try_open_exec_file (exec_file_host
.get (), current_inferior (), add_flags
);
225 /* Set FILENAME as the new exec file.
227 This function is intended to be behave essentially the same
228 as exec_file_command, except that the latter will detect when
229 a target is being debugged, and will ask the user whether it
230 should be shut down first. (If the answer is "no", then the
231 new file is ignored.)
233 This file is used by exec_file_command, to do the work of opening
234 and processing the exec file after any prompting has happened.
236 And, it is used by child_attach, when the attach command was
237 given a pid but not a exec pathname, and the attach command could
238 figure out the pathname from the pid. (In this case, we shouldn't
239 ask the user whether the current target should be shut down --
240 we're supplying the exec pathname late for good reason.) */
243 exec_file_attach (const char *filename
, int from_tty
)
245 /* First, acquire a reference to the current exec_bfd. We release
246 this at the end of the function; but acquiring it now lets the
247 BFD cache return it if this call refers to the same file. */
248 gdb_bfd_ref_ptr exec_bfd_holder
= new_bfd_ref (exec_bfd
);
250 /* Remove any previous exec file. */
253 /* Now open and digest the file the user requested, if any. */
258 printf_unfiltered (_("No executable file now.\n"));
260 set_gdbarch_from_file (NULL
);
264 int load_via_target
= 0;
265 const char *scratch_pathname
, *canonical_pathname
;
267 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
270 if (is_target_filename (filename
))
272 if (target_filesystem_is_local ())
273 filename
+= strlen (TARGET_SYSROOT_PREFIX
);
278 gdb::unique_xmalloc_ptr
<char> canonical_storage
, scratch_storage
;
281 /* gdb_bfd_fopen does not support "target:" filenames. */
283 warning (_("writing into executable files is "
284 "not supported for %s sysroots"),
285 TARGET_SYSROOT_PREFIX
);
287 scratch_pathname
= filename
;
289 canonical_pathname
= scratch_pathname
;
295 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
296 filename
, write_files
?
297 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
299 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
300 if (scratch_chan
< 0)
302 char *exename
= (char *) alloca (strlen (filename
) + 5);
304 strcat (strcpy (exename
, filename
), ".exe");
305 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
,
306 exename
, write_files
?
308 : O_RDONLY
| O_BINARY
,
312 if (scratch_chan
< 0)
313 perror_with_name (filename
);
315 scratch_storage
.reset (temp_pathname
);
316 scratch_pathname
= temp_pathname
;
318 /* gdb_bfd_open (and its variants) prefers canonicalized
319 pathname for better BFD caching. */
320 canonical_storage
= gdb_realpath (scratch_pathname
);
321 canonical_pathname
= canonical_storage
.get ();
324 gdb_bfd_ref_ptr temp
;
325 if (write_files
&& !load_via_target
)
326 temp
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
327 FOPEN_RUB
, scratch_chan
);
329 temp
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
330 exec_bfd
= temp
.release ();
334 error (_("\"%s\": could not open as an executable file: %s."),
335 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
338 /* gdb_realpath_keepfile resolves symlinks on the local
339 filesystem and so cannot be used for "target:" files. */
340 gdb_assert (exec_filename
== NULL
);
342 exec_filename
= xstrdup (bfd_get_filename (exec_bfd
));
344 exec_filename
= gdb_realpath_keepfile (scratch_pathname
).release ();
346 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
348 /* Make sure to close exec_bfd, or else "run" might try to use
351 error (_("\"%s\": not in executable format: %s"),
353 gdb_bfd_errmsg (bfd_get_error (), matching
));
356 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
358 /* Make sure to close exec_bfd, or else "run" might try to use
361 error (_("\"%s\": can't find the file sections: %s"),
362 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
365 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
369 set_gdbarch_from_file (exec_bfd
);
371 /* Add the executable's sections to the current address spaces'
372 list of sections. This possibly pushes the exec_ops
374 add_target_sections (&exec_bfd
, sections
, sections_end
);
377 /* Tell display code (if any) about the changed file name. */
378 if (deprecated_exec_file_display_hook
)
379 (*deprecated_exec_file_display_hook
) (filename
);
382 bfd_cache_close_all ();
383 observer_notify_executable_changed ();
386 /* Process the first arg in ARGS as the new exec file.
388 Note that we have to explicitly ignore additional args, since we can
389 be called from file_command(), which also calls symbol_file_command()
390 which can take multiple args.
392 If ARGS is NULL, we just want to close the exec file. */
395 exec_file_command (const char *args
, int from_tty
)
397 if (from_tty
&& target_has_execution
398 && !query (_("A program is being debugged already.\n"
399 "Are you sure you want to change the file? ")))
400 error (_("File not changed."));
404 /* Scan through the args and pick up the first non option arg
407 gdb_argv
built_argv (args
);
408 char **argv
= built_argv
.get ();
410 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
414 error (_("No executable file name was specified"));
416 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (*argv
));
417 exec_file_attach (filename
.get (), from_tty
);
420 exec_file_attach (NULL
, from_tty
);
423 /* Set both the exec file and the symbol file, in one command.
424 What a novelty. Why did GDB go through four major releases before this
425 command was added? */
428 file_command (const char *arg
, int from_tty
)
430 /* FIXME, if we lose on reading the symbol file, we should revert
431 the exec file, but that's rough. */
432 exec_file_command (arg
, from_tty
);
433 symbol_file_command (arg
, from_tty
);
434 if (deprecated_file_changed_hook
)
435 deprecated_file_changed_hook (arg
);
439 /* Locate all mappable sections of a BFD file.
440 table_pp_char is a char * to get it through bfd_map_over_sections;
441 we cast it back to its proper type. */
444 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
447 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
450 gdb_assert (abfd
== asect
->owner
);
452 /* Check the section flags, but do not discard zero-length sections, since
453 some symbols may still be attached to this section. For instance, we
454 encountered on sparc-solaris 2.10 a shared library with an empty .bss
455 section to which a symbol named "_end" was attached. The address
456 of this symbol still needs to be relocated. */
457 aflag
= bfd_get_section_flags (abfd
, asect
);
458 if (!(aflag
& SEC_ALLOC
))
461 (*table_pp
)->owner
= NULL
;
462 (*table_pp
)->the_bfd_section
= asect
;
463 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
464 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
471 clear_section_table (struct target_section_table
*table
)
473 xfree (table
->sections
);
474 table
->sections
= table
->sections_end
= NULL
;
477 /* Resize section table TABLE by ADJUSTMENT.
478 ADJUSTMENT may be negative, in which case the caller must have already
479 removed the sections being deleted.
480 Returns the old size. */
483 resize_section_table (struct target_section_table
*table
, int adjustment
)
488 old_count
= table
->sections_end
- table
->sections
;
490 new_count
= adjustment
+ old_count
;
494 table
->sections
= XRESIZEVEC (struct target_section
, table
->sections
,
496 table
->sections_end
= table
->sections
+ new_count
;
499 clear_section_table (table
);
504 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
505 Returns 0 if OK, 1 on error. */
508 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
509 struct target_section
**end
)
513 count
= bfd_count_sections (some_bfd
);
516 *start
= XNEWVEC (struct target_section
, count
);
518 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
519 if (*end
> *start
+ count
)
520 internal_error (__FILE__
, __LINE__
,
521 _("failed internal consistency check"));
522 /* We could realloc the table, but it probably loses for most files. */
526 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
527 current set of target sections. */
530 add_target_sections (void *owner
,
531 struct target_section
*sections
,
532 struct target_section
*sections_end
)
535 struct target_section_table
*table
= current_target_sections
;
537 count
= sections_end
- sections
;
541 int space
= resize_section_table (table
, count
);
544 for (i
= 0; i
< count
; ++i
)
546 table
->sections
[space
+ i
] = sections
[i
];
547 table
->sections
[space
+ i
].owner
= owner
;
550 /* If these are the first file sections we can provide memory
551 from, push the file_stratum target. */
552 if (!target_is_pushed (&exec_ops
))
553 push_target (&exec_ops
);
557 /* Add the sections of OBJFILE to the current set of target sections. */
560 add_target_sections_of_objfile (struct objfile
*objfile
)
562 struct target_section_table
*table
= current_target_sections
;
563 struct obj_section
*osect
;
566 struct target_section
*ts
;
571 /* Compute the number of sections to add. */
572 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
574 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
582 space
= resize_section_table (table
, count
);
584 ts
= table
->sections
+ space
;
586 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
588 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
591 gdb_assert (ts
< table
->sections
+ space
+ count
);
593 ts
->addr
= obj_section_addr (osect
);
594 ts
->endaddr
= obj_section_endaddr (osect
);
595 ts
->the_bfd_section
= osect
->the_bfd_section
;
596 ts
->owner
= (void *) objfile
;
602 /* Remove all target sections owned by OWNER.
603 OWNER must be the same value passed to add_target_sections. */
606 remove_target_sections (void *owner
)
608 struct target_section
*src
, *dest
;
609 struct target_section_table
*table
= current_target_sections
;
611 gdb_assert (owner
!= NULL
);
613 dest
= table
->sections
;
614 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
615 if (src
->owner
!= owner
)
617 /* Keep this section. */
623 /* If we've dropped any sections, resize the section table. */
628 old_count
= resize_section_table (table
, dest
- src
);
630 /* If we don't have any more sections to read memory from,
631 remove the file_stratum target from the stack. */
632 if (old_count
+ (dest
- src
) == 0)
634 struct program_space
*pspace
;
637 if (pspace
->target_sections
.sections
638 != pspace
->target_sections
.sections_end
)
641 unpush_target (&exec_ops
);
648 enum target_xfer_status
649 exec_read_partial_read_only (gdb_byte
*readbuf
, ULONGEST offset
,
650 ULONGEST len
, ULONGEST
*xfered_len
)
652 /* It's unduly pedantic to refuse to look at the executable for
653 read-only pieces; so do the equivalent of readonly regions aka
655 if (exec_bfd
!= NULL
)
661 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
663 if ((s
->flags
& SEC_LOAD
) == 0
664 || (s
->flags
& SEC_READONLY
) == 0)
668 size
= bfd_get_section_size (s
);
669 if (vma
<= offset
&& offset
< (vma
+ size
))
673 amt
= (vma
+ size
) - offset
;
677 amt
= bfd_get_section_contents (exec_bfd
, s
,
678 readbuf
, offset
- vma
, amt
);
681 return TARGET_XFER_EOF
;
685 return TARGET_XFER_OK
;
691 /* Indicate failure to find the requested memory block. */
692 return TARGET_XFER_E_IO
;
695 /* Return all read-only memory ranges found in the target section
696 table defined by SECTIONS and SECTIONS_END, starting at (and
697 intersected with) MEMADDR for LEN bytes. */
699 static std::vector
<mem_range
>
700 section_table_available_memory (CORE_ADDR memaddr
, ULONGEST len
,
701 struct target_section
*sections
,
702 struct target_section
*sections_end
)
704 std::vector
<mem_range
> memory
;
706 for (target_section
*p
= sections
; p
< sections_end
; p
++)
708 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
710 & SEC_READONLY
) == 0)
713 /* Copy the meta-data, adjusted. */
714 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
716 ULONGEST lo1
, hi1
, lo2
, hi2
;
724 CORE_ADDR start
= std::max (lo1
, lo2
);
725 int length
= std::min (hi1
, hi2
) - start
;
727 memory
.emplace_back (start
, length
);
734 enum target_xfer_status
735 section_table_read_available_memory (gdb_byte
*readbuf
, ULONGEST offset
,
736 ULONGEST len
, ULONGEST
*xfered_len
)
738 target_section_table
*table
= target_get_section_table (&exec_ops
);
739 std::vector
<mem_range
> available_memory
740 = section_table_available_memory (offset
, len
,
741 table
->sections
, table
->sections_end
);
743 normalize_mem_ranges (&available_memory
);
745 for (const mem_range
&r
: available_memory
)
747 if (mem_ranges_overlap (r
.start
, r
.length
, offset
, len
))
750 enum target_xfer_status status
;
752 /* Get the intersection window. */
753 end
= std::min
<CORE_ADDR
> (offset
+ len
, r
.start
+ r
.length
);
755 gdb_assert (end
- offset
<= len
);
757 if (offset
>= r
.start
)
758 status
= exec_read_partial_read_only (readbuf
, offset
,
763 *xfered_len
= r
.start
- offset
;
764 status
= TARGET_XFER_UNAVAILABLE
;
771 return TARGET_XFER_UNAVAILABLE
;
774 enum target_xfer_status
775 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
776 ULONGEST offset
, ULONGEST len
,
777 ULONGEST
*xfered_len
,
778 struct target_section
*sections
,
779 struct target_section
*sections_end
,
780 const char *section_name
)
783 struct target_section
*p
;
784 ULONGEST memaddr
= offset
;
785 ULONGEST memend
= memaddr
+ len
;
788 internal_error (__FILE__
, __LINE__
,
789 _("failed internal consistency check"));
791 for (p
= sections
; p
< sections_end
; p
++)
793 struct bfd_section
*asect
= p
->the_bfd_section
;
794 bfd
*abfd
= asect
->owner
;
796 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
797 continue; /* not the section we need. */
798 if (memaddr
>= p
->addr
)
800 if (memend
<= p
->endaddr
)
802 /* Entire transfer is within this section. */
804 res
= bfd_set_section_contents (abfd
, asect
,
805 writebuf
, memaddr
- p
->addr
,
808 res
= bfd_get_section_contents (abfd
, asect
,
809 readbuf
, memaddr
- p
->addr
,
815 return TARGET_XFER_OK
;
818 return TARGET_XFER_EOF
;
820 else if (memaddr
>= p
->endaddr
)
822 /* This section ends before the transfer starts. */
827 /* This section overlaps the transfer. Just do half. */
828 len
= p
->endaddr
- memaddr
;
830 res
= bfd_set_section_contents (abfd
, asect
,
831 writebuf
, memaddr
- p
->addr
,
834 res
= bfd_get_section_contents (abfd
, asect
,
835 readbuf
, memaddr
- p
->addr
,
840 return TARGET_XFER_OK
;
843 return TARGET_XFER_EOF
;
848 return TARGET_XFER_EOF
; /* We can't help. */
851 static struct target_section_table
*
852 exec_get_section_table (struct target_ops
*ops
)
854 return current_target_sections
;
857 static enum target_xfer_status
858 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
859 const char *annex
, gdb_byte
*readbuf
,
860 const gdb_byte
*writebuf
,
861 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
863 struct target_section_table
*table
= target_get_section_table (ops
);
865 if (object
== TARGET_OBJECT_MEMORY
)
866 return section_table_xfer_memory_partial (readbuf
, writebuf
,
867 offset
, len
, xfered_len
,
872 return TARGET_XFER_E_IO
;
877 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
879 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
880 struct target_section
*p
;
881 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
882 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
884 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
886 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
887 if (abfd
== exec_bfd
)
889 /* gcc-3.4 does not like the initialization in
890 <p == t->sections_end>. */
891 bfd_vma displacement
= 0;
894 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
896 struct bfd_section
*psect
= p
->the_bfd_section
;
897 bfd
*pbfd
= psect
->owner
;
899 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
900 != (SEC_ALLOC
| SEC_LOAD
))
903 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
904 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
905 + bfd_get_section_size (psect
)))
907 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
911 if (p
== t
->sections_end
)
912 warning (_("Cannot find section for the entry point of %s."),
913 bfd_get_filename (abfd
));
915 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
916 bfd_get_start_address (abfd
)
918 printf_filtered (_("\tEntry point: %s\n"),
919 paddress (gdbarch
, entry_point
));
921 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
923 struct bfd_section
*psect
= p
->the_bfd_section
;
924 bfd
*pbfd
= psect
->owner
;
926 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
927 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
929 /* FIXME: A format of "08l" is not wide enough for file offsets
930 larger than 4GB. OTOH, making it "016l" isn't desirable either
931 since most output will then be much wider than necessary. It
932 may make sense to test the size of the file and choose the
933 format string accordingly. */
934 /* FIXME: i18n: Need to rewrite this sentence. */
936 printf_filtered (" @ %s",
937 hex_string_custom (psect
->filepos
, 8));
938 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
940 printf_filtered (" in %s", bfd_get_filename (pbfd
));
941 printf_filtered ("\n");
946 exec_files_info (struct target_ops
*t
)
949 print_section_info (current_target_sections
, exec_bfd
);
951 puts_filtered (_("\t<no file loaded>\n"));
955 set_section_command (const char *args
, int from_tty
)
957 struct target_section
*p
;
960 unsigned long secaddr
;
963 struct target_section_table
*table
;
966 error (_("Must specify section name and its virtual address"));
968 /* Parse out section name. */
969 for (secname
= args
; !isspace (*args
); args
++);
970 seclen
= args
- secname
;
972 /* Parse out new virtual address. */
973 secaddr
= parse_and_eval_address (args
);
975 table
= current_target_sections
;
976 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
978 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
979 p
->the_bfd_section
), seclen
)
980 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
982 offset
= secaddr
- p
->addr
;
984 p
->endaddr
+= offset
;
986 exec_files_info (&exec_ops
);
990 if (seclen
>= sizeof (secprint
))
991 seclen
= sizeof (secprint
) - 1;
992 strncpy (secprint
, secname
, seclen
);
993 secprint
[seclen
] = '\0';
994 error (_("Section %s not found"), secprint
);
997 /* If we can find a section in FILENAME with BFD index INDEX, adjust
1001 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
1003 struct target_section
*p
;
1004 struct target_section_table
*table
;
1006 table
= current_target_sections
;
1007 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1009 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
1010 && index
== p
->the_bfd_section
->index
)
1012 p
->endaddr
+= address
- p
->addr
;
1018 /* If mourn is being called in all the right places, this could be say
1019 `gdb internal error' (since generic_mourn calls
1020 breakpoint_init_inferior). */
1023 ignore (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
1024 struct bp_target_info
*bp_tgt
)
1029 /* Implement the to_remove_breakpoint method. */
1032 exec_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
1033 struct bp_target_info
*bp_tgt
,
1034 enum remove_bp_reason reason
)
1040 exec_has_memory (struct target_ops
*ops
)
1042 /* We can provide memory if we have any file/target sections to read
1044 return (current_target_sections
->sections
1045 != current_target_sections
->sections_end
);
1049 exec_make_note_section (struct target_ops
*self
, bfd
*obfd
, int *note_size
)
1051 error (_("Can't create a corefile"));
1054 /* Fill in the exec file target vector. Very few entries need to be
1058 init_exec_ops (void)
1060 exec_ops
.to_shortname
= "exec";
1061 exec_ops
.to_longname
= "Local exec file";
1062 exec_ops
.to_doc
= "Use an executable file as a target.\n\
1063 Specify the filename of the executable file.";
1064 exec_ops
.to_open
= exec_open
;
1065 exec_ops
.to_close
= exec_close_1
;
1066 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
1067 exec_ops
.to_get_section_table
= exec_get_section_table
;
1068 exec_ops
.to_files_info
= exec_files_info
;
1069 exec_ops
.to_insert_breakpoint
= ignore
;
1070 exec_ops
.to_remove_breakpoint
= exec_remove_breakpoint
;
1071 exec_ops
.to_stratum
= file_stratum
;
1072 exec_ops
.to_has_memory
= exec_has_memory
;
1073 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
1074 exec_ops
.to_find_memory_regions
= objfile_find_memory_regions
;
1075 exec_ops
.to_magic
= OPS_MAGIC
;
1079 _initialize_exec (void)
1081 struct cmd_list_element
*c
;
1087 c
= add_cmd ("file", class_files
, file_command
, _("\
1088 Use FILE as program to be debugged.\n\
1089 It is read for its symbols, for getting the contents of pure memory,\n\
1090 and it is the program executed when you use the `run' command.\n\
1091 If FILE cannot be found as specified, your execution directory path\n\
1092 ($PATH) is searched for a command of that name.\n\
1093 No arg means to have no executable file and no symbols."), &cmdlist
);
1094 set_cmd_completer (c
, filename_completer
);
1097 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
1098 Use FILE as program for getting contents of pure memory.\n\
1099 If FILE cannot be found as specified, your execution directory path\n\
1100 is searched for a command of that name.\n\
1101 No arg means have no executable file."), &cmdlist
);
1102 set_cmd_completer (c
, filename_completer
);
1104 add_com ("section", class_files
, set_section_command
, _("\
1105 Change the base address of section SECTION of the exec file to ADDR.\n\
1106 This can be used if the exec file does not contain section addresses,\n\
1107 (such as in the a.out format), or when the addresses specified in the\n\
1108 file itself are wrong. Each section must be changed separately. The\n\
1109 ``info files'' command lists all the sections and their addresses."));
1111 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
1112 Set writing into executable and core files."), _("\
1113 Show writing into executable and core files."), NULL
,
1116 &setlist
, &showlist
);
1118 add_target_with_completer (&exec_ops
, filename_completer
);