1 /* Core dump and executable file functions below target vector, for GDB.
2 Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
3 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
27 #include "frame.h" /* required by inferior.h */
34 #include "gdbthread.h"
36 /* List of all available core_fns. On gdb startup, each core file register
37 reader calls add_core_fns() to register information on each core format it
38 is prepared to read. */
40 static struct core_fns
*core_file_fns
= NULL
;
42 /* The core_fns for a core file handler that is prepared to read the core
43 file currently open on core_bfd. */
45 static struct core_fns
*core_vec
= NULL
;
47 static void core_files_info
PARAMS ((struct target_ops
*));
50 static int solib_add_stub
PARAMS ((PTR
));
53 static struct core_fns
*sniff_core_bfd
PARAMS ((bfd
*));
55 static boolean gdb_check_format
PARAMS ((bfd
*));
57 static void core_open
PARAMS ((char *, int));
59 static void core_detach
PARAMS ((char *, int));
61 static void core_close
PARAMS ((int));
63 static void get_core_registers
PARAMS ((int));
65 static void add_to_thread_list
PARAMS ((bfd
*, asection
*, PTR
));
67 static int ignore
PARAMS ((CORE_ADDR
, char *));
69 static char *core_file_to_sym_file
PARAMS ((char *));
71 static int core_file_thread_alive
PARAMS ((int tid
));
73 static void init_core_ops
PARAMS ((void));
75 void _initialize_corelow
PARAMS ((void));
77 struct target_ops core_ops
;
79 /* Link a new core_fns into the global core_file_fns list. Called on gdb
80 startup by the _initialize routine in each core file register reader, to
81 register information about each format the the reader is prepared to
88 cf
->next
= core_file_fns
;
92 /* The default function that core file handlers can use to examine a
93 core file BFD and decide whether or not to accept the job of
94 reading the core file. */
97 default_core_sniffer (our_fns
, abfd
)
98 struct core_fns
*our_fns
;
103 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
107 /* Walk through the list of core functions to find a set that can
108 handle the core file open on ABFD. Default to the first one in the
109 list of nothing matches. Returns pointer to set that is
112 static struct core_fns
*
113 sniff_core_bfd (abfd
)
117 struct core_fns
*yummy
= NULL
;
120 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
122 if (cf
->core_sniffer (cf
, abfd
))
130 warning ("\"%s\": ambiguous core format, %d handlers match",
131 bfd_get_filename (abfd
), matches
);
133 else if (matches
== 0)
135 warning ("\"%s\": no core file handler recognizes format, using default",
136 bfd_get_filename (abfd
));
140 yummy
= core_file_fns
;
145 /* The default is to reject every core file format we see. Either
146 BFD has to recognize it, or we have to provide a function in the
147 core file handler that recognizes it. */
150 default_check_format (abfd
)
156 /* Attempt to recognize core file formats that BFD rejects. */
159 gdb_check_format (abfd
)
164 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
166 if (cf
->check_format (abfd
))
174 /* Discard all vestiges of any previous core file and mark data and stack
179 core_close (quitting
)
186 inferior_pid
= 0; /* Avoid confusion from thread stuff */
188 /* Clear out solib state while the bfd is still open. See
189 comments in clear_solib in solib.c. */
194 name
= bfd_get_filename (core_bfd
);
195 if (!bfd_close (core_bfd
))
196 warning ("cannot close \"%s\": %s",
197 name
, bfd_errmsg (bfd_get_error ()));
200 if (core_ops
.to_sections
)
202 free ((PTR
) core_ops
.to_sections
);
203 core_ops
.to_sections
= NULL
;
204 core_ops
.to_sections_end
= NULL
;
211 /* Stub function for catch_errors around shared library hacking. FROM_TTYP
212 is really an int * which points to from_tty. */
215 solib_add_stub (from_ttyp
)
218 SOLIB_ADD (NULL
, *(int *) from_ttyp
, ¤t_target
);
219 re_enable_breakpoints_in_shlibs ();
222 #endif /* SOLIB_ADD */
224 /* Look for sections whose names start with `.reg/' so that we can extract the
225 list of threads in a core file. */
228 add_to_thread_list (abfd
, asect
, reg_sect_arg
)
234 asection
*reg_sect
= (asection
*) reg_sect_arg
;
236 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
239 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
241 add_thread (thread_id
);
243 /* Warning, Will Robinson, looking at BFD private data! */
246 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
247 inferior_pid
= thread_id
; /* Yes, make it current */
250 /* This routine opens and sets up the core file bfd. */
253 core_open (filename
, from_tty
)
259 struct cleanup
*old_chain
;
265 target_preopen (from_tty
);
269 "No core file specified. (Use `detach' to stop debugging a core file.)"
270 : "No core file specified.");
273 filename
= tilde_expand (filename
);
274 if (filename
[0] != '/')
276 temp
= concat (current_directory
, "/", filename
, NULL
);
281 old_chain
= make_cleanup (free
, filename
);
283 scratch_chan
= open (filename
, write_files
? O_RDWR
: O_RDONLY
, 0);
284 if (scratch_chan
< 0)
285 perror_with_name (filename
);
287 temp_bfd
= bfd_fdopenr (filename
, gnutarget
, scratch_chan
);
288 if (temp_bfd
== NULL
)
289 perror_with_name (filename
);
291 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
292 !gdb_check_format (temp_bfd
))
294 /* Do it after the err msg */
295 /* FIXME: should be checking for errors from bfd_close (for one thing,
296 on error it does not free all the storage associated with the
298 make_cleanup_bfd_close (temp_bfd
);
299 error ("\"%s\" is not a core dump: %s",
300 filename
, bfd_errmsg (bfd_get_error ()));
303 /* Looks semi-reasonable. Toss the old core file and work on the new. */
305 discard_cleanups (old_chain
); /* Don't free filename any more */
306 unpush_target (&core_ops
);
308 old_chain
= make_cleanup ((make_cleanup_func
) core_close
, core_bfd
);
310 /* Find a suitable core file handler to munch on core_bfd */
311 core_vec
= sniff_core_bfd (core_bfd
);
315 /* Find the data section */
316 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
317 &core_ops
.to_sections_end
))
318 error ("\"%s\": Can't find sections: %s",
319 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
321 set_gdbarch_from_file (core_bfd
);
323 ontop
= !push_target (&core_ops
);
324 discard_cleanups (old_chain
);
326 p
= bfd_core_file_failing_command (core_bfd
);
328 printf_filtered ("Core was generated by `%s'.\n", p
);
330 siggy
= bfd_core_file_failing_signal (core_bfd
);
332 printf_filtered ("Program terminated with signal %d, %s.\n", siggy
,
333 safe_strsignal (siggy
));
335 /* Build up thread list from BFD sections. */
338 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
339 bfd_get_section_by_name (core_bfd
, ".reg"));
343 /* Fetch all registers from core file. */
344 target_fetch_registers (-1);
346 /* Add symbols and section mappings for any shared libraries. */
348 catch_errors (solib_add_stub
, &from_tty
, (char *) 0,
352 /* Now, set up the frame cache, and print the top of stack. */
353 flush_cached_frames ();
354 select_frame (get_current_frame (), 0);
355 print_stack_frame (selected_frame
, selected_frame_level
, 1);
360 "you won't be able to access this core file until you terminate\n\
361 your %s; do ``info files''", target_longname
);
366 core_detach (args
, from_tty
)
371 error ("Too many arguments");
372 unpush_target (&core_ops
);
373 reinit_frame_cache ();
375 printf_filtered ("No core file now.\n");
379 /* Try to retrieve registers from a section in core_bfd, and supply
380 them to core_vec->core_read_registers, as the register set numbered
383 If inferior_pid is zero, do the single-threaded thing: look for a
384 section named NAME. If inferior_pid is non-zero, do the
385 multi-threaded thing: look for a section named "NAME/PID", where
386 PID is the shortest ASCII decimal representation of inferior_pid.
388 HUMAN_NAME is a human-readable name for the kind of registers the
389 NAME section contains, for use in error messages.
391 If REQUIRED is non-zero, print an error if the core file doesn't
392 have a section by the appropriate name. Otherwise, just do nothing. */
395 get_core_register_section (char *name
,
400 char section_name
[100];
406 sprintf (section_name
, "%s/%d", name
, inferior_pid
);
408 strcpy (section_name
, name
);
410 section
= bfd_get_section_by_name (core_bfd
, section_name
);
414 warning ("Couldn't find %s registers in core file.\n", human_name
);
418 size
= bfd_section_size (core_bfd
, section
);
419 contents
= alloca (size
);
420 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
423 warning ("Couldn't read %s registers from `%s' section in core file.\n",
428 core_vec
->core_read_registers (contents
, size
, which
,
430 bfd_section_vma (core_bfd
, section
)));
434 /* Get the registers out of a core file. This is the machine-
435 independent part. Fetch_core_registers is the machine-dependent
436 part, typically implemented in the xm-file for each architecture. */
438 /* We just get all the registers, so we don't use regno. */
442 get_core_registers (regno
)
448 || core_vec
->core_read_registers
== NULL
)
450 fprintf_filtered (gdb_stderr
,
451 "Can't fetch registers from this type of core file\n");
455 get_core_register_section (".reg", 0, "general-purpose", 1);
456 get_core_register_section (".reg2", 2, "floating-point", 0);
457 get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
459 registers_fetched ();
463 core_file_to_sym_file (core
)
466 CONST
char *failing_command
;
473 error ("No core file specified.");
475 core
= tilde_expand (core
);
478 temp
= concat (current_directory
, "/", core
, NULL
);
482 scratch_chan
= open (core
, write_files
? O_RDWR
: O_RDONLY
, 0);
483 if (scratch_chan
< 0)
484 perror_with_name (core
);
486 temp_bfd
= bfd_fdopenr (core
, gnutarget
, scratch_chan
);
487 if (temp_bfd
== NULL
)
488 perror_with_name (core
);
490 if (!bfd_check_format (temp_bfd
, bfd_core
))
492 /* Do it after the err msg */
493 /* FIXME: should be checking for errors from bfd_close (for one thing,
494 on error it does not free all the storage associated with the
496 make_cleanup_bfd_close (temp_bfd
);
497 error ("\"%s\" is not a core dump: %s",
498 core
, bfd_errmsg (bfd_get_error ()));
501 /* Find the data section */
502 if (build_section_table (temp_bfd
, &core_ops
.to_sections
,
503 &core_ops
.to_sections_end
))
504 error ("\"%s\": Can't find sections: %s",
505 bfd_get_filename (temp_bfd
), bfd_errmsg (bfd_get_error ()));
507 failing_command
= bfd_core_file_failing_command (temp_bfd
);
509 bfd_close (temp_bfd
);
511 /* If we found a filename, remember that it is probably saved
512 relative to the executable that created it. If working directory
513 isn't there now, we may not be able to find the executable. Rather
514 than trying to be sauve about finding it, just check if the file
515 exists where we are now. If not, then punt and tell our client
516 we couldn't find the sym file.
518 p
= (char *) failing_command
;
519 if ((p
!= NULL
) && (access (p
, F_OK
) != 0))
527 struct target_ops
*t
;
529 print_section_info (t
, core_bfd
);
532 /* If mourn is being called in all the right places, this could be say
533 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
536 ignore (addr
, contents
)
544 /* Okay, let's be honest: threads gleaned from a core file aren't
545 exactly lively, are they? On the other hand, if we don't claim
546 that each & every one is alive, then we don't get any of them
547 to appear in an "info thread" command, which is quite a useful
551 core_file_thread_alive (tid
)
557 /* Fill in core_ops with its defined operations and properties. */
562 core_ops
.to_shortname
= "core";
563 core_ops
.to_longname
= "Local core dump file";
565 "Use a core file as a target. Specify the filename of the core file.";
566 core_ops
.to_open
= core_open
;
567 core_ops
.to_close
= core_close
;
568 core_ops
.to_attach
= find_default_attach
;
569 core_ops
.to_require_attach
= find_default_require_attach
;
570 core_ops
.to_detach
= core_detach
;
571 core_ops
.to_require_detach
= find_default_require_detach
;
572 core_ops
.to_fetch_registers
= get_core_registers
;
573 core_ops
.to_xfer_memory
= xfer_memory
;
574 core_ops
.to_files_info
= core_files_info
;
575 core_ops
.to_insert_breakpoint
= ignore
;
576 core_ops
.to_remove_breakpoint
= ignore
;
577 core_ops
.to_create_inferior
= find_default_create_inferior
;
578 core_ops
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
579 core_ops
.to_thread_alive
= core_file_thread_alive
;
580 core_ops
.to_core_file_to_sym_file
= core_file_to_sym_file
;
581 core_ops
.to_stratum
= core_stratum
;
582 core_ops
.to_has_memory
= 1;
583 core_ops
.to_has_stack
= 1;
584 core_ops
.to_has_registers
= 1;
585 core_ops
.to_magic
= OPS_MAGIC
;
588 /* non-zero if we should not do the add_target call in
589 _initialize_corelow; not initialized (i.e., bss) so that
590 the target can initialize it (i.e., data) if appropriate.
591 This needs to be set at compile time because we don't know
592 for sure whether the target's initialize routine is called
593 before us or after us. */
594 int coreops_suppress_target
;
597 _initialize_corelow ()
601 if (!coreops_suppress_target
)
602 add_target (&core_ops
);