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, Boston, MA 02111-1307, USA. */
22 #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 static void core_files_info
PARAMS ((struct target_ops
*));
45 static int solib_add_stub
PARAMS ((char *));
48 static void core_open
PARAMS ((char *, int));
50 static void core_detach
PARAMS ((char *, int));
52 static void core_close
PARAMS ((int));
54 static void get_core_registers
PARAMS ((int));
56 static void add_to_thread_list
PARAMS ((bfd
*, asection
*, PTR
));
58 static int ignore
PARAMS ((CORE_ADDR
, char *));
60 static char *core_file_to_sym_file
PARAMS ((char *));
62 static int core_file_thread_alive
PARAMS ((int tid
));
64 static void init_core_ops
PARAMS ((void));
66 void _initialize_corelow
PARAMS ((void));
68 struct target_ops core_ops
;
70 /* Link a new core_fns into the global core_file_fns list. Called on gdb
71 startup by the _initialize routine in each core file register reader, to
72 register information about each format the the reader is prepared to
79 cf
-> next
= core_file_fns
;
84 /* Discard all vestiges of any previous core file and mark data and stack
96 inferior_pid
= 0; /* Avoid confusion from thread stuff */
98 name
= bfd_get_filename (core_bfd
);
99 if (!bfd_close (core_bfd
))
100 warning ("cannot close \"%s\": %s",
101 name
, bfd_errmsg (bfd_get_error ()));
107 if (core_ops
.to_sections
)
109 free ((PTR
)core_ops
.to_sections
);
110 core_ops
.to_sections
= NULL
;
111 core_ops
.to_sections_end
= NULL
;
117 /* Stub function for catch_errors around shared library hacking. FROM_TTYP
118 is really an int * which points to from_tty. */
121 solib_add_stub (from_ttyp
)
124 SOLIB_ADD (NULL
, *(int *)from_ttyp
, ¤t_target
);
125 re_enable_breakpoints_in_shlibs ();
128 #endif /* SOLIB_ADD */
130 /* Look for sections whose names start with `.reg/' so that we can extract the
131 list of threads in a core file. */
134 add_to_thread_list (abfd
, asect
, reg_sect_arg
)
140 asection
*reg_sect
= (asection
*) reg_sect_arg
;
142 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
145 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
147 add_thread (thread_id
);
149 /* Warning, Will Robinson, looking at BFD private data! */
152 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
153 inferior_pid
= thread_id
; /* Yes, make it current */
156 /* This routine opens and sets up the core file bfd. */
159 core_open (filename
, from_tty
)
165 struct cleanup
*old_chain
;
171 target_preopen (from_tty
);
175 "No core file specified. (Use `detach' to stop debugging a core file.)"
176 : "No core file specified.");
179 filename
= tilde_expand (filename
);
180 if (filename
[0] != '/')
182 temp
= concat (current_directory
, "/", filename
, NULL
);
187 old_chain
= make_cleanup (free
, filename
);
189 scratch_chan
= open (filename
, write_files
? O_RDWR
: O_RDONLY
, 0);
190 if (scratch_chan
< 0)
191 perror_with_name (filename
);
193 temp_bfd
= bfd_fdopenr (filename
, gnutarget
, scratch_chan
);
194 if (temp_bfd
== NULL
)
195 perror_with_name (filename
);
197 if (!bfd_check_format (temp_bfd
, bfd_core
))
199 /* Do it after the err msg */
200 /* FIXME: should be checking for errors from bfd_close (for one thing,
201 on error it does not free all the storage associated with the
203 make_cleanup ((make_cleanup_func
) bfd_close
, temp_bfd
);
204 error ("\"%s\" is not a core dump: %s",
205 filename
, bfd_errmsg (bfd_get_error ()));
208 /* Looks semi-reasonable. Toss the old core file and work on the new. */
210 discard_cleanups (old_chain
); /* Don't free filename any more */
211 unpush_target (&core_ops
);
213 old_chain
= make_cleanup ((make_cleanup_func
) core_close
, core_bfd
);
217 /* Find the data section */
218 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
219 &core_ops
.to_sections_end
))
220 error ("\"%s\": Can't find sections: %s",
221 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
223 ontop
= !push_target (&core_ops
);
224 discard_cleanups (old_chain
);
226 p
= bfd_core_file_failing_command (core_bfd
);
228 printf_filtered ("Core was generated by `%s'.\n", p
);
230 siggy
= bfd_core_file_failing_signal (core_bfd
);
232 printf_filtered ("Program terminated with signal %d, %s.\n", siggy
,
233 safe_strsignal (siggy
));
235 /* Build up thread list from BFD sections. */
238 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
239 bfd_get_section_by_name (core_bfd
, ".reg"));
243 /* Fetch all registers from core file. */
244 target_fetch_registers (-1);
246 /* Add symbols and section mappings for any shared libraries. */
248 catch_errors (solib_add_stub
, &from_tty
, (char *)0,
252 /* Now, set up the frame cache, and print the top of stack. */
253 flush_cached_frames ();
254 select_frame (get_current_frame (), 0);
255 print_stack_frame (selected_frame
, selected_frame_level
, 1);
260 "you won't be able to access this core file until you terminate\n\
261 your %s; do ``info files''", target_longname
);
266 core_detach (args
, from_tty
)
271 error ("Too many arguments");
272 unpush_target (&core_ops
);
273 reinit_frame_cache ();
275 printf_filtered ("No core file now.\n");
278 /* Get the registers out of a core file. This is the machine-
279 independent part. Fetch_core_registers is the machine-dependent
280 part, typically implemented in the xm-file for each architecture. */
282 /* We just get all the registers, so we don't use regno. */
286 get_core_registers (regno
)
293 enum bfd_flavour our_flavour
= bfd_get_flavour (core_bfd
);
294 struct core_fns
*cf
= NULL
;
296 if (core_file_fns
== NULL
)
298 fprintf_filtered (gdb_stderr
,
299 "Can't fetch registers from this type of core file\n");
303 /* Thread support. If inferior_pid is non-zero, then we have found a core
304 file with threads (or multiple processes). In that case, we need to
305 use the appropriate register section, else we just use `.reg'. */
307 /* XXX - same thing needs to be done for floating-point (.reg2) sections. */
310 sprintf (secname
, ".reg/%d", inferior_pid
);
312 strcpy (secname
, ".reg");
314 reg_sec
= bfd_get_section_by_name (core_bfd
, secname
);
317 size
= bfd_section_size (core_bfd
, reg_sec
);
318 the_regs
= alloca (size
);
319 /* Look for the core functions that match this flavor. Default to the
320 first one if nothing matches. */
321 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
-> next
)
323 if (our_flavour
== cf
-> core_flavour
)
333 bfd_get_section_contents (core_bfd
, reg_sec
, the_regs
, (file_ptr
)0, size
) &&
334 cf
-> core_read_registers
!= NULL
)
336 (cf
-> core_read_registers (the_regs
, size
, 0,
337 (unsigned) bfd_section_vma (abfd
,reg_sec
)));
342 fprintf_filtered (gdb_stderr
,
343 "Couldn't fetch registers from core file: %s\n",
344 bfd_errmsg (bfd_get_error ()));
347 /* Now do it again for the float registers, if they exist. */
348 reg_sec
= bfd_get_section_by_name (core_bfd
, ".reg2");
351 size
= bfd_section_size (core_bfd
, reg_sec
);
352 the_regs
= alloca (size
);
354 bfd_get_section_contents (core_bfd
, reg_sec
, the_regs
, (file_ptr
)0, size
) &&
355 cf
-> core_read_registers
!= NULL
)
357 (cf
-> core_read_registers (the_regs
, size
, 2,
358 (unsigned) bfd_section_vma (abfd
,reg_sec
)));
362 fprintf_filtered (gdb_stderr
,
363 "Couldn't fetch register set 2 from core file: %s\n",
364 bfd_errmsg (bfd_get_error ()));
367 registers_fetched ();
371 core_file_to_sym_file (core
)
374 CONST
char * failing_command
;
381 error ("No core file specified.");
383 core
= tilde_expand (core
);
386 temp
= concat (current_directory
, "/", core
, NULL
);
390 scratch_chan
= open (core
, write_files
? O_RDWR
: O_RDONLY
, 0);
391 if (scratch_chan
< 0)
392 perror_with_name (core
);
394 temp_bfd
= bfd_fdopenr (core
, gnutarget
, scratch_chan
);
395 if (temp_bfd
== NULL
)
396 perror_with_name (core
);
398 if (!bfd_check_format (temp_bfd
, bfd_core
))
400 /* Do it after the err msg */
401 /* FIXME: should be checking for errors from bfd_close (for one thing,
402 on error it does not free all the storage associated with the
404 make_cleanup (bfd_close
, temp_bfd
);
405 error ("\"%s\" is not a core dump: %s",
406 core
, bfd_errmsg (bfd_get_error ()));
409 /* Find the data section */
410 if (build_section_table (temp_bfd
, &core_ops
.to_sections
,
411 &core_ops
.to_sections_end
))
412 error ("\"%s\": Can't find sections: %s",
413 bfd_get_filename (temp_bfd
), bfd_errmsg (bfd_get_error ()));
415 failing_command
= bfd_core_file_failing_command (temp_bfd
);
417 bfd_close (temp_bfd
);
419 /* If we found a filename, remember that it is probably saved
420 relative to the executable that created it. If working directory
421 isn't there now, we may not be able to find the executable. Rather
422 than trying to be sauve about finding it, just check if the file
423 exists where we are now. If not, then punt and tell our client
424 we couldn't find the sym file.
426 p
= (char *) failing_command
;
427 if ((p
!= NULL
) && (access (p
, F_OK
) != 0))
435 struct target_ops
*t
;
437 print_section_info (t
, core_bfd
);
440 /* If mourn is being called in all the right places, this could be say
441 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
444 ignore (addr
, contents
)
452 /* Okay, let's be honest: threads gleaned from a core file aren't
453 exactly lively, are they? On the other hand, if we don't claim
454 that each & every one is alive, then we don't get any of them
455 to appear in an "info thread" command, which is quite a useful
459 core_file_thread_alive (tid
)
465 /* Fill in core_ops with its defined operations and properties. */
470 core_ops
.to_shortname
= "core";
471 core_ops
.to_longname
= "Local core dump file";
473 "Use a core file as a target. Specify the filename of the core file.";
474 core_ops
.to_open
= core_open
;
475 core_ops
.to_close
= core_close
;
476 core_ops
.to_attach
= find_default_attach
;
477 core_ops
.to_require_attach
= find_default_require_attach
;
478 core_ops
.to_detach
= core_detach
;
479 core_ops
.to_require_detach
= find_default_require_detach
;
480 core_ops
.to_fetch_registers
= get_core_registers
;
481 core_ops
.to_xfer_memory
= xfer_memory
;
482 core_ops
.to_files_info
= core_files_info
;
483 core_ops
.to_insert_breakpoint
= ignore
;
484 core_ops
.to_remove_breakpoint
= ignore
;
485 core_ops
.to_create_inferior
= find_default_create_inferior
;
486 core_ops
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
487 core_ops
.to_thread_alive
= core_file_thread_alive
;
488 core_ops
.to_core_file_to_sym_file
= core_file_to_sym_file
;
489 core_ops
.to_stratum
= core_stratum
;
490 core_ops
.to_has_memory
= 1;
491 core_ops
.to_has_stack
= 1;
492 core_ops
.to_has_registers
= 1;
493 core_ops
.to_magic
= OPS_MAGIC
;
496 /* non-zero if we should not do the add_target call in
497 _initialize_corelow; not initialized (i.e., bss) so that
498 the target can initialize it (i.e., data) if appropriate.
499 This needs to be set at compile time because we don't know
500 for sure whether the target's initialize routine is called
501 before us or after us. */
502 int coreops_suppress_target
;
505 _initialize_corelow ()
509 if (!coreops_suppress_target
)
510 add_target (&core_ops
);