Update copyright year in gdb/gdbserver/gdbreplay version output.
[deliverable/binutils-gdb.git] / gdb / corefile.c
CommitLineData
c906108c 1/* Core dump and executable file functions above target vector, for GDB.
1bac305b 2
28e7fd62 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
0e9f083f 21#include <string.h>
c906108c
SS
22#include <errno.h>
23#include <signal.h>
24#include <fcntl.h>
c906108c
SS
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"
53ce3c39 33#include <sys/stat.h>
d75b5104 34#include "completer.h"
60250e8b 35#include "exceptions.h"
972daa01 36#include "observer.h"
44478ab3 37#include "cli/cli-utils.h"
c906108c 38
c906108c
SS
39/* Local function declarations. */
40
a14ed312
KB
41extern void _initialize_core (void);
42static void call_extra_exec_file_hooks (char *filename);
c906108c 43
9a4105ab
AC
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. */
c906108c 52
507f3c78 53typedef void (*hook_type) (char *);
c906108c 54
aff410f1
MS
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. */
c906108c
SS
59
60/* Binary file diddling handle for the core file. */
61
62bfd *core_bfd = NULL;
c0edd9ed 63
06b9f45f 64/* corelow.c target. It is never NULL after GDB initialization. */
c0edd9ed
JK
65
66struct target_ops *core_target;
c906108c 67\f
c5aa993b 68
c906108c
SS
69/* Backward compatability with old way of specifying core files. */
70
71void
fba45db2 72core_file_command (char *filename, int from_tty)
c906108c 73{
aff410f1 74 dont_repeat (); /* Either way, seems bogus. */
c906108c 75
06b9f45f 76 gdb_assert (core_target != NULL);
46c6cdcf
C
77
78 if (!filename)
c0edd9ed 79 (core_target->to_detach) (core_target, filename, from_tty);
46c6cdcf 80 else
c0edd9ed 81 (core_target->to_open) (filename, from_tty);
c906108c 82}
c906108c 83\f
c5aa993b 84
de6854b5
MS
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. */
c906108c
SS
88
89static void
fba45db2 90call_extra_exec_file_hooks (char *filename)
c906108c
SS
91{
92 int i;
93
94 for (i = 0; i < exec_file_hook_count; i++)
c5aa993b 95 (*exec_file_extra_hooks[i]) (filename);
c906108c
SS
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
dbb41be1 102specify_exec_file_hook (void (*hook) (char *))
c906108c
SS
103{
104 hook_type *new_array;
105
9a4105ab 106 if (deprecated_exec_file_display_hook != NULL)
c906108c
SS
107 {
108 /* There's already a hook installed. Arrange to have both it
aff410f1 109 and the subsequent hooks called. */
c906108c
SS
110 if (exec_file_hook_count == 0)
111 {
aff410f1
MS
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));
9a4105ab
AC
116 exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
117 deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
c906108c
SS
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++;
aff410f1
MS
125 new_array = (hook_type *)
126 xrealloc (exec_file_extra_hooks,
127 exec_file_hook_count * sizeof (hook_type));
c906108c
SS
128 exec_file_extra_hooks = new_array;
129 exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
130 }
131 else
9a4105ab 132 deprecated_exec_file_display_hook = hook;
c906108c
SS
133}
134
c906108c 135void
fba45db2 136reopen_exec_file (void)
c906108c 137{
c906108c
SS
138 char *filename;
139 int res;
140 struct stat st;
f7545552 141 struct cleanup *cleanups;
c906108c 142
aff410f1 143 /* Don't do anything if there isn't an exec file. */
4c42eaff 144 if (exec_bfd == NULL)
c906108c 145 return;
c5aa993b 146
aff410f1 147 /* If the timestamp of the exec file has changed, reopen it. */
c2d11a7d 148 filename = xstrdup (bfd_get_filename (exec_bfd));
f7545552 149 cleanups = make_cleanup (xfree, filename);
c906108c
SS
150 res = stat (filename, &st);
151
c04ea773 152 if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
4c42eaff 153 exec_file_attach (filename, 0);
939643d7
DJ
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 ();
f7545552
TT
159
160 do_cleanups (cleanups);
c906108c
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
fba45db2 167validate_files (void)
c906108c
SS
168{
169 if (exec_bfd && core_bfd)
170 {
171 if (!core_file_matches_executable_p (core_bfd, exec_bfd))
8a3fe4f8 172 warning (_("core file may not match specified executable file."));
c5aa993b 173 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
8a3fe4f8 174 warning (_("exec file is newer than core file."));
c906108c
SS
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 *
fba45db2 183get_exec_file (int err)
c906108c 184{
1f0c4988
JK
185 if (exec_filename)
186 return exec_filename;
c5aa993b
JM
187 if (!err)
188 return NULL;
c906108c 189
8a3fe4f8
AC
190 error (_("No executable file specified.\n\
191Use the \"file\" or \"exec-file\" command."));
c906108c
SS
192 return NULL;
193}
c906108c 194\f
c5aa993b 195
578d3588
PA
196char *
197memory_error_message (enum target_xfer_error err,
198 struct gdbarch *gdbarch, CORE_ADDR memaddr)
6be7b56e
PA
199{
200 switch (err)
201 {
202 case TARGET_XFER_E_IO:
203 /* Actually, address between memaddr and memaddr + len was out of
204 bounds. */
578d3588
PA
205 return xstrprintf (_("Cannot access memory at address %s"),
206 paddress (gdbarch, memaddr));
6be7b56e 207 case TARGET_XFER_E_UNAVAILABLE:
578d3588
PA
208 return xstrprintf (_("Memory at address %s unavailable."),
209 paddress (gdbarch, memaddr));
6be7b56e
PA
210 default:
211 internal_error (__FILE__, __LINE__,
212 "unhandled target_xfer_error: %s (%s)",
213 target_xfer_error_to_string (err),
214 plongest (err));
215 }
216}
217
578d3588 218/* Report a memory error by throwing a suitable exception. */
c906108c
SS
219
220void
578d3588 221memory_error (enum target_xfer_error err, CORE_ADDR memaddr)
c906108c 222{
578d3588
PA
223 char *str;
224
225 /* Build error string. */
226 str = memory_error_message (err, target_gdbarch (), memaddr);
227 make_cleanup (xfree, str);
228
229 /* Choose the right error to throw. */
230 switch (err)
231 {
232 case TARGET_XFER_E_IO:
233 err = MEMORY_ERROR;
234 break;
235 case TARGET_XFER_E_UNAVAILABLE:
236 err = NOT_AVAILABLE_ERROR;
237 break;
238 }
239
240 /* Throw it. */
241 throw_error (err, ("%s"), str);
c906108c
SS
242}
243
244/* Same as target_read_memory, but report an error if can't read. */
4e5d721f 245
c906108c 246void
45aa4659 247read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
c906108c 248{
6be7b56e 249 LONGEST xfered = 0;
c5504eaf 250
6be7b56e
PA
251 while (xfered < len)
252 {
253 LONGEST xfer = target_xfer_partial (current_target.beneath,
254 TARGET_OBJECT_MEMORY, NULL,
255 myaddr + xfered, NULL,
256 memaddr + xfered, len - xfered);
257
258 if (xfer == 0)
578d3588 259 memory_error (TARGET_XFER_E_IO, memaddr + xfered);
6be7b56e 260 if (xfer < 0)
578d3588 261 memory_error (xfer, memaddr + xfered);
6be7b56e
PA
262 xfered += xfer;
263 QUIT;
264 }
c906108c
SS
265}
266
4e5d721f
DE
267/* Same as target_read_stack, but report an error if can't read. */
268
269void
45aa4659 270read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
4e5d721f
DE
271{
272 int status;
c5504eaf 273
4e5d721f
DE
274 status = target_read_stack (memaddr, myaddr, len);
275 if (status != 0)
276 memory_error (status, memaddr);
277}
278
0865b04a
YQ
279/* Same as target_read_code, but report an error if can't read. */
280
281void
282read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
283{
284 int status;
285
286 status = target_read_code (memaddr, myaddr, len);
287 if (status != 0)
288 memory_error (status, memaddr);
289}
290
ee8ff470
KB
291/* Argument / return result struct for use with
292 do_captured_read_memory_integer(). MEMADDR and LEN are filled in
293 by gdb_read_memory_integer(). RESULT is the contents that were
294 successfully read from MEMADDR of length LEN. */
c906108c 295
16a0f3e7
EZ
296struct captured_read_memory_integer_arguments
297{
298 CORE_ADDR memaddr;
299 int len;
e17a4113 300 enum bfd_endian byte_order;
16a0f3e7
EZ
301 LONGEST result;
302};
303
ee8ff470 304/* Helper function for gdb_read_memory_integer(). DATA must be a
aff410f1 305 pointer to a captured_read_memory_integer_arguments struct.
ee8ff470
KB
306 Return 1 if successful. Note that the catch_errors() interface
307 will return 0 if an error occurred while reading memory. This
308 choice of return code is so that we can distinguish between
309 success and failure. */
310
16a0f3e7
EZ
311static int
312do_captured_read_memory_integer (void *data)
313{
aff410f1
MS
314 struct captured_read_memory_integer_arguments *args
315 = (struct captured_read_memory_integer_arguments*) data;
16a0f3e7
EZ
316 CORE_ADDR memaddr = args->memaddr;
317 int len = args->len;
e17a4113 318 enum bfd_endian byte_order = args->byte_order;
16a0f3e7 319
e17a4113 320 args->result = read_memory_integer (memaddr, len, byte_order);
16a0f3e7 321
ee8ff470 322 return 1;
16a0f3e7
EZ
323}
324
ee8ff470
KB
325/* Read memory at MEMADDR of length LEN and put the contents in
326 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
327 if successful. */
328
16a0f3e7 329int
c5504eaf
MS
330safe_read_memory_integer (CORE_ADDR memaddr, int len,
331 enum bfd_endian byte_order,
e17a4113 332 LONGEST *return_value)
16a0f3e7
EZ
333{
334 int status;
335 struct captured_read_memory_integer_arguments args;
c5504eaf 336
16a0f3e7
EZ
337 args.memaddr = memaddr;
338 args.len = len;
e17a4113 339 args.byte_order = byte_order;
16a0f3e7
EZ
340
341 status = catch_errors (do_captured_read_memory_integer, &args,
aff410f1 342 "", RETURN_MASK_ALL);
ee8ff470 343 if (status)
16a0f3e7
EZ
344 *return_value = args.result;
345
346 return status;
347}
348
c906108c 349LONGEST
aff410f1
MS
350read_memory_integer (CORE_ADDR memaddr, int len,
351 enum bfd_endian byte_order)
c906108c 352{
dfb65433 353 gdb_byte buf[sizeof (LONGEST)];
c906108c
SS
354
355 read_memory (memaddr, buf, len);
e17a4113 356 return extract_signed_integer (buf, len, byte_order);
c906108c
SS
357}
358
359ULONGEST
aff410f1
MS
360read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
361 enum bfd_endian byte_order)
c906108c 362{
dfb65433 363 gdb_byte buf[sizeof (ULONGEST)];
c906108c
SS
364
365 read_memory (memaddr, buf, len);
e17a4113 366 return extract_unsigned_integer (buf, len, byte_order);
c906108c
SS
367}
368
0865b04a
YQ
369LONGEST
370read_code_integer (CORE_ADDR memaddr, int len,
371 enum bfd_endian byte_order)
372{
373 gdb_byte buf[sizeof (LONGEST)];
374
375 read_code (memaddr, buf, len);
376 return extract_signed_integer (buf, len, byte_order);
377}
378
379ULONGEST
380read_code_unsigned_integer (CORE_ADDR memaddr, int len,
381 enum bfd_endian byte_order)
382{
383 gdb_byte buf[sizeof (ULONGEST)];
384
385 read_code (memaddr, buf, len);
386 return extract_unsigned_integer (buf, len, byte_order);
387}
388
c906108c 389void
fba45db2 390read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
c906108c 391{
52f0bd74
AC
392 char *cp;
393 int i;
c906108c
SS
394 int cnt;
395
396 cp = buffer;
397 while (1)
398 {
399 if (cp - buffer >= max_len)
c5aa993b
JM
400 {
401 buffer[max_len - 1] = '\0';
402 break;
403 }
c906108c
SS
404 cnt = max_len - (cp - buffer);
405 if (cnt > 8)
406 cnt = 8;
c8af03a2 407 read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
c906108c 408 for (i = 0; i < cnt && *cp; i++, cp++)
c5aa993b 409 ; /* null body */
c906108c
SS
410
411 if (i < cnt && !*cp)
c5aa993b 412 break;
c906108c
SS
413 }
414}
c26e4683 415
0d540cdf
KD
416CORE_ADDR
417read_memory_typed_address (CORE_ADDR addr, struct type *type)
418{
dfb65433 419 gdb_byte *buf = alloca (TYPE_LENGTH (type));
c5504eaf 420
0d540cdf
KD
421 read_memory (addr, buf, TYPE_LENGTH (type));
422 return extract_typed_address (buf, type);
423}
424
aff410f1
MS
425/* Same as target_write_memory, but report an error if can't
426 write. */
c26e4683 427void
aff410f1 428write_memory (CORE_ADDR memaddr,
45aa4659 429 const bfd_byte *myaddr, ssize_t len)
c26e4683
JB
430{
431 int status;
c5504eaf 432
00630ca8 433 status = target_write_memory (memaddr, myaddr, len);
c26e4683
JB
434 if (status != 0)
435 memory_error (status, memaddr);
436}
437
972daa01
YQ
438/* Same as write_memory, but notify 'memory_changed' observers. */
439
440void
441write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
442 ssize_t len)
443{
444 write_memory (memaddr, myaddr, len);
8de0566d 445 observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
972daa01
YQ
446}
447
aff410f1
MS
448/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
449 integer. */
c26e4683 450void
c5504eaf
MS
451write_memory_unsigned_integer (CORE_ADDR addr, int len,
452 enum bfd_endian byte_order,
e17a4113 453 ULONGEST value)
c26e4683 454{
dfb65433 455 gdb_byte *buf = alloca (len);
c5504eaf 456
e17a4113 457 store_unsigned_integer (buf, len, byte_order, value);
c26e4683
JB
458 write_memory (addr, buf, len);
459}
460
aff410f1
MS
461/* Store VALUE at ADDR in the inferior as a LEN-byte signed
462 integer. */
c26e4683 463void
c5504eaf
MS
464write_memory_signed_integer (CORE_ADDR addr, int len,
465 enum bfd_endian byte_order,
e17a4113 466 LONGEST value)
c26e4683 467{
dfb65433 468 gdb_byte *buf = alloca (len);
c5504eaf 469
e17a4113 470 store_signed_integer (buf, len, byte_order, value);
c26e4683
JB
471 write_memory (addr, buf, len);
472}
c906108c
SS
473\f
474/* The current default bfd target. Points to storage allocated for
475 gnutarget_string. */
476char *gnutarget;
477
478/* Same thing, except it is "auto" not NULL for the default case. */
479static char *gnutarget_string;
920d2a44
AC
480static void
481show_gnutarget_string (struct ui_file *file, int from_tty,
aff410f1
MS
482 struct cmd_list_element *c,
483 const char *value)
920d2a44 484{
aff410f1
MS
485 fprintf_filtered (file,
486 _("The current BFD target is \"%s\".\n"), value);
920d2a44 487}
c906108c 488
aff410f1
MS
489static void set_gnutarget_command (char *, int,
490 struct cmd_list_element *);
c906108c
SS
491
492static void
aff410f1
MS
493set_gnutarget_command (char *ignore, int from_tty,
494 struct cmd_list_element *c)
c906108c 495{
44478ab3
TT
496 char *gend = gnutarget_string + strlen (gnutarget_string);
497
498 gend = remove_trailing_whitespace (gnutarget_string, gend);
499 *gend = '\0';
500
bde58177 501 if (strcmp (gnutarget_string, "auto") == 0)
c906108c
SS
502 gnutarget = NULL;
503 else
504 gnutarget = gnutarget_string;
505}
506
44478ab3
TT
507/* A completion function for "set gnutarget". */
508
509static VEC (char_ptr) *
6f937416
PA
510complete_set_gnutarget (struct cmd_list_element *cmd,
511 const char *text, const char *word)
44478ab3
TT
512{
513 static const char **bfd_targets;
514
515 if (bfd_targets == NULL)
516 {
517 int last;
518
519 bfd_targets = bfd_target_list ();
520 for (last = 0; bfd_targets[last] != NULL; ++last)
521 ;
522
523 bfd_targets = xrealloc (bfd_targets, (last + 2) * sizeof (const char **));
524 bfd_targets[last] = "auto";
525 bfd_targets[last + 1] = NULL;
526 }
527
528 return complete_on_enum (bfd_targets, text, word);
529}
530
c906108c
SS
531/* Set the gnutarget. */
532void
fba45db2 533set_gnutarget (char *newtarget)
c906108c
SS
534{
535 if (gnutarget_string != NULL)
b8c9b27d 536 xfree (gnutarget_string);
1b36a34b 537 gnutarget_string = xstrdup (newtarget);
c906108c
SS
538 set_gnutarget_command (NULL, 0, NULL);
539}
540
541void
fba45db2 542_initialize_core (void)
c906108c
SS
543{
544 struct cmd_list_element *c;
c5504eaf 545
1a966eab
AC
546 c = add_cmd ("core-file", class_files, core_file_command, _("\
547Use FILE as core dump for examining memory and registers.\n\
c906108c 548No arg means have no core file. This command has been superseded by the\n\
1a966eab 549`target core' and `detach' commands."), &cmdlist);
5ba2abeb 550 set_cmd_completer (c, filename_completer);
c906108c 551
26c41df3 552
44478ab3
TT
553 c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
554 &gnutarget_string, _("\
26c41df3
AC
555Set the current BFD target."), _("\
556Show the current BFD target."), _("\
557Use `set gnutarget auto' to specify automatic detection."),
44478ab3
TT
558 set_gnutarget_command,
559 show_gnutarget_string,
560 &setlist, &showlist);
561 set_cmd_completer (c, complete_set_gnutarget);
562
7e20dfcd 563 add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
c906108c
SS
564
565 if (getenv ("GNUTARGET"))
566 set_gnutarget (getenv ("GNUTARGET"));
567 else
568 set_gnutarget ("auto");
569}
This page took 0.945193 seconds and 4 git commands to generate.