2004-11-12 Andrew Cagney <[email protected]>

[binutils.git] / gdb / arch-utils.c

diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index db3bae115fcd118e2a5a3f628dba3ec1b87f637e..6fc8511395da2bf857de509f942e746820594368 100644 (file)
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -1,7 +1,7 @@
 /* Dynamic architecture support for GDB, the GNU debugger.
 
 /* 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.
 
 
    This file is part of GDB.
 


@@ -30,6 +30,8 @@
 #include "regcache.h"
 #include "gdb_assert.h"
 #include "sim-regno.h"
 #include "regcache.h"
 #include "gdb_assert.h"
 #include "sim-regno.h"

+#include "gdbcore.h"
+#include "osabi.h"

 
 #include "version.h"
 
 
 #include "version.h"
 


@@ -58,13 +60,46 @@ legacy_store_return_value (struct type *type, struct regcache *regcache,
   DEPRECATED_STORE_RETURN_VALUE (type, b);
 }
 
   DEPRECATED_STORE_RETURN_VALUE (type, b);
 }
 

-

 int
 always_use_struct_convention (int gcc_p, struct type *value_type)
 {
   return 1;
 }
 
 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)
 
 int
 legacy_register_sim_regno (int regnum)


@@ -82,26 +117,14 @@ legacy_register_sim_regno (int regnum)
     return LEGACY_SIM_REGNO_IGNORE;
 }
 
     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;
 }
 
 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;
 }


@@ -118,13 +141,6 @@ generic_in_function_epilogue_p (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,
 void
 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
                                       struct regcache *regcache,


@@ -135,12 +151,6 @@ generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
   *rem_len = gdb_len;
 }
 
   *rem_len = gdb_len;
 }
 

-int
-generic_prologue_frameless_p (CORE_ADDR ip)
-{
-  return ip == SKIP_PROLOGUE (ip);
-}
-

 /* Helper functions for INNER_THAN */
 
 int
 /* Helper functions for INNER_THAN */
 
 int


@@ -193,30 +203,15 @@ default_double_format (struct gdbarch *gdbarch)
 
 /* Misc helper functions for targets. */
 
 
 /* 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
 CORE_ADDR

-generic_cannot_extract_struct_value_address (char *dummy)
+core_addr_identity (CORE_ADDR addr)

 {
 {

-  return 0;
+  return addr;

 }
 
 CORE_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 addr;
 }


@@ -227,17 +222,6 @@ no_op_reg_to_regnum (int reg)
   return reg;
 }
 
   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)
 {
 void
 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 {


@@ -288,13 +272,7 @@ int
 generic_register_size (int regnum)
 {
   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 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.  */
 }
 
 /* Assume all registers are adjacent.  */


@@ -317,40 +295,17 @@ generic_register_byte (int regnum)
 int
 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 {
 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
 #else

-  return IN_SIGTRAMP (pc, name);
+  return name && strcmp ("_sigtramp", name) == 0;

 #endif
 }
 
 int
 #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
 }
 
 int


@@ -380,8 +335,17 @@ default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
    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.  */
    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 const char endian_big[] = "big";
 static const char endian_little[] = "little";


@@ -400,7 +364,7 @@ static const char *set_endian_string;
 static void
 show_endian (char *args, int from_tty)
 {
 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
     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
                       (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
   else


@@ -443,9 +407,18 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 
 enum set_arch { set_arch_auto, set_arch_manual };
 
 
 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. */
 
 /* Called if the user enters ``show architecture'' without an
    argument. */


@@ -489,17 +462,72 @@ set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
   show_architecture (NULL, from_tty);
 }
 
   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)
 {
 /* 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");
     error ("Architecture of file not recognized.\n");

+  deprecated_current_gdbarch_select_hack (gdbarch);

 }
 
 /* Initialize the current architecture.  Update the ``set
 }
 
 /* Initialize the current architecture.  Update the ``set


@@ -619,7 +647,7 @@ initialize_current_architecture (void)
 
 /* Initialize a gdbarch info to values that will be automatically
    overridden.  Note: Originally, this ``struct info'' was initialized
 
 /* 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.  */
 
    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
    can explicitly set each field to a well defined value is used.  */
 


@@ -631,6 +659,54 @@ gdbarch_info_init (struct gdbarch_info *info)
   info->osabi = GDB_OSABI_UNINITIALIZED;
 }
 
   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 */
 /* */
 
 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */