[InstCombine] Add support for simplifying inverted `select` in `foldAndOrOfSelectUsingImpliedCond`; NFC

[goldstein.w.n]

Summary

No change to any functionality at the moment, this is preperatory for
a foldSelectOfBools refactor.

[goldstein.w.n]

Rebase

[RKSimon]

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

412

Update comment describing NotSICond

[goldstein.w.n]

Abandoning and resubmitting on GH

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

private:
   Instruction *foldIntrinsicWithOverflowCommon(IntrinsicInst *II);
   Instruction *foldIntrinsicIsFPClass(IntrinsicInst &II);
   Instruction *foldFPSignBitOps(BinaryOperator &I);
   Instruction *foldFDivConstantDivisor(BinaryOperator &I);
 
   // Optimize one of these forms:
   //   and i1 Op, SI / select i1 Op, i1 SI, i1 false (if IsAnd = true)
   //   or i1 Op, SI  / select i1 Op, i1 true, i1 SI  (if IsAnd = false)
   // into simplier select instruction using isImpliedCondition.
   Instruction *foldAndOrOfSelectUsingImpliedCond(Value *Op, SelectInst &SI,
-                                                 bool IsAnd);
+                                                 bool IsAnd,
+                                                 bool NotSICond = false);
 
   Instruction *hoistFNegAboveFMulFDiv(Value *FNegOp, Instruction &FMFSource);
 
 public:
   /// Create and insert the idiom we use to indicate a block is unreachable
   /// without having to rewrite the CFG from within InstCombine.
   void CreateNonTerminatorUnreachable(Instruction *InsertAt) {
     auto &Ctx = InsertAt->getContext();

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if (FI->hasOneUse() &&
       match(Cond, m_c_ICmp(Pred, m_Specific(TrueVal), m_Specific(FalseVal))) &&
       (Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE)) {
     return Pred == ICmpInst::ICMP_EQ ? FalseVal : TrueVal;
   }
 
   return nullptr;
 }
 
-Instruction *InstCombinerImpl::foldAndOrOfSelectUsingImpliedCond(Value *Op,
-                                                                 SelectInst &SI,
-                                                                 bool IsAnd) {
+Instruction *InstCombinerImpl::foldAndOrOfSelectUsingImpliedCond(
+    Value *Op, SelectInst &SI, bool IsAnd, bool NotSICond) {
   Value *CondVal = SI.getCondition();
   Value *A = SI.getTrueValue();
   Value *B = SI.getFalseValue();
 
   assert(Op->getType()->isIntOrIntVectorTy(1) &&
          "Op must be either i1 or vector of i1.");
 
   std::optional<bool> Res = isImpliedCondition(Op, CondVal, DL, IsAnd);
   if (!Res)
     return nullptr;
 
+  if (NotSICond)
+    *Res = !*Res;
+
   Value *Zero = Constant::getNullValue(A->getType());
   Value *One = Constant::getAllOnesValue(A->getType());
 
   if (*Res == true) {
     if (IsAnd)
       // select op, (select cond, A, B), false => select op, A, false
       // and    op, (select cond, A, B)        => select op, A, false
       //   if op = true implies condval = true.