Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / corefile.c
CommitLineData
5796c8dc
SS
1/* Core dump and executable file functions above target vector, for GDB.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
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 3 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, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "gdb_string.h"
22#include <errno.h>
23#include <signal.h>
24#include <fcntl.h>
25#include "inferior.h"
26#include "symtab.h"
27#include "command.h"
28#include "gdbcmd.h"
29#include "bfd.h"
30#include "target.h"
31#include "gdbcore.h"
32#include "dis-asm.h"
33#include "gdb_stat.h"
34#include "completer.h"
35#include "exceptions.h"
ef5ccd6c
JM
36#include "observer.h"
37#include "cli/cli-utils.h"
5796c8dc
SS
38
39/* Local function declarations. */
40
41extern void _initialize_core (void);
42static void call_extra_exec_file_hooks (char *filename);
43
44/* You can have any number of hooks for `exec_file_command' command to
45 call. If there's only one hook, it is set in exec_file_display
46 hook. If there are two or more hooks, they are set in
47 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
48 set to a function that calls all of them. This extra complexity is
49 needed to preserve compatibility with old code that assumed that
50 only one hook could be set, and which called
51 deprecated_exec_file_display_hook directly. */
52
53typedef void (*hook_type) (char *);
54
c50c785c
JM
55hook_type deprecated_exec_file_display_hook; /* The original hook. */
56static hook_type *exec_file_extra_hooks; /* Array of additional
57 hooks. */
58static int exec_file_hook_count = 0; /* Size of array. */
5796c8dc
SS
59
60/* Binary file diddling handle for the core file. */
61
62bfd *core_bfd = NULL;
c50c785c 63
ef5ccd6c 64/* corelow.c target. It is never NULL after GDB initialization. */
c50c785c
JM
65
66struct target_ops *core_target;
5796c8dc
SS
67\f
68
69/* Backward compatability with old way of specifying core files. */
70
71void
72core_file_command (char *filename, int from_tty)
73{
c50c785c 74 dont_repeat (); /* Either way, seems bogus. */
5796c8dc 75
ef5ccd6c 76 gdb_assert (core_target != NULL);
5796c8dc
SS
77
78 if (!filename)
c50c785c 79 (core_target->to_detach) (core_target, filename, from_tty);
5796c8dc 80 else
c50c785c 81 (core_target->to_open) (filename, from_tty);
5796c8dc
SS
82}
83\f
84
85/* If there are two or more functions that wish to hook into
86 exec_file_command, this function will call all of the hook
87 functions. */
88
89static void
90call_extra_exec_file_hooks (char *filename)
91{
92 int i;
93
94 for (i = 0; i < exec_file_hook_count; i++)
95 (*exec_file_extra_hooks[i]) (filename);
96}
97
98/* Call this to specify the hook for exec_file_command to call back.
99 This is called from the x-window display code. */
100
101void
102specify_exec_file_hook (void (*hook) (char *))
103{
104 hook_type *new_array;
105
106 if (deprecated_exec_file_display_hook != NULL)
107 {
108 /* There's already a hook installed. Arrange to have both it
c50c785c 109 and the subsequent hooks called. */
5796c8dc
SS
110 if (exec_file_hook_count == 0)
111 {
c50c785c
JM
112 /* If this is the first extra hook, initialize the hook
113 array. */
114 exec_file_extra_hooks = (hook_type *)
115 xmalloc (sizeof (hook_type));
5796c8dc
SS
116 exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
117 deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
118 exec_file_hook_count = 1;
119 }
120
121 /* Grow the hook array by one and add the new hook to the end.
122 Yes, it's inefficient to grow it by one each time but since
123 this is hardly ever called it's not a big deal. */
124 exec_file_hook_count++;
c50c785c
JM
125 new_array = (hook_type *)
126 xrealloc (exec_file_extra_hooks,
127 exec_file_hook_count * sizeof (hook_type));
5796c8dc
SS
128 exec_file_extra_hooks = new_array;
129 exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
130 }
131 else
132 deprecated_exec_file_display_hook = hook;
133}
134
5796c8dc
SS
135void
136reopen_exec_file (void)
137{
5796c8dc
SS
138 char *filename;
139 int res;
140 struct stat st;
5796c8dc
SS
141 struct cleanup *cleanups;
142
c50c785c 143 /* Don't do anything if there isn't an exec file. */
5796c8dc
SS
144 if (exec_bfd == NULL)
145 return;
146
c50c785c 147 /* If the timestamp of the exec file has changed, reopen it. */
5796c8dc
SS
148 filename = xstrdup (bfd_get_filename (exec_bfd));
149 cleanups = make_cleanup (xfree, filename);
150 res = stat (filename, &st);
151
152 if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
153 exec_file_attach (filename, 0);
154 else
155 /* If we accessed the file since last opening it, close it now;
156 this stops GDB from holding the executable open after it
157 exits. */
158 bfd_cache_close_all ();
159
160 do_cleanups (cleanups);
5796c8dc
SS
161}
162\f
163/* If we have both a core file and an exec file,
164 print a warning if they don't go together. */
165
166void
167validate_files (void)
168{
169 if (exec_bfd && core_bfd)
170 {
171 if (!core_file_matches_executable_p (core_bfd, exec_bfd))
172 warning (_("core file may not match specified executable file."));
173 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
174 warning (_("exec file is newer than core file."));
175 }
176}
177
178/* Return the name of the executable file as a string.
179 ERR nonzero means get error if there is none specified;
180 otherwise return 0 in that case. */
181
182char *
183get_exec_file (int err)
184{
ef5ccd6c
JM
185 if (exec_filename)
186 return exec_filename;
5796c8dc
SS
187 if (!err)
188 return NULL;
189
190 error (_("No executable file specified.\n\
191Use the \"file\" or \"exec-file\" command."));
192 return NULL;
193}
194\f
195
196/* Report a memory error by throwing a MEMORY_ERROR error. */
197
198void
199memory_error (int status, CORE_ADDR memaddr)
200{
201 if (status == EIO)
202 /* Actually, address between memaddr and memaddr + len was out of
203 bounds. */
204 throw_error (MEMORY_ERROR,
205 _("Cannot access memory at address %s"),
ef5ccd6c 206 paddress (target_gdbarch (), memaddr));
5796c8dc
SS
207 else
208 throw_error (MEMORY_ERROR,
209 _("Error accessing memory address %s: %s."),
ef5ccd6c 210 paddress (target_gdbarch (), memaddr),
5796c8dc
SS
211 safe_strerror (status));
212}
213
214/* Same as target_read_memory, but report an error if can't read. */
215
216void
ef5ccd6c 217read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
5796c8dc
SS
218{
219 int status;
cf7f2e2d 220
5796c8dc
SS
221 status = target_read_memory (memaddr, myaddr, len);
222 if (status != 0)
223 memory_error (status, memaddr);
224}
225
226/* Same as target_read_stack, but report an error if can't read. */
227
228void
ef5ccd6c 229read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
5796c8dc
SS
230{
231 int status;
cf7f2e2d 232
5796c8dc
SS
233 status = target_read_stack (memaddr, myaddr, len);
234 if (status != 0)
235 memory_error (status, memaddr);
236}
237
238/* Argument / return result struct for use with
239 do_captured_read_memory_integer(). MEMADDR and LEN are filled in
240 by gdb_read_memory_integer(). RESULT is the contents that were
241 successfully read from MEMADDR of length LEN. */
242
243struct captured_read_memory_integer_arguments
244{
245 CORE_ADDR memaddr;
246 int len;
247 enum bfd_endian byte_order;
248 LONGEST result;
249};
250
251/* Helper function for gdb_read_memory_integer(). DATA must be a
c50c785c 252 pointer to a captured_read_memory_integer_arguments struct.
5796c8dc
SS
253 Return 1 if successful. Note that the catch_errors() interface
254 will return 0 if an error occurred while reading memory. This
255 choice of return code is so that we can distinguish between
256 success and failure. */
257
258static int
259do_captured_read_memory_integer (void *data)
260{
c50c785c
JM
261 struct captured_read_memory_integer_arguments *args
262 = (struct captured_read_memory_integer_arguments*) data;
5796c8dc
SS
263 CORE_ADDR memaddr = args->memaddr;
264 int len = args->len;
265 enum bfd_endian byte_order = args->byte_order;
266
267 args->result = read_memory_integer (memaddr, len, byte_order);
268
269 return 1;
270}
271
272/* Read memory at MEMADDR of length LEN and put the contents in
273 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
274 if successful. */
275
276int
cf7f2e2d
JM
277safe_read_memory_integer (CORE_ADDR memaddr, int len,
278 enum bfd_endian byte_order,
5796c8dc
SS
279 LONGEST *return_value)
280{
281 int status;
282 struct captured_read_memory_integer_arguments args;
cf7f2e2d 283
5796c8dc
SS
284 args.memaddr = memaddr;
285 args.len = len;
286 args.byte_order = byte_order;
287
288 status = catch_errors (do_captured_read_memory_integer, &args,
c50c785c 289 "", RETURN_MASK_ALL);
5796c8dc
SS
290 if (status)
291 *return_value = args.result;
292
293 return status;
294}
295
296LONGEST
c50c785c
JM
297read_memory_integer (CORE_ADDR memaddr, int len,
298 enum bfd_endian byte_order)
5796c8dc
SS
299{
300 gdb_byte buf[sizeof (LONGEST)];
301
302 read_memory (memaddr, buf, len);
303 return extract_signed_integer (buf, len, byte_order);
304}
305
306ULONGEST
c50c785c
JM
307read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
308 enum bfd_endian byte_order)
5796c8dc
SS
309{
310 gdb_byte buf[sizeof (ULONGEST)];
311
312 read_memory (memaddr, buf, len);
313 return extract_unsigned_integer (buf, len, byte_order);
314}
315
316void
317read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
318{
319 char *cp;
320 int i;
321 int cnt;
322
323 cp = buffer;
324 while (1)
325 {
326 if (cp - buffer >= max_len)
327 {
328 buffer[max_len - 1] = '\0';
329 break;
330 }
331 cnt = max_len - (cp - buffer);
332 if (cnt > 8)
333 cnt = 8;
ef5ccd6c 334 read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
5796c8dc
SS
335 for (i = 0; i < cnt && *cp; i++, cp++)
336 ; /* null body */
337
338 if (i < cnt && !*cp)
339 break;
340 }
341}
342
343CORE_ADDR
344read_memory_typed_address (CORE_ADDR addr, struct type *type)
345{
346 gdb_byte *buf = alloca (TYPE_LENGTH (type));
cf7f2e2d 347
5796c8dc
SS
348 read_memory (addr, buf, TYPE_LENGTH (type));
349 return extract_typed_address (buf, type);
350}
351
c50c785c
JM
352/* Same as target_write_memory, but report an error if can't
353 write. */
5796c8dc 354void
c50c785c 355write_memory (CORE_ADDR memaddr,
ef5ccd6c 356 const bfd_byte *myaddr, ssize_t len)
5796c8dc
SS
357{
358 int status;
cf7f2e2d 359
5796c8dc
SS
360 status = target_write_memory (memaddr, myaddr, len);
361 if (status != 0)
362 memory_error (status, memaddr);
363}
364
ef5ccd6c
JM
365/* Same as write_memory, but notify 'memory_changed' observers. */
366
367void
368write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
369 ssize_t len)
370{
371 write_memory (memaddr, myaddr, len);
372 observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
373}
374
c50c785c
JM
375/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
376 integer. */
5796c8dc 377void
cf7f2e2d
JM
378write_memory_unsigned_integer (CORE_ADDR addr, int len,
379 enum bfd_endian byte_order,
5796c8dc
SS
380 ULONGEST value)
381{
382 gdb_byte *buf = alloca (len);
cf7f2e2d 383
5796c8dc
SS
384 store_unsigned_integer (buf, len, byte_order, value);
385 write_memory (addr, buf, len);
386}
387
c50c785c
JM
388/* Store VALUE at ADDR in the inferior as a LEN-byte signed
389 integer. */
5796c8dc 390void
cf7f2e2d
JM
391write_memory_signed_integer (CORE_ADDR addr, int len,
392 enum bfd_endian byte_order,
5796c8dc
SS
393 LONGEST value)
394{
395 gdb_byte *buf = alloca (len);
cf7f2e2d 396
5796c8dc
SS
397 store_signed_integer (buf, len, byte_order, value);
398 write_memory (addr, buf, len);
399}
400\f
401/* The current default bfd target. Points to storage allocated for
402 gnutarget_string. */
403char *gnutarget;
404
405/* Same thing, except it is "auto" not NULL for the default case. */
406static char *gnutarget_string;
407static void
408show_gnutarget_string (struct ui_file *file, int from_tty,
c50c785c
JM
409 struct cmd_list_element *c,
410 const char *value)
5796c8dc 411{
c50c785c
JM
412 fprintf_filtered (file,
413 _("The current BFD target is \"%s\".\n"), value);
5796c8dc
SS
414}
415
c50c785c
JM
416static void set_gnutarget_command (char *, int,
417 struct cmd_list_element *);
5796c8dc
SS
418
419static void
c50c785c
JM
420set_gnutarget_command (char *ignore, int from_tty,
421 struct cmd_list_element *c)
5796c8dc 422{
ef5ccd6c
JM
423 char *gend = gnutarget_string + strlen (gnutarget_string);
424
425 gend = remove_trailing_whitespace (gnutarget_string, gend);
426 *gend = '\0';
427
5796c8dc
SS
428 if (strcmp (gnutarget_string, "auto") == 0)
429 gnutarget = NULL;
430 else
431 gnutarget = gnutarget_string;
432}
433
ef5ccd6c
JM
434/* A completion function for "set gnutarget". */
435
436static VEC (char_ptr) *
437complete_set_gnutarget (struct cmd_list_element *cmd, char *text, char *word)
438{
439 static const char **bfd_targets;
440
441 if (bfd_targets == NULL)
442 {
443 int last;
444
445 bfd_targets = bfd_target_list ();
446 for (last = 0; bfd_targets[last] != NULL; ++last)
447 ;
448
449 bfd_targets = xrealloc (bfd_targets, (last + 2) * sizeof (const char **));
450 bfd_targets[last] = "auto";
451 bfd_targets[last + 1] = NULL;
452 }
453
454 return complete_on_enum (bfd_targets, text, word);
455}
456
5796c8dc
SS
457/* Set the gnutarget. */
458void
459set_gnutarget (char *newtarget)
460{
461 if (gnutarget_string != NULL)
462 xfree (gnutarget_string);
463 gnutarget_string = xstrdup (newtarget);
464 set_gnutarget_command (NULL, 0, NULL);
465}
466
467void
468_initialize_core (void)
469{
470 struct cmd_list_element *c;
cf7f2e2d 471
5796c8dc
SS
472 c = add_cmd ("core-file", class_files, core_file_command, _("\
473Use FILE as core dump for examining memory and registers.\n\
474No arg means have no core file. This command has been superseded by the\n\
475`target core' and `detach' commands."), &cmdlist);
476 set_cmd_completer (c, filename_completer);
477
478
ef5ccd6c
JM
479 c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
480 &gnutarget_string, _("\
5796c8dc
SS
481Set the current BFD target."), _("\
482Show the current BFD target."), _("\
483Use `set gnutarget auto' to specify automatic detection."),
ef5ccd6c
JM
484 set_gnutarget_command,
485 show_gnutarget_string,
486 &setlist, &showlist);
487 set_cmd_completer (c, complete_set_gnutarget);
488
489 add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
5796c8dc
SS
490
491 if (getenv ("GNUTARGET"))
492 set_gnutarget (getenv ("GNUTARGET"));
493 else
494 set_gnutarget ("auto");
495}