merge from gcc

[deliverable/binutils-gdb.git] / gdb / ppc-sysv-tdep.c

diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 3824c99a6fa173a3cc5873bcdfd5aef0b9d41a3e..048bb707f320f75675eeb7eeb6dc4654f8754618 100644 (file)
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -1,7 +1,7 @@
 /* Target-dependent code for PowerPC systems using the SVR4 ABI
    for GDB, the GNU debugger.
 
-   Copyright 2000, 2001, 2002, 2003, 2005
+   Copyright (C) 2000, 2001, 2002, 2003, 2005
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -18,8 +18,8 @@
 
    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.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "defs.h"
 #include "gdbcore.h"
@@ -451,52 +451,33 @@ do_ppc_sysv_return_value (struct gdbarch *gdbarch, struct type *type,
     }
   if (broken_gcc && TYPE_LENGTH (type) <= 8)
     {
+      /* GCC screwed up for structures or unions whose size is less
+        than or equal to 8 bytes..  Instead of left-aligning, it
+        right-aligns the data into the buffer formed by r3, r4.  */
+      gdb_byte regvals[MAX_REGISTER_SIZE * 2];
+      int len = TYPE_LENGTH (type);
+      int offset = (2 * tdep->wordsize - len) % tdep->wordsize;
+
       if (readbuf)
        {
-         /* GCC screwed up.  The last register isn't "left" aligned.
-            Need to extract the least significant part of each
-            register and then store that.  */
-         /* Transfer any full words.  */
-         int word = 0;
-         while (1)
-           {
-             ULONGEST reg;
-             int len = TYPE_LENGTH (type) - word * tdep->wordsize;
-             if (len <= 0)
-               break;
-             if (len > tdep->wordsize)
-               len = tdep->wordsize;
-             regcache_cooked_read_unsigned (regcache,
-                                            tdep->ppc_gp0_regnum + 3 + word,
-                                            &reg);
-             store_unsigned_integer (((bfd_byte *) readbuf
-                                      + word * tdep->wordsize), len, reg);
-             word++;
-           }
+         regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3,
+                               regvals + 0 * tdep->wordsize);
+         if (len > tdep->wordsize)
+           regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4,
+                                 regvals + 1 * tdep->wordsize);
+         memcpy (readbuf, regvals + offset, len);
        }
       if (writebuf)
        {
-         /* GCC screwed up.  The last register isn't "left" aligned.
-            Need to extract the least significant part of each
-            register and then store that.  */
-         /* Transfer any full words.  */
-         int word = 0;
-         while (1)
-           {
-             ULONGEST reg;
-             int len = TYPE_LENGTH (type) - word * tdep->wordsize;
-             if (len <= 0)
-               break;
-             if (len > tdep->wordsize)
-               len = tdep->wordsize;
-             reg = extract_unsigned_integer (((const bfd_byte *) writebuf
-                                              + word * tdep->wordsize), len);
-             regcache_cooked_write_unsigned (regcache,
-                                             tdep->ppc_gp0_regnum + 3 + word,
-                                             reg);
-             word++;
-           }
+         memset (regvals, 0, sizeof regvals);
+         memcpy (regvals + offset, writebuf, len);
+         regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3,
+                                regvals + 0 * tdep->wordsize);
+         if (len > tdep->wordsize)
+           regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4,
+                                  regvals + 1 * tdep->wordsize);
        }
+
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
   if (TYPE_LENGTH (type) <= 8)
@@ -925,11 +906,11 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
        }
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
+  /* Integers in r3.  */
   if ((TYPE_CODE (valtype) == TYPE_CODE_INT
        || TYPE_CODE (valtype) == TYPE_CODE_ENUM)
       && TYPE_LENGTH (valtype) <= 8)
     {
-      /* Integers in r3.  */
       if (writebuf != NULL)
        {
          /* Be careful to sign extend the value.  */
@@ -957,24 +938,37 @@ ppc64_sysv_abi_return_value (struct gdbarch *gdbarch, struct type *valtype,
        regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf);
       return RETURN_VALUE_REGISTER_CONVENTION;
     }
-  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
-      && TYPE_LENGTH (valtype) <= 8
-      && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
-      && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
+  /* Array type has more than one use.  */
+  if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
     {
       /* Small character arrays are returned, right justified, in r3.  */
-      int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3)
-                   - TYPE_LENGTH (valtype));
-      if (writebuf != NULL)
-       regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
-                                   offset, TYPE_LENGTH (valtype), writebuf);
-      if (readbuf != NULL)
-       regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
-                                  offset, TYPE_LENGTH (valtype), readbuf);
-      return RETURN_VALUE_REGISTER_CONVENTION;
+      if (TYPE_LENGTH (valtype) <= 8
+        && TYPE_CODE (TYPE_TARGET_TYPE (valtype)) == TYPE_CODE_INT
+        && TYPE_LENGTH (TYPE_TARGET_TYPE (valtype)) == 1)
+        {
+          int offset = (register_size (gdbarch, tdep->ppc_gp0_regnum + 3)
+                       - TYPE_LENGTH (valtype));
+          if (writebuf != NULL)
+           regcache_cooked_write_part (regcache, tdep->ppc_gp0_regnum + 3,
+                                      offset, TYPE_LENGTH (valtype), writebuf);
+          if (readbuf != NULL)
+           regcache_cooked_read_part (regcache, tdep->ppc_gp0_regnum + 3,
+                                      offset, TYPE_LENGTH (valtype), readbuf);
+          return RETURN_VALUE_REGISTER_CONVENTION;
+       }
+      /* A VMX vector is returned in v2.  */
+      if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY
+        && TYPE_VECTOR (valtype) && tdep->ppc_vr0_regnum >= 0)
+        {
+          if (readbuf)
+            regcache_cooked_read (regcache, tdep->ppc_vr0_regnum + 2, readbuf);
+          if (writebuf)
+            regcache_cooked_write (regcache, tdep->ppc_vr0_regnum + 2, writebuf);
+          return RETURN_VALUE_REGISTER_CONVENTION;
+        }
     }
   /* Big floating point values get stored in adjacent floating
-     point registers.  */
+     point registers, starting with F1.  */
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT
       && (TYPE_LENGTH (valtype) == 16 || TYPE_LENGTH (valtype) == 32))
     {