1 /* Core dump and executable file functions above target vector, for GDB.
3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997,
4 1998, 1999, 2000, 2001, 2003, 2006
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
38 #include "completer.h"
39 #include "exceptions.h"
41 /* Local function declarations. */
43 extern void _initialize_core (void);
44 static void call_extra_exec_file_hooks (char *filename
);
46 /* You can have any number of hooks for `exec_file_command' command to
47 call. If there's only one hook, it is set in exec_file_display
48 hook. If there are two or more hooks, they are set in
49 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
50 set to a function that calls all of them. This extra complexity is
51 needed to preserve compatibility with old code that assumed that
52 only one hook could be set, and which called
53 deprecated_exec_file_display_hook directly. */
55 typedef void (*hook_type
) (char *);
57 hook_type deprecated_exec_file_display_hook
; /* the original hook */
58 static hook_type
*exec_file_extra_hooks
; /* array of additional hooks */
59 static int exec_file_hook_count
= 0; /* size of array */
61 /* Binary file diddling handle for the core file. */
66 /* Backward compatability with old way of specifying core files. */
69 core_file_command (char *filename
, int from_tty
)
73 dont_repeat (); /* Either way, seems bogus. */
75 t
= find_core_target ();
77 error (_("GDB can't read core files on this machine."));
80 (t
->to_detach
) (filename
, from_tty
);
82 (t
->to_open
) (filename
, from_tty
);
86 /* If there are two or more functions that wish to hook into
87 exec_file_command, this function will call all of the hook
91 call_extra_exec_file_hooks (char *filename
)
95 for (i
= 0; i
< exec_file_hook_count
; i
++)
96 (*exec_file_extra_hooks
[i
]) (filename
);
99 /* Call this to specify the hook for exec_file_command to call back.
100 This is called from the x-window display code. */
103 specify_exec_file_hook (void (*hook
) (char *))
105 hook_type
*new_array
;
107 if (deprecated_exec_file_display_hook
!= NULL
)
109 /* There's already a hook installed. Arrange to have both it
110 * and the subsequent hooks called. */
111 if (exec_file_hook_count
== 0)
113 /* If this is the first extra hook, initialize the hook array. */
114 exec_file_extra_hooks
= (hook_type
*) xmalloc (sizeof (hook_type
));
115 exec_file_extra_hooks
[0] = deprecated_exec_file_display_hook
;
116 deprecated_exec_file_display_hook
= call_extra_exec_file_hooks
;
117 exec_file_hook_count
= 1;
120 /* Grow the hook array by one and add the new hook to the end.
121 Yes, it's inefficient to grow it by one each time but since
122 this is hardly ever called it's not a big deal. */
123 exec_file_hook_count
++;
125 (hook_type
*) xrealloc (exec_file_extra_hooks
,
126 exec_file_hook_count
* sizeof (hook_type
));
127 exec_file_extra_hooks
= new_array
;
128 exec_file_extra_hooks
[exec_file_hook_count
- 1] = hook
;
131 deprecated_exec_file_display_hook
= hook
;
134 /* The exec file must be closed before running an inferior.
135 If it is needed again after the inferior dies, it must
139 close_exec_file (void)
143 bfd_tempclose (exec_bfd
);
148 reopen_exec_file (void)
152 bfd_reopen (exec_bfd
);
159 /* Don't do anything if there isn't an exec file. */
160 if (exec_bfd
== NULL
)
163 /* If the timestamp of the exec file has changed, reopen it. */
164 filename
= xstrdup (bfd_get_filename (exec_bfd
));
165 make_cleanup (xfree
, filename
);
166 mtime
= bfd_get_mtime (exec_bfd
);
167 res
= stat (filename
, &st
);
169 if (mtime
&& mtime
!= st
.st_mtime
)
170 exec_file_attach (filename
, 0);
174 /* If we have both a core file and an exec file,
175 print a warning if they don't go together. */
178 validate_files (void)
180 if (exec_bfd
&& core_bfd
)
182 if (!core_file_matches_executable_p (core_bfd
, exec_bfd
))
183 warning (_("core file may not match specified executable file."));
184 else if (bfd_get_mtime (exec_bfd
) > bfd_get_mtime (core_bfd
))
185 warning (_("exec file is newer than core file."));
189 /* Return the name of the executable file as a string.
190 ERR nonzero means get error if there is none specified;
191 otherwise return 0 in that case. */
194 get_exec_file (int err
)
197 return bfd_get_filename (exec_bfd
);
201 error (_("No executable file specified.\n\
202 Use the \"file\" or \"exec-file\" command."));
207 /* Report a memory error with error(). */
210 memory_error (int status
, CORE_ADDR memaddr
)
212 struct ui_file
*tmp_stream
= mem_fileopen ();
213 make_cleanup_ui_file_delete (tmp_stream
);
217 /* Actually, address between memaddr and memaddr + len
218 was out of bounds. */
219 fprintf_unfiltered (tmp_stream
, "Cannot access memory at address ");
220 deprecated_print_address_numeric (memaddr
, 1, tmp_stream
);
224 fprintf_filtered (tmp_stream
, "Error accessing memory address ");
225 deprecated_print_address_numeric (memaddr
, 1, tmp_stream
);
226 fprintf_filtered (tmp_stream
, ": %s.",
227 safe_strerror (status
));
230 error_stream (tmp_stream
);
233 /* Same as target_read_memory, but report an error if can't read. */
235 read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
238 status
= target_read_memory (memaddr
, myaddr
, len
);
240 memory_error (status
, memaddr
);
243 /* Argument / return result struct for use with
244 do_captured_read_memory_integer(). MEMADDR and LEN are filled in
245 by gdb_read_memory_integer(). RESULT is the contents that were
246 successfully read from MEMADDR of length LEN. */
248 struct captured_read_memory_integer_arguments
255 /* Helper function for gdb_read_memory_integer(). DATA must be a
256 pointer to a captured_read_memory_integer_arguments struct.
257 Return 1 if successful. Note that the catch_errors() interface
258 will return 0 if an error occurred while reading memory. This
259 choice of return code is so that we can distinguish between
260 success and failure. */
263 do_captured_read_memory_integer (void *data
)
265 struct captured_read_memory_integer_arguments
*args
= (struct captured_read_memory_integer_arguments
*) data
;
266 CORE_ADDR memaddr
= args
->memaddr
;
269 args
->result
= read_memory_integer (memaddr
, len
);
274 /* Read memory at MEMADDR of length LEN and put the contents in
275 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
279 safe_read_memory_integer (CORE_ADDR memaddr
, int len
, LONGEST
*return_value
)
282 struct captured_read_memory_integer_arguments args
;
283 args
.memaddr
= memaddr
;
286 status
= catch_errors (do_captured_read_memory_integer
, &args
,
287 "", RETURN_MASK_ALL
);
289 *return_value
= args
.result
;
295 read_memory_integer (CORE_ADDR memaddr
, int len
)
297 gdb_byte buf
[sizeof (LONGEST
)];
299 read_memory (memaddr
, buf
, len
);
300 return extract_signed_integer (buf
, len
);
304 read_memory_unsigned_integer (CORE_ADDR memaddr
, int len
)
306 gdb_byte buf
[sizeof (ULONGEST
)];
308 read_memory (memaddr
, buf
, len
);
309 return extract_unsigned_integer (buf
, len
);
313 read_memory_string (CORE_ADDR memaddr
, char *buffer
, int max_len
)
322 if (cp
- buffer
>= max_len
)
324 buffer
[max_len
- 1] = '\0';
327 cnt
= max_len
- (cp
- buffer
);
330 read_memory (memaddr
+ (int) (cp
- buffer
), cp
, cnt
);
331 for (i
= 0; i
< cnt
&& *cp
; i
++, cp
++)
340 read_memory_typed_address (CORE_ADDR addr
, struct type
*type
)
342 gdb_byte
*buf
= alloca (TYPE_LENGTH (type
));
343 read_memory (addr
, buf
, TYPE_LENGTH (type
));
344 return extract_typed_address (buf
, type
);
347 /* Same as target_write_memory, but report an error if can't write. */
349 write_memory (CORE_ADDR memaddr
, const bfd_byte
*myaddr
, int len
)
352 gdb_byte
*bytes
= alloca (len
);
354 memcpy (bytes
, myaddr
, len
);
355 status
= target_write_memory (memaddr
, bytes
, len
);
357 memory_error (status
, memaddr
);
360 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
362 write_memory_unsigned_integer (CORE_ADDR addr
, int len
, ULONGEST value
)
364 gdb_byte
*buf
= alloca (len
);
365 store_unsigned_integer (buf
, len
, value
);
366 write_memory (addr
, buf
, len
);
369 /* Store VALUE at ADDR in the inferior as a LEN-byte signed integer. */
371 write_memory_signed_integer (CORE_ADDR addr
, int len
, LONGEST value
)
373 gdb_byte
*buf
= alloca (len
);
374 store_signed_integer (buf
, len
, value
);
375 write_memory (addr
, buf
, len
);
381 /* Enable after 4.12. It is not tested. */
383 /* Search code. Targets can just make this their search function, or
384 if the protocol has a less general search function, they can call this
385 in the cases it can't handle. */
387 generic_search (int len
, char *data
, char *mask
, CORE_ADDR startaddr
,
388 int increment
, CORE_ADDR lorange
, CORE_ADDR hirange
,
389 CORE_ADDR
*addr_found
, char *data_found
)
392 CORE_ADDR curaddr
= startaddr
;
394 while (curaddr
>= lorange
&& curaddr
< hirange
)
396 read_memory (curaddr
, data_found
, len
);
397 for (i
= 0; i
< len
; ++i
)
398 if ((data_found
[i
] & mask
[i
]) != data
[i
])
401 *addr_found
= curaddr
;
405 curaddr
+= increment
;
407 *addr_found
= (CORE_ADDR
) 0;
412 /* The current default bfd target. Points to storage allocated for
416 /* Same thing, except it is "auto" not NULL for the default case. */
417 static char *gnutarget_string
;
419 show_gnutarget_string (struct ui_file
*file
, int from_tty
,
420 struct cmd_list_element
*c
, const char *value
)
422 fprintf_filtered (file
, _("The current BFD target is \"%s\".\n"), value
);
425 static void set_gnutarget_command (char *, int, struct cmd_list_element
*);
428 set_gnutarget_command (char *ignore
, int from_tty
, struct cmd_list_element
*c
)
430 if (strcmp (gnutarget_string
, "auto") == 0)
433 gnutarget
= gnutarget_string
;
436 /* Set the gnutarget. */
438 set_gnutarget (char *newtarget
)
440 if (gnutarget_string
!= NULL
)
441 xfree (gnutarget_string
);
442 gnutarget_string
= savestring (newtarget
, strlen (newtarget
));
443 set_gnutarget_command (NULL
, 0, NULL
);
447 _initialize_core (void)
449 struct cmd_list_element
*c
;
450 c
= add_cmd ("core-file", class_files
, core_file_command
, _("\
451 Use FILE as core dump for examining memory and registers.\n\
452 No arg means have no core file. This command has been superseded by the\n\
453 `target core' and `detach' commands."), &cmdlist
);
454 set_cmd_completer (c
, filename_completer
);
457 add_setshow_string_noescape_cmd ("gnutarget", class_files
,
458 &gnutarget_string
, _("(\
459 Set the current BFD target."), _("\
460 Show the current BFD target."), _("\
461 Use `set gnutarget auto' to specify automatic detection."),
462 set_gnutarget_command
,
463 show_gnutarget_string
,
464 &setlist
, &showlist
);
466 if (getenv ("GNUTARGET"))
467 set_gnutarget (getenv ("GNUTARGET"));
469 set_gnutarget ("auto");