d: Add support for vector comparison operators

The front-end added semantic support to permit comparing two vector
expressions.  This removes the restriction in the code generator, as
well as the intrisics that previously exposed the same operation.

gcc/d/ChangeLog:

	* d-target.cc (Target::isVectorOpSupported): Remove cases for
	comparison operators.
	* intrinsics.cc (maybe_set_intrinsic): Remove cases for vector
	comparison intrinsics.
	(maybe_warn_intrinsic_mismatch): Likewise.
	(expand_intrinsic_vec_cond): Remove.
	(maybe_expand_intrinsic): Remove cases for vector comparison
	intrinsics.
	* intrinsics.def (INTRINSIC_EQUALMASK): Remove.
	(INTRINSIC_NOTEQUALMASK): Remove.
	(INTRINSIC_GREATERMASK): Remove.
	(INTRINSIC_GREATEREQUALMASK): Remove.

libphobos/ChangeLog:

	* libdruntime/gcc/simd.d (equalMask): Implement using generics.
	(notEqualMask): Likewise.
	(greaterMask): Likewise.
	(greaterOrEqualMask): Likewise.
	(notMask): Likewise.
	(andAndMask): Likewise.
	(orOrMask): Likewise.

gcc/testsuite/ChangeLog:

	* gdc.dg/Wbuiltin_declaration_mismatch2.d: Remove comparision tests.
	* gdc.dg/simd2a.d: Update comparison tests.
	* gdc.dg/simd2b.d: Likewise.
	* gdc.dg/simd2c.d: Likewise.
	* gdc.dg/simd2d.d: Likewise.
	* gdc.dg/simd2e.d: Likewise.
	* gdc.dg/simd2f.d: Likewise.
	* gdc.dg/simd2g.d: Likewise.
	* gdc.dg/simd2h.d: Likewise.
	* gdc.dg/simd2i.d: Likewise.
	* gdc.dg/simd2j.d: Likewise.

3 files changed, 0 insertions, 79 deletions

diff --git a/gcc/d/d-target.cc b/gcc/d/d-target.cc
index d4350e5..d324467 100644
--- a/gcc/d/d-target.cc
+++ b/gcc/d/d-target.cc
@@ -323,12 +323,6 @@ Target::isVectorOpSupported (Type *type, EXP op, Type *)
       /* Logical operators must have a result type of bool.  */
       return false;
 
-    case EXP::lessOrEqual:
-    case EXP::lessThan:
-    case EXP::greaterOrEqual:
-    case EXP::greaterThan:
-    case EXP::equal:
-    case EXP::notEqual:
     case EXP::identity:
     case EXP::notIdentity:
       /* Comparison operators must have a result type of bool.  */
diff --git a/gcc/d/intrinsics.cc b/gcc/d/intrinsics.cc
index 75d4318..6d9f74a 100644
--- a/gcc/d/intrinsics.cc
+++ b/gcc/d/intrinsics.cc
@@ -170,10 +170,6 @@ maybe_set_intrinsic (FuncDeclaration *decl)
 	    case INTRINSIC_SHUFFLEVECTOR:
 	    case INTRINSIC_CONVERTVECTOR:
 	    case INTRINSIC_BLENDVECTOR:
-	    case INTRINSIC_EQUALMASK:
-	    case INTRINSIC_NOTEQUALMASK:
-	    case INTRINSIC_GREATERMASK:
-	    case INTRINSIC_GREATEREQUALMASK:
 	    case INTRINSIC_VLOAD8:
 	    case INTRINSIC_VLOAD16:
 	    case INTRINSIC_VLOAD32:
@@ -487,29 +483,6 @@ maybe_warn_intrinsic_mismatch (tree function, tree callexp)
 
 	return false;
       }
-
-    case INTRINSIC_EQUALMASK:
-    case INTRINSIC_NOTEQUALMASK:
-    case INTRINSIC_GREATERMASK:
-    case INTRINSIC_GREATEREQUALMASK:
-      {
-	/* Expects the signature:
-	   vector(T) equalMask(vector(T), vector(T));
-	   vector(T) notEqualMask(vector(T), vector(T));
-	   vector(T) greaterMask(vector(T), vector(T));
-	   vector(T) greateOrEqualMask(vector(T), vector(T));  */
-	gcc_assert (call_expr_nargs (callexp) == 2);
-
-	tree vec0 = TREE_TYPE (CALL_EXPR_ARG (callexp, 0));
-	tree vec1 = TREE_TYPE (CALL_EXPR_ARG (callexp, 1));
-	if (!VECTOR_TYPE_P (TREE_TYPE (callexp))
-	    || !VECTOR_TYPE_P (vec0)
-	    || !VECTOR_TYPE_P (vec1)
-	    || TYPE_MAIN_VARIANT (vec0) != TYPE_MAIN_VARIANT (vec1))
-	  return warn_mismatched_return_type (callexp, "__vector(T)");
-
-	return false;
-      }
     }
 
   /* Generic mismatch warning if it hasn't already been handled.  */
@@ -1072,32 +1045,6 @@ expand_volatile_store (tree callexp)
   return modify_expr (result, value);
 }
 
-/* Expand a front-end intrinsic call to a vector comparison intrinsic, which is
-   either a call to equalMask(), notEqualMask(), greaterMask(), or
-   greaterOrEqualMask().  These intrinsics take two arguments, the signature to
-   which can be either:
-
-	vector(T) equalMask(vector(T) vec0, vector(T) vec1);
-	vector(T) notEqualMask(vector(T) vec0, vector(T) vec1);
-	vector(T) greaterMask(vector(T) vec0, vector(T) vec1);
-	vector(T) greaterOrEqualMask(vector(T) vec0, vector(T) vec1);
-
-   This performs an element-wise comparison between two vectors VEC0 and VEC1,
-   returning a vector with signed integral elements.  */
-
-static tree
-expand_intrinsic_vec_cond (tree_code code, tree callexp)
-{
-  tree vec0 = CALL_EXPR_ARG (callexp, 0);
-  tree vec1 = CALL_EXPR_ARG (callexp, 1);
-  tree type = TREE_TYPE (callexp);
-
-  tree cmp = fold_build2_loc (EXPR_LOCATION (callexp), code,
-			      truth_type_for (type), vec0, vec1);
-  return fold_build3_loc (EXPR_LOCATION (callexp), VEC_COND_EXPR, type, cmp,
-			  build_minus_one_cst (type), build_zero_cst (type));
-}
-
 /* Expand a front-end instrinsic call to convertvector().  This takes one
    argument, the signature to which is:
 
@@ -1488,18 +1435,6 @@ maybe_expand_intrinsic (tree callexp)
     case INTRINSIC_BLENDVECTOR:
       return expand_intrinsic_vec_blend (callexp);
 
-    case INTRINSIC_EQUALMASK:
-      return expand_intrinsic_vec_cond (EQ_EXPR, callexp);
-
-    case INTRINSIC_NOTEQUALMASK:
-      return expand_intrinsic_vec_cond (NE_EXPR, callexp);
-
-    case INTRINSIC_GREATERMASK:
-      return expand_intrinsic_vec_cond (GT_EXPR, callexp);
-
-    case INTRINSIC_GREATEREQUALMASK:
-      return expand_intrinsic_vec_cond (GE_EXPR, callexp);
-
     default:
       gcc_unreachable ();
     }
diff --git a/gcc/d/intrinsics.def b/gcc/d/intrinsics.def
index b8d1ec5..96f9b93 100644
--- a/gcc/d/intrinsics.def
+++ b/gcc/d/intrinsics.def
@@ -266,14 +266,6 @@ DEF_D_BUILTIN (INTRINSIC_CONVERTVECTOR, BUILT_IN_NONE, "convertvector",
 	       "gcc.simd", "F@1TZ@1V")
 DEF_D_BUILTIN (INTRINSIC_BLENDVECTOR, BUILT_IN_NONE, "blendvector", "gcc.simd",
 	       "F@2V0@2V1@1MZ@2V0")
-DEF_D_BUILTIN (INTRINSIC_EQUALMASK, BUILT_IN_NONE, "equalMask", "gcc.simd",
-	       "F@1V@1VZ@1V")
-DEF_D_BUILTIN (INTRINSIC_NOTEQUALMASK, BUILT_IN_NONE, "notEqualMask",
-	       "gcc.simd", "F@1V@1VZ@1V")
-DEF_D_BUILTIN (INTRINSIC_GREATERMASK, BUILT_IN_NONE, "greaterMask", "gcc.simd",
-	       "F@1V@1VZ@1V")
-DEF_D_BUILTIN (INTRINSIC_GREATEREQUALMASK, BUILT_IN_NONE,
-	       "greaterOrEqualMask", "gcc.simd", "F@1V@1VZ@1V")
 
 #undef DEF_D_BUILTIN
 #undef DEF_CTFE_BUILTIN