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