1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2014 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"
39 #include "readline/readline.h"
47 void (*deprecated_file_changed_hook
) (char *);
49 /* Prototypes for local functions */
51 static void file_command (char *, int);
53 static void set_section_command (char *, int);
55 static void exec_files_info (struct target_ops
*);
57 static void init_exec_ops (void);
59 void _initialize_exec (void);
61 /* The target vector for executable files. */
63 struct target_ops exec_ops
;
65 /* True if the exec target is pushed on the stack. */
66 static int using_exec_ops
;
68 /* Whether to open exec and core files read-only or read-write. */
72 show_write_files (struct ui_file
*file
, int from_tty
,
73 struct cmd_list_element
*c
, const char *value
)
75 fprintf_filtered (file
, _("Writing into executable and core files is %s.\n"),
81 exec_open (char *args
, int from_tty
)
83 target_preopen (from_tty
);
84 exec_file_attach (args
, from_tty
);
87 /* Close and clear exec_bfd. If we end up with no target sections to
88 read memory from, this unpushes the exec_ops target. */
99 /* Removing target sections may close the exec_ops target.
100 Clear exec_bfd before doing so to prevent recursion. */
104 remove_target_sections (&exec_bfd
);
106 xfree (exec_filename
);
107 exec_filename
= NULL
;
111 /* This is the target_close implementation. Clears all target
112 sections and closes all executable bfds from all program spaces. */
120 struct program_space
*ss
;
121 struct cleanup
*old_chain
;
123 old_chain
= save_current_program_space ();
126 set_current_program_space (ss
);
128 /* Delete all target sections. */
130 (current_target_sections
,
131 -resize_section_table (current_target_sections
, 0));
136 do_cleanups (old_chain
);
141 exec_file_clear (int from_tty
)
143 /* Remove exec file. */
147 printf_unfiltered (_("No executable file now.\n"));
150 /* Set FILENAME as the new exec file.
152 This function is intended to be behave essentially the same
153 as exec_file_command, except that the latter will detect when
154 a target is being debugged, and will ask the user whether it
155 should be shut down first. (If the answer is "no", then the
156 new file is ignored.)
158 This file is used by exec_file_command, to do the work of opening
159 and processing the exec file after any prompting has happened.
161 And, it is used by child_attach, when the attach command was
162 given a pid but not a exec pathname, and the attach command could
163 figure out the pathname from the pid. (In this case, we shouldn't
164 ask the user whether the current target should be shut down --
165 we're supplying the exec pathname late for good reason.) */
168 exec_file_attach (char *filename
, int from_tty
)
170 /* Remove any previous exec file. */
173 /* Now open and digest the file the user requested, if any. */
178 printf_unfiltered (_("No executable file now.\n"));
180 set_gdbarch_from_file (NULL
);
184 struct cleanup
*cleanups
;
185 char *scratch_pathname
, *canonical_pathname
;
187 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
190 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, filename
,
191 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
193 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
194 if (scratch_chan
< 0)
196 char *exename
= alloca (strlen (filename
) + 5);
198 strcat (strcpy (exename
, filename
), ".exe");
199 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
200 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
204 if (scratch_chan
< 0)
205 perror_with_name (filename
);
207 cleanups
= make_cleanup (xfree
, scratch_pathname
);
209 /* gdb_bfd_open (and its variants) prefers canonicalized pathname for
210 better BFD caching. */
211 canonical_pathname
= gdb_realpath (scratch_pathname
);
212 make_cleanup (xfree
, canonical_pathname
);
215 exec_bfd
= gdb_bfd_fopen (canonical_pathname
, gnutarget
,
216 FOPEN_RUB
, scratch_chan
);
218 exec_bfd
= gdb_bfd_open (canonical_pathname
, gnutarget
, scratch_chan
);
222 error (_("\"%s\": could not open as an executable file: %s"),
223 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
226 gdb_assert (exec_filename
== NULL
);
227 exec_filename
= gdb_realpath_keepfile (scratch_pathname
);
229 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
231 /* Make sure to close exec_bfd, or else "run" might try to use
234 error (_("\"%s\": not in executable format: %s"),
236 gdb_bfd_errmsg (bfd_get_error (), matching
));
239 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
241 /* Make sure to close exec_bfd, or else "run" might try to use
244 error (_("\"%s\": can't find the file sections: %s"),
245 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
248 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
252 set_gdbarch_from_file (exec_bfd
);
254 /* Add the executable's sections to the current address spaces'
255 list of sections. This possibly pushes the exec_ops
257 add_target_sections (&exec_bfd
, sections
, sections_end
);
260 /* Tell display code (if any) about the changed file name. */
261 if (deprecated_exec_file_display_hook
)
262 (*deprecated_exec_file_display_hook
) (filename
);
264 do_cleanups (cleanups
);
266 bfd_cache_close_all ();
267 observer_notify_executable_changed ();
270 /* Process the first arg in ARGS as the new exec file.
272 Note that we have to explicitly ignore additional args, since we can
273 be called from file_command(), which also calls symbol_file_command()
274 which can take multiple args.
276 If ARGS is NULL, we just want to close the exec file. */
279 exec_file_command (char *args
, int from_tty
)
284 if (from_tty
&& target_has_execution
285 && !query (_("A program is being debugged already.\n"
286 "Are you sure you want to change the file? ")))
287 error (_("File not changed."));
291 struct cleanup
*cleanups
;
293 /* Scan through the args and pick up the first non option arg
296 argv
= gdb_buildargv (args
);
297 cleanups
= make_cleanup_freeargv (argv
);
299 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
303 error (_("No executable file name was specified"));
305 filename
= tilde_expand (*argv
);
306 make_cleanup (xfree
, filename
);
307 exec_file_attach (filename
, from_tty
);
309 do_cleanups (cleanups
);
312 exec_file_attach (NULL
, from_tty
);
315 /* Set both the exec file and the symbol file, in one command.
316 What a novelty. Why did GDB go through four major releases before this
317 command was added? */
320 file_command (char *arg
, int from_tty
)
322 /* FIXME, if we lose on reading the symbol file, we should revert
323 the exec file, but that's rough. */
324 exec_file_command (arg
, from_tty
);
325 symbol_file_command (arg
, from_tty
);
326 if (deprecated_file_changed_hook
)
327 deprecated_file_changed_hook (arg
);
331 /* Locate all mappable sections of a BFD file.
332 table_pp_char is a char * to get it through bfd_map_over_sections;
333 we cast it back to its proper type. */
336 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
339 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
342 gdb_assert (abfd
== asect
->owner
);
344 /* Check the section flags, but do not discard zero-length sections, since
345 some symbols may still be attached to this section. For instance, we
346 encountered on sparc-solaris 2.10 a shared library with an empty .bss
347 section to which a symbol named "_end" was attached. The address
348 of this symbol still needs to be relocated. */
349 aflag
= bfd_get_section_flags (abfd
, asect
);
350 if (!(aflag
& SEC_ALLOC
))
353 (*table_pp
)->owner
= NULL
;
354 (*table_pp
)->the_bfd_section
= asect
;
355 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
356 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
361 resize_section_table (struct target_section_table
*table
, int num_added
)
366 old_count
= table
->sections_end
- table
->sections
;
368 new_count
= num_added
+ old_count
;
372 table
->sections
= xrealloc (table
->sections
,
373 sizeof (struct target_section
) * new_count
);
374 table
->sections_end
= table
->sections
+ new_count
;
378 xfree (table
->sections
);
379 table
->sections
= table
->sections_end
= NULL
;
385 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
386 Returns 0 if OK, 1 on error. */
389 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
390 struct target_section
**end
)
394 count
= bfd_count_sections (some_bfd
);
397 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
399 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
400 if (*end
> *start
+ count
)
401 internal_error (__FILE__
, __LINE__
,
402 _("failed internal consistency check"));
403 /* We could realloc the table, but it probably loses for most files. */
407 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
408 current set of target sections. */
411 add_target_sections (void *owner
,
412 struct target_section
*sections
,
413 struct target_section
*sections_end
)
416 struct target_section_table
*table
= current_target_sections
;
418 count
= sections_end
- sections
;
422 int space
= resize_section_table (table
, count
);
425 for (i
= 0; i
< count
; ++i
)
427 table
->sections
[space
+ i
] = sections
[i
];
428 table
->sections
[space
+ i
].owner
= owner
;
431 /* If these are the first file sections we can provide memory
432 from, push the file_stratum target. */
436 push_target (&exec_ops
);
441 /* Add the sections of OBJFILE to the current set of target sections. */
444 add_target_sections_of_objfile (struct objfile
*objfile
)
446 struct target_section_table
*table
= current_target_sections
;
447 struct obj_section
*osect
;
450 struct target_section
*ts
;
455 /* Compute the number of sections to add. */
456 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
458 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
466 space
= resize_section_table (table
, count
);
468 ts
= table
->sections
+ space
;
470 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
472 if (bfd_get_section_size (osect
->the_bfd_section
) == 0)
475 gdb_assert (ts
< table
->sections
+ space
+ count
);
477 ts
->addr
= obj_section_addr (osect
);
478 ts
->endaddr
= obj_section_endaddr (osect
);
479 ts
->the_bfd_section
= osect
->the_bfd_section
;
480 ts
->owner
= (void *) objfile
;
486 /* Remove all target sections owned by OWNER.
487 OWNER must be the same value passed to add_target_sections. */
490 remove_target_sections (void *owner
)
492 struct target_section
*src
, *dest
;
493 struct target_section_table
*table
= current_target_sections
;
495 gdb_assert (owner
!= NULL
);
497 dest
= table
->sections
;
498 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
499 if (src
->owner
!= owner
)
501 /* Keep this section. */
507 /* If we've dropped any sections, resize the section table. */
512 old_count
= resize_section_table (table
, dest
- src
);
514 /* If we don't have any more sections to read memory from,
515 remove the file_stratum target from the stack. */
516 if (old_count
+ (dest
- src
) == 0)
518 struct program_space
*pspace
;
521 if (pspace
->target_sections
.sections
522 != pspace
->target_sections
.sections_end
)
525 unpush_target (&exec_ops
);
533 section_table_available_memory (VEC(mem_range_s
) *memory
,
534 CORE_ADDR memaddr
, ULONGEST len
,
535 struct target_section
*sections
,
536 struct target_section
*sections_end
)
538 struct target_section
*p
;
540 for (p
= sections
; p
< sections_end
; p
++)
542 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
544 & SEC_READONLY
) == 0)
547 /* Copy the meta-data, adjusted. */
548 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
550 ULONGEST lo1
, hi1
, lo2
, hi2
;
559 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
561 r
->start
= max (lo1
, lo2
);
562 r
->length
= min (hi1
, hi2
) - r
->start
;
569 enum target_xfer_status
570 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
571 ULONGEST offset
, ULONGEST len
,
572 ULONGEST
*xfered_len
,
573 struct target_section
*sections
,
574 struct target_section
*sections_end
,
575 const char *section_name
)
578 struct target_section
*p
;
579 ULONGEST memaddr
= offset
;
580 ULONGEST memend
= memaddr
+ len
;
583 internal_error (__FILE__
, __LINE__
,
584 _("failed internal consistency check"));
586 for (p
= sections
; p
< sections_end
; p
++)
588 struct bfd_section
*asect
= p
->the_bfd_section
;
589 bfd
*abfd
= asect
->owner
;
591 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
592 continue; /* not the section we need. */
593 if (memaddr
>= p
->addr
)
595 if (memend
<= p
->endaddr
)
597 /* Entire transfer is within this section. */
599 res
= bfd_set_section_contents (abfd
, asect
,
600 writebuf
, memaddr
- p
->addr
,
603 res
= bfd_get_section_contents (abfd
, asect
,
604 readbuf
, memaddr
- p
->addr
,
610 return TARGET_XFER_OK
;
613 return TARGET_XFER_EOF
;
615 else if (memaddr
>= p
->endaddr
)
617 /* This section ends before the transfer starts. */
622 /* This section overlaps the transfer. Just do half. */
623 len
= p
->endaddr
- memaddr
;
625 res
= bfd_set_section_contents (abfd
, asect
,
626 writebuf
, memaddr
- p
->addr
,
629 res
= bfd_get_section_contents (abfd
, asect
,
630 readbuf
, memaddr
- p
->addr
,
635 return TARGET_XFER_OK
;
638 return TARGET_XFER_EOF
;
643 return TARGET_XFER_EOF
; /* We can't help. */
646 static struct target_section_table
*
647 exec_get_section_table (struct target_ops
*ops
)
649 return current_target_sections
;
652 static enum target_xfer_status
653 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
654 const char *annex
, gdb_byte
*readbuf
,
655 const gdb_byte
*writebuf
,
656 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
658 struct target_section_table
*table
= target_get_section_table (ops
);
660 if (object
== TARGET_OBJECT_MEMORY
)
661 return section_table_xfer_memory_partial (readbuf
, writebuf
,
662 offset
, len
, xfered_len
,
667 return TARGET_XFER_E_IO
;
672 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
674 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
675 struct target_section
*p
;
676 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
677 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
679 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
681 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
682 if (abfd
== exec_bfd
)
684 /* gcc-3.4 does not like the initialization in
685 <p == t->sections_end>. */
686 bfd_vma displacement
= 0;
689 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
691 struct bfd_section
*psect
= p
->the_bfd_section
;
692 bfd
*pbfd
= psect
->owner
;
694 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
695 != (SEC_ALLOC
| SEC_LOAD
))
698 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
699 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
700 + bfd_get_section_size (psect
)))
702 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
706 if (p
== t
->sections_end
)
707 warning (_("Cannot find section for the entry point of %s."),
708 bfd_get_filename (abfd
));
710 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
711 bfd_get_start_address (abfd
)
713 printf_filtered (_("\tEntry point: %s\n"),
714 paddress (gdbarch
, entry_point
));
716 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
718 struct bfd_section
*psect
= p
->the_bfd_section
;
719 bfd
*pbfd
= psect
->owner
;
721 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
722 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
724 /* FIXME: A format of "08l" is not wide enough for file offsets
725 larger than 4GB. OTOH, making it "016l" isn't desirable either
726 since most output will then be much wider than necessary. It
727 may make sense to test the size of the file and choose the
728 format string accordingly. */
729 /* FIXME: i18n: Need to rewrite this sentence. */
731 printf_filtered (" @ %s",
732 hex_string_custom (psect
->filepos
, 8));
733 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
735 printf_filtered (" in %s", bfd_get_filename (pbfd
));
736 printf_filtered ("\n");
741 exec_files_info (struct target_ops
*t
)
744 print_section_info (current_target_sections
, exec_bfd
);
746 puts_filtered (_("\t<no file loaded>\n"));
750 set_section_command (char *args
, int from_tty
)
752 struct target_section
*p
;
755 unsigned long secaddr
;
758 struct target_section_table
*table
;
761 error (_("Must specify section name and its virtual address"));
763 /* Parse out section name. */
764 for (secname
= args
; !isspace (*args
); args
++);
765 seclen
= args
- secname
;
767 /* Parse out new virtual address. */
768 secaddr
= parse_and_eval_address (args
);
770 table
= current_target_sections
;
771 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
773 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
774 p
->the_bfd_section
), seclen
)
775 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
777 offset
= secaddr
- p
->addr
;
779 p
->endaddr
+= offset
;
781 exec_files_info (&exec_ops
);
785 if (seclen
>= sizeof (secprint
))
786 seclen
= sizeof (secprint
) - 1;
787 strncpy (secprint
, secname
, seclen
);
788 secprint
[seclen
] = '\0';
789 error (_("Section %s not found"), secprint
);
792 /* If we can find a section in FILENAME with BFD index INDEX, adjust
796 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
798 struct target_section
*p
;
799 struct target_section_table
*table
;
801 table
= current_target_sections
;
802 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
804 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
805 && index
== p
->the_bfd_section
->index
)
807 p
->endaddr
+= address
- p
->addr
;
813 /* If mourn is being called in all the right places, this could be say
814 `gdb internal error' (since generic_mourn calls
815 breakpoint_init_inferior). */
818 ignore (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
819 struct bp_target_info
*bp_tgt
)
825 exec_has_memory (struct target_ops
*ops
)
827 /* We can provide memory if we have any file/target sections to read
829 return (current_target_sections
->sections
830 != current_target_sections
->sections_end
);
833 /* Find mapped memory. */
836 exec_set_find_memory_regions (int (*func
) (find_memory_region_ftype
, void *))
838 exec_ops
.to_find_memory_regions
= func
;
841 static char *exec_make_note_section (bfd
*, int *);
843 /* Fill in the exec file target vector. Very few entries need to be
849 exec_ops
.to_shortname
= "exec";
850 exec_ops
.to_longname
= "Local exec file";
851 exec_ops
.to_doc
= "Use an executable file as a target.\n\
852 Specify the filename of the executable file.";
853 exec_ops
.to_open
= exec_open
;
854 exec_ops
.to_close
= exec_close_1
;
855 exec_ops
.to_attach
= find_default_attach
;
856 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
857 exec_ops
.to_get_section_table
= exec_get_section_table
;
858 exec_ops
.to_files_info
= exec_files_info
;
859 exec_ops
.to_insert_breakpoint
= ignore
;
860 exec_ops
.to_remove_breakpoint
= ignore
;
861 exec_ops
.to_create_inferior
= find_default_create_inferior
;
862 exec_ops
.to_stratum
= file_stratum
;
863 exec_ops
.to_has_memory
= exec_has_memory
;
864 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
865 exec_ops
.to_magic
= OPS_MAGIC
;
869 _initialize_exec (void)
871 struct cmd_list_element
*c
;
877 c
= add_cmd ("file", class_files
, file_command
, _("\
878 Use FILE as program to be debugged.\n\
879 It is read for its symbols, for getting the contents of pure memory,\n\
880 and it is the program executed when you use the `run' command.\n\
881 If FILE cannot be found as specified, your execution directory path\n\
882 ($PATH) is searched for a command of that name.\n\
883 No arg means to have no executable file and no symbols."), &cmdlist
);
884 set_cmd_completer (c
, filename_completer
);
887 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
888 Use FILE as program for getting contents of pure memory.\n\
889 If FILE cannot be found as specified, your execution directory path\n\
890 is searched for a command of that name.\n\
891 No arg means have no executable file."), &cmdlist
);
892 set_cmd_completer (c
, filename_completer
);
894 add_com ("section", class_files
, set_section_command
, _("\
895 Change the base address of section SECTION of the exec file to ADDR.\n\
896 This can be used if the exec file does not contain section addresses,\n\
897 (such as in the a.out format), or when the addresses specified in the\n\
898 file itself are wrong. Each section must be changed separately. The\n\
899 ``info files'' command lists all the sections and their addresses."));
901 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
902 Set writing into executable and core files."), _("\
903 Show writing into executable and core files."), NULL
,
906 &setlist
, &showlist
);
908 add_target_with_completer (&exec_ops
, filename_completer
);
912 exec_make_note_section (bfd
*obfd
, int *note_size
)
914 error (_("Can't create a corefile"));