1 /* Work with executable files, for GDB.
3 Copyright (C) 1988-2003, 2007-2012 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 #include "xcoffsolib.h"
49 struct vmap *map_vmap (bfd *, bfd *);
51 void (*deprecated_file_changed_hook) (char *);
53 /* Prototypes for local functions */
55 static void file_command (char *, int);
57 static void set_section_command (char *, int);
59 static void exec_files_info (struct target_ops *);
61 static void init_exec_ops (void);
63 void _initialize_exec (void);
65 /* The target vector for executable files. */
67 struct target_ops exec_ops;
69 /* True if the exec target is pushed on the stack. */
70 static int using_exec_ops;
72 /* Whether to open exec and core files read-only or read-write. */
76 show_write_files (struct ui_file *file, int from_tty,
77 struct cmd_list_element *c, const char *value)
79 fprintf_filtered (file, _("Writing into executable and core files is %s.\n"),
87 exec_open (char *args, int from_tty)
89 target_preopen (from_tty);
90 exec_file_attach (args, from_tty);
93 /* Close and clear exec_bfd. If we end up with no target sections to
94 read memory from, this unpushes the exec_ops target. */
101 bfd *abfd = exec_bfd;
103 gdb_bfd_unref (abfd);
105 /* Removing target sections may close the exec_ops target.
106 Clear exec_bfd before doing so to prevent recursion. */
110 remove_target_sections (abfd);
114 /* This is the target_close implementation. Clears all target
115 sections and closes all executable bfds from all program spaces. */
118 exec_close_1 (int quitting)
120 int need_symtab_cleanup = 0;
121 struct vmap *vp, *nxt;
125 for (nxt = vmap; nxt != NULL;)
130 /* if there is an objfile associated with this bfd,
131 free_objfile() will do proper cleanup of objfile *and* bfd. */
135 free_objfile (vp->objfile);
136 need_symtab_cleanup = 1;
138 else if (vp->bfd != exec_bfd)
139 gdb_bfd_unref (vp->bfd);
147 struct program_space *ss;
148 struct cleanup *old_chain;
150 old_chain = save_current_program_space ();
153 set_current_program_space (ss);
155 /* Delete all target sections. */
157 (current_target_sections,
158 -resize_section_table (current_target_sections, 0));
163 do_cleanups (old_chain);
168 exec_file_clear (int from_tty)
170 /* Remove exec file. */
174 printf_unfiltered (_("No executable file now.\n"));
177 /* Set FILENAME as the new exec file.
179 This function is intended to be behave essentially the same
180 as exec_file_command, except that the latter will detect when
181 a target is being debugged, and will ask the user whether it
182 should be shut down first. (If the answer is "no", then the
183 new file is ignored.)
185 This file is used by exec_file_command, to do the work of opening
186 and processing the exec file after any prompting has happened.
188 And, it is used by child_attach, when the attach command was
189 given a pid but not a exec pathname, and the attach command could
190 figure out the pathname from the pid. (In this case, we shouldn't
191 ask the user whether the current target should be shut down --
192 we're supplying the exec pathname late for good reason.) */
195 exec_file_attach (char *filename, int from_tty)
197 /* Remove any previous exec file. */
200 /* Now open and digest the file the user requested, if any. */
205 printf_unfiltered (_("No executable file now.\n"));
207 set_gdbarch_from_file (NULL);
211 struct cleanup *cleanups;
212 char *scratch_pathname;
214 struct target_section *sections = NULL, *sections_end = NULL;
217 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
218 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
220 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
221 if (scratch_chan < 0)
223 char *exename = alloca (strlen (filename) + 5);
225 strcat (strcpy (exename, filename), ".exe");
226 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
227 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
232 cleanups = make_cleanup (xfree, scratch_pathname);
234 if (scratch_chan < 0)
235 perror_with_name (filename);
236 exec_bfd = gdb_bfd_fopen (scratch_pathname, gnutarget,
237 write_files ? FOPEN_RUB : FOPEN_RB,
242 error (_("\"%s\": could not open as an executable file: %s"),
243 scratch_pathname, bfd_errmsg (bfd_get_error ()));
246 if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
248 /* Make sure to close exec_bfd, or else "run" might try to use
251 error (_("\"%s\": not in executable format: %s"),
253 gdb_bfd_errmsg (bfd_get_error (), matching));
256 /* FIXME - This should only be run for RS6000, but the ifdef is a poor
257 way to accomplish. */
258 #ifdef DEPRECATED_IBM6000_TARGET
259 /* Setup initial vmap. */
261 map_vmap (exec_bfd, 0);
264 /* Make sure to close exec_bfd, or else "run" might try to use
267 error (_("\"%s\": can't find the file sections: %s"),
268 scratch_pathname, bfd_errmsg (bfd_get_error ()));
270 #endif /* DEPRECATED_IBM6000_TARGET */
272 if (build_section_table (exec_bfd, §ions, §ions_end))
274 /* Make sure to close exec_bfd, or else "run" might try to use
277 error (_("\"%s\": can't find the file sections: %s"),
278 scratch_pathname, bfd_errmsg (bfd_get_error ()));
281 exec_bfd_mtime = bfd_get_mtime (exec_bfd);
285 set_gdbarch_from_file (exec_bfd);
287 /* Add the executable's sections to the current address spaces'
288 list of sections. This possibly pushes the exec_ops
290 add_target_sections (sections, sections_end);
293 /* Tell display code (if any) about the changed file name. */
294 if (deprecated_exec_file_display_hook)
295 (*deprecated_exec_file_display_hook) (filename);
297 do_cleanups (cleanups);
299 bfd_cache_close_all ();
300 observer_notify_executable_changed ();
303 /* Process the first arg in ARGS as the new exec file.
305 Note that we have to explicitly ignore additional args, since we can
306 be called from file_command(), which also calls symbol_file_command()
307 which can take multiple args.
309 If ARGS is NULL, we just want to close the exec file. */
312 exec_file_command (char *args, int from_tty)
317 if (from_tty && target_has_execution
318 && !query (_("A program is being debugged already.\n"
319 "Are you sure you want to change the file? ")))
320 error (_("File not changed."));
324 struct cleanup *cleanups;
326 /* Scan through the args and pick up the first non option arg
329 argv = gdb_buildargv (args);
330 cleanups = make_cleanup_freeargv (argv);
332 for (; (*argv != NULL) && (**argv == '-'); argv++)
336 error (_("No executable file name was specified"));
338 filename = tilde_expand (*argv);
339 make_cleanup (xfree, filename);
340 exec_file_attach (filename, from_tty);
342 do_cleanups (cleanups);
345 exec_file_attach (NULL, from_tty);
348 /* Set both the exec file and the symbol file, in one command.
349 What a novelty. Why did GDB go through four major releases before this
350 command was added? */
353 file_command (char *arg, int from_tty)
355 /* FIXME, if we lose on reading the symbol file, we should revert
356 the exec file, but that's rough. */
357 exec_file_command (arg, from_tty);
358 symbol_file_command (arg, from_tty);
359 if (deprecated_file_changed_hook)
360 deprecated_file_changed_hook (arg);
364 /* Locate all mappable sections of a BFD file.
365 table_pp_char is a char * to get it through bfd_map_over_sections;
366 we cast it back to its proper type. */
369 add_to_section_table (bfd *abfd, struct bfd_section *asect,
372 struct target_section **table_pp = (struct target_section **) table_pp_char;
375 /* Check the section flags, but do not discard zero-length sections, since
376 some symbols may still be attached to this section. For instance, we
377 encountered on sparc-solaris 2.10 a shared library with an empty .bss
378 section to which a symbol named "_end" was attached. The address
379 of this symbol still needs to be relocated. */
380 aflag = bfd_get_section_flags (abfd, asect);
381 if (!(aflag & SEC_ALLOC))
384 (*table_pp)->bfd = abfd;
385 (*table_pp)->the_bfd_section = asect;
386 (*table_pp)->addr = bfd_section_vma (abfd, asect);
387 (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
392 resize_section_table (struct target_section_table *table, int num_added)
394 struct target_section *old_value;
398 old_value = table->sections;
399 old_count = table->sections_end - table->sections;
401 new_count = num_added + old_count;
405 table->sections = xrealloc (table->sections,
406 sizeof (struct target_section) * new_count);
407 table->sections_end = table->sections + new_count;
411 xfree (table->sections);
412 table->sections = table->sections_end = NULL;
418 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
419 Returns 0 if OK, 1 on error. */
422 build_section_table (struct bfd *some_bfd, struct target_section **start,
423 struct target_section **end)
427 count = bfd_count_sections (some_bfd);
430 *start = (struct target_section *) xmalloc (count * sizeof (**start));
432 bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
433 if (*end > *start + count)
434 internal_error (__FILE__, __LINE__,
435 _("failed internal consistency check"));
436 /* We could realloc the table, but it probably loses for most files. */
440 /* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
441 current set of target sections. */
444 add_target_sections (struct target_section *sections,
445 struct target_section *sections_end)
448 struct target_section_table *table = current_target_sections;
450 count = sections_end - sections;
454 int space = resize_section_table (table, count);
456 memcpy (table->sections + space,
457 sections, count * sizeof (sections[0]));
459 /* If these are the first file sections we can provide memory
460 from, push the file_stratum target. */
464 push_target (&exec_ops);
469 /* Remove all target sections taken from ABFD. */
472 remove_target_sections (bfd *abfd)
474 struct target_section *src, *dest;
475 struct target_section_table *table = current_target_sections;
477 dest = table->sections;
478 for (src = table->sections; src < table->sections_end; src++)
479 if (src->bfd != abfd)
481 /* Keep this section. */
487 /* If we've dropped any sections, resize the section table. */
492 old_count = resize_section_table (table, dest - src);
494 /* If we don't have any more sections to read memory from,
495 remove the file_stratum target from the stack. */
496 if (old_count + (dest - src) == 0)
498 struct program_space *pspace;
501 if (pspace->target_sections.sections
502 != pspace->target_sections.sections_end)
505 unpush_target (&exec_ops);
512 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
514 struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
517 vp = vmap_bfd->pvmap;
519 if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
522 if (strcmp (bfd_section_name (abfd, sect), ".text") == 0)
524 vp->tstart = bfd_section_vma (abfd, sect);
525 vp->tend = vp->tstart + bfd_section_size (abfd, sect);
526 vp->tvma = bfd_section_vma (abfd, sect);
527 vp->toffs = sect->filepos;
529 else if (strcmp (bfd_section_name (abfd, sect), ".data") == 0)
531 vp->dstart = bfd_section_vma (abfd, sect);
532 vp->dend = vp->dstart + bfd_section_size (abfd, sect);
533 vp->dvma = bfd_section_vma (abfd, sect);
535 /* Silently ignore other types of sections. (FIXME?) */
538 /* Make a vmap for ABFD which might be a member of the archive ARCH.
539 Return the new vmap. */
542 map_vmap (bfd *abfd, bfd *arch)
544 struct vmap_and_bfd vmap_bfd;
545 struct vmap *vp, **vpp;
547 vp = (struct vmap *) xmalloc (sizeof (*vp));
548 memset ((char *) vp, '\0', sizeof (*vp));
551 vp->name = bfd_get_filename (arch ? arch : abfd);
552 vp->member = arch ? bfd_get_filename (abfd) : "";
554 vmap_bfd.pbfd = arch;
556 bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
558 /* Find the end of the list and append. */
559 for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
568 section_table_available_memory (VEC(mem_range_s) *memory,
569 CORE_ADDR memaddr, ULONGEST len,
570 struct target_section *sections,
571 struct target_section *sections_end)
573 struct target_section *p;
575 for (p = sections; p < sections_end; p++)
577 if ((bfd_get_section_flags (p->bfd, p->the_bfd_section)
578 & SEC_READONLY) == 0)
581 /* Copy the meta-data, adjusted. */
582 if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
584 ULONGEST lo1, hi1, lo2, hi2;
593 r = VEC_safe_push (mem_range_s, memory, NULL);
595 r->start = max (lo1, lo2);
596 r->length = min (hi1, hi2) - r->start;
604 section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
605 ULONGEST offset, LONGEST len,
606 struct target_section *sections,
607 struct target_section *sections_end,
608 const char *section_name)
611 struct target_section *p;
612 ULONGEST memaddr = offset;
613 ULONGEST memend = memaddr + len;
616 internal_error (__FILE__, __LINE__,
617 _("failed internal consistency check"));
619 for (p = sections; p < sections_end; p++)
621 if (section_name && strcmp (section_name, p->the_bfd_section->name) != 0)
622 continue; /* not the section we need. */
623 if (memaddr >= p->addr)
625 if (memend <= p->endaddr)
627 /* Entire transfer is within this section. */
629 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
630 writebuf, memaddr - p->addr,
633 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
634 readbuf, memaddr - p->addr,
636 return (res != 0) ? len : 0;
638 else if (memaddr >= p->endaddr)
640 /* This section ends before the transfer starts. */
645 /* This section overlaps the transfer. Just do half. */
646 len = p->endaddr - memaddr;
648 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
649 writebuf, memaddr - p->addr,
652 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
653 readbuf, memaddr - p->addr,
655 return (res != 0) ? len : 0;
660 return 0; /* We can't help. */
663 static struct target_section_table *
664 exec_get_section_table (struct target_ops *ops)
666 return current_target_sections;
670 exec_xfer_partial (struct target_ops *ops, enum target_object object,
671 const char *annex, gdb_byte *readbuf,
672 const gdb_byte *writebuf,
673 ULONGEST offset, LONGEST len)
675 struct target_section_table *table = target_get_section_table (ops);
677 if (object == TARGET_OBJECT_MEMORY)
678 return section_table_xfer_memory_partial (readbuf, writebuf,
689 print_section_info (struct target_section_table *t, bfd *abfd)
691 struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
692 struct target_section *p;
693 /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
694 int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
696 printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
698 printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
699 if (abfd == exec_bfd)
701 /* gcc-3.4 does not like the initialization in
702 <p == t->sections_end>. */
703 bfd_vma displacement = 0;
706 for (p = t->sections; p < t->sections_end; p++)
708 asection *asect = p->the_bfd_section;
710 if ((bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD))
711 != (SEC_ALLOC | SEC_LOAD))
714 if (bfd_get_section_vma (abfd, asect) <= abfd->start_address
715 && abfd->start_address < (bfd_get_section_vma (abfd, asect)
716 + bfd_get_section_size (asect)))
718 displacement = p->addr - bfd_get_section_vma (abfd, asect);
722 if (p == t->sections_end)
723 warning (_("Cannot find section for the entry point of %s."),
724 bfd_get_filename (abfd));
726 entry_point = gdbarch_addr_bits_remove (gdbarch,
727 bfd_get_start_address (abfd)
729 printf_filtered (_("\tEntry point: %s\n"),
730 paddress (gdbarch, entry_point));
732 for (p = t->sections; p < t->sections_end; p++)
734 printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
735 printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
737 /* FIXME: A format of "08l" is not wide enough for file offsets
738 larger than 4GB. OTOH, making it "016l" isn't desirable either
739 since most output will then be much wider than necessary. It
740 may make sense to test the size of the file and choose the
741 format string accordingly. */
742 /* FIXME: i18n: Need to rewrite this sentence. */
744 printf_filtered (" @ %s",
745 hex_string_custom (p->the_bfd_section->filepos, 8));
746 printf_filtered (" is %s", bfd_section_name (p->bfd,
747 p->the_bfd_section));
749 printf_filtered (" in %s", bfd_get_filename (p->bfd));
750 printf_filtered ("\n");
755 exec_files_info (struct target_ops *t)
758 print_section_info (current_target_sections, exec_bfd);
760 puts_filtered (_("\t<no file loaded>\n"));
764 int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
767 printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
768 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
769 addr_size * 2, "tstart",
770 addr_size * 2, "tend",
771 addr_size * 2, "dstart",
772 addr_size * 2, "dend",
776 for (vp = vmap; vp; vp = vp->nxt)
777 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
778 phex (vp->tstart, addr_size),
779 phex (vp->tend, addr_size),
780 phex (vp->dstart, addr_size),
781 phex (vp->dend, addr_size),
783 *vp->member ? "(" : "", vp->member,
784 *vp->member ? ")" : "");
789 set_section_command (char *args, int from_tty)
791 struct target_section *p;
794 unsigned long secaddr;
797 struct target_section_table *table;
800 error (_("Must specify section name and its virtual address"));
802 /* Parse out section name. */
803 for (secname = args; !isspace (*args); args++);
804 seclen = args - secname;
806 /* Parse out new virtual address. */
807 secaddr = parse_and_eval_address (args);
809 table = current_target_sections;
810 for (p = table->sections; p < table->sections_end; p++)
812 if (!strncmp (secname, bfd_section_name (p->bfd,
813 p->the_bfd_section), seclen)
814 && bfd_section_name (p->bfd, p->the_bfd_section)[seclen] == '\0')
816 offset = secaddr - p->addr;
818 p->endaddr += offset;
820 exec_files_info (&exec_ops);
824 if (seclen >= sizeof (secprint))
825 seclen = sizeof (secprint) - 1;
826 strncpy (secprint, secname, seclen);
827 secprint[seclen] = '\0';
828 error (_("Section %s not found"), secprint);
831 /* If we can find a section in FILENAME with BFD index INDEX, adjust
835 exec_set_section_address (const char *filename, int index, CORE_ADDR address)
837 struct target_section *p;
838 struct target_section_table *table;
840 table = current_target_sections;
841 for (p = table->sections; p < table->sections_end; p++)
843 if (filename_cmp (filename, p->bfd->filename) == 0
844 && index == p->the_bfd_section->index)
846 p->endaddr += address - p->addr;
852 /* If mourn is being called in all the right places, this could be say
853 `gdb internal error' (since generic_mourn calls
854 breakpoint_init_inferior). */
857 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
863 exec_has_memory (struct target_ops *ops)
865 /* We can provide memory if we have any file/target sections to read
867 return (current_target_sections->sections
868 != current_target_sections->sections_end);
871 /* Find mapped memory. */
874 exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *))
876 exec_ops.to_find_memory_regions = func;
879 static char *exec_make_note_section (bfd *, int *);
881 /* Fill in the exec file target vector. Very few entries need to be
887 exec_ops.to_shortname = "exec";
888 exec_ops.to_longname = "Local exec file";
889 exec_ops.to_doc = "Use an executable file as a target.\n\
890 Specify the filename of the executable file.";
891 exec_ops.to_open = exec_open;
892 exec_ops.to_close = exec_close_1;
893 exec_ops.to_attach = find_default_attach;
894 exec_ops.to_xfer_partial = exec_xfer_partial;
895 exec_ops.to_get_section_table = exec_get_section_table;
896 exec_ops.to_files_info = exec_files_info;
897 exec_ops.to_insert_breakpoint = ignore;
898 exec_ops.to_remove_breakpoint = ignore;
899 exec_ops.to_create_inferior = find_default_create_inferior;
900 exec_ops.to_stratum = file_stratum;
901 exec_ops.to_has_memory = exec_has_memory;
902 exec_ops.to_make_corefile_notes = exec_make_note_section;
903 exec_ops.to_magic = OPS_MAGIC;
907 _initialize_exec (void)
909 struct cmd_list_element *c;
915 c = add_cmd ("file", class_files, file_command, _("\
916 Use FILE as program to be debugged.\n\
917 It is read for its symbols, for getting the contents of pure memory,\n\
918 and it is the program executed when you use the `run' command.\n\
919 If FILE cannot be found as specified, your execution directory path\n\
920 ($PATH) is searched for a command of that name.\n\
921 No arg means to have no executable file and no symbols."), &cmdlist);
922 set_cmd_completer (c, filename_completer);
925 c = add_cmd ("exec-file", class_files, exec_file_command, _("\
926 Use FILE as program for getting contents of pure memory.\n\
927 If FILE cannot be found as specified, your execution directory path\n\
928 is searched for a command of that name.\n\
929 No arg means have no executable file."), &cmdlist);
930 set_cmd_completer (c, filename_completer);
932 add_com ("section", class_files, set_section_command, _("\
933 Change the base address of section SECTION of the exec file to ADDR.\n\
934 This can be used if the exec file does not contain section addresses,\n\
935 (such as in the a.out format), or when the addresses specified in the\n\
936 file itself are wrong. Each section must be changed separately. The\n\
937 ``info files'' command lists all the sections and their addresses."));
939 add_setshow_boolean_cmd ("write", class_support, &write_files, _("\
940 Set writing into executable and core files."), _("\
941 Show writing into executable and core files."), NULL,
944 &setlist, &showlist);
946 add_target (&exec_ops);
950 exec_make_note_section (bfd *obfd, int *note_size)
952 error (_("Can't create a corefile"));