/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
- Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+ Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "gdb_assert.h"
#include "sim-regno.h"
+#include "gdbcore.h"
+#include "osabi.h"
#include "version.h"
DEPRECATED_STORE_RETURN_VALUE (type, b);
}
-
int
always_use_struct_convention (int gcc_p, struct type *value_type)
{
return 1;
}
+enum return_value_convention
+legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
+ struct regcache *regcache, void *readbuf,
+ const void *writebuf)
+{
+ /* NOTE: cagney/2004-06-13: The gcc_p parameter to
+ USE_STRUCT_CONVENTION isn't used. */
+ int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+ || TYPE_CODE (valtype) == TYPE_CODE_UNION
+ || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
+ && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
+
+ if (writebuf != NULL)
+ {
+ gdb_assert (!struct_return);
+ /* NOTE: cagney/2004-06-13: See stack.c:return_command. Old
+ architectures don't expect STORE_RETURN_VALUE to handle small
+ structures. Should not be called with such types. */
+ gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
+ && TYPE_CODE (valtype) != TYPE_CODE_UNION);
+ STORE_RETURN_VALUE (valtype, regcache, writebuf);
+ }
+
+ if (readbuf != NULL)
+ {
+ gdb_assert (!struct_return);
+ EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
+ }
+
+ if (struct_return)
+ return RETURN_VALUE_STRUCT_CONVENTION;
+ else
+ return RETURN_VALUE_REGISTER_CONVENTION;
+}
int
legacy_register_sim_regno (int regnum)
return LEGACY_SIM_REGNO_IGNORE;
}
-int
-generic_frameless_function_invocation_not (struct frame_info *fi)
-{
- return 0;
-}
-
-int
-generic_return_value_on_stack_not (struct type *type)
-{
- return 0;
-}
-
CORE_ADDR
generic_skip_trampoline_code (CORE_ADDR pc)
{
return 0;
}
-int
-generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
+CORE_ADDR
+generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
{
return 0;
}
return 0;
}
-#if defined (CALL_DUMMY)
-LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
-#else
-LONGEST legacy_call_dummy_words[1];
-#endif
-int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
-
void
generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
struct regcache *regcache,
*rem_len = gdb_len;
}
-int
-generic_prologue_frameless_p (CORE_ADDR ip)
-{
- return ip == SKIP_PROLOGUE (ip);
-}
-
/* Helper functions for INNER_THAN */
int
/* Misc helper functions for targets. */
-int
-deprecated_register_convertible_not (int num)
-{
- return 0;
-}
-
-
-/* Under some ABI's that specify the `struct convention' for returning
- structures by value, by the time we've returned from the function,
- the return value is sitting there in the caller's buffer, but GDB
- has no way to find the address of that buffer.
-
- On such architectures, use this function as your
- extract_struct_value_address method. When asked to a struct
- returned by value in this fashion, GDB will print a nice error
- message, instead of garbage. */
CORE_ADDR
-generic_cannot_extract_struct_value_address (char *dummy)
+core_addr_identity (CORE_ADDR addr)
{
- return 0;
+ return addr;
}
CORE_ADDR
-core_addr_identity (CORE_ADDR addr)
+convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct target_ops *targ)
{
return addr;
}
return reg;
}
-CORE_ADDR
-init_frame_pc_default (int fromleaf, struct frame_info *prev)
-{
- if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
- return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
- else if (get_next_frame (prev) != NULL)
- return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
- else
- return read_pc ();
-}
-
void
default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
{
generic_register_size (int regnum)
{
gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
- if (gdbarch_register_type_p (current_gdbarch))
- return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
- else
- /* FIXME: cagney/2003-03-01: Once all architectures implement
- gdbarch_register_type(), this entire function can go away. It
- is made obsolete by register_size(). */
- return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
+ return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
}
/* Assume all registers are adjacent. */
int
legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
-#if !defined (IN_SIGTRAMP)
- if (SIGTRAMP_START_P ())
- return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
- else
- return name && strcmp ("_sigtramp", name) == 0;
+#if defined (DEPRECATED_IN_SIGTRAMP)
+ return DEPRECATED_IN_SIGTRAMP (pc, name);
#else
- return IN_SIGTRAMP (pc, name);
+ return name && strcmp ("_sigtramp", name) == 0;
#endif
}
int
-legacy_convert_register_p (int regnum, struct type *type)
+generic_convert_register_p (int regnum, struct type *type)
{
- return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
-}
-
-void
-legacy_register_to_value (struct frame_info *frame, int regnum,
- struct type *type, void *to)
-{
- char from[MAX_REGISTER_SIZE];
- frame_read_register (frame, regnum, from);
- DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
-}
-
-void
-legacy_value_to_register (struct frame_info *frame, int regnum,
- struct type *type, const void *tmp)
-{
- char to[MAX_REGISTER_SIZE];
- char *from = alloca (TYPE_LENGTH (type));
- memcpy (from, from, TYPE_LENGTH (type));
- DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
- put_frame_register (frame, regnum, to);
+ return 0;
}
int
The choice of initial value is entirely arbitrary. During startup,
the function initialize_current_architecture() updates this value
based on default byte-order information extracted from BFD. */
-int target_byte_order = BFD_ENDIAN_BIG;
-int target_byte_order_auto = 1;
+static int target_byte_order = BFD_ENDIAN_BIG;
+static int target_byte_order_auto = 1;
+
+enum bfd_endian
+selected_byte_order (void)
+{
+ if (target_byte_order_auto)
+ return BFD_ENDIAN_UNKNOWN;
+ else
+ return target_byte_order;
+}
static const char endian_big[] = "big";
static const char endian_little[] = "little";
static void
show_endian (char *args, int from_tty)
{
- if (TARGET_BYTE_ORDER_AUTO)
+ if (target_byte_order_auto)
printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
(TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
else
enum set_arch { set_arch_auto, set_arch_manual };
-int target_architecture_auto = 1;
+static int target_architecture_auto = 1;
+
+static const char *set_architecture_string;
-const char *set_architecture_string;
+const char *
+selected_architecture_name (void)
+{
+ if (target_architecture_auto)
+ return NULL;
+ else
+ return set_architecture_string;
+}
/* Called if the user enters ``show architecture'' without an
argument. */
show_architecture (NULL, from_tty);
}
+/* Try to select a global architecture that matches "info". Return
+ non-zero if the attempt succeds. */
+int
+gdbarch_update_p (struct gdbarch_info info)
+{
+ struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
+
+ /* If there no architecture by that name, reject the request. */
+ if (new_gdbarch == NULL)
+ {
+ if (gdbarch_debug)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
+ "Architecture not found\n");
+ return 0;
+ }
+
+ /* If it is the same old architecture, accept the request (but don't
+ swap anything). */
+ if (new_gdbarch == current_gdbarch)
+ {
+ if (gdbarch_debug)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
+ "Architecture 0x%08lx (%s) unchanged\n",
+ (long) 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,
+ gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
+ deprecated_current_gdbarch_select_hack (new_gdbarch);
+
+ return 1;
+}
+
+/* Return the architecture for ABFD. If no suitable architecture
+ could be find, return NULL. */
+
+struct gdbarch *
+gdbarch_from_bfd (bfd *abfd)
+{
+ struct gdbarch *old_gdbarch = current_gdbarch;
+ struct gdbarch *new_gdbarch;
+ struct gdbarch_info info;
+
+ gdbarch_info_init (&info);
+ info.abfd = abfd;
+ return gdbarch_find_by_info (info);
+}
+
/* Set the dynamic target-system-dependent parameters (architecture,
byte-order) using information found in the BFD */
void
set_gdbarch_from_file (bfd *abfd)
{
- struct gdbarch_info info;
- gdbarch_info_init (&info);
- info.abfd = abfd;
- if (! gdbarch_update_p (info))
+ struct gdbarch *gdbarch;
+
+ gdbarch = gdbarch_from_bfd (abfd);
+ if (gdbarch == NULL)
error ("Architecture of file not recognized.\n");
+ deprecated_current_gdbarch_select_hack (gdbarch);
}
/* Initialize the current architecture. Update the ``set
/* Initialize a gdbarch info to values that will be automatically
overridden. Note: Originally, this ``struct info'' was initialized
- using memset(0). Unfortunatly, that ran into problems, namely
+ using memset(0). Unfortunately, that ran into problems, namely
BFD_ENDIAN_BIG is zero. An explicit initialization function that
can explicitly set each field to a well defined value is used. */
info->osabi = GDB_OSABI_UNINITIALIZED;
}
+/* Similar to init, but this time fill in the blanks. Information is
+ obtained from the specified architecture, global "set ..." options,
+ and explicitly initialized INFO fields. */
+
+void
+gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
+{
+ /* "(gdb) set architecture ...". */
+ if (info->bfd_arch_info == NULL
+ && !target_architecture_auto
+ && gdbarch != NULL)
+ info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
+ if (info->bfd_arch_info == NULL
+ && info->abfd != NULL
+ && bfd_get_arch (info->abfd) != bfd_arch_unknown
+ && bfd_get_arch (info->abfd) != bfd_arch_obscure)
+ info->bfd_arch_info = bfd_get_arch_info (info->abfd);
+ if (info->bfd_arch_info == NULL
+ && gdbarch != NULL)
+ info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
+
+ /* "(gdb) set byte-order ...". */
+ if (info->byte_order == BFD_ENDIAN_UNKNOWN
+ && !target_byte_order_auto
+ && gdbarch != NULL)
+ info->byte_order = gdbarch_byte_order (gdbarch);
+ /* From the INFO struct. */
+ if (info->byte_order == BFD_ENDIAN_UNKNOWN
+ && info->abfd != NULL)
+ info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
+ : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
+ : BFD_ENDIAN_UNKNOWN);
+ /* From the current target. */
+ if (info->byte_order == BFD_ENDIAN_UNKNOWN
+ && gdbarch != NULL)
+ info->byte_order = gdbarch_byte_order (gdbarch);
+
+ /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
+ if (info->osabi == GDB_OSABI_UNINITIALIZED)
+ info->osabi = gdbarch_lookup_osabi (info->abfd);
+ if (info->osabi == GDB_OSABI_UNINITIALIZED
+ && gdbarch != NULL)
+ info->osabi = gdbarch_osabi (gdbarch);
+
+ /* Must have at least filled in the architecture. */
+ gdb_assert (info->bfd_arch_info != NULL);
+}
+
/* */
extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
projects / binutils.git / blobdiff