In gcc/:

	* config/rs6000/rs6000.h (SLOW_UNALIGNED_ACCESS): Simplify.
	* config/rs6000/rs6000.c (rs6000_emit_move): Use adjust_address
	rather than simplify_subreg.  Check for volatile-ness.  Check that
	we're not splitting one slow operation into two slow operations.
In gcc/testsuite/:
	* gcc.c-torture/compile/structs.c: New testcase from GDB.

From-SVN: r47524

gcc/ChangeLog

+2001-12-02  Geoff Keating  <geoffk@redhat.com>
+
+	* config/rs6000/rs6000.h (SLOW_UNALIGNED_ACCESS): Simplify.
+	* config/rs6000/rs6000.c (rs6000_emit_move): Use adjust_address
+	rather than simplify_subreg.  Check for volatile-ness.  Check that
+	we're not splitting one slow operation into two slow operations.
+
 2001-12-02  David Edelsohn  <edelsohn@gnu.org>
 
 	* emit-rtl.c (gen_lowpart_common): Cast array element to HOST_WIDE_INT

gcc/config/rs6000/rs6000.c

@@ -1878,23 +1878,20 @@ rs6000_emit_move (dest, source, mode)
   if (GET_CODE (operands[0]) == MEM
       && GET_CODE (operands[1]) == MEM
       && mode == DImode
-      && (SLOW_UNALIGNED_ACCESS(DImode, MEM_ALIGN(operands[0]))
-	  || SLOW_UNALIGNED_ACCESS(DImode, MEM_ALIGN(operands[1]))))
-    {
-      if (!TARGET_POWERPC64)
-	{
-	  emit_move_insn (simplify_subreg (SImode, operands[0], DImode, 0),
-			  simplify_subreg (SImode, operands[1], DImode, 0));
-	  emit_move_insn (simplify_subreg (SImode, operands[0], DImode, 4),
-			  simplify_subreg (SImode, operands[1], DImode, 4));
-	}
-      else
-	{
-	  emit_move_insn (gen_lowpart (SImode, operands[0]),
-			  gen_lowpart (SImode, operands[1]));
-	  emit_move_insn (gen_highpart (SImode, operands[0]),
-			  gen_highpart (SImode, operands[1]));
-	}
+      && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
+	  || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
+      && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
+					    ? 32 : MEM_ALIGN (operands[0])))
+	    || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
+					       ? 32 
+					       : MEM_ALIGN (operands[1]))))
+      && ! MEM_VOLATILE_P (operands [0])
+      && ! MEM_VOLATILE_P (operands [1]))
+    {
+      emit_move_insn (adjust_address (operands[0], SImode, 0),
+		      adjust_address (operands[1], SImode, 0));
+      emit_move_insn (adjust_address (operands[0], SImode, 4),
+		      adjust_address (operands[1], SImode, 4));
       return;
     }
   

gcc/config/rs6000/rs6000.h

@@ -651,10 +651,10 @@ extern int rs6000_debug_arg;		/* debug argument handling */
 /* Define this macro to be the value 1 if unaligned accesses have a cost
    many times greater than aligned accesses, for example if they are
    emulated in a trap handler.  */
-#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN)			\
-   ((STRICT_ALIGNMENT						\
-     || (((MODE) == SFmode || (MODE) == DFmode || (MODE) == DImode) \
-         && (ALIGN) < 32)) ? 1 : 0)
+#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN)				\
+  (STRICT_ALIGNMENT							\
+   || (((MODE) == SFmode || (MODE) == DFmode || (MODE) == DImode)	\
+       && (ALIGN) < 32))
 
 /* Standard register usage.  */
 

gcc/testsuite/ChangeLog

+2001-12-01  Geoff Keating  <geoffk@redhat.com>
+
+	* gcc.c-torture/compile/structs.c: New testcase from GDB.
+
 2001-12-02  Neil Booth  <neil@daikokuya.demon.co.uk>
 
 	* objc.dg/alias.m: Update.

gcc/testsuite/gcc.c-torture/compile/structs.c

+/* Copyright 1996, 1999 Free Software Foundation, Inc.
+
+   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.
+
+   Please email any bugs, comments, and/or additions to this file to:
+   bug-gdb@prep.ai.mit.edu  */
+
+struct struct1 { char a;};
+struct struct2 { char a, b;};
+struct struct3 { char a, b, c; };
+struct struct4 { char a, b, c, d; };
+struct struct5 { char a, b, c, d, e; };
+struct struct6 { char a, b, c, d, e, f; };
+struct struct7 { char a, b, c, d, e, f, g; };
+struct struct8 { char a, b, c, d, e, f, g, h; };
+struct struct9 { char a, b, c, d, e, f, g, h, i; };
+struct struct10 { char a, b, c, d, e, f, g, h, i, j; };
+struct struct11 { char a, b, c, d, e, f, g, h, i, j, k; };
+struct struct12 { char a, b, c, d, e, f, g, h, i, j, k, l; };
+struct struct16 { char a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p; };
+
+struct struct1 foo1 = {'1'},  L1;
+struct struct2 foo2 = { 'a', 'b'},  L2;
+struct struct3 foo3 = { 'A', 'B', 'C'},  L3;
+struct struct4 foo4 = {'1', '2', '3', '4'},  L4;
+struct struct5 foo5 = {'a', 'b', 'c', 'd', 'e'},  L5;
+struct struct6 foo6 = {'A', 'B', 'C', 'D', 'E', 'F'},  L6;
+struct struct7 foo7 = {'1', '2', '3', '4', '5', '6', '7'},  L7;
+struct struct8 foo8 = {'1', '2', '3', '4', '5', '6', '7', '8'},  L8;
+struct struct9 foo9 = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'},  L9;
+struct struct10 foo10 = {
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'},  L10;
+struct struct11 foo11 = {
+  '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B'}, L11;
+struct struct12 foo12 = {
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'}, L12;
+struct struct16 foo16 = {
+  'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'}, L16;
+
+struct struct1  fun1()
+{
+  return foo1;  
+}
+struct struct2  fun2()
+{
+  return foo2;
+}
+struct struct3  fun3()
+{
+  return foo3;
+}
+struct struct4  fun4()
+{
+  return foo4;
+}
+struct struct5  fun5()
+{
+  return foo5;
+}
+struct struct6  fun6()
+{
+  return foo6;
+}
+struct struct7  fun7()
+{
+  return foo7;
+}
+struct struct8  fun8()
+{
+  return foo8;
+}
+struct struct9  fun9()
+{
+  return foo9;
+}
+struct struct10 fun10()
+{
+  return foo10; 
+}
+struct struct11 fun11()
+{
+  return foo11; 
+}
+struct struct12 fun12()
+{
+  return foo12; 
+}
+struct struct16 fun16()
+{
+  return foo16; 
+}
+
+#ifdef PROTOTYPES
+void Fun1(struct struct1 foo1)
+#else
+void Fun1(foo1)
+     struct struct1 foo1;
+#endif
+{
+  L1 = foo1;
+}
+#ifdef PROTOTYPES
+void Fun2(struct struct2 foo2)
+#else
+void Fun2(foo2)
+     struct struct2 foo2;
+#endif
+{
+  L2 = foo2;
+}
+#ifdef PROTOTYPES
+void Fun3(struct struct3 foo3)
+#else
+void Fun3(foo3)
+     struct struct3 foo3;
+#endif
+{
+  L3 = foo3;
+}
+#ifdef PROTOTYPES
+void Fun4(struct struct4 foo4)
+#else
+void Fun4(foo4)
+     struct struct4 foo4;
+#endif
+{
+  L4 = foo4;
+}
+#ifdef PROTOTYPES
+void Fun5(struct struct5 foo5)
+#else
+void Fun5(foo5)
+     struct struct5 foo5;
+#endif
+{
+  L5 = foo5;
+}
+#ifdef PROTOTYPES
+void Fun6(struct struct6 foo6)
+#else
+void Fun6(foo6)
+     struct struct6 foo6;
+#endif
+{
+  L6 = foo6;
+}
+#ifdef PROTOTYPES
+void Fun7(struct struct7 foo7)
+#else
+void Fun7(foo7)
+     struct struct7 foo7;
+#endif
+{
+  L7 = foo7;
+}
+#ifdef PROTOTYPES
+void Fun8(struct struct8 foo8)
+#else
+void Fun8(foo8)
+     struct struct8 foo8;
+#endif
+{
+  L8 = foo8;
+}
+#ifdef PROTOTYPES
+void Fun9(struct struct9 foo9)
+#else
+void Fun9(foo9)
+     struct struct9 foo9;
+#endif
+{
+  L9 = foo9;
+}
+#ifdef PROTOTYPES
+void Fun10(struct struct10 foo10)
+#else
+void Fun10(foo10)
+     struct struct10 foo10;
+#endif
+{
+  L10 = foo10; 
+}
+#ifdef PROTOTYPES
+void Fun11(struct struct11 foo11)
+#else
+void Fun11(foo11)
+     struct struct11 foo11;
+#endif
+{
+  L11 = foo11; 
+}
+#ifdef PROTOTYPES
+void Fun12(struct struct12 foo12)
+#else
+void Fun12(foo12)
+     struct struct12 foo12;
+#endif
+{
+  L12 = foo12; 
+}
+#ifdef PROTOTYPES
+void Fun16(struct struct16 foo16)
+#else
+void Fun16(foo16)
+     struct struct16 foo16;
+#endif
+{
+  L16 = foo16; 
+}
+
+int main()
+{
+#ifdef usestubs
+  set_debug_traps();
+  breakpoint();
+#endif
+
+  /* TEST C FUNCTIONS */
+  L1  = fun1();	
+  L2  = fun2();	
+  L3  = fun3();	
+  L4  = fun4();	
+  L5  = fun5();	
+  L6  = fun6();	
+  L7  = fun7();	
+  L8  = fun8();	
+  L9  = fun9();	
+  L10 = fun10();
+  L11 = fun11();
+  L12 = fun12();
+  L16 = fun16();
+
+  foo1.a = foo2.a = foo3.a = foo4.a = foo5.a = foo6.a = foo7.a = foo8.a =
+    foo9.a = foo10.a = foo11.a = foo12.a = foo16.a = '$';
+
+  Fun1(foo1);	
+  Fun2(foo2);	
+  Fun3(foo3);	
+  Fun4(foo4);	
+  Fun5(foo5);	
+  Fun6(foo6);	
+  Fun7(foo7);	
+  Fun8(foo8);	
+  Fun9(foo9);	
+  Fun10(foo10);
+  Fun11(foo11);
+  Fun12(foo12);
+  Fun16(foo16);
+
+  return 0;
+}