2008-03-12 Paolo Bonzini <bonzini@gnu.org>

	PR tree-opt/35422
	* fold-const.c (fold_unary) <NOP_EXPR>: Distribute a narrowing
	conversion to the operands of a multiplication.

testsuite:
2008-03-12  Paolo Bonzini  <bonzini@gnu.org>

	PR tree-opt/35422
	* gcc.dg/vect/slp-7.c: Change target keywords required for vectorizing
	third loop.
	* gcc.target/i386/pr35422.c: New.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@133144 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4801608..dfdbfc2 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2008-03-12  Paolo Bonzini  <bonzini@gnu.org>
+
+       PR tree-opt/35422
+       * fold-const.c (fold_unary) <NOP_EXPR>: Distribute a narrowing
+       conversion to the operands of a multiplication.
+
 2008-03-12  Richard Guenther  <rguenther@suse.de>
 
        * Makefile.in (OBJS-common): Add tree-ssa-phiprop.o

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 4774661..7cf132b 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -7926,6 +7926,26 @@ fold_unary (enum tree_code code, tree type, tree op0)
            return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
        }
 
+      /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
+        type of X and Y (integer types only).  */
+      if (INTEGRAL_TYPE_P (type)
+         && TREE_CODE (op0) == MULT_EXPR
+         && INTEGRAL_TYPE_P (TREE_TYPE (op0))
+         && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
+       {
+         /* Be careful not to introduce new overflows.  */
+         tree mult_type;
+          if (TYPE_OVERFLOW_WRAPS (type))
+           mult_type = type;
+         else
+           mult_type = unsigned_type_for (type);
+         
+         tem = fold_build2 (MULT_EXPR, mult_type,
+                            fold_convert (mult_type, TREE_OPERAND (op0, 0)),
+                            fold_convert (mult_type, TREE_OPERAND (op0, 1)));
+         return fold_convert (type, tem);
+       }
+
       tem = fold_convert_const (code, type, op0);
       return tem ? tem : NULL_TREE;
 

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 52a96c3..a313f02 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,10 @@
+2008-03-12  Paolo Bonzini  <bonzini@gnu.org>
+
+       PR tree-opt/35422
+       * gcc.dg/vect/slp-7.c: Change target keywords required for vectorizing
+       third loop.
+       * gcc.target/i386/pr35422.c: New.
+
 2008-03-11  Andrew Pinski  <andrew_pinski@playstation.sony.com>
 
        PR tree-opt/35403

diff --git a/gcc/testsuite/gcc.dg/vect/slp-7.c b/gcc/testsuite/gcc.dg/vect/slp-7.c
index 4ee7029..f000fc9 100644 (file)
--- a/gcc/testsuite/gcc.dg/vect/slp-7.c
+++ b/gcc/testsuite/gcc.dg/vect/slp-7.c
@@ -120,8 +120,9 @@ int main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  {target {  vect_strided &&  vect_int_mult  } } } }*/
-/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  {target  { ! {  vect_strided && vect_int_mult } } } } } */
-/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  } } */
+/* { dg-final { scan-tree-dump-times "vectorized 3 loops" 1 "vect"  { target { vect_unpack && vect_int_mult } } } }*/
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect"  { target { ! { vect_unpack && vect_int_mult } } } } }*/
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 3 "vect"  { target { vect_unpack && vect_int_mult } } } } */
+/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 2 "vect"  { target { ! { vect_unpack && vect_int_mult } } } } } */
 /* { dg-final { cleanup-tree-dump "vect" } } */
  

diff --git a/gcc/testsuite/gcc.target/i386/pr34522.c b/gcc/testsuite/gcc.target/i386/pr34522.c
new file mode 100644 (file)
index 0000000..d5e66ae
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr34522.c
@@ -0,0 +1,13 @@
+/* { dg-options "-O2" } */
+/* { dg-do compile } */
+/* { dg-require-effective-target ilp32 } */
+
+int test(long long a, long long b)
+{
+        return a * b;
+}
+
+/* Check that we did not spill anything.  This is all that is needed
+   to qualify the generated code as "decent"...  */
+
+/* { dg-final { scan-assembler-not "%e[sd]i" } } */