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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Core dump and executable file functions below target vector, for GDB.
2
 
3
   Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4
   1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
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 "arch-utils.h"
24
#include "gdb_string.h"
25
#include <errno.h>
26
#include <signal.h>
27
#include <fcntl.h>
28
#ifdef HAVE_SYS_FILE_H
29
#include <sys/file.h>           /* needed for F_OK and friends */
30
#endif
31
#include "frame.h"              /* required by inferior.h */
32
#include "inferior.h"
33
#include "symtab.h"
34
#include "command.h"
35
#include "bfd.h"
36
#include "target.h"
37
#include "gdbcore.h"
38
#include "gdbthread.h"
39
#include "regcache.h"
40
#include "regset.h"
41
#include "symfile.h"
42
#include "exec.h"
43
#include "readline/readline.h"
44
#include "gdb_assert.h"
45
#include "exceptions.h"
46
#include "solib.h"
47
#include "filenames.h"
48
 
49
 
50
#ifndef O_LARGEFILE
51
#define O_LARGEFILE 0
52
#endif
53
 
54
/* List of all available core_fns.  On gdb startup, each core file
55
   register reader calls deprecated_add_core_fns() to register
56
   information on each core format it is prepared to read.  */
57
 
58
static struct core_fns *core_file_fns = NULL;
59
 
60
/* The core_fns for a core file handler that is prepared to read the core
61
   file currently open on core_bfd. */
62
 
63
static struct core_fns *core_vec = NULL;
64
 
65
/* FIXME: kettenis/20031023: Eventually this variable should
66
   disappear.  */
67
 
68
struct gdbarch *core_gdbarch = NULL;
69
 
70
static void core_files_info (struct target_ops *);
71
 
72
static struct core_fns *sniff_core_bfd (bfd *);
73
 
74
static int gdb_check_format (bfd *);
75
 
76
static void core_open (char *, int);
77
 
78
static void core_detach (char *, int);
79
 
80
static void core_close (int);
81
 
82
static void core_close_cleanup (void *ignore);
83
 
84
static void get_core_registers (struct regcache *, int);
85
 
86
static void add_to_thread_list (bfd *, asection *, void *);
87
 
88
static int core_file_thread_alive (ptid_t tid);
89
 
90
static void init_core_ops (void);
91
 
92
void _initialize_corelow (void);
93
 
94
struct target_ops core_ops;
95
 
96
/* Link a new core_fns into the global core_file_fns list.  Called on gdb
97
   startup by the _initialize routine in each core file register reader, to
98
   register information about each format the the reader is prepared to
99
   handle. */
100
 
101
void
102
deprecated_add_core_fns (struct core_fns *cf)
103
{
104
  cf->next = core_file_fns;
105
  core_file_fns = cf;
106
}
107
 
108
/* The default function that core file handlers can use to examine a
109
   core file BFD and decide whether or not to accept the job of
110
   reading the core file. */
111
 
112
int
113
default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
114
{
115
  int result;
116
 
117
  result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
118
  return (result);
119
}
120
 
121
/* Walk through the list of core functions to find a set that can
122
   handle the core file open on ABFD.  Default to the first one in the
123
   list if nothing matches.  Returns pointer to set that is
124
   selected. */
125
 
126
static struct core_fns *
127
sniff_core_bfd (bfd *abfd)
128
{
129
  struct core_fns *cf;
130
  struct core_fns *yummy = NULL;
131
  int matches = 0;;
132
 
133
  /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
134
  if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
135
    return NULL;
136
 
137
  for (cf = core_file_fns; cf != NULL; cf = cf->next)
138
    {
139
      if (cf->core_sniffer (cf, abfd))
140
        {
141
          yummy = cf;
142
          matches++;
143
        }
144
    }
145
  if (matches > 1)
146
    {
147
      warning (_("\"%s\": ambiguous core format, %d handlers match"),
148
               bfd_get_filename (abfd), matches);
149
    }
150
  else if (matches == 0)
151
    {
152
      warning (_("\"%s\": no core file handler recognizes format, using default"),
153
               bfd_get_filename (abfd));
154
    }
155
  if (yummy == NULL)
156
    {
157
      yummy = core_file_fns;
158
    }
159
  return (yummy);
160
}
161
 
162
/* The default is to reject every core file format we see.  Either
163
   BFD has to recognize it, or we have to provide a function in the
164
   core file handler that recognizes it. */
165
 
166
int
167
default_check_format (bfd *abfd)
168
{
169
  return (0);
170
}
171
 
172
/* Attempt to recognize core file formats that BFD rejects. */
173
 
174
static int
175
gdb_check_format (bfd *abfd)
176
{
177
  struct core_fns *cf;
178
 
179
  for (cf = core_file_fns; cf != NULL; cf = cf->next)
180
    {
181
      if (cf->check_format (abfd))
182
        {
183
          return (1);
184
        }
185
    }
186
  return (0);
187
}
188
 
189
/* Discard all vestiges of any previous core file and mark data and stack
190
   spaces as empty.  */
191
 
192
static void
193
core_close (int quitting)
194
{
195
  char *name;
196
 
197
  if (core_bfd)
198
    {
199
      inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
200
 
201
      /* Clear out solib state while the bfd is still open. See
202
         comments in clear_solib in solib.c. */
203
      clear_solib ();
204
 
205
      name = bfd_get_filename (core_bfd);
206
      if (!bfd_close (core_bfd))
207
        warning (_("cannot close \"%s\": %s"),
208
                 name, bfd_errmsg (bfd_get_error ()));
209
      xfree (name);
210
      core_bfd = NULL;
211
      if (core_ops.to_sections)
212
        {
213
          xfree (core_ops.to_sections);
214
          core_ops.to_sections = NULL;
215
          core_ops.to_sections_end = NULL;
216
        }
217
    }
218
  core_vec = NULL;
219
  core_gdbarch = NULL;
220
}
221
 
222
static void
223
core_close_cleanup (void *ignore)
224
{
225
  core_close (0/*ignored*/);
226
}
227
 
228
/* Look for sections whose names start with `.reg/' so that we can extract the
229
   list of threads in a core file.  */
230
 
231
static void
232
add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
233
{
234
  int thread_id;
235
  asection *reg_sect = (asection *) reg_sect_arg;
236
 
237
  if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
238
    return;
239
 
240
  thread_id = atoi (bfd_section_name (abfd, asect) + 5);
241
 
242
  add_thread (pid_to_ptid (thread_id));
243
 
244
/* Warning, Will Robinson, looking at BFD private data! */
245
 
246
  if (reg_sect != NULL
247
      && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
248
    inferior_ptid = pid_to_ptid (thread_id);    /* Yes, make it current */
249
}
250
 
251
/* This routine opens and sets up the core file bfd.  */
252
 
253
static void
254
core_open (char *filename, int from_tty)
255
{
256
  const char *p;
257
  int siggy;
258
  struct cleanup *old_chain;
259
  char *temp;
260
  bfd *temp_bfd;
261
  int ontop;
262
  int scratch_chan;
263
  int flags;
264
 
265
  target_preopen (from_tty);
266
  if (!filename)
267
    {
268
      if (core_bfd)
269
        error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
270
      else
271
        error (_("No core file specified."));
272
    }
273
 
274
  filename = tilde_expand (filename);
275
  if (!IS_ABSOLUTE_PATH(filename))
276
    {
277
      temp = concat (current_directory, "/", filename, (char *)NULL);
278
      xfree (filename);
279
      filename = temp;
280
    }
281
 
282
  old_chain = make_cleanup (xfree, filename);
283
 
284
  flags = O_BINARY | O_LARGEFILE;
285
  if (write_files)
286
    flags |= O_RDWR;
287
  else
288
    flags |= O_RDONLY;
289
  scratch_chan = open (filename, flags, 0);
290
  if (scratch_chan < 0)
291
    perror_with_name (filename);
292
 
293
  temp_bfd = bfd_fopen (filename, gnutarget,
294
                        write_files ? FOPEN_RUB : FOPEN_RB,
295
                        scratch_chan);
296
  if (temp_bfd == NULL)
297
    perror_with_name (filename);
298
 
299
  if (!bfd_check_format (temp_bfd, bfd_core) &&
300
      !gdb_check_format (temp_bfd))
301
    {
302
      /* Do it after the err msg */
303
      /* FIXME: should be checking for errors from bfd_close (for one thing,
304
         on error it does not free all the storage associated with the
305
         bfd).  */
306
      make_cleanup_bfd_close (temp_bfd);
307
      error (_("\"%s\" is not a core dump: %s"),
308
             filename, bfd_errmsg (bfd_get_error ()));
309
    }
310
 
311
  /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
312
 
313
  discard_cleanups (old_chain); /* Don't free filename any more */
314
  unpush_target (&core_ops);
315
  core_bfd = temp_bfd;
316
  old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
317
 
318
  /* FIXME: kettenis/20031023: This is very dangerous.  The
319
     CORE_GDBARCH that results from this call may very well be
320
     different from CURRENT_GDBARCH.  However, its methods may only
321
     work if it is selected as the current architecture, because they
322
     rely on swapped data (see gdbarch.c).  We should get rid of that
323
     swapped data.  */
324
  core_gdbarch = gdbarch_from_bfd (core_bfd);
325
 
326
  /* Find a suitable core file handler to munch on core_bfd */
327
  core_vec = sniff_core_bfd (core_bfd);
328
 
329
  validate_files ();
330
 
331
  /* Find the data section */
332
  if (build_section_table (core_bfd, &core_ops.to_sections,
333
                           &core_ops.to_sections_end))
334
    error (_("\"%s\": Can't find sections: %s"),
335
           bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
336
 
337
  /* If we have no exec file, try to set the architecture from the
338
     core file.  We don't do this unconditionally since an exec file
339
     typically contains more information that helps us determine the
340
     architecture than a core file.  */
341
  if (!exec_bfd)
342
    set_gdbarch_from_file (core_bfd);
343
 
344
  ontop = !push_target (&core_ops);
345
  discard_cleanups (old_chain);
346
 
347
  /* This is done first, before anything has a chance to query the
348
     inferior for information such as symbols.  */
349
  post_create_inferior (&core_ops, from_tty);
350
 
351
  p = bfd_core_file_failing_command (core_bfd);
352
  if (p)
353
    printf_filtered (_("Core was generated by `%s'.\n"), p);
354
 
355
  siggy = bfd_core_file_failing_signal (core_bfd);
356
  if (siggy > 0)
357
    /* NOTE: target_signal_from_host() converts a target signal value
358
       into gdb's internal signal value.  Unfortunately gdb's internal
359
       value is called ``target_signal'' and this function got the
360
       name ..._from_host(). */
361
    printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
362
                     target_signal_to_string (target_signal_from_host (siggy)));
363
 
364
  /* Build up thread list from BFD sections. */
365
 
366
  init_thread_list ();
367
  bfd_map_over_sections (core_bfd, add_to_thread_list,
368
                         bfd_get_section_by_name (core_bfd, ".reg"));
369
 
370
  if (ontop)
371
    {
372
      /* Fetch all registers from core file.  */
373
      target_fetch_registers (get_current_regcache (), -1);
374
 
375
      /* Now, set up the frame cache, and print the top of stack.  */
376
      reinit_frame_cache ();
377
      print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
378
    }
379
  else
380
    {
381
      warning (
382
                "you won't be able to access this core file until you terminate\n\
383
your %s; do ``info files''", target_longname);
384
    }
385
}
386
 
387
static void
388
core_detach (char *args, int from_tty)
389
{
390
  if (args)
391
    error (_("Too many arguments"));
392
  unpush_target (&core_ops);
393
  reinit_frame_cache ();
394
  if (from_tty)
395
    printf_filtered (_("No core file now.\n"));
396
}
397
 
398
 
399
/* Try to retrieve registers from a section in core_bfd, and supply
400
   them to core_vec->core_read_registers, as the register set numbered
401
   WHICH.
402
 
403
   If inferior_ptid is zero, do the single-threaded thing: look for a
404
   section named NAME.  If inferior_ptid is non-zero, do the
405
   multi-threaded thing: look for a section named "NAME/PID", where
406
   PID is the shortest ASCII decimal representation of inferior_ptid.
407
 
408
   HUMAN_NAME is a human-readable name for the kind of registers the
409
   NAME section contains, for use in error messages.
410
 
411
   If REQUIRED is non-zero, print an error if the core file doesn't
412
   have a section by the appropriate name.  Otherwise, just do nothing.  */
413
 
414
static void
415
get_core_register_section (struct regcache *regcache,
416
                           char *name,
417
                           int which,
418
                           char *human_name,
419
                           int required)
420
{
421
  static char *section_name = NULL;
422
  struct bfd_section *section;
423
  bfd_size_type size;
424
  char *contents;
425
 
426
  xfree (section_name);
427
  if (PIDGET (inferior_ptid))
428
    section_name = xstrprintf ("%s/%d", name, PIDGET (inferior_ptid));
429
  else
430
    section_name = xstrdup (name);
431
 
432
  section = bfd_get_section_by_name (core_bfd, section_name);
433
  if (! section)
434
    {
435
      if (required)
436
        warning (_("Couldn't find %s registers in core file."), human_name);
437
      return;
438
    }
439
 
440
  size = bfd_section_size (core_bfd, section);
441
  contents = alloca (size);
442
  if (! bfd_get_section_contents (core_bfd, section, contents,
443
                                  (file_ptr) 0, size))
444
    {
445
      warning (_("Couldn't read %s registers from `%s' section in core file."),
446
               human_name, name);
447
      return;
448
    }
449
 
450
  if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
451
    {
452
      const struct regset *regset;
453
 
454
      regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
455
      if (regset == NULL)
456
        {
457
          if (required)
458
            warning (_("Couldn't recognize %s registers in core file."),
459
                     human_name);
460
          return;
461
        }
462
 
463
      regset->supply_regset (regset, regcache, -1, contents, size);
464
      return;
465
    }
466
 
467
  gdb_assert (core_vec);
468
  core_vec->core_read_registers (regcache, contents, size, which,
469
                                 ((CORE_ADDR)
470
                                  bfd_section_vma (core_bfd, section)));
471
}
472
 
473
 
474
/* Get the registers out of a core file.  This is the machine-
475
   independent part.  Fetch_core_registers is the machine-dependent
476
   part, typically implemented in the xm-file for each architecture.  */
477
 
478
/* We just get all the registers, so we don't use regno.  */
479
 
480
static void
481
get_core_registers (struct regcache *regcache, int regno)
482
{
483
  int i;
484
 
485
  if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
486
      && (core_vec == NULL || core_vec->core_read_registers == NULL))
487
    {
488
      fprintf_filtered (gdb_stderr,
489
                     "Can't fetch registers from this type of core file\n");
490
      return;
491
    }
492
 
493
  get_core_register_section (regcache,
494
                             ".reg", 0, "general-purpose", 1);
495
  get_core_register_section (regcache,
496
                             ".reg2", 2, "floating-point", 0);
497
  get_core_register_section (regcache,
498
                             ".reg-xfp", 3, "extended floating-point", 0);
499
  get_core_register_section (regcache,
500
                             ".reg-ppc-vmx", 3, "ppc Altivec", 0);
501
 
502
  /* Supply dummy value for all registers not found in the core.  */
503
  for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
504
    if (!regcache_valid_p (regcache, i))
505
      regcache_raw_supply (regcache, i, NULL);
506
}
507
 
508
static void
509
core_files_info (struct target_ops *t)
510
{
511
  print_section_info (t, core_bfd);
512
}
513
 
514
static LONGEST
515
core_xfer_partial (struct target_ops *ops, enum target_object object,
516
                   const char *annex, gdb_byte *readbuf,
517
                   const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
518
{
519
  switch (object)
520
    {
521
    case TARGET_OBJECT_MEMORY:
522
      if (readbuf)
523
        return (*ops->deprecated_xfer_memory) (offset, readbuf,
524
                                               len, 0/*read*/, NULL, ops);
525
      if (writebuf)
526
        return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
527
                                               len, 1/*write*/, NULL, ops);
528
      return -1;
529
 
530
    case TARGET_OBJECT_AUXV:
531
      if (readbuf)
532
        {
533
          /* When the aux vector is stored in core file, BFD
534
             represents this with a fake section called ".auxv".  */
535
 
536
          struct bfd_section *section;
537
          bfd_size_type size;
538
          char *contents;
539
 
540
          section = bfd_get_section_by_name (core_bfd, ".auxv");
541
          if (section == NULL)
542
            return -1;
543
 
544
          size = bfd_section_size (core_bfd, section);
545
          if (offset >= size)
546
            return 0;
547
          size -= offset;
548
          if (size > len)
549
            size = len;
550
          if (size > 0
551
              && !bfd_get_section_contents (core_bfd, section, readbuf,
552
                                            (file_ptr) offset, size))
553
            {
554
              warning (_("Couldn't read NT_AUXV note in core file."));
555
              return -1;
556
            }
557
 
558
          return size;
559
        }
560
      return -1;
561
 
562
    case TARGET_OBJECT_WCOOKIE:
563
      if (readbuf)
564
        {
565
          /* When the StackGhost cookie is stored in core file, BFD
566
             represents this with a fake section called ".wcookie".  */
567
 
568
          struct bfd_section *section;
569
          bfd_size_type size;
570
          char *contents;
571
 
572
          section = bfd_get_section_by_name (core_bfd, ".wcookie");
573
          if (section == NULL)
574
            return -1;
575
 
576
          size = bfd_section_size (core_bfd, section);
577
          if (offset >= size)
578
            return 0;
579
          size -= offset;
580
          if (size > len)
581
            size = len;
582
          if (size > 0
583
              && !bfd_get_section_contents (core_bfd, section, readbuf,
584
                                            (file_ptr) offset, size))
585
            {
586
              warning (_("Couldn't read StackGhost cookie in core file."));
587
              return -1;
588
            }
589
 
590
          return size;
591
        }
592
      return -1;
593
 
594
    case TARGET_OBJECT_LIBRARIES:
595
      if (core_gdbarch
596
          && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
597
        {
598
          if (writebuf)
599
            return -1;
600
          return
601
            gdbarch_core_xfer_shared_libraries (core_gdbarch,
602
                                                readbuf, offset, len);
603
        }
604
      /* FALL THROUGH */
605
 
606
    default:
607
      if (ops->beneath != NULL)
608
        return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
609
                                              readbuf, writebuf, offset, len);
610
      return -1;
611
    }
612
}
613
 
614
 
615
/* If mourn is being called in all the right places, this could be say
616
   `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
617
 
618
static int
619
ignore (struct bp_target_info *bp_tgt)
620
{
621
  return 0;
622
}
623
 
624
 
625
/* Okay, let's be honest: threads gleaned from a core file aren't
626
   exactly lively, are they?  On the other hand, if we don't claim
627
   that each & every one is alive, then we don't get any of them
628
   to appear in an "info thread" command, which is quite a useful
629
   behaviour.
630
 */
631
static int
632
core_file_thread_alive (ptid_t tid)
633
{
634
  return 1;
635
}
636
 
637
/* Ask the current architecture what it knows about this core file.
638
   That will be used, in turn, to pick a better architecture.  This
639
   wrapper could be avoided if targets got a chance to specialize
640
   core_ops.  */
641
 
642
static const struct target_desc *
643
core_read_description (struct target_ops *target)
644
{
645
  if (gdbarch_core_read_description_p (current_gdbarch))
646
    return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
647
 
648
  return NULL;
649
}
650
 
651
/* Fill in core_ops with its defined operations and properties.  */
652
 
653
static void
654
init_core_ops (void)
655
{
656
  core_ops.to_shortname = "core";
657
  core_ops.to_longname = "Local core dump file";
658
  core_ops.to_doc =
659
    "Use a core file as a target.  Specify the filename of the core file.";
660
  core_ops.to_open = core_open;
661
  core_ops.to_close = core_close;
662
  core_ops.to_attach = find_default_attach;
663
  core_ops.to_detach = core_detach;
664
  core_ops.to_fetch_registers = get_core_registers;
665
  core_ops.to_xfer_partial = core_xfer_partial;
666
  core_ops.deprecated_xfer_memory = xfer_memory;
667
  core_ops.to_files_info = core_files_info;
668
  core_ops.to_insert_breakpoint = ignore;
669
  core_ops.to_remove_breakpoint = ignore;
670
  core_ops.to_create_inferior = find_default_create_inferior;
671
  core_ops.to_thread_alive = core_file_thread_alive;
672
  core_ops.to_read_description = core_read_description;
673
  core_ops.to_stratum = core_stratum;
674
  core_ops.to_has_memory = 1;
675
  core_ops.to_has_stack = 1;
676
  core_ops.to_has_registers = 1;
677
  core_ops.to_magic = OPS_MAGIC;
678
}
679
 
680
/* non-zero if we should not do the add_target call in
681
   _initialize_corelow; not initialized (i.e., bss) so that
682
   the target can initialize it (i.e., data) if appropriate.
683
   This needs to be set at compile time because we don't know
684
   for sure whether the target's initialize routine is called
685
   before us or after us. */
686
int coreops_suppress_target;
687
 
688
void
689
_initialize_corelow (void)
690
{
691
  init_core_ops ();
692
 
693
  if (!coreops_suppress_target)
694
    add_target (&core_ops);
695
}

powered by: WebSVN 2.1.0

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