1 /* Core dump and executable file functions below target vector, for GDB. 2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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. */ 20 21 #include "defs.h" 22 #include "gdb_string.h" 23 #include <errno.h> 24 #include <signal.h> 25 #include <fcntl.h> 26 #include "frame.h" /* required by inferior.h */ 27 #include "inferior.h" 28 #include "symtab.h" 29 #include "command.h" 30 #include "bfd.h" 31 #include "target.h" 32 #include "gdbcore.h" 33 #include "gdbthread.h" 34 35 /* List of all available core_fns. On gdb startup, each core file register 36 reader calls add_core_fns() to register information on each core format it 37 is prepared to read. */ 38 39 static struct core_fns *core_file_fns = NULL; 40 41 static void core_files_info PARAMS ((struct target_ops *)); 42 43 #ifdef SOLIB_ADD 44 static int solib_add_stub PARAMS ((char *)); 45 #endif 46 47 static void core_open PARAMS ((char *, int)); 48 49 static void core_detach PARAMS ((char *, int)); 50 51 static void core_close PARAMS ((int)); 52 53 static void get_core_registers PARAMS ((int)); 54 55 static void add_to_thread_list PARAMS ((bfd *, asection *, PTR)); 56 57 static int ignore PARAMS ((CORE_ADDR, char *)); 58 59 /* Link a new core_fns into the global core_file_fns list. Called on gdb 60 startup by the _initialize routine in each core file register reader, to 61 register information about each format the the reader is prepared to 62 handle. */ 63 64 void 65 add_core_fns (cf) 66 struct core_fns *cf; 67 { 68 cf -> next = core_file_fns; 69 core_file_fns = cf; 70 } 71 72 73 /* Discard all vestiges of any previous core file and mark data and stack 74 spaces as empty. */ 75 76 /* ARGSUSED */ 77 static void 78 core_close (quitting) 79 int quitting; 80 { 81 char *name; 82 83 if (core_bfd) 84 { 85 inferior_pid = 0; /* Avoid confusion from thread stuff */ 86 87 name = bfd_get_filename (core_bfd); 88 if (!bfd_close (core_bfd)) 89 warning ("cannot close \"%s\": %s", 90 name, bfd_errmsg (bfd_get_error ())); 91 free (name); 92 core_bfd = NULL; 93 #ifdef CLEAR_SOLIB 94 CLEAR_SOLIB (); 95 #endif 96 if (core_ops.to_sections) 97 { 98 free ((PTR)core_ops.to_sections); 99 core_ops.to_sections = NULL; 100 core_ops.to_sections_end = NULL; 101 } 102 } 103 } 104 105 #ifdef SOLIB_ADD 106 /* Stub function for catch_errors around shared library hacking. FROM_TTYP 107 is really an int * which points to from_tty. */ 108 109 static int 110 solib_add_stub (from_ttyp) 111 char *from_ttyp; 112 { 113 SOLIB_ADD (NULL, *(int *)from_ttyp, ¤t_target); 114 re_enable_breakpoints_in_shlibs (); 115 return 0; 116 } 117 #endif /* SOLIB_ADD */ 118 119 /* Look for sections whose names start with `.reg/' so that we can extract the 120 list of threads in a core file. */ 121 122 static void 123 add_to_thread_list (abfd, asect, reg_sect_arg) 124 bfd *abfd; 125 asection *asect; 126 PTR reg_sect_arg; 127 { 128 int thread_id; 129 asection *reg_sect = (asection *) reg_sect_arg; 130 131 if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0) 132 return; 133 134 thread_id = atoi (bfd_section_name (abfd, asect) + 5); 135 136 add_thread (thread_id); 137 138 /* Warning, Will Robinson, looking at BFD private data! */ 139 140 if (reg_sect != NULL 141 && asect->filepos == reg_sect->filepos) /* Did we find .reg? */ 142 inferior_pid = thread_id; /* Yes, make it current */ 143 } 144 145 /* This routine opens and sets up the core file bfd. */ 146 147 static void 148 core_open (filename, from_tty) 149 char *filename; 150 int from_tty; 151 { 152 const char *p; 153 int siggy; 154 struct cleanup *old_chain; 155 char *temp; 156 bfd *temp_bfd; 157 int ontop; 158 int scratch_chan; 159 160 target_preopen (from_tty); 161 if (!filename) 162 { 163 error (core_bfd ? 164 "No core file specified. (Use `detach' to stop debugging a core file.)" 165 : "No core file specified."); 166 } 167 168 filename = tilde_expand (filename); 169 if (filename[0] != '/') 170 { 171 temp = concat (current_directory, "/", filename, NULL); 172 free (filename); 173 filename = temp; 174 } 175 176 old_chain = make_cleanup (free, filename); 177 178 scratch_chan = open (filename, write_files ? O_RDWR : O_RDONLY, 0); 179 if (scratch_chan < 0) 180 perror_with_name (filename); 181 182 temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan); 183 if (temp_bfd == NULL) 184 perror_with_name (filename); 185 186 if (!bfd_check_format (temp_bfd, bfd_core)) 187 { 188 /* Do it after the err msg */ 189 /* FIXME: should be checking for errors from bfd_close (for one thing, 190 on error it does not free all the storage associated with the 191 bfd). */ 192 make_cleanup (bfd_close, temp_bfd); 193 error ("\"%s\" is not a core dump: %s", 194 filename, bfd_errmsg (bfd_get_error ())); 195 } 196 197 /* Looks semi-reasonable. Toss the old core file and work on the new. */ 198 199 discard_cleanups (old_chain); /* Don't free filename any more */ 200 unpush_target (&core_ops); 201 core_bfd = temp_bfd; 202 old_chain = make_cleanup (core_close, core_bfd); 203 204 validate_files (); 205 206 /* Find the data section */ 207 if (build_section_table (core_bfd, &core_ops.to_sections, 208 &core_ops.to_sections_end)) 209 error ("\"%s\": Can't find sections: %s", 210 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); 211 212 ontop = !push_target (&core_ops); 213 discard_cleanups (old_chain); 214 215 p = bfd_core_file_failing_command (core_bfd); 216 if (p) 217 printf_filtered ("Core was generated by `%s'.\n", p); 218 219 siggy = bfd_core_file_failing_signal (core_bfd); 220 if (siggy > 0) 221 printf_filtered ("Program terminated with signal %d, %s.\n", siggy, 222 safe_strsignal (siggy)); 223 224 /* Build up thread list from BFD sections. */ 225 226 init_thread_list (); 227 bfd_map_over_sections (core_bfd, add_to_thread_list, 228 bfd_get_section_by_name (core_bfd, ".reg")); 229 230 if (ontop) 231 { 232 /* Fetch all registers from core file. */ 233 target_fetch_registers (-1); 234 235 /* Add symbols and section mappings for any shared libraries. */ 236 #ifdef SOLIB_ADD 237 catch_errors (solib_add_stub, &from_tty, (char *)0, 238 RETURN_MASK_ALL); 239 #endif 240 241 /* Now, set up the frame cache, and print the top of stack. */ 242 flush_cached_frames (); 243 select_frame (get_current_frame (), 0); 244 print_stack_frame (selected_frame, selected_frame_level, 1); 245 } 246 else 247 { 248 warning ( 249 "you won't be able to access this core file until you terminate\n\ 250 your %s; do ``info files''", target_longname); 251 } 252 } 253 254 static void 255 core_detach (args, from_tty) 256 char *args; 257 int from_tty; 258 { 259 if (args) 260 error ("Too many arguments"); 261 unpush_target (&core_ops); 262 reinit_frame_cache (); 263 if (from_tty) 264 printf_filtered ("No core file now.\n"); 265 } 266 267 /* Get the registers out of a core file. This is the machine- 268 independent part. Fetch_core_registers is the machine-dependent 269 part, typically implemented in the xm-file for each architecture. */ 270 271 /* We just get all the registers, so we don't use regno. */ 272 273 /* ARGSUSED */ 274 static void 275 get_core_registers (regno) 276 int regno; 277 { 278 sec_ptr reg_sec; 279 unsigned size; 280 char *the_regs; 281 char secname[10]; 282 enum bfd_flavour our_flavour = bfd_get_flavour (core_bfd); 283 struct core_fns *cf; 284 285 if (core_file_fns == NULL) 286 { 287 fprintf_filtered (gdb_stderr, 288 "Can't fetch registers from this type of core file\n"); 289 return; 290 } 291 292 /* Thread support. If inferior_pid is non-zero, then we have found a core 293 file with threads (or multiple processes). In that case, we need to 294 use the appropriate register section, else we just use `.reg'. */ 295 296 /* XXX - same thing needs to be done for floating-point (.reg2) sections. */ 297 298 if (inferior_pid) 299 sprintf (secname, ".reg/%d", inferior_pid); 300 else 301 strcpy (secname, ".reg"); 302 303 reg_sec = bfd_get_section_by_name (core_bfd, secname); 304 if (!reg_sec) 305 goto cant; 306 size = bfd_section_size (core_bfd, reg_sec); 307 the_regs = alloca (size); 308 /* Look for the core functions that match this flavor. Default to the 309 first one if nothing matches. */ 310 for (cf = core_file_fns; cf != NULL; cf = cf -> next) 311 { 312 if (our_flavour == cf -> core_flavour) 313 { 314 break; 315 } 316 } 317 if (cf == NULL) 318 { 319 cf = core_file_fns; 320 } 321 if (cf != NULL && 322 bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size) && 323 cf -> core_read_registers != NULL) 324 { 325 (cf -> core_read_registers (the_regs, size, 0, 326 (unsigned) bfd_section_vma (abfd,reg_sec))); 327 } 328 else 329 { 330 cant: 331 fprintf_filtered (gdb_stderr, 332 "Couldn't fetch registers from core file: %s\n", 333 bfd_errmsg (bfd_get_error ())); 334 } 335 336 /* Now do it again for the float registers, if they exist. */ 337 reg_sec = bfd_get_section_by_name (core_bfd, ".reg2"); 338 if (reg_sec) 339 { 340 size = bfd_section_size (core_bfd, reg_sec); 341 the_regs = alloca (size); 342 if (cf != NULL && 343 bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size) && 344 cf -> core_read_registers != NULL) 345 { 346 (cf -> core_read_registers (the_regs, size, 2, 347 (unsigned) bfd_section_vma (abfd,reg_sec))); 348 } 349 else 350 { 351 fprintf_filtered (gdb_stderr, 352 "Couldn't fetch register set 2 from core file: %s\n", 353 bfd_errmsg (bfd_get_error ())); 354 } 355 } 356 registers_fetched (); 357 } 358 359 static void 360 core_files_info (t) 361 struct target_ops *t; 362 { 363 print_section_info (t, core_bfd); 364 } 365 366 /* If mourn is being called in all the right places, this could be say 367 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */ 368 369 static int 370 ignore (addr, contents) 371 CORE_ADDR addr; 372 char *contents; 373 { 374 return 0; 375 } 376 377 struct target_ops core_ops = { 378 "core", /* to_shortname */ 379 "Local core dump file", /* to_longname */ 380 "Use a core file as a target. Specify the filename of the core file.", /* to_doc */ 381 core_open, /* to_open */ 382 core_close, /* to_close */ 383 find_default_attach, /* to_attach */ 384 core_detach, /* to_detach */ 385 0, /* to_resume */ 386 0, /* to_wait */ 387 get_core_registers, /* to_fetch_registers */ 388 0, /* to_store_registers */ 389 0, /* to_prepare_to_store */ 390 xfer_memory, /* to_xfer_memory */ 391 core_files_info, /* to_files_info */ 392 ignore, /* to_insert_breakpoint */ 393 ignore, /* to_remove_breakpoint */ 394 0, /* to_terminal_init */ 395 0, /* to_terminal_inferior */ 396 0, /* to_terminal_ours_for_output */ 397 0, /* to_terminal_ours */ 398 0, /* to_terminal_info */ 399 0, /* to_kill */ 400 0, /* to_load */ 401 0, /* to_lookup_symbol */ 402 find_default_create_inferior, /* to_create_inferior */ 403 0, /* to_mourn_inferior */ 404 0, /* to_can_run */ 405 0, /* to_notice_signals */ 406 0, /* to_thread_alive */ 407 0, /* to_stop */ 408 core_stratum, /* to_stratum */ 409 0, /* to_next */ 410 0, /* to_has_all_memory */ 411 1, /* to_has_memory */ 412 1, /* to_has_stack */ 413 1, /* to_has_registers */ 414 0, /* to_has_execution */ 415 0, /* to_sections */ 416 0, /* to_sections_end */ 417 OPS_MAGIC, /* to_magic */ 418 }; 419 420 void 421 _initialize_corelow() 422 { 423 add_target (&core_ops); 424 } 425