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