[IRBuilder] Migrate select-folding to value-based FoldSelect.

[lebedev.ri]

lg

llvm/include/llvm/Analysis/InstSimplifyFolder.h

Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
     return SimplifyICmpInst(P, LHS, RHS, SQ);
   }
 
   Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                  bool IsInBounds = false) const override {
     return SimplifyGEPInst(Ty, Ptr, IdxList, IsInBounds, SQ);
   }
 
+  Value *FoldSelect(Value *C, Value *True, Value *False) const override {
+    return SimplifySelectInst(C, True, False, SQ);
+  }
+
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Value *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return ConstFolder.CreateFAdd(LHS, RHS);
   }
   Value *CreateSub(Constant *LHS, Constant *RHS, bool HasNUW = false,
Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
                     Constant *RHS) const override {
     return ConstFolder.CreateFCmp(P, LHS, RHS);
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Value *CreateSelect(Constant *C, Constant *True,
-                      Constant *False) const override {
-    return ConstFolder.CreateSelect(C, True, False);
-  }
-
   Value *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
     return ConstFolder.CreateExtractElement(Vec, Idx);
   }
 
   Value *CreateInsertElement(Constant *Vec, Constant *NewElt,
                              Constant *Idx) const override {
     return ConstFolder.CreateInsertElement(Vec, NewElt, Idx);
   }

llvm/include/llvm/Analysis/TargetFolder.h

if (auto *PC = dyn_cast<Constant>(Ptr)) {
       if (IsInBounds)
         return Fold(ConstantExpr::getInBoundsGetElementPtr(Ty, PC, IdxList));
       else
         return Fold(ConstantExpr::getGetElementPtr(Ty, PC, IdxList));
     }
     return nullptr;
   }
 
+  Value *FoldSelect(Value *C, Value *True, Value *False) const override {
+    auto *CC = dyn_cast<Constant>(C);
+    auto *TC = dyn_cast<Constant>(True);
+    auto *FC = dyn_cast<Constant>(False);
+    if (CC && TC && FC)
+      return Fold(ConstantExpr::getSelect(CC, TC, FC));
+
+    return nullptr;
+  }
+
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return Fold(ConstantExpr::getFAdd(LHS, RHS));
   }
   Constant *CreateSub(Constant *LHS, Constant *RHS,
Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
                        Constant *RHS) const override {
     return Fold(ConstantExpr::getCompare(P, LHS, RHS));
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateSelect(Constant *C, Constant *True,
-                         Constant *False) const override {
-    return Fold(ConstantExpr::getSelect(C, True, False));
-  }
-
   Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
     return Fold(ConstantExpr::getExtractElement(Vec, Idx));
   }
 
   Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
                                 Constant *Idx) const override {
     return Fold(ConstantExpr::getInsertElement(Vec, NewElt, Idx));
   }

llvm/include/llvm/IR/ConstantFolder.h

if (auto *PC = dyn_cast<Constant>(Ptr)) {
       if (IsInBounds)
         return ConstantExpr::getInBoundsGetElementPtr(Ty, PC, IdxList);
       else
         return ConstantExpr::getGetElementPtr(Ty, PC, IdxList);
     }
     return nullptr;
   }
 
+  Value *FoldSelect(Value *C, Value *True, Value *False) const override {
+    auto *CC = dyn_cast<Constant>(C);
+    auto *TC = dyn_cast<Constant>(True);
+    auto *FC = dyn_cast<Constant>(False);
+    if (CC && TC && FC)
+      return ConstantExpr::getSelect(CC, TC, FC);
+    return nullptr;
+  }
+
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Constant *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return ConstantExpr::getFAdd(LHS, RHS);
   }
 
Constant *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
                        Constant *RHS) const override {
     return ConstantExpr::getCompare(P, LHS, RHS);
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Constant *CreateSelect(Constant *C, Constant *True,
-                         Constant *False) const override {
-    return ConstantExpr::getSelect(C, True, False);
-  }
-
   Constant *CreateExtractElement(Constant *Vec, Constant *Idx) const override {
     return ConstantExpr::getExtractElement(Vec, Idx);
   }
 
   Constant *CreateInsertElement(Constant *Vec, Constant *NewElt,
                                 Constant *Idx) const override {
     return ConstantExpr::getInsertElement(Vec, NewElt, Idx);
   }

llvm/include/llvm/IR/IRBuilderFolder.h

public:
   virtual Value *FoldOr(Value *LHS, Value *RHS) const = 0;
 
   virtual Value *FoldICmp(CmpInst::Predicate P, Value *LHS,
                           Value *RHS) const = 0;
 
   virtual Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                          bool IsInBounds = false) const = 0;
 
+  virtual Value *FoldSelect(Value *C, Value *True, Value *False) const = 0;
+
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   virtual Value *CreateFAdd(Constant *LHS, Constant *RHS) const = 0;
   virtual Value *CreateSub(Constant *LHS, Constant *RHS,
                            bool HasNUW = false, bool HasNSW = false) const = 0;
   virtual Value *CreateFSub(Constant *LHS, Constant *RHS) const = 0;
public:
 
   virtual Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS,
                             Constant *RHS) const = 0;
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  virtual Value *CreateSelect(Constant *C, Constant *True,
-                              Constant *False) const = 0;
   virtual Value *CreateExtractElement(Constant *Vec, Constant *Idx) const = 0;
   virtual Value *CreateInsertElement(Constant *Vec, Constant *NewElt,
                                      Constant *Idx) const = 0;
   virtual Value *CreateShuffleVector(Constant *V1, Constant *V2,
                                      ArrayRef<int> Mask) const = 0;
   virtual Value *CreateExtractValue(Constant *Agg,
                                     ArrayRef<unsigned> IdxList) const = 0;
   virtual Value *CreateInsertValue(Constant *Agg, Constant *Val,
                                    ArrayRef<unsigned> IdxList) const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_IRBUILDERFOLDER_H

llvm/include/llvm/IR/NoFolder.h

Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override {
     return nullptr;
   }
 
   Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
                  bool IsInBounds = false) const override {
     return nullptr;
   }
 
+  Value *FoldSelect(Value *C, Value *True, Value *False) const override {
+    return nullptr;
+  }
+
   //===--------------------------------------------------------------------===//
   // Binary Operators
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const override {
     return BinaryOperator::CreateFAdd(LHS, RHS);
   }
 
Instruction *CreateFCmp(CmpInst::Predicate P,
                           Constant *LHS, Constant *RHS) const override {
     return new FCmpInst(P, LHS, RHS);
   }
 
   //===--------------------------------------------------------------------===//
   // Other Instructions
   //===--------------------------------------------------------------------===//
 
-  Instruction *CreateSelect(Constant *C,
-                            Constant *True, Constant *False) const override {
-    return SelectInst::Create(C, True, False);
-  }
-
   Instruction *CreateExtractElement(Constant *Vec,
                                     Constant *Idx) const override {
     return ExtractElementInst::Create(Vec, Idx);
   }
 
   Instruction *CreateInsertElement(Constant *Vec, Constant *NewElt,
                                    Constant *Idx) const override {
     return InsertElementInst::Create(Vec, NewElt, Idx);

llvm/lib/IR/IRBuilder.cpp

#include "llvm/IR/ConstrainedOps.def"
 
   CallInst *C = CreateCall(Callee, UseArgs, Name);
   setConstrainedFPCallAttr(C);
   return C;
 }
 
 Value *IRBuilderBase::CreateSelect(Value *C, Value *True, Value *False,
                                    const Twine &Name, Instruction *MDFrom) {
-  if (auto *CC = dyn_cast<Constant>(C))
-    if (auto *TC = dyn_cast<Constant>(True))
-      if (auto *FC = dyn_cast<Constant>(False))
-        return Insert(Folder.CreateSelect(CC, TC, FC), Name);
+  if (auto *V = Folder.FoldSelect(C, True, False))
+    return V;
 
   SelectInst *Sel = SelectInst::Create(C, True, False);
   if (MDFrom) {
     MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
     MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
     Sel = addBranchMetadata(Sel, Prof, Unpred);
   }
   if (isa<FPMathOperator>(Sel))

llvm/test/Transforms/LoopVectorize/pr34681.ll

 ; %0 = or i1 false, %ident.check
 ; br i1 %0, label %scalar.ph, label %vector.ph
 
 
 ; CHECK-LABEL: @foo2
 ; CHECK: vector.scevcheck:
 ; CHECK-NEXT:  add nsw i32 %conv, -1
 ; CHECK-NEXT:  [[NEG:%.+]] = sub i32 0, %conv
-; CHECK-NEXT:  = select i1 false, i32 [[NEG]], i32 %conv
 ; CHECK-NOT: %ident.check = icmp ne i16 %N, 1
 ; CHECK-NOT: %{{[0-9]+}} = or i1 false, %ident.check
 ; CHECK-NOT: br i1 %{{[0-9]+}}, label %scalar.ph, label %vector.ph
 ; CHECK: vector.ph
 ; CHECK: vector.body
 ; CHECK: <4 x i32>
 ; CHECK: middle.block
 ; CHECK: scalar.ph