/* Dynamic architecture support for GDB, the GNU debugger.
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
if (debug_displaced)
{
- fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ",
- paddr_nz (from), paddr_nz (to));
+ fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
+ paddress (gdbarch, from), paddress (gdbarch, to));
displaced_step_dump_bytes (gdb_stdlog, buf, len);
}
xfree (closure);
}
+int
+default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
+ struct displaced_step_closure *closure)
+{
+ return !gdbarch_software_single_step_p (gdbarch);
+}
CORE_ADDR
displaced_step_at_entry_point (struct gdbarch *gdbarch)
addr = entry_point_address ();
- /* Make certain that the address points at real code, and not a
- function descriptor. */
- addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
-
/* Inferior calls also use the entry point as a breakpoint location.
We don't want displaced stepping to interfere with those
breakpoints, so leave space. */
}
int
-generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
+generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
+ CORE_ADDR pc, char *name)
{
return 0;
}
/* Misc helper functions for targets. */
CORE_ADDR
-core_addr_identity (CORE_ADDR addr)
+core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
{
return addr;
}
enum bfd_endian
selected_byte_order (void)
{
- if (target_byte_order_user != BFD_ENDIAN_UNKNOWN)
- return gdbarch_byte_order (current_gdbarch);
- else
- return BFD_ENDIAN_UNKNOWN;
+ return target_byte_order_user;
}
/* Called by ``show endian''. */
const char *value)
{
if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently big endian)\n"));
else
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently little endian)\n"));
else
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (target_byte_order_user == BFD_ENDIAN_BIG)
fprintf_unfiltered (file,
_("The target is assumed to be big endian\n"));
else
}
/* Given SELECTED, a currently selected BFD architecture, and
- FROM_TARGET, a BFD architecture reported by the target description,
- return what architecture to use. Either may be NULL; if both are
- specified, we use the more specific. If the two are obviously
- incompatible, warn the user. */
+ TARGET_DESC, the current target description, return what
+ architecture to use.
+
+ SELECTED may be NULL, in which case we return the architecture
+ associated with TARGET_DESC. If SELECTED specifies a variant
+ of the architecture associtated with TARGET_DESC, return the
+ more specific of the two.
+
+ If SELECTED is a different architecture, but it is accepted as
+ compatible by the target, we can use the target architecture.
+
+ If SELECTED is obviously incompatible, warn the user. */
static const struct bfd_arch_info *
-choose_architecture_for_target (const struct bfd_arch_info *selected,
- const struct bfd_arch_info *from_target)
+choose_architecture_for_target (const struct target_desc *target_desc,
+ const struct bfd_arch_info *selected)
{
+ const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
const struct bfd_arch_info *compat1, *compat2;
if (selected == NULL)
if (compat1 == NULL && compat2 == NULL)
{
+ /* BFD considers the architectures incompatible. Check our target
+ description whether it accepts SELECTED as compatible anyway. */
+ if (tdesc_compatible_p (target_desc, selected))
+ return from_target;
+
warning (_("Selected architecture %s is not compatible "
"with reported target architecture %s"),
selected->printable_name, from_target->printable_name);
show_architecture (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- const char *arch;
- arch = gdbarch_bfd_arch_info (current_gdbarch)->printable_name;
if (target_architecture_user == NULL)
fprintf_filtered (file, _("\
-The target architecture is set automatically (currently %s)\n"), arch);
+The target architecture is set automatically (currently %s)\n"),
+ gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
else
fprintf_filtered (file, _("\
-The target architecture is assumed to be %s\n"), arch);
+The target architecture is assumed to be %s\n"), set_architecture_string);
}
/* If it is the same old architecture, accept the request (but don't
swap anything). */
- if (new_gdbarch == current_gdbarch)
+ if (new_gdbarch == target_gdbarch)
{
if (gdbarch_debug)
fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
- "Architecture 0x%08lx (%s) unchanged\n",
- (long) new_gdbarch,
+ "Architecture %s (%s) unchanged\n",
+ host_address_to_string (new_gdbarch),
gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
return 1;
}
/* It's a new architecture, swap it in. */
if (gdbarch_debug)
fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
- "New architecture 0x%08lx (%s) selected\n",
- (long) new_gdbarch,
+ "New architecture %s (%s) selected\n",
+ host_address_to_string (new_gdbarch),
gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
- deprecated_current_gdbarch_select_hack (new_gdbarch);
+ deprecated_target_gdbarch_select_hack (new_gdbarch);
return 1;
}
if (gdbarch == NULL)
error (_("Architecture of file not recognized."));
- deprecated_current_gdbarch_select_hack (gdbarch);
+ deprecated_target_gdbarch_select_hack (gdbarch);
}
/* Initialize the current architecture. Update the ``set
/* From the target. */
if (info->target_desc != NULL)
info->bfd_arch_info = choose_architecture_for_target
- (info->bfd_arch_info, tdesc_architecture (info->target_desc));
+ (info->target_desc, info->bfd_arch_info);
/* From the default. */
if (info->bfd_arch_info == NULL)
info->bfd_arch_info = default_bfd_arch;
info->byte_order_for_code = info->byte_order;
/* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
+ /* From the manual override, or from file. */
if (info->osabi == GDB_OSABI_UNINITIALIZED)
info->osabi = gdbarch_lookup_osabi (info->abfd);
+ /* From the target. */
+ if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
+ info->osabi = tdesc_osabi (info->target_desc);
+ /* From the configured default. */
+#ifdef GDB_OSABI_DEFAULT
+ if (info->osabi == GDB_OSABI_UNKNOWN)
+ info->osabi = GDB_OSABI_DEFAULT;
+#endif
/* Must have at least filled in the architecture. */
gdb_assert (info->bfd_arch_info != NULL);
}
+/* Return "current" architecture. If the target is running, this is the
+ architecture of the selected frame. Otherwise, the "current" architecture
+ defaults to the target architecture.
+
+ This function should normally be called solely by the command interpreter
+ routines to determine the architecture to execute a command in. */
+struct gdbarch *
+get_current_arch (void)
+{
+ if (has_stack_frames ())
+ return get_frame_arch (get_selected_frame (NULL));
+ else
+ return target_gdbarch;
+}
+
+int
+default_has_shared_address_space (struct gdbarch *gdbarch)
+{
+ /* Simply say no. In most unix-like targets each inferior/process
+ has its own address space. */
+ return 0;
+}
+
+int
+default_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
+ CORE_ADDR addr, int *isize, char **msg)
+{
+ /* We don't know if maybe the target has some way to do fast
+ tracepoints that doesn't need gdbarch, so always say yes. */
+ if (msg)
+ *msg = NULL;
+ return 1;
+}
+
+void
+default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
+ int *kindptr)
+{
+ gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr);
+}
+
/* */
extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
projects / binutils.git / blobdiff