* rs6000-tdep.c: #include "dwarf2expr.h".master-UNNAMED-BRANCHcvs/master-UNNAMED-BRANCH

(dwarf_piece_is_ev_upper_reg, dwarf_piece_is_gpr)
(e500_dwarf_simplify_register_pieces): New functions.
(rs6000_gdbarch_init): If the architecture is E500, register
e500_dwarf_simplify_register_pieces.
* Makefile.in (rs6000-tdep.o): Update dependencies.

* gdbarch.sh (dwarf_simplify_register_pieces): New method.
Add forward declaration for 'struct dwarf_expr_piece'.
* gdbarch.c, gdbarch.h: Regenerated.
* dwarf2loc.c (dwarf2_evaluate_loc_desc): Try to simplify
multi-piece expression results before giving up.
* arch-utils.c (dwarf_never_simplify_pieces): New function.
* arch-utils.h (struct dwarf_expr_piece): Forward decl for struct
type, used in ...
(dwarf_never_simplify_pieces): New declaration.

7 files changed, 1092 insertions, 5 deletions

diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
new file mode 100644
index 00000000000..d7a9b302b55
--- /dev/null
+++ b/gdb/arch-utils.c
@@ -0,0 +1,757 @@
+/* Dynamic architecture support for GDB, the GNU debugger.
+
+   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+
+#include "arch-utils.h"
+#include "buildsym.h"
+#include "gdbcmd.h"
+#include "inferior.h"		/* enum CALL_DUMMY_LOCATION et.al. */
+#include "gdb_string.h"
+#include "regcache.h"
+#include "gdb_assert.h"
+#include "sim-regno.h"
+#include "gdbcore.h"
+#include "osabi.h"
+
+#include "version.h"
+
+#include "floatformat.h"
+
+/* Implementation of extract return value that grubs around in the
+   register cache.  */
+void
+legacy_extract_return_value (struct type *type, struct regcache *regcache,
+			     void *valbuf)
+{
+  char *registers = deprecated_grub_regcache_for_registers (regcache);
+  bfd_byte *buf = valbuf;
+  DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
+}
+
+/* Implementation of store return value that grubs the register cache.
+   Takes a local copy of the buffer to avoid const problems.  */
+void
+legacy_store_return_value (struct type *type, struct regcache *regcache,
+			   const void *buf)
+{
+  bfd_byte *b = alloca (TYPE_LENGTH (type));
+  gdb_assert (regcache == current_regcache);
+  memcpy (b, buf, TYPE_LENGTH (type));
+  DEPRECATED_STORE_RETURN_VALUE (type, b);
+}
+
+int
+always_use_struct_convention (int gcc_p, struct type *value_type)
+{
+  return 1;
+}
+
+enum return_value_convention
+legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
+		     struct regcache *regcache, void *readbuf,
+		     const void *writebuf)
+{
+  /* NOTE: cagney/2004-06-13: The gcc_p parameter to
+     USE_STRUCT_CONVENTION isn't used.  */
+  int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+			|| TYPE_CODE (valtype) == TYPE_CODE_UNION
+			|| TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
+		       && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
+
+  if (writebuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      /* NOTE: cagney/2004-06-13: See stack.c:return_command.  Old
+	 architectures don't expect STORE_RETURN_VALUE to handle small
+	 structures.  Should not be called with such types.  */
+      gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
+		  && TYPE_CODE (valtype) != TYPE_CODE_UNION);
+      STORE_RETURN_VALUE (valtype, regcache, writebuf);
+    }
+
+  if (readbuf != NULL)
+    {
+      gdb_assert (!struct_return);
+      EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
+    }
+
+  if (struct_return)
+    return RETURN_VALUE_STRUCT_CONVENTION;
+  else
+    return RETURN_VALUE_REGISTER_CONVENTION;
+}
+
+int
+legacy_register_sim_regno (int regnum)
+{
+  /* Only makes sense to supply raw registers.  */
+  gdb_assert (regnum >= 0 && regnum < NUM_REGS);
+  /* NOTE: cagney/2002-05-13: The old code did it this way and it is
+     suspected that some GDB/SIM combinations may rely on this
+     behavour.  The default should be one2one_register_sim_regno
+     (below).  */
+  if (REGISTER_NAME (regnum) != NULL
+      && REGISTER_NAME (regnum)[0] != '\0')
+    return regnum;
+  else
+    return LEGACY_SIM_REGNO_IGNORE;
+}
+
+CORE_ADDR
+generic_skip_trampoline_code (CORE_ADDR pc)
+{
+  return 0;
+}
+
+CORE_ADDR
+generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+  return 0;
+}
+
+int
+generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
+{
+  return 0;
+}
+
+int
+generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
+{
+  return 0;
+}
+
+int
+generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+  return 0;
+}
+
+void
+generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
+				       struct regcache *regcache,
+				       CORE_ADDR gdb_addr, int gdb_len,
+				       CORE_ADDR * rem_addr, int *rem_len)
+{
+  *rem_addr = gdb_addr;
+  *rem_len = gdb_len;
+}
+
+/* Helper functions for INNER_THAN */
+
+int
+core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
+{
+  return (lhs < rhs);
+}
+
+int
+core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
+{
+  return (lhs > rhs);
+}
+
+
+/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
+
+const struct floatformat *
+default_float_format (struct gdbarch *gdbarch)
+{
+  int byte_order = gdbarch_byte_order (gdbarch);
+  switch (byte_order)
+    {
+    case BFD_ENDIAN_BIG:
+      return &floatformat_ieee_single_big;
+    case BFD_ENDIAN_LITTLE:
+      return &floatformat_ieee_single_little;
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "default_float_format: bad byte order");
+    }
+}
+
+
+const struct floatformat *
+default_double_format (struct gdbarch *gdbarch)
+{
+  int byte_order = gdbarch_byte_order (gdbarch);
+  switch (byte_order)
+    {
+    case BFD_ENDIAN_BIG:
+      return &floatformat_ieee_double_big;
+    case BFD_ENDIAN_LITTLE:
+      return &floatformat_ieee_double_little;
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "default_double_format: bad byte order");
+    }
+}
+
+/* Misc helper functions for targets. */
+
+CORE_ADDR
+core_addr_identity (CORE_ADDR addr)
+{
+  return addr;
+}
+
+CORE_ADDR
+convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
+				     struct target_ops *targ)
+{
+  return addr;
+}
+
+int
+no_op_reg_to_regnum (int reg)
+{
+  return reg;
+}
+
+CORE_ADDR
+deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev)
+{
+  if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
+    return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
+  else if (get_next_frame (prev) != NULL)
+    return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
+  else
+    return read_pc ();
+}
+
+int
+dwarf_never_simplify_pieces (int num_pieces,
+                             struct dwarf_expr_piece *pieces)
+{
+  return -1;
+}
+
+void
+default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
+{
+  return;
+}
+
+void
+default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
+{
+  return;
+}
+
+int
+cannot_register_not (int regnum)
+{
+  return 0;
+}
+
+/* Legacy version of target_virtual_frame_pointer().  Assumes that
+   there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+   raw.  */
+
+void
+legacy_virtual_frame_pointer (CORE_ADDR pc,
+			      int *frame_regnum,
+			      LONGEST *frame_offset)
+{
+  /* FIXME: cagney/2002-09-13: This code is used when identifying the
+     frame pointer of the current PC.  It is assuming that a single
+     register and an offset can determine this.  I think it should
+     instead generate a byte code expression as that would work better
+     with things like Dwarf2's CFI.  */
+  if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
+    *frame_regnum = DEPRECATED_FP_REGNUM;
+  else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
+    *frame_regnum = SP_REGNUM;
+  else
+    /* Should this be an internal error?  I guess so, it is reflecting
+       an architectural limitation in the current design.  */
+    internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
+  *frame_offset = 0;
+}
+
+/* Assume the world is sane, every register's virtual and real size
+   is identical.  */
+
+int
+generic_register_size (int regnum)
+{
+  gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
+  if (gdbarch_register_type_p (current_gdbarch))
+    return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
+  else
+    /* FIXME: cagney/2003-03-01: Once all architectures implement
+       gdbarch_register_type(), this entire function can go away.  It
+       is made obsolete by register_size().  */
+    return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
+}
+
+/* Assume all registers are adjacent.  */
+
+int
+generic_register_byte (int regnum)
+{
+  int byte;
+  int i;
+  gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
+  byte = 0;
+  for (i = 0; i < regnum; i++)
+    {
+      byte += generic_register_size (i);
+    }
+  return byte;
+}
+
+
+int
+legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
+{
+#if defined (DEPRECATED_IN_SIGTRAMP)
+  return DEPRECATED_IN_SIGTRAMP (pc, name);
+#else
+  return name && strcmp ("_sigtramp", name) == 0;
+#endif
+}
+
+int
+generic_convert_register_p (int regnum, struct type *type)
+{
+  return 0;
+}
+
+int
+default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
+{
+  if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
+      && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
+    {
+      CHECK_TYPEDEF (type);
+
+      return (TYPE_CODE (type) == TYPE_CODE_STRUCT
+	      || TYPE_CODE (type) == TYPE_CODE_UNION
+	      || TYPE_CODE (type) == TYPE_CODE_SET
+	      || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
+    }
+
+  return 0;
+}
+
+
+/* Functions to manipulate the endianness of the target.  */
+
+/* ``target_byte_order'' is only used when non- multi-arch.
+   Multi-arch targets obtain the current byte order using the
+   TARGET_BYTE_ORDER gdbarch method.
+
+   The choice of initial value is entirely arbitrary.  During startup,
+   the function initialize_current_architecture() updates this value
+   based on default byte-order information extracted from BFD.  */
+static int target_byte_order = BFD_ENDIAN_BIG;
+static int target_byte_order_auto = 1;
+
+enum bfd_endian
+selected_byte_order (void)
+{
+  if (target_byte_order_auto)
+    return BFD_ENDIAN_UNKNOWN;
+  else
+    return target_byte_order;
+}
+
+static const char endian_big[] = "big";
+static const char endian_little[] = "little";
+static const char endian_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 == BFD_ENDIAN_BIG ? "big" : "little"));
+  else
+    printf_unfiltered ("The target is assumed to be %s endian\n",
+		       (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
+}
+
+static void
+set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
+{
+  if (set_endian_string == endian_auto)
+    {
+      target_byte_order_auto = 1;
+    }
+  else if (set_endian_string == endian_little)
+    {
+      struct gdbarch_info info;
+      target_byte_order_auto = 0;
+      gdbarch_info_init (&info);
+      info.byte_order = BFD_ENDIAN_LITTLE;
+      if (! gdbarch_update_p (info))
+	printf_unfiltered ("Little endian target not supported by GDB\n");
+    }
+  else if (set_endian_string == endian_big)
+    {
+      struct gdbarch_info info;
+      target_byte_order_auto = 0;
+      gdbarch_info_init (&info);
+      info.byte_order = BFD_ENDIAN_BIG;
+      if (! gdbarch_update_p (info))
+	printf_unfiltered ("Big endian target not supported by GDB\n");
+    }
+  else
+    internal_error (__FILE__, __LINE__,
+		    "set_endian: bad value");
+  show_endian (NULL, from_tty);
+}
+
+/* Functions to manipulate the architecture of the target */
+
+enum set_arch { set_arch_auto, set_arch_manual };
+
+static int target_architecture_auto = 1;
+
+static const char *set_architecture_string;
+
+const char *
+selected_architecture_name (void)
+{
+  if (target_architecture_auto)
+    return NULL;
+  else
+    return set_architecture_string;
+}
+
+/* Called if the user enters ``show architecture'' without an
+   argument. */
+
+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
+    {
+      struct gdbarch_info info;
+      gdbarch_info_init (&info);
+      info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
+      if (info.bfd_arch_info == NULL)
+	internal_error (__FILE__, __LINE__,
+			"set_architecture: bfd_scan_arch failed");
+      if (gdbarch_update_p (info))
+	target_architecture_auto = 0;
+      else
+	printf_unfiltered ("Architecture `%s' not recognized.\n",
+			   set_architecture_string);
+    }
+  show_architecture (NULL, from_tty);
+}
+
+/* Try to select a global architecture that matches "info".  Return
+   non-zero if the attempt succeds.  */
+int
+gdbarch_update_p (struct gdbarch_info info)
+{
+  struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
+
+  /* If there no architecture by that name, reject the request.  */
+  if (new_gdbarch == NULL)
+    {
+      if (gdbarch_debug)
+	fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
+			    "Architecture not found\n");
+      return 0;
+    }
+
+  /* If it is the same old architecture, accept the request (but don't
+     swap anything).  */
+  if (new_gdbarch == current_gdbarch)
+    {
+      if (gdbarch_debug)
+	fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
+			    "Architecture 0x%08lx (%s) unchanged\n",
+			    (long) new_gdbarch,
+			    gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
+      return 1;
+    }
+
+  /* It's a new architecture, swap it in.  */
+  if (gdbarch_debug)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
+			"New architecture 0x%08lx (%s) selected\n",
+			(long) new_gdbarch,
+			gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
+  deprecated_current_gdbarch_select_hack (new_gdbarch);
+
+  return 1;
+}
+
+/* Return the architecture for ABFD.  If no suitable architecture
+   could be find, return NULL.  */
+
+struct gdbarch *
+gdbarch_from_bfd (bfd *abfd)
+{
+  struct gdbarch *old_gdbarch = current_gdbarch;
+  struct gdbarch *new_gdbarch;
+  struct gdbarch_info info;
+
+  gdbarch_info_init (&info);
+  info.abfd = abfd;
+  return gdbarch_find_by_info (info);
+}
+
+/* Set the dynamic target-system-dependent parameters (architecture,
+   byte-order) using information found in the BFD */
+
+void
+set_gdbarch_from_file (bfd *abfd)
+{
+  struct gdbarch *gdbarch;
+
+  gdbarch = gdbarch_from_bfd (abfd);
+  if (gdbarch == NULL)
+    error ("Architecture of file not recognized.\n");
+  deprecated_current_gdbarch_select_hack (gdbarch);
+}
+
+/* Initialize the current architecture.  Update the ``set
+   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;
+  gdbarch_info_init (&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 (__FILE__, __LINE__,
+			"initialize_current_architecture: No arch");
+      info.bfd_arch_info = bfd_scan_arch (chosen);
+      if (info.bfd_arch_info == NULL)
+	internal_error (__FILE__, __LINE__,
+			"initialize_current_architecture: Arch not found");
+    }
+
+  /* Take several guesses at a byte order.  */
+  if (info.byte_order == BFD_ENDIAN_UNKNOWN
+      && default_bfd_vec != NULL)
+    {
+      /* Extract BFD's default vector's byte order. */
+      switch (default_bfd_vec->byteorder)
+	{
+	case BFD_ENDIAN_BIG:
+	  info.byte_order = BFD_ENDIAN_BIG;
+	  break;
+	case BFD_ENDIAN_LITTLE:
+	  info.byte_order = BFD_ENDIAN_LITTLE;
+	  break;
+	default:
+	  break;
+	}
+    }
+  if (info.byte_order == BFD_ENDIAN_UNKNOWN)
+    {
+      /* 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 = BFD_ENDIAN_LITTLE;
+    }
+  if (info.byte_order == BFD_ENDIAN_UNKNOWN)
+    {
+      /* Wire it to big-endian!!! */
+      info.byte_order = BFD_ENDIAN_BIG;
+    }
+
+  if (! gdbarch_update_p (info))
+    internal_error (__FILE__, __LINE__,
+		    "initialize_current_architecture: Selection of initial architecture failed");
+
+  /* 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,
+			  arches, &set_architecture_string,
+			  "Set architecture of target.",
+			  &setlist);
+    set_cmd_sfunc (c, 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);
+  }
+}
+
+
+/* Initialize a gdbarch info to values that will be automatically
+   overridden.  Note: Originally, this ``struct info'' was initialized
+   using memset(0).  Unfortunately, that ran into problems, namely
+   BFD_ENDIAN_BIG is zero.  An explicit initialization function that
+   can explicitly set each field to a well defined value is used.  */
+
+void
+gdbarch_info_init (struct gdbarch_info *info)
+{
+  memset (info, 0, sizeof (struct gdbarch_info));
+  info->byte_order = BFD_ENDIAN_UNKNOWN;
+  info->osabi = GDB_OSABI_UNINITIALIZED;
+}
+
+/* Similar to init, but this time fill in the blanks.  Information is
+   obtained from the specified architecture, global "set ..." options,
+   and explicitly initialized INFO fields.  */
+
+void
+gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
+{
+  /* "(gdb) set architecture ...".  */
+  if (info->bfd_arch_info == NULL
+      && !target_architecture_auto
+      && gdbarch != NULL)
+    info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
+  if (info->bfd_arch_info == NULL
+      && info->abfd != NULL
+      && bfd_get_arch (info->abfd) != bfd_arch_unknown
+      && bfd_get_arch (info->abfd) != bfd_arch_obscure)
+    info->bfd_arch_info = bfd_get_arch_info (info->abfd);
+  if (info->bfd_arch_info == NULL
+      && gdbarch != NULL)
+    info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
+
+  /* "(gdb) set byte-order ...".  */
+  if (info->byte_order == BFD_ENDIAN_UNKNOWN
+      && !target_byte_order_auto
+      && gdbarch != NULL)
+    info->byte_order = gdbarch_byte_order (gdbarch);
+  /* From the INFO struct.  */
+  if (info->byte_order == BFD_ENDIAN_UNKNOWN
+      && info->abfd != NULL)
+    info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
+		       : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
+		       : BFD_ENDIAN_UNKNOWN);
+  /* From the current target.  */
+  if (info->byte_order == BFD_ENDIAN_UNKNOWN
+      && gdbarch != NULL)
+    info->byte_order = gdbarch_byte_order (gdbarch);
+
+  /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
+  if (info->osabi == GDB_OSABI_UNINITIALIZED)
+    info->osabi = gdbarch_lookup_osabi (info->abfd);
+  if (info->osabi == GDB_OSABI_UNINITIALIZED
+      && gdbarch != NULL)
+    info->osabi = gdbarch_osabi (gdbarch);
+
+  /* Must have at least filled in the architecture.  */
+  gdb_assert (info->bfd_arch_info != NULL);
+}
+
+/* */
+
+extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
+
+void
+_initialize_gdbarch_utils (void)
+{
+  struct cmd_list_element *c;
+  c = add_set_enum_cmd ("endian", class_support,
+			endian_enum, &set_endian_string,
+			"Set endianness of target.",
+			&setlist);
+  set_cmd_sfunc (c, 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
new file mode 100644
index 00000000000..a6639b99ad1
--- /dev/null
+++ b/gdb/arch-utils.h
@@ -0,0 +1,164 @@
+/* Dynamic architecture support for GDB, the GNU debugger.
+
+   Copyright 1998, 1999, 2000, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef GDBARCH_UTILS_H
+#define GDBARCH_UTILS_H
+
+struct gdbarch;
+struct frame_info;
+struct minimal_symbol;
+struct type;
+struct gdbarch_info;
+struct dwarf_expr_piece;
+
+/* gdbarch trace variable */
+extern int gdbarch_debug;
+
+/* An implementation of return_value that props up architectures still
+   using USE_STRUCT_RETURN, EXTRACT_RETURN_VALUE and
+   STORE_RETURN_VALUE.  See also the hacks in "stack.c".  */
+enum return_value_convention legacy_return_value (struct gdbarch *gdbarch,
+						  struct type *valtype,
+						  struct regcache *regcache,
+						  void *readbuf,
+						  const void *writebuf);
+
+/* Implementation of extract return value that grubs around in the
+   register cache.  */
+extern gdbarch_extract_return_value_ftype legacy_extract_return_value;
+
+/* Implementation of store return value that grubs the register cache.  */
+extern gdbarch_store_return_value_ftype legacy_store_return_value;
+
+/* To return any structure or union type by value, store it at the
+   address passed as an invisible first argument to the function.  */
+extern gdbarch_deprecated_use_struct_convention_ftype always_use_struct_convention;
+
+/* Typical remote_translate_xfer_address */
+extern gdbarch_remote_translate_xfer_address_ftype generic_remote_translate_xfer_address;
+
+/* The only possible cases for inner_than. */
+extern int core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs);
+extern int core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs);
+
+/* Floating point values. */
+extern const struct floatformat *default_float_format (struct gdbarch *gdbarch);
+extern const struct floatformat *default_double_format (struct gdbarch *gdbarch);
+
+/* Identity functions on a CORE_ADDR.  Just return the "addr".  */
+
+extern CORE_ADDR core_addr_identity (CORE_ADDR addr);
+extern gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr_identity;
+
+/* No-op conversion of reg to regnum. */
+
+extern int no_op_reg_to_regnum (int reg);
+
+/* Versions of init_frame_pc().  Do nothing; do the default. */
+
+extern CORE_ADDR deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev);
+
+/* Dwarf piece simplifier that never simplifies anything.  */
+extern int dwarf_never_simplify_pieces (int num_pieces,
+                                        struct dwarf_expr_piece *pieces);
+
+/* Do nothing version of elf_make_msymbol_special. */
+
+void default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym);
+
+/* Do nothing version of coff_make_msymbol_special. */
+
+void default_coff_make_msymbol_special (int val, struct minimal_symbol *msym);
+
+/* Version of cannot_fetch_register() / cannot_store_register() that
+   always fails. */
+
+int cannot_register_not (int regnum);
+
+/* Legacy version of target_virtual_frame_pointer().  Assumes that
+   there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+   raw.  */
+
+extern gdbarch_virtual_frame_pointer_ftype legacy_virtual_frame_pointer;
+
+extern CORE_ADDR generic_skip_trampoline_code (CORE_ADDR pc);
+
+extern CORE_ADDR generic_skip_solib_resolver (struct gdbarch *gdbarch,
+					      CORE_ADDR pc);
+
+extern int generic_in_solib_call_trampoline (CORE_ADDR pc, char *name);
+
+extern int generic_in_solib_return_trampoline (CORE_ADDR pc, char *name);
+
+extern int generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc);
+
+/* Assume that the world is sane, a registers raw and virtual size
+   both match its type.  */
+
+extern int generic_register_size (int regnum);
+
+/* Assume that the world is sane, the registers are all adjacent.  */
+extern int generic_register_byte (int regnum);
+
+/* Prop up old targets that use various sigtramp macros.  */
+extern int legacy_pc_in_sigtramp (CORE_ADDR pc, char *name);
+
+/* By default, registers are not convertible.  */
+extern int generic_convert_register_p (int regnum, struct type *type);
+
+extern int default_stabs_argument_has_addr (struct gdbarch *gdbarch,
+					    struct type *type);
+
+/* For compatibility with older architectures, returns
+   (LEGACY_SIM_REGNO_IGNORE) when the register doesn't have a valid
+   name.  */
+
+extern int legacy_register_sim_regno (int regnum);
+
+/* Return the selected byte order, or BFD_ENDIAN_UNKNOWN if no byte
+   order was explicitly selected.  */
+extern enum bfd_endian selected_byte_order (void);
+
+/* Return the selected architecture's name, or NULL if no architecture
+   was explicitly selected.  */
+extern const char *selected_architecture_name (void);
+
+/* Initialize a ``struct info''.  Can't use memset(0) since some
+   default values are not zero.  "fill" takes all available
+   information and fills in any unspecified fields.  */
+
+extern void gdbarch_info_init (struct gdbarch_info *info);
+extern void gdbarch_info_fill (struct gdbarch *gdbarch,
+			       struct gdbarch_info *info);
+
+/* Similar to init, but this time fill in the blanks.  Information is
+   obtained from the specified architecture, global "set ..." options,
+   and explicitly initialized INFO fields.  */
+extern void gdbarch_info_fill (struct gdbarch *gdbarch,
+			       struct gdbarch_info *info);
+
+/* Return the architecture for ABFD.  If no suitable architecture
+   could be find, return NULL.  */
+
+extern struct gdbarch *gdbarch_from_bfd (bfd *abfd);
+
+#endif
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index ed2744f7aca..42820a65d3b 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -231,11 +231,18 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 
   if (ctx->num_pieces > 0)
     {
-      /* We haven't implemented splicing together pieces from
-         arbitrary sources yet.  */
-      error ("The value of variable '%s' is distributed across several\n"
-             "locations, and GDB cannot access its value.\n",
-             SYMBOL_NATURAL_NAME (var));
+      CORE_ADDR simplified
+        = gdbarch_dwarf_simplify_register_pieces (arch, ctx->num_pieces,
+                                                  ctx->pieces);
+      if (simplified >= 0)
+        retval = value_from_register (SYMBOL_TYPE (var), simplified, frame);
+
+      /* We haven't implemented the more complex case of splicing
+         together pieces from arbitrary sources yet.  */
+      else
+        error ("The value of variable '%s' is distributed across several\n"
+               "locations, and GDB cannot access its value.\n",
+               SYMBOL_NATURAL_NAME (var));
     }
   else if (ctx->in_reg)
       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 798e3ea03fa..0796d44c84a 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -143,6 +143,7 @@ struct gdbarch
   gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
   gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
   gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
+  gdbarch_dwarf_simplify_register_pieces_ftype *dwarf_simplify_register_pieces;
   gdbarch_register_name_ftype *register_name;
   gdbarch_register_type_ftype *register_type;
   gdbarch_deprecated_register_virtual_type_ftype *deprecated_register_virtual_type;
@@ -292,6 +293,7 @@ struct gdbarch startup_gdbarch =
   0,  /* dwarf_reg_to_regnum */
   0,  /* sdb_reg_to_regnum */
   0,  /* dwarf2_reg_to_regnum */
+  dwarf_never_simplify_pieces,  /* dwarf_simplify_register_pieces */
   0,  /* register_name */
   0,  /* register_type */
   0,  /* deprecated_register_virtual_type */
@@ -451,6 +453,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
   current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
   current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
+  current_gdbarch->dwarf_simplify_register_pieces = dwarf_never_simplify_pieces;
   current_gdbarch->deprecated_register_byte = generic_register_byte;
   current_gdbarch->deprecated_register_raw_size = generic_register_size;
   current_gdbarch->deprecated_register_virtual_size = generic_register_size;
@@ -576,6 +579,9 @@ verify_gdbarch (struct gdbarch *current_gdbarch)
   /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
   /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
+      && (current_gdbarch->dwarf_simplify_register_pieces == dwarf_never_simplify_pieces))
+    fprintf_unfiltered (log, "\n\tdwarf_simplify_register_pieces");
   /* Skip verify of register_type, has predicate */
   /* Skip verify of deprecated_register_virtual_type, has predicate */
   /* Skip verify of deprecated_register_byte, has predicate */
@@ -1437,6 +1443,9 @@ gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
   fprintf_unfiltered (file,
                       "gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
                       (long) current_gdbarch->dwarf_reg_to_regnum);
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: dwarf_simplify_register_pieces = <0x%lx>\n",
+                      (long) current_gdbarch->dwarf_simplify_register_pieces);
 #ifdef ECOFF_REG_TO_REGNUM
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2606,6 +2615,23 @@ set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
   gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
 }
 
+int
+gdbarch_dwarf_simplify_register_pieces (struct gdbarch *gdbarch, int num_pieces, struct dwarf_expr_piece *pieces)
+{
+  gdb_assert (gdbarch != NULL);
+  gdb_assert (gdbarch->dwarf_simplify_register_pieces != NULL);
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_simplify_register_pieces called\n");
+  return gdbarch->dwarf_simplify_register_pieces (gdbarch, num_pieces, pieces);
+}
+
+void
+set_gdbarch_dwarf_simplify_register_pieces (struct gdbarch *gdbarch,
+                                            gdbarch_dwarf_simplify_register_pieces_ftype dwarf_simplify_register_pieces)
+{
+  gdbarch->dwarf_simplify_register_pieces = dwarf_simplify_register_pieces;
+}
+
 const char *
 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
 {
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index cf460b86840..eb501def9f4 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -49,6 +49,7 @@ struct regset;
 struct disassemble_info;
 struct target_ops;
 struct obstack;
+struct dwarf_expr_piece;
 
 extern struct gdbarch *current_gdbarch;
 
@@ -436,6 +437,32 @@ extern void set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch_d
 #define DWARF2_REG_TO_REGNUM(dwarf2_regnr) (gdbarch_dwarf2_reg_to_regnum (current_gdbarch, dwarf2_regnr))
 #endif
 
+/* On some architectures, GDB has registers that Dwarf treats as the
+   concatenation of two separate registers.  For example, PowerPC
+   variants implementing the SPE APU have 64-bit general-purpose
+   registers.  GDB refers to the lower 32 bits of each register as 'r0'
+   -- 'r31', and the full 64-bit registers as 'ev0' -- 'ev31'.
+   However, the Dwarf register numbering treats the upper halves as
+   separate registers.
+  
+   Dwarf location expressions describe variables allocated to such
+   registers using a series of DW_OP_piece operations.  In the case
+   above, the expressions would have the form:
+  
+     <upper half> DW_OP_piece 4 <lower half> DW_OP_piece 4.
+  
+   However, since GDB does have a register that corresponds to the
+   entire variable, it can simply say the variable lives in that
+   register; it needn't use a complicated location description.
+  
+   Given an array of NUM_PIECES pieces PIECES, return the number of the
+   register that is equivalent to those pieces, or -1 if there is no
+   such register. */
+
+typedef int (gdbarch_dwarf_simplify_register_pieces_ftype) (struct gdbarch *gdbarch, int num_pieces, struct dwarf_expr_piece *pieces);
+extern int gdbarch_dwarf_simplify_register_pieces (struct gdbarch *gdbarch, int num_pieces, struct dwarf_expr_piece *pieces);
+extern void set_gdbarch_dwarf_simplify_register_pieces (struct gdbarch *gdbarch, gdbarch_dwarf_simplify_register_pieces_ftype *dwarf_simplify_register_pieces);
+
 typedef const char * (gdbarch_register_name_ftype) (int regnr);
 extern const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr);
 extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name);
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 4cb1bc9d423..a0c9d0901d0 100755
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -457,6 +457,30 @@ f:=:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
 # Convert from an sdb register number to an internal gdb register number.
 f:=:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
 f:=:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
+
+# On some architectures, GDB has registers that Dwarf treats as the
+# concatenation of two separate registers.  For example, PowerPC
+# variants implementing the SPE APU have 64-bit general-purpose
+# registers.  GDB refers to the lower 32 bits of each register as 'r0'
+# -- 'r31', and the full 64-bit registers as 'ev0' -- 'ev31'.
+# However, the Dwarf register numbering treats the upper halves as
+# separate registers.
+#
+# Dwarf location expressions describe variables allocated to such
+# registers using a series of DW_OP_piece operations.  In the case
+# above, the expressions would have the form:
+#
+#   <upper half> DW_OP_piece 4 <lower half> DW_OP_piece 4.
+#
+# However, since GDB does have a register that corresponds to the
+# entire variable, it can simply say the variable lives in that
+# register; it needn't use a complicated location description.
+#
+# Given an array of NUM_PIECES pieces PIECES, return the number of the
+# register that is equivalent to those pieces, or -1 if there is no
+# such register.
+m::int:dwarf_simplify_register_pieces:int num_pieces, struct dwarf_expr_piece *pieces:num_pieces, pieces:::dwarf_never_simplify_pieces
+
 f:=:const char *:register_name:int regnr:regnr
 
 # REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
@@ -858,6 +882,7 @@ struct regset;
 struct disassemble_info;
 struct target_ops;
 struct obstack;
+struct dwarf_expr_piece;
 
 extern struct gdbarch *current_gdbarch;
 
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index 871e9b4d0fd..9bfcaec39b5 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -40,6 +40,7 @@
 #include "sim-regno.h"
 #include "gdb/sim-ppc.h"
 #include "reggroups.h"
+#include "dwarf2expr.h"
 #include "dwarf2-frame.h"
 
 #include "libbfd.h"		/* for bfd_default_set_arch_mach */
@@ -2006,6 +2007,84 @@ e500_register_reggroup_p (struct gdbarch *gdbarch,
   return default_register_reggroup_p (gdbarch, regnum, group);
 }
 
+/* Return true if PIECE is a SPE upper-half register for ARCH.
+   Remember that pieces use the Dwarf register numbering.  */
+static int
+dwarf_piece_is_ev_upper_reg (struct gdbarch *arch,
+                       struct dwarf_expr_piece *piece)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+
+  return (piece->in_reg
+          && 1200 <= piece->value
+          && piece->value < 1200 + ppc_num_gprs
+          && piece->size == register_size (arch, 
+                                           (piece->value - 1200
+                                            + tdep->ppc_ev0_upper_regnum)));
+}
+
+/* Return true if PIECE is a full GPR in ARCH.
+   Remember that pieces use the Dwarf register numbering.  */
+static int
+dwarf_piece_is_gpr (struct gdbarch *arch,
+                       struct dwarf_expr_piece *piece)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
+
+  return (piece->in_reg
+          && 0 <= piece->value
+          && piece->value < ppc_num_gprs
+          && (piece->size
+              == register_size (arch, piece->value + tdep->ppc_gp0_regnum)));
+}
+
+static int
+e500_dwarf_simplify_register_pieces (struct gdbarch *gdbarch,
+                                     int num_pieces,
+                                     struct dwarf_expr_piece *pieces)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+  if (num_pieces == 2)
+    {
+      int low, high;
+
+      /* Pieces are listed in order of increasing addresses, so the
+         endianness affects the order of the most- and least-
+         significant halves.  */
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+        high = 0, low = 1;
+      else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
+        low = 0, high = 1;
+      else
+        internal_error (__FILE__, __LINE__,
+                        "fetch_register: unexpected byte order: %d",
+                        gdbarch_byte_order (gdbarch));
+
+      /* An SPE vector register is the concatenation of an "upper
+         half" register with a GPR, each four bytes long.  */
+      if (dwarf_piece_is_ev_upper_reg (gdbarch, &pieces[high])
+          && dwarf_piece_is_gpr (gdbarch, &pieces[low])
+          && (pieces[high].value - 1200 == pieces[low].value))
+        /* Return the corresponding 64-bit 'ev' pseudo-register.  */
+        return tdep->ppc_ev0_regnum + pieces[low].value;
+      
+      /* long long values are sometimes placed in pairs of consecutive
+         registers.  The lower-addressed end of the value is always
+         assigned the lower-numbered register, so we don't need to
+         worry about endianness here.  */
+      else if (dwarf_piece_is_gpr (gdbarch, &pieces[0])
+               && dwarf_piece_is_gpr (gdbarch, &pieces[1])
+               && pieces[0].value + 1 == pieces[1].value)
+        return tdep->ppc_gp0_regnum + pieces[0].value;
+
+      else
+        return -1;
+    }
+  else
+    return -1;
+}
+
 /* Convert a DBX STABS register number to a GDB register number.  */
 static int
 rs6000_stab_reg_to_regnum (int num)
@@ -3177,6 +3256,8 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
         set_gdbarch_pseudo_register_read (gdbarch, e500_pseudo_register_read);
         set_gdbarch_pseudo_register_write (gdbarch, e500_pseudo_register_write);
         set_gdbarch_register_reggroup_p (gdbarch, e500_register_reggroup_p);
+        set_gdbarch_dwarf_simplify_register_pieces
+          (gdbarch, e500_dwarf_simplify_register_pieces);
 	break;
 
       case bfd_mach_ppc64: