1/* Core dump and executable file functions above target vector, for GDB.
2
3   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997,
4   1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
5
6   This file is part of GDB.
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 of the License, or
11   (at your option) any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 59 Temple Place - Suite 330,
21   Boston, MA 02111-1307, USA.  */
22
23#include "defs.h"
24#include "gdb_string.h"
25#include <errno.h>
26#include <signal.h>
27#include <fcntl.h>
28#include "inferior.h"
29#include "symtab.h"
30#include "command.h"
31#include "gdbcmd.h"
32#include "bfd.h"
33#include "target.h"
34#include "gdbcore.h"
35#include "dis-asm.h"
36#include "gdb_stat.h"
37#include "completer.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 hooks */
57static int exec_file_hook_count = 0;	/* size of array */
58
59/* Binary file diddling handle for the core file.  */
60
61bfd *core_bfd = NULL;
62
63
64/* Backward compatability with old way of specifying core files.  */
65
66void
67core_file_command (char *filename, int from_tty)
68{
69  struct target_ops *t;
70
71  dont_repeat ();		/* Either way, seems bogus. */
72
73  t = find_core_target ();
74  if (t == NULL)
75    error ("GDB can't read core files on this machine.");
76
77  if (!filename)
78    (t->to_detach) (filename, from_tty);
79  else
80    (t->to_open) (filename, from_tty);
81}
82
83
84/* If there are two or more functions that wish to hook into exec_file_command,
85 * this function will call all of the hook functions. */
86
87static void
88call_extra_exec_file_hooks (char *filename)
89{
90  int i;
91
92  for (i = 0; i < exec_file_hook_count; i++)
93    (*exec_file_extra_hooks[i]) (filename);
94}
95
96/* Call this to specify the hook for exec_file_command to call back.
97   This is called from the x-window display code.  */
98
99void
100specify_exec_file_hook (void (*hook) (char *))
101{
102  hook_type *new_array;
103
104  if (deprecated_exec_file_display_hook != NULL)
105    {
106      /* There's already a hook installed.  Arrange to have both it
107       * and the subsequent hooks called. */
108      if (exec_file_hook_count == 0)
109	{
110	  /* If this is the first extra hook, initialize the hook array. */
111	  exec_file_extra_hooks = (hook_type *) 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 =
122	(hook_type *) 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/* The exec file must be closed before running an inferior.
132   If it is needed again after the inferior dies, it must
133   be reopened.  */
134
135void
136close_exec_file (void)
137{
138#if 0				/* FIXME */
139  if (exec_bfd)
140    bfd_tempclose (exec_bfd);
141#endif
142}
143
144void
145reopen_exec_file (void)
146{
147#if 0				/* FIXME */
148  if (exec_bfd)
149    bfd_reopen (exec_bfd);
150#else
151  char *filename;
152  int res;
153  struct stat st;
154  long mtime;
155
156  /* Don't do anything if the current target isn't exec. */
157  if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
158    return;
159
160  /* If the timestamp of the exec file has changed, reopen it. */
161  filename = xstrdup (bfd_get_filename (exec_bfd));
162  make_cleanup (xfree, filename);
163  mtime = bfd_get_mtime (exec_bfd);
164  res = stat (filename, &st);
165
166  if (mtime && mtime != st.st_mtime)
167    {
168      exec_open (filename, 0);
169    }
170#endif
171}
172
173/* If we have both a core file and an exec file,
174   print a warning if they don't go together.  */
175
176void
177validate_files (void)
178{
179  if (exec_bfd && core_bfd)
180    {
181      if (!core_file_matches_executable_p (core_bfd, exec_bfd))
182	warning ("core file may not match specified executable file.");
183      else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
184	warning ("exec file is newer than core file.");
185    }
186}
187
188/* Return the name of the executable file as a string.
189   ERR nonzero means get error if there is none specified;
190   otherwise return 0 in that case.  */
191
192char *
193get_exec_file (int err)
194{
195  if (exec_bfd)
196    return bfd_get_filename (exec_bfd);
197  if (!err)
198    return NULL;
199
200  error ("No executable file specified.\n\
201Use the \"file\" or \"exec-file\" command.");
202  return NULL;
203}
204
205
206/* Report a memory error with error().  */
207
208void
209memory_error (int status, CORE_ADDR memaddr)
210{
211  struct ui_file *tmp_stream = mem_fileopen ();
212  make_cleanup_ui_file_delete (tmp_stream);
213
214  if (status == EIO)
215    {
216      /* Actually, address between memaddr and memaddr + len
217         was out of bounds. */
218      fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
219      print_address_numeric (memaddr, 1, tmp_stream);
220    }
221  else
222    {
223      fprintf_filtered (tmp_stream, "Error accessing memory address ");
224      print_address_numeric (memaddr, 1, tmp_stream);
225      fprintf_filtered (tmp_stream, ": %s.",
226		       safe_strerror (status));
227    }
228
229  error_stream (tmp_stream);
230}
231
232/* Same as target_read_memory, but report an error if can't read.  */
233void
234read_memory (CORE_ADDR memaddr, char *myaddr, int len)
235{
236  int status;
237  status = target_read_memory (memaddr, myaddr, len);
238  if (status != 0)
239    memory_error (status, memaddr);
240}
241
242/* Argument / return result struct for use with
243   do_captured_read_memory_integer().  MEMADDR and LEN are filled in
244   by gdb_read_memory_integer().  RESULT is the contents that were
245   successfully read from MEMADDR of length LEN.  */
246
247struct captured_read_memory_integer_arguments
248{
249  CORE_ADDR memaddr;
250  int len;
251  LONGEST result;
252};
253
254/* Helper function for gdb_read_memory_integer().  DATA must be a
255   pointer to a captured_read_memory_integer_arguments struct.
256   Return 1 if successful.  Note that the catch_errors() interface
257   will return 0 if an error occurred while reading memory.  This
258   choice of return code is so that we can distinguish between
259   success and failure.  */
260
261static int
262do_captured_read_memory_integer (void *data)
263{
264  struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
265  CORE_ADDR memaddr = args->memaddr;
266  int len = args->len;
267
268  args->result = read_memory_integer (memaddr, len);
269
270  return 1;
271}
272
273/* Read memory at MEMADDR of length LEN and put the contents in
274   RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
275   if successful.  */
276
277int
278safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
279{
280  int status;
281  struct captured_read_memory_integer_arguments args;
282  args.memaddr = memaddr;
283  args.len = len;
284
285  status = catch_errors (do_captured_read_memory_integer, &args,
286                        "", RETURN_MASK_ALL);
287  if (status)
288    *return_value = args.result;
289
290  return status;
291}
292
293LONGEST
294read_memory_integer (CORE_ADDR memaddr, int len)
295{
296  char buf[sizeof (LONGEST)];
297
298  read_memory (memaddr, buf, len);
299  return extract_signed_integer (buf, len);
300}
301
302ULONGEST
303read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
304{
305  char buf[sizeof (ULONGEST)];
306
307  read_memory (memaddr, buf, len);
308  return extract_unsigned_integer (buf, len);
309}
310
311void
312read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
313{
314  char *cp;
315  int i;
316  int cnt;
317
318  cp = buffer;
319  while (1)
320    {
321      if (cp - buffer >= max_len)
322	{
323	  buffer[max_len - 1] = '\0';
324	  break;
325	}
326      cnt = max_len - (cp - buffer);
327      if (cnt > 8)
328	cnt = 8;
329      read_memory (memaddr + (int) (cp - buffer), cp, cnt);
330      for (i = 0; i < cnt && *cp; i++, cp++)
331	;			/* null body */
332
333      if (i < cnt && !*cp)
334	break;
335    }
336}
337
338CORE_ADDR
339read_memory_typed_address (CORE_ADDR addr, struct type *type)
340{
341  char *buf = alloca (TYPE_LENGTH (type));
342  read_memory (addr, buf, TYPE_LENGTH (type));
343  return extract_typed_address (buf, type);
344}
345
346/* Same as target_write_memory, but report an error if can't write.  */
347void
348write_memory (CORE_ADDR memaddr, char *myaddr, int len)
349{
350  int status;
351
352  status = target_write_memory (memaddr, myaddr, len);
353  if (status != 0)
354    memory_error (status, memaddr);
355}
356
357/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
358void
359write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
360{
361  char *buf = alloca (len);
362  store_unsigned_integer (buf, len, value);
363  write_memory (addr, buf, len);
364}
365
366/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */
367void
368write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
369{
370  char *buf = alloca (len);
371  store_signed_integer (buf, len, value);
372  write_memory (addr, buf, len);
373}
374
375
376
377#if 0
378/* Enable after 4.12.  It is not tested.  */
379
380/* Search code.  Targets can just make this their search function, or
381   if the protocol has a less general search function, they can call this
382   in the cases it can't handle.  */
383void
384generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
385		int increment, CORE_ADDR lorange, CORE_ADDR hirange,
386		CORE_ADDR *addr_found, char *data_found)
387{
388  int i;
389  CORE_ADDR curaddr = startaddr;
390
391  while (curaddr >= lorange && curaddr < hirange)
392    {
393      read_memory (curaddr, data_found, len);
394      for (i = 0; i < len; ++i)
395	if ((data_found[i] & mask[i]) != data[i])
396	  goto try_again;
397      /* It matches.  */
398      *addr_found = curaddr;
399      return;
400
401    try_again:
402      curaddr += increment;
403    }
404  *addr_found = (CORE_ADDR) 0;
405  return;
406}
407#endif /* 0 */
408
409/* The current default bfd target.  Points to storage allocated for
410   gnutarget_string.  */
411char *gnutarget;
412
413/* Same thing, except it is "auto" not NULL for the default case.  */
414static char *gnutarget_string;
415
416static void set_gnutarget_command (char *, int, struct cmd_list_element *);
417
418static void
419set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
420{
421  if (strcmp (gnutarget_string, "auto") == 0)
422    gnutarget = NULL;
423  else
424    gnutarget = gnutarget_string;
425}
426
427/* Set the gnutarget.  */
428void
429set_gnutarget (char *newtarget)
430{
431  if (gnutarget_string != NULL)
432    xfree (gnutarget_string);
433  gnutarget_string = savestring (newtarget, strlen (newtarget));
434  set_gnutarget_command (NULL, 0, NULL);
435}
436
437void
438_initialize_core (void)
439{
440  struct cmd_list_element *c;
441  c = add_cmd ("core-file", class_files, core_file_command,
442	       "Use FILE as core dump for examining memory and registers.\n\
443No arg means have no core file.  This command has been superseded by the\n\
444`target core' and `detach' commands.", &cmdlist);
445  set_cmd_completer (c, filename_completer);
446
447  c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
448		   (char *) &gnutarget_string,
449		   "Set the current BFD target.\n\
450Use `set gnutarget auto' to specify automatic detection.",
451		   &setlist);
452  set_cmd_sfunc (c, set_gnutarget_command);
453  deprecated_add_show_from_set (c, &showlist);
454
455  if (getenv ("GNUTARGET"))
456    set_gnutarget (getenv ("GNUTARGET"));
457  else
458    set_gnutarget ("auto");
459}
460