[InstCombine] Don't combine smul of i1 type constant one

[StephenFan]

Summary

Fixes: https://github.com/llvm/llvm-project/issues/59876

[craig.topper]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

4997–4998

What about i1 vectors?

[spatel]

I added tests similar to what is here and more with:
fc9d54a4a131c
...because there was another missing piece that should be fixed with:
2dcbd740eee0

But we still need a patch like this. Please rebase/update.

[StephenFan]

Rebase and handle i1 vectors.

[nikic]

LG

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

Instruction *InstCombinerImpl::foldICmpWithCastOp(ICmpInst &ICmp) {
   }
 
   if (Instruction *R = foldICmpWithTrunc(ICmp, Builder))
     return R;
 
   return foldICmpWithZextOrSext(ICmp);
 }
 
-static bool isNeutralValue(Instruction::BinaryOps BinaryOp, Value *RHS) {
+static bool isNeutralValue(Instruction::BinaryOps BinaryOp, Value *RHS, bool IsSigned) {
   switch (BinaryOp) {
     default:
       llvm_unreachable("Unsupported binary op");
     case Instruction::Add:
     case Instruction::Sub:
       return match(RHS, m_Zero());
     case Instruction::Mul:
-      return match(RHS, m_One());
+      return !(RHS->getType()->isIntOrIntVectorTy(1) && IsSigned) &&
+             match(RHS, m_One());
   }
 }
 
 OverflowResult
 InstCombinerImpl::computeOverflow(Instruction::BinaryOps BinaryOp,
                                   bool IsSigned, Value *LHS, Value *RHS,
                                   Instruction *CxtI) const {
   switch (BinaryOp) {
bool InstCombinerImpl::OptimizeOverflowCheck(Instruction::BinaryOps BinaryOp,
   // before the add in case there are uses of the add between the add and the
   // compare.
   Builder.SetInsertPoint(&OrigI);
 
   Type *OverflowTy = Type::getInt1Ty(LHS->getContext());
   if (auto *LHSTy = dyn_cast<VectorType>(LHS->getType()))
     OverflowTy = VectorType::get(OverflowTy, LHSTy->getElementCount());
 
-  if (isNeutralValue(BinaryOp, RHS)) {
+  if (isNeutralValue(BinaryOp, RHS, IsSigned)) {
     Result = LHS;
     Overflow = ConstantInt::getFalse(OverflowTy);
     return true;
   }
 
   switch (computeOverflow(BinaryOp, IsSigned, LHS, RHS, &OrigI)) {
     case OverflowResult::MayOverflow:
       return false;

llvm/test/Transforms/InstCombine/smulo.ll

 ;
   %m = call {<2 x i1>, <2 x i1>} @llvm.smul.with.overflow.v2i1(<2 x i1> %x, <2 x i1> %y)
   %ov = extractvalue {<2 x i1>, <2 x i1>} %m, 1
   ret <2 x i1> %ov
 }
 
 define i1 @i1_ov_by_one(i1 %x) {
 ; CHECK-LABEL: @i1_ov_by_one(
-; CHECK-NEXT:    ret i1 false
+; CHECK-NEXT:    ret i1 [[X:%.*]]
 ;
   %m = call {i1, i1} @llvm.smul.with.overflow.i1(i1 %x, i1 1)
   %ov = extractvalue {i1, i1} %m, 1
   ret i1 %ov
 }
 
 define <2 x i1> @v2i1_ov_by_one(<2 x i1> %x) {
 ; CHECK-LABEL: @v2i1_ov_by_one(
-; CHECK-NEXT:    ret <2 x i1> zeroinitializer
+; CHECK-NEXT:    ret <2 x i1> [[X:%.*]]
 ;
   %m = call {<2 x i1>, <2 x i1>} @llvm.smul.with.overflow.v2i1(<2 x i1> %x, <2 x i1> <i1 1, i1 1>)
   %ov = extractvalue {<2 x i1>, <2 x i1>} %m, 1
   ret <2 x i1> %ov
 }