1 /* Core dump and executable file functions above target vector, for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
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 */
41 /* Local function declarations. */
43 extern void _initialize_core PARAMS ((void));
44 static void call_extra_exec_file_hooks PARAMS ((char *filename));
46 /* You can have any number of hooks for `exec_file_command' command to call.
47 If there's only one hook, it is set in exec_file_display hook.
48 If there are two or more hooks, they are set in exec_file_extra_hooks[],
49 and exec_file_display_hook is set to a function that calls all of them.
50 This extra complexity is needed to preserve compatibility with
51 old code that assumed that only one hook could be set, and which called
52 exec_file_display_hook directly. */
54 typedef void (*hook_type) PARAMS ((char *));
56 hook_type exec_file_display_hook; /* the original hook */
57 static hook_type *exec_file_extra_hooks; /* array of additional hooks */
58 static int exec_file_hook_count = 0; /* size of array */
60 /* Binary file diddling handle for the core file. */
65 /* Backward compatability with old way of specifying core files. */
68 core_file_command (filename, from_tty)
74 dont_repeat (); /* Either way, seems bogus. */
76 t = find_core_target ();
79 (t->to_detach) (filename, from_tty);
82 /* Yes, we were given the path of a core file. Do we already
83 have a symbol file? If not, can we determine it from the
84 core file? If we can, do so.
87 if (symfile_objfile == NULL)
90 symfile = t->to_core_file_to_sym_file (filename);
93 char *symfile_copy = strdup (symfile);
95 make_cleanup (free, symfile_copy);
96 symbol_file_command (symfile_copy, from_tty);
99 warning ("Unknown symbols for '%s'; use the 'symbol-file' command.", filename);
102 (t->to_open) (filename, from_tty);
105 error ("GDB can't read core files on this machine.");
109 /* If there are two or more functions that wish to hook into exec_file_command,
110 * this function will call all of the hook functions. */
113 call_extra_exec_file_hooks (filename)
118 for (i = 0; i < exec_file_hook_count; i++)
119 (*exec_file_extra_hooks[i]) (filename);
122 /* Call this to specify the hook for exec_file_command to call back.
123 This is called from the x-window display code. */
126 specify_exec_file_hook (hook)
127 void (*hook) PARAMS ((char *));
129 hook_type *new_array;
131 if (exec_file_display_hook != NULL)
133 /* There's already a hook installed. Arrange to have both it
134 * and the subsequent hooks called. */
135 if (exec_file_hook_count == 0)
137 /* If this is the first extra hook, initialize the hook array. */
138 exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
139 exec_file_extra_hooks[0] = exec_file_display_hook;
140 exec_file_display_hook = call_extra_exec_file_hooks;
141 exec_file_hook_count = 1;
144 /* Grow the hook array by one and add the new hook to the end.
145 Yes, it's inefficient to grow it by one each time but since
146 this is hardly ever called it's not a big deal. */
147 exec_file_hook_count++;
149 (hook_type *) xrealloc (exec_file_extra_hooks,
150 exec_file_hook_count * sizeof (hook_type));
151 exec_file_extra_hooks = new_array;
152 exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
155 exec_file_display_hook = hook;
158 /* The exec file must be closed before running an inferior.
159 If it is needed again after the inferior dies, it must
167 bfd_tempclose (exec_bfd);
176 bfd_reopen (exec_bfd);
183 /* Don't do anything if the current target isn't exec. */
184 if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
187 /* If the timestamp of the exec file has changed, reopen it. */
188 filename = strdup (bfd_get_filename (exec_bfd));
189 make_cleanup (free, filename);
190 mtime = bfd_get_mtime (exec_bfd);
191 res = stat (filename, &st);
193 if (mtime && mtime != st.st_mtime)
194 exec_file_command (filename, 0);
198 /* If we have both a core file and an exec file,
199 print a warning if they don't go together. */
204 if (exec_bfd && core_bfd)
206 if (!core_file_matches_executable_p (core_bfd, exec_bfd))
207 warning ("core file may not match specified executable file.");
208 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
209 warning ("exec file is newer than core file.");
213 /* Return the name of the executable file as a string.
214 ERR nonzero means get error if there is none specified;
215 otherwise return 0 in that case. */
222 return bfd_get_filename (exec_bfd);
226 error ("No executable file specified.\n\
227 Use the \"file\" or \"exec-file\" command.");
232 /* Report a memory error with error(). */
235 memory_error (status, memaddr)
241 /* Actually, address between memaddr and memaddr + len
242 was out of bounds. */
244 printf_filtered ("Cannot access memory at address ");
245 print_address_numeric (memaddr, 1, gdb_stdout);
246 printf_filtered (".\n");
247 return_to_top_level (RETURN_ERROR);
252 printf_filtered ("Error accessing memory address ");
253 print_address_numeric (memaddr, 1, gdb_stdout);
254 printf_filtered (": %s.\n",
255 safe_strerror (status));
256 return_to_top_level (RETURN_ERROR);
260 /* Same as target_read_memory, but report an error if can't read. */
262 read_memory (memaddr, myaddr, len)
268 status = target_read_memory (memaddr, myaddr, len);
270 memory_error (status, memaddr);
274 read_memory_section (memaddr, myaddr, len, bfd_section)
278 asection *bfd_section;
281 status = target_read_memory_section (memaddr, myaddr, len, bfd_section);
283 memory_error (status, memaddr);
286 /* Like target_read_memory, but slightly different parameters. */
289 dis_asm_read_memory (memaddr, myaddr, len, info)
293 disassemble_info *info;
295 return target_read_memory (memaddr, (char *) myaddr, len);
298 /* Like memory_error with slightly different parameters. */
300 dis_asm_memory_error (status, memaddr, info)
303 disassemble_info *info;
305 memory_error (status, memaddr);
308 /* Like print_address with slightly different parameters. */
310 dis_asm_print_address (addr, info)
312 struct disassemble_info *info;
314 print_address (addr, info->stream);
317 /* Same as target_write_memory, but report an error if can't write. */
319 write_memory (memaddr, myaddr, len)
326 status = target_write_memory (memaddr, myaddr, len);
328 memory_error (status, memaddr);
331 /* Read an integer from debugged memory, given address and number of bytes. */
334 read_memory_integer (memaddr, len)
338 char buf[sizeof (LONGEST)];
340 read_memory (memaddr, buf, len);
341 return extract_signed_integer (buf, len);
345 read_memory_unsigned_integer (memaddr, len)
349 char buf[sizeof (ULONGEST)];
351 read_memory (memaddr, buf, len);
352 return extract_unsigned_integer (buf, len);
356 read_memory_string (memaddr, buffer, max_len)
368 if (cp - buffer >= max_len)
370 buffer[max_len - 1] = '\0';
373 cnt = max_len - (cp - buffer);
376 read_memory (memaddr + (int) (cp - buffer), cp, cnt);
377 for (i = 0; i < cnt && *cp; i++, cp++)
387 /* Enable after 4.12. It is not tested. */
389 /* Search code. Targets can just make this their search function, or
390 if the protocol has a less general search function, they can call this
391 in the cases it can't handle. */
393 generic_search (len, data, mask, startaddr, increment, lorange, hirange
394 addr_found, data_found)
402 CORE_ADDR *addr_found;
406 CORE_ADDR curaddr = startaddr;
408 while (curaddr >= lorange && curaddr < hirange)
410 read_memory (curaddr, data_found, len);
411 for (i = 0; i < len; ++i)
412 if ((data_found[i] & mask[i]) != data[i])
415 *addr_found = curaddr;
419 curaddr += increment;
421 *addr_found = (CORE_ADDR) 0;
426 /* The current default bfd target. Points to storage allocated for
430 /* Same thing, except it is "auto" not NULL for the default case. */
431 static char *gnutarget_string;
433 static void set_gnutarget_command
434 PARAMS ((char *, int, struct cmd_list_element *));
437 set_gnutarget_command (ignore, from_tty, c)
440 struct cmd_list_element *c;
442 if (STREQ (gnutarget_string, "auto"))
445 gnutarget = gnutarget_string;
448 /* Set the gnutarget. */
450 set_gnutarget (newtarget)
453 if (gnutarget_string != NULL)
454 free (gnutarget_string);
455 gnutarget_string = savestring (newtarget, strlen (newtarget));
456 set_gnutarget_command (NULL, 0, NULL);
462 struct cmd_list_element *c;
463 c = add_cmd ("core-file", class_files, core_file_command,
464 "Use FILE as core dump for examining memory and registers.\n\
465 No arg means have no core file. This command has been superseded by the\n\
466 `target core' and `detach' commands.", &cmdlist);
467 c->completer = filename_completer;
469 c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
470 (char *) &gnutarget_string,
471 "Set the current BFD target.\n\
472 Use `set gnutarget auto' to specify automatic detection.",
474 c->function.sfunc = set_gnutarget_command;
475 add_show_from_set (c, &showlist);
477 if (getenv ("GNUTARGET"))
478 set_gnutarget (getenv ("GNUTARGET"));
480 set_gnutarget ("auto");