OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [corefile.c] - Blame information for rev 258

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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 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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "gdb_string.h"
23
#include <errno.h>
24
#include <signal.h>
25
#include <fcntl.h>
26
#include "inferior.h"
27
#include "symtab.h"
28
#include "command.h"
29
#include "gdbcmd.h"
30
#include "bfd.h"
31
#include "target.h"
32
#include "gdbcore.h"
33
#include "dis-asm.h"
34
#include "gdb_stat.h"
35
#include "completer.h"
36
#include "exceptions.h"
37
 
38
/* Local function declarations.  */
39
 
40
extern void _initialize_core (void);
41
static void call_extra_exec_file_hooks (char *filename);
42
 
43
/* You can have any number of hooks for `exec_file_command' command to
44
   call.  If there's only one hook, it is set in exec_file_display
45
   hook.  If there are two or more hooks, they are set in
46
   exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
47
   set to a function that calls all of them.  This extra complexity is
48
   needed to preserve compatibility with old code that assumed that
49
   only one hook could be set, and which called
50
   deprecated_exec_file_display_hook directly.  */
51
 
52
typedef void (*hook_type) (char *);
53
 
54
hook_type deprecated_exec_file_display_hook;    /* the original hook */
55
static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
56
static int exec_file_hook_count = 0;     /* size of array */
57
 
58
/* Binary file diddling handle for the core file.  */
59
 
60
bfd *core_bfd = NULL;
61
 
62
 
63
/* Backward compatability with old way of specifying core files.  */
64
 
65
void
66
core_file_command (char *filename, int from_tty)
67
{
68
  struct target_ops *t;
69
 
70
  dont_repeat ();               /* Either way, seems bogus. */
71
 
72
  t = find_core_target ();
73
  if (t == NULL)
74
    error (_("GDB can't read core files on this machine."));
75
 
76
  if (!filename)
77
    (t->to_detach) (filename, from_tty);
78
  else
79
    (t->to_open) (filename, from_tty);
80
}
81
 
82
 
83
/* If there are two or more functions that wish to hook into
84
   exec_file_command, this function will call all of the hook
85
   functions.  */
86
 
87
static void
88
call_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
 
99
void
100
specify_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
 
135
void
136
close_exec_file (void)
137
{
138
#if 0                           /* FIXME */
139
  if (exec_bfd)
140
    bfd_tempclose (exec_bfd);
141
#endif
142
}
143
 
144
void
145
reopen_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 there isn't an exec file. */
157
  if (exec_bfd == NULL)
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
    exec_file_attach (filename, 0);
168
#endif
169
}
170
 
171
/* If we have both a core file and an exec file,
172
   print a warning if they don't go together.  */
173
 
174
void
175
validate_files (void)
176
{
177
  if (exec_bfd && core_bfd)
178
    {
179
      if (!core_file_matches_executable_p (core_bfd, exec_bfd))
180
        warning (_("core file may not match specified executable file."));
181
      else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
182
        warning (_("exec file is newer than core file."));
183
    }
184
}
185
 
186
/* Return the name of the executable file as a string.
187
   ERR nonzero means get error if there is none specified;
188
   otherwise return 0 in that case.  */
189
 
190
char *
191
get_exec_file (int err)
192
{
193
  if (exec_bfd)
194
    return bfd_get_filename (exec_bfd);
195
  if (!err)
196
    return NULL;
197
 
198
  error (_("No executable file specified.\n\
199
Use the \"file\" or \"exec-file\" command."));
200
  return NULL;
201
}
202
 
203
 
204
/* Report a memory error with error().  */
205
 
206
void
207
memory_error (int status, CORE_ADDR memaddr)
208
{
209
  struct ui_file *tmp_stream = mem_fileopen ();
210
  make_cleanup_ui_file_delete (tmp_stream);
211
 
212
  if (status == EIO)
213
    {
214
      /* Actually, address between memaddr and memaddr + len
215
         was out of bounds. */
216
      fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
217
      fputs_filtered (paddress (memaddr), tmp_stream);
218
    }
219
  else
220
    {
221
      fprintf_filtered (tmp_stream, "Error accessing memory address ");
222
      fputs_filtered (paddress (memaddr), tmp_stream);
223
      fprintf_filtered (tmp_stream, ": %s.",
224
                       safe_strerror (status));
225
    }
226
 
227
  error_stream (tmp_stream);
228
}
229
 
230
/* Same as target_read_memory, but report an error if can't read.  */
231
void
232
read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
233
{
234
  int status;
235
  status = target_read_memory (memaddr, myaddr, len);
236
  if (status != 0)
237
    memory_error (status, memaddr);
238
}
239
 
240
/* Argument / return result struct for use with
241
   do_captured_read_memory_integer().  MEMADDR and LEN are filled in
242
   by gdb_read_memory_integer().  RESULT is the contents that were
243
   successfully read from MEMADDR of length LEN.  */
244
 
245
struct captured_read_memory_integer_arguments
246
{
247
  CORE_ADDR memaddr;
248
  int len;
249
  LONGEST result;
250
};
251
 
252
/* Helper function for gdb_read_memory_integer().  DATA must be a
253
   pointer to a captured_read_memory_integer_arguments struct.
254
   Return 1 if successful.  Note that the catch_errors() interface
255
   will return 0 if an error occurred while reading memory.  This
256
   choice of return code is so that we can distinguish between
257
   success and failure.  */
258
 
259
static int
260
do_captured_read_memory_integer (void *data)
261
{
262
  struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
263
  CORE_ADDR memaddr = args->memaddr;
264
  int len = args->len;
265
 
266
  args->result = read_memory_integer (memaddr, len);
267
 
268
  return 1;
269
}
270
 
271
/* Read memory at MEMADDR of length LEN and put the contents in
272
   RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
273
   if successful.  */
274
 
275
int
276
safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
277
{
278
  int status;
279
  struct captured_read_memory_integer_arguments args;
280
  args.memaddr = memaddr;
281
  args.len = len;
282
 
283
  status = catch_errors (do_captured_read_memory_integer, &args,
284
                        "", RETURN_MASK_ALL);
285
  if (status)
286
    *return_value = args.result;
287
 
288
  return status;
289
}
290
 
291
LONGEST
292
read_memory_integer (CORE_ADDR memaddr, int len)
293
{
294
  gdb_byte buf[sizeof (LONGEST)];
295
 
296
  read_memory (memaddr, buf, len);
297
  return extract_signed_integer (buf, len);
298
}
299
 
300
ULONGEST
301
read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
302
{
303
  gdb_byte buf[sizeof (ULONGEST)];
304
 
305
  read_memory (memaddr, buf, len);
306
  return extract_unsigned_integer (buf, len);
307
}
308
 
309
void
310
read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
311
{
312
  char *cp;
313
  int i;
314
  int cnt;
315
 
316
  cp = buffer;
317
  while (1)
318
    {
319
      if (cp - buffer >= max_len)
320
        {
321
          buffer[max_len - 1] = '\0';
322
          break;
323
        }
324
      cnt = max_len - (cp - buffer);
325
      if (cnt > 8)
326
        cnt = 8;
327
      read_memory (memaddr + (int) (cp - buffer), cp, cnt);
328
      for (i = 0; i < cnt && *cp; i++, cp++)
329
        ;                       /* null body */
330
 
331
      if (i < cnt && !*cp)
332
        break;
333
    }
334
}
335
 
336
CORE_ADDR
337
read_memory_typed_address (CORE_ADDR addr, struct type *type)
338
{
339
  gdb_byte *buf = alloca (TYPE_LENGTH (type));
340
  read_memory (addr, buf, TYPE_LENGTH (type));
341
  return extract_typed_address (buf, type);
342
}
343
 
344
/* Same as target_write_memory, but report an error if can't write.  */
345
void
346
write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
347
{
348
  int status;
349
  gdb_byte *bytes = alloca (len);
350
 
351
  memcpy (bytes, myaddr, len);
352
  status = target_write_memory (memaddr, bytes, 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.  */
358
void
359
write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
360
{
361
  gdb_byte *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.  */
367
void
368
write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
369
{
370
  gdb_byte *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.  */
383
void
384
generic_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.  */
411
char *gnutarget;
412
 
413
/* Same thing, except it is "auto" not NULL for the default case.  */
414
static char *gnutarget_string;
415
static void
416
show_gnutarget_string (struct ui_file *file, int from_tty,
417
                       struct cmd_list_element *c, const char *value)
418
{
419
  fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), value);
420
}
421
 
422
static void set_gnutarget_command (char *, int, struct cmd_list_element *);
423
 
424
static void
425
set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
426
{
427
  if (strcmp (gnutarget_string, "auto") == 0)
428
    gnutarget = NULL;
429
  else
430
    gnutarget = gnutarget_string;
431
}
432
 
433
/* Set the gnutarget.  */
434
void
435
set_gnutarget (char *newtarget)
436
{
437
  if (gnutarget_string != NULL)
438
    xfree (gnutarget_string);
439
  gnutarget_string = savestring (newtarget, strlen (newtarget));
440
  set_gnutarget_command (NULL, 0, NULL);
441
}
442
 
443
void
444
_initialize_core (void)
445
{
446
  struct cmd_list_element *c;
447
  c = add_cmd ("core-file", class_files, core_file_command, _("\
448
Use FILE as core dump for examining memory and registers.\n\
449
No arg means have no core file.  This command has been superseded by the\n\
450
`target core' and `detach' commands."), &cmdlist);
451
  set_cmd_completer (c, filename_completer);
452
 
453
 
454
  add_setshow_string_noescape_cmd ("gnutarget", class_files,
455
                                   &gnutarget_string, _("(\
456
Set the current BFD target."), _("\
457
Show the current BFD target."), _("\
458
Use `set gnutarget auto' to specify automatic detection."),
459
                                   set_gnutarget_command,
460
                                   show_gnutarget_string,
461
                                   &setlist, &showlist);
462
 
463
  if (getenv ("GNUTARGET"))
464
    set_gnutarget (getenv ("GNUTARGET"));
465
  else
466
    set_gnutarget ("auto");
467
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.