1 /* Work with executable files, for GDB.
2 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
31 #include "completer.h"
35 #include <sys/types.h>
39 #include <readline/readline.h>
40 #include "gdb_string.h"
50 #include "xcoffsolib.h"
52 struct vmap
*map_vmap (bfd
*, bfd
*);
54 void (*file_changed_hook
) (char *);
56 /* Prototypes for local functions */
58 static void add_to_section_table (bfd
*, sec_ptr
, void *);
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 void bfdsec_to_vmap (bfd
*, sec_ptr
, void *);
70 static int ignore (CORE_ADDR
, char *);
72 static void init_exec_ops (void);
74 void _initialize_exec (void);
76 /* The target vector for executable files. */
78 struct target_ops exec_ops
;
80 /* The Binary File Descriptor handle for the executable file. */
84 /* Whether to open exec and core files read-only or read-write. */
91 exec_open (char *args
, int from_tty
)
93 target_preopen (from_tty
);
94 exec_file_attach (args
, from_tty
);
99 exec_close (int quitting
)
101 int need_symtab_cleanup
= 0;
102 struct vmap
*vp
, *nxt
;
104 for (nxt
= vmap
; nxt
!= NULL
;)
109 /* if there is an objfile associated with this bfd,
110 free_objfile() will do proper cleanup of objfile *and* bfd. */
114 free_objfile (vp
->objfile
);
115 need_symtab_cleanup
= 1;
117 else if (vp
->bfd
!= exec_bfd
)
118 /* FIXME-leak: We should be freeing vp->name too, I think. */
119 if (!bfd_close (vp
->bfd
))
120 warning ("cannot close \"%s\": %s",
121 vp
->name
, bfd_errmsg (bfd_get_error ()));
123 /* FIXME: This routine is #if 0'd in symfile.c. What should we
124 be doing here? Should we just free everything in
125 vp->objfile->symtabs? Should free_objfile do that?
126 FIXME-as-well: free_objfile already free'd vp->name, so it isn't
128 free_named_symtabs (vp
->name
);
136 char *name
= bfd_get_filename (exec_bfd
);
138 if (!bfd_close (exec_bfd
))
139 warning ("cannot close \"%s\": %s",
140 name
, bfd_errmsg (bfd_get_error ()));
145 if (exec_ops
.to_sections
)
147 xfree (exec_ops
.to_sections
);
148 exec_ops
.to_sections
= NULL
;
149 exec_ops
.to_sections_end
= NULL
;
154 exec_file_clear (int from_tty
)
156 /* Remove exec file. */
157 unpush_target (&exec_ops
);
160 printf_unfiltered ("No executable file now.\n");
163 /* Process the first arg in ARGS as the new exec file.
165 This function is intended to be behave essentially the same
166 as exec_file_command, except that the latter will detect when
167 a target is being debugged, and will ask the user whether it
168 should be shut down first. (If the answer is "no", then the
169 new file is ignored.)
171 This file is used by exec_file_command, to do the work of opening
172 and processing the exec file after any prompting has happened.
174 And, it is used by child_attach, when the attach command was
175 given a pid but not a exec pathname, and the attach command could
176 figure out the pathname from the pid. (In this case, we shouldn't
177 ask the user whether the current target should be shut down --
178 we're supplying the exec pathname late for good reason.)
180 ARGS is assumed to be the filename. */
183 exec_file_attach (char *filename
, int from_tty
)
185 /* Remove any previous exec file. */
186 unpush_target (&exec_ops
);
188 /* Now open and digest the file the user requested, if any. */
193 printf_unfiltered ("No executable file now.\n");
197 char *scratch_pathname
;
200 scratch_chan
= openp (getenv ("PATH"), 1, filename
,
201 write_files
? O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
, 0,
203 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
204 if (scratch_chan
< 0)
206 char *exename
= alloca (strlen (filename
) + 5);
207 strcat (strcpy (exename
, filename
), ".exe");
208 scratch_chan
= openp (getenv ("PATH"), 1, exename
, write_files
?
209 O_RDWR
| O_BINARY
: O_RDONLY
| O_BINARY
, 0, &scratch_pathname
);
212 if (scratch_chan
< 0)
213 perror_with_name (filename
);
214 exec_bfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
217 error ("\"%s\": could not open as an executable file: %s",
218 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
220 /* At this point, scratch_pathname and exec_bfd->name both point to the
221 same malloc'd string. However exec_close() will attempt to free it
222 via the exec_bfd->name pointer, so we need to make another copy and
223 leave exec_bfd as the new owner of the original copy. */
224 scratch_pathname
= xstrdup (scratch_pathname
);
225 make_cleanup (xfree
, scratch_pathname
);
227 if (!bfd_check_format (exec_bfd
, bfd_object
))
229 /* Make sure to close exec_bfd, or else "run" might try to use
232 error ("\"%s\": not in executable format: %s",
233 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
236 /* FIXME - This should only be run for RS6000, but the ifdef is a poor
237 way to accomplish. */
238 #ifdef DEPRECATED_IBM6000_TARGET
239 /* Setup initial vmap. */
241 map_vmap (exec_bfd
, 0);
244 /* Make sure to close exec_bfd, or else "run" might try to use
247 error ("\"%s\": can't find the file sections: %s",
248 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
250 #endif /* DEPRECATED_IBM6000_TARGET */
252 if (build_section_table (exec_bfd
, &exec_ops
.to_sections
,
253 &exec_ops
.to_sections_end
))
255 /* Make sure to close exec_bfd, or else "run" might try to use
258 error ("\"%s\": can't find the file sections: %s",
259 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
262 #ifdef DEPRECATED_HPUX_TEXT_END
263 DEPRECATED_HPUX_TEXT_END (&exec_ops
);
268 set_gdbarch_from_file (exec_bfd
);
270 push_target (&exec_ops
);
272 /* Tell display code (if any) about the changed file name. */
273 if (exec_file_display_hook
)
274 (*exec_file_display_hook
) (filename
);
278 /* Process the first arg in ARGS as the new exec file.
280 Note that we have to explicitly ignore additional args, since we can
281 be called from file_command(), which also calls symbol_file_command()
282 which can take multiple args.
284 If ARGS is NULL, we just want to close the exec file. */
287 exec_file_command (char *args
, int from_tty
)
292 target_preopen (from_tty
);
296 /* Scan through the args and pick up the first non option arg
299 argv
= buildargv (args
);
303 make_cleanup_freeargv (argv
);
305 for (; (*argv
!= NULL
) && (**argv
== '-'); argv
++)
309 error ("No executable file name was specified");
311 filename
= tilde_expand (*argv
);
312 make_cleanup (xfree
, filename
);
313 exec_file_attach (filename
, from_tty
);
316 exec_file_attach (NULL
, from_tty
);
319 /* Set both the exec file and the symbol file, in one command.
320 What a novelty. Why did GDB go through four major releases before this
321 command was added? */
324 file_command (char *arg
, int from_tty
)
326 /* FIXME, if we lose on reading the symbol file, we should revert
327 the exec file, but that's rough. */
328 exec_file_command (arg
, from_tty
);
329 symbol_file_command (arg
, from_tty
);
330 if (file_changed_hook
)
331 file_changed_hook (arg
);
335 /* Locate all mappable sections of a BFD file.
336 table_pp_char is a char * to get it through bfd_map_over_sections;
337 we cast it back to its proper type. */
340 add_to_section_table (bfd
*abfd
, sec_ptr asect
, void *table_pp_char
)
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 (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 (bfd
*abfd
, sec_ptr 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 (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 (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 int (*xfer_fn
) (bfd
*, sec_ptr
, void *, file_ptr
, bfd_size_type
);
460 asection
*section
= NULL
;
463 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
465 if (overlay_debugging
)
467 section
= find_pc_overlay (memaddr
);
468 if (pc_in_unmapped_range (memaddr
, section
))
469 memaddr
= overlay_mapped_address (memaddr
, section
);
472 memend
= memaddr
+ len
;
473 xfer_fn
= write
? bfd_set_section_contents
: bfd_get_section_contents
;
474 nextsectaddr
= memend
;
476 for (p
= target
->to_sections
; p
< target
->to_sections_end
; p
++)
478 if (overlay_debugging
&& section
&& p
->the_bfd_section
&&
479 strcmp (section
->name
, p
->the_bfd_section
->name
) != 0)
480 continue; /* not the section we need */
481 if (memaddr
>= p
->addr
)
483 if (memend
<= p
->endaddr
)
485 /* Entire transfer is within this section. */
486 res
= xfer_fn (p
->bfd
, p
->the_bfd_section
, myaddr
,
487 memaddr
- p
->addr
, len
);
488 return (res
!= 0) ? len
: 0;
490 else if (memaddr
>= p
->endaddr
)
492 /* This section ends before the transfer starts. */
497 /* This section overlaps the transfer. Just do half. */
498 len
= p
->endaddr
- memaddr
;
499 res
= xfer_fn (p
->bfd
, p
->the_bfd_section
, myaddr
,
500 memaddr
- p
->addr
, len
);
501 return (res
!= 0) ? len
: 0;
505 nextsectaddr
= min (nextsectaddr
, p
->addr
);
508 if (nextsectaddr
>= memend
)
509 return 0; /* We can't help */
511 return -(nextsectaddr
- memaddr
); /* Next boundary where we can help */
516 print_section_info (struct target_ops
*t
, bfd
*abfd
)
518 struct section_table
*p
;
519 /* FIXME: "016l" is not wide enough when TARGET_ADDR_BIT > 64. */
520 char *fmt
= TARGET_ADDR_BIT
<= 32 ? "08l" : "016l";
522 printf_filtered ("\t`%s', ", bfd_get_filename (abfd
));
524 printf_filtered ("file type %s.\n", bfd_get_target (abfd
));
525 if (abfd
== exec_bfd
)
527 printf_filtered ("\tEntry point: ");
528 print_address_numeric (bfd_get_start_address (abfd
), 1, gdb_stdout
);
529 printf_filtered ("\n");
531 for (p
= t
->to_sections
; p
< t
->to_sections_end
; p
++)
533 printf_filtered ("\t%s", local_hex_string_custom (p
->addr
, fmt
));
534 printf_filtered (" - %s", local_hex_string_custom (p
->endaddr
, fmt
));
536 /* FIXME: A format of "08l" is not wide enough for file offsets
537 larger than 4GB. OTOH, making it "016l" isn't desirable either
538 since most output will then be much wider than necessary. It
539 may make sense to test the size of the file and choose the
540 format string accordingly. */
542 printf_filtered (" @ %s",
543 local_hex_string_custom (p
->the_bfd_section
->filepos
, "08l"));
544 printf_filtered (" is %s", bfd_section_name (p
->bfd
, p
->the_bfd_section
));
547 printf_filtered (" in %s", bfd_get_filename (p
->bfd
));
549 printf_filtered ("\n");
554 exec_files_info (struct target_ops
*t
)
556 print_section_info (t
, exec_bfd
);
562 printf_unfiltered ("\tMapping info for file `%s'.\n", vmap
->name
);
563 printf_unfiltered ("\t %*s %*s %*s %*s %8.8s %s\n",
564 strlen_paddr (), "tstart",
565 strlen_paddr (), "tend",
566 strlen_paddr (), "dstart",
567 strlen_paddr (), "dend",
571 for (vp
= vmap
; vp
; vp
= vp
->nxt
)
572 printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
578 *vp
->member
? "(" : "", vp
->member
,
579 *vp
->member
? ")" : "");
584 exec_set_section_offsets sets the offsets of all the sections
585 in the exec objfile. */
588 exec_set_section_offsets (bfd_signed_vma text_off
, bfd_signed_vma data_off
,
589 bfd_signed_vma bss_off
)
591 struct section_table
*sect
;
593 for (sect
= exec_ops
.to_sections
;
594 sect
< exec_ops
.to_sections_end
;
599 flags
= bfd_get_section_flags (exec_bfd
, sect
->the_bfd_section
);
601 if (flags
& SEC_CODE
)
603 sect
->addr
+= text_off
;
604 sect
->endaddr
+= text_off
;
606 else if (flags
& (SEC_DATA
| SEC_LOAD
))
608 sect
->addr
+= data_off
;
609 sect
->endaddr
+= data_off
;
611 else if (flags
& SEC_ALLOC
)
613 sect
->addr
+= bss_off
;
614 sect
->endaddr
+= bss_off
;
620 set_section_command (char *args
, int from_tty
)
622 struct section_table
*p
;
625 unsigned long secaddr
;
630 error ("Must specify section name and its virtual address");
632 /* Parse out section name */
633 for (secname
= args
; !isspace (*args
); args
++);
634 seclen
= args
- secname
;
636 /* Parse out new virtual address */
637 secaddr
= parse_and_eval_address (args
);
639 for (p
= exec_ops
.to_sections
; p
< exec_ops
.to_sections_end
; p
++)
641 if (!strncmp (secname
, bfd_section_name (exec_bfd
, p
->the_bfd_section
), seclen
)
642 && bfd_section_name (exec_bfd
, p
->the_bfd_section
)[seclen
] == '\0')
644 offset
= secaddr
- p
->addr
;
646 p
->endaddr
+= offset
;
648 exec_files_info (&exec_ops
);
652 if (seclen
>= sizeof (secprint
))
653 seclen
= sizeof (secprint
) - 1;
654 strncpy (secprint
, secname
, seclen
);
655 secprint
[seclen
] = '\0';
656 error ("Section %s not found", secprint
);
659 /* If mourn is being called in all the right places, this could be say
660 `gdb internal error' (since generic_mourn calls
661 breakpoint_init_inferior). */
664 ignore (CORE_ADDR addr
, char *contents
)
669 /* Find mapped memory. */
672 exec_set_find_memory_regions (int (*func
) (int (*) (CORE_ADDR
,
678 exec_ops
.to_find_memory_regions
= func
;
681 static char *exec_make_note_section (bfd
*, int *);
683 /* Fill in the exec file target vector. Very few entries need to be
689 exec_ops
.to_shortname
= "exec";
690 exec_ops
.to_longname
= "Local exec file";
691 exec_ops
.to_doc
= "Use an executable file as a target.\n\
692 Specify the filename of the executable file.";
693 exec_ops
.to_open
= exec_open
;
694 exec_ops
.to_close
= exec_close
;
695 exec_ops
.to_attach
= find_default_attach
;
696 exec_ops
.to_xfer_memory
= xfer_memory
;
697 exec_ops
.to_files_info
= exec_files_info
;
698 exec_ops
.to_insert_breakpoint
= ignore
;
699 exec_ops
.to_remove_breakpoint
= ignore
;
700 exec_ops
.to_create_inferior
= find_default_create_inferior
;
701 exec_ops
.to_stratum
= file_stratum
;
702 exec_ops
.to_has_memory
= 1;
703 exec_ops
.to_make_corefile_notes
= exec_make_note_section
;
704 exec_ops
.to_magic
= OPS_MAGIC
;
708 _initialize_exec (void)
710 struct cmd_list_element
*c
;
716 c
= add_cmd ("file", class_files
, file_command
,
717 "Use FILE as program to be debugged.\n\
718 It is read for its symbols, for getting the contents of pure memory,\n\
719 and it is the program executed when you use the `run' command.\n\
720 If FILE cannot be found as specified, your execution directory path\n\
721 ($PATH) is searched for a command of that name.\n\
722 No arg means to have no executable file and no symbols.", &cmdlist
);
723 set_cmd_completer (c
, filename_completer
);
726 c
= add_cmd ("exec-file", class_files
, exec_file_command
,
727 "Use FILE as program for getting contents of pure memory.\n\
728 If FILE cannot be found as specified, your execution directory path\n\
729 is searched for a command of that name.\n\
730 No arg means have no executable file.", &cmdlist
);
731 set_cmd_completer (c
, filename_completer
);
733 add_com ("section", class_files
, set_section_command
,
734 "Change the base address of section SECTION of the exec file to ADDR.\n\
735 This can be used if the exec file does not contain section addresses,\n\
736 (such as in the a.out format), or when the addresses specified in the\n\
737 file itself are wrong. Each section must be changed separately. The\n\
738 ``info files'' command lists all the sections and their addresses.");
741 (add_set_cmd ("write", class_support
, var_boolean
, (char *) &write_files
,
742 "Set writing into executable and core files.",
746 add_target (&exec_ops
);
750 exec_make_note_section (bfd
*obfd
, int *note_size
)
752 error ("Can't create a corefile");