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 ((make_cleanup_func
) 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 ontop
= !push_target (&core_ops
);
322 discard_cleanups (old_chain
);
324 p
= bfd_core_file_failing_command (core_bfd
);
326 printf_filtered ("Core was generated by `%s'.\n", p
);
328 siggy
= bfd_core_file_failing_signal (core_bfd
);
330 printf_filtered ("Program terminated with signal %d, %s.\n", siggy
,
331 safe_strsignal (siggy
));
333 /* Build up thread list from BFD sections. */
336 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
337 bfd_get_section_by_name (core_bfd
, ".reg"));
341 /* Fetch all registers from core file. */
342 target_fetch_registers (-1);
344 /* Add symbols and section mappings for any shared libraries. */
346 catch_errors (solib_add_stub
, &from_tty
, (char *) 0,
350 /* Now, set up the frame cache, and print the top of stack. */
351 flush_cached_frames ();
352 select_frame (get_current_frame (), 0);
353 print_stack_frame (selected_frame
, selected_frame_level
, 1);
358 "you won't be able to access this core file until you terminate\n\
359 your %s; do ``info files''", target_longname
);
364 core_detach (args
, from_tty
)
369 error ("Too many arguments");
370 unpush_target (&core_ops
);
371 reinit_frame_cache ();
373 printf_filtered ("No core file now.\n");
377 /* Try to retrieve registers from a section in core_bfd, and supply
378 them to core_vec->core_read_registers, as the register set numbered
381 If inferior_pid is zero, do the single-threaded thing: look for a
382 section named NAME. If inferior_pid is non-zero, do the
383 multi-threaded thing: look for a section named "NAME/PID", where
384 PID is the shortest ASCII decimal representation of inferior_pid.
386 HUMAN_NAME is a human-readable name for the kind of registers the
387 NAME section contains, for use in error messages.
389 If REQUIRED is non-zero, print an error if the core file doesn't
390 have a section by the appropriate name. Otherwise, just do nothing. */
393 get_core_register_section (char *name
,
398 char section_name
[100];
404 sprintf (section_name
, "%s/%d", name
, inferior_pid
);
406 strcpy (section_name
, name
);
408 section
= bfd_get_section_by_name (core_bfd
, section_name
);
412 warning ("Couldn't find %s registers in core file.\n", human_name
);
416 size
= bfd_section_size (core_bfd
, section
);
417 contents
= alloca (size
);
418 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
421 warning ("Couldn't read %s registers from `%s' section in core file.\n",
426 core_vec
->core_read_registers (contents
, size
, which
,
428 bfd_section_vma (core_bfd
, section
)));
432 /* Get the registers out of a core file. This is the machine-
433 independent part. Fetch_core_registers is the machine-dependent
434 part, typically implemented in the xm-file for each architecture. */
436 /* We just get all the registers, so we don't use regno. */
440 get_core_registers (regno
)
446 || core_vec
->core_read_registers
== NULL
)
448 fprintf_filtered (gdb_stderr
,
449 "Can't fetch registers from this type of core file\n");
453 get_core_register_section (".reg", 0, "general-purpose", 1);
454 get_core_register_section (".reg2", 2, "floating-point", 0);
455 get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
457 registers_fetched ();
461 core_file_to_sym_file (core
)
464 CONST
char *failing_command
;
471 error ("No core file specified.");
473 core
= tilde_expand (core
);
476 temp
= concat (current_directory
, "/", core
, NULL
);
480 scratch_chan
= open (core
, write_files
? O_RDWR
: O_RDONLY
, 0);
481 if (scratch_chan
< 0)
482 perror_with_name (core
);
484 temp_bfd
= bfd_fdopenr (core
, gnutarget
, scratch_chan
);
485 if (temp_bfd
== NULL
)
486 perror_with_name (core
);
488 if (!bfd_check_format (temp_bfd
, bfd_core
))
490 /* Do it after the err msg */
491 /* FIXME: should be checking for errors from bfd_close (for one thing,
492 on error it does not free all the storage associated with the
494 make_cleanup ((make_cleanup_func
) bfd_close
, temp_bfd
);
495 error ("\"%s\" is not a core dump: %s",
496 core
, bfd_errmsg (bfd_get_error ()));
499 /* Find the data section */
500 if (build_section_table (temp_bfd
, &core_ops
.to_sections
,
501 &core_ops
.to_sections_end
))
502 error ("\"%s\": Can't find sections: %s",
503 bfd_get_filename (temp_bfd
), bfd_errmsg (bfd_get_error ()));
505 failing_command
= bfd_core_file_failing_command (temp_bfd
);
507 bfd_close (temp_bfd
);
509 /* If we found a filename, remember that it is probably saved
510 relative to the executable that created it. If working directory
511 isn't there now, we may not be able to find the executable. Rather
512 than trying to be sauve about finding it, just check if the file
513 exists where we are now. If not, then punt and tell our client
514 we couldn't find the sym file.
516 p
= (char *) failing_command
;
517 if ((p
!= NULL
) && (access (p
, F_OK
) != 0))
525 struct target_ops
*t
;
527 print_section_info (t
, core_bfd
);
530 /* If mourn is being called in all the right places, this could be say
531 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
534 ignore (addr
, contents
)
542 /* Okay, let's be honest: threads gleaned from a core file aren't
543 exactly lively, are they? On the other hand, if we don't claim
544 that each & every one is alive, then we don't get any of them
545 to appear in an "info thread" command, which is quite a useful
549 core_file_thread_alive (tid
)
555 /* Fill in core_ops with its defined operations and properties. */
560 core_ops
.to_shortname
= "core";
561 core_ops
.to_longname
= "Local core dump file";
563 "Use a core file as a target. Specify the filename of the core file.";
564 core_ops
.to_open
= core_open
;
565 core_ops
.to_close
= core_close
;
566 core_ops
.to_attach
= find_default_attach
;
567 core_ops
.to_require_attach
= find_default_require_attach
;
568 core_ops
.to_detach
= core_detach
;
569 core_ops
.to_require_detach
= find_default_require_detach
;
570 core_ops
.to_fetch_registers
= get_core_registers
;
571 core_ops
.to_xfer_memory
= xfer_memory
;
572 core_ops
.to_files_info
= core_files_info
;
573 core_ops
.to_insert_breakpoint
= ignore
;
574 core_ops
.to_remove_breakpoint
= ignore
;
575 core_ops
.to_create_inferior
= find_default_create_inferior
;
576 core_ops
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
577 core_ops
.to_thread_alive
= core_file_thread_alive
;
578 core_ops
.to_core_file_to_sym_file
= core_file_to_sym_file
;
579 core_ops
.to_stratum
= core_stratum
;
580 core_ops
.to_has_memory
= 1;
581 core_ops
.to_has_stack
= 1;
582 core_ops
.to_has_registers
= 1;
583 core_ops
.to_magic
= OPS_MAGIC
;
586 /* non-zero if we should not do the add_target call in
587 _initialize_corelow; not initialized (i.e., bss) so that
588 the target can initialize it (i.e., data) if appropriate.
589 This needs to be set at compile time because we don't know
590 for sure whether the target's initialize routine is called
591 before us or after us. */
592 int coreops_suppress_target
;
595 _initialize_corelow ()
599 if (!coreops_suppress_target
)
600 add_target (&core_ops
);