GDB (xrefs)
/tmp/gdb-7.10/gdb/corelow.c
Go to the documentation of this file.
1 /* Core dump and executable file functions below target vector, for GDB.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include <signal.h>
23 #include <fcntl.h>
24 #ifdef HAVE_SYS_FILE_H
25 #include <sys/file.h> /* needed for F_OK and friends */
26 #endif
27 #include "frame.h" /* required by inferior.h */
28 #include "inferior.h"
29 #include "infrun.h"
30 #include "symtab.h"
31 #include "command.h"
32 #include "bfd.h"
33 #include "target.h"
34 #include "gdbcore.h"
35 #include "gdbthread.h"
36 #include "regcache.h"
37 #include "regset.h"
38 #include "symfile.h"
39 #include "exec.h"
40 #include "readline/readline.h"
41 #include "solib.h"
42 #include "filenames.h"
43 #include "progspace.h"
44 #include "objfiles.h"
45 #include "gdb_bfd.h"
46 #include "completer.h"
47 #include "filestuff.h"
48 
49 #ifndef O_LARGEFILE
50 #define O_LARGEFILE 0
51 #endif
52 
53 /* List of all available core_fns. On gdb startup, each core file
54  register reader calls deprecated_add_core_fns() to register
55  information on each core format it is prepared to read. */
56 
57 static struct core_fns *core_file_fns = NULL;
58 
59 /* The core_fns for a core file handler that is prepared to read the
60  core file currently open on core_bfd. */
61 
62 static struct core_fns *core_vec = NULL;
63 
64 /* FIXME: kettenis/20031023: Eventually this variable should
65  disappear. */
66 
67 static struct gdbarch *core_gdbarch = NULL;
68 
69 /* Per-core data. Currently, only the section table. Note that these
70  target sections are *not* mapped in the current address spaces' set
71  of target sections --- those should come only from pure executable
72  or shared library bfds. The core bfd sections are an
73  implementation detail of the core target, just like ptrace is for
74  unix child targets. */
76 
77 static void core_files_info (struct target_ops *);
78 
79 static struct core_fns *sniff_core_bfd (bfd *);
80 
81 static int gdb_check_format (bfd *);
82 
83 static void core_close (struct target_ops *self);
84 
85 static void core_close_cleanup (void *ignore);
86 
87 static void add_to_thread_list (bfd *, asection *, void *);
88 
89 static void init_core_ops (void);
90 
91 void _initialize_corelow (void);
92 
93 static struct target_ops core_ops;
94 
95 /* An arbitrary identifier for the core inferior. */
96 #define CORELOW_PID 1
97 
98 /* Link a new core_fns into the global core_file_fns list. Called on
99  gdb startup by the _initialize routine in each core file register
100  reader, to register information about each format the reader is
101  prepared to handle. */
102 
103 void
105 {
106  cf->next = core_file_fns;
107  core_file_fns = cf;
108 }
109 
110 /* The default function that core file handlers can use to examine a
111  core file BFD and decide whether or not to accept the job of
112  reading the core file. */
113 
114 int
115 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
116 {
117  int result;
118 
119  result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
120  return (result);
121 }
122 
123 /* Walk through the list of core functions to find a set that can
124  handle the core file open on ABFD. Returns pointer to set that is
125  selected. */
126 
127 static struct core_fns *
128 sniff_core_bfd (bfd *abfd)
129 {
130  struct core_fns *cf;
131  struct core_fns *yummy = NULL;
132  int matches = 0;;
133 
134  /* Don't sniff if we have support for register sets in
135  CORE_GDBARCH. */
136  if (core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
137  return NULL;
138 
139  for (cf = core_file_fns; cf != NULL; cf = cf->next)
140  {
141  if (cf->core_sniffer (cf, abfd))
142  {
143  yummy = cf;
144  matches++;
145  }
146  }
147  if (matches > 1)
148  {
149  warning (_("\"%s\": ambiguous core format, %d handlers match"),
150  bfd_get_filename (abfd), matches);
151  }
152  else if (matches == 0)
153  error (_("\"%s\": no core file handler recognizes format"),
154  bfd_get_filename (abfd));
155 
156  return (yummy);
157 }
158 
159 /* The default is to reject every core file format we see. Either
160  BFD has to recognize it, or we have to provide a function in the
161  core file handler that recognizes it. */
162 
163 int
165 {
166  return (0);
167 }
168 
169 /* Attempt to recognize core file formats that BFD rejects. */
170 
171 static int
172 gdb_check_format (bfd *abfd)
173 {
174  struct core_fns *cf;
175 
176  for (cf = core_file_fns; cf != NULL; cf = cf->next)
177  {
178  if (cf->check_format (abfd))
179  {
180  return (1);
181  }
182  }
183  return (0);
184 }
185 
186 /* Discard all vestiges of any previous core file and mark data and
187  stack spaces as empty. */
188 
189 static void
190 core_close (struct target_ops *self)
191 {
192  if (core_bfd)
193  {
195  inferior_ptid = null_ptid; /* Avoid confusion from thread
196  stuff. */
197  if (pid != 0)
198  exit_inferior_silent (pid);
199 
200  /* Clear out solib state while the bfd is still open. See
201  comments in clear_solib in solib.c. */
202  clear_solib ();
203 
204  if (core_data)
205  {
206  xfree (core_data->sections);
207  xfree (core_data);
208  core_data = NULL;
209  }
210 
212  core_bfd = NULL;
213  }
214  core_vec = NULL;
215  core_gdbarch = NULL;
216 }
217 
218 static void
220 {
221  core_close (NULL);
222 }
223 
224 /* Look for sections whose names start with `.reg/' so that we can
225  extract the list of threads in a core file. */
226 
227 static void
228 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
229 {
230  ptid_t ptid;
231  int core_tid;
232  int pid, lwpid;
233  asection *reg_sect = (asection *) reg_sect_arg;
234  int fake_pid_p = 0;
235  struct inferior *inf;
236 
237  if (!startswith (bfd_section_name (abfd, asect), ".reg/"))
238  return;
239 
240  core_tid = atoi (bfd_section_name (abfd, asect) + 5);
241 
242  pid = bfd_core_file_pid (core_bfd);
243  if (pid == 0)
244  {
245  fake_pid_p = 1;
246  pid = CORELOW_PID;
247  }
248 
249  lwpid = core_tid;
250 
251  inf = current_inferior ();
252  if (inf->pid == 0)
253  {
254  inferior_appeared (inf, pid);
255  inf->fake_pid_p = fake_pid_p;
256  }
257 
258  ptid = ptid_build (pid, lwpid, 0);
259 
260  add_thread (ptid);
261 
262 /* Warning, Will Robinson, looking at BFD private data! */
263 
264  if (reg_sect != NULL
265  && asect->filepos == reg_sect->filepos) /* Did we find .reg? */
266  inferior_ptid = ptid; /* Yes, make it current. */
267 }
268 
269 /* This routine opens and sets up the core file bfd. */
270 
271 static void
272 core_open (const char *arg, int from_tty)
273 {
274  const char *p;
275  int siggy;
276  struct cleanup *old_chain;
277  char *temp;
278  bfd *temp_bfd;
279  int scratch_chan;
280  int flags;
281  char *filename;
282 
283  target_preopen (from_tty);
284  if (!arg)
285  {
286  if (core_bfd)
287  error (_("No core file specified. (Use `detach' "
288  "to stop debugging a core file.)"));
289  else
290  error (_("No core file specified."));
291  }
292 
293  filename = tilde_expand (arg);
294  if (!IS_ABSOLUTE_PATH (filename))
295  {
296  temp = concat (current_directory, "/",
297  filename, (char *) NULL);
298  xfree (filename);
299  filename = temp;
300  }
301 
302  old_chain = make_cleanup (xfree, filename);
303 
304  flags = O_BINARY | O_LARGEFILE;
305  if (write_files)
306  flags |= O_RDWR;
307  else
308  flags |= O_RDONLY;
309  scratch_chan = gdb_open_cloexec (filename, flags, 0);
310  if (scratch_chan < 0)
311  perror_with_name (filename);
312 
313  temp_bfd = gdb_bfd_fopen (filename, gnutarget,
314  write_files ? FOPEN_RUB : FOPEN_RB,
315  scratch_chan);
316  if (temp_bfd == NULL)
317  perror_with_name (filename);
318 
319  if (!bfd_check_format (temp_bfd, bfd_core)
320  && !gdb_check_format (temp_bfd))
321  {
322  /* Do it after the err msg */
323  /* FIXME: should be checking for errors from bfd_close (for one
324  thing, on error it does not free all the storage associated
325  with the bfd). */
326  make_cleanup_bfd_unref (temp_bfd);
327  error (_("\"%s\" is not a core dump: %s"),
328  filename, bfd_errmsg (bfd_get_error ()));
329  }
330 
331  /* Looks semi-reasonable. Toss the old core file and work on the
332  new. */
333 
334  do_cleanups (old_chain);
336  core_bfd = temp_bfd;
337  old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
338 
339  core_gdbarch = gdbarch_from_bfd (core_bfd);
340 
341  /* Find a suitable core file handler to munch on core_bfd */
342  core_vec = sniff_core_bfd (core_bfd);
343 
344  validate_files ();
345 
346  core_data = XCNEW (struct target_section_table);
347 
348  /* Find the data section */
350  &core_data->sections,
351  &core_data->sections_end))
352  error (_("\"%s\": Can't find sections: %s"),
353  bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
354 
355  /* If we have no exec file, try to set the architecture from the
356  core file. We don't do this unconditionally since an exec file
357  typically contains more information that helps us determine the
358  architecture than a core file. */
359  if (!exec_bfd)
361 
363  discard_cleanups (old_chain);
364 
365  /* Do this before acknowledging the inferior, so if
366  post_create_inferior throws (can happen easilly if you're loading
367  a core file with the wrong exec), we aren't left with threads
368  from the previous inferior. */
369  init_thread_list ();
370 
372 
373  /* Need to flush the register cache (and the frame cache) from a
374  previous debug session. If inferior_ptid ends up the same as the
375  last debug session --- e.g., b foo; run; gcore core1; step; gcore
376  core2; core core1; core core2 --- then there's potential for
377  get_current_regcache to return the cached regcache of the
378  previous session, and the frame cache being stale. */
380 
381  /* Build up thread list from BFD sections, and possibly set the
382  current thread to the .reg/NN section matching the .reg
383  section. */
384  bfd_map_over_sections (core_bfd, add_to_thread_list,
385  bfd_get_section_by_name (core_bfd, ".reg"));
386 
388  {
389  /* Either we found no .reg/NN section, and hence we have a
390  non-threaded core (single-threaded, from gdb's perspective),
391  or for some reason add_to_thread_list couldn't determine
392  which was the "main" thread. The latter case shouldn't
393  usually happen, but we're dealing with input here, which can
394  always be broken in different ways. */
395  struct thread_info *thread = first_thread_of_process (-1);
396 
397  if (thread == NULL)
398  {
402  }
403  else
404  switch_to_thread (thread->ptid);
405  }
406 
407  post_create_inferior (&core_ops, from_tty);
408 
409  /* Now go through the target stack looking for threads since there
410  may be a thread_stratum target loaded on top of target core by
411  now. The layer above should claim threads found in the BFD
412  sections. */
413  TRY
414  {
416  }
417 
418  CATCH (except, RETURN_MASK_ERROR)
419  {
420  exception_print (gdb_stderr, except);
421  }
422  END_CATCH
423 
424  p = bfd_core_file_failing_command (core_bfd);
425  if (p)
426  printf_filtered (_("Core was generated by `%s'.\n"), p);
427 
428  /* Clearing any previous state of convenience variables. */
430 
431  siggy = bfd_core_file_failing_signal (core_bfd);
432  if (siggy > 0)
433  {
434  /* If we don't have a CORE_GDBARCH to work with, assume a native
435  core (map gdb_signal from host signals). If we do have
436  CORE_GDBARCH to work with, but no gdb_signal_from_target
437  implementation for that gdbarch, as a fallback measure,
438  assume the host signal mapping. It'll be correct for native
439  cores, but most likely incorrect for cross-cores. */
440  enum gdb_signal sig = (core_gdbarch != NULL
441  && gdbarch_gdb_signal_from_target_p (core_gdbarch)
442  ? gdbarch_gdb_signal_from_target (core_gdbarch,
443  siggy)
444  : gdb_signal_from_host (siggy));
445 
446  printf_filtered (_("Program terminated with signal %s, %s.\n"),
448 
449  /* Set the value of the internal variable $_exitsignal,
450  which holds the signal uncaught by the inferior. */
452  siggy);
453  }
454 
455  /* Fetch all registers from core file. */
457 
458  /* Now, set up the frame cache, and print the top of stack. */
461 
462  /* Current thread should be NUM 1 but the user does not know that.
463  If a program is single threaded gdb in general does not mention
464  anything about threads. That is why the test is >= 2. */
465  if (thread_count () >= 2)
466  {
467  TRY
468  {
469  thread_command (NULL, from_tty);
470  }
471  CATCH (except, RETURN_MASK_ERROR)
472  {
473  exception_print (gdb_stderr, except);
474  }
475  END_CATCH
476  }
477 }
478 
479 static void
480 core_detach (struct target_ops *ops, const char *args, int from_tty)
481 {
482  if (args)
483  error (_("Too many arguments"));
484  unpush_target (ops);
486  if (from_tty)
487  printf_filtered (_("No core file now.\n"));
488 }
489 
490 /* Try to retrieve registers from a section in core_bfd, and supply
491  them to core_vec->core_read_registers, as the register set numbered
492  WHICH.
493 
494  If inferior_ptid's lwp member is zero, do the single-threaded
495  thing: look for a section named NAME. If inferior_ptid's lwp
496  member is non-zero, do the multi-threaded thing: look for a section
497  named "NAME/LWP", where LWP is the shortest ASCII decimal
498  representation of inferior_ptid's lwp member.
499 
500  HUMAN_NAME is a human-readable name for the kind of registers the
501  NAME section contains, for use in error messages.
502 
503  If REQUIRED is non-zero, print an error if the core file doesn't
504  have a section by the appropriate name. Otherwise, just do
505  nothing. */
506 
507 static void
509  const struct regset *regset,
510  const char *name,
511  int min_size,
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 
524  section_name = xstrprintf ("%s/%ld", name,
526  else
527  section_name = xstrdup (name);
528 
529  section = bfd_get_section_by_name (core_bfd, section_name);
530  if (! section)
531  {
532  if (required)
533  warning (_("Couldn't find %s registers in core file."),
534  human_name);
535  return;
536  }
537 
538  size = bfd_section_size (core_bfd, section);
539  if (size < min_size)
540  {
541  warning (_("Section `%s' in core file too small."), section_name);
542  return;
543  }
544  if (size != min_size && !(regset->flags & REGSET_VARIABLE_SIZE))
545  {
546  warning (_("Unexpected size of section `%s' in core file."),
547  section_name);
548  }
549 
550  contents = alloca (size);
551  if (! bfd_get_section_contents (core_bfd, section, contents,
552  (file_ptr) 0, size))
553  {
554  warning (_("Couldn't read %s registers from `%s' section in core file."),
555  human_name, name);
556  return;
557  }
558 
559  if (regset != NULL)
560  {
561  regset->supply_regset (regset, regcache, -1, contents, size);
562  return;
563  }
564 
565  gdb_assert (core_vec);
566  core_vec->core_read_registers (regcache, contents, size, which,
567  ((CORE_ADDR)
568  bfd_section_vma (core_bfd, section)));
569 }
570 
571 /* Callback for get_core_registers that handles a single core file
572  register note section. */
573 
574 static void
575 get_core_registers_cb (const char *sect_name, int size,
576  const struct regset *regset,
577  const char *human_name, void *cb_data)
578 {
579  struct regcache *regcache = (struct regcache *) cb_data;
580  int required = 0;
581 
582  if (strcmp (sect_name, ".reg") == 0)
583  {
584  required = 1;
585  if (human_name == NULL)
586  human_name = "general-purpose";
587  }
588  else if (strcmp (sect_name, ".reg2") == 0)
589  {
590  if (human_name == NULL)
591  human_name = "floating-point";
592  }
593 
594  /* The 'which' parameter is only used when no regset is provided.
595  Thus we just set it to -1. */
596  get_core_register_section (regcache, regset, sect_name,
597  size, -1, human_name, required);
598 }
599 
600 /* Get the registers out of a core file. This is the machine-
601  independent part. Fetch_core_registers is the machine-dependent
602  part, typically implemented in the xm-file for each
603  architecture. */
604 
605 /* We just get all the registers, so we don't use regno. */
606 
607 static void
609  struct regcache *regcache, int regno)
610 {
611  int i;
612  struct gdbarch *gdbarch;
613 
614  if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
615  && (core_vec == NULL || core_vec->core_read_registers == NULL))
616  {
618  "Can't fetch registers from this type of core file\n");
619  return;
620  }
621 
622  gdbarch = get_regcache_arch (regcache);
626  (void *) regcache, NULL);
627  else
628  {
629  get_core_register_section (regcache, NULL,
630  ".reg", 0, 0, "general-purpose", 1);
631  get_core_register_section (regcache, NULL,
632  ".reg2", 0, 2, "floating-point", 0);
633  }
634 
635  /* Mark all registers not found in the core as unavailable. */
636  for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
637  if (regcache_register_status (regcache, i) == REG_UNKNOWN)
638  regcache_raw_supply (regcache, i, NULL);
639 }
640 
641 static void
643 {
644  print_section_info (core_data, core_bfd);
645 }
646 
648 {
654 };
655 
656 static void
657 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
658 {
659  struct spuid_list *list = list_p;
660  enum bfd_endian byte_order
661  = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
662  int fd, pos = 0;
663 
664  sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
665  if (pos == 0)
666  return;
667 
668  if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
669  {
670  store_unsigned_integer (list->buf + list->pos - list->offset,
671  4, byte_order, fd);
672  list->written += 4;
673  }
674  list->pos += 4;
675 }
676 
677 /* Read siginfo data from the core, if possible. Returns -1 on
678  failure. Otherwise, returns the number of bytes read. ABFD is the
679  core file's BFD; READBUF, OFFSET, and LEN are all as specified by
680  the to_xfer_partial interface. */
681 
682 static LONGEST
684 {
685  asection *section;
686  char *section_name;
687  const char *name = ".note.linuxcore.siginfo";
688 
690  section_name = xstrprintf ("%s/%ld", name,
692  else
693  section_name = xstrdup (name);
694 
695  section = bfd_get_section_by_name (abfd, section_name);
696  xfree (section_name);
697  if (section == NULL)
698  return -1;
699 
700  if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
701  return -1;
702 
703  return len;
704 }
705 
706 static enum target_xfer_status
707 core_xfer_partial (struct target_ops *ops, enum target_object object,
708  const char *annex, gdb_byte *readbuf,
709  const gdb_byte *writebuf, ULONGEST offset,
710  ULONGEST len, ULONGEST *xfered_len)
711 {
712  switch (object)
713  {
715  return section_table_xfer_memory_partial (readbuf, writebuf,
716  offset, len, xfered_len,
717  core_data->sections,
718  core_data->sections_end,
719  NULL);
720 
721  case TARGET_OBJECT_AUXV:
722  if (readbuf)
723  {
724  /* When the aux vector is stored in core file, BFD
725  represents this with a fake section called ".auxv". */
726 
727  struct bfd_section *section;
728  bfd_size_type size;
729 
730  section = bfd_get_section_by_name (core_bfd, ".auxv");
731  if (section == NULL)
732  return TARGET_XFER_E_IO;
733 
734  size = bfd_section_size (core_bfd, section);
735  if (offset >= size)
736  return TARGET_XFER_EOF;
737  size -= offset;
738  if (size > len)
739  size = len;
740 
741  if (size == 0)
742  return TARGET_XFER_EOF;
743  if (!bfd_get_section_contents (core_bfd, section, readbuf,
744  (file_ptr) offset, size))
745  {
746  warning (_("Couldn't read NT_AUXV note in core file."));
747  return TARGET_XFER_E_IO;
748  }
749 
750  *xfered_len = (ULONGEST) size;
751  return TARGET_XFER_OK;
752  }
753  return TARGET_XFER_E_IO;
754 
756  if (readbuf)
757  {
758  /* When the StackGhost cookie is stored in core file, BFD
759  represents this with a fake section called
760  ".wcookie". */
761 
762  struct bfd_section *section;
763  bfd_size_type size;
764 
765  section = bfd_get_section_by_name (core_bfd, ".wcookie");
766  if (section == NULL)
767  return TARGET_XFER_E_IO;
768 
769  size = bfd_section_size (core_bfd, section);
770  if (offset >= size)
771  return TARGET_XFER_EOF;
772  size -= offset;
773  if (size > len)
774  size = len;
775 
776  if (size == 0)
777  return TARGET_XFER_EOF;
778  if (!bfd_get_section_contents (core_bfd, section, readbuf,
779  (file_ptr) offset, size))
780  {
781  warning (_("Couldn't read StackGhost cookie in core file."));
782  return TARGET_XFER_E_IO;
783  }
784 
785  *xfered_len = (ULONGEST) size;
786  return TARGET_XFER_OK;
787 
788  }
789  return TARGET_XFER_E_IO;
790 
792  if (core_gdbarch
793  && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
794  {
795  if (writebuf)
796  return TARGET_XFER_E_IO;
797  else
798  {
799  *xfered_len = gdbarch_core_xfer_shared_libraries (core_gdbarch,
800  readbuf,
801  offset, len);
802 
803  if (*xfered_len == 0)
804  return TARGET_XFER_EOF;
805  else
806  return TARGET_XFER_OK;
807  }
808  }
809  /* FALL THROUGH */
810 
812  if (core_gdbarch
814  {
815  if (writebuf)
816  return TARGET_XFER_E_IO;
817  else
818  {
819  *xfered_len
821  readbuf, offset,
822  len);
823 
824  if (*xfered_len == 0)
825  return TARGET_XFER_EOF;
826  else
827  return TARGET_XFER_OK;
828  }
829  }
830  /* FALL THROUGH */
831 
832  case TARGET_OBJECT_SPU:
833  if (readbuf && annex)
834  {
835  /* When the SPU contexts are stored in a core file, BFD
836  represents this with a fake section called
837  "SPU/<annex>". */
838 
839  struct bfd_section *section;
840  bfd_size_type size;
841  char sectionstr[100];
842 
843  xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
844 
845  section = bfd_get_section_by_name (core_bfd, sectionstr);
846  if (section == NULL)
847  return TARGET_XFER_E_IO;
848 
849  size = bfd_section_size (core_bfd, section);
850  if (offset >= size)
851  return TARGET_XFER_EOF;
852  size -= offset;
853  if (size > len)
854  size = len;
855 
856  if (size == 0)
857  return TARGET_XFER_EOF;
858  if (!bfd_get_section_contents (core_bfd, section, readbuf,
859  (file_ptr) offset, size))
860  {
861  warning (_("Couldn't read SPU section in core file."));
862  return TARGET_XFER_E_IO;
863  }
864 
865  *xfered_len = (ULONGEST) size;
866  return TARGET_XFER_OK;
867  }
868  else if (readbuf)
869  {
870  /* NULL annex requests list of all present spuids. */
871  struct spuid_list list;
872 
873  list.buf = readbuf;
874  list.offset = offset;
875  list.len = len;
876  list.pos = 0;
877  list.written = 0;
878  bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
879 
880  if (list.written == 0)
881  return TARGET_XFER_EOF;
882  else
883  {
884  *xfered_len = (ULONGEST) list.written;
885  return TARGET_XFER_OK;
886  }
887  }
888  return TARGET_XFER_E_IO;
889 
891  if (readbuf)
892  {
893  LONGEST l = get_core_siginfo (core_bfd, readbuf, offset, len);
894 
895  if (l > 0)
896  {
897  *xfered_len = len;
898  return TARGET_XFER_OK;
899  }
900  }
901  return TARGET_XFER_E_IO;
902 
903  default:
904  return ops->beneath->to_xfer_partial (ops->beneath, object,
905  annex, readbuf,
906  writebuf, offset, len,
907  xfered_len);
908  }
909 }
910 
911 
912 /* If mourn is being called in all the right places, this could be say
913  `gdb internal error' (since generic_mourn calls
914  breakpoint_init_inferior). */
915 
916 static int
917 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
918  struct bp_target_info *bp_tgt)
919 {
920  return 0;
921 }
922 
923 
924 /* Okay, let's be honest: threads gleaned from a core file aren't
925  exactly lively, are they? On the other hand, if we don't claim
926  that each & every one is alive, then we don't get any of them
927  to appear in an "info thread" command, which is quite a useful
928  behaviour.
929  */
930 static int
932 {
933  return 1;
934 }
935 
936 /* Ask the current architecture what it knows about this core file.
937  That will be used, in turn, to pick a better architecture. This
938  wrapper could be avoided if targets got a chance to specialize
939  core_ops. */
940 
941 static const struct target_desc *
943 {
944  if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
945  {
946  const struct target_desc *result;
947 
948  result = gdbarch_core_read_description (core_gdbarch,
949  target, core_bfd);
950  if (result != NULL)
951  return result;
952  }
953 
954  return target->beneath->to_read_description (target->beneath);
955 }
956 
957 static char *
959 {
960  static char buf[64];
961  struct inferior *inf;
962  int pid;
963 
964  /* The preferred way is to have a gdbarch/OS specific
965  implementation. */
966  if (core_gdbarch
967  && gdbarch_core_pid_to_str_p (core_gdbarch))
968  return gdbarch_core_pid_to_str (core_gdbarch, ptid);
969 
970  /* Otherwise, if we don't have one, we'll just fallback to
971  "process", with normal_pid_to_str. */
972 
973  /* Try the LWPID field first. */
974  pid = ptid_get_lwp (ptid);
975  if (pid != 0)
976  return normal_pid_to_str (pid_to_ptid (pid));
977 
978  /* Otherwise, this isn't a "threaded" core -- use the PID field, but
979  only if it isn't a fake PID. */
980  inf = find_inferior_ptid (ptid);
981  if (inf != NULL && !inf->fake_pid_p)
982  return normal_pid_to_str (ptid);
983 
984  /* No luck. We simply don't have a valid PID to print. */
985  xsnprintf (buf, sizeof buf, "<main task>");
986  return buf;
987 }
988 
989 static int
991 {
992  return (core_bfd != NULL);
993 }
994 
995 static int
997 {
998  return (core_bfd != NULL);
999 }
1000 
1001 static int
1003 {
1004  return (core_bfd != NULL);
1005 }
1006 
1007 /* Implement the to_info_proc method. */
1008 
1009 static void
1010 core_info_proc (struct target_ops *ops, const char *args,
1011  enum info_proc_what request)
1012 {
1013  struct gdbarch *gdbarch = get_current_arch ();
1014 
1015  /* Since this is the core file target, call the 'core_info_proc'
1016  method on gdbarch, not 'info_proc'. */
1017  if (gdbarch_core_info_proc_p (gdbarch))
1018  gdbarch_core_info_proc (gdbarch, args, request);
1019 }
1020 
1021 /* Fill in core_ops with its defined operations and properties. */
1022 
1023 static void
1025 {
1026  core_ops.to_shortname = "core";
1027  core_ops.to_longname = "Local core dump file";
1028  core_ops.to_doc =
1029  "Use a core file as a target. Specify the filename of the core file.";
1047 
1048  if (core_target)
1049  internal_error (__FILE__, __LINE__,
1050  _("init_core_ops: core target already exists (\"%s\")."),
1052  core_target = &core_ops;
1053 }
1054 
1055 void
1057 {
1058  init_core_ops ();
1059 
1060  add_target_with_completer (&core_ops, filename_completer);
1061 }
int default_check_format(bfd *abfd)
Definition: corelow.c:164
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:305
const struct target_desc *(* to_read_description)(struct target_ops *ops) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:769
const char * to_longname
Definition: target.h:433
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
void(* core_read_registers)(struct regcache *regcache, char *core_reg_sect, unsigned core_reg_size, int which, CORE_ADDR reg_addr)
Definition: gdbcore.h:217
void post_create_inferior(struct target_ops *target, int from_tty)
Definition: infcmd.c:406
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
int gdbarch_core_xfer_shared_libraries_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3477
void xfree(void *)
Definition: common-utils.c:97
void clear_exit_convenience_vars(void)
Definition: infrun.c:7550
struct target_section * sections_end
Definition: target.h:2277
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
int(* to_has_memory)(struct target_ops *)
Definition: target.h:652
void warning(const char *fmt,...)
Definition: errors.c:26
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
static void core_close_cleanup(void *ignore)
Definition: corelow.c:219
tuple inf
Definition: arm-linux.py:13
int(* to_has_stack)(struct target_ops *)
Definition: target.h:653
void push_target(struct target_ops *t)
Definition: target.c:664
static struct target_section_table * core_data
Definition: corelow.c:75
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:481
int build_section_table(struct bfd *some_bfd, struct target_section **start, struct target_section **end)
Definition: exec.c:470
int pid
Definition: inferior.h:299
int unpush_target(struct target_ops *t)
Definition: target.c:711
char * args
Definition: inferior.h:320
struct core_fns * next
Definition: gdbcore.h:227
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define CORELOW_PID
Definition: corelow.c:96
const struct target_desc * gdbarch_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
Definition: gdbarch.c:3806
static struct core_fns * sniff_core_bfd(bfd *)
Definition: corelow.c:128
ULONGEST gdbarch_core_xfer_shared_libraries_aix(struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
Definition: gdbarch.c:3508
void(* to_close)(struct target_ops *)
Definition: target.h:448
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
void _initialize_corelow(void)
Definition: corelow.c:1056
static char * core_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: corelow.c:958
gdb_byte * buf
Definition: corelow.c:649
int gdbarch_core_xfer_shared_libraries_aix_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3501
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:484
struct thread_info * first_thread_of_process(int pid)
Definition: thread.c:497
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2131
ULONGEST gdbarch_core_xfer_shared_libraries(struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
Definition: gdbarch.c:3484
#define _(String)
Definition: gdb_locale.h:40
static void get_core_register_section(struct regcache *regcache, const struct regset *regset, const char *name, int min_size, int which, const char *human_name, int required)
Definition: corelow.c:508
unsigned flags
Definition: regset.h:47
enum target_xfer_status section_table_xfer_memory_partial(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, struct target_section *sections, struct target_section *sections_end, const char *section_name)
Definition: exec.c:754
#define END_CATCH
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
int required
Definition: agent.c:66
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
void printf_filtered(const char *format,...)
Definition: utils.c:2388
Definition: ptid.h:35
static void core_info_proc(struct target_ops *ops, const char *args, enum info_proc_what request)
Definition: corelow.c:1010
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
Definition: regset.h:34
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
#define TRY
int thread_count(void)
Definition: thread.c:435
const char *const name
Definition: aarch64-tdep.c:68
char * gdbarch_core_pid_to_str(struct gdbarch *gdbarch, ptid_t ptid)
Definition: gdbarch.c:3532
ULONGEST pos
Definition: corelow.c:652
#define OPS_MAGIC
Definition: target.h:1233
int gdbarch_iterate_over_regset_sections_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3381
#define CATCH(EXCEPTION, MASK)
int write_files
Definition: exec.c:67
char * gnutarget
Definition: corefile.c:437
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void set_gdbarch_from_file(bfd *abfd)
Definition: arch-utils.c:573
#define exec_bfd
Definition: exec.h:32
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static void add_to_spuid_list(bfd *abfd, asection *asect, void *list_p)
Definition: corelow.c:657
static void add_to_thread_list(bfd *, asection *, void *)
Definition: corelow.c:228
int gdbarch_core_info_proc_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4522
static struct target_ops core_ops
Definition: corelow.c:93
bfd * gdb_bfd_fopen(const char *filename, const char *target, const char *mode, int fd)
Definition: gdb_bfd.c:675
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
int gdbarch_core_pid_to_str_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3525
void clear_solib(void)
Definition: solib.c:1222
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int(* core_sniffer)(struct core_fns *, bfd *)
Definition: gdbcore.h:194
struct target_section * sections
Definition: target.h:2276
target_xfer_status
Definition: target.h:219
void add_target_with_completer(struct target_ops *t, completer_ftype *completer)
Definition: target.c:368
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
#define REGSET_VARIABLE_SIZE
Definition: regset.h:52
static int core_has_memory(struct target_ops *ops)
Definition: corelow.c:990
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * to_doc
Definition: target.h:434
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
int gdbarch_gdb_signal_from_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3912
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
void deprecated_add_core_fns(struct core_fns *cf)
Definition: corelow.c:104
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
info_proc_what
Definition: defs.h:431
static enum target_xfer_status core_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: corelow.c:707
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
supply_regset_ftype * supply_regset
Definition: regset.h:42
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
static void core_open(const char *arg, int from_tty)
Definition: corelow.c:272
target_object
Definition: target.h:136
ULONGEST written
Definition: corelow.c:653
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
void gdbarch_core_info_proc(struct gdbarch *gdbarch, const char *args, enum info_proc_what what)
Definition: gdbarch.c:4529
int(* check_format)(bfd *)
Definition: gdbcore.h:188
struct target_ops * core_target
Definition: corefile.c:62
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static void core_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: corelow.c:480
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:151
char * current_directory
Definition: top.c:117
bfd_byte gdb_byte
Definition: common-types.h:38
void target_update_thread_list(void)
Definition: target.c:3283
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition: arch-utils.c:560
#define O_BINARY
Definition: defs.h:100
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
LONGEST len
Definition: corelow.c:651
ptid_t null_ptid
Definition: ptid.c:25
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
enum register_status regcache_register_status(const struct regcache *regcache, int regnum)
Definition: regcache.c:446
static struct core_fns * core_file_fns
Definition: corelow.c:57
ptid_t ptid
Definition: gdbthread.h:169
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
enum gdb_signal gdbarch_gdb_signal_from_target(struct gdbarch *gdbarch, int signo)
Definition: gdbarch.c:3919
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition: value.c:2347
enum strata to_stratum
Definition: target.h:650
static void get_core_registers_cb(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: corelow.c:575
void(* to_open)(const char *, int)
Definition: target.h:443
int offset
Definition: agent.c:65
void thread_command(char *tidstr, int from_tty)
Definition: thread.c:1555
void registers_changed(void)
Definition: regcache.c:624
static void init_core_ops(void)
Definition: corelow.c:1024
void validate_files(void)
Definition: corefile.c:163
static void core_close(struct target_ops *self)
Definition: corelow.c:190
int fake_pid_p
Definition: inferior.h:301
static int gdb_check_format(bfd *)
Definition: corelow.c:172
int gdb_open_cloexec(const char *filename, int flags, unsigned long mode)
Definition: filestuff.c:291
struct inferior * current_inferior(void)
Definition: inferior.c:57
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
const char * to_shortname
Definition: target.h:432
unsigned long long ULONGEST
Definition: common-types.h:53
void exit_inferior_silent(int pid)
Definition: inferior.c:293
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
int to_magic
Definition: target.h:1224
#define O_LARGEFILE
Definition: corelow.c:50
static int core_has_stack(struct target_ops *ops)
Definition: corelow.c:996
ULONGEST offset
Definition: corelow.c:650
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
static int core_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: corelow.c:931
const char * gdb_signal_to_string(enum gdb_signal)
Definition: signals.c:68
static const struct target_desc * core_read_description(struct target_ops *target)
Definition: corelow.c:942
bfd * core_bfd
Definition: corefile.c:58
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
void(* to_info_proc)(struct target_ops *, const char *, enum info_proc_what)
Definition: target.h:922
void target_preopen(int from_tty)
Definition: target.c:2171
void reinit_frame_cache(void)
Definition: frame.c:1687
static void core_files_info(struct target_ops *)
Definition: corelow.c:642
static LONGEST get_core_siginfo(bfd *abfd, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
Definition: corelow.c:683
int(* to_has_registers)(struct target_ops *)
Definition: target.h:654
int default_core_sniffer(struct core_fns *our_fns, bfd *abfd)
Definition: corelow.c:115
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
int gdbarch_core_read_description_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3799
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
long long LONGEST
Definition: common-types.h:52
struct target_ops * beneath
Definition: target.h:431
static void get_core_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: corelow.c:608
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void print_section_info(struct target_section_table *t, bfd *abfd)
Definition: exec.c:856
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void init_thread_list(void)
Definition: thread.c:198
void gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: gdbarch.c:3388
static int core_has_registers(struct target_ops *ops)
Definition: corelow.c:1002
const ULONGEST const LONGEST len
Definition: target.h:309