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 static void core_files_info
PARAMS ((struct target_ops
*));
45 static int solib_add_stub
PARAMS ((PTR
));
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 /* Clear out solib state while the bfd is still open. See
99 comments in clear_solib in solib.c. */
104 name
= bfd_get_filename (core_bfd
);
105 if (!bfd_close (core_bfd
))
106 warning ("cannot close \"%s\": %s",
107 name
, bfd_errmsg (bfd_get_error ()));
110 if (core_ops
.to_sections
)
112 free ((PTR
) core_ops
.to_sections
);
113 core_ops
.to_sections
= NULL
;
114 core_ops
.to_sections_end
= NULL
;
120 /* Stub function for catch_errors around shared library hacking. FROM_TTYP
121 is really an int * which points to from_tty. */
124 solib_add_stub (from_ttyp
)
127 SOLIB_ADD (NULL
, *(int *) from_ttyp
, ¤t_target
);
128 re_enable_breakpoints_in_shlibs ();
131 #endif /* SOLIB_ADD */
133 /* Look for sections whose names start with `.reg/' so that we can extract the
134 list of threads in a core file. */
137 add_to_thread_list (abfd
, asect
, reg_sect_arg
)
143 asection
*reg_sect
= (asection
*) reg_sect_arg
;
145 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
148 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
150 add_thread (thread_id
);
152 /* Warning, Will Robinson, looking at BFD private data! */
155 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
156 inferior_pid
= thread_id
; /* Yes, make it current */
159 /* This routine opens and sets up the core file bfd. */
162 core_open (filename
, from_tty
)
168 struct cleanup
*old_chain
;
174 target_preopen (from_tty
);
178 "No core file specified. (Use `detach' to stop debugging a core file.)"
179 : "No core file specified.");
182 filename
= tilde_expand (filename
);
183 if (filename
[0] != '/')
185 temp
= concat (current_directory
, "/", filename
, NULL
);
190 old_chain
= make_cleanup (free
, filename
);
192 scratch_chan
= open (filename
, write_files
? O_RDWR
: O_RDONLY
, 0);
193 if (scratch_chan
< 0)
194 perror_with_name (filename
);
196 temp_bfd
= bfd_fdopenr (filename
, gnutarget
, scratch_chan
);
197 if (temp_bfd
== NULL
)
198 perror_with_name (filename
);
200 if (!bfd_check_format (temp_bfd
, bfd_core
))
202 /* Do it after the err msg */
203 /* FIXME: should be checking for errors from bfd_close (for one thing,
204 on error it does not free all the storage associated with the
206 make_cleanup ((make_cleanup_func
) bfd_close
, temp_bfd
);
207 error ("\"%s\" is not a core dump: %s",
208 filename
, bfd_errmsg (bfd_get_error ()));
211 /* Looks semi-reasonable. Toss the old core file and work on the new. */
213 discard_cleanups (old_chain
); /* Don't free filename any more */
214 unpush_target (&core_ops
);
216 old_chain
= make_cleanup ((make_cleanup_func
) core_close
, core_bfd
);
220 /* Find the data section */
221 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
222 &core_ops
.to_sections_end
))
223 error ("\"%s\": Can't find sections: %s",
224 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
226 ontop
= !push_target (&core_ops
);
227 discard_cleanups (old_chain
);
229 p
= bfd_core_file_failing_command (core_bfd
);
231 printf_filtered ("Core was generated by `%s'.\n", p
);
233 siggy
= bfd_core_file_failing_signal (core_bfd
);
235 printf_filtered ("Program terminated with signal %d, %s.\n", siggy
,
236 safe_strsignal (siggy
));
238 /* Build up thread list from BFD sections. */
241 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
242 bfd_get_section_by_name (core_bfd
, ".reg"));
246 /* Fetch all registers from core file. */
247 target_fetch_registers (-1);
249 /* Add symbols and section mappings for any shared libraries. */
251 catch_errors (solib_add_stub
, &from_tty
, (char *) 0,
255 /* Now, set up the frame cache, and print the top of stack. */
256 flush_cached_frames ();
257 select_frame (get_current_frame (), 0);
258 print_stack_frame (selected_frame
, selected_frame_level
, 1);
263 "you won't be able to access this core file until you terminate\n\
264 your %s; do ``info files''", target_longname
);
269 core_detach (args
, from_tty
)
274 error ("Too many arguments");
275 unpush_target (&core_ops
);
276 reinit_frame_cache ();
278 printf_filtered ("No core file now.\n");
281 /* Get the registers out of a core file. This is the machine-
282 independent part. Fetch_core_registers is the machine-dependent
283 part, typically implemented in the xm-file for each architecture. */
285 /* We just get all the registers, so we don't use regno. */
289 get_core_registers (regno
)
296 enum bfd_flavour our_flavour
= bfd_get_flavour (core_bfd
);
297 struct core_fns
*cf
= NULL
;
299 if (core_file_fns
== NULL
)
301 fprintf_filtered (gdb_stderr
,
302 "Can't fetch registers from this type of core file\n");
306 /* Thread support. If inferior_pid is non-zero, then we have found a core
307 file with threads (or multiple processes). In that case, we need to
308 use the appropriate register section, else we just use `.reg'. */
310 /* XXX - same thing needs to be done for floating-point (.reg2) sections. */
313 sprintf (secname
, ".reg/%d", inferior_pid
);
315 strcpy (secname
, ".reg");
317 reg_sec
= bfd_get_section_by_name (core_bfd
, secname
);
320 size
= bfd_section_size (core_bfd
, reg_sec
);
321 the_regs
= alloca (size
);
322 /* Look for the core functions that match this flavor. Default to the
323 first one if nothing matches. */
324 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
326 if (our_flavour
== cf
->core_flavour
)
336 bfd_get_section_contents (core_bfd
, reg_sec
, the_regs
, (file_ptr
) 0, size
) &&
337 cf
->core_read_registers
!= NULL
)
339 (cf
->core_read_registers (the_regs
, size
, 0,
340 (unsigned) bfd_section_vma (abfd
, reg_sec
)));
345 fprintf_filtered (gdb_stderr
,
346 "Couldn't fetch registers from core file: %s\n",
347 bfd_errmsg (bfd_get_error ()));
350 /* Now do it again for the float registers, if they exist. */
351 reg_sec
= bfd_get_section_by_name (core_bfd
, ".reg2");
354 size
= bfd_section_size (core_bfd
, reg_sec
);
355 the_regs
= alloca (size
);
357 bfd_get_section_contents (core_bfd
, reg_sec
, the_regs
, (file_ptr
) 0, size
) &&
358 cf
->core_read_registers
!= NULL
)
360 (cf
->core_read_registers (the_regs
, size
, 2,
361 (unsigned) bfd_section_vma (abfd
, reg_sec
)));
365 fprintf_filtered (gdb_stderr
,
366 "Couldn't fetch register set 2 from core file: %s\n",
367 bfd_errmsg (bfd_get_error ()));
370 registers_fetched ();
374 core_file_to_sym_file (core
)
377 CONST
char *failing_command
;
384 error ("No core file specified.");
386 core
= tilde_expand (core
);
389 temp
= concat (current_directory
, "/", core
, NULL
);
393 scratch_chan
= open (core
, write_files
? O_RDWR
: O_RDONLY
, 0);
394 if (scratch_chan
< 0)
395 perror_with_name (core
);
397 temp_bfd
= bfd_fdopenr (core
, gnutarget
, scratch_chan
);
398 if (temp_bfd
== NULL
)
399 perror_with_name (core
);
401 if (!bfd_check_format (temp_bfd
, bfd_core
))
403 /* Do it after the err msg */
404 /* FIXME: should be checking for errors from bfd_close (for one thing,
405 on error it does not free all the storage associated with the
407 make_cleanup ((make_cleanup_func
) bfd_close
, temp_bfd
);
408 error ("\"%s\" is not a core dump: %s",
409 core
, bfd_errmsg (bfd_get_error ()));
412 /* Find the data section */
413 if (build_section_table (temp_bfd
, &core_ops
.to_sections
,
414 &core_ops
.to_sections_end
))
415 error ("\"%s\": Can't find sections: %s",
416 bfd_get_filename (temp_bfd
), bfd_errmsg (bfd_get_error ()));
418 failing_command
= bfd_core_file_failing_command (temp_bfd
);
420 bfd_close (temp_bfd
);
422 /* If we found a filename, remember that it is probably saved
423 relative to the executable that created it. If working directory
424 isn't there now, we may not be able to find the executable. Rather
425 than trying to be sauve about finding it, just check if the file
426 exists where we are now. If not, then punt and tell our client
427 we couldn't find the sym file.
429 p
= (char *) failing_command
;
430 if ((p
!= NULL
) && (access (p
, F_OK
) != 0))
438 struct target_ops
*t
;
440 print_section_info (t
, core_bfd
);
443 /* If mourn is being called in all the right places, this could be say
444 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
447 ignore (addr
, contents
)
455 /* Okay, let's be honest: threads gleaned from a core file aren't
456 exactly lively, are they? On the other hand, if we don't claim
457 that each & every one is alive, then we don't get any of them
458 to appear in an "info thread" command, which is quite a useful
462 core_file_thread_alive (tid
)
468 /* Fill in core_ops with its defined operations and properties. */
473 core_ops
.to_shortname
= "core";
474 core_ops
.to_longname
= "Local core dump file";
476 "Use a core file as a target. Specify the filename of the core file.";
477 core_ops
.to_open
= core_open
;
478 core_ops
.to_close
= core_close
;
479 core_ops
.to_attach
= find_default_attach
;
480 core_ops
.to_require_attach
= find_default_require_attach
;
481 core_ops
.to_detach
= core_detach
;
482 core_ops
.to_require_detach
= find_default_require_detach
;
483 core_ops
.to_fetch_registers
= get_core_registers
;
484 core_ops
.to_xfer_memory
= xfer_memory
;
485 core_ops
.to_files_info
= core_files_info
;
486 core_ops
.to_insert_breakpoint
= ignore
;
487 core_ops
.to_remove_breakpoint
= ignore
;
488 core_ops
.to_create_inferior
= find_default_create_inferior
;
489 core_ops
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
490 core_ops
.to_thread_alive
= core_file_thread_alive
;
491 core_ops
.to_core_file_to_sym_file
= core_file_to_sym_file
;
492 core_ops
.to_stratum
= core_stratum
;
493 core_ops
.to_has_memory
= 1;
494 core_ops
.to_has_stack
= 1;
495 core_ops
.to_has_registers
= 1;
496 core_ops
.to_magic
= OPS_MAGIC
;
499 /* non-zero if we should not do the add_target call in
500 _initialize_corelow; not initialized (i.e., bss) so that
501 the target can initialize it (i.e., data) if appropriate.
502 This needs to be set at compile time because we don't know
503 for sure whether the target's initialize routine is called
504 before us or after us. */
505 int coreops_suppress_target
;
508 _initialize_corelow ()
512 if (!coreops_suppress_target
)
513 add_target (&core_ops
);