1 /* Work with executable files, for GDB.
3 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
32 #include "completer.h"
37 #include <sys/types.h>
41 #include "readline/readline.h"
42 #include "gdb_string.h"
52 #include "xcoffsolib.h"
54 struct vmap *map_vmap (bfd *, bfd *);
56 void (*deprecated_file_changed_hook) (char *);
58 /* Prototypes for local functions */
60 static void exec_close (int);
62 static void file_command (char *, int);
64 static void set_section_command (char *, int);
66 static void exec_files_info (struct target_ops *);
68 static int ignore (CORE_ADDR, char *);
70 static void init_exec_ops (void);
72 void _initialize_exec (void);
74 /* The target vector for executable files. */
76 struct target_ops exec_ops;
78 /* The Binary File Descriptor handle for the executable file. */
82 /* Whether to open exec and core files read-only or read-write. */
89 exec_open (char *args, int from_tty)
91 target_preopen (from_tty);
92 exec_file_attach (args, from_tty);
96 exec_close (int quitting)
98 int need_symtab_cleanup = 0;
99 struct vmap *vp, *nxt;
101 for (nxt = vmap; nxt != NULL;)
106 /* if there is an objfile associated with this bfd,
107 free_objfile() will do proper cleanup of objfile *and* bfd. */
111 free_objfile (vp->objfile);
112 need_symtab_cleanup = 1;
114 else if (vp->bfd != exec_bfd)
115 /* FIXME-leak: We should be freeing vp->name too, I think. */
116 if (!bfd_close (vp->bfd))
117 warning ("cannot close \"%s\": %s",
118 vp->name, bfd_errmsg (bfd_get_error ()));
120 /* FIXME: This routine is #if 0'd in symfile.c. What should we
121 be doing here? Should we just free everything in
122 vp->objfile->symtabs? Should free_objfile do that?
123 FIXME-as-well: free_objfile already free'd vp->name, so it isn't
125 free_named_symtabs (vp->name);
133 char *name = bfd_get_filename (exec_bfd);
135 if (!bfd_close (exec_bfd))
136 warning ("cannot close \"%s\": %s",
137 name, bfd_errmsg (bfd_get_error ()));
142 if (exec_ops.to_sections)
144 xfree (exec_ops.to_sections);
145 exec_ops.to_sections = NULL;
146 exec_ops.to_sections_end = NULL;
151 exec_file_clear (int from_tty)
153 /* Remove exec file. */
154 unpush_target (&exec_ops);
157 printf_unfiltered ("No executable file now.\n");
160 /* Process the first arg in ARGS as the new exec file.
162 This function is intended to be behave essentially the same
163 as exec_file_command, except that the latter will detect when
164 a target is being debugged, and will ask the user whether it
165 should be shut down first. (If the answer is "no", then the
166 new file is ignored.)
168 This file is used by exec_file_command, to do the work of opening
169 and processing the exec file after any prompting has happened.
171 And, it is used by child_attach, when the attach command was
172 given a pid but not a exec pathname, and the attach command could
173 figure out the pathname from the pid. (In this case, we shouldn't
174 ask the user whether the current target should be shut down --
175 we're supplying the exec pathname late for good reason.)
177 ARGS is assumed to be the filename. */
180 exec_file_attach (char *filename, int from_tty)
182 /* Remove any previous exec file. */
183 unpush_target (&exec_ops);
185 /* Now open and digest the file the user requested, if any. */
190 printf_unfiltered ("No executable file now.\n");
194 char *scratch_pathname;
197 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
198 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
200 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
201 if (scratch_chan < 0)
203 char *exename = alloca (strlen (filename) + 5);
204 strcat (strcpy (exename, filename), ".exe");
205 scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
206 write_files ? O_RDWR | O_BINARY : O_RDONLY | O_BINARY, 0,
210 if (scratch_chan < 0)
211 perror_with_name (filename);
212 exec_bfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
215 error ("\"%s\": could not open as an executable file: %s",
216 scratch_pathname, bfd_errmsg (bfd_get_error ()));
218 /* At this point, scratch_pathname and exec_bfd->name both point to the
219 same malloc'd string. However exec_close() will attempt to free it
220 via the exec_bfd->name pointer, so we need to make another copy and
221 leave exec_bfd as the new owner of the original copy. */
222 scratch_pathname = xstrdup (scratch_pathname);
223 make_cleanup (xfree, scratch_pathname);
225 if (!bfd_check_format (exec_bfd, bfd_object))
227 /* Make sure to close exec_bfd, or else "run" might try to use
230 error ("\"%s\": not in executable format: %s",
231 scratch_pathname, bfd_errmsg (bfd_get_error ()));
234 /* FIXME - This should only be run for RS6000, but the ifdef is a poor
235 way to accomplish. */
236 #ifdef DEPRECATED_IBM6000_TARGET
237 /* Setup initial vmap. */
239 map_vmap (exec_bfd, 0);
242 /* Make sure to close exec_bfd, or else "run" might try to use
245 error ("\"%s\": can't find the file sections: %s",
246 scratch_pathname, bfd_errmsg (bfd_get_error ()));
248 #endif /* DEPRECATED_IBM6000_TARGET */
250 if (build_section_table (exec_bfd, &exec_ops.to_sections,
251 &exec_ops.to_sections_end))
253 /* Make sure to close exec_bfd, or else "run" might try to use
256 error ("\"%s\": can't find the file sections: %s",
257 scratch_pathname, bfd_errmsg (bfd_get_error ()));
260 #ifdef DEPRECATED_HPUX_TEXT_END
261 DEPRECATED_HPUX_TEXT_END (&exec_ops);
266 set_gdbarch_from_file (exec_bfd);
268 push_target (&exec_ops);
270 /* Tell display code (if any) about the changed file name. */
271 if (deprecated_exec_file_display_hook)
272 (*deprecated_exec_file_display_hook) (filename);
274 bfd_cache_close_all ();
277 /* Process the first arg in ARGS as the new exec file.
279 Note that we have to explicitly ignore additional args, since we can
280 be called from file_command(), which also calls symbol_file_command()
281 which can take multiple args.
283 If ARGS is NULL, we just want to close the exec file. */
286 exec_file_command (char *args, int from_tty)
291 target_preopen (from_tty);
295 /* Scan through the args and pick up the first non option arg
298 argv = buildargv (args);
302 make_cleanup_freeargv (argv);
304 for (; (*argv != NULL) && (**argv == '-'); argv++)
308 error ("No executable file name was specified");
310 filename = tilde_expand (*argv);
311 make_cleanup (xfree, filename);
312 exec_file_attach (filename, from_tty);
315 exec_file_attach (NULL, from_tty);
318 /* Set both the exec file and the symbol file, in one command.
319 What a novelty. Why did GDB go through four major releases before this
320 command was added? */
323 file_command (char *arg, int from_tty)
325 /* FIXME, if we lose on reading the symbol file, we should revert
326 the exec file, but that's rough. */
327 exec_file_command (arg, from_tty);
328 symbol_file_command (arg, from_tty);
329 if (deprecated_file_changed_hook)
330 deprecated_file_changed_hook (arg);
334 /* Locate all mappable sections of a BFD file.
335 table_pp_char is a char * to get it through bfd_map_over_sections;
336 we cast it back to its proper type. */
339 add_to_section_table (bfd *abfd, struct bfd_section *asect,
342 struct section_table **table_pp = (struct section_table **) table_pp_char;
345 aflag = bfd_get_section_flags (abfd, asect);
346 if (!(aflag & SEC_ALLOC))
348 if (0 == bfd_section_size (abfd, asect))
350 (*table_pp)->bfd = abfd;
351 (*table_pp)->the_bfd_section = asect;
352 (*table_pp)->addr = bfd_section_vma (abfd, asect);
353 (*table_pp)->endaddr = (*table_pp)->addr + bfd_section_size (abfd, asect);
357 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
358 Returns 0 if OK, 1 on error. */
361 build_section_table (struct bfd *some_bfd, struct section_table **start,
362 struct section_table **end)
366 count = bfd_count_sections (some_bfd);
369 *start = (struct section_table *) xmalloc (count * sizeof (**start));
371 bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
372 if (*end > *start + count)
373 internal_error (__FILE__, __LINE__, "failed internal consistency check");
374 /* We could realloc the table, but it probably loses for most files. */
379 bfdsec_to_vmap (struct bfd *abfd, struct bfd_section *sect, void *arg3)
381 struct vmap_and_bfd *vmap_bfd = (struct vmap_and_bfd *) arg3;
384 vp = vmap_bfd->pvmap;
386 if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
389 if (DEPRECATED_STREQ (bfd_section_name (abfd, sect), ".text"))
391 vp->tstart = bfd_section_vma (abfd, sect);
392 vp->tend = vp->tstart + bfd_section_size (abfd, sect);
393 vp->tvma = bfd_section_vma (abfd, sect);
394 vp->toffs = sect->filepos;
396 else if (DEPRECATED_STREQ (bfd_section_name (abfd, sect), ".data"))
398 vp->dstart = bfd_section_vma (abfd, sect);
399 vp->dend = vp->dstart + bfd_section_size (abfd, sect);
400 vp->dvma = bfd_section_vma (abfd, sect);
402 /* Silently ignore other types of sections. (FIXME?) */
405 /* Make a vmap for ABFD which might be a member of the archive ARCH.
406 Return the new vmap. */
409 map_vmap (bfd *abfd, bfd *arch)
411 struct vmap_and_bfd vmap_bfd;
412 struct vmap *vp, **vpp;
414 vp = (struct vmap *) xmalloc (sizeof (*vp));
415 memset ((char *) vp, '\0', sizeof (*vp));
418 vp->name = bfd_get_filename (arch ? arch : abfd);
419 vp->member = arch ? bfd_get_filename (abfd) : "";
421 vmap_bfd.pbfd = arch;
423 bfd_map_over_sections (abfd, bfdsec_to_vmap, &vmap_bfd);
425 /* Find the end of the list and append. */
426 for (vpp = &vmap; *vpp; vpp = &(*vpp)->nxt)
433 /* Read or write the exec file.
435 Args are address within a BFD file, address within gdb address-space,
436 length, and a flag indicating whether to read or write.
440 0: We cannot handle this address and length.
441 > 0: We have handled N bytes starting at this address.
442 (If N == length, we did it all.) We might be able
443 to handle more bytes beyond this length, but no
445 < 0: We cannot handle this address, but if somebody
446 else handles (-N) bytes, we can start from there.
448 The same routine is used to handle both core and exec files;
449 we just tail-call it with more arguments to select between them. */
452 xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
453 struct mem_attrib *attrib,
454 struct target_ops *target)
457 struct section_table *p;
458 CORE_ADDR nextsectaddr, memend;
459 asection *section = NULL;
462 internal_error (__FILE__, __LINE__, "failed internal consistency check");
464 if (overlay_debugging)
466 section = find_pc_overlay (memaddr);
467 if (pc_in_unmapped_range (memaddr, section))
468 memaddr = overlay_mapped_address (memaddr, section);
471 memend = memaddr + len;
472 nextsectaddr = memend;
474 for (p = target->to_sections; p < target->to_sections_end; p++)
476 if (overlay_debugging && section && p->the_bfd_section &&
477 strcmp (section->name, p->the_bfd_section->name) != 0)
478 continue; /* not the section we need */
479 if (memaddr >= p->addr)
481 if (memend <= p->endaddr)
483 /* Entire transfer is within this section. */
485 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
486 myaddr, memaddr - p->addr,
489 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
490 myaddr, memaddr - p->addr,
492 return (res != 0) ? len : 0;
494 else if (memaddr >= p->endaddr)
496 /* This section ends before the transfer starts. */
501 /* This section overlaps the transfer. Just do half. */
502 len = p->endaddr - memaddr;
504 res = bfd_set_section_contents (p->bfd, p->the_bfd_section,
505 myaddr, memaddr - p->addr,
508 res = bfd_get_section_contents (p->bfd, p->the_bfd_section,
509 myaddr, memaddr - p->addr,
511 return (res != 0) ? len : 0;
515 nextsectaddr = min (nextsectaddr, p->addr);
518 if (nextsectaddr >= memend)
519 return 0; /* We can't help */
521 return -(nextsectaddr - memaddr); /* Next boundary where we can help */
526 print_section_info (struct target_ops *t, bfd *abfd)
528 struct section_table *p;
529 /* FIXME: "016l" is not wide enough when TARGET_ADDR_BIT > 64. */
530 char *fmt = TARGET_ADDR_BIT <= 32 ? "08l" : "016l";
532 printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
534 printf_filtered ("file type %s.\n", bfd_get_target (abfd));
535 if (abfd == exec_bfd)
537 printf_filtered ("\tEntry point: ");
538 print_address_numeric (bfd_get_start_address (abfd), 1, gdb_stdout);
539 printf_filtered ("\n");
541 for (p = t->to_sections; p < t->to_sections_end; p++)
543 printf_filtered ("\t%s", local_hex_string_custom (p->addr, fmt));
544 printf_filtered (" - %s", local_hex_string_custom (p->endaddr, fmt));
546 /* FIXME: A format of "08l" is not wide enough for file offsets
547 larger than 4GB. OTOH, making it "016l" isn't desirable either
548 since most output will then be much wider than necessary. It
549 may make sense to test the size of the file and choose the
550 format string accordingly. */
552 printf_filtered (" @ %s",
553 local_hex_string_custom (p->the_bfd_section->filepos, "08l"));
554 printf_filtered (" is %s", bfd_section_name (p->bfd, p->the_bfd_section));
557 printf_filtered (" in %s", bfd_get_filename (p->bfd));
559 printf_filtered ("\n");
564 exec_files_info (struct target_ops *t)
566 print_section_info (t, exec_bfd);
572 printf_unfiltered ("\tMapping info for file `%s'.\n", vmap->name);
573 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
574 strlen_paddr (), "tstart",
575 strlen_paddr (), "tend",
576 strlen_paddr (), "dstart",
577 strlen_paddr (), "dend",
581 for (vp = vmap; vp; vp = vp->nxt)
582 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
588 *vp->member ? "(" : "", vp->member,
589 *vp->member ? ")" : "");
594 exec_set_section_offsets sets the offsets of all the sections
595 in the exec objfile. */
598 exec_set_section_offsets (bfd_signed_vma text_off, bfd_signed_vma data_off,
599 bfd_signed_vma bss_off)
601 struct section_table *sect;
603 for (sect = exec_ops.to_sections;
604 sect < exec_ops.to_sections_end;
609 flags = bfd_get_section_flags (exec_bfd, sect->the_bfd_section);
611 if (flags & SEC_CODE)
613 sect->addr += text_off;
614 sect->endaddr += text_off;
616 else if (flags & (SEC_DATA | SEC_LOAD))
618 sect->addr += data_off;
619 sect->endaddr += data_off;
621 else if (flags & SEC_ALLOC)
623 sect->addr += bss_off;
624 sect->endaddr += bss_off;
630 set_section_command (char *args, int from_tty)
632 struct section_table *p;
635 unsigned long secaddr;
640 error ("Must specify section name and its virtual address");
642 /* Parse out section name */
643 for (secname = args; !isspace (*args); args++);
644 seclen = args - secname;
646 /* Parse out new virtual address */
647 secaddr = parse_and_eval_address (args);
649 for (p = exec_ops.to_sections; p < exec_ops.to_sections_end; p++)
651 if (!strncmp (secname, bfd_section_name (exec_bfd, p->the_bfd_section), seclen)
652 && bfd_section_name (exec_bfd, p->the_bfd_section)[seclen] == '\0')
654 offset = secaddr - p->addr;
656 p->endaddr += offset;
658 exec_files_info (&exec_ops);
662 if (seclen >= sizeof (secprint))
663 seclen = sizeof (secprint) - 1;
664 strncpy (secprint, secname, seclen);
665 secprint[seclen] = '\0';
666 error ("Section %s not found", secprint);
669 /* If mourn is being called in all the right places, this could be say
670 `gdb internal error' (since generic_mourn calls
671 breakpoint_init_inferior). */
674 ignore (CORE_ADDR addr, char *contents)
679 /* Find mapped memory. */
682 exec_set_find_memory_regions (int (*func) (int (*) (CORE_ADDR,
688 exec_ops.to_find_memory_regions = func;
691 static char *exec_make_note_section (bfd *, int *);
693 /* Fill in the exec file target vector. Very few entries need to be
699 exec_ops.to_shortname = "exec";
700 exec_ops.to_longname = "Local exec file";
701 exec_ops.to_doc = "Use an executable file as a target.\n\
702 Specify the filename of the executable file.";
703 exec_ops.to_open = exec_open;
704 exec_ops.to_close = exec_close;
705 exec_ops.to_attach = find_default_attach;
706 exec_ops.to_xfer_memory = xfer_memory;
707 exec_ops.to_files_info = exec_files_info;
708 exec_ops.to_insert_breakpoint = ignore;
709 exec_ops.to_remove_breakpoint = ignore;
710 exec_ops.to_create_inferior = find_default_create_inferior;
711 exec_ops.to_stratum = file_stratum;
712 exec_ops.to_has_memory = 1;
713 exec_ops.to_make_corefile_notes = exec_make_note_section;
714 exec_ops.to_magic = OPS_MAGIC;
718 _initialize_exec (void)
720 struct cmd_list_element *c;
726 c = add_cmd ("file", class_files, file_command,
727 "Use FILE as program to be debugged.\n\
728 It is read for its symbols, for getting the contents of pure memory,\n\
729 and it is the program executed when you use the `run' command.\n\
730 If FILE cannot be found as specified, your execution directory path\n\
731 ($PATH) is searched for a command of that name.\n\
732 No arg means to have no executable file and no symbols.", &cmdlist);
733 set_cmd_completer (c, filename_completer);
736 c = add_cmd ("exec-file", class_files, exec_file_command,
737 "Use FILE as program for getting contents of pure memory.\n\
738 If FILE cannot be found as specified, your execution directory path\n\
739 is searched for a command of that name.\n\
740 No arg means have no executable file.", &cmdlist);
741 set_cmd_completer (c, filename_completer);
743 add_com ("section", class_files, set_section_command,
744 "Change the base address of section SECTION of the exec file to ADDR.\n\
745 This can be used if the exec file does not contain section addresses,\n\
746 (such as in the a.out format), or when the addresses specified in the\n\
747 file itself are wrong. Each section must be changed separately. The\n\
748 ``info files'' command lists all the sections and their addresses.");
750 deprecated_add_show_from_set
751 (add_set_cmd ("write", class_support, var_boolean, (char *) &write_files,
752 "Set writing into executable and core files.",
756 add_target (&exec_ops);
760 exec_make_note_section (bfd *obfd, int *note_size)
762 error ("Can't create a corefile");