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 gdb_assert (abfd
== asect
->owner
);
333 /* Check the section flags, but do not discard zero-length sections, since
334 some symbols may still be attached to this section. For instance, we
335 encountered on sparc-solaris 2.10 a shared library with an empty .bss
336 section to which a symbol named "_end" was attached. The address
337 of this symbol still needs to be relocated. */
338 aflag
= bfd_get_section_flags (abfd
, asect
);
339 if (!(aflag
& SEC_ALLOC
))
342 (*table_pp
)->key
= NULL
;
343 (*table_pp
)->the_bfd_section
= asect
;
344 (*table_pp
)->addr
= bfd_section_vma (abfd
, asect
);
345 (*table_pp
)->endaddr
= (*table_pp
)->addr
+ bfd_section_size (abfd
, asect
);
350 resize_section_table (struct target_section_table
*table
, int num_added
)
355 old_count
= table
->sections_end
- table
->sections
;
357 new_count
= num_added
+ old_count
;
361 table
->sections
= xrealloc (table
->sections
,
362 sizeof (struct target_section
) * new_count
);
363 table
->sections_end
= table
->sections
+ new_count
;
367 xfree (table
->sections
);
368 table
->sections
= table
->sections_end
= NULL
;
374 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
375 Returns 0 if OK, 1 on error. */
378 build_section_table (struct bfd
*some_bfd
, struct target_section
**start
,
379 struct target_section
**end
)
383 count
= bfd_count_sections (some_bfd
);
386 *start
= (struct target_section
*) xmalloc (count
* sizeof (**start
));
388 bfd_map_over_sections (some_bfd
, add_to_section_table
, (char *) end
);
389 if (*end
> *start
+ count
)
390 internal_error (__FILE__
, __LINE__
,
391 _("failed internal consistency check"));
392 /* We could realloc the table, but it probably loses for most files. */
396 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
397 current set of target sections. */
400 add_target_sections (void *key
,
401 struct target_section
*sections
,
402 struct target_section
*sections_end
)
405 struct target_section_table
*table
= current_target_sections
;
407 count
= sections_end
- sections
;
411 int space
= resize_section_table (table
, count
);
414 for (i
= 0; i
< count
; ++i
)
416 table
->sections
[space
+ i
] = sections
[i
];
417 table
->sections
[space
+ i
].key
= key
;
420 /* If these are the first file sections we can provide memory
421 from, push the file_stratum target. */
425 push_target (&exec_ops
);
430 /* Remove all target sections taken from ABFD. */
433 remove_target_sections (void *key
, bfd
*abfd
)
435 struct target_section
*src
, *dest
;
436 struct target_section_table
*table
= current_target_sections
;
438 dest
= table
->sections
;
439 for (src
= table
->sections
; src
< table
->sections_end
; src
++)
440 if (src
->key
!= key
|| src
->the_bfd_section
->owner
!= abfd
)
442 /* Keep this section. */
448 /* If we've dropped any sections, resize the section table. */
453 old_count
= resize_section_table (table
, dest
- src
);
455 /* If we don't have any more sections to read memory from,
456 remove the file_stratum target from the stack. */
457 if (old_count
+ (dest
- src
) == 0)
459 struct program_space
*pspace
;
462 if (pspace
->target_sections
.sections
463 != pspace
->target_sections
.sections_end
)
466 unpush_target (&exec_ops
);
474 section_table_available_memory (VEC(mem_range_s
) *memory
,
475 CORE_ADDR memaddr
, ULONGEST len
,
476 struct target_section
*sections
,
477 struct target_section
*sections_end
)
479 struct target_section
*p
;
481 for (p
= sections
; p
< sections_end
; p
++)
483 if ((bfd_get_section_flags (p
->the_bfd_section
->owner
,
485 & SEC_READONLY
) == 0)
488 /* Copy the meta-data, adjusted. */
489 if (mem_ranges_overlap (p
->addr
, p
->endaddr
- p
->addr
, memaddr
, len
))
491 ULONGEST lo1
, hi1
, lo2
, hi2
;
500 r
= VEC_safe_push (mem_range_s
, memory
, NULL
);
502 r
->start
= max (lo1
, lo2
);
503 r
->length
= min (hi1
, hi2
) - r
->start
;
511 section_table_xfer_memory_partial (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
512 ULONGEST offset
, LONGEST len
,
513 struct target_section
*sections
,
514 struct target_section
*sections_end
,
515 const char *section_name
)
518 struct target_section
*p
;
519 ULONGEST memaddr
= offset
;
520 ULONGEST memend
= memaddr
+ len
;
523 internal_error (__FILE__
, __LINE__
,
524 _("failed internal consistency check"));
526 for (p
= sections
; p
< sections_end
; p
++)
528 struct bfd_section
*asect
= p
->the_bfd_section
;
529 bfd
*abfd
= asect
->owner
;
531 if (section_name
&& strcmp (section_name
, asect
->name
) != 0)
532 continue; /* not the section we need. */
533 if (memaddr
>= p
->addr
)
535 if (memend
<= p
->endaddr
)
537 /* Entire transfer is within this section. */
539 res
= bfd_set_section_contents (abfd
, asect
,
540 writebuf
, memaddr
- p
->addr
,
543 res
= bfd_get_section_contents (abfd
, asect
,
544 readbuf
, memaddr
- p
->addr
,
546 return (res
!= 0) ? len
: 0;
548 else if (memaddr
>= p
->endaddr
)
550 /* This section ends before the transfer starts. */
555 /* This section overlaps the transfer. Just do half. */
556 len
= p
->endaddr
- memaddr
;
558 res
= bfd_set_section_contents (abfd
, asect
,
559 writebuf
, memaddr
- p
->addr
,
562 res
= bfd_get_section_contents (abfd
, asect
,
563 readbuf
, memaddr
- p
->addr
,
565 return (res
!= 0) ? len
: 0;
570 return 0; /* We can't help. */
573 static struct target_section_table
*
574 exec_get_section_table (struct target_ops
*ops
)
576 return current_target_sections
;
580 exec_xfer_partial (struct target_ops
*ops
, enum target_object object
,
581 const char *annex
, gdb_byte
*readbuf
,
582 const gdb_byte
*writebuf
,
583 ULONGEST offset
, LONGEST len
)
585 struct target_section_table
*table
= target_get_section_table (ops
);
587 if (object
== TARGET_OBJECT_MEMORY
)
588 return section_table_xfer_memory_partial (readbuf
, writebuf
,
599 print_section_info (struct target_section_table
*t
, bfd
*abfd
)
601 struct gdbarch
*gdbarch
= gdbarch_from_bfd (abfd
);
602 struct target_section
*p
;
603 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
604 int wid
= gdbarch_addr_bit (gdbarch
) <= 32 ? 8 : 16;
606 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
608 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd
));
609 if (abfd
== exec_bfd
)
611 /* gcc-3.4 does not like the initialization in
612 <p == t->sections_end>. */
613 bfd_vma displacement
= 0;
616 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
618 struct bfd_section
*psect
= p
->the_bfd_section
;
619 bfd
*pbfd
= psect
->owner
;
621 if ((bfd_get_section_flags (pbfd
, psect
) & (SEC_ALLOC
| SEC_LOAD
))
622 != (SEC_ALLOC
| SEC_LOAD
))
625 if (bfd_get_section_vma (pbfd
, psect
) <= abfd
->start_address
626 && abfd
->start_address
< (bfd_get_section_vma (pbfd
, psect
)
627 + bfd_get_section_size (psect
)))
629 displacement
= p
->addr
- bfd_get_section_vma (pbfd
, psect
);
633 if (p
== t
->sections_end
)
634 warning (_("Cannot find section for the entry point of %s."),
635 bfd_get_filename (abfd
));
637 entry_point
= gdbarch_addr_bits_remove (gdbarch
,
638 bfd_get_start_address (abfd
)
640 printf_filtered (_("\tEntry point: %s\n"),
641 paddress (gdbarch
, entry_point
));
643 for (p
= t
->sections
; p
< t
->sections_end
; p
++)
645 struct bfd_section
*psect
= p
->the_bfd_section
;
646 bfd
*pbfd
= psect
->owner
;
648 printf_filtered ("\t%s", hex_string_custom (p
->addr
, wid
));
649 printf_filtered (" - %s", hex_string_custom (p
->endaddr
, wid
));
651 /* FIXME: A format of "08l" is not wide enough for file offsets
652 larger than 4GB. OTOH, making it "016l" isn't desirable either
653 since most output will then be much wider than necessary. It
654 may make sense to test the size of the file and choose the
655 format string accordingly. */
656 /* FIXME: i18n: Need to rewrite this sentence. */
658 printf_filtered (" @ %s",
659 hex_string_custom (psect
->filepos
, 8));
660 printf_filtered (" is %s", bfd_section_name (pbfd
, psect
));
662 printf_filtered (" in %s", bfd_get_filename (pbfd
));
663 printf_filtered ("\n");
668 exec_files_info (struct target_ops
*t
)
671 print_section_info (current_target_sections
, exec_bfd
);
673 puts_filtered (_("\t<no file loaded>\n"));
677 set_section_command (char *args
, int from_tty
)
679 struct target_section
*p
;
682 unsigned long secaddr
;
685 struct target_section_table
*table
;
688 error (_("Must specify section name and its virtual address"));
690 /* Parse out section name. */
691 for (secname
= args
; !isspace (*args
); args
++);
692 seclen
= args
- secname
;
694 /* Parse out new virtual address. */
695 secaddr
= parse_and_eval_address (args
);
697 table
= current_target_sections
;
698 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
700 if (!strncmp (secname
, bfd_section_name (p
->bfd
,
701 p
->the_bfd_section
), seclen
)
702 && bfd_section_name (p
->bfd
, p
->the_bfd_section
)[seclen
] == '\0')
704 offset
= secaddr
- p
->addr
;
706 p
->endaddr
+= offset
;
708 exec_files_info (&exec_ops
);
712 if (seclen
>= sizeof (secprint
))
713 seclen
= sizeof (secprint
) - 1;
714 strncpy (secprint
, secname
, seclen
);
715 secprint
[seclen
] = '\0';
716 error (_("Section %s not found"), secprint
);
719 /* If we can find a section in FILENAME with BFD index INDEX, adjust
723 exec_set_section_address (const char *filename
, int index
, CORE_ADDR address
)
725 struct target_section
*p
;
726 struct target_section_table
*table
;
728 table
= current_target_sections
;
729 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
731 if (filename_cmp (filename
, p
->the_bfd_section
->owner
->filename
) == 0
732 && index
== p
->the_bfd_section
->index
)
734 p
->endaddr
+= address
- p
->addr
;
740 /* If mourn is being called in all the right places, this could be say
741 `gdb internal error' (since generic_mourn calls
742 breakpoint_init_inferior). */
745 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
751 exec_has_memory (struct target_ops
*ops
)
753 /* We can provide memory if we have any file/target sections to read
755 return (current_target_sections
->sections
756 != current_target_sections
->sections_end
);
759 /* Find mapped memory. */
762 exec_set_find_memory_regions (int (*func
) (find_memory_region_ftype
, void *))
764 exec_ops
.to_find_memory_regions
= func
;
767 static char *exec_make_note_section (bfd
*, int *);
769 /* Fill in the exec file target vector. Very few entries need to be
775 exec_ops
.to_shortname
= "exec";
776 exec_ops
.to_longname
= "Local exec file";
777 exec_ops
.to_doc
= "Use an executable file as a target.\n\
778 Specify the filename of the executable file.";
779 exec_ops
.to_open
= exec_open
;
780 exec_ops
.to_close
= exec_close_1
;
781 exec_ops
.to_attach
= find_default_attach
;
782 exec_ops
.to_xfer_partial
= exec_xfer_partial
;
783 exec_ops
.to_get_section_table
= exec_get_section_table
;
784 exec_ops
.to_files_info
= exec_files_info
;
785 exec_ops
.to_insert_breakpoint
= ignore
;
786 exec_ops
.to_remove_breakpoint
= ignore
;
787 exec_ops
.to_create_inferior
= find_default_create_inferior
;
788 exec_ops
.to_stratum
= file_stratum
;
789 exec_ops
.to_has_memory
= exec_has_memory
;
790 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
791 exec_ops
.to_magic
= OPS_MAGIC
;
795 _initialize_exec (void)
797 struct cmd_list_element
*c
;
803 c
= add_cmd ("file", class_files
, file_command
, _("\
804 Use FILE as program to be debugged.\n\
805 It is read for its symbols, for getting the contents of pure memory,\n\
806 and it is the program executed when you use the `run' command.\n\
807 If FILE cannot be found as specified, your execution directory path\n\
808 ($PATH) is searched for a command of that name.\n\
809 No arg means to have no executable file and no symbols."), &cmdlist
);
810 set_cmd_completer (c
, filename_completer
);
813 c
= add_cmd ("exec-file", class_files
, exec_file_command
, _("\
814 Use FILE as program for getting contents of pure memory.\n\
815 If FILE cannot be found as specified, your execution directory path\n\
816 is searched for a command of that name.\n\
817 No arg means have no executable file."), &cmdlist
);
818 set_cmd_completer (c
, filename_completer
);
820 add_com ("section", class_files
, set_section_command
, _("\
821 Change the base address of section SECTION of the exec file to ADDR.\n\
822 This can be used if the exec file does not contain section addresses,\n\
823 (such as in the a.out format), or when the addresses specified in the\n\
824 file itself are wrong. Each section must be changed separately. The\n\
825 ``info files'' command lists all the sections and their addresses."));
827 add_setshow_boolean_cmd ("write", class_support
, &write_files
, _("\
828 Set writing into executable and core files."), _("\
829 Show writing into executable and core files."), NULL
,
832 &setlist
, &showlist
);
834 add_target_with_completer (&exec_ops
, filename_completer
);
838 exec_make_note_section (bfd
*obfd
, int *note_size
)
840 error (_("Can't create a corefile"));