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);
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)->owner = 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 *owner,
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].owner = owner;
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 owned by OWNER.
431 OWNER must be the same value passed to add_target_sections. */
434 remove_target_sections (void *owner)
436 struct target_section *src, *dest;
437 struct target_section_table *table = current_target_sections;
439 gdb_assert (owner != NULL);
441 dest = table->sections;
442 for (src = table->sections; src < table->sections_end; src++)
443 if (src->owner != owner)
445 /* Keep this section. */
451 /* If we've dropped any sections, resize the section table. */
456 old_count = resize_section_table (table, dest - src);
458 /* If we don't have any more sections to read memory from,
459 remove the file_stratum target from the stack. */
460 if (old_count + (dest - src) == 0)
462 struct program_space *pspace;
465 if (pspace->target_sections.sections
466 != pspace->target_sections.sections_end)
469 unpush_target (&exec_ops);
477 section_table_available_memory (VEC(mem_range_s) *memory,
478 CORE_ADDR memaddr, ULONGEST len,
479 struct target_section *sections,
480 struct target_section *sections_end)
482 struct target_section *p;
484 for (p = sections; p < sections_end; p++)
486 if ((bfd_get_section_flags (p->the_bfd_section->owner,
488 & SEC_READONLY) == 0)
491 /* Copy the meta-data, adjusted. */
492 if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
494 ULONGEST lo1, hi1, lo2, hi2;
503 r = VEC_safe_push (mem_range_s, memory, NULL);
505 r->start = max (lo1, lo2);
506 r->length = min (hi1, hi2) - r->start;
514 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
515 ULONGEST offset, LONGEST len,
516 struct target_section *sections,
517 struct target_section *sections_end,
518 const char *section_name)
521 struct target_section *p;
522 ULONGEST memaddr = offset;
523 ULONGEST memend = memaddr + len;
526 internal_error (__FILE__, __LINE__,
527 _("failed internal consistency check"));
529 for (p = sections; p < sections_end; p++)
531 struct bfd_section *asect = p->the_bfd_section;
532 bfd *abfd = asect->owner;
534 if (section_name && strcmp (section_name, asect->name) != 0)
535 continue; /* not the section we need. */
536 if (memaddr >= p->addr)
538 if (memend <= p->endaddr)
540 /* Entire transfer is within this section. */
542 res = bfd_set_section_contents (abfd, asect,
543 writebuf, memaddr - p->addr,
546 res = bfd_get_section_contents (abfd, asect,
547 readbuf, memaddr - p->addr,
549 return (res != 0) ? len : 0;
551 else if (memaddr >= p->endaddr)
553 /* This section ends before the transfer starts. */
558 /* This section overlaps the transfer. Just do half. */
559 len = p->endaddr - memaddr;
561 res = bfd_set_section_contents (abfd, asect,
562 writebuf, memaddr - p->addr,
565 res = bfd_get_section_contents (abfd, asect,
566 readbuf, memaddr - p->addr,
568 return (res != 0) ? len : 0;
573 return 0; /* We can't help. */
576 static struct target_section_table *
577 exec_get_section_table (struct target_ops *ops)
579 return current_target_sections;
583 exec_xfer_partial (struct target_ops *ops, enum target_object object,
584 const char *annex, gdb_byte *readbuf,
585 const gdb_byte *writebuf,
586 ULONGEST offset, LONGEST len)
588 struct target_section_table *table = target_get_section_table (ops);
590 if (object == TARGET_OBJECT_MEMORY)
591 return section_table_xfer_memory_partial (readbuf, writebuf,
602 print_section_info (struct target_section_table *t, bfd *abfd)
604 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
605 struct target_section *p;
606 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
607 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
609 printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
611 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
612 if (abfd == exec_bfd)
614 /* gcc-3.4 does not like the initialization in
615 <p == t->sections_end>. */
616 bfd_vma displacement = 0;
619 for (p = t->sections; p < t->sections_end; p++)
621 struct bfd_section *psect = p->the_bfd_section;
622 bfd *pbfd = psect->owner;
624 if ((bfd_get_section_flags (pbfd, psect) & (SEC_ALLOC | SEC_LOAD))
625 != (SEC_ALLOC | SEC_LOAD))
628 if (bfd_get_section_vma (pbfd, psect) <= abfd->start_address
629 && abfd->start_address < (bfd_get_section_vma (pbfd, psect)
630 + bfd_get_section_size (psect)))
632 displacement = p->addr - bfd_get_section_vma (pbfd, psect);
636 if (p == t->sections_end)
637 warning (_("Cannot find section for the entry point of %s."),
638 bfd_get_filename (abfd));
640 entry_point = gdbarch_addr_bits_remove (gdbarch,
641 bfd_get_start_address (abfd)
643 printf_filtered (_("\tEntry point: %s\n"),
644 paddress (gdbarch, entry_point));
646 for (p = t->sections; p < t->sections_end; p++)
648 struct bfd_section *psect = p->the_bfd_section;
649 bfd *pbfd = psect->owner;
651 printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
652 printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
654 /* FIXME: A format of "08l" is not wide enough for file offsets
655 larger than 4GB. OTOH, making it "016l" isn't desirable either
656 since most output will then be much wider than necessary. It
657 may make sense to test the size of the file and choose the
658 format string accordingly. */
659 /* FIXME: i18n: Need to rewrite this sentence. */
661 printf_filtered (" @ %s",
662 hex_string_custom (psect->filepos, 8));
663 printf_filtered (" is %s", bfd_section_name (pbfd, psect));
665 printf_filtered (" in %s", bfd_get_filename (pbfd));
666 printf_filtered ("\n");
671 exec_files_info (struct target_ops *t)
674 print_section_info (current_target_sections, exec_bfd);
676 puts_filtered (_("\t<no file loaded>\n"));
680 set_section_command (char *args, int from_tty)
682 struct target_section *p;
685 unsigned long secaddr;
688 struct target_section_table *table;
691 error (_("Must specify section name and its virtual address"));
693 /* Parse out section name. */
694 for (secname = args; !isspace (*args); args++);
695 seclen = args - secname;
697 /* Parse out new virtual address. */
698 secaddr = parse_and_eval_address (args);
700 table = current_target_sections;
701 for (p = table->sections; p < table->sections_end; p++)
703 if (!strncmp (secname, bfd_section_name (p->bfd,
704 p->the_bfd_section), seclen)
705 && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
707 offset = secaddr - p->addr;
709 p->endaddr += offset;
711 exec_files_info (&exec_ops);
715 if (seclen >= sizeof (secprint))
716 seclen = sizeof (secprint) - 1;
717 strncpy (secprint, secname, seclen);
718 secprint[seclen] = '\0';
719 error (_("Section %s not found"), secprint);
722 /* If we can find a section in FILENAME with BFD index INDEX, adjust
726 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
728 struct target_section *p;
729 struct target_section_table *table;
731 table = current_target_sections;
732 for (p = table->sections; p < table->sections_end; p++)
734 if (filename_cmp (filename, p->the_bfd_section->owner->filename) == 0
735 && index == p->the_bfd_section->index)
737 p->endaddr += address - p->addr;
743 /* If mourn is being called in all the right places, this could be say
744 `gdb internal error' (since generic_mourn calls
745 breakpoint_init_inferior). */
748 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
754 exec_has_memory (struct target_ops *ops)
756 /* We can provide memory if we have any file/target sections to read
758 return (current_target_sections->sections
759 != current_target_sections->sections_end);
762 /* Find mapped memory. */
765 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *))
767 exec_ops.to_find_memory_regions = func;
770 static char *exec_make_note_section (bfd *, int *);
772 /* Fill in the exec file target vector. Very few entries need to be
778 exec_ops.to_shortname = "exec";
779 exec_ops.to_longname = "Local exec file";
780 exec_ops.to_doc = "Use an executable file as a target.\n\
781 Specify the filename of the executable file.";
782 exec_ops.to_open = exec_open;
783 exec_ops.to_close = exec_close_1;
784 exec_ops.to_attach = find_default_attach;
785 exec_ops.to_xfer_partial = exec_xfer_partial;
786 exec_ops.to_get_section_table = exec_get_section_table;
787 exec_ops.to_files_info = exec_files_info;
788 exec_ops.to_insert_breakpoint = ignore;
789 exec_ops.to_remove_breakpoint = ignore;
790 exec_ops.to_create_inferior = find_default_create_inferior;
791 exec_ops.to_stratum = file_stratum;
792 exec_ops.to_has_memory = exec_has_memory;
793 exec_ops.to_make_corefile_notes = exec_make_note_section;
794 exec_ops.to_magic = OPS_MAGIC;
798 _initialize_exec (void)
800 struct cmd_list_element *c;
806 c = add_cmd ("file", class_files, file_command, _("\
807 Use FILE as program to be debugged.\n\
808 It is read for its symbols, for getting the contents of pure memory,\n\
809 and it is the program executed when you use the `run' command.\n\
810 If FILE cannot be found as specified, your execution directory path\n\
811 ($PATH) is searched for a command of that name.\n\
812 No arg means to have no executable file and no symbols."), &cmdlist);
813 set_cmd_completer (c, filename_completer);
816 c = add_cmd ("exec-file", class_files, exec_file_command, _("\
817 Use FILE as program for getting contents of pure memory.\n\
818 If FILE cannot be found as specified, your execution directory path\n\
819 is searched for a command of that name.\n\
820 No arg means have no executable file."), &cmdlist);
821 set_cmd_completer (c, filename_completer);
823 add_com ("section", class_files, set_section_command, _("\
824 Change the base address of section SECTION of the exec file to ADDR.\n\
825 This can be used if the exec file does not contain section addresses,\n\
826 (such as in the a.out format), or when the addresses specified in the\n\
827 file itself are wrong. Each section must be changed separately. The\n\
828 ``info files'' command lists all the sections and their addresses."));
830 add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
831 Set writing into executable and core files."), _("\
832 Show writing into executable and core files."), NULL,
835 &setlist, &showlist);
837 add_target_with_completer (&exec_ops, filename_completer);
841 exec_make_note_section (bfd *obfd, int *note_size)
843 error (_("Can't create a corefile"));