Import ``maint print arch'' from trunk.

Import dump of macro values from trunk.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 6b51c40aa624934b0fa262b23dc876587c131cbe..2e0761c0d9d423f7d4a3d03558840c07c666383f 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,49 @@
+Fri Jun  9 15:06:37 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbarch.sh (struct gdbarch): Add member dump_tdep.
+       (struct gdbarch_registration): Ditto.
+       (gdbarch_dump): Add ui_file and gdbarch arguments.  Add support
+       for external dump functions.  Dump the macro value.  Call target
+       dump routine.
+       (gdbarch_register): New function.
+       (gdbarch_registrary): Replace gdbarch_init_registrary.
+       * gdbarch.h, gdbarch.c: Re-generate.
+       * arch-utils.c (set_arch): Update.
+       
+       * mips-tdep.c (mips_dump_tdep): New function. Move dump code here.
+       (mips_gdbarch_init): From here.
+
+       * maint.c (maintenance_print_architecture): New function.
+       (_initialize_maint_cmds): Add command ``maintenance print
+       architecture''.
+
+Wed Jun  7 11:34:54 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * arch-utils.c (target_byte_order, target_byte_order_auto,
+       show_endian, set_endian, set_endian_big, set_endian_little,
+       set_endian_auto, set_endian_from_file, enum set_arch,
+       target_architecture_auto, set_architecture_string,
+       target_architecture_hook, target_architecture, arch_ok, set_arch,
+       set_architecture_from_arch_mach, set_architecture_from_file,
+       show_architecture, set_architecture, info_architecture,
+       set_gdbarch_from_file, initialize_current_architecture): Copy from
+       gdbarch.c.  Rewrite ``set architecture'' and ``set endian''
+       commands to use enums.
+       (_initialize_gdbarch_utils): Fix name.
+       * arch-utils.h (set_architecture_from_arch_mach,
+       target_architecture_hook): Copy from gdbarch.h.
+       * gdbarch.sh: Update.
+       * gdbarch.h, gdbarch.c: Re-generate.
+
+Tue Jun  6 16:21:14 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbarch.sh (generic_register_convertible_not,
+       frame_num_args_unknown): Move from here.
+       * arch-utils.c (generic_register_convertible_not,
+       frame_num_args_unknown): To here.
+       * arch-utils.h (frame_num_args_unknown): Add declaration.
+       * gdbarch.h, gdbarch.c: Re-generate.
+
 2000-06-05  Daniel Berlin  <dan@cgsoftware.com>
 
        * c-exp.y (yylex): template handling fixes.

diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index be2433d37e6787b1f602d4d4e587c70869196ae8..047f2a2dc469543903aa75d961c22ae004904a0b 100644 (file)
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -41,6 +41,8 @@
 #include "symfile.h"           /* for overlay functions */
 #endif
 
+#include "version.h"
+
 #include "floatformat.h"
 
 /* Convenience macro for allocting typesafe memory. */
@@ -206,11 +208,488 @@ default_double_format (struct gdbarch *gdbarch)
     }
 }
 
+/* Misc helper functions for targets. */
+
+int
+frame_num_args_unknown (fi)
+     struct frame_info *fi;
+{
+  return -1;
+}
+
+
+int
+generic_register_convertible_not (num)
+     int num;
+{
+  return 0;
+}
+  
+
+/* Functions to manipulate the endianness of the target.  */
+
+#ifdef TARGET_BYTE_ORDER_SELECTABLE
+/* compat - Catch old targets that expect a selectable byte-order to
+   default to BIG_ENDIAN */
+#ifndef TARGET_BYTE_ORDER_DEFAULT
+#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
+#endif
+#endif
+#if !TARGET_BYTE_ORDER_SELECTABLE_P
+#ifndef TARGET_BYTE_ORDER_DEFAULT
+/* compat - Catch old non byte-order selectable targets that do not
+   define TARGET_BYTE_ORDER_DEFAULT and instead expect
+   TARGET_BYTE_ORDER to be used as the default.  For targets that
+   defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
+   below will get a strange compiler warning. */
+#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
+#endif
+#endif
+#ifndef TARGET_BYTE_ORDER_DEFAULT
+#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
+#endif
+/* ``target_byte_order'' is only used when non- multi-arch.
+   Multi-arch targets obtain the current byte order using
+   TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
+int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
+int target_byte_order_auto = 1;
+
+static const char endian_big[] = "big";
+static const char endian_little[] = "little";
+static const char endian_auto[] = "auto";
+static const char *endian_enum[] =
+{
+  endian_big,
+  endian_little,
+  endian_auto,
+  NULL,
+};
+static const char *set_endian_string;
+
+/* Called by ``show endian''.  */
+
+static void
+show_endian (char *args, int from_tty)
+{
+  if (TARGET_BYTE_ORDER_AUTO)
+    printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
+                      (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
+  else
+    printf_unfiltered ("The target is assumed to be %s endian\n",
+                      (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
+}
+
+static void
+set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
+{
+  if (!TARGET_BYTE_ORDER_SELECTABLE_P)
+    {
+      printf_unfiltered ("Byte order is not selectable.");
+    }
+  else if (set_endian_string == endian_auto)
+    {
+      target_byte_order_auto = 1;
+    }
+  else if (set_endian_string == endian_little)
+    {
+      target_byte_order_auto = 0;
+      if (GDB_MULTI_ARCH)
+       {
+         struct gdbarch_info info;
+         memset (&info, 0, sizeof info);
+         info.byte_order = LITTLE_ENDIAN;
+         gdbarch_update (info);
+       }
+      else
+       {
+         target_byte_order = LITTLE_ENDIAN;
+       }
+    }
+  else if (set_endian_string == endian_big)
+    {
+      target_byte_order_auto = 0;
+      if (GDB_MULTI_ARCH)
+       {
+         struct gdbarch_info info;
+         memset (&info, 0, sizeof info);
+         info.byte_order = BIG_ENDIAN;
+         gdbarch_update (info);
+       }
+      else
+       {
+         target_byte_order = BIG_ENDIAN;
+       }
+    }
+  else
+    internal_error ("set_endian: bad value");
+  show_endian (NULL, from_tty);
+}
+
+/* Set the endianness from a BFD.  */
+
+static void
+set_endian_from_file (bfd *abfd)
+{
+  if (GDB_MULTI_ARCH)
+    internal_error ("set_endian_from_file: not for multi-arch");
+  if (TARGET_BYTE_ORDER_SELECTABLE_P)
+    {
+      int want;
+      
+      if (bfd_big_endian (abfd))
+       want = BIG_ENDIAN;
+      else
+       want = LITTLE_ENDIAN;
+      if (TARGET_BYTE_ORDER_AUTO)
+       target_byte_order = want;
+      else if (TARGET_BYTE_ORDER != want)
+       warning ("%s endian file does not match %s endian target.",
+                want == BIG_ENDIAN ? "big" : "little",
+                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
+    }
+  else
+    {
+      if (bfd_big_endian (abfd)
+         ? TARGET_BYTE_ORDER != BIG_ENDIAN
+         : TARGET_BYTE_ORDER == BIG_ENDIAN)
+       warning ("%s endian file does not match %s endian target.",
+                bfd_big_endian (abfd) ? "big" : "little",
+                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
+    }
+}
+
+
+/* Functions to manipulate the architecture of the target */
+
+enum set_arch { set_arch_auto, set_arch_manual };
+
+int target_architecture_auto = 1;
+
+const char *set_architecture_string;
+
+/* Old way of changing the current architecture. */
+
+extern const struct bfd_arch_info bfd_default_arch_struct;
+const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
+int (*target_architecture_hook) (const struct bfd_arch_info *ap);
+
+static int
+arch_ok (const struct bfd_arch_info *arch)
+{
+  if (GDB_MULTI_ARCH)
+    internal_error ("arch_ok: not multi-arched");
+  /* Should be performing the more basic check that the binary is
+     compatible with GDB. */
+  /* Check with the target that the architecture is valid. */
+  return (target_architecture_hook == NULL
+         || target_architecture_hook (arch));
+}
+
+static void
+set_arch (const struct bfd_arch_info *arch,
+          enum set_arch type)
+{
+  if (GDB_MULTI_ARCH)
+    internal_error ("set_arch: not multi-arched");
+  switch (type)
+    {
+    case set_arch_auto:
+      if (!arch_ok (arch))
+       warning ("Target may not support %s architecture",
+                arch->printable_name);
+      target_architecture = arch;
+      break;
+    case set_arch_manual:
+      if (!arch_ok (arch))
+       {
+         printf_unfiltered ("Target does not support `%s' architecture.\n",
+                            arch->printable_name);
+       }
+      else
+       {
+         target_architecture_auto = 0;
+         target_architecture = arch;
+       }
+      break;
+    }
+  if (gdbarch_debug)
+    gdbarch_dump (current_gdbarch, gdb_stdlog);
+}
+
+/* Set the architecture from arch/machine (deprecated) */
+
+void
+set_architecture_from_arch_mach (enum bfd_architecture arch,
+                                unsigned long mach)
+{
+  const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
+  if (GDB_MULTI_ARCH)
+    internal_error ("set_architecture_from_arch_mach: not multi-arched");
+  if (wanted != NULL)
+    set_arch (wanted, set_arch_manual);
+  else
+    internal_error ("gdbarch: hardwired architecture/machine not reconized");
+}
+
+/* Set the architecture from a BFD (deprecated) */
+
+static void
+set_architecture_from_file (bfd *abfd)
+{
+  const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
+  if (GDB_MULTI_ARCH)
+    internal_error ("set_architecture_from_file: not multi-arched");
+  if (target_architecture_auto)
+    {
+      set_arch (wanted, set_arch_auto);
+    }
+  else if (wanted != target_architecture)
+    {
+      warning ("%s architecture file may be incompatible with %s target.",
+              wanted->printable_name,
+              target_architecture->printable_name);
+    }
+}
+
+
+/* Called if the user enters ``show architecture'' without an
+   argument. */
+
+static void
+show_architecture (char *args, int from_tty)
+{
+  const char *arch;
+  arch = TARGET_ARCHITECTURE->printable_name;
+  if (target_architecture_auto)
+    printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
+  else
+    printf_filtered ("The target architecture is assumed to be %s\n", arch);
+}
+
+
+/* Called if the user enters ``set architecture'' with or without an
+   argument. */
+
+static void
+set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
+{
+  if (strcmp (set_architecture_string, "auto") == 0)
+    {
+      target_architecture_auto = 1;
+    }
+  else if (GDB_MULTI_ARCH)
+    {
+      struct gdbarch_info info;
+      memset (&info, 0, sizeof info);
+      info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
+      if (info.bfd_arch_info == NULL)
+       internal_error ("set_architecture: bfd_scan_arch failed");
+      if (gdbarch_update (info))
+       target_architecture_auto = 0;
+      else
+       printf_unfiltered ("Architecture `%s' not reconized.\n",
+                          set_architecture_string);
+    }
+  else
+    {
+      const struct bfd_arch_info *arch
+       = bfd_scan_arch (set_architecture_string);
+      if (arch == NULL)
+       internal_error ("set_architecture: bfd_scan_arch failed");
+      set_arch (arch, set_arch_manual);
+    }
+  show_architecture (NULL, from_tty);
+}
+
+/* Called if the user enters ``info architecture'' without an argument. */
+
+static void
+info_architecture (char *args, int from_tty)
+{
+  printf_filtered ("Available architectures are:\n");
+  if (GDB_MULTI_ARCH)
+    {
+      const char **arches = gdbarch_printable_names ();
+      const char **arch;
+      for (arch = arches; *arch != NULL; arch++)
+       {
+         printf_filtered (" %s", *arch);
+       }
+      free (arches);
+    }
+  else
+    {
+      enum bfd_architecture a;
+      for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
+       {
+         const struct bfd_arch_info *ap;
+         for (ap = bfd_lookup_arch (a, 0);
+              ap != NULL;
+              ap = ap->next)
+           {
+             printf_filtered (" %s", ap->printable_name);
+             ap = ap->next;
+           }
+       }
+    }
+  printf_filtered ("\n");
+}
+
+/* Set the dynamic target-system-dependant parameters (architecture,
+   byte-order) using information found in the BFD */
+
+void
+set_gdbarch_from_file (abfd)
+     bfd *abfd;
+{
+  if (GDB_MULTI_ARCH)
+    {
+      struct gdbarch_info info;
+      memset (&info, 0, sizeof info);
+      info.abfd = abfd;
+      gdbarch_update (info);
+    }
+  else
+    {
+      set_architecture_from_file (abfd);
+      set_endian_from_file (abfd);
+    }
+}
+
+/* Initialize the current architecture.  Update the ``set
+   architecture'' command so that it specifies a list of valid
+   architectures.  */
+
+#ifdef DEFAULT_BFD_ARCH
+extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
+static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
+#else
+static const bfd_arch_info_type *default_bfd_arch;
+#endif
+
+#ifdef DEFAULT_BFD_VEC
+extern const bfd_target DEFAULT_BFD_VEC;
+static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
+#else
+static const bfd_target *default_bfd_vec;
+#endif
+
+void
+initialize_current_architecture (void)
+{
+  const char **arches = gdbarch_printable_names ();
+
+  /* determine a default architecture and byte order. */
+  struct gdbarch_info info;
+  memset (&info, 0, sizeof (info));
+  
+  /* Find a default architecture. */
+  if (info.bfd_arch_info == NULL
+      && default_bfd_arch != NULL)
+    info.bfd_arch_info = default_bfd_arch;
+  if (info.bfd_arch_info == NULL)
+    {
+      /* Choose the architecture by taking the first one
+        alphabetically. */
+      const char *chosen = arches[0];
+      const char **arch;
+      for (arch = arches; *arch != NULL; arch++)
+       {
+         if (strcmp (*arch, chosen) < 0)
+           chosen = *arch;
+       }
+      if (chosen == NULL)
+       internal_error ("initialize_current_architecture: No arch");
+      info.bfd_arch_info = bfd_scan_arch (chosen);
+      if (info.bfd_arch_info == NULL)
+       internal_error ("initialize_current_architecture: Arch not found");
+    }
+
+  /* take several guesses at a byte order. */
+  /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
+     forced above. */
+  if (info.byte_order == 0
+      && default_bfd_vec != NULL)
+    {
+      /* Extract BFD's default vector's byte order. */
+      switch (default_bfd_vec->byteorder)
+       {
+       case BFD_ENDIAN_BIG:
+         info.byte_order = BIG_ENDIAN;
+         break;
+       case BFD_ENDIAN_LITTLE:
+         info.byte_order = LITTLE_ENDIAN;
+         break;
+       default:
+         break;
+       }
+    }
+  if (info.byte_order == 0)
+    {
+      /* look for ``*el-*'' in the target name. */
+      const char *chp;
+      chp = strchr (target_name, '-');
+      if (chp != NULL
+         && chp - 2 >= target_name
+         && strncmp (chp - 2, "el", 2) == 0)
+       info.byte_order = LITTLE_ENDIAN;
+    }
+  if (info.byte_order == 0)
+    {
+      /* Wire it to big-endian!!! */
+      info.byte_order = BIG_ENDIAN;
+    }
+
+  if (GDB_MULTI_ARCH)
+    {
+      gdbarch_update (info);
+    }
+
+  /* Create the ``set architecture'' command appending ``auto'' to the
+     list of architectures. */
+  {
+    struct cmd_list_element *c;
+    /* Append ``auto''. */
+    int nr;
+    for (nr = 0; arches[nr] != NULL; nr++);
+    arches = xrealloc (arches, sizeof (char*) * (nr + 2));
+    arches[nr + 0] = "auto";
+    arches[nr + 1] = NULL;
+    /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
+       of ``const char *''.  We just happen to know that the casts are
+       safe. */
+    c = add_set_enum_cmd ("architecture", class_support,
+                         (char **) arches, (char **) &set_architecture_string,
+                         "Set architecture of target.",
+                         &setlist);
+    c->function.sfunc = set_architecture;
+    add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
+    /* Don't use set_from_show - need to print both auto/manual and
+       current setting. */
+    add_cmd ("architecture", class_support, show_architecture,
+            "Show the current target architecture", &showlist);
+    c = add_cmd ("architecture", class_support, info_architecture,
+                "List supported target architectures", &infolist);
+    deprecate_cmd (c, "set architecture");
+  }
+}
+
+
 /* */
 
-extern initialize_file_ftype __initialize_gdbarch_utils;
+extern initialize_file_ftype _initialize_gdbarch_utils;
 
 void
-__initialize_gdbarch_utils (void)
+_initialize_gdbarch_utils (void)
 {
+  struct cmd_list_element *c;
+  c = add_set_enum_cmd ("endian", class_support,
+                       (char **) endian_enum, (char **) &set_endian_string,
+                       "Set endianness of target.",
+                       &setlist);
+  c->function.sfunc = set_endian;
+  /* Don't use set_from_show - need to print both auto/manual and
+     current setting. */
+  add_cmd ("endian", class_support, show_endian,
+          "Show the current byte-order", &showlist);
 }

diff --git a/gdb/arch-utils.h b/gdb/arch-utils.h
index a9ff6f52ad93e128dafde76b21c5d427d8e78586..1a147da49cb376d521535f05c8b5333e525ea567 100644 (file)
--- a/gdb/arch-utils.h
+++ b/gdb/arch-utils.h
@@ -67,4 +67,25 @@ extern int core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs);
 extern const struct floatformat *default_float_format (struct gdbarch *gdbarch);
 extern const struct floatformat *default_double_format (struct gdbarch *gdbarch);
 
+/* Helper function for targets that don't know how my arguments are
+   being passed */
+extern int frame_num_args_unknown (struct frame_info *fi);
+
+
+/* The following DEPRECATED interfaces are for pre- multi-arch legacy
+   targets. */
+
+/* DEPRECATED pre- multi-arch interface.  Explicitly set the dynamic
+   target-system-dependant parameters based on bfd_architecture and
+   machine.  This function is deprecated, use
+   set_gdbarch_from_arch_machine(). */
+
+extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
+
+/* DEPRECATED pre- multi-arch interface.  Notify the target dependant
+   backend of a change to the selected architecture. A zero return
+   status indicates that the target did not like the change. */
+
+extern int (*target_architecture_hook) (const struct bfd_arch_info *);
+
 #endif

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 55afe114e6a99fd855ed6a2344a0bca43408afcd..967534ee372e5f26b4ae648899dafa08590f3a86 100644 (file)
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -93,6 +93,7 @@ struct gdbarch
 
   /* target specific vector. */
   struct gdbarch_tdep *tdep;
+  gdbarch_dump_tdep_ftype *dump_tdep;
 
   /* per-architecture data-pointers */
   int nr_data;
@@ -232,12 +233,13 @@ struct gdbarch
 
 extern const struct bfd_arch_info bfd_default_arch_struct;
 
-struct gdbarch startup_gdbarch = {
+struct gdbarch startup_gdbarch =
+{
   /* basic architecture information */
   &bfd_default_arch_struct,
   BIG_ENDIAN,
-  /* target specific vector */
-  NULL,
+  /* target specific vector and its dump routine */
+  NULL, NULL,
   /*per-architecture data-pointers and swap regions */
   0, NULL, NULL,
   /* Multi-arch values */
@@ -340,6 +342,7 @@ struct gdbarch startup_gdbarch = {
   0,
   /* startup_gdbarch() */
 };
+
 struct gdbarch *current_gdbarch = &startup_gdbarch;
 
 
@@ -406,6 +409,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
    However, if an architecture's init function encounters an error
    building the structure, it may need to clean up a partially
    constructed gdbarch.  */
+
 void
 gdbarch_free (struct gdbarch *arch)
 {
@@ -655,567 +659,1184 @@ verify_gdbarch (struct gdbarch *gdbarch)
 
 /* Print out the details of the current architecture. */
 
+/* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
+   just happens to match the global variable ``current_gdbarch''.  That
+   way macros refering to that variable get the local and not the global
+   version - ulgh.  Once everything is parameterised with gdbarch, this
+   will go away. */
+
 void
-gdbarch_dump (void)
+gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 {
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
+                      GDB_MULTI_ARCH);
+#ifdef TARGET_ARCHITECTURE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
+                      XSTRING (TARGET_ARCHITECTURE));
+#endif
+#ifdef TARGET_BYTE_ORDER
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
+                      XSTRING (TARGET_BYTE_ORDER));
+#endif
+#ifdef TARGET_BFD_VMA_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
+                      XSTRING (TARGET_BFD_VMA_BIT));
+#endif
+#ifdef TARGET_PTR_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_PTR_BIT # %s\n",
+                      XSTRING (TARGET_PTR_BIT));
+#endif
+#ifdef TARGET_SHORT_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
+                      XSTRING (TARGET_SHORT_BIT));
+#endif
+#ifdef TARGET_INT_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_INT_BIT # %s\n",
+                      XSTRING (TARGET_INT_BIT));
+#endif
+#ifdef TARGET_LONG_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_BIT # %s\n",
+                      XSTRING (TARGET_LONG_BIT));
+#endif
+#ifdef TARGET_LONG_LONG_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
+                      XSTRING (TARGET_LONG_LONG_BIT));
+#endif
+#ifdef TARGET_FLOAT_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
+                      XSTRING (TARGET_FLOAT_BIT));
+#endif
+#ifdef TARGET_DOUBLE_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
+                      XSTRING (TARGET_DOUBLE_BIT));
+#endif
+#ifdef TARGET_LONG_DOUBLE_BIT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
+                      XSTRING (TARGET_LONG_DOUBLE_BIT));
+#endif
+#ifdef IEEE_FLOAT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: IEEE_FLOAT # %s\n",
+                      XSTRING (IEEE_FLOAT));
+#endif
+#ifdef TARGET_READ_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_READ_PC(pid)",
+                      XSTRING (TARGET_READ_PC (pid)));
+#endif
+#ifdef TARGET_WRITE_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_WRITE_PC(val, pid)",
+                      XSTRING (TARGET_WRITE_PC (val, pid)));
+#endif
+#ifdef TARGET_READ_FP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_READ_FP()",
+                      XSTRING (TARGET_READ_FP ()));
+#endif
+#ifdef TARGET_WRITE_FP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_WRITE_FP(val)",
+                      XSTRING (TARGET_WRITE_FP (val)));
+#endif
+#ifdef TARGET_READ_SP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_READ_SP()",
+                      XSTRING (TARGET_READ_SP ()));
+#endif
+#ifdef TARGET_WRITE_SP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "TARGET_WRITE_SP(val)",
+                      XSTRING (TARGET_WRITE_SP (val)));
+#endif
+#ifdef NUM_REGS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NUM_REGS # %s\n",
+                      XSTRING (NUM_REGS));
+#endif
+#ifdef SP_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: SP_REGNUM # %s\n",
+                      XSTRING (SP_REGNUM));
+#endif
+#ifdef FP_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FP_REGNUM # %s\n",
+                      XSTRING (FP_REGNUM));
+#endif
+#ifdef PC_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: PC_REGNUM # %s\n",
+                      XSTRING (PC_REGNUM));
+#endif
+#ifdef FP0_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FP0_REGNUM # %s\n",
+                      XSTRING (FP0_REGNUM));
+#endif
+#ifdef NPC_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NPC_REGNUM # %s\n",
+                      XSTRING (NPC_REGNUM));
+#endif
+#ifdef NNPC_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NNPC_REGNUM # %s\n",
+                      XSTRING (NNPC_REGNUM));
+#endif
+#ifdef REGISTER_NAME
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_NAME(regnr)",
+                      XSTRING (REGISTER_NAME (regnr)));
+#endif
+#ifdef REGISTER_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_SIZE # %s\n",
+                      XSTRING (REGISTER_SIZE));
+#endif
+#ifdef REGISTER_BYTES
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_BYTES # %s\n",
+                      XSTRING (REGISTER_BYTES));
+#endif
+#ifdef REGISTER_BYTE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_BYTE(reg_nr)",
+                      XSTRING (REGISTER_BYTE (reg_nr)));
+#endif
+#ifdef REGISTER_RAW_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_RAW_SIZE(reg_nr)",
+                      XSTRING (REGISTER_RAW_SIZE (reg_nr)));
+#endif
+#ifdef MAX_REGISTER_RAW_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
+                      XSTRING (MAX_REGISTER_RAW_SIZE));
+#endif
+#ifdef REGISTER_VIRTUAL_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_VIRTUAL_SIZE(reg_nr)",
+                      XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
+#endif
+#ifdef MAX_REGISTER_VIRTUAL_SIZE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
+                      XSTRING (MAX_REGISTER_VIRTUAL_SIZE));
+#endif
+#ifdef REGISTER_VIRTUAL_TYPE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_VIRTUAL_TYPE(reg_nr)",
+                      XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
+#endif
+#ifdef USE_GENERIC_DUMMY_FRAMES
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
+                      XSTRING (USE_GENERIC_DUMMY_FRAMES));
+#endif
+#ifdef CALL_DUMMY_LOCATION
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
+                      XSTRING (CALL_DUMMY_LOCATION));
+#endif
+#ifdef CALL_DUMMY_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "CALL_DUMMY_ADDRESS()",
+                      XSTRING (CALL_DUMMY_ADDRESS ()));
+#endif
+#ifdef CALL_DUMMY_START_OFFSET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
+                      XSTRING (CALL_DUMMY_START_OFFSET));
+#endif
+#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
+                      XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
+#endif
+#ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
+                      XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P));
+#endif
+#ifdef CALL_DUMMY_LENGTH
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
+                      XSTRING (CALL_DUMMY_LENGTH));
+#endif
+#ifdef PC_IN_CALL_DUMMY
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
+                      XSTRING (PC_IN_CALL_DUMMY (pc, sp, frame_address)));
+#endif
+#ifdef CALL_DUMMY_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_P # %s\n",
+                      XSTRING (CALL_DUMMY_P));
+#endif
+#ifdef CALL_DUMMY_WORDS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
+                      XSTRING (CALL_DUMMY_WORDS));
+#endif
+#ifdef SIZEOF_CALL_DUMMY_WORDS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
+                      XSTRING (SIZEOF_CALL_DUMMY_WORDS));
+#endif
+#ifdef CALL_DUMMY_STACK_ADJUST_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
+                      XSTRING (CALL_DUMMY_STACK_ADJUST_P));
+#endif
+#ifdef CALL_DUMMY_STACK_ADJUST
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
+                      XSTRING (CALL_DUMMY_STACK_ADJUST));
+#endif
+#ifdef FIX_CALL_DUMMY
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
+                      XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
+#endif
+#ifdef BELIEVE_PCC_PROMOTION
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
+                      XSTRING (BELIEVE_PCC_PROMOTION));
+#endif
+#ifdef BELIEVE_PCC_PROMOTION_TYPE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
+                      XSTRING (BELIEVE_PCC_PROMOTION_TYPE));
+#endif
+#ifdef COERCE_FLOAT_TO_DOUBLE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
+                      XSTRING (COERCE_FLOAT_TO_DOUBLE (formal, actual)));
+#endif
+#ifdef GET_SAVED_REGISTER
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
+                      XSTRING (GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
+#endif
+#ifdef REGISTER_CONVERTIBLE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_CONVERTIBLE(nr)",
+                      XSTRING (REGISTER_CONVERTIBLE (nr)));
+#endif
+#ifdef REGISTER_CONVERT_TO_VIRTUAL
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
+                      XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to)));
+#endif
+#ifdef REGISTER_CONVERT_TO_RAW
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
+                      XSTRING (REGISTER_CONVERT_TO_RAW (type, regnum, from, to)));
+#endif
+#ifdef POINTER_TO_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "POINTER_TO_ADDRESS(type, buf)",
+                      XSTRING (POINTER_TO_ADDRESS (type, buf)));
+#endif
+#ifdef ADDRESS_TO_POINTER
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "ADDRESS_TO_POINTER(type, buf, addr)",
+                      XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
+#endif
+#ifdef RETURN_VALUE_ON_STACK
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "RETURN_VALUE_ON_STACK(type)",
+                      XSTRING (RETURN_VALUE_ON_STACK (type)));
+#endif
+#ifdef EXTRACT_RETURN_VALUE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
+                      XSTRING (EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
+#endif
+#ifdef PUSH_ARGUMENTS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
+                      XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
+#endif
+#ifdef PUSH_DUMMY_FRAME
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PUSH_DUMMY_FRAME(-)",
+                      XSTRING (PUSH_DUMMY_FRAME (-)));
+#endif
+#ifdef PUSH_RETURN_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PUSH_RETURN_ADDRESS(pc, sp)",
+                      XSTRING (PUSH_RETURN_ADDRESS (pc, sp)));
+#endif
+#ifdef POP_FRAME
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "POP_FRAME(-)",
+                      XSTRING (POP_FRAME (-)));
+#endif
+#ifdef D10V_MAKE_DADDR
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_MAKE_DADDR(x)",
+                      XSTRING (D10V_MAKE_DADDR (x)));
+#endif
+#ifdef D10V_MAKE_IADDR
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_MAKE_IADDR(x)",
+                      XSTRING (D10V_MAKE_IADDR (x)));
+#endif
+#ifdef D10V_DADDR_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_DADDR_P(x)",
+                      XSTRING (D10V_DADDR_P (x)));
+#endif
+#ifdef D10V_IADDR_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_IADDR_P(x)",
+                      XSTRING (D10V_IADDR_P (x)));
+#endif
+#ifdef D10V_CONVERT_DADDR_TO_RAW
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_CONVERT_DADDR_TO_RAW(x)",
+                      XSTRING (D10V_CONVERT_DADDR_TO_RAW (x)));
+#endif
+#ifdef D10V_CONVERT_IADDR_TO_RAW
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "D10V_CONVERT_IADDR_TO_RAW(x)",
+                      XSTRING (D10V_CONVERT_IADDR_TO_RAW (x)));
+#endif
+#ifdef STORE_STRUCT_RETURN
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "STORE_STRUCT_RETURN(addr, sp)",
+                      XSTRING (STORE_STRUCT_RETURN (addr, sp)));
+#endif
+#ifdef STORE_RETURN_VALUE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "STORE_RETURN_VALUE(type, valbuf)",
+                      XSTRING (STORE_RETURN_VALUE (type, valbuf)));
+#endif
+#ifdef EXTRACT_STRUCT_VALUE_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
+                      XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
+#endif
+#ifdef USE_STRUCT_CONVENTION
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "USE_STRUCT_CONVENTION(gcc_p, value_type)",
+                      XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
+#endif
+#ifdef FRAME_INIT_SAVED_REGS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_INIT_SAVED_REGS(frame)",
+                      XSTRING (FRAME_INIT_SAVED_REGS (frame)));
+#endif
+#ifdef INIT_EXTRA_FRAME_INFO
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
+                      XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
+#endif
+#ifdef SKIP_PROLOGUE
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "SKIP_PROLOGUE(ip)",
+                      XSTRING (SKIP_PROLOGUE (ip)));
+#endif
+#ifdef PROLOGUE_FRAMELESS_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PROLOGUE_FRAMELESS_P(ip)",
+                      XSTRING (PROLOGUE_FRAMELESS_P (ip)));
+#endif
+#ifdef INNER_THAN
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "INNER_THAN(lhs, rhs)",
+                      XSTRING (INNER_THAN (lhs, rhs)));
+#endif
+#ifdef BREAKPOINT_FROM_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "BREAKPOINT_FROM_PC(pcptr, lenptr)",
+                      XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
+#endif
+#ifdef MEMORY_INSERT_BREAKPOINT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
+                      XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
+#endif
+#ifdef MEMORY_REMOVE_BREAKPOINT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
+                      XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
+#endif
+#ifdef DECR_PC_AFTER_BREAK
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
+                      XSTRING (DECR_PC_AFTER_BREAK));
+#endif
+#ifdef FUNCTION_START_OFFSET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
+                      XSTRING (FUNCTION_START_OFFSET));
+#endif
+#ifdef REMOTE_TRANSLATE_XFER_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
+                      XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len)));
+#endif
+#ifdef FRAME_ARGS_SKIP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
+                      XSTRING (FRAME_ARGS_SKIP));
+#endif
+#ifdef FRAMELESS_FUNCTION_INVOCATION
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAMELESS_FUNCTION_INVOCATION(fi)",
+                      XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
+#endif
+#ifdef FRAME_CHAIN
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_CHAIN(frame)",
+                      XSTRING (FRAME_CHAIN (frame)));
+#endif
+#ifdef FRAME_CHAIN_VALID
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_CHAIN_VALID(chain, thisframe)",
+                      XSTRING (FRAME_CHAIN_VALID (chain, thisframe)));
+#endif
+#ifdef FRAME_SAVED_PC
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_SAVED_PC(fi)",
+                      XSTRING (FRAME_SAVED_PC (fi)));
+#endif
+#ifdef FRAME_ARGS_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_ARGS_ADDRESS(fi)",
+                      XSTRING (FRAME_ARGS_ADDRESS (fi)));
+#endif
+#ifdef FRAME_LOCALS_ADDRESS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_LOCALS_ADDRESS(fi)",
+                      XSTRING (FRAME_LOCALS_ADDRESS (fi)));
+#endif
+#ifdef SAVED_PC_AFTER_CALL
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "SAVED_PC_AFTER_CALL(frame)",
+                      XSTRING (SAVED_PC_AFTER_CALL (frame)));
+#endif
+#ifdef FRAME_NUM_ARGS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "FRAME_NUM_ARGS(frame)",
+                      XSTRING (FRAME_NUM_ARGS (frame)));
+#endif
+#ifdef STACK_ALIGN
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "STACK_ALIGN(sp)",
+                      XSTRING (STACK_ALIGN (sp)));
+#endif
+#ifdef REG_STRUCT_HAS_ADDR
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REG_STRUCT_HAS_ADDR(gcc_p, type)",
+                      XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
+#endif
+#ifdef SAVE_DUMMY_FRAME_TOS
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "SAVE_DUMMY_FRAME_TOS(sp)",
+                      XSTRING (SAVE_DUMMY_FRAME_TOS (sp)));
+#endif
+#ifdef TARGET_FLOAT_FORMAT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
+                      XSTRING (TARGET_FLOAT_FORMAT));
+#endif
+#ifdef TARGET_DOUBLE_FORMAT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
+                      XSTRING (TARGET_DOUBLE_FORMAT));
+#endif
+#ifdef TARGET_LONG_DOUBLE_FORMAT
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
+                      XSTRING (TARGET_LONG_DOUBLE_FORMAT));
+#endif
 #ifdef TARGET_ARCHITECTURE
   if (TARGET_ARCHITECTURE != NULL)
-    fprintf_unfiltered (gdb_stdlog,
-                        "gdbarch_update: TARGET_ARCHITECTURE = %s\n",
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
                         TARGET_ARCHITECTURE->printable_name);
 #endif
 #ifdef TARGET_BYTE_ORDER
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
                       (long) TARGET_BYTE_ORDER);
 #endif
 #ifdef TARGET_BFD_VMA_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_BFD_VMA_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_BFD_VMA_BIT = %ld\n",
                       (long) TARGET_BFD_VMA_BIT);
 #endif
 #ifdef TARGET_PTR_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_PTR_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_PTR_BIT = %ld\n",
                       (long) TARGET_PTR_BIT);
 #endif
 #ifdef TARGET_SHORT_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_SHORT_BIT = %ld\n",
                       (long) TARGET_SHORT_BIT);
 #endif
 #ifdef TARGET_INT_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_INT_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_INT_BIT = %ld\n",
                       (long) TARGET_INT_BIT);
 #endif
 #ifdef TARGET_LONG_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_LONG_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_BIT = %ld\n",
                       (long) TARGET_LONG_BIT);
 #endif
 #ifdef TARGET_LONG_LONG_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_LONG_BIT = %ld\n",
                       (long) TARGET_LONG_LONG_BIT);
 #endif
 #ifdef TARGET_FLOAT_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_FLOAT_BIT = %ld\n",
                       (long) TARGET_FLOAT_BIT);
 #endif
 #ifdef TARGET_DOUBLE_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_DOUBLE_BIT = %ld\n",
                       (long) TARGET_DOUBLE_BIT);
 #endif
 #ifdef TARGET_LONG_DOUBLE_BIT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %ld\n",
                       (long) TARGET_LONG_DOUBLE_BIT);
 #endif
 #ifdef IEEE_FLOAT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: IEEE_FLOAT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: IEEE_FLOAT = %ld\n",
                       (long) IEEE_FLOAT);
 #endif
 #ifdef TARGET_READ_PC
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
-                      (long) current_gdbarch->read_pc
-                      /*TARGET_READ_PC ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
+                        (long) current_gdbarch->read_pc
+                        /*TARGET_READ_PC ()*/);
 #endif
 #ifdef TARGET_WRITE_PC
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
-                      (long) current_gdbarch->write_pc
-                      /*TARGET_WRITE_PC ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
+                        (long) current_gdbarch->write_pc
+                        /*TARGET_WRITE_PC ()*/);
 #endif
 #ifdef TARGET_READ_FP
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
-                      (long) current_gdbarch->read_fp
-                      /*TARGET_READ_FP ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
+                        (long) current_gdbarch->read_fp
+                        /*TARGET_READ_FP ()*/);
 #endif
 #ifdef TARGET_WRITE_FP
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
-                      (long) current_gdbarch->write_fp
-                      /*TARGET_WRITE_FP ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_WRITE_FP = 0x%08lx\n",
+                        (long) current_gdbarch->write_fp
+                        /*TARGET_WRITE_FP ()*/);
 #endif
 #ifdef TARGET_READ_SP
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
-                      (long) current_gdbarch->read_sp
-                      /*TARGET_READ_SP ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
+                        (long) current_gdbarch->read_sp
+                        /*TARGET_READ_SP ()*/);
 #endif
 #ifdef TARGET_WRITE_SP
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
-                      (long) current_gdbarch->write_sp
-                      /*TARGET_WRITE_SP ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
+                        (long) current_gdbarch->write_sp
+                        /*TARGET_WRITE_SP ()*/);
 #endif
 #ifdef NUM_REGS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: NUM_REGS = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NUM_REGS = %ld\n",
                       (long) NUM_REGS);
 #endif
 #ifdef SP_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: SP_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: SP_REGNUM = %ld\n",
                       (long) SP_REGNUM);
 #endif
 #ifdef FP_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FP_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FP_REGNUM = %ld\n",
                       (long) FP_REGNUM);
 #endif
 #ifdef PC_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PC_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: PC_REGNUM = %ld\n",
                       (long) PC_REGNUM);
 #endif
 #ifdef FP0_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FP0_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FP0_REGNUM = %ld\n",
                       (long) FP0_REGNUM);
 #endif
 #ifdef NPC_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: NPC_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NPC_REGNUM = %ld\n",
                       (long) NPC_REGNUM);
 #endif
 #ifdef NNPC_REGNUM
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: NNPC_REGNUM = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: NNPC_REGNUM = %ld\n",
                       (long) NNPC_REGNUM);
 #endif
 #ifdef REGISTER_NAME
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
-                      (long) current_gdbarch->register_name
-                      /*REGISTER_NAME ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
+                        (long) current_gdbarch->register_name
+                        /*REGISTER_NAME ()*/);
 #endif
 #ifdef REGISTER_SIZE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_SIZE = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_SIZE = %ld\n",
                       (long) REGISTER_SIZE);
 #endif
 #ifdef REGISTER_BYTES
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_BYTES = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: REGISTER_BYTES = %ld\n",
                       (long) REGISTER_BYTES);
 #endif
 #ifdef REGISTER_BYTE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
-                      (long) current_gdbarch->register_byte
-                      /*REGISTER_BYTE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
+                        (long) current_gdbarch->register_byte
+                        /*REGISTER_BYTE ()*/);
 #endif
 #ifdef REGISTER_RAW_SIZE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
-                      (long) current_gdbarch->register_raw_size
-                      /*REGISTER_RAW_SIZE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
+                        (long) current_gdbarch->register_raw_size
+                        /*REGISTER_RAW_SIZE ()*/);
 #endif
 #ifdef MAX_REGISTER_RAW_SIZE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %ld\n",
                       (long) MAX_REGISTER_RAW_SIZE);
 #endif
 #ifdef REGISTER_VIRTUAL_SIZE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
-                      (long) current_gdbarch->register_virtual_size
-                      /*REGISTER_VIRTUAL_SIZE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
+                        (long) current_gdbarch->register_virtual_size
+                        /*REGISTER_VIRTUAL_SIZE ()*/);
 #endif
 #ifdef MAX_REGISTER_VIRTUAL_SIZE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
                       (long) MAX_REGISTER_VIRTUAL_SIZE);
 #endif
 #ifdef REGISTER_VIRTUAL_TYPE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
-                      (long) current_gdbarch->register_virtual_type
-                      /*REGISTER_VIRTUAL_TYPE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
+                        (long) current_gdbarch->register_virtual_type
+                        /*REGISTER_VIRTUAL_TYPE ()*/);
 #endif
 #ifdef USE_GENERIC_DUMMY_FRAMES
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %ld\n",
                       (long) USE_GENERIC_DUMMY_FRAMES);
 #endif
 #ifdef CALL_DUMMY_LOCATION
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_LOCATION = %ld\n",
                       (long) CALL_DUMMY_LOCATION);
 #endif
 #ifdef CALL_DUMMY_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->call_dummy_address
-                      /*CALL_DUMMY_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->call_dummy_address
+                        /*CALL_DUMMY_ADDRESS ()*/);
 #endif
 #ifdef CALL_DUMMY_START_OFFSET
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
                       (long) CALL_DUMMY_START_OFFSET);
 #endif
 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
                       (long) CALL_DUMMY_BREAKPOINT_OFFSET);
 #endif
 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
                       (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
 #endif
 #ifdef CALL_DUMMY_LENGTH
   if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
-    fprintf_unfiltered (gdb_stdlog,
-                        "gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: CALL_DUMMY_LENGTH = %ld\n",
                         (long) CALL_DUMMY_LENGTH);
 #endif
 #ifdef PC_IN_CALL_DUMMY
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
-                      (long) current_gdbarch->pc_in_call_dummy
-                      /*PC_IN_CALL_DUMMY ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
+                        (long) current_gdbarch->pc_in_call_dummy
+                        /*PC_IN_CALL_DUMMY ()*/);
 #endif
 #ifdef CALL_DUMMY_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_P = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_P = %ld\n",
                       (long) CALL_DUMMY_P);
 #endif
 #ifdef CALL_DUMMY_WORDS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
                       (long) CALL_DUMMY_WORDS);
 #endif
 #ifdef SIZEOF_CALL_DUMMY_WORDS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
                       (long) SIZEOF_CALL_DUMMY_WORDS);
 #endif
 #ifdef CALL_DUMMY_STACK_ADJUST_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
                       (long) CALL_DUMMY_STACK_ADJUST_P);
 #endif
 #ifdef CALL_DUMMY_STACK_ADJUST
   if (CALL_DUMMY_STACK_ADJUST_P)
-    fprintf_unfiltered (gdb_stdlog,
-                        "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
                         (long) CALL_DUMMY_STACK_ADJUST);
 #endif
 #ifdef FIX_CALL_DUMMY
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
-                      (long) current_gdbarch->fix_call_dummy
-                      /*FIX_CALL_DUMMY ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
+                        (long) current_gdbarch->fix_call_dummy
+                        /*FIX_CALL_DUMMY ()*/);
 #endif
 #ifdef BELIEVE_PCC_PROMOTION
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: BELIEVE_PCC_PROMOTION = %ld\n",
                       (long) BELIEVE_PCC_PROMOTION);
 #endif
 #ifdef BELIEVE_PCC_PROMOTION_TYPE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
                       (long) BELIEVE_PCC_PROMOTION_TYPE);
 #endif
 #ifdef COERCE_FLOAT_TO_DOUBLE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
-                      (long) current_gdbarch->coerce_float_to_double
-                      /*COERCE_FLOAT_TO_DOUBLE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
+                        (long) current_gdbarch->coerce_float_to_double
+                        /*COERCE_FLOAT_TO_DOUBLE ()*/);
 #endif
 #ifdef GET_SAVED_REGISTER
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
-                      (long) current_gdbarch->get_saved_register
-                      /*GET_SAVED_REGISTER ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
+                        (long) current_gdbarch->get_saved_register
+                        /*GET_SAVED_REGISTER ()*/);
 #endif
 #ifdef REGISTER_CONVERTIBLE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
-                      (long) current_gdbarch->register_convertible
-                      /*REGISTER_CONVERTIBLE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
+                        (long) current_gdbarch->register_convertible
+                        /*REGISTER_CONVERTIBLE ()*/);
 #endif
 #ifdef REGISTER_CONVERT_TO_VIRTUAL
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
-                      (long) current_gdbarch->register_convert_to_virtual
-                      /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
+                        (long) current_gdbarch->register_convert_to_virtual
+                        /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
 #endif
 #ifdef REGISTER_CONVERT_TO_RAW
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
-                      (long) current_gdbarch->register_convert_to_raw
-                      /*REGISTER_CONVERT_TO_RAW ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
+                        (long) current_gdbarch->register_convert_to_raw
+                        /*REGISTER_CONVERT_TO_RAW ()*/);
 #endif
 #ifdef POINTER_TO_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: POINTER_TO_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->pointer_to_address
-                      /*POINTER_TO_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->pointer_to_address
+                        /*POINTER_TO_ADDRESS ()*/);
 #endif
 #ifdef ADDRESS_TO_POINTER
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: ADDRESS_TO_POINTER = 0x%08lx\n",
-                      (long) current_gdbarch->address_to_pointer
-                      /*ADDRESS_TO_POINTER ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
+                        (long) current_gdbarch->address_to_pointer
+                        /*ADDRESS_TO_POINTER ()*/);
 #endif
 #ifdef RETURN_VALUE_ON_STACK
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: RETURN_VALUE_ON_STACK = 0x%08lx\n",
-                      (long) current_gdbarch->return_value_on_stack
-                      /*RETURN_VALUE_ON_STACK ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
+                        (long) current_gdbarch->return_value_on_stack
+                        /*RETURN_VALUE_ON_STACK ()*/);
 #endif
 #ifdef EXTRACT_RETURN_VALUE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
-                      (long) current_gdbarch->extract_return_value
-                      /*EXTRACT_RETURN_VALUE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
+                        (long) current_gdbarch->extract_return_value
+                        /*EXTRACT_RETURN_VALUE ()*/);
 #endif
 #ifdef PUSH_ARGUMENTS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
-                      (long) current_gdbarch->push_arguments
-                      /*PUSH_ARGUMENTS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
+                        (long) current_gdbarch->push_arguments
+                        /*PUSH_ARGUMENTS ()*/);
 #endif
 #ifdef PUSH_DUMMY_FRAME
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
-                      (long) current_gdbarch->push_dummy_frame
-                      /*PUSH_DUMMY_FRAME ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
+                        (long) current_gdbarch->push_dummy_frame
+                        /*PUSH_DUMMY_FRAME ()*/);
 #endif
 #ifdef PUSH_RETURN_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->push_return_address
-                      /*PUSH_RETURN_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->push_return_address
+                        /*PUSH_RETURN_ADDRESS ()*/);
 #endif
 #ifdef POP_FRAME
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: POP_FRAME = 0x%08lx\n",
-                      (long) current_gdbarch->pop_frame
-                      /*POP_FRAME ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: POP_FRAME = 0x%08lx\n",
+                        (long) current_gdbarch->pop_frame
+                        /*POP_FRAME ()*/);
 #endif
 #ifdef D10V_MAKE_DADDR
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_make_daddr
-                      /*D10V_MAKE_DADDR ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_MAKE_DADDR = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_make_daddr
+                        /*D10V_MAKE_DADDR ()*/);
 #endif
 #ifdef D10V_MAKE_IADDR
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_make_iaddr
-                      /*D10V_MAKE_IADDR ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_MAKE_IADDR = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_make_iaddr
+                        /*D10V_MAKE_IADDR ()*/);
 #endif
 #ifdef D10V_DADDR_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_daddr_p
-                      /*D10V_DADDR_P ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_DADDR_P = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_daddr_p
+                        /*D10V_DADDR_P ()*/);
 #endif
 #ifdef D10V_IADDR_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_iaddr_p
-                      /*D10V_IADDR_P ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_IADDR_P = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_iaddr_p
+                        /*D10V_IADDR_P ()*/);
 #endif
 #ifdef D10V_CONVERT_DADDR_TO_RAW
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_convert_daddr_to_raw
-                      /*D10V_CONVERT_DADDR_TO_RAW ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_convert_daddr_to_raw
+                        /*D10V_CONVERT_DADDR_TO_RAW ()*/);
 #endif
 #ifdef D10V_CONVERT_IADDR_TO_RAW
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
-                      (long) current_gdbarch->d10v_convert_iaddr_to_raw
-                      /*D10V_CONVERT_IADDR_TO_RAW ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
+                        (long) current_gdbarch->d10v_convert_iaddr_to_raw
+                        /*D10V_CONVERT_IADDR_TO_RAW ()*/);
 #endif
 #ifdef STORE_STRUCT_RETURN
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
-                      (long) current_gdbarch->store_struct_return
-                      /*STORE_STRUCT_RETURN ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
+                        (long) current_gdbarch->store_struct_return
+                        /*STORE_STRUCT_RETURN ()*/);
 #endif
 #ifdef STORE_RETURN_VALUE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
-                      (long) current_gdbarch->store_return_value
-                      /*STORE_RETURN_VALUE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
+                        (long) current_gdbarch->store_return_value
+                        /*STORE_RETURN_VALUE ()*/);
 #endif
 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->extract_struct_value_address
-                      /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->extract_struct_value_address
+                        /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
 #endif
 #ifdef USE_STRUCT_CONVENTION
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
-                      (long) current_gdbarch->use_struct_convention
-                      /*USE_STRUCT_CONVENTION ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
+                        (long) current_gdbarch->use_struct_convention
+                        /*USE_STRUCT_CONVENTION ()*/);
 #endif
 #ifdef FRAME_INIT_SAVED_REGS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
-                      (long) current_gdbarch->frame_init_saved_regs
-                      /*FRAME_INIT_SAVED_REGS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
+                        (long) current_gdbarch->frame_init_saved_regs
+                        /*FRAME_INIT_SAVED_REGS ()*/);
 #endif
 #ifdef INIT_EXTRA_FRAME_INFO
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
-                      (long) current_gdbarch->init_extra_frame_info
-                      /*INIT_EXTRA_FRAME_INFO ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
+                        (long) current_gdbarch->init_extra_frame_info
+                        /*INIT_EXTRA_FRAME_INFO ()*/);
 #endif
 #ifdef SKIP_PROLOGUE
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
-                      (long) current_gdbarch->skip_prologue
-                      /*SKIP_PROLOGUE ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
+                        (long) current_gdbarch->skip_prologue
+                        /*SKIP_PROLOGUE ()*/);
 #endif
 #ifdef PROLOGUE_FRAMELESS_P
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
-                      (long) current_gdbarch->prologue_frameless_p
-                      /*PROLOGUE_FRAMELESS_P ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
+                        (long) current_gdbarch->prologue_frameless_p
+                        /*PROLOGUE_FRAMELESS_P ()*/);
 #endif
 #ifdef INNER_THAN
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: INNER_THAN = 0x%08lx\n",
-                      (long) current_gdbarch->inner_than
-                      /*INNER_THAN ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: INNER_THAN = 0x%08lx\n",
+                        (long) current_gdbarch->inner_than
+                        /*INNER_THAN ()*/);
 #endif
 #ifdef BREAKPOINT_FROM_PC
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
-                      (long) current_gdbarch->breakpoint_from_pc
-                      /*BREAKPOINT_FROM_PC ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
+                        (long) current_gdbarch->breakpoint_from_pc
+                        /*BREAKPOINT_FROM_PC ()*/);
 #endif
 #ifdef MEMORY_INSERT_BREAKPOINT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
-                      (long) current_gdbarch->memory_insert_breakpoint
-                      /*MEMORY_INSERT_BREAKPOINT ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
+                        (long) current_gdbarch->memory_insert_breakpoint
+                        /*MEMORY_INSERT_BREAKPOINT ()*/);
 #endif
 #ifdef MEMORY_REMOVE_BREAKPOINT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
-                      (long) current_gdbarch->memory_remove_breakpoint
-                      /*MEMORY_REMOVE_BREAKPOINT ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
+                        (long) current_gdbarch->memory_remove_breakpoint
+                        /*MEMORY_REMOVE_BREAKPOINT ()*/);
 #endif
 #ifdef DECR_PC_AFTER_BREAK
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
                       (long) DECR_PC_AFTER_BREAK);
 #endif
 #ifdef FUNCTION_START_OFFSET
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
                       (long) FUNCTION_START_OFFSET);
 #endif
 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->remote_translate_xfer_address
-                      /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->remote_translate_xfer_address
+                        /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
 #endif
 #ifdef FRAME_ARGS_SKIP
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
                       (long) FRAME_ARGS_SKIP);
 #endif
 #ifdef FRAMELESS_FUNCTION_INVOCATION
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
-                      (long) current_gdbarch->frameless_function_invocation
-                      /*FRAMELESS_FUNCTION_INVOCATION ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
+                        (long) current_gdbarch->frameless_function_invocation
+                        /*FRAMELESS_FUNCTION_INVOCATION ()*/);
 #endif
 #ifdef FRAME_CHAIN
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
-                      (long) current_gdbarch->frame_chain
-                      /*FRAME_CHAIN ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
+                        (long) current_gdbarch->frame_chain
+                        /*FRAME_CHAIN ()*/);
 #endif
 #ifdef FRAME_CHAIN_VALID
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
-                      (long) current_gdbarch->frame_chain_valid
-                      /*FRAME_CHAIN_VALID ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
+                        (long) current_gdbarch->frame_chain_valid
+                        /*FRAME_CHAIN_VALID ()*/);
 #endif
 #ifdef FRAME_SAVED_PC
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
-                      (long) current_gdbarch->frame_saved_pc
-                      /*FRAME_SAVED_PC ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
+                        (long) current_gdbarch->frame_saved_pc
+                        /*FRAME_SAVED_PC ()*/);
 #endif
 #ifdef FRAME_ARGS_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->frame_args_address
-                      /*FRAME_ARGS_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->frame_args_address
+                        /*FRAME_ARGS_ADDRESS ()*/);
 #endif
 #ifdef FRAME_LOCALS_ADDRESS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
-                      (long) current_gdbarch->frame_locals_address
-                      /*FRAME_LOCALS_ADDRESS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
+                        (long) current_gdbarch->frame_locals_address
+                        /*FRAME_LOCALS_ADDRESS ()*/);
 #endif
 #ifdef SAVED_PC_AFTER_CALL
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
-                      (long) current_gdbarch->saved_pc_after_call
-                      /*SAVED_PC_AFTER_CALL ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
+                        (long) current_gdbarch->saved_pc_after_call
+                        /*SAVED_PC_AFTER_CALL ()*/);
 #endif
 #ifdef FRAME_NUM_ARGS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
-                      (long) current_gdbarch->frame_num_args
-                      /*FRAME_NUM_ARGS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
+                        (long) current_gdbarch->frame_num_args
+                        /*FRAME_NUM_ARGS ()*/);
 #endif
 #ifdef STACK_ALIGN
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: STACK_ALIGN = 0x%08lx\n",
-                      (long) current_gdbarch->stack_align
-                      /*STACK_ALIGN ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
+                        (long) current_gdbarch->stack_align
+                        /*STACK_ALIGN ()*/);
 #endif
 #ifdef REG_STRUCT_HAS_ADDR
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
-                      (long) current_gdbarch->reg_struct_has_addr
-                      /*REG_STRUCT_HAS_ADDR ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
+                        (long) current_gdbarch->reg_struct_has_addr
+                        /*REG_STRUCT_HAS_ADDR ()*/);
 #endif
 #ifdef SAVE_DUMMY_FRAME_TOS
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
-                      (long) current_gdbarch->save_dummy_frame_tos
-                      /*SAVE_DUMMY_FRAME_TOS ()*/);
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
+                        (long) current_gdbarch->save_dummy_frame_tos
+                        /*SAVE_DUMMY_FRAME_TOS ()*/);
 #endif
 #ifdef TARGET_FLOAT_FORMAT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_FLOAT_FORMAT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n",
                       (long) TARGET_FLOAT_FORMAT);
 #endif
 #ifdef TARGET_DOUBLE_FORMAT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_DOUBLE_FORMAT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n",
                       (long) TARGET_DOUBLE_FORMAT);
 #endif
 #ifdef TARGET_LONG_DOUBLE_FORMAT
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
                       (long) TARGET_LONG_DOUBLE_FORMAT);
 #endif
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: GDB_MULTI_ARCH = %d\n",
-                      GDB_MULTI_ARCH);
+  if (current_gdbarch->dump_tdep != NULL)
+    current_gdbarch->dump_tdep (current_gdbarch, file);
 }
 
 struct gdbarch_tdep *
@@ -3059,21 +3680,67 @@ swapin_gdbarch_swap (struct gdbarch *gdbarch)
 
 /* Keep a registrary of the architectures known by GDB. */
 
-struct gdbarch_init_registration
+struct gdbarch_registration
 {
   enum bfd_architecture bfd_architecture;
   gdbarch_init_ftype *init;
+  gdbarch_dump_tdep_ftype *dump_tdep;
   struct gdbarch_list *arches;
-  struct gdbarch_init_registration *next;
+  struct gdbarch_registration *next;
 };
 
-static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
+static struct gdbarch_registration *gdbarch_registrary = NULL;
+
+static void
+append_name (const char ***buf, int *nr, const char *name)
+{
+  *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
+  (*buf)[*nr] = name;
+  *nr += 1;
+}
+
+const char **
+gdbarch_printable_names (void)
+{
+  if (GDB_MULTI_ARCH)
+    {
+      /* Accumulate a list of names based on the registed list of
+         architectures. */
+      enum bfd_architecture a;
+      int nr_arches = 0;
+      const char **arches = NULL;
+      struct gdbarch_registration *rego;
+      for (rego = gdbarch_registrary;
+          rego != NULL;
+          rego = rego->next)
+       {
+         const struct bfd_arch_info *ap;
+         ap = bfd_lookup_arch (rego->bfd_architecture, 0);
+         if (ap == NULL)
+           internal_error ("gdbarch_architecture_names: multi-arch unknown");
+         do
+           {
+             append_name (&arches, &nr_arches, ap->printable_name);
+             ap = ap->next;
+           }
+         while (ap != NULL);
+       }
+      append_name (&arches, &nr_arches, NULL);
+      return arches;
+    }
+  else
+    /* Just return all the architectures that BFD knows.  Assume that
+       the legacy architecture framework supports them. */
+    return bfd_arch_list ();
+}
+
 
 void
-register_gdbarch_init (enum bfd_architecture bfd_architecture,
-                       gdbarch_init_ftype *init)
+gdbarch_register (enum bfd_architecture bfd_architecture,
+                  gdbarch_init_ftype *init,
+                 gdbarch_dump_tdep_ftype *dump_tdep)
 {
-  struct gdbarch_init_registration **curr;
+  struct gdbarch_registration **curr;
   const struct bfd_arch_info *bfd_arch_info;
   /* Check that BFD reconizes this architecture */
   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
@@ -3082,7 +3749,7 @@ register_gdbarch_init (enum bfd_architecture bfd_architecture,
       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
     }
   /* Check that we haven't seen this architecture before */
-  for (curr = &gdbarch_init_registrary;
+  for (curr = &gdbarch_registrary;
        (*curr) != NULL;
        curr = &(*curr)->next)
     {
@@ -3096,13 +3763,26 @@ register_gdbarch_init (enum bfd_architecture bfd_architecture,
                        bfd_arch_info->printable_name,
                        (long) init);
   /* Append it */
-  (*curr) = XMALLOC (struct gdbarch_init_registration);
+  (*curr) = XMALLOC (struct gdbarch_registration);
   (*curr)->bfd_architecture = bfd_architecture;
   (*curr)->init = init;
+  (*curr)->dump_tdep = dump_tdep;
   (*curr)->arches = NULL;
   (*curr)->next = NULL;
+  /* When non- multi-arch, install what ever target dump routine we've
+     been provided - hopefully that routine has been writen correct
+     and works regardless of multi-arch. */
+  if (!GDB_MULTI_ARCH && dump_tdep != NULL
+      && startup_gdbarch.dump_tdep == NULL)
+    startup_gdbarch.dump_tdep = dump_tdep;
+}
+
+void
+register_gdbarch_init (enum bfd_architecture bfd_architecture,
+                      gdbarch_init_ftype *init)
+{
+  gdbarch_register (bfd_architecture, init, NULL);
 }
-  
 
 
 /* Look for an architecture using gdbarch_info.  Base search on only
@@ -3132,7 +3812,7 @@ gdbarch_update (struct gdbarch_info info)
 {
   struct gdbarch *new_gdbarch;
   struct gdbarch_list **list;
-  struct gdbarch_init_registration *rego;
+  struct gdbarch_registration *rego;
 
   /* Fill in any missing bits. Most important is the bfd_architecture
      which is used to select the target architecture. */
@@ -3166,9 +3846,11 @@ gdbarch_update (struct gdbarch_info info)
   /* A default for abfd? */
 
   /* Find the target that knows about this architecture. */
-  for (rego = gdbarch_init_registrary;
-       rego != NULL && rego->bfd_architecture != info.bfd_architecture;
-       rego = rego->next);
+  for (rego = gdbarch_registrary;
+       rego != NULL;
+       rego = rego->next)
+    if (rego->bfd_architecture == info.bfd_architecture)
+      break;
   if (rego == NULL)
     {
       if (gdbarch_debug)
@@ -3233,7 +3915,8 @@ gdbarch_update (struct gdbarch_info info)
       if ((*list)->gdbarch == new_gdbarch)
        {
          if (gdbarch_debug)
-           fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
+           fprintf_unfiltered (gdb_stdlog,
+                                "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
                                (long) new_gdbarch,
                                new_gdbarch->bfd_arch_info->printable_name);
          current_gdbarch = new_gdbarch;
@@ -3241,7 +3924,7 @@ gdbarch_update (struct gdbarch_info info)
          return 1;
        }
     }
-    
+
   /* Append this new architecture to this targets list. */
   (*list) = XMALLOC (struct gdbarch_list);
   (*list)->next = NULL;
@@ -3255,10 +3938,11 @@ gdbarch_update (struct gdbarch_info info)
                          "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
                          (long) new_gdbarch,
                          new_gdbarch->bfd_arch_info->printable_name);
-      gdbarch_dump ();
     }
   
-  /* Check that the newly installed architecture is valid.  */
+  /* Check that the newly installed architecture is valid.  Plug in
+     any post init values.  */
+  new_gdbarch->dump_tdep = rego->dump_tdep;
   verify_gdbarch (new_gdbarch);
 
   /* Initialize the per-architecture memory (swap) areas.
@@ -3271,366 +3955,13 @@ gdbarch_update (struct gdbarch_info info)
      must be updated before these modules are called. */
   init_gdbarch_data (new_gdbarch);
   
-  return 1;
-}
-
-
-
-/* Functions to manipulate the endianness of the target.  */
-
-#ifdef TARGET_BYTE_ORDER_SELECTABLE
-/* compat - Catch old targets that expect a selectable byte-order to
-   default to BIG_ENDIAN */
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
-#endif
-#endif
-#if !TARGET_BYTE_ORDER_SELECTABLE_P
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-/* compat - Catch old non byte-order selectable targets that do not
-   define TARGET_BYTE_ORDER_DEFAULT and instead expect
-   TARGET_BYTE_ORDER to be used as the default.  For targets that
-   defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
-   below will get a strange compiler warning. */
-#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
-#endif
-#endif
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
-#endif
-int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
-int target_byte_order_auto = 1;
-
-/* Chain containing the \"set endian\" commands.  */
-static struct cmd_list_element *endianlist = NULL;
-
-/* Called by ``show endian''.  */
-static void
-show_endian (char *args, int from_tty)
-{
-  char *msg =
-    (TARGET_BYTE_ORDER_AUTO
-     ? "The target endianness is set automatically (currently %s endian)\n"
-     : "The target is assumed to be %s endian\n");
-  printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
-}
-
-/* Called if the user enters ``set endian'' without an argument.  */
-static void
-set_endian (char *args, int from_tty)
-{
-  printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
-  show_endian (args, from_tty);
-}
-
-/* Called by ``set endian big''.  */
-static void
-set_endian_big (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order = BIG_ENDIAN;
-      target_byte_order_auto = 0;
-      if (GDB_MULTI_ARCH)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.byte_order = BIG_ENDIAN;
-         gdbarch_update (info);
-       }
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Called by ``set endian little''.  */
-static void
-set_endian_little (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order = LITTLE_ENDIAN;
-      target_byte_order_auto = 0;
-      if (GDB_MULTI_ARCH)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.byte_order = LITTLE_ENDIAN;
-         gdbarch_update (info);
-       }
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Called by ``set endian auto''.  */
-static void
-set_endian_auto (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order_auto = 1;
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Set the endianness from a BFD.  */
-static void
-set_endian_from_file (bfd *abfd)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      int want;
-      
-      if (bfd_big_endian (abfd))
-       want = BIG_ENDIAN;
-      else
-       want = LITTLE_ENDIAN;
-      if (TARGET_BYTE_ORDER_AUTO)
-       target_byte_order = want;
-      else if (TARGET_BYTE_ORDER != want)
-       warning ("%s endian file does not match %s endian target.",
-                want == BIG_ENDIAN ? "big" : "little",
-                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
-    }
-  else
-    {
-      if (bfd_big_endian (abfd)
-         ? TARGET_BYTE_ORDER != BIG_ENDIAN
-         : TARGET_BYTE_ORDER == BIG_ENDIAN)
-       warning ("%s endian file does not match %s endian target.",
-                bfd_big_endian (abfd) ? "big" : "little",
-                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
-    }
-}
-
-
-
-/* Functions to manipulate the architecture of the target */
-
-enum set_arch { set_arch_auto, set_arch_manual };
-
-int target_architecture_auto = 1;
-extern const struct bfd_arch_info bfd_default_arch_struct;
-const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
-int (*target_architecture_hook) (const struct bfd_arch_info *ap);
-
-static void show_endian (char *, int);
-static void set_endian (char *, int);
-static void set_endian_big (char *, int);
-static void set_endian_little (char *, int);
-static void set_endian_auto (char *, int);
-static void set_endian_from_file (bfd *);
-static int arch_ok (const struct bfd_arch_info *arch);
-static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
-static void show_architecture (char *, int);
-static void set_architecture (char *, int);
-static void info_architecture (char *, int);
-static void set_architecture_from_file (bfd *);
-
-/* Do the real work of changing the current architecture */
-
-static int
-arch_ok (const struct bfd_arch_info *arch)
-{
-  /* Should be performing the more basic check that the binary is
-     compatible with GDB. */
-  /* Check with the target that the architecture is valid. */
-  return (target_architecture_hook == NULL
-         || target_architecture_hook (arch));
-}
-
-static void
-set_arch (const struct bfd_arch_info *arch,
-          enum set_arch type)
-{
-  switch (type)
-    {
-    case set_arch_auto:
-      if (!arch_ok (arch))
-       warning ("Target may not support %s architecture",
-                arch->printable_name);
-      target_architecture = arch;
-      break;
-    case set_arch_manual:
-      if (!arch_ok (arch))
-       {
-         printf_unfiltered ("Target does not support `%s' architecture.\n",
-                            arch->printable_name);
-       }
-      else
-       {
-         target_architecture_auto = 0;
-         target_architecture = arch;
-       }
-      break;
-    }
   if (gdbarch_debug)
-    gdbarch_dump ();
-}
-
-/* Called if the user enters ``show architecture'' without an argument. */
-static void
-show_architecture (char *args, int from_tty)
-{
-  const char *arch;
-  arch = TARGET_ARCHITECTURE->printable_name;
-  if (target_architecture_auto)
-    printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
-  else
-    printf_filtered ("The target architecture is assumed to be %s\n", arch);
-}
-
-/* Called if the user enters ``set architecture'' with or without an
-   argument. */
-static void
-set_architecture (char *args, int from_tty)
-{
-  if (args == NULL)
-    {
-      printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
-    }
-  else if (strcmp (args, "auto") == 0)
-    {
-      target_architecture_auto = 1;
-    }
-  else if (GDB_MULTI_ARCH)
-    {
-      const struct bfd_arch_info *arch = bfd_scan_arch (args);
-      if (arch == NULL)
-       printf_unfiltered ("Architecture `%s' not reconized.\n", args);
-      else
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.bfd_arch_info = arch;
-         if (gdbarch_update (info))
-           target_architecture_auto = 0;
-         else
-           printf_unfiltered ("Architecture `%s' not reconized.\n", args);
-       }
-    }
-  else
-    {
-      const struct bfd_arch_info *arch = bfd_scan_arch (args);
-      if (arch != NULL)
-       set_arch (arch, set_arch_manual);
-      else
-       printf_unfiltered ("Architecture `%s' not reconized.\n", args);
-    }
-}
-
-/* Called if the user enters ``info architecture'' without an argument. */
-static void
-info_architecture (char *args, int from_tty)
-{
-  enum bfd_architecture a;
-  if (GDB_MULTI_ARCH)
-    {
-      if (gdbarch_init_registrary != NULL)
-       {
-         struct gdbarch_init_registration *rego;
-         printf_filtered ("Available architectures are:\n");
-         for (rego = gdbarch_init_registrary;
-              rego != NULL;
-              rego = rego->next)
-           {
-             const struct bfd_arch_info *ap;
-             ap = bfd_lookup_arch (rego->bfd_architecture, 0);
-             if (ap != NULL)
-               {
-                 do
-                   {
-                     printf_filtered (" %s", ap->printable_name);
-                     ap = ap->next;
-                   }
-                 while (ap != NULL);
-                 printf_filtered ("\n");
-               }
-           }
-       }
-      else
-       {
-         printf_filtered ("There are no available architectures.\n");
-       }
-      return;
-    }
-  printf_filtered ("Available architectures are:\n");
-  for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
-    {
-      const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
-      if (ap != NULL)
-       {
-         do
-           {
-             printf_filtered (" %s", ap->printable_name);
-             ap = ap->next;
-           }
-         while (ap != NULL);
-         printf_filtered ("\n");
-       }
-    }
-}
-
-/* Set the architecture from arch/machine */
-void
-set_architecture_from_arch_mach (arch, mach)
-     enum bfd_architecture arch;
-     unsigned long mach;
-{
-  const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
-  if (wanted != NULL)
-    set_arch (wanted, set_arch_manual);
-  else
-    internal_error ("gdbarch: hardwired architecture/machine not reconized");
-}
+    gdbarch_dump (current_gdbarch, gdb_stdlog);
 
-/* Set the architecture from a BFD */
-static void
-set_architecture_from_file (bfd *abfd)
-{
-  const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
-  if (target_architecture_auto)
-    {
-      set_arch (wanted, set_arch_auto);
-    }
-  else if (wanted != target_architecture)
-    {
-      warning ("%s architecture file may be incompatible with %s target.",
-              wanted->printable_name,
-              target_architecture->printable_name);
-    }
-}
-
-
-/* Misc helper functions for targets. */
-
-int
-frame_num_args_unknown (fi)
-     struct frame_info *fi;
-{
-  return -1;
+  return 1;
 }
 
 
-int
-generic_register_convertible_not (num)
-     int num;
-{
-  return 0;
-}
-  
-
 /* Disassembler */
 
 /* Pointer to the target-dependent disassembly function.  */
@@ -3638,82 +3969,13 @@ int (*tm_print_insn) (bfd_vma, disassemble_info *);
 disassemble_info tm_print_insn_info;
 
 
-
-/* Set the dynamic target-system-dependant parameters (architecture,
-   byte-order) using information found in the BFD */
-
-void
-set_gdbarch_from_file (abfd)
-     bfd *abfd;
-{
-  if (GDB_MULTI_ARCH)
-    {
-      struct gdbarch_info info;
-      memset (&info, 0, sizeof info);
-      info.abfd = abfd;
-      gdbarch_update (info);
-      return;
-    }
-  set_architecture_from_file (abfd);
-  set_endian_from_file (abfd);
-}
-
-
-/* Initialize the current architecture.  */
-void
-initialize_current_architecture ()
-{
-  if (GDB_MULTI_ARCH)
-    {
-      struct gdbarch_init_registration *rego;
-      const struct bfd_arch_info *chosen = NULL;
-      for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
-       {
-         const struct bfd_arch_info *ap
-           = bfd_lookup_arch (rego->bfd_architecture, 0);
-
-         /* Choose the first architecture alphabetically.  */
-         if (chosen == NULL
-             || strcmp (ap->printable_name, chosen->printable_name) < 0)
-           chosen = ap;
-       }
-
-      if (chosen != NULL)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.bfd_arch_info = chosen;
-         gdbarch_update (info);
-       }
-    }
-}
-
 extern void _initialize_gdbarch (void);
+
 void
 _initialize_gdbarch ()
 {
   struct cmd_list_element *c;
 
-  add_prefix_cmd ("endian", class_support, set_endian,
-                 "Set endianness of target.",
-                 &endianlist, "set endian ", 0, &setlist);
-  add_cmd ("big", class_support, set_endian_big,
-          "Set target as being big endian.", &endianlist);
-  add_cmd ("little", class_support, set_endian_little,
-          "Set target as being little endian.", &endianlist);
-  add_cmd ("auto", class_support, set_endian_auto,
-          "Select target endianness automatically.", &endianlist);
-  add_cmd ("endian", class_support, show_endian,
-          "Show endianness of target.", &showlist);
-
-  add_cmd ("architecture", class_support, set_architecture,
-          "Set architecture of target.", &setlist);
-  add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
-  add_cmd ("architecture", class_support, show_architecture,
-          "Show architecture of target.", &showlist);
-  add_cmd ("architecture", class_support, info_architecture,
-          "List supported target architectures", &infolist);
-
   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
   tm_print_insn_info.read_memory_func = dis_asm_read_memory;

diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 1875774e4e792f546cd36c50437cd4b68fd2bb90..49932c03b6b9ad38b85120309f6e06baadbcf180 100644 (file)
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -1180,8 +1180,11 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
    gdbarch'' from the ARCHES list - indicating that the new
    architecture is just a synonym for an earlier architecture (see
    gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
-   - that describes the selected architecture (see
-   gdbarch_alloc()). */
+   - that describes the selected architecture (see gdbarch_alloc()).
+
+   The DUMP_TDEP function shall print out all target specific values.
+   Care should be taken to ensure that the function works in both the
+   multi-arch and non- multi-arch cases. */
 
 struct gdbarch_list
 {
@@ -1208,9 +1211,23 @@ struct gdbarch_info
 };
 
 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
+typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 
+/* DEPRECATED - use gdbarch_register() */
 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 
+extern void gdbarch_register (enum bfd_architecture architecture,
+                              gdbarch_init_ftype *,
+                              gdbarch_dump_tdep_ftype *);
+
+
+/* Return a freshly allocated, NULL terminated, array of the valid
+   architecture names.  Since architectures are registered during the
+   _initialize phase this function only returns useful information
+   once initialization has been completed. */
+
+extern const char **gdbarch_printable_names (void);
+
 
 /* Helper function.  Search the list of ARCHES for a GDBARCH that
    matches the information provided by INFO. */
@@ -1226,7 +1243,10 @@ extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *ar
 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 
 
-/* Helper function.  Free a partially-constructed ``struct gdbarch''.  */
+/* Helper function.  Free a partially-constructed ``struct gdbarch''.
+   It is assumed that the caller freeds the ``struct
+   gdbarch_tdep''. */
+
 extern void gdbarch_free (struct gdbarch *);
 
 
@@ -1342,13 +1362,6 @@ extern const struct bfd_arch_info *target_architecture;
 #define TARGET_ARCHITECTURE (target_architecture + 0)
 #endif
 
-/* Notify the target dependant backend of a change to the selected
-   architecture. A zero return status indicates that the target did
-   not like the change. */
-
-extern int (*target_architecture_hook) (const struct bfd_arch_info *);
-
-
 
 /* The target-system-dependant disassembler is semi-dynamic */
 
@@ -1397,26 +1410,15 @@ extern disassemble_info tm_print_insn_info;
 extern void set_gdbarch_from_file (bfd *);
 
 
-/* Explicitly set the dynamic target-system-dependant parameters based
-   on bfd_architecture and machine. */
-
-extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
-
-
 /* Initialize the current architecture to the "first" one we find on
    our list.  */
 
 extern void initialize_current_architecture (void);
 
-/* Helper function for targets that don't know how my arguments are
-   being passed */
-
-extern int frame_num_args_unknown (struct frame_info *fi);
-
 
 /* gdbarch trace variable */
 extern int gdbarch_debug;
 
-extern void gdbarch_dump (void);
+extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
 
 #endif

diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index bf7b47c1e5dc1a7f07e17d1d77b3d59059c297e1..83ff37eb3210e86922b0d24fc532721e874a46f9 100755 (executable)
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -250,6 +250,7 @@ do
        # An optional indicator for any predicte to wrap around the
        # print member code.
 
+       #   () -> Call a custom function to do the dump.
        #   exp -> Wrap print up in ``if (${print_p}) ...
        #   ``'' -> No predicate
 
@@ -670,8 +671,11 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
    gdbarch'' from the ARCHES list - indicating that the new
    architecture is just a synonym for an earlier architecture (see
    gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
-   - that describes the selected architecture (see
-   gdbarch_alloc()). */
+   - that describes the selected architecture (see gdbarch_alloc()).
+
+   The DUMP_TDEP function shall print out all target specific values.
+   Care should be taken to ensure that the function works in both the
+   multi-arch and non- multi-arch cases. */
 
 struct gdbarch_list
 {
@@ -698,9 +702,23 @@ struct gdbarch_info
 };
 
 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
+typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
 
+/* DEPRECATED - use gdbarch_register() */
 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
 
+extern void gdbarch_register (enum bfd_architecture architecture,
+                              gdbarch_init_ftype *,
+                              gdbarch_dump_tdep_ftype *);
+
+
+/* Return a freshly allocated, NULL terminated, array of the valid
+   architecture names.  Since architectures are registered during the
+   _initialize phase this function only returns useful information
+   once initialization has been completed. */
+
+extern const char **gdbarch_printable_names (void);
+
 
 /* Helper function.  Search the list of ARCHES for a GDBARCH that
    matches the information provided by INFO. */
@@ -716,7 +734,10 @@ extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *ar
 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
 
 
-/* Helper function.  Free a partially-constructed \`\`struct gdbarch''.  */
+/* Helper function.  Free a partially-constructed \`\`struct gdbarch''.
+   It is assumed that the caller freeds the \`\`struct
+   gdbarch_tdep''. */
+
 extern void gdbarch_free (struct gdbarch *);
 
 
@@ -832,13 +853,6 @@ extern const struct bfd_arch_info *target_architecture;
 #define TARGET_ARCHITECTURE (target_architecture + 0)
 #endif
 
-/* Notify the target dependant backend of a change to the selected
-   architecture. A zero return status indicates that the target did
-   not like the change. */
-
-extern int (*target_architecture_hook) (const struct bfd_arch_info *);
-
-
 
 /* The target-system-dependant disassembler is semi-dynamic */
 
@@ -887,27 +901,16 @@ extern disassemble_info tm_print_insn_info;
 extern void set_gdbarch_from_file (bfd *);
 
 
-/* Explicitly set the dynamic target-system-dependant parameters based
-   on bfd_architecture and machine. */
-
-extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
-
-
 /* Initialize the current architecture to the "first" one we find on
    our list.  */
 
 extern void initialize_current_architecture (void);
 
-/* Helper function for targets that don't know how my arguments are
-   being passed */
-
-extern int frame_num_args_unknown (struct frame_info *fi);
-
 
 /* gdbarch trace variable */
 extern int gdbarch_debug;
 
-extern void gdbarch_dump (void);
+extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
 
 #endif
 EOF
@@ -992,6 +995,7 @@ done
 echo ""
 echo "  /* target specific vector. */"
 echo "  struct gdbarch_tdep *tdep;"
+echo "  gdbarch_dump_tdep_ftype *dump_tdep;"
 echo ""
 echo "  /* per-architecture data-pointers */"
 echo "  int nr_data;"
@@ -1050,9 +1054,10 @@ EOF
 echo ""
 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
 echo ""
-echo "struct gdbarch startup_gdbarch = {"
+echo "struct gdbarch startup_gdbarch ="
+echo "{"
 echo "  /* basic architecture information */"
-function_list | while do_read # eval read $read
+function_list | while do_read
 do
     if class_is_info_p
     then
@@ -1060,8 +1065,8 @@ do
     fi
 done
 cat <<EOF
-  /* target specific vector */
-  NULL,
+  /* target specific vector and its dump routine */
+  NULL, NULL,
   /*per-architecture data-pointers and swap regions */
   0, NULL, NULL,
   /* Multi-arch values */
@@ -1076,6 +1081,7 @@ done
 cat <<EOF
   /* startup_gdbarch() */
 };
+
 struct gdbarch *current_gdbarch = &startup_gdbarch;
 EOF
 
@@ -1133,6 +1139,7 @@ cat <<EOF
    However, if an architecture's init function encounters an error
    building the structure, it may need to clean up a partially
    constructed gdbarch.  */
+
 void
 gdbarch_free (struct gdbarch *arch)
 {
@@ -1203,41 +1210,70 @@ EOF
 # dump the structure
 echo ""
 echo ""
-echo "/* Print out the details of the current architecture. */"
-echo ""
 cat <<EOF
+/* Print out the details of the current architecture. */
+
+/* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
+   just happens to match the global variable \`\`current_gdbarch''.  That
+   way macros refering to that variable get the local and not the global
+   version - ulgh.  Once everything is parameterised with gdbarch, this
+   will go away. */
+
 void
-gdbarch_dump (void)
+gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
 {
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
+                      GDB_MULTI_ARCH);
 EOF
-function_list | while do_read # eval read $read
+function_list | while do_read
 do
     echo "#ifdef ${macro}"
     if class_is_function_p
     then
-       echo "  fprintf_unfiltered (gdb_stdlog,"
-       echo "                      \"gdbarch_update: ${macro} = 0x%08lx\\n\","
-       echo "                      (long) current_gdbarch->${function}"
-       echo "                      /*${macro} ()*/);"
+       echo "  fprintf_unfiltered (file,"
+       echo "                      \"gdbarch_dump: %s # %s\\n\","
+       echo "                      \"${macro}(${actual})\","
+       echo "                      XSTRING (${macro} (${actual})));"
     else
-       if [ "${print_p}" ]
-       then
-         echo "  if (${print_p})"
-         echo "    fprintf_unfiltered (gdb_stdlog,"
-         echo "                        \"gdbarch_update: ${macro} = ${fmt}\\n\","
-         echo "                        ${print});"
-       else
-         echo "  fprintf_unfiltered (gdb_stdlog,"
-         echo "                      \"gdbarch_update: ${macro} = ${fmt}\\n\","
-         echo "                      ${print});"
-       fi
+       echo "  fprintf_unfiltered (file,"
+       echo "                      \"gdbarch_dump: ${macro} # %s\\n\","
+       echo "                      XSTRING (${macro}));"
+    fi
+    echo "#endif"
+done
+function_list | while do_read
+do
+    echo "#ifdef ${macro}"
+    if [ "${print_p}" = "()" ]
+    then
+       echo "  gdbarch_dump_${function} (current_gdbarch);"
+    elif [ "${print_p}" = "0" ]
+    then
+       echo "  /* skip print of ${macro}, print_p == 0. */"
+    elif [ "${print_p}" ]
+    then
+       echo "  if (${print_p})"
+       echo "    fprintf_unfiltered (file,"
+       echo "                        \"gdbarch_dump: ${macro} = ${fmt}\\n\","
+       echo "                        ${print});"
+    elif class_is_function_p
+    then
+       echo "  if (GDB_MULTI_ARCH)"
+       echo "    fprintf_unfiltered (file,"
+       echo "                        \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
+       echo "                        (long) current_gdbarch->${function}"
+       echo "                        /*${macro} ()*/);"
+    else
+       echo "  fprintf_unfiltered (file,"
+       echo "                      \"gdbarch_dump: ${macro} = ${fmt}\\n\","
+       echo "                      ${print});"
     fi
     echo "#endif"
 done
 cat <<EOF
-  fprintf_unfiltered (gdb_stdlog,
-                      "gdbarch_update: GDB_MULTI_ARCH = %d\\n",
-                      GDB_MULTI_ARCH);
+  if (current_gdbarch->dump_tdep != NULL)
+    current_gdbarch->dump_tdep (current_gdbarch, file);
 }
 EOF
 
@@ -1511,21 +1547,67 @@ swapin_gdbarch_swap (struct gdbarch *gdbarch)
 
 /* Keep a registrary of the architectures known by GDB. */
 
-struct gdbarch_init_registration
+struct gdbarch_registration
 {
   enum bfd_architecture bfd_architecture;
   gdbarch_init_ftype *init;
+  gdbarch_dump_tdep_ftype *dump_tdep;
   struct gdbarch_list *arches;
-  struct gdbarch_init_registration *next;
+  struct gdbarch_registration *next;
 };
 
-static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
+static struct gdbarch_registration *gdbarch_registrary = NULL;
+
+static void
+append_name (const char ***buf, int *nr, const char *name)
+{
+  *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
+  (*buf)[*nr] = name;
+  *nr += 1;
+}
+
+const char **
+gdbarch_printable_names (void)
+{
+  if (GDB_MULTI_ARCH)
+    {
+      /* Accumulate a list of names based on the registed list of
+         architectures. */
+      enum bfd_architecture a;
+      int nr_arches = 0;
+      const char **arches = NULL;
+      struct gdbarch_registration *rego;
+      for (rego = gdbarch_registrary;
+          rego != NULL;
+          rego = rego->next)
+       {
+         const struct bfd_arch_info *ap;
+         ap = bfd_lookup_arch (rego->bfd_architecture, 0);
+         if (ap == NULL)
+           internal_error ("gdbarch_architecture_names: multi-arch unknown");
+         do
+           {
+             append_name (&arches, &nr_arches, ap->printable_name);
+             ap = ap->next;
+           }
+         while (ap != NULL);
+       }
+      append_name (&arches, &nr_arches, NULL);
+      return arches;
+    }
+  else
+    /* Just return all the architectures that BFD knows.  Assume that
+       the legacy architecture framework supports them. */
+    return bfd_arch_list ();
+}
+
 
 void
-register_gdbarch_init (enum bfd_architecture bfd_architecture,
-                       gdbarch_init_ftype *init)
+gdbarch_register (enum bfd_architecture bfd_architecture,
+                  gdbarch_init_ftype *init,
+                 gdbarch_dump_tdep_ftype *dump_tdep)
 {
-  struct gdbarch_init_registration **curr;
+  struct gdbarch_registration **curr;
   const struct bfd_arch_info *bfd_arch_info;
   /* Check that BFD reconizes this architecture */
   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
@@ -1534,7 +1616,7 @@ register_gdbarch_init (enum bfd_architecture bfd_architecture,
       internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
     }
   /* Check that we haven't seen this architecture before */
-  for (curr = &gdbarch_init_registrary;
+  for (curr = &gdbarch_registrary;
        (*curr) != NULL;
        curr = &(*curr)->next)
     {
@@ -1548,13 +1630,26 @@ register_gdbarch_init (enum bfd_architecture bfd_architecture,
                        bfd_arch_info->printable_name,
                        (long) init);
   /* Append it */
-  (*curr) = XMALLOC (struct gdbarch_init_registration);
+  (*curr) = XMALLOC (struct gdbarch_registration);
   (*curr)->bfd_architecture = bfd_architecture;
   (*curr)->init = init;
+  (*curr)->dump_tdep = dump_tdep;
   (*curr)->arches = NULL;
   (*curr)->next = NULL;
+  /* When non- multi-arch, install what ever target dump routine we've
+     been provided - hopefully that routine has been writen correct
+     and works regardless of multi-arch. */
+  if (!GDB_MULTI_ARCH && dump_tdep != NULL
+      && startup_gdbarch.dump_tdep == NULL)
+    startup_gdbarch.dump_tdep = dump_tdep;
+}
+
+void
+register_gdbarch_init (enum bfd_architecture bfd_architecture,
+                      gdbarch_init_ftype *init)
+{
+  gdbarch_register (bfd_architecture, init, NULL);
 }
-  
 
 
 /* Look for an architecture using gdbarch_info.  Base search on only
@@ -1584,7 +1679,7 @@ gdbarch_update (struct gdbarch_info info)
 {
   struct gdbarch *new_gdbarch;
   struct gdbarch_list **list;
-  struct gdbarch_init_registration *rego;
+  struct gdbarch_registration *rego;
 
   /* Fill in any missing bits. Most important is the bfd_architecture
      which is used to select the target architecture. */
@@ -1618,9 +1713,11 @@ gdbarch_update (struct gdbarch_info info)
   /* A default for abfd? */
 
   /* Find the target that knows about this architecture. */
-  for (rego = gdbarch_init_registrary;
-       rego != NULL && rego->bfd_architecture != info.bfd_architecture;
-       rego = rego->next);
+  for (rego = gdbarch_registrary;
+       rego != NULL;
+       rego = rego->next)
+    if (rego->bfd_architecture == info.bfd_architecture)
+      break;
   if (rego == NULL)
     {
       if (gdbarch_debug)
@@ -1685,7 +1782,8 @@ gdbarch_update (struct gdbarch_info info)
       if ((*list)->gdbarch == new_gdbarch)
        {
          if (gdbarch_debug)
-           fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
+           fprintf_unfiltered (gdb_stdlog,
+                                "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
                                (long) new_gdbarch,
                                new_gdbarch->bfd_arch_info->printable_name);
          current_gdbarch = new_gdbarch;
@@ -1693,7 +1791,7 @@ gdbarch_update (struct gdbarch_info info)
          return 1;
        }
     }
-    
+
   /* Append this new architecture to this targets list. */
   (*list) = XMALLOC (struct gdbarch_list);
   (*list)->next = NULL;
@@ -1707,10 +1805,11 @@ gdbarch_update (struct gdbarch_info info)
                          "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
                          (long) new_gdbarch,
                          new_gdbarch->bfd_arch_info->printable_name);
-      gdbarch_dump ();
     }
   
-  /* Check that the newly installed architecture is valid.  */
+  /* Check that the newly installed architecture is valid.  Plug in
+     any post init values.  */
+  new_gdbarch->dump_tdep = rego->dump_tdep;
   verify_gdbarch (new_gdbarch);
 
   /* Initialize the per-architecture memory (swap) areas.
@@ -1723,366 +1822,13 @@ gdbarch_update (struct gdbarch_info info)
      must be updated before these modules are called. */
   init_gdbarch_data (new_gdbarch);
   
-  return 1;
-}
-
-
-
-/* Functions to manipulate the endianness of the target.  */
-
-#ifdef TARGET_BYTE_ORDER_SELECTABLE
-/* compat - Catch old targets that expect a selectable byte-order to
-   default to BIG_ENDIAN */
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
-#endif
-#endif
-#if !TARGET_BYTE_ORDER_SELECTABLE_P
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-/* compat - Catch old non byte-order selectable targets that do not
-   define TARGET_BYTE_ORDER_DEFAULT and instead expect
-   TARGET_BYTE_ORDER to be used as the default.  For targets that
-   defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
-   below will get a strange compiler warning. */
-#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
-#endif
-#endif
-#ifndef TARGET_BYTE_ORDER_DEFAULT
-#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
-#endif
-int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
-int target_byte_order_auto = 1;
-
-/* Chain containing the \"set endian\" commands.  */
-static struct cmd_list_element *endianlist = NULL;
-
-/* Called by \`\`show endian''.  */
-static void
-show_endian (char *args, int from_tty)
-{
-  char *msg =
-    (TARGET_BYTE_ORDER_AUTO
-     ? "The target endianness is set automatically (currently %s endian)\n"
-     : "The target is assumed to be %s endian\n");
-  printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
-}
-
-/* Called if the user enters \`\`set endian'' without an argument.  */
-static void
-set_endian (char *args, int from_tty)
-{
-  printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
-  show_endian (args, from_tty);
-}
-
-/* Called by \`\`set endian big''.  */
-static void
-set_endian_big (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order = BIG_ENDIAN;
-      target_byte_order_auto = 0;
-      if (GDB_MULTI_ARCH)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.byte_order = BIG_ENDIAN;
-         gdbarch_update (info);
-       }
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Called by \`\`set endian little''.  */
-static void
-set_endian_little (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order = LITTLE_ENDIAN;
-      target_byte_order_auto = 0;
-      if (GDB_MULTI_ARCH)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.byte_order = LITTLE_ENDIAN;
-         gdbarch_update (info);
-       }
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Called by \`\`set endian auto''.  */
-static void
-set_endian_auto (char *args, int from_tty)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      target_byte_order_auto = 1;
-    }
-  else
-    {
-      printf_unfiltered ("Byte order is not selectable.");
-      show_endian (args, from_tty);
-    }
-}
-
-/* Set the endianness from a BFD.  */
-static void
-set_endian_from_file (bfd *abfd)
-{
-  if (TARGET_BYTE_ORDER_SELECTABLE_P)
-    {
-      int want;
-      
-      if (bfd_big_endian (abfd))
-       want = BIG_ENDIAN;
-      else
-       want = LITTLE_ENDIAN;
-      if (TARGET_BYTE_ORDER_AUTO)
-       target_byte_order = want;
-      else if (TARGET_BYTE_ORDER != want)
-       warning ("%s endian file does not match %s endian target.",
-                want == BIG_ENDIAN ? "big" : "little",
-                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
-    }
-  else
-    {
-      if (bfd_big_endian (abfd)
-         ? TARGET_BYTE_ORDER != BIG_ENDIAN
-         : TARGET_BYTE_ORDER == BIG_ENDIAN)
-       warning ("%s endian file does not match %s endian target.",
-                bfd_big_endian (abfd) ? "big" : "little",
-                TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
-    }
-}
-
-
-
-/* Functions to manipulate the architecture of the target */
-
-enum set_arch { set_arch_auto, set_arch_manual };
-
-int target_architecture_auto = 1;
-extern const struct bfd_arch_info bfd_default_arch_struct;
-const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
-int (*target_architecture_hook) (const struct bfd_arch_info *ap);
-
-static void show_endian (char *, int);
-static void set_endian (char *, int);
-static void set_endian_big (char *, int);
-static void set_endian_little (char *, int);
-static void set_endian_auto (char *, int);
-static void set_endian_from_file (bfd *);
-static int arch_ok (const struct bfd_arch_info *arch);
-static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
-static void show_architecture (char *, int);
-static void set_architecture (char *, int);
-static void info_architecture (char *, int);
-static void set_architecture_from_file (bfd *);
-
-/* Do the real work of changing the current architecture */
-
-static int
-arch_ok (const struct bfd_arch_info *arch)
-{
-  /* Should be performing the more basic check that the binary is
-     compatible with GDB. */
-  /* Check with the target that the architecture is valid. */
-  return (target_architecture_hook == NULL
-         || target_architecture_hook (arch));
-}
-
-static void
-set_arch (const struct bfd_arch_info *arch,
-          enum set_arch type)
-{
-  switch (type)
-    {
-    case set_arch_auto:
-      if (!arch_ok (arch))
-       warning ("Target may not support %s architecture",
-                arch->printable_name);
-      target_architecture = arch;
-      break;
-    case set_arch_manual:
-      if (!arch_ok (arch))
-       {
-         printf_unfiltered ("Target does not support \`%s' architecture.\n",
-                            arch->printable_name);
-       }
-      else
-       {
-         target_architecture_auto = 0;
-         target_architecture = arch;
-       }
-      break;
-    }
   if (gdbarch_debug)
-    gdbarch_dump ();
-}
-
-/* Called if the user enters \`\`show architecture'' without an argument. */
-static void
-show_architecture (char *args, int from_tty)
-{
-  const char *arch;
-  arch = TARGET_ARCHITECTURE->printable_name;
-  if (target_architecture_auto)
-    printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
-  else
-    printf_filtered ("The target architecture is assumed to be %s\n", arch);
-}
-
-/* Called if the user enters \`\`set architecture'' with or without an
-   argument. */
-static void
-set_architecture (char *args, int from_tty)
-{
-  if (args == NULL)
-    {
-      printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
-    }
-  else if (strcmp (args, "auto") == 0)
-    {
-      target_architecture_auto = 1;
-    }
-  else if (GDB_MULTI_ARCH)
-    {
-      const struct bfd_arch_info *arch = bfd_scan_arch (args);
-      if (arch == NULL)
-       printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
-      else
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.bfd_arch_info = arch;
-         if (gdbarch_update (info))
-           target_architecture_auto = 0;
-         else
-           printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
-       }
-    }
-  else
-    {
-      const struct bfd_arch_info *arch = bfd_scan_arch (args);
-      if (arch != NULL)
-       set_arch (arch, set_arch_manual);
-      else
-       printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
-    }
-}
-
-/* Called if the user enters \`\`info architecture'' without an argument. */
-static void
-info_architecture (char *args, int from_tty)
-{
-  enum bfd_architecture a;
-  if (GDB_MULTI_ARCH)
-    {
-      if (gdbarch_init_registrary != NULL)
-       {
-         struct gdbarch_init_registration *rego;
-         printf_filtered ("Available architectures are:\n");
-         for (rego = gdbarch_init_registrary;
-              rego != NULL;
-              rego = rego->next)
-           {
-             const struct bfd_arch_info *ap;
-             ap = bfd_lookup_arch (rego->bfd_architecture, 0);
-             if (ap != NULL)
-               {
-                 do
-                   {
-                     printf_filtered (" %s", ap->printable_name);
-                     ap = ap->next;
-                   }
-                 while (ap != NULL);
-                 printf_filtered ("\n");
-               }
-           }
-       }
-      else
-       {
-         printf_filtered ("There are no available architectures.\n");
-       }
-      return;
-    }
-  printf_filtered ("Available architectures are:\n");
-  for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
-    {
-      const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
-      if (ap != NULL)
-       {
-         do
-           {
-             printf_filtered (" %s", ap->printable_name);
-             ap = ap->next;
-           }
-         while (ap != NULL);
-         printf_filtered ("\n");
-       }
-    }
-}
+    gdbarch_dump (current_gdbarch, gdb_stdlog);
 
-/* Set the architecture from arch/machine */
-void
-set_architecture_from_arch_mach (arch, mach)
-     enum bfd_architecture arch;
-     unsigned long mach;
-{
-  const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
-  if (wanted != NULL)
-    set_arch (wanted, set_arch_manual);
-  else
-    internal_error ("gdbarch: hardwired architecture/machine not reconized");
-}
-
-/* Set the architecture from a BFD */
-static void
-set_architecture_from_file (bfd *abfd)
-{
-  const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
-  if (target_architecture_auto)
-    {
-      set_arch (wanted, set_arch_auto);
-    }
-  else if (wanted != target_architecture)
-    {
-      warning ("%s architecture file may be incompatible with %s target.",
-              wanted->printable_name,
-              target_architecture->printable_name);
-    }
-}
-
-
-/* Misc helper functions for targets. */
-
-int
-frame_num_args_unknown (fi)
-     struct frame_info *fi;
-{
-  return -1;
+  return 1;
 }
 
 
-int
-generic_register_convertible_not (num)
-     int num;
-{
-  return 0;
-}
-  
-
 /* Disassembler */
 
 /* Pointer to the target-dependent disassembly function.  */
@@ -2090,82 +1836,13 @@ int (*tm_print_insn) (bfd_vma, disassemble_info *);
 disassemble_info tm_print_insn_info;
 
 
-
-/* Set the dynamic target-system-dependant parameters (architecture,
-   byte-order) using information found in the BFD */
-
-void
-set_gdbarch_from_file (abfd)
-     bfd *abfd;
-{
-  if (GDB_MULTI_ARCH)
-    {
-      struct gdbarch_info info;
-      memset (&info, 0, sizeof info);
-      info.abfd = abfd;
-      gdbarch_update (info);
-      return;
-    }
-  set_architecture_from_file (abfd);
-  set_endian_from_file (abfd);
-}
-
-
-/* Initialize the current architecture.  */
-void
-initialize_current_architecture ()
-{
-  if (GDB_MULTI_ARCH)
-    {
-      struct gdbarch_init_registration *rego;
-      const struct bfd_arch_info *chosen = NULL;
-      for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
-       {
-         const struct bfd_arch_info *ap
-           = bfd_lookup_arch (rego->bfd_architecture, 0);
-
-         /* Choose the first architecture alphabetically.  */
-         if (chosen == NULL
-             || strcmp (ap->printable_name, chosen->printable_name) < 0)
-           chosen = ap;
-       }
-
-      if (chosen != NULL)
-       {
-         struct gdbarch_info info;
-         memset (&info, 0, sizeof info);
-         info.bfd_arch_info = chosen;
-         gdbarch_update (info);
-       }
-    }
-}
-
 extern void _initialize_gdbarch (void);
+
 void
 _initialize_gdbarch ()
 {
   struct cmd_list_element *c;
 
-  add_prefix_cmd ("endian", class_support, set_endian,
-                 "Set endianness of target.",
-                 &endianlist, "set endian ", 0, &setlist);
-  add_cmd ("big", class_support, set_endian_big,
-          "Set target as being big endian.", &endianlist);
-  add_cmd ("little", class_support, set_endian_little,
-          "Set target as being little endian.", &endianlist);
-  add_cmd ("auto", class_support, set_endian_auto,
-          "Select target endianness automatically.", &endianlist);
-  add_cmd ("endian", class_support, show_endian,
-          "Show endianness of target.", &showlist);
-
-  add_cmd ("architecture", class_support, set_architecture,
-          "Set architecture of target.", &setlist);
-  add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
-  add_cmd ("architecture", class_support, show_architecture,
-          "Show architecture of target.", &showlist);
-  add_cmd ("architecture", class_support, info_architecture,
-          "List supported target architectures", &infolist);
-
   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
   tm_print_insn_info.read_memory_func = dis_asm_read_memory;

diff --git a/gdb/maint.c b/gdb/maint.c
index a4def305b5b26bbe118825afce048e80d42280f8..44dcba8e18eea68ad325edc63d6763857ab6b8c8 100644 (file)
--- a/gdb/maint.c
+++ b/gdb/maint.c
@@ -283,6 +283,21 @@ maintenance_print_statistics (args, from_tty)
   print_symbol_bcache_statistics ();
 }
 
+void
+maintenance_print_architecture (char *args, int from_tty)
+{
+  if (args == NULL)
+    gdbarch_dump (current_gdbarch, gdb_stdout);
+  else
+    {
+      struct ui_file *file = gdb_fopen (args, "w");
+      if (file == NULL)
+       perror_with_name ("maintenance print architecture");
+      gdbarch_dump (current_gdbarch, file);    
+      ui_file_delete (file);
+    }
+}
+
 /* The "maintenance print" command is defined as a prefix, with
    allow_unknown 0.  Therefore, its own definition is called only for
    "maintenance print" with no args.  */
@@ -569,6 +584,11 @@ If a SOURCE file is specified, dump only that file's partial symbols.",
           "Print statistics about internal gdb state.",
           &maintenanceprintlist);
 
+  add_cmd ("architecture", class_maintenance, maintenance_print_architecture,
+          "Print the internal architecture configuration.\
+Takes an optional file parameter.",
+          &maintenanceprintlist);
+
   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
           "Check consistency of psymtabs and symtabs.",
           &maintenancelist);

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 95dc72d7440a731a5a5215e05e773fc5499cd840..f81dd9a1bc0817d0bcd9c98c4ee772be01af216b 100644 (file)
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -3829,7 +3829,6 @@ mips_gdbarch_init (info, arches)
   struct gdbarch *gdbarch;
   struct gdbarch_tdep *tdep;
   int elf_flags;
-  char *ef_mips_abi;
   int ef_mips_bitptrs;
   int ef_mips_arch;
   enum mips_abi mips_abi;
@@ -3894,7 +3893,6 @@ mips_gdbarch_init (info, arches)
   switch (mips_abi)
     {
     case MIPS_ABI_O32:
-      ef_mips_abi = "o32";
       tdep->mips_default_saved_regsize = 4;
       tdep->mips_default_stack_argsize = 4;
       tdep->mips_fp_register_double = 0;
@@ -3906,7 +3904,6 @@ mips_gdbarch_init (info, arches)
       set_gdbarch_long_long_bit (gdbarch, 64);
       break;
     case MIPS_ABI_O64:
-      ef_mips_abi = "o64";
       tdep->mips_default_saved_regsize = 8;
       tdep->mips_default_stack_argsize = 8;
       tdep->mips_fp_register_double = 1;
@@ -3918,7 +3915,6 @@ mips_gdbarch_init (info, arches)
       set_gdbarch_long_long_bit (gdbarch, 64);
       break;
     case MIPS_ABI_EABI32:
-      ef_mips_abi = "eabi32";
       tdep->mips_default_saved_regsize = 4;
       tdep->mips_default_stack_argsize = 4;
       tdep->mips_fp_register_double = 0;
@@ -3930,7 +3926,6 @@ mips_gdbarch_init (info, arches)
       set_gdbarch_long_long_bit (gdbarch, 64);
       break;
     case MIPS_ABI_EABI64:
-      ef_mips_abi = "eabi64";
       tdep->mips_default_saved_regsize = 8;
       tdep->mips_default_stack_argsize = 8;
       tdep->mips_fp_register_double = 1;
@@ -3942,7 +3937,6 @@ mips_gdbarch_init (info, arches)
       set_gdbarch_long_long_bit (gdbarch, 64);
       break;
     case MIPS_ABI_N32:
-      ef_mips_abi = "n32";
       tdep->mips_default_saved_regsize = 4;
       tdep->mips_default_stack_argsize = 8;
       tdep->mips_fp_register_double = 1;
@@ -3954,7 +3948,6 @@ mips_gdbarch_init (info, arches)
       set_gdbarch_long_long_bit (gdbarch, 64);
       break;
     default:
-      ef_mips_abi = "default";
       tdep->mips_default_saved_regsize = MIPS_REGSIZE;
       tdep->mips_default_stack_argsize = MIPS_REGSIZE;
       tdep->mips_fp_register_double = (REGISTER_VIRTUAL_SIZE (FP0_REGNUM) == 8);
@@ -4078,67 +4071,78 @@ mips_gdbarch_init (info, arches)
   set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
   set_gdbarch_get_saved_register (gdbarch, mips_get_saved_register);
 
-  if (gdbarch_debug)
+  return gdbarch;
+}
+
+static void
+mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  if (tdep != NULL)
     {
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: (info)ef_mips_abi = %s\n",
-                         ef_mips_abi);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: (info)ef_mips_arch = %d\n",
-                         ef_mips_arch);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: (info)ef_mips_bitptrs = %d\n",
-                         ef_mips_bitptrs);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: MIPS_REGSIZE = %d\n",
-                         MIPS_REGSIZE);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->elf_flags = 0x%x\n",
+      fprintf_unfiltered (file,
+                         "mips_dump_tdep: tdep->elf_flags = 0x%x\n",
                          tdep->elf_flags);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_abi = %d\n",
+      fprintf_unfiltered (file,
+                         "mips_dump_tdep: tdep->mips_abi = %d\n",
                          tdep->mips_abi);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_fpu_type = %d (%s)\n",
-                         tdep->mips_fpu_type,
-                         (tdep->mips_fpu_type == MIPS_FPU_NONE ? "none"
-                          : tdep->mips_fpu_type == MIPS_FPU_SINGLE ? "single"
-                          : tdep->mips_fpu_type == MIPS_FPU_DOUBLE ? "double"
-                          : "???"));
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_last_arg_regnum = %d\n",
-                         tdep->mips_last_arg_regnum);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_last_fp_arg_regnum = %d (%d)\n",
-                         tdep->mips_last_fp_arg_regnum,
-                         tdep->mips_last_fp_arg_regnum - FP0_REGNUM);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_default_saved_regsize = %d\n",
-                         tdep->mips_default_saved_regsize);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_fp_register_double = %d (%s)\n",
-                         tdep->mips_fp_register_double,
-                         (tdep->mips_fp_register_double ? "true" : "false"));
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_regs_have_home_p = %d\n",
-                         tdep->mips_regs_have_home_p);
-      fprintf_unfiltered (gdb_stdlog,
-                         "mips_gdbarch_init: tdep->mips_default_stack_argsize = %d\n",
-                         tdep->mips_default_stack_argsize);
     }
-
-  return gdbarch;
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
+                     FP_REGISTER_DOUBLE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_DEFAULT_FPU_TYPE = %d (%s)\n",
+                     MIPS_DEFAULT_FPU_TYPE,
+                     (MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_NONE ? "none"
+                      : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
+                      : MIPS_DEFAULT_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
+                      : "???"));
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_EABI = %d\n",
+                     MIPS_EABI);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_LAST_FP_ARG_REGNUM = %d\n",
+                     MIPS_LAST_FP_ARG_REGNUM);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_LAST_ARG_REGNUM = %d\n",
+                     MIPS_LAST_ARG_REGNUM);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_FPU_TYPE = %d (%s)\n",
+                     MIPS_FPU_TYPE,
+                     (MIPS_FPU_TYPE == MIPS_FPU_NONE ? "none"
+                      : MIPS_FPU_TYPE == MIPS_FPU_SINGLE ? "single"
+                      : MIPS_FPU_TYPE == MIPS_FPU_DOUBLE ? "double"
+                      : "???"));
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_DEFAULT_SAVED_REGSIZE = %d\n",
+                     MIPS_DEFAULT_SAVED_REGSIZE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_SAVED_REGSIZE = %d\n",
+                     MIPS_SAVED_REGSIZE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: FP_REGISTER_DOUBLE = %d\n",
+                     FP_REGISTER_DOUBLE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_REGS_HAVE_HOME_P = %d\n",
+                     MIPS_REGS_HAVE_HOME_P);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_DEFAULT_STACK_ARGSIZE = %d\n",
+                     MIPS_DEFAULT_STACK_ARGSIZE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_STACK_ARGSIZE = %d\n",
+                     MIPS_STACK_ARGSIZE);
+  fprintf_unfiltered (file,
+                     "mips_dump_tdep: MIPS_REGSIZE = %d\n",
+                     MIPS_REGSIZE);
 }
 
-
 void
 _initialize_mips_tdep ()
 {
   static struct cmd_list_element *mipsfpulist = NULL;
   struct cmd_list_element *c;
 
-  if (GDB_MULTI_ARCH)
-    register_gdbarch_init (bfd_arch_mips, mips_gdbarch_init);
+  gdbarch_register (bfd_arch_mips, mips_gdbarch_init, mips_dump_tdep);
   if (!tm_print_insn)          /* Someone may have already set it */
     tm_print_insn = gdb_print_insn_mips;