Patchwork vector comparisons in C++

login
register
mail settings
Submitter Marc Glisse
Date Sept. 14, 2012, 4:33 p.m.
Message ID <alpine.DEB.2.02.1209141827190.18857@stedding.saclay.inria.fr>
Download mbox | patch
Permalink /patch/183973/
State New
Headers show

Comments

Marc Glisse - Sept. 14, 2012, 4:33 p.m.
On Fri, 14 Sep 2012, Jason Merrill wrote:

> On 09/14/2012 11:03 AM, Marc Glisse wrote:
>> I wanted to use decltype(x<x) to find an integer vector type of the same
>> size as x, and then actually be able to use it. Being opaque, it refuses
>> to be initialized (cp/decl.c:5550). Maybe decltype (and others?) could
>> return non-opaque types?
>
> That sounds like the right answer.

Ok, I'll open a bugzilla to remember to try that later.

>> Type is %qT right? I see a number of %q#T but can't remember where the
>> doc is. Well, I'll try both and see what happens.
>
> Either one works; the # asks for more verbose output.

The %qT looked good enough to me (it prints the alias and the type). I 
added the types in an "inform" because the line was already getting long, 
I hope that's ok.

The attached just finished the testsuite (changelog unchanged).
Jason Merrill - Sept. 14, 2012, 4:50 p.m.
On 09/14/2012 12:33 PM, Marc Glisse wrote:
> Ok, I'll open a bugzilla to remember to try that later.

OK.

> The attached just finished the testsuite (changelog unchanged).

This patch is OK.

Jason
Marc Glisse - Sept. 14, 2012, 5:29 p.m.
On Fri, 14 Sep 2012, Jason Merrill wrote:

[decltype of opaque vector]

I think a simple TYPE_MAIN_VARIANT will do, I just need to find where to 
add it, and how much to constrain that change. Type deduction in templates 
and auto already seem to remove opacity :-)

> This patch is OK.

Committed. Thank you for all the quick comments,

Patch

Index: gcc/gimple-fold.c

===================================================================
--- gcc/gimple-fold.c	(revision 191291)

+++ gcc/gimple-fold.c	(working copy)

@@ -23,20 +23,21 @@  along with GCC; see the file COPYING3.

 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
 #include "flags.h"
 #include "function.h"
 #include "dumpfile.h"
 #include "tree-flow.h"
 #include "tree-ssa-propagate.h"
 #include "target.h"
 #include "gimple-fold.h"
+#include "langhooks.h"

 
 /* Return true when DECL can be referenced from current unit.
    FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
    We can get declarations that are not possible to reference for various
    reasons:
 
      1) When analyzing C++ virtual tables.
 	C++ virtual tables do have known constructors even
 	when they are keyed to other compilation unit.
 	Those tables can contain pointers to methods and vars
@@ -1685,41 +1686,51 @@  and_var_with_comparison_1 (gimple stmt,

    (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
    If this can be done without constructing an intermediate value,
    return the resulting tree; otherwise NULL_TREE is returned.
    This function is deliberately asymmetric as it recurses on SSA_DEFs
    in the first comparison but not the second.  */
 
 static tree
 and_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
 		   enum tree_code code2, tree op2a, tree op2b)
 {
+  tree truth_type = boolean_type_node;

+  if (TREE_CODE (TREE_TYPE (op1a)) == VECTOR_TYPE)

+    {

+      tree vec_type = TREE_TYPE (op1a);

+      tree elem = lang_hooks.types.type_for_size

+	(GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (vec_type))), 0);

+      truth_type = build_opaque_vector_type (elem,

+					     TYPE_VECTOR_SUBPARTS (vec_type));

+    }

+

   /* First check for ((x CODE1 y) AND (x CODE2 y)).  */
   if (operand_equal_p (op1a, op2a, 0)
       && operand_equal_p (op1b, op2b, 0))
     {
       /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ANDIF_EXPR, code1, code2,
-				    boolean_type_node, op1a, op1b);

+				    truth_type, op1a, op1b);

       if (t)
 	return t;
     }
 
   /* Likewise the swapped case of the above.  */
   if (operand_equal_p (op1a, op2b, 0)
       && operand_equal_p (op1b, op2a, 0))
     {
       /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ANDIF_EXPR, code1,
 				    swap_tree_comparison (code2),
-				    boolean_type_node, op1a, op1b);

+				    truth_type, op1a, op1b);

       if (t)
 	return t;
     }
 
   /* If both comparisons are of the same value against constants, we might
      be able to merge them.  */
   if (operand_equal_p (op1a, op2a, 0)
       && TREE_CODE (op1b) == INTEGER_CST
       && TREE_CODE (op2b) == INTEGER_CST)
     {
@@ -2147,41 +2158,51 @@  or_var_with_comparison_1 (gimple stmt,

    (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
    If this can be done without constructing an intermediate value,
    return the resulting tree; otherwise NULL_TREE is returned.
    This function is deliberately asymmetric as it recurses on SSA_DEFs
    in the first comparison but not the second.  */
 
 static tree
 or_comparisons_1 (enum tree_code code1, tree op1a, tree op1b,
 		  enum tree_code code2, tree op2a, tree op2b)
 {
+  tree truth_type = boolean_type_node;

+  if (TREE_CODE (TREE_TYPE (op1a)) == VECTOR_TYPE)

+    {

+      tree vec_type = TREE_TYPE (op1a);

+      tree elem = lang_hooks.types.type_for_size

+	(GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (vec_type))), 0);

+      truth_type = build_opaque_vector_type (elem,

+					     TYPE_VECTOR_SUBPARTS (vec_type));

+    }

+

   /* First check for ((x CODE1 y) OR (x CODE2 y)).  */
   if (operand_equal_p (op1a, op2a, 0)
       && operand_equal_p (op1b, op2b, 0))
     {
       /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ORIF_EXPR, code1, code2,
-				    boolean_type_node, op1a, op1b);

+				    truth_type, op1a, op1b);

       if (t)
 	return t;
     }
 
   /* Likewise the swapped case of the above.  */
   if (operand_equal_p (op1a, op2b, 0)
       && operand_equal_p (op1b, op2a, 0))
     {
       /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ORIF_EXPR, code1,
 				    swap_tree_comparison (code2),
-				    boolean_type_node, op1a, op1b);

+				    truth_type, op1a, op1b);

       if (t)
 	return t;
     }
 
   /* If both comparisons are of the same value against constants, we might
      be able to merge them.  */
   if (operand_equal_p (op1a, op2a, 0)
       && TREE_CODE (op1b) == INTEGER_CST
       && TREE_CODE (op2b) == INTEGER_CST)
     {
Index: gcc/cp/typeck.c

===================================================================
--- gcc/cp/typeck.c	(revision 191291)

+++ gcc/cp/typeck.c	(working copy)

@@ -3978,21 +3978,29 @@  cp_build_binary_op (location_t location,

     case TRUTH_AND_EXPR:
     case TRUTH_OR_EXPR:
       result_type = boolean_type_node;
       break;
 
       /* Shift operations: result has same type as first operand;
 	 always convert second operand to int.
 	 Also set SHORT_SHIFT if shifting rightward.  */
 
     case RSHIFT_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)

+      if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE

+	  && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE

+	  && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE

+	  && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))

+	{

+	  result_type = type0;

+	  converted = 1;

+	}

+      else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)

 	{
 	  result_type = type0;
 	  if (TREE_CODE (op1) == INTEGER_CST)
 	    {
 	      if (tree_int_cst_lt (op1, integer_zero_node))
 		{
 		  if ((complain & tf_warning)
 		      && c_inhibit_evaluation_warnings == 0)
 		    warning (0, "right shift count is negative");
 		}
@@ -4007,21 +4015,29 @@  cp_build_binary_op (location_t location,

 	  /* Convert the shift-count to an integer, regardless of
 	     size of value being shifted.  */
 	  if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
 	    op1 = cp_convert (integer_type_node, op1, complain);
 	  /* Avoid converting op1 to result_type later.  */
 	  converted = 1;
 	}
       break;
 
     case LSHIFT_EXPR:
-      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)

+      if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE

+	  && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE

+	  && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE

+	  && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))

+	{

+	  result_type = type0;

+	  converted = 1;

+	}

+      else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)

 	{
 	  result_type = type0;
 	  if (TREE_CODE (op1) == INTEGER_CST)
 	    {
 	      if (tree_int_cst_lt (op1, integer_zero_node))
 		{
 		  if ((complain & tf_warning)
 		      && c_inhibit_evaluation_warnings == 0)
 		    warning (0, "left shift count is negative");
 		}
@@ -4065,20 +4081,22 @@  cp_build_binary_op (location_t location,

 	    }
 	  /* Convert the shift-count to an integer, regardless of
 	     size of value being shifted.  */
 	  if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
 	    op1 = cp_convert (integer_type_node, op1, complain);
 	}
       break;
 
     case EQ_EXPR:
     case NE_EXPR:
+      if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)

+	goto vector_compare;

       if ((complain & tf_warning)
 	  && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
 	warning (OPT_Wfloat_equal,
 		 "comparing floating point with == or != is unsafe");
       if ((complain & tf_warning)
 	  && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
 	      || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
 	warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
 
       build_type = boolean_type_node;
@@ -4307,20 +4325,49 @@  cp_build_binary_op (location_t location,

     case GE_EXPR:
     case LT_EXPR:
     case GT_EXPR:
       if (TREE_CODE (orig_op0) == STRING_CST
 	  || TREE_CODE (orig_op1) == STRING_CST)
 	{
 	  if (complain & tf_warning)
 	    warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
 	}
 
+      if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)

+	{

+	vector_compare:

+	  tree intt;

+	  if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),

+							  TREE_TYPE (type1)))

+	    {

+	      error_at (location, "comparing vectors with different "

+				  "element types");

+	      inform (location, "operand types are %qT and %qT", type0, type1);

+	      return error_mark_node;

+	    }

+

+	  if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))

+	    {

+	      error_at (location, "comparing vectors with different "

+				  "number of elements");

+	      inform (location, "operand types are %qT and %qT", type0, type1);

+	      return error_mark_node;

+	    }

+

+	  /* Always construct signed integer vector type.  */

+	  intt = c_common_type_for_size (GET_MODE_BITSIZE

+					   (TYPE_MODE (TREE_TYPE (type0))), 0);

+	  result_type = build_opaque_vector_type (intt,

+						  TYPE_VECTOR_SUBPARTS (type0));

+	  converted = 1;

+	  break;

+	}

       build_type = boolean_type_node;
       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
 	   || code0 == ENUMERAL_TYPE)
 	   && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
 	       || code1 == ENUMERAL_TYPE))
 	short_compare = 1;
       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
 	result_type = composite_pointer_type (type0, type1, op0, op1,
 					      CPO_COMPARISON, complain);
       else if (code0 == POINTER_TYPE && null_ptr_cst_p (op1))
Index: gcc/testsuite/c-c++-common/vector-shift1.c

===================================================================
--- gcc/testsuite/c-c++-common/vector-shift1.c	(revision 190834)

+++ gcc/testsuite/c-c++-common/vector-shift1.c	(working copy)

@@ -1,18 +1,19 @@ 

 /* { dg-do compile } */
+/* { dg-prune-output "in evaluation of" } */

 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 int main (int argc, char *argv[]) {
     vector(4, float) vfloat0 = {1., 2., 3., 4.};
     vector(4, float) vfloat1 = {1., 2., 3., 4.};
     
     vector(4,   int) vint   = {1,  1,  1,  1 };
     
     vint <<= vfloat0;  /* { dg-error "nvalid operands to binary <<" } */
     vfloat0 >>= vint;  /* { dg-error "nvalid operands to binary >>" } */
 
-    vfloat0 <<= vfloat1;  /* { dg-error "nvalid operands to binary <<" } */

+    vfloat0 <<= vfloat1;  /* { dg-error "nvalid operands" } */

 
     return 0;
 }
 
Index: gcc/testsuite/c-c++-common/vector-shift3.c

===================================================================
--- gcc/testsuite/c-c++-common/vector-shift3.c	(revision 190834)

+++ gcc/testsuite/c-c++-common/vector-shift3.c	(working copy)

@@ -1,16 +1,16 @@ 

 /* { dg-do compile } */
 
 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 
 int main (int argc, char *argv[]) {
-    vector(8, short) v0 = {argc,2,3,4,5,6,7};

+    vector(8, short) v0 = {(short)argc,2,3,4,5,6,7};

     short sc;
 
     
-    scalar1 <<= v0; /* { dg-error ".*scalar1.*undeclared" } */

+    scalar1 <<= v0; /* { dg-error "scalar1.*(undeclared|was not declared)" } */

    
     return 0;
 }
 
Index: gcc/testsuite/c-c++-common/vector-compare-1.c

===================================================================
--- gcc/testsuite/c-c++-common/vector-compare-1.c	(revision 190834)

+++ gcc/testsuite/c-c++-common/vector-compare-1.c	(working copy)

@@ -1,19 +1,20 @@ 

 /* { dg-do compile } */
 /* { dg-options "-mabi=altivec" { target { { powerpc*-*-linux* } && ilp32 } } } */
+/* { dg-prune-output "operand types are" } */

 
 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 void
 foo (vector (4, int) x, vector (4, float) y)
 {
   vector (4, int) p4;
   vector (4, int) r4;
   vector (4, unsigned int) q4;
   vector (8, int) r8;
   vector (4, float) f4;
   
   r4 = x > y;	    /* { dg-error "comparing vectors with different element types" } */
-  r8 = (x != p4);   /* { dg-error "incompatible types when assigning to type" } */

+  r8 = (x != p4);   /* { dg-error "incompatible types when assigning to type|cannot convert" } */

   r8 == r4;	    /* { dg-error "comparing vectors with different number of elements" } */
 }
Index: gcc/testsuite/c-c++-common/vector-compare-3.c

===================================================================
--- gcc/testsuite/c-c++-common/vector-compare-3.c	(revision 0)

+++ gcc/testsuite/c-c++-common/vector-compare-3.c	(revision 0)

@@ -0,0 +1,25 @@ 

+/* { dg-do compile } */

+/* { dg-options "-O2" } */

+

+typedef int v4i __attribute__((vector_size(4*sizeof(int))));

+

+// fold should not turn (vec_other)(x<y) into (x<y)?vec_other(-1):vec_other(0).

+

+void use (v4i const *z);

+

+void

+f (v4i *x, v4i *y)

+{

+  v4i const zz = *x < *y;

+  use (&zz);

+}

+

+// Optimizations shouldn't introduce a boolean type in there

+

+void

+g (v4i *x, v4i const *y, v4i *z, v4i *t)

+{

+  *z = *x < *y | *x == *y;

+  *t = *x < *y & *x > *y;

+}

+


Property changes on: gcc/testsuite/c-c++-common/vector-compare-3.c
___________________________________________________________________
Added: svn:keywords
   + Author Date Id Revision URL
Added: svn:eol-style
   + native

Index: gcc/testsuite/c-c++-common/vector-shift.c

===================================================================
--- gcc/testsuite/c-c++-common/vector-shift.c	(revision 190834)

+++ gcc/testsuite/c-c++-common/vector-shift.c	(working copy)

@@ -1,11 +1,12 @@ 

 /* { dg-do compile } */
+/* { dg-prune-output "in evaluation of" } */

 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 int main (int argc, char *argv[]) {
     vector(4,char) vchar = {1,2,3,4};
     vector(4, int) vint  = {1,1,1,1};
     
     vint <<= vchar;  /* { dg-error "nvalid operands to binary <<" } */
     vchar >>= vint;  /* { dg-error "nvalid operands to binary >>" } */
 
Index: gcc/testsuite/c-c++-common/torture/vector-compare-1.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-compare-1.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-compare-1.c	(working copy)

@@ -1,10 +1,11 @@ 

+/* { dg-do run } */

 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 #define check_compare(count, res, i0, i1, op, fmt) \
 do { \
     int __i; \
     for (__i = 0; __i < count; __i ++) { \
       if ((res)[__i] != ((i0)[__i] op (i1)[__i] ? -1 : 0)) \
 	{ \
             __builtin_printf ("%i != ((" fmt " " #op " " fmt " ? -1 : 0) ", \
@@ -31,76 +32,76 @@  do { \

 } while (0)
 
 
 int main (int argc, char *argv[]) {
 #define INT  int
     vector (4, INT) i0;
     vector (4, INT) i1;
     vector (4, int) ires;
     int i;
 
-    i0 = (vector (4, INT)){argc, 1,  2,  10};

+    i0 = (vector (4, INT)){(INT)argc, 1,  2,  10};

     i1 = (vector (4, INT)){0, 3, 2, (INT)-23};
     test (4, i0, i1, ires, "%i");
 #undef INT
 
 #define INT unsigned int
     vector (4, int) ures;
     vector (4, INT) u0;
     vector (4, INT) u1;
 
-    u0 = (vector (4, INT)){argc, 1,  2,  10};

+    u0 = (vector (4, INT)){(INT)argc, 1,  2,  10};

     u1 = (vector (4, INT)){0, 3, 2, (INT)-23};
     test (4, u0, u1, ures, "%u");
 #undef INT
 
 
 #define SHORT short
     vector (8, SHORT) s0;
     vector (8, SHORT) s1;
     vector (8, short) sres;
 
-    s0 = (vector (8, SHORT)){argc, 1,  2,  10,  6, 87, (SHORT)-5, 2};

+    s0 = (vector (8, SHORT)){(SHORT)argc, 1,  2,  10,  6, 87, (SHORT)-5, 2};

     s1 = (vector (8, SHORT)){0, 3, 2, (SHORT)-23, 12, 10, (SHORT)-2, 0};
     test (8, s0, s1, sres, "%i");
 #undef SHORT
 
 #define SHORT unsigned short
     vector (8, SHORT) us0;
     vector (8, SHORT) us1;
     vector (8, short) usres;
 
-    us0 = (vector (8, SHORT)){argc, 1,  2,  10,  6, 87, (SHORT)-5, 2};

+    us0 = (vector (8, SHORT)){(SHORT)argc, 1,  2,  10,  6, 87, (SHORT)-5, 2};

     us1 = (vector (8, SHORT)){0, 3, 2, (SHORT)-23, 12, 10, (SHORT)-2, 0};
     test (8, us0, us1, usres, "%u");
 #undef SHORT
 
 #define CHAR signed char
     vector (16, CHAR) c0;
     vector (16, CHAR) c1;
     vector (16, signed char) cres;
 
-    c0 = (vector (16, CHAR)){argc, 1,  2,  10,  6, 87, (CHAR)-5, 2, \

-                             argc, 1,  2,  10,  6, 87, (CHAR)-5, 2 };

+    c0 = (vector (16, CHAR)){(CHAR)argc, 1,  2,  10,  6, 87, (CHAR)-5, 2, \

+                             (CHAR)argc, 1,  2,  10,  6, 87, (CHAR)-5, 2 };

 
     c1 = (vector (16, CHAR)){0, 3, 2, (CHAR)-23, 12, 10, (CHAR)-2, 0, \
                              0, 3, 2, (CHAR)-23, 12, 10, (CHAR)-2, 0};
     test (16, c0, c1, cres, "%i");
 #undef CHAR
 
 #define CHAR unsigned char
     vector (16, CHAR) uc0;
     vector (16, CHAR) uc1;
     vector (16, signed char) ucres;
 
-    uc0 = (vector (16, CHAR)){argc, 1,  2,  10,  6, 87, (CHAR)-5, 2, \

-                             argc, 1,  2,  10,  6, 87, (CHAR)-5, 2 };

+    uc0 = (vector (16, CHAR)){(CHAR)argc, 1,  2,  10,  6, 87, (CHAR)-5, 2, \

+                              (CHAR)argc, 1,  2,  10,  6, 87, (CHAR)-5, 2 };

 
     uc1 = (vector (16, CHAR)){0, 3, 2, (CHAR)-23, 12, 10, (CHAR)-2, 0, \
                              0, 3, 2, (CHAR)-23, 12, 10, (CHAR)-2, 0};
     test (16, uc0, uc1, ucres, "%u");
 #undef CHAR
 /* Float comparison.  */
     vector (4, float) f0;
     vector (4, float) f1;
     __typeof (f0 == f1) ifres;
 
Index: gcc/testsuite/c-c++-common/torture/vector-compare-2.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-compare-2.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-compare-2.c	(working copy)

@@ -1,10 +1,12 @@ 

+/* { dg-do run } */

+/* { dg-options "-Wno-psabi" } */

 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 /* Check that constant folding in 
    these simple cases works.  */
 vector (4, int)
 foo (vector (4, int) x)
 {
   return   (x == x) + (x != x) + (x >  x) 
 	 + (x <  x) + (x >= x) + (x <= x);
Index: gcc/testsuite/c-c++-common/torture/vector-shift2.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-shift2.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-shift2.c	(working copy)

@@ -1,10 +1,11 @@ 

+/* { dg-do run } */

 #define vector(elcount, type)  \
 __attribute__((vector_size((elcount)*sizeof(type)))) type
 
 #define vidx(type, vec, idx) (*((type *) &(vec) + idx))
 #define uint unsigned int
 
 int main (int argc, char *argv[]) {
     vector(4, uint) vuint  = { 1,  2,  3,  4};
     vector(4,  int) vint0  = { 1,  1,  1,  1};
     vector(4,  int) vint1  = {-1, -1, -1, -1};
Index: gcc/testsuite/c-c++-common/torture/vector-subscript-1.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-subscript-1.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-subscript-1.c	(working copy)

@@ -1,11 +1,11 @@ 

-/* dg-do run */

+/* { dg-do run } */

 #define vector __attribute__((vector_size(sizeof(int)*4) ))
 
 /* Check to make sure that we extract and insert the vector at the same
    location for vector subscripting and that vectors layout are the same
    as arrays. */
 
 struct TV4
 {
     vector int v;
 };
Index: gcc/testsuite/c-c++-common/torture/vector-subscript-2.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-subscript-2.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-subscript-2.c	(working copy)

@@ -1,10 +1,11 @@ 

+/* { dg-do run } */

 #define vector __attribute__((vector_size(sizeof(int)*4) ))
 
 /* Check to make sure that we extract and insert the vector at the same
    location for vector subscripting (with constant indexes) and
    that vectors layout are the same as arrays. */
 
 struct TV4
 {
     vector int v;
 };
Index: gcc/testsuite/c-c++-common/torture/vector-shift.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-shift.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-shift.c	(working copy)

@@ -1,29 +1,30 @@ 

+/* { dg-do run } */

 
 #define vector __attribute__((vector_size(sizeof(int)*4) ))
 
 static vector int allones = {1, 1, 1, 1};
 static vector int allzeros = {0, 0, 0, 0};
 static vector int numbers = {0, 1, 2, 3};
 static vector int numbersleftshiftallones = {0, 2, 4, 6};
 static vector int numbersrightshiftallones = {0, 0, 1, 1};
 
 
 static vector unsigned int uallones = {1, 1, 1, 1};
 static vector unsigned int uallzeros = {0, 0, 0, 0};
 static vector unsigned int unumbers = {0, 1, 2, 3};
 static vector unsigned int unumbersleftshiftallones = {0, 2, 4, 6};
 static vector unsigned int unumbersrightshiftallones = {0, 0, 1, 1};
 
 #define TEST(result, expected) \
 do { \
-  typeof(result) result1 = result; \

+  __typeof__(result) result1 = result; \

   if(sizeof (result1) != sizeof (expected)) \
     __builtin_abort (); \
   if (__builtin_memcmp (&result1, &expected, sizeof(result1)) != 0) \
     __builtin_abort (); \
 }while (0);
 
 int main(void)
 {
   vector int result;
   TEST ((numbers << allzeros), numbers);
Index: gcc/testsuite/c-c++-common/torture/vector-subscript-3.c

===================================================================
--- gcc/testsuite/c-c++-common/torture/vector-subscript-3.c	(revision 190838)

+++ gcc/testsuite/c-c++-common/torture/vector-subscript-3.c	(working copy)

@@ -1,11 +1,11 @@ 

-/* dg-do run */

+/* { dg-do run } */

 #define vector __attribute__((vector_size(16) ))
 
 /* Check whether register declaration of vector type still 
    allow us to subscript this type.  */
 
 typedef vector short myvec_t;
 
 struct vec_s {
     vector short member;
 };
Index: gcc/testsuite/g++.dg/other/vector-compare.C

===================================================================
--- gcc/testsuite/g++.dg/other/vector-compare.C	(revision 0)

+++ gcc/testsuite/g++.dg/other/vector-compare.C	(revision 0)

@@ -0,0 +1,36 @@ 

+/* { dg-do compile } */

+/* { dg-options "-std=gnu++11 -Wall" } */

+

+// Check that we can compare vector types that really are the same through

+// typedefs.

+

+typedef float v4f __attribute__((vector_size(4*sizeof(float))));

+

+template <class T> void eat (T&&) {}

+

+template <class T, int n>

+struct Vec

+{

+  typedef T type __attribute__((vector_size(4*sizeof(T))));

+

+  template <class U>

+  static void fun (type const& t, U& u) { eat (t > u); }

+};

+

+long long

+f (v4f *x, v4f const *y)

+{

+  return ((*x < *y) | (*x <= *y))[2];

+}

+

+int main ()

+{

+  v4f x = {0,1,2,3};

+  Vec<const volatile float,4>::type f = {-1,5,2,3.1};

+  auto c = (x == f) == (x >= x);

+  eat (c[3]);

+  Vec<const volatile float,4>::fun (f, x);

+  Vec<const volatile float,4>::fun (x, f);

+  Vec<const volatile float,4>::fun (f, f);

+  Vec<const volatile float,4>::fun (x, x);

+}


Property changes on: gcc/testsuite/g++.dg/other/vector-compare.C
___________________________________________________________________
Added: svn:keywords
   + Author Date Id Revision URL
Added: svn:eol-style
   + native

Index: gcc/fold-const.c

===================================================================
--- gcc/fold-const.c	(revision 191291)

+++ gcc/fold-const.c	(working copy)

@@ -7764,21 +7764,21 @@  fold_unary_loc (location_t loc, enum tre

 	  /* If we have (type) (a CMP b) and type is an integral type, return
 	     new expression involving the new type.  Canonicalize
 	     (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
 	     non-integral type.
 	     Do not fold the result as that would not simplify further, also
 	     folding again results in recursions.  */
 	  if (TREE_CODE (type) == BOOLEAN_TYPE)
 	    return build2_loc (loc, TREE_CODE (op0), type,
 			       TREE_OPERAND (op0, 0),
 			       TREE_OPERAND (op0, 1));
-	  else if (!INTEGRAL_TYPE_P (type))

+	  else if (!INTEGRAL_TYPE_P (type) && TREE_CODE (type) != VECTOR_TYPE)

 	    return build3_loc (loc, COND_EXPR, type, op0,
 			       constant_boolean_node (true, type),
 			       constant_boolean_node (false, type));
 	}
 
       /* Handle cases of two conversions in a row.  */
       if (CONVERT_EXPR_P (op0))
 	{
 	  tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
 	  tree inter_type = TREE_TYPE (op0);
@@ -9822,20 +9822,21 @@  fold_binary_loc (location_t loc,

 
      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
      one of the operands is a comparison and the other is a comparison, a
      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
      code below would make the expression more complex.  Change it to a
      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
 
   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
        || code == EQ_EXPR || code == NE_EXPR)
+      && TREE_CODE (type) != VECTOR_TYPE

       && ((truth_value_p (TREE_CODE (arg0))
 	   && (truth_value_p (TREE_CODE (arg1))
 	       || (TREE_CODE (arg1) == BIT_AND_EXPR
 		   && integer_onep (TREE_OPERAND (arg1, 1)))))
 	  || (truth_value_p (TREE_CODE (arg1))
 	      && (truth_value_p (TREE_CODE (arg0))
 		  || (TREE_CODE (arg0) == BIT_AND_EXPR
 		      && integer_onep (TREE_OPERAND (arg0, 1)))))))
     {
       tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR