[IR] fix crash in Constant::isElementWiseEqual() with FP types

[spatel]

Summary

We lifted this code from InstCombine for general usage in:
rL369842
...but it's not safe as-is. There are no existing users that can trigger this bug, but I discovered it via crashing several regression tests when trying to use it for select folding in InstSimplify.

ICmp requires (vector) integer types, so bitcast the constants before trying the match. That matches the definition of "equal or undef" that I was looking for. If someone wants an FP-aware version of equality (deal with NaN, -0.0), that could be a different mode or different function.

[nikic]

llvm/lib/IR/Constants.cpp

295–299

Probably not going to work for vectors of pointers though. Is that relevant to your use-case?

[spatel]

llvm/lib/IR/Constants.cpp

295–299

Yes, good catch. It was not my immediate concern, and I'm not sure how to handle pointers. So I think it's ok to just bail out on those. I'll add to the tests though.

[spatel]

Patch updated:
Bail out on anything not integer or FP. I'm not sure how to deal with pointers, but added a few basic tests in case we do eventually support those.

[nikic]

LGTM

llvm/lib/IR/Constants.cpp

bool Constant::isElementWiseEqual(Value *Y) const {
   if (this == Y)
     return true;
 
   // The input value must be a vector constant with the same type.
   Type *Ty = getType();
   if (!isa<Constant>(Y) || !Ty->isVectorTy() || Ty != Y->getType())
     return false;
 
+  // TODO: Compare pointer constants?
+  if (!(Ty->getVectorElementType()->isIntegerTy() ||
+        Ty->getVectorElementType()->isFloatingPointTy()))
+    return false;
+
   // They may still be identical element-wise (if they have `undef`s).
-  // FIXME: This crashes on FP vector constants.
-  return match(ConstantExpr::getICmp(ICmpInst::Predicate::ICMP_EQ,
-                                     const_cast<Constant *>(this),
-                                     cast<Constant>(Y)),
-               m_One());
+  // Bitcast to integer to allow exact bitwise comparison for all types.
+  Type *IntTy = VectorType::getInteger(cast<VectorType>(Ty));
+  Constant *C0 = ConstantExpr::getBitCast(const_cast<Constant *>(this), IntTy);
+  Constant *C1 = ConstantExpr::getBitCast(cast<Constant>(Y), IntTy);
+  return match(ConstantExpr::getICmp(ICmpInst::ICMP_EQ, C0, C1), m_One());
 }
 
 bool Constant::containsUndefElement() const {
   if (!getType()->isVectorTy())
     return false;
   for (unsigned i = 0, e = getType()->getVectorNumElements(); i != e; ++i)
     if (isa<UndefValue>(getAggregateElement(i)))
       return true;

llvm/unittests/IR/ConstantsTest.cpp

TEST(ConstantsTest, FoldGlobalVariablePtr) {
   Constant *TheConstantExpr(
       ConstantExpr::getPtrToInt(Global.get(), IntType));
 
   ASSERT_TRUE(ConstantExpr::get( \
       Instruction::And, TheConstantExpr, TheConstant)->isNullValue());
 }
 
 // Check that undefined elements in vector constants are matched
-// correctly for both integer and floating-point types.
+// correctly for both integer and floating-point types. Just don't
+// crash on vectors of pointers (could be handled?).
 
 TEST(ConstantsTest, isElementWiseEqual) {
   LLVMContext Context;
 
   Type *Int32Ty = Type::getInt32Ty(Context);
   Constant *CU = UndefValue::get(Int32Ty);
   Constant *C1 = ConstantInt::get(Int32Ty, 1);
   Constant *C2 = ConstantInt::get(Int32Ty, 2);
 
   Constant *C1211 = ConstantVector::get({C1, C2, C1, C1});
   Constant *C12U1 = ConstantVector::get({C1, C2, CU, C1});
   Constant *C12U2 = ConstantVector::get({C1, C2, CU, C2});
   Constant *C12U21 = ConstantVector::get({C1, C2, CU, C2, C1});
 
   EXPECT_TRUE(C1211->isElementWiseEqual(C12U1));
   EXPECT_TRUE(C12U1->isElementWiseEqual(C1211));
   EXPECT_FALSE(C12U2->isElementWiseEqual(C12U1));
   EXPECT_FALSE(C12U1->isElementWiseEqual(C12U2));
   EXPECT_FALSE(C12U21->isElementWiseEqual(C12U2));
 
-/* FIXME: This will crash.
   Type *FltTy = Type::getFloatTy(Context);
   Constant *CFU = UndefValue::get(FltTy);
   Constant *CF1 = ConstantFP::get(FltTy, 1.0);
   Constant *CF2 = ConstantFP::get(FltTy, 2.0);
 
   Constant *CF1211 = ConstantVector::get({CF1, CF2, CF1, CF1});
   Constant *CF12U1 = ConstantVector::get({CF1, CF2, CFU, CF1});
   Constant *CF12U2 = ConstantVector::get({CF1, CF2, CFU, CF2});
 
   EXPECT_TRUE(CF1211->isElementWiseEqual(CF12U1));
   EXPECT_TRUE(CF12U1->isElementWiseEqual(CF1211));
   EXPECT_FALSE(CF12U2->isElementWiseEqual(CF12U1));
   EXPECT_FALSE(CF12U1->isElementWiseEqual(CF12U2));
-*/
+
+  PointerType *PtrTy = Type::getInt8PtrTy(Context);
+  Constant *CPU = UndefValue::get(PtrTy);
+  Constant *CP0 = ConstantPointerNull::get(PtrTy);
+
+  Constant *CP0000 = ConstantVector::get({CP0, CP0, CP0, CP0});
+  Constant *CP00U0 = ConstantVector::get({CP0, CP0, CPU, CP0});
+  Constant *CP00U = ConstantVector::get({CP0, CP0, CPU});
+
+  EXPECT_FALSE(CP0000->isElementWiseEqual(CP00U0));
+  EXPECT_FALSE(CP00U0->isElementWiseEqual(CP0000));
+  EXPECT_FALSE(CP0000->isElementWiseEqual(CP00U));
+  EXPECT_FALSE(CP00U->isElementWiseEqual(CP00U0));
 }
 
 }  // end anonymous namespace
 }  // end namespace llvm