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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [corelow.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 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, 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 "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
#include "progspace.h"
49
 
50
 
51
#ifndef O_LARGEFILE
52
#define O_LARGEFILE 0
53
#endif
54
 
55
/* List of all available core_fns.  On gdb startup, each core file
56
   register reader calls deprecated_add_core_fns() to register
57
   information on each core format it is prepared to read.  */
58
 
59
static struct core_fns *core_file_fns = NULL;
60
 
61
/* The core_fns for a core file handler that is prepared to read the core
62
   file currently open on core_bfd. */
63
 
64
static struct core_fns *core_vec = NULL;
65
 
66
/* FIXME: kettenis/20031023: Eventually this variable should
67
   disappear.  */
68
 
69
struct gdbarch *core_gdbarch = NULL;
70
 
71
/* Per-core data.  Currently, only the section table.  Note that these
72
   target sections are *not* mapped in the current address spaces' set
73
   of target sections --- those should come only from pure executable
74
   or shared library bfds.  The core bfd sections are an
75
   implementation detail of the core target, just like ptrace is for
76
   unix child targets.  */
77
static struct target_section_table *core_data;
78
 
79
/* True if we needed to fake the pid of the loaded core inferior.  */
80
static int core_has_fake_pid = 0;
81
 
82
static void core_files_info (struct target_ops *);
83
 
84
static struct core_fns *sniff_core_bfd (bfd *);
85
 
86
static int gdb_check_format (bfd *);
87
 
88
static void core_open (char *, int);
89
 
90
static void core_detach (struct target_ops *ops, char *, int);
91
 
92
static void core_close (int);
93
 
94
static void core_close_cleanup (void *ignore);
95
 
96
static void add_to_thread_list (bfd *, asection *, void *);
97
 
98
static void init_core_ops (void);
99
 
100
void _initialize_corelow (void);
101
 
102
struct target_ops core_ops;
103
 
104
/* An arbitrary identifier for the core inferior.  */
105
#define CORELOW_PID 1
106
 
107
/* Link a new core_fns into the global core_file_fns list.  Called on gdb
108
   startup by the _initialize routine in each core file register reader, to
109
   register information about each format the the reader is prepared to
110
   handle. */
111
 
112
void
113
deprecated_add_core_fns (struct core_fns *cf)
114
{
115
  cf->next = core_file_fns;
116
  core_file_fns = cf;
117
}
118
 
119
/* The default function that core file handlers can use to examine a
120
   core file BFD and decide whether or not to accept the job of
121
   reading the core file. */
122
 
123
int
124
default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
125
{
126
  int result;
127
 
128
  result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
129
  return (result);
130
}
131
 
132
/* Walk through the list of core functions to find a set that can
133
   handle the core file open on ABFD.  Default to the first one in the
134
   list if nothing matches.  Returns pointer to set that is
135
   selected. */
136
 
137
static struct core_fns *
138
sniff_core_bfd (bfd *abfd)
139
{
140
  struct core_fns *cf;
141
  struct core_fns *yummy = NULL;
142
  int matches = 0;;
143
 
144
  /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
145
  if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
146
    return NULL;
147
 
148
  for (cf = core_file_fns; cf != NULL; cf = cf->next)
149
    {
150
      if (cf->core_sniffer (cf, abfd))
151
        {
152
          yummy = cf;
153
          matches++;
154
        }
155
    }
156
  if (matches > 1)
157
    {
158
      warning (_("\"%s\": ambiguous core format, %d handlers match"),
159
               bfd_get_filename (abfd), matches);
160
    }
161
  else if (matches == 0)
162
    {
163
      warning (_("\"%s\": no core file handler recognizes format, using default"),
164
               bfd_get_filename (abfd));
165
    }
166
  if (yummy == NULL)
167
    {
168
      yummy = core_file_fns;
169
    }
170
  return (yummy);
171
}
172
 
173
/* The default is to reject every core file format we see.  Either
174
   BFD has to recognize it, or we have to provide a function in the
175
   core file handler that recognizes it. */
176
 
177
int
178
default_check_format (bfd *abfd)
179
{
180
  return (0);
181
}
182
 
183
/* Attempt to recognize core file formats that BFD rejects. */
184
 
185
static int
186
gdb_check_format (bfd *abfd)
187
{
188
  struct core_fns *cf;
189
 
190
  for (cf = core_file_fns; cf != NULL; cf = cf->next)
191
    {
192
      if (cf->check_format (abfd))
193
        {
194
          return (1);
195
        }
196
    }
197
  return (0);
198
}
199
 
200
/* Discard all vestiges of any previous core file and mark data and stack
201
   spaces as empty.  */
202
 
203
static void
204
core_close (int quitting)
205
{
206
  char *name;
207
 
208
  if (core_bfd)
209
    {
210
      int pid = ptid_get_pid (inferior_ptid);
211
      inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
212
      exit_inferior_silent (pid);
213
 
214
      /* Clear out solib state while the bfd is still open. See
215
         comments in clear_solib in solib.c. */
216
      clear_solib ();
217
 
218
      xfree (core_data->sections);
219
      xfree (core_data);
220
      core_data = NULL;
221
      core_has_fake_pid = 0;
222
 
223
      name = bfd_get_filename (core_bfd);
224
      if (!bfd_close (core_bfd))
225
        warning (_("cannot close \"%s\": %s"),
226
                 name, bfd_errmsg (bfd_get_error ()));
227
      xfree (name);
228
      core_bfd = NULL;
229
    }
230
  core_vec = NULL;
231
  core_gdbarch = NULL;
232
}
233
 
234
static void
235
core_close_cleanup (void *ignore)
236
{
237
  core_close (0/*ignored*/);
238
}
239
 
240
/* Look for sections whose names start with `.reg/' so that we can extract the
241
   list of threads in a core file.  */
242
 
243
static void
244
add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
245
{
246
  ptid_t ptid;
247
  int core_tid;
248
  int pid, lwpid;
249
  asection *reg_sect = (asection *) reg_sect_arg;
250
 
251
  if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
252
    return;
253
 
254
  core_tid = atoi (bfd_section_name (abfd, asect) + 5);
255
 
256
  if (core_gdbarch
257
      && gdbarch_core_reg_section_encodes_pid (core_gdbarch))
258
    {
259
      uint32_t merged_pid = core_tid;
260
      pid = merged_pid & 0xffff;
261
      lwpid = merged_pid >> 16;
262
 
263
      /* This can happen on solaris core, for example, if we don't
264
         find a NT_PSTATUS note in the core, but do find NT_LWPSTATUS
265
         notes.  */
266
      if (pid == 0)
267
        {
268
          core_has_fake_pid = 1;
269
          pid = CORELOW_PID;
270
        }
271
    }
272
  else
273
    {
274
      core_has_fake_pid = 1;
275
      pid = CORELOW_PID;
276
      lwpid = core_tid;
277
    }
278
 
279
  if (current_inferior ()->pid == 0)
280
    inferior_appeared (current_inferior (), pid);
281
 
282
  ptid = ptid_build (pid, lwpid, 0);
283
 
284
  add_thread (ptid);
285
 
286
/* Warning, Will Robinson, looking at BFD private data! */
287
 
288
  if (reg_sect != NULL
289
      && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
290
    inferior_ptid = ptid;                        /* Yes, make it current */
291
}
292
 
293
/* This routine opens and sets up the core file bfd.  */
294
 
295
static void
296
core_open (char *filename, int from_tty)
297
{
298
  const char *p;
299
  int siggy;
300
  struct cleanup *old_chain;
301
  char *temp;
302
  bfd *temp_bfd;
303
  int scratch_chan;
304
  int flags;
305
 
306
  target_preopen (from_tty);
307
  if (!filename)
308
    {
309
      if (core_bfd)
310
        error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
311
      else
312
        error (_("No core file specified."));
313
    }
314
 
315
  filename = tilde_expand (filename);
316
  if (!IS_ABSOLUTE_PATH(filename))
317
    {
318
      temp = concat (current_directory, "/", filename, (char *)NULL);
319
      xfree (filename);
320
      filename = temp;
321
    }
322
 
323
  old_chain = make_cleanup (xfree, filename);
324
 
325
  flags = O_BINARY | O_LARGEFILE;
326
  if (write_files)
327
    flags |= O_RDWR;
328
  else
329
    flags |= O_RDONLY;
330
  scratch_chan = open (filename, flags, 0);
331
  if (scratch_chan < 0)
332
    perror_with_name (filename);
333
 
334
  temp_bfd = bfd_fopen (filename, gnutarget,
335
                        write_files ? FOPEN_RUB : FOPEN_RB,
336
                        scratch_chan);
337
  if (temp_bfd == NULL)
338
    perror_with_name (filename);
339
 
340
  if (!bfd_check_format (temp_bfd, bfd_core)
341
      && !gdb_check_format (temp_bfd))
342
    {
343
      /* Do it after the err msg */
344
      /* FIXME: should be checking for errors from bfd_close (for one thing,
345
         on error it does not free all the storage associated with the
346
         bfd).  */
347
      make_cleanup_bfd_close (temp_bfd);
348
      error (_("\"%s\" is not a core dump: %s"),
349
             filename, bfd_errmsg (bfd_get_error ()));
350
    }
351
 
352
  /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
353
 
354
  discard_cleanups (old_chain); /* Don't free filename any more */
355
  unpush_target (&core_ops);
356
  core_bfd = temp_bfd;
357
  old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
358
 
359
  /* FIXME: kettenis/20031023: This is very dangerous.  The
360
     CORE_GDBARCH that results from this call may very well be
361
     different from CURRENT_GDBARCH.  However, its methods may only
362
     work if it is selected as the current architecture, because they
363
     rely on swapped data (see gdbarch.c).  We should get rid of that
364
     swapped data.  */
365
  core_gdbarch = gdbarch_from_bfd (core_bfd);
366
 
367
  /* Find a suitable core file handler to munch on core_bfd */
368
  core_vec = sniff_core_bfd (core_bfd);
369
 
370
  validate_files ();
371
 
372
  core_data = XZALLOC (struct target_section_table);
373
 
374
  /* Find the data section */
375
  if (build_section_table (core_bfd,
376
                           &core_data->sections, &core_data->sections_end))
377
    error (_("\"%s\": Can't find sections: %s"),
378
           bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
379
 
380
  /* If we have no exec file, try to set the architecture from the
381
     core file.  We don't do this unconditionally since an exec file
382
     typically contains more information that helps us determine the
383
     architecture than a core file.  */
384
  if (!exec_bfd)
385
    set_gdbarch_from_file (core_bfd);
386
 
387
  push_target (&core_ops);
388
  discard_cleanups (old_chain);
389
 
390
  /* Do this before acknowledging the inferior, so if
391
     post_create_inferior throws (can happen easilly if you're loading
392
     a core file with the wrong exec), we aren't left with threads
393
     from the previous inferior.  */
394
  init_thread_list ();
395
 
396
  inferior_ptid = null_ptid;
397
  core_has_fake_pid = 0;
398
 
399
  /* Need to flush the register cache (and the frame cache) from a
400
     previous debug session.  If inferior_ptid ends up the same as the
401
     last debug session --- e.g., b foo; run; gcore core1; step; gcore
402
     core2; core core1; core core2 --- then there's potential for
403
     get_current_regcache to return the cached regcache of the
404
     previous session, and the frame cache being stale.  */
405
  registers_changed ();
406
 
407
  /* Build up thread list from BFD sections, and possibly set the
408
     current thread to the .reg/NN section matching the .reg
409
     section. */
410
  bfd_map_over_sections (core_bfd, add_to_thread_list,
411
                         bfd_get_section_by_name (core_bfd, ".reg"));
412
 
413
  if (ptid_equal (inferior_ptid, null_ptid))
414
    {
415
      /* Either we found no .reg/NN section, and hence we have a
416
         non-threaded core (single-threaded, from gdb's perspective),
417
         or for some reason add_to_thread_list couldn't determine
418
         which was the "main" thread.  The latter case shouldn't
419
         usually happen, but we're dealing with input here, which can
420
         always be broken in different ways.  */
421
      struct thread_info *thread = first_thread_of_process (-1);
422
      if (thread == NULL)
423
        {
424
          inferior_appeared (current_inferior (), CORELOW_PID);
425
          inferior_ptid = pid_to_ptid (CORELOW_PID);
426
          add_thread_silent (inferior_ptid);
427
        }
428
      else
429
        switch_to_thread (thread->ptid);
430
    }
431
 
432
  post_create_inferior (&core_ops, from_tty);
433
 
434
  /* Now go through the target stack looking for threads since there
435
     may be a thread_stratum target loaded on top of target core by
436
     now.  The layer above should claim threads found in the BFD
437
     sections.  */
438
  target_find_new_threads ();
439
 
440
  p = bfd_core_file_failing_command (core_bfd);
441
  if (p)
442
    printf_filtered (_("Core was generated by `%s'.\n"), p);
443
 
444
  siggy = bfd_core_file_failing_signal (core_bfd);
445
  if (siggy > 0)
446
    /* NOTE: target_signal_from_host() converts a target signal value
447
       into gdb's internal signal value.  Unfortunately gdb's internal
448
       value is called ``target_signal'' and this function got the
449
       name ..._from_host(). */
450
    printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
451
                     target_signal_to_string (
452
                       (core_gdbarch != NULL) ?
453
                        gdbarch_target_signal_from_host (core_gdbarch, siggy)
454
                        : siggy));
455
 
456
  /* Fetch all registers from core file.  */
457
  target_fetch_registers (get_current_regcache (), -1);
458
 
459
  /* Now, set up the frame cache, and print the top of stack.  */
460
  reinit_frame_cache ();
461
  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
462
}
463
 
464
static void
465
core_detach (struct target_ops *ops, char *args, int from_tty)
466
{
467
  if (args)
468
    error (_("Too many arguments"));
469
  unpush_target (ops);
470
  reinit_frame_cache ();
471
  if (from_tty)
472
    printf_filtered (_("No core file now.\n"));
473
}
474
 
475
#ifdef DEPRECATED_IBM6000_TARGET
476
 
477
/* Resize the core memory's section table, by NUM_ADDED.  Returns a
478
   pointer into the first new slot.  This will not be necessary when
479
   the rs6000 target is converted to use the standard solib
480
   framework.  */
481
 
482
struct target_section *
483
deprecated_core_resize_section_table (int num_added)
484
{
485
  int old_count;
486
 
487
  old_count = resize_section_table (core_data, num_added);
488
  return core_data->sections + old_count;
489
}
490
 
491
#endif
492
 
493
/* Try to retrieve registers from a section in core_bfd, and supply
494
   them to core_vec->core_read_registers, as the register set numbered
495
   WHICH.
496
 
497
   If inferior_ptid's lwp member is zero, do the single-threaded
498
   thing: look for a section named NAME.  If inferior_ptid's lwp
499
   member is non-zero, do the multi-threaded thing: look for a section
500
   named "NAME/LWP", where LWP is the shortest ASCII decimal
501
   representation of inferior_ptid's lwp member.
502
 
503
   HUMAN_NAME is a human-readable name for the kind of registers the
504
   NAME section contains, for use in error messages.
505
 
506
   If REQUIRED is non-zero, print an error if the core file doesn't
507
   have a section by the appropriate name.  Otherwise, just do nothing.  */
508
 
509
static void
510
get_core_register_section (struct regcache *regcache,
511
                           const char *name,
512
                           int which,
513
                           const char *human_name,
514
                           int required)
515
{
516
  static char *section_name = NULL;
517
  struct bfd_section *section;
518
  bfd_size_type size;
519
  char *contents;
520
 
521
  xfree (section_name);
522
 
523
  if (core_gdbarch
524
      && gdbarch_core_reg_section_encodes_pid (core_gdbarch))
525
    {
526
      uint32_t merged_pid;
527
      int pid = ptid_get_pid (inferior_ptid);
528
 
529
      if (core_has_fake_pid)
530
        pid = 0;
531
 
532
      merged_pid = ptid_get_lwp (inferior_ptid);
533
      merged_pid = merged_pid << 16 | pid;
534
 
535
      section_name = xstrprintf ("%s/%s", name, plongest (merged_pid));
536
    }
537
  else if (ptid_get_lwp (inferior_ptid))
538
    section_name = xstrprintf ("%s/%ld", name, ptid_get_lwp (inferior_ptid));
539
  else
540
    section_name = xstrdup (name);
541
 
542
  section = bfd_get_section_by_name (core_bfd, section_name);
543
  if (! section)
544
    {
545
      if (required)
546
        warning (_("Couldn't find %s registers in core file."), human_name);
547
      return;
548
    }
549
 
550
  size = bfd_section_size (core_bfd, section);
551
  contents = alloca (size);
552
  if (! bfd_get_section_contents (core_bfd, section, contents,
553
                                  (file_ptr) 0, size))
554
    {
555
      warning (_("Couldn't read %s registers from `%s' section in core file."),
556
               human_name, name);
557
      return;
558
    }
559
 
560
  if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
561
    {
562
      const struct regset *regset;
563
 
564
      regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
565
      if (regset == NULL)
566
        {
567
          if (required)
568
            warning (_("Couldn't recognize %s registers in core file."),
569
                     human_name);
570
          return;
571
        }
572
 
573
      regset->supply_regset (regset, regcache, -1, contents, size);
574
      return;
575
    }
576
 
577
  gdb_assert (core_vec);
578
  core_vec->core_read_registers (regcache, contents, size, which,
579
                                 ((CORE_ADDR)
580
                                  bfd_section_vma (core_bfd, section)));
581
}
582
 
583
 
584
/* Get the registers out of a core file.  This is the machine-
585
   independent part.  Fetch_core_registers is the machine-dependent
586
   part, typically implemented in the xm-file for each architecture.  */
587
 
588
/* We just get all the registers, so we don't use regno.  */
589
 
590
static void
591
get_core_registers (struct target_ops *ops,
592
                    struct regcache *regcache, int regno)
593
{
594
  struct core_regset_section *sect_list;
595
  int i;
596
 
597
  if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
598
      && (core_vec == NULL || core_vec->core_read_registers == NULL))
599
    {
600
      fprintf_filtered (gdb_stderr,
601
                     "Can't fetch registers from this type of core file\n");
602
      return;
603
    }
604
 
605
  sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
606
  if (sect_list)
607
    while (sect_list->sect_name != NULL)
608
      {
609
        if (strcmp (sect_list->sect_name, ".reg") == 0)
610
          get_core_register_section (regcache, sect_list->sect_name,
611
                                     0, sect_list->human_name, 1);
612
        else if (strcmp (sect_list->sect_name, ".reg2") == 0)
613
          get_core_register_section (regcache, sect_list->sect_name,
614
                                     2, sect_list->human_name, 0);
615
        else
616
          get_core_register_section (regcache, sect_list->sect_name,
617
                                     3, sect_list->human_name, 0);
618
 
619
        sect_list++;
620
      }
621
 
622
  else
623
    {
624
      get_core_register_section (regcache,
625
                                 ".reg", 0, "general-purpose", 1);
626
      get_core_register_section (regcache,
627
                                 ".reg2", 2, "floating-point", 0);
628
    }
629
 
630
  /* Supply dummy value for all registers not found in the core.  */
631
  for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
632
    if (!regcache_valid_p (regcache, i))
633
      regcache_raw_supply (regcache, i, NULL);
634
}
635
 
636
static void
637
core_files_info (struct target_ops *t)
638
{
639
  print_section_info (core_data, core_bfd);
640
}
641
 
642
struct spuid_list
643
{
644
  gdb_byte *buf;
645
  ULONGEST offset;
646
  LONGEST len;
647
  ULONGEST pos;
648
  ULONGEST written;
649
};
650
 
651
static void
652
add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
653
{
654
  struct spuid_list *list = list_p;
655
  enum bfd_endian byte_order
656
    = bfd_big_endian (abfd)? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
657
  int fd, pos = 0;
658
 
659
  sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
660
  if (pos == 0)
661
    return;
662
 
663
  if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
664
    {
665
      store_unsigned_integer (list->buf + list->pos - list->offset,
666
                              4, byte_order, fd);
667
      list->written += 4;
668
    }
669
  list->pos += 4;
670
}
671
 
672
static LONGEST
673
core_xfer_partial (struct target_ops *ops, enum target_object object,
674
                   const char *annex, gdb_byte *readbuf,
675
                   const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
676
{
677
  switch (object)
678
    {
679
    case TARGET_OBJECT_MEMORY:
680
      return section_table_xfer_memory_partial (readbuf, writebuf,
681
                                                offset, len,
682
                                                core_data->sections,
683
                                                core_data->sections_end,
684
                                                NULL);
685
 
686
    case TARGET_OBJECT_AUXV:
687
      if (readbuf)
688
        {
689
          /* When the aux vector is stored in core file, BFD
690
             represents this with a fake section called ".auxv".  */
691
 
692
          struct bfd_section *section;
693
          bfd_size_type size;
694
          char *contents;
695
 
696
          section = bfd_get_section_by_name (core_bfd, ".auxv");
697
          if (section == NULL)
698
            return -1;
699
 
700
          size = bfd_section_size (core_bfd, section);
701
          if (offset >= size)
702
            return 0;
703
          size -= offset;
704
          if (size > len)
705
            size = len;
706
          if (size > 0
707
              && !bfd_get_section_contents (core_bfd, section, readbuf,
708
                                            (file_ptr) offset, size))
709
            {
710
              warning (_("Couldn't read NT_AUXV note in core file."));
711
              return -1;
712
            }
713
 
714
          return size;
715
        }
716
      return -1;
717
 
718
    case TARGET_OBJECT_WCOOKIE:
719
      if (readbuf)
720
        {
721
          /* When the StackGhost cookie is stored in core file, BFD
722
             represents this with a fake section called ".wcookie".  */
723
 
724
          struct bfd_section *section;
725
          bfd_size_type size;
726
          char *contents;
727
 
728
          section = bfd_get_section_by_name (core_bfd, ".wcookie");
729
          if (section == NULL)
730
            return -1;
731
 
732
          size = bfd_section_size (core_bfd, section);
733
          if (offset >= size)
734
            return 0;
735
          size -= offset;
736
          if (size > len)
737
            size = len;
738
          if (size > 0
739
              && !bfd_get_section_contents (core_bfd, section, readbuf,
740
                                            (file_ptr) offset, size))
741
            {
742
              warning (_("Couldn't read StackGhost cookie in core file."));
743
              return -1;
744
            }
745
 
746
          return size;
747
        }
748
      return -1;
749
 
750
    case TARGET_OBJECT_LIBRARIES:
751
      if (core_gdbarch
752
          && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
753
        {
754
          if (writebuf)
755
            return -1;
756
          return
757
            gdbarch_core_xfer_shared_libraries (core_gdbarch,
758
                                                readbuf, offset, len);
759
        }
760
      /* FALL THROUGH */
761
 
762
    case TARGET_OBJECT_SPU:
763
      if (readbuf && annex)
764
        {
765
          /* When the SPU contexts are stored in a core file, BFD
766
             represents this with a fake section called "SPU/<annex>".  */
767
 
768
          struct bfd_section *section;
769
          bfd_size_type size;
770
          char *contents;
771
 
772
          char sectionstr[100];
773
          xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
774
 
775
          section = bfd_get_section_by_name (core_bfd, sectionstr);
776
          if (section == NULL)
777
            return -1;
778
 
779
          size = bfd_section_size (core_bfd, section);
780
          if (offset >= size)
781
            return 0;
782
          size -= offset;
783
          if (size > len)
784
            size = len;
785
          if (size > 0
786
              && !bfd_get_section_contents (core_bfd, section, readbuf,
787
                                            (file_ptr) offset, size))
788
            {
789
              warning (_("Couldn't read SPU section in core file."));
790
              return -1;
791
            }
792
 
793
          return size;
794
        }
795
      else if (readbuf)
796
        {
797
          /* NULL annex requests list of all present spuids.  */
798
          struct spuid_list list;
799
          list.buf = readbuf;
800
          list.offset = offset;
801
          list.len = len;
802
          list.pos = 0;
803
          list.written = 0;
804
          bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
805
          return list.written;
806
        }
807
      return -1;
808
 
809
    default:
810
      if (ops->beneath != NULL)
811
        return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
812
                                              readbuf, writebuf, offset, len);
813
      return -1;
814
    }
815
}
816
 
817
 
818
/* If mourn is being called in all the right places, this could be say
819
   `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
820
 
821
static int
822
ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
823
{
824
  return 0;
825
}
826
 
827
 
828
/* Okay, let's be honest: threads gleaned from a core file aren't
829
   exactly lively, are they?  On the other hand, if we don't claim
830
   that each & every one is alive, then we don't get any of them
831
   to appear in an "info thread" command, which is quite a useful
832
   behaviour.
833
 */
834
static int
835
core_thread_alive (struct target_ops *ops, ptid_t ptid)
836
{
837
  return 1;
838
}
839
 
840
/* Ask the current architecture what it knows about this core file.
841
   That will be used, in turn, to pick a better architecture.  This
842
   wrapper could be avoided if targets got a chance to specialize
843
   core_ops.  */
844
 
845
static const struct target_desc *
846
core_read_description (struct target_ops *target)
847
{
848
  if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
849
    return gdbarch_core_read_description (core_gdbarch, target, core_bfd);
850
 
851
  return NULL;
852
}
853
 
854
static char *
855
core_pid_to_str (struct target_ops *ops, ptid_t ptid)
856
{
857
  static char buf[64];
858
 
859
  if (core_gdbarch
860
      && gdbarch_core_pid_to_str_p (core_gdbarch))
861
    {
862
      char *ret = gdbarch_core_pid_to_str (core_gdbarch, ptid);
863
      if (ret != NULL)
864
        return ret;
865
    }
866
 
867
  if (ptid_get_lwp (ptid) == 0)
868
    xsnprintf (buf, sizeof buf, "<main task>");
869
  else
870
    xsnprintf (buf, sizeof buf, "Thread %ld", ptid_get_lwp (ptid));
871
 
872
  return buf;
873
}
874
 
875
static int
876
core_has_memory (struct target_ops *ops)
877
{
878
  return (core_bfd != NULL);
879
}
880
 
881
static int
882
core_has_stack (struct target_ops *ops)
883
{
884
  return (core_bfd != NULL);
885
}
886
 
887
static int
888
core_has_registers (struct target_ops *ops)
889
{
890
  return (core_bfd != NULL);
891
}
892
 
893
/* Fill in core_ops with its defined operations and properties.  */
894
 
895
static void
896
init_core_ops (void)
897
{
898
  core_ops.to_shortname = "core";
899
  core_ops.to_longname = "Local core dump file";
900
  core_ops.to_doc =
901
    "Use a core file as a target.  Specify the filename of the core file.";
902
  core_ops.to_open = core_open;
903
  core_ops.to_close = core_close;
904
  core_ops.to_attach = find_default_attach;
905
  core_ops.to_detach = core_detach;
906
  core_ops.to_fetch_registers = get_core_registers;
907
  core_ops.to_xfer_partial = core_xfer_partial;
908
  core_ops.to_files_info = core_files_info;
909
  core_ops.to_insert_breakpoint = ignore;
910
  core_ops.to_remove_breakpoint = ignore;
911
  core_ops.to_create_inferior = find_default_create_inferior;
912
  core_ops.to_thread_alive = core_thread_alive;
913
  core_ops.to_read_description = core_read_description;
914
  core_ops.to_pid_to_str = core_pid_to_str;
915
  core_ops.to_stratum = core_stratum;
916
  core_ops.to_has_memory = core_has_memory;
917
  core_ops.to_has_stack = core_has_stack;
918
  core_ops.to_has_registers = core_has_registers;
919
  core_ops.to_magic = OPS_MAGIC;
920
}
921
 
922
void
923
_initialize_corelow (void)
924
{
925
  init_core_ops ();
926
 
927
  add_target (&core_ops);
928
}

powered by: WebSVN 2.1.0

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