/* Core dump and executable file functions below target vector, for GDB.
- Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software Foundation,
- Inc.
+ Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+ 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
+ Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "arch-utils.h"
#include "symfile.h"
#include "exec.h"
#include "readline/readline.h"
-#include "observer.h"
#include "gdb_assert.h"
#include "exceptions.h"
#include "solib.h"
+#include "filenames.h"
-#ifndef O_BINARY
-#define O_BINARY 0
-#endif
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
static void core_close_cleanup (void *ignore);
-static void get_core_registers (int);
+static void get_core_registers (struct regcache *, int);
static void add_to_thread_list (bfd *, asection *, void *);
-static int ignore (CORE_ADDR, bfd_byte *);
-
static int core_file_thread_alive (ptid_t tid);
static void init_core_ops (void);
/* Clear out solib state while the bfd is still open. See
comments in clear_solib in solib.c. */
-#ifdef CLEAR_SOLIB
- CLEAR_SOLIB ();
-#else
clear_solib ();
-#endif
name = bfd_get_filename (core_bfd);
if (!bfd_close (core_bfd))
core_close (0/*ignored*/);
}
-/* Stub function for catch_errors around shared library hacking. FROM_TTYP
- is really an int * which points to from_tty. */
-
-static int
-solib_add_stub (void *from_ttyp)
-{
-#ifdef SOLIB_ADD
- SOLIB_ADD (NULL, *(int *) from_ttyp, ¤t_target, auto_solib_add);
-#else
- solib_add (NULL, *(int *)from_ttyp, ¤t_target, auto_solib_add);
-#endif
- re_enable_breakpoints_in_shlibs ();
- return 0;
-}
-
/* Look for sections whose names start with `.reg/' so that we can extract the
list of threads in a core file. */
}
filename = tilde_expand (filename);
- if (filename[0] != '/')
+ if (!IS_ABSOLUTE_PATH(filename))
{
- temp = concat (current_directory, "/", filename, NULL);
+ temp = concat (current_directory, "/", filename, (char *)NULL);
xfree (filename);
filename = temp;
}
if (scratch_chan < 0)
perror_with_name (filename);
- temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
+ temp_bfd = bfd_fopen (filename, gnutarget,
+ write_files ? FOPEN_RUB : FOPEN_RB,
+ scratch_chan);
if (temp_bfd == NULL)
perror_with_name (filename);
/* This is done first, before anything has a chance to query the
inferior for information such as symbols. */
- observer_notify_inferior_created (&core_ops, from_tty);
+ post_create_inferior (&core_ops, from_tty);
p = bfd_core_file_failing_command (core_bfd);
if (p)
value is called ``target_signal'' and this function got the
name ..._from_host(). */
printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
- target_signal_to_string (target_signal_from_host (siggy)));
+ target_signal_to_string (
+ gdbarch_target_signal_from_host (core_gdbarch, siggy)));
/* Build up thread list from BFD sections. */
if (ontop)
{
/* Fetch all registers from core file. */
- target_fetch_registers (-1);
-
- /* Add symbols and section mappings for any shared libraries. */
- catch_errors (solib_add_stub, &from_tty, (char *) 0, RETURN_MASK_ALL);
+ target_fetch_registers (get_current_regcache (), -1);
/* Now, set up the frame cache, and print the top of stack. */
- flush_cached_frames ();
- select_frame (get_current_frame ());
+ reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
}
else
have a section by the appropriate name. Otherwise, just do nothing. */
static void
-get_core_register_section (char *name,
+get_core_register_section (struct regcache *regcache,
+ char *name,
int which,
char *human_name,
int required)
return;
}
- regset->supply_regset (regset, current_regcache, -1, contents, size);
+ regset->supply_regset (regset, regcache, -1, contents, size);
return;
}
gdb_assert (core_vec);
- core_vec->core_read_registers (contents, size, which,
+ core_vec->core_read_registers (regcache, contents, size, which,
((CORE_ADDR)
bfd_section_vma (core_bfd, section)));
}
/* We just get all the registers, so we don't use regno. */
static void
-get_core_registers (int regno)
+get_core_registers (struct regcache *regcache, int regno)
{
- int status;
+ int i;
if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
&& (core_vec == NULL || core_vec->core_read_registers == NULL))
return;
}
- get_core_register_section (".reg", 0, "general-purpose", 1);
- get_core_register_section (".reg2", 2, "floating-point", 0);
- get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
-
- deprecated_registers_fetched ();
+ get_core_register_section (regcache,
+ ".reg", 0, "general-purpose", 1);
+ get_core_register_section (regcache,
+ ".reg2", 2, "floating-point", 0);
+ get_core_register_section (regcache,
+ ".reg-xfp", 3, "extended floating-point", 0);
+ get_core_register_section (regcache,
+ ".reg-ppc-vmx", 3, "ppc Altivec", 0);
+ get_core_register_section (regcache,
+ ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
+
+ /* Supply dummy value for all registers not found in the core. */
+ for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
+ if (!regcache_valid_p (regcache, i))
+ regcache_raw_supply (regcache, i, NULL);
}
static void
\f
static LONGEST
core_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, void *readbuf,
- const void *writebuf, ULONGEST offset, LONGEST len)
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
switch (object)
{
case TARGET_OBJECT_MEMORY:
if (readbuf)
- return (*ops->deprecated_xfer_memory) (offset, readbuf, len,
- 0/*write*/, NULL, ops);
+ return (*ops->deprecated_xfer_memory) (offset, readbuf,
+ len, 0/*read*/, NULL, ops);
if (writebuf)
- return (*ops->deprecated_xfer_memory) (offset, readbuf, len,
- 1/*write*/, NULL, ops);
+ return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
+ len, 1/*write*/, NULL, ops);
return -1;
case TARGET_OBJECT_AUXV:
}
return -1;
+ case TARGET_OBJECT_LIBRARIES:
+ if (core_gdbarch
+ && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
+ {
+ if (writebuf)
+ return -1;
+ return
+ gdbarch_core_xfer_shared_libraries (core_gdbarch,
+ readbuf, offset, len);
+ }
+ /* FALL THROUGH */
+
default:
if (ops->beneath != NULL)
return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
`gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
static int
-ignore (CORE_ADDR addr, bfd_byte *contents)
+ignore (struct bp_target_info *bp_tgt)
{
return 0;
}
return 1;
}
+/* Ask the current architecture what it knows about this core file.
+ That will be used, in turn, to pick a better architecture. This
+ wrapper could be avoided if targets got a chance to specialize
+ core_ops. */
+
+static const struct target_desc *
+core_read_description (struct target_ops *target)
+{
+ if (gdbarch_core_read_description_p (current_gdbarch))
+ return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
+
+ return NULL;
+}
+
/* Fill in core_ops with its defined operations and properties. */
static void
core_ops.to_remove_breakpoint = ignore;
core_ops.to_create_inferior = find_default_create_inferior;
core_ops.to_thread_alive = core_file_thread_alive;
+ core_ops.to_read_description = core_read_description;
core_ops.to_stratum = core_stratum;
core_ops.to_has_memory = 1;
core_ops.to_has_stack = 1;
projects / deliverable / binutils-gdb.git / blobdiff