[EarlyCSE][OpaquePointers]Replace assert with return for mask type check.

[dantrushin]

Summary

When EarlyCSE tries to common vector masked loads/stores, it first checks that
they have same base operand and then assumes that this is enough for mask types
to be equal. This is true for typed pointers but false for opaque ones -
two loads of different vector sizes from same base pointer '%b' are the same,
ptr %b. (For typed pointers, %b was cast to vector pointer type so bases
were different).
Change assert to return from lambda isSubmask so this transformation properly
works with opaque pointers.

[nikic]

LGTM

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

auto IsSubmask = [](const Value *Mask0, const Value *Mask1) {
       if (Mask0 == Mask1)
         return true;
       if (isa<UndefValue>(Mask0) || isa<UndefValue>(Mask1))
         return false;
       auto *Vec0 = dyn_cast<ConstantVector>(Mask0);
       auto *Vec1 = dyn_cast<ConstantVector>(Mask1);
       if (!Vec0 || !Vec1)
         return false;
-      assert(Vec0->getType() == Vec1->getType() &&
-             "Masks should have the same type");
+      if (Vec0->getType() != Vec1->getType())
+        return false;
       for (int i = 0, e = Vec0->getNumOperands(); i != e; ++i) {
         Constant *Elem0 = Vec0->getOperand(i);
         Constant *Elem1 = Vec1->getOperand(i);
         auto *Int0 = dyn_cast<ConstantInt>(Elem0);
         if (Int0 && Int0->isZero())
           continue;
         auto *Int1 = dyn_cast<ConstantInt>(Elem1);
         if (Int1 && !Int1->isZero())

llvm/test/Transforms/EarlyCSE/opaque-ptr.ll

 ;
   %v1 = load i32, ptr %p
   %v2 = load i64, ptr %p
   %v2.c = trunc i64 %v2 to i32
   %sub = sub i32 %v1, %v2.c
   ret i32 %sub
 }
 
+define i32 @different_types_vector_load(ptr %p) {
+; CHECK-LABEL: @different_types_vector_load(
+; CHECK-NEXT:    [[V1:%.*]] = call <4 x i32> @llvm.masked.load.v4i32.p0(ptr [[P:%.*]], i32 4, <4 x i1> <i1 true, i1 true, i1 true, i1 false>, <4 x i32> poison)
+; CHECK-NEXT:    [[V2:%.*]] = call <8 x i32> @llvm.masked.load.v8i32.p0(ptr [[P]], i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>, <8 x i32> poison)
+; CHECK-NEXT:    [[E1:%.*]] = extractelement <4 x i32> [[V1]], i32 0
+; CHECK-NEXT:    [[E2:%.*]] = extractelement <8 x i32> [[V2]], i32 6
+; CHECK-NEXT:    [[SUM:%.*]] = add i32 [[E1]], [[E2]]
+; CHECK-NEXT:    ret i32 [[SUM]]
+;
+  %v1 = call <4 x i32> @llvm.masked.load.v4i32.p(ptr %p, i32 4, <4 x i1> <i1 true, i1 true, i1 true, i1 false>, <4 x i32> poison)
+  %v2 = call <8 x i32> @llvm.masked.load.v8i32.p(ptr %p, i32 4, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>, <8 x i32> poison)
+  %e1 = extractelement <4 x i32> %v1, i32 0
+  %e2 = extractelement <8 x i32> %v2, i32 6
+  %sum = add i32 %e1, %e2
+  ret i32 %sum
+}
+
 define i32 @different_types_store(ptr %p, i32 %a) {
 ; CHECK-LABEL: @different_types_store(
 ; CHECK-NEXT:    store i32 [[A:%.*]], ptr [[P:%.*]], align 4
 ; CHECK-NEXT:    [[V2:%.*]] = load i64, ptr [[P]], align 4
 ; CHECK-NEXT:    [[V2_C:%.*]] = trunc i64 [[V2]] to i32
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[A]], [[V2_C]]
 ; CHECK-NEXT:    ret i32 [[SUB]]
 ;

 ; CHECK-NEXT:    store i32 [[I1:%.*]], ptr [[P:%.*]], align 4
 ; CHECK-NEXT:    store i8 [[I2:%.*]], ptr [[P]], align 1
 ; CHECK-NEXT:    ret void
 ;
   store i32 %i1, ptr %p
   store i8 %i2, ptr %p
   ret void
 }
+
+declare <4 x i32> @llvm.masked.load.v4i32.p(ptr, i32 immarg, <4 x i1>, <4 x i32>)
+declare <8 x i32> @llvm.masked.load.v8i32.p(ptr, i32 immarg, <8 x i1>, <8 x i32>)