1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2013 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"
40 #include "gdb_string.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
, abfd
);
108 /* This is the target_close implementation. Clears all target
109 sections and closes all executable bfds from all program spaces. */
117 struct program_space
*ss
;
118 struct cleanup
*old_chain
;
120 old_chain
= save_current_program_space ();
123 set_current_program_space (ss
);
125 /* Delete all target sections. */
127 (current_target_sections
,
128 -resize_section_table (current_target_sections
, 0));
133 do_cleanups (old_chain
);
138 exec_file_clear (int from_tty
)
140 /* Remove exec file. */
144 printf_unfiltered (_("No executable file now.\n"));
147 /* Set FILENAME as the new exec file.
149 This function is intended to be behave essentially the same
150 as exec_file_command, except that the latter will detect when
151 a target is being debugged, and will ask the user whether it
152 should be shut down first. (If the answer is "no", then the
153 new file is ignored.)
155 This file is used by exec_file_command, to do the work of opening
156 and processing the exec file after any prompting has happened.
158 And, it is used by child_attach, when the attach command was
159 given a pid but not a exec pathname, and the attach command could
160 figure out the pathname from the pid. (In this case, we shouldn't
161 ask the user whether the current target should be shut down --
162 we're supplying the exec pathname late for good reason.) */
165 exec_file_attach (char *filename
, int from_tty
)
167 /* Remove any previous exec file. */
170 /* Now open and digest the file the user requested, if any. */
175 printf_unfiltered (_("No executable file now.\n"));
177 set_gdbarch_from_file (NULL
);
181 struct cleanup
*cleanups
;
182 char *scratch_pathname
;
184 struct target_section
*sections
= NULL
, *sections_end
= NULL
;
187 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, filename
,
188 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
190 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
191 if (scratch_chan
< 0)
193 char *exename
= alloca (strlen (filename
) + 5);
195 strcat (strcpy (exename
, filename
), ".exe");
196 scratch_chan
= openp (getenv ("PATH"), OPF_TRY_CWD_FIRST
, exename
,
197 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
,
201 if (scratch_chan
< 0)
202 perror_with_name (filename
);
204 cleanups
= make_cleanup (xfree
, scratch_pathname
);
207 exec_bfd
= gdb_bfd_fopen (scratch_pathname
, gnutarget
,
208 FOPEN_RUB
, scratch_chan
);
210 exec_bfd
= gdb_bfd_open (scratch_pathname
, gnutarget
, scratch_chan
);
214 error (_("\"%s\": could not open as an executable file: %s"),
215 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
218 if (!bfd_check_format_matches (exec_bfd
, bfd_object
, &matching
))
220 /* Make sure to close exec_bfd, or else "run" might try to use
223 error (_("\"%s\": not in executable format: %s"),
225 gdb_bfd_errmsg (bfd_get_error (), matching
));
228 if (build_section_table (exec_bfd
, §ions
, §ions_end
))
230 /* Make sure to close exec_bfd, or else "run" might try to use
233 error (_("\"%s\": can't find the file sections: %s"),
234 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
237 exec_bfd_mtime
= bfd_get_mtime (exec_bfd
);
241 set_gdbarch_from_file (exec_bfd
);
243 /* Add the executable's sections to the current address spaces'
244 list of sections. This possibly pushes the exec_ops
246 add_target_sections (&exec_bfd
, sections
, sections_end
);
249 /* Tell display code (if any) about the changed file name. */
250 if (deprecated_exec_file_display_hook
)
251 (*deprecated_exec_file_display_hook
) (filename
);
253 do_cleanups (cleanups
);
255 bfd_cache_close_all ();
256 observer_notify_executable_changed ();
259 /* Process the first arg in ARGS as the new exec file.
261 Note that we have to explicitly ignore additional args, since we can
262 be called from file_command(), which also calls symbol_file_command()
263 which can take multiple args.
265 If ARGS is NULL, we just want to close the exec file. */
268 exec_file_command (char *args
, int from_tty
)
273 if (from_tty
&& target_has_execution
274 && !query (_("A program is being debugged already.\n"
275 "Are you sure you want to change the file? ")))
276 error (_("File not changed."));
280 struct cleanup
*cleanups
;
282 /* Scan through the args and pick up the first non option arg
285 argv
= gdb_buildargv (args
);
286 cleanups
= make_cleanup_freeargv (argv
);
288 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
292 error (_("No executable file name was specified"));
294 filename
= tilde_expand (*argv
);
295 make_cleanup (xfree
, filename
);
296 exec_file_attach (filename
, from_tty
);
298 do_cleanups (cleanups
);
301 exec_file_attach (NULL
, from_tty
);
304 /* Set both the exec file and the symbol file, in one command.
305 What a novelty. Why did GDB go through four major releases before this
306 command was added? */
309 file_command (char *arg
, int from_tty
)
311 /* FIXME, if we lose on reading the symbol file, we should revert
312 the exec file, but that's rough. */
313 exec_file_command (arg
, from_tty
);
314 symbol_file_command (arg
, from_tty
);
315 if (deprecated_file_changed_hook
)
316 deprecated_file_changed_hook (arg
);
320 /* Locate all mappable sections of a BFD file.
321 table_pp_char is a char * to get it through bfd_map_over_sections;
322 we cast it back to its proper type. */
325 add_to_section_table (bfd
*abfd
, struct bfd_section
*asect
,
328 struct target_section
**table_pp
= (struct target_section
**) table_pp_char
;
331 /* Check the section flags, but do not discard zero-length sections, since
332 some symbols may still be attached to this section. For instance, we
333 encountered on sparc-solaris 2.10 a shared library with an empty .bss
334 section to which a symbol named "_end" was attached. The address
335 of this symbol still needs to be relocated. */
336 aflag
= bfd_get_section_flags (abfd
, asect
);
337 if (!(aflag
& SEC_ALLOC
))
340 (*table_pp
)->key
= NULL
;
341 (*table_pp
)->bfd
= abfd
;
342 (*table_pp
)->the_bfd_section
= asect
;
343 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
344 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
349 resize_section_table (struct target_section_table
*table
, int num_added
)
354 old_count
= table
->sections_end
- table
->sections
;
356 new_count
= num_added
+ old_count
;
360 table
->sections
= xrealloc (table
->sections
,
361 sizeof (struct target_section
) * new_count
);
362 table
->sections_end
= table
->sections
+ new_count
;
366 xfree (table
->sections
);
367 table
->sections
= table
->sections_end
= NULL
;
373 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
374 Returns 0 if OK, 1 on error. */
377 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
378 struct target_section
**end
)
382 count
= bfd_count_sections (some_bfd
);
385 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
387 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
388 if (*end
> *start
+ count
)
389 internal_error (__FILE__
, __LINE__
,
390 _("failed internal consistency check"));
391 /* We could realloc the table, but it probably loses for most files. */
395 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
396 current set of target sections. */
399 add_target_sections (void *key
,
400 struct target_section
*sections
,
401 struct target_section
*sections_end
)
404 struct target_section_table
*table
= current_target_sections
;
406 count
= sections_end
- sections
;
410 int space
= resize_section_table (table
, count
);
413 for (i
= 0; i
< count
; ++i
)
415 table
->sections
[space
+ i
] = sections
[i
];
416 table
->sections
[space
+ i
].key
= key
;
419 /* If these are the first file sections we can provide memory
420 from, push the file_stratum target. */
424 push_target (&exec_ops
);
429 /* Remove all target sections taken from ABFD. */
432 remove_target_sections (void *key
, bfd
*abfd
)
434 struct target_section
*src
, *dest
;
435 struct target_section_table
*table
= current_target_sections
;
437 dest
= table
->sections
;
438 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
439 if (src
->key
!= key
|| src
->bfd
!= abfd
)
441 /* Keep this section. */
447 /* If we've dropped any sections, resize the section table. */
452 old_count
= resize_section_table (table
, dest
- src
);
454 /* If we don't have any more sections to read memory from,
455 remove the file_stratum target from the stack. */
456 if (old_count
+ (dest
- src
) == 0)
458 struct program_space
*pspace
;
461 if (pspace
->target_sections
.sections
462 != pspace
->target_sections
.sections_end
)
465 unpush_target (&exec_ops
);
473 section_table_available_memory (VEC(mem_range_s
) *memory
,
474 CORE_ADDR memaddr
, ULONGEST len
,
475 struct target_section
*sections
,
476 struct target_section
*sections_end
)
478 struct target_section
*p
;
480 for (p
= sections
; p
< sections_end
; p
++)
482 if ((bfd_get_section_flags (p
->bfd
, p
->the_bfd_section
)
483 & SEC_READONLY
) == 0)
486 /* Copy the meta-data, adjusted. */
487 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
489 ULONGEST lo1
, hi1
, lo2
, hi2
;
498 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
500 r
->start
= max (lo1
, lo2
);
501 r
->length
= min (hi1
, hi2
) - r
->start
;
509 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
510 ULONGEST offset
, LONGEST len
,
511 struct target_section
*sections
,
512 struct target_section
*sections_end
,
513 const char *section_name
)
516 struct target_section
*p
;
517 ULONGEST memaddr
= offset
;
518 ULONGEST memend
= memaddr
+ len
;
521 internal_error (__FILE__
, __LINE__
,
522 _("failed internal consistency check"));
524 for (p
= sections
; p
< sections_end
; p
++)
526 if (section_name
&& strcmp (section_name
, p
->the_bfd_section
->name
) != 0)
527 continue; /* not the section we need. */
528 if (memaddr
>= p
->addr
)
530 if (memend
<= p
->endaddr
)
532 /* Entire transfer is within this section. */
534 res
= bfd_set_section_contents (p
->bfd
, p
->the_bfd_section
,
535 writebuf
, memaddr
- p
->addr
,
538 res
= bfd_get_section_contents (p
->bfd
, p
->the_bfd_section
,
539 readbuf
, memaddr
- p
->addr
,
541 return (res
!= 0) ? len
: 0;
543 else if (memaddr
>= p
->endaddr
)
545 /* This section ends before the transfer starts. */
550 /* This section overlaps the transfer. Just do half. */
551 len
= p
->endaddr
- memaddr
;
553 res
= bfd_set_section_contents (p
->bfd
, p
->the_bfd_section
,
554 writebuf
, memaddr
- p
->addr
,
557 res
= bfd_get_section_contents (p
->bfd
, p
->the_bfd_section
,
558 readbuf
, memaddr
- p
->addr
,
560 return (res
!= 0) ? len
: 0;
565 return 0; /* We can't help. */
568 static struct target_section_table
*
569 exec_get_section_table (struct target_ops
*ops
)
571 return current_target_sections
;
575 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
576 const char *annex
, gdb_byte
*readbuf
,
577 const gdb_byte
*writebuf
,
578 ULONGEST offset
, LONGEST len
)
580 struct target_section_table
*table
= target_get_section_table (ops
);
582 if (object
== TARGET_OBJECT_MEMORY
)
583 return section_table_xfer_memory_partial (readbuf
, writebuf
,
594 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
596 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
597 struct target_section
*p
;
598 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
599 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
601 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
603 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
604 if (abfd
== exec_bfd
)
606 /* gcc-3.4 does not like the initialization in
607 <p == t->sections_end>. */
608 bfd_vma displacement
= 0;
611 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
613 asection
*asect
= p
->the_bfd_section
;
615 if ((bfd_get_section_flags (abfd
, asect
) & (SEC_ALLOC
| SEC_LOAD
))
616 != (SEC_ALLOC
| SEC_LOAD
))
619 if (bfd_get_section_vma (abfd
, asect
) <= abfd
->start_address
620 && abfd
->start_address
< (bfd_get_section_vma (abfd
, asect
)
621 + bfd_get_section_size (asect
)))
623 displacement
= p
->addr
- bfd_get_section_vma (abfd
, asect
);
627 if (p
== t
->sections_end
)
628 warning (_("Cannot find section for the entry point of %s."),
629 bfd_get_filename (abfd
));
631 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
632 bfd_get_start_address (abfd
)
634 printf_filtered (_("\tEntry point: %s\n"),
635 paddress (gdbarch
, entry_point
));
637 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
639 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
640 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
642 /* FIXME: A format of "08l" is not wide enough for file offsets
643 larger than 4GB. OTOH, making it "016l" isn't desirable either
644 since most output will then be much wider than necessary. It
645 may make sense to test the size of the file and choose the
646 format string accordingly. */
647 /* FIXME: i18n: Need to rewrite this sentence. */
649 printf_filtered (" @ %s",
650 hex_string_custom (p
->the_bfd_section
->filepos
, 8));
651 printf_filtered (" is %s", bfd_section_name (p
->bfd
,
652 p
->the_bfd_section
));
654 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
655 printf_filtered ("\n");
660 exec_files_info (struct target_ops
*t
)
663 print_section_info (current_target_sections
, exec_bfd
);
665 puts_filtered (_("\t<no file loaded>\n"));
669 set_section_command (char *args
, int from_tty
)
671 struct target_section
*p
;
674 unsigned long secaddr
;
677 struct target_section_table
*table
;
680 error (_("Must specify section name and its virtual address"));
682 /* Parse out section name. */
683 for (secname
= args
; !isspace (*args
); args
++);
684 seclen
= args
- secname
;
686 /* Parse out new virtual address. */
687 secaddr
= parse_and_eval_address (args
);
689 table
= current_target_sections
;
690 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
692 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
693 p
->the_bfd_section
), seclen
)
694 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
696 offset
= secaddr
- p
->addr
;
698 p
->endaddr
+= offset
;
700 exec_files_info (&exec_ops
);
704 if (seclen
>= sizeof (secprint
))
705 seclen
= sizeof (secprint
) - 1;
706 strncpy (secprint
, secname
, seclen
);
707 secprint
[seclen
] = '\0';
708 error (_("Section %s not found"), secprint
);
711 /* If we can find a section in FILENAME with BFD index INDEX, adjust
715 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
717 struct target_section
*p
;
718 struct target_section_table
*table
;
720 table
= current_target_sections
;
721 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
723 if (filename_cmp (filename
, p
->bfd
->filename
) == 0
724 && index
== p
->the_bfd_section
->index
)
726 p
->endaddr
+= address
- p
->addr
;
732 /* If mourn is being called in all the right places, this could be say
733 `gdb internal error' (since generic_mourn calls
734 breakpoint_init_inferior). */
737 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
743 exec_has_memory (struct target_ops
*ops
)
745 /* We can provide memory if we have any file/target sections to read
747 return (current_target_sections
->sections
748 != current_target_sections
->sections_end
);
751 /* Find mapped memory. */
754 exec_set_find_memory_regions (int (*func
) (find_memory_region_ftype
, void *))
756 exec_ops
.to_find_memory_regions
= func
;
759 static char *exec_make_note_section (bfd
*, int *);
761 /* Fill in the exec file target vector. Very few entries need to be
767 exec_ops
.to_shortname
= "exec";
768 exec_ops
.to_longname
= "Local exec file";
769 exec_ops
.to_doc
= "Use an executable file as a target.\n\
770 Specify the filename of the executable file.";
771 exec_ops
.to_open
= exec_open
;
772 exec_ops
.to_close
= exec_close_1
;
773 exec_ops
.to_attach
= find_default_attach
;
774 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
775 exec_ops
.to_get_section_table
= exec_get_section_table
;
776 exec_ops
.to_files_info
= exec_files_info
;
777 exec_ops
.to_insert_breakpoint
= ignore
;
778 exec_ops
.to_remove_breakpoint
= ignore
;
779 exec_ops
.to_create_inferior
= find_default_create_inferior
;
780 exec_ops
.to_stratum
= file_stratum
;
781 exec_ops
.to_has_memory
= exec_has_memory
;
782 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
783 exec_ops
.to_magic
= OPS_MAGIC
;
787 _initialize_exec (void)
789 struct cmd_list_element
*c
;
795 c
= add_cmd ("file", class_files
, file_command
, _("\
796 Use FILE as program to be debugged.\n\
797 It is read for its symbols, for getting the contents of pure memory,\n\
798 and it is the program executed when you use the `run' command.\n\
799 If FILE cannot be found as specified, your execution directory path\n\
800 ($PATH) is searched for a command of that name.\n\
801 No arg means to have no executable file and no symbols."), &cmdlist
);
802 set_cmd_completer (c
, filename_completer
);
805 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
806 Use FILE as program for getting contents of pure memory.\n\
807 If FILE cannot be found as specified, your execution directory path\n\
808 is searched for a command of that name.\n\
809 No arg means have no executable file."), &cmdlist
);
810 set_cmd_completer (c
, filename_completer
);
812 add_com ("section", class_files
, set_section_command
, _("\
813 Change the base address of section SECTION of the exec file to ADDR.\n\
814 This can be used if the exec file does not contain section addresses,\n\
815 (such as in the a.out format), or when the addresses specified in the\n\
816 file itself are wrong. Each section must be changed separately. The\n\
817 ``info files'' command lists all the sections and their addresses."));
819 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
820 Set writing into executable and core files."), _("\
821 Show writing into executable and core files."), NULL
,
824 &setlist
, &showlist
);
826 add_target_with_completer (&exec_ops
, filename_completer
);
830 exec_make_note_section (bfd
*obfd
, int *note_size
)
832 error (_("Can't create a corefile"));