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, 2011
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
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
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.  */
59
60/* Binary file diddling handle for the core file.  */
61
62bfd *core_bfd = NULL;
63
64/* corelow.c target (if included for this gdb target).  */
65
66struct target_ops *core_target;
67
68
69/* Backward compatability with old way of specifying core files.  */
70
71void
72core_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
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
90static void
91call_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
102void
103specify_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
140void
141close_exec_file (void)
142{
143#if 0				/* FIXME */
144  if (exec_bfd)
145    bfd_tempclose (exec_bfd);
146#endif
147}
148
149void
150reopen_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
182/* If we have both a core file and an exec file,
183   print a warning if they don't go together.  */
184
185void
186validate_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
201char *
202get_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\
210Use the \"file\" or \"exec-file\" command."));
211  return NULL;
212}
213
214
215/* Report a memory error by throwing a MEMORY_ERROR error.  */
216
217void
218memory_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
235void
236read_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
247void
248read_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
262struct 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
277static int
278do_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
295int
296safe_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
315LONGEST
316read_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
325ULONGEST
326read_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
335void
336read_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
362CORE_ADDR
363read_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.  */
373void
374write_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.  */
386void
387write_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.  */
399void
400write_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
410/* The current default bfd target.  Points to storage allocated for
411   gnutarget_string.  */
412char *gnutarget;
413
414/* Same thing, except it is "auto" not NULL for the default case.  */
415static char *gnutarget_string;
416static void
417show_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
425static void set_gnutarget_command (char *, int,
426				   struct cmd_list_element *);
427
428static void
429set_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.  */
439void
440set_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
448void
449_initialize_core (void)
450{
451  struct cmd_list_element *c;
452
453  c = add_cmd ("core-file", class_files, core_file_command, _("\
454Use FILE as core dump for examining memory and registers.\n\
455No 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, _("\
462Set the current BFD target."), _("\
463Show the current BFD target."), _("\
464Use `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}
474