reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/Analysis/BasicAliasAnalysis.h

   43 class SelectInst;

include/llvm/Analysis/MemoryBuiltins.h

   50 class SelectInst;

include/llvm/IR/Instruction.def

  210 HANDLE_OTHER_INST(57, Select , SelectInst )  // select instruction

include/llvm/Transforms/Scalar/SROA.h

   32 class SelectInst;

lib/Transforms/ObjCARC/ProvenanceAnalysis.h

   37 class SelectInst;

References

include/llvm/ADT/DenseMapInfo.h

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

include/llvm/Analysis/BasicAliasAnalysis.h

  209   AliasResult aliasSelect(const SelectInst *SI, LocationSize SISize,

include/llvm/Analysis/MemoryBuiltins.h

  272   SizeOffsetType visitSelectInst(SelectInst &I);
  339   SizeOffsetEvalType visitSelectInst(SelectInst &I);

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  865   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
  865   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
 2316     SelectInst *Sel = SelectInst::Create(C, True, False);
 2316     SelectInst *Sel = SelectInst::Create(C, True, False);

include/llvm/IR/InstVisitor.h

  191   RetTy visitSelectInst(SelectInst &I)            { DELEGATE(Instruction);}

include/llvm/IR/Instructions.h

 1743   SelectInst *cloneImpl() const;
 1746   static SelectInst *Create(Value *C, Value *S1, Value *S2,
 1750     SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
 1750     SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
 1756   static SelectInst *Create(Value *C, Value *S1, Value *S2,
 1759     return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
 1798 struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {

include/llvm/IR/NoFolder.h

  315     return SelectInst::Create(C, True, False);

include/llvm/IR/OperandTraits.h

   31   static Use *op_begin(SubClass* U) {
   33         !std::is_polymorphic<SubClass>::value,
   37   static Use *op_end(SubClass* U) {

include/llvm/IR/PatternMatch.h

   47 template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
 1207   template <typename OpTy> bool match(OpTy *V) {
 1439   template <typename OpTy> bool match(OpTy *V) {
 1441     auto *SI = dyn_cast<SelectInst>(V);
 1441     auto *SI = dyn_cast<SelectInst>(V);

include/llvm/IR/User.h

  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];

include/llvm/Support/Casting.h

   34   using SimpleType = From; // The real type this represents...
   37   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
   41   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   47   static RetType getSimplifiedValue(const From& Val) {
   57   static inline bool doit(const From &Val) {
   58     return To::classof(&Val);
   66   static inline bool doit(const From &) { return true; }
   76   static inline bool doit(const From &Val) {
   77     return isa_impl<To, From>::doit(Val);
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
  142   return isa_impl_wrap<X, const Y,
  142   return isa_impl_wrap<X, const Y,
  143                        typename simplify_type<const Y>::SimpleType>::doit(Val);
  165   using ret_type = To &;       // Normal case, return Ty&
  168   using ret_type = const To &; // Normal case, return Ty&
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  331                             typename cast_retty<X, const Y>::ret_type>::type
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

include/llvm/Support/PointerLikeTypeTraits.h

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

include/llvm/Support/type_traits.h

   55 struct add_const_past_pointer { using type = const T; };

include/llvm/Transforms/Scalar/JumpThreading.h

  141   void UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI,

include/llvm/Transforms/Scalar/SROA.h

  109   SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;
  109   SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;

lib/Analysis/BasicAliasAnalysis.cpp

  684     if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
  684     if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
 1548 BasicAAResult::aliasSelect(const SelectInst *SI, LocationSize SISize,
 1554   if (const SelectInst *SI2 = dyn_cast<SelectInst>(V2))
 1554   if (const SelectInst *SI2 = dyn_cast<SelectInst>(V2))
 1869   if (isa<SelectInst>(V2) && !isa<SelectInst>(V1)) {
 1869   if (isa<SelectInst>(V2) && !isa<SelectInst>(V1)) {
 1875   if (const SelectInst *S1 = dyn_cast<SelectInst>(V1)) {
 1875   if (const SelectInst *S1 = dyn_cast<SelectInst>(V1)) {

lib/Analysis/CFLGraph.h

  332     void visitSelectInst(SelectInst &Inst) {

lib/Analysis/GlobalsModRef.cpp

  659     if (auto *SI = dyn_cast<SelectInst>(Input)) {
  776     if (auto *SI = dyn_cast<SelectInst>(Input)) {

lib/Analysis/IVDescriptors.cpp

  291     if (!Cur->isCommutative() && !IsAPhi && !isa<SelectInst>(Cur) &&
  308     bool IsASelect = isa<SelectInst>(Cur);
  326         (isa<ICmpInst>(Cur) || isa<SelectInst>(Cur)))
  328     if (Kind == RK_FloatMinMax && (isa<FCmpInst>(Cur) || isa<SelectInst>(Cur)))
  378                    !isa<SelectInst>(UI)) ||
  466   SelectInst *Select = nullptr;
  471     if (!Cmp->hasOneUse() || !(Select = dyn_cast<SelectInst>(*I->user_begin())))
  477   if (!(Select = dyn_cast<SelectInst>(I)))
  521   SelectInst *SI = dyn_cast<SelectInst>(I);
  521   SelectInst *SI = dyn_cast<SelectInst>(I);

lib/Analysis/InlineCost.cpp

  284   bool visitSelectInst(SelectInst &SI);
 1353 bool CallAnalyzer::visitSelectInst(SelectInst &SI) {

lib/Analysis/InstructionSimplify.cpp

  336   SelectInst *SI;
  337   if (isa<SelectInst>(LHS)) {
  338     SI = cast<SelectInst>(LHS);
  341     SI = cast<SelectInst>(RHS);
  409   if (!isa<SelectInst>(LHS)) {
  414   SelectInst *SI = cast<SelectInst>(LHS);
  414   SelectInst *SI = cast<SelectInst>(LHS);
  870   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
  870   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1049   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1049   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1091   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1091   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1218   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 1218   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 2004   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 2004   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 2157   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 2157   if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
 2256   SelectInst *SI = dyn_cast<SelectInst>(V);
 2256   SelectInst *SI = dyn_cast<SelectInst>(V);
 3456   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
 3456   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
 3645   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
 3645   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))

lib/Analysis/LazyValueInfo.cpp

  421   bool solveBlockValueSelect(ValueLatticeElement &BBLV, SelectInst *S,
  630   if (auto *SI = dyn_cast<SelectInst>(BBI))
  630   if (auto *SI = dyn_cast<SelectInst>(BBI))
  855                                               SelectInst *SI, BasicBlock *BB) {

lib/Analysis/MemoryBuiltins.cpp

  785 SizeOffsetType ObjectSizeOffsetVisitor::visitSelectInst(SelectInst &I) {
 1031 SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitSelectInst(SelectInst &I) {

lib/Analysis/ScalarEvolution.cpp

 4351         SelectInst *SI = cast<SelectInst>(I);
 4351         SelectInst *SI = cast<SelectInst>(I);
 7713       isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I) ||

lib/Analysis/TargetTransformInfo.cpp

  898   if (auto *SI = dyn_cast<SelectInst>(I)) {
  898   if (auto *SI = dyn_cast<SelectInst>(I)) {
 1191     const SelectInst *SI = cast<SelectInst>(I);
 1191     const SelectInst *SI = cast<SelectInst>(I);

lib/Analysis/ValueTracking.cpp

 1776   if (const SelectInst *SI = dyn_cast<SelectInst>(V))
 1776   if (const SelectInst *SI = dyn_cast<SelectInst>(V))
 2210   else if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
 2210   else if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
 3621   if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
 3621   if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
 3777     if (auto *SI = dyn_cast<SelectInst>(P)) {
 5057   SelectInst *SI = dyn_cast<SelectInst>(V);
 5057   SelectInst *SI = dyn_cast<SelectInst>(V);
 5634 static void setLimitsForSelectPattern(const SelectInst &SI, APInt &Lower,
 5702   else if (auto *SI = dyn_cast<SelectInst>(V))

lib/AsmParser/LLParser.cpp

 3622       if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
 6575   if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
 6578   Inst = SelectInst::Create(Op0, Op1, Op2);

lib/Bitcode/Reader/BitcodeReader.cpp

 4089       I = SelectInst::Create(Cond, TrueVal, FalseVal);
 4116       I = SelectInst::Create(Cond, TrueVal, FalseVal);

lib/CodeGen/CodeGenPrepare.cpp

  368     bool optimizeSelectInst(SelectInst *SI);
 2985   SmallPtrSet<SelectInst *, 32> AllSelectNodes;
 3016           if (auto *Select = dyn_cast<SelectInst>(PI))
 3016           if (auto *Select = dyn_cast<SelectInst>(PI))
 3046   void insertNewSelect(SelectInst *SI) { AllSelectNodes.insert(SI); }
 3388       if (SelectInst *Select = dyn_cast<SelectInst>(V)) {
 3388       if (SelectInst *Select = dyn_cast<SelectInst>(V)) {
 3390         auto *CurrentSelect = cast<SelectInst>(Current);
 3390         auto *CurrentSelect = cast<SelectInst>(Current);
 3433       if (SelectInst *CurrentSelect = dyn_cast<SelectInst>(Current)) {
 3433       if (SelectInst *CurrentSelect = dyn_cast<SelectInst>(Current)) {
 3436         SelectInst *Select = SelectInst::Create(
 3436         SelectInst *Select = SelectInst::Create(
 3638     return !(isa<SelectInst>(Inst) && OpIdx == 0);
 4702     if (SelectInst *SI = dyn_cast<SelectInst>(V)) {
 4702     if (SelectInst *SI = dyn_cast<SelectInst>(V)) {
 5840                                                 SelectInst *SI) {
 5883     SelectInst *SI, bool isTrue,
 5887   for (SelectInst *DefSI = SI; DefSI != nullptr && Selects.count(DefSI);
 5888        DefSI = dyn_cast<SelectInst>(V)) {
 5933 bool CodeGenPrepare::optimizeSelectInst(SelectInst *SI) {
 5939   SmallVector<SelectInst *, 2> ASI;
 5943     SelectInst *I = dyn_cast<SelectInst>(&*It);
 5943     SelectInst *I = dyn_cast<SelectInst>(&*It);
 5951   SelectInst *LastSI = ASI.back();
 6020   for (SelectInst *SI : ASI) {
 6081     SelectInst *SI = *It;
 7054     return optimizeSelectInst(cast<SelectInst>(I));

lib/CodeGen/GlobalISel/IRTranslator.cpp

 1008   const SelectInst &SI = cast<SelectInst>(U);
 1008   const SelectInst &SI = cast<SelectInst>(U);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3246     return isa<SelectInst>(V);
 3342         hasOnlySelectUsers(cast<SelectInst>(I).getCondition())) {

lib/CodeGen/SjLjEHPrepare.cpp

  248     Instruction *SI = SelectInst::Create(

lib/ExecutionEngine/Interpreter/Execution.cpp

  859 void Interpreter::visitSelectInst(SelectInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  150   void visitSelectInst(SelectInst &I);

lib/IR/AsmWriter.cpp

 4029     if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)

lib/IR/Constants.cpp

 3006     return SelectInst::Create(Ops[0], Ops[1], Ops[2]);

lib/IR/Instructions.cpp

 4232 SelectInst *SelectInst::cloneImpl() const {
 4233   return SelectInst::Create(getOperand(0), getOperand(1), getOperand(2));

lib/IR/SafepointIRVerifier.cpp

  355     if (const auto *SI = dyn_cast<SelectInst>(V)) {
  355     if (const auto *SI = dyn_cast<SelectInst>(V)) {

lib/IR/Verifier.cpp

  473   void visitSelectInst(SelectInst &SI);
 2521 void Verifier::visitSelectInst(SelectInst &SI) {
 4041     else if (isa<SelectInst>(&I))

lib/Target/AArch64/AArch64FastISel.cpp

  197   bool optimizeSelect(const SelectInst *SI);
 2654 bool AArch64FastISel::optimizeSelect(const SelectInst *SI) {
 2741   const SelectInst *SI = cast<SelectInst>(I);
 2741   const SelectInst *SI = cast<SelectInst>(I);

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

   91   bool isSigned(const SelectInst &I) const;
  128   bool promoteUniformOpToI32(SelectInst &I) const;
  183   bool visitSelectInst(SelectInst &I);
  223 bool AMDGPUCodeGenPrepare::isSigned(const SelectInst &I) const {
  357 bool AMDGPUCodeGenPrepare::promoteUniformOpToI32(SelectInst &I) const {
  988 bool AMDGPUCodeGenPrepare::visitSelectInst(SelectInst &I) {

lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp

  181         auto *SI = dyn_cast<SelectInst>(ZextUser);
  181         auto *SI = dyn_cast<SelectInst>(ZextUser);

lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp

  188     if (auto S = dyn_cast<SelectInst>(V)) {

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

  595     if (SelectInst *SI = dyn_cast<SelectInst>(UseInst)) {
  595     if (SelectInst *SI = dyn_cast<SelectInst>(UseInst)) {
  859       if (SelectInst *SI = dyn_cast<SelectInst>(V)) {
  859       if (SelectInst *SI = dyn_cast<SelectInst>(V)) {

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  604     bool matchLeftShift(SelectInst *SelI, Value *CIV, ParsedValues &PV);
  605     bool matchRightShift(SelectInst *SelI, ParsedValues &PV);
  606     bool scanSelect(SelectInst *SI, BasicBlock *LoopB, BasicBlock *PrehB,
  665 bool PolynomialMultiplyRecognize::matchLeftShift(SelectInst *SelI,
  780 bool PolynomialMultiplyRecognize::matchRightShift(SelectInst *SelI,
  855 bool PolynomialMultiplyRecognize::scanSelect(SelectInst *SelI,
 1633       if (SelectInst *Sel = dyn_cast<SelectInst>(BO->getOperand(0))) {
 1633       if (SelectInst *Sel = dyn_cast<SelectInst>(BO->getOperand(0))) {
 1641       if (SelectInst *Sel = dyn_cast<SelectInst>(BO->getOperand(1))) {
 1641       if (SelectInst *Sel = dyn_cast<SelectInst>(BO->getOperand(1))) {
 1655       SelectInst *Sel = dyn_cast<SelectInst>(I);
 1655       SelectInst *Sel = dyn_cast<SelectInst>(I);
 1660       if (SelectInst *Sel0 = dyn_cast<SelectInst>(Sel->getTrueValue())) {
 1660       if (SelectInst *Sel0 = dyn_cast<SelectInst>(Sel->getTrueValue())) {
 1664       if (SelectInst *Sel1 = dyn_cast<SelectInst>(Sel->getFalseValue())) {
 1664       if (SelectInst *Sel1 = dyn_cast<SelectInst>(Sel->getFalseValue())) {
 1813     SelectInst *SI = dyn_cast<SelectInst>(&In);
 1813     SelectInst *SI = dyn_cast<SelectInst>(&In);
 1819     SelectInst *SelI = (T && isa<SelectInst>(T)) ? cast<SelectInst>(T) : SI;
 1819     SelectInst *SelI = (T && isa<SelectInst>(T)) ? cast<SelectInst>(T) : SI;
 1819     SelectInst *SelI = (T && isa<SelectInst>(T)) ? cast<SelectInst>(T) : SI;
 1848       SelectInst *SI = dyn_cast<SelectInst>(&In);
 1848       SelectInst *SI = dyn_cast<SelectInst>(&In);
 1853       SelectInst *SelI = dyn_cast_or_null<SelectInst>(T);
 1853       SelectInst *SelI = dyn_cast_or_null<SelectInst>(T);
 1870     SelectInst *SelI = dyn_cast<SelectInst>(&In);
 1870     SelectInst *SelI = dyn_cast<SelectInst>(&In);

lib/Target/Mips/MipsFastISel.cpp

 1045   const SelectInst *SI = cast<SelectInst>(I);
 1045   const SelectInst *SI = cast<SelectInst>(I);

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  888   const auto *Select = cast<SelectInst>(I);
  888   const auto *Select = cast<SelectInst>(I);

lib/Transforms/Coroutines/CoroFrame.cpp

  943          isa<BinaryOperator>(&V) || isa<CmpInst>(&V) || isa<SelectInst>(&V);

lib/Transforms/IPO/Attributor.cpp

  209     if (auto *SI = dyn_cast<SelectInst>(V)) {
  209     if (auto *SI = dyn_cast<SelectInst>(V)) {

lib/Transforms/IPO/CalledValuePropagation.cpp

  182       return visitSelect(*cast<SelectInst>(&I), ChangedValues, SS);
  301   void visitSelect(SelectInst &I,

lib/Transforms/IPO/FunctionAttrs.cpp

  889         SelectInst *SI = cast<SelectInst>(RVI);
  889         SelectInst *SI = cast<SelectInst>(RVI);
 1002       SelectInst *SI = cast<SelectInst>(RVI);
 1002       SelectInst *SI = cast<SelectInst>(RVI);

lib/Transforms/IPO/GlobalOpt.cpp

 1742         NSI = SelectInst::Create(NLI, OtherVal, InitVal, "", LI);

lib/Transforms/InstCombine/InstCombineAddSub.cpp

  892     return SelectInst::Create(X, AddOne(Op1C), Op1);
 1349     SelectInst *SI = dyn_cast<SelectInst>(LHS);
 1349     SelectInst *SI = dyn_cast<SelectInst>(LHS);
 1352       SI = dyn_cast<SelectInst>(RHS);
 1364         return SelectInst::Create(SI->getCondition(), N, A);
 1368         return SelectInst::Create(SI->getCondition(), A, N);
 1737       return SelectInst::Create(X, SubOne(C), C);
 1744       return SelectInst::Create(X, AddOne(C), C);
 1752     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 1752     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 1815           cast<SelectInst>(Op1)->swapValues();
 2005     return SelectInst::Create(Cmp, Neg, A);
 2128     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 2128     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 1957     return SelectInst::Create(A, Op1, Constant::getNullValue(I.getType()));
 1960     return SelectInst::Create(A, Op0, Constant::getNullValue(I.getType()));
 1972       return SelectInst::Create(NewICmpInst, X, ConstantInt::getNullValue(Ty));
 2681     return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op1);
 2684     return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op0);
 2709       return SelectInst::Create(X, orTrue, orFalse);
 2723       return SelectInst::Create(NewICmpInst, ConstantInt::getAllOnesValue(Ty),
 3236     return SelectInst::Create(Cmp, Neg, A);
 3259         return SelectInst::Create(
 3267         return SelectInst::Create(
 3277         return SelectInst::Create(

lib/Transforms/InstCombine/InstCombineCalls.cpp

 2289       return SelectInst::Create(Cond, Call0, Call1);
 3059       return SelectInst::Create(NewSelector, Op1, Op0, "blendv");
 3076         return SelectInst::Create(BoolVec, Op1, Op0);

lib/Transforms/InstCombine/InstCombineCasts.cpp

  209     Res = SelectInst::Create(I->getOperand(0), True, False);
  277   if (auto *Sel = dyn_cast<SelectInst>(Src)) {
  277   if (auto *Sel = dyn_cast<SelectInst>(Src)) {
  428     SelectInst *SI = cast<SelectInst>(I);
  428     SelectInst *SI = cast<SelectInst>(I);
  714   if (SelectInst *SI = dyn_cast<SelectInst>(CI.getOperand(0)))
  714   if (SelectInst *SI = dyn_cast<SelectInst>(CI.getOperand(0)))
 2132     return SelectInst::Create(Cond, X, CastedVal, "", nullptr, Sel);
 2139     return SelectInst::Create(Cond, CastedVal, X, "", nullptr, Sel);

lib/Transforms/InstCombine/InstCombineCompares.cpp

 1060         isa<SelectInst>(V)) {
 2622 bool InstCombiner::matchThreeWayIntCompare(SelectInst *SI, Value *&LHS,
 2675                                                   SelectInst *Select,
 2881   if (auto *SI = dyn_cast<SelectInst>(Cmp.getOperand(0))) {
 2881   if (auto *SI = dyn_cast<SelectInst>(Cmp.getOperand(0))) {
 3227             replacedSelectWithOperand(cast<SelectInst>(LHSI), &I, Op1 ? 2 : 1);
 3236       return SelectInst::Create(LHSI->getOperand(0), Op1, Op2);
 4844 static bool isChainSelectCmpBranch(const SelectInst *SI) {
 4897 bool InstCombiner::replacedSelectWithOperand(SelectInst *SI,
 5443     if (SelectInst *SI = dyn_cast<SelectInst>(I.user_back())) {
 5443     if (SelectInst *SI = dyn_cast<SelectInst>(I.user_back())) {
 6022     if (SelectInst *SI = dyn_cast<SelectInst>(I.user_back())) {
 6022     if (SelectInst *SI = dyn_cast<SelectInst>(I.user_back())) {

lib/Transforms/InstCombine/InstCombineInternal.h

  423   Instruction *visitSelectInst(SelectInst &SI);
  460   bool replacedSelectWithOperand(SelectInst *SI, const ICmpInst *Icmp,
  604   Instruction *matchSAddSubSat(SelectInst &MinMax1);
  827   bool matchThreeWayIntCompare(SelectInst *SI, Value *&LHS, Value *&RHS,
  877   Instruction *FoldOpIntoSelect(Instruction &Op, SelectInst *SI);
  927   Instruction *foldICmpSelectConstant(ICmpInst &Cmp, SelectInst *Select,
  971   Instruction *foldSelectExtConst(SelectInst &Sel);
  972   Instruction *foldSelectOpOp(SelectInst &SI, Instruction *TI, Instruction *FI);
  973   Instruction *foldSelectIntoOp(SelectInst &SI, Value *, Value *);
  977   Instruction *foldSelectInstWithICmp(SelectInst &SI, ICmpInst *ICI);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  769     if (SelectInst *SI = dyn_cast<SelectInst>(P)) {
  769     if (SelectInst *SI = dyn_cast<SelectInst>(P)) {
 1021     if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
 1021     if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
 1039         return SelectInst::Create(SI->getCondition(), V1, V2);

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  360     return SelectInst::Create(X, Op1, ConstantInt::get(I.getType(), 0));
  362     return SelectInst::Create(X, Op0, ConstantInt::get(I.getType(), 0));
  580   SelectInst *SI = dyn_cast<SelectInst>(I.getOperand(1));
  580   SelectInst *SI = dyn_cast<SelectInst>(I.getOperand(1));
  772       return SelectInst::Create(Cmp, Op1, ConstantInt::get(Ty, 0));
  906   if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
  906   if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 1031         Inst = SelectInst::Create(cast<SelectInst>(ActionOp1)->getCondition(),
 1031         Inst = SelectInst::Create(cast<SelectInst>(ActionOp1)->getCondition(),
 1219     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 1219     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
 1224     if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
 1224     if (SelectInst *SI = dyn_cast<SelectInst>(Op0))
 1320       if (SelectInst *SI = dyn_cast<SelectInst>(Op0I)) {
 1320       if (SelectInst *SI = dyn_cast<SelectInst>(Op0I)) {
 1378     return SelectInst::Create(Cmp, Op0, Sub);
 1388     return SelectInst::Create(Cmp, ConstantInt::getNullValue(Ty), Op0);

lib/Transforms/InstCombine/InstCombineSelect.cpp

   58 static Instruction *foldSelectBinOpIdentity(SelectInst &Sel,
  123 static Value *foldSelectICmpAnd(SelectInst &Sel, ICmpInst *Cmp,
  282 Instruction *InstCombiner::foldSelectOpOp(SelectInst &SI, Instruction *TI,
  424 Instruction *InstCombiner::foldSelectIntoOp(SelectInst &SI, Value *TrueVal,
  894 static bool adjustMinMax(SelectInst &Sel, ICmpInst &Cmp) {
  991 canonicalizeMinMaxWithConstant(SelectInst &Sel, ICmpInst &Cmp,
 1029 static Instruction *canonicalizeAbsNabs(SelectInst &Sel, ICmpInst &Cmp,
 1137 static Value *foldSelectValueEquivalence(SelectInst &Sel, ICmpInst &Cmp,
 1178 static Instruction *canonicalizeClampLike(SelectInst &Sel0, ICmpInst &Cmp0,
 1302       SelectInst::Create(ShouldReplaceHigh, ReplacementHigh, MaybeReplacedLow);
 1316 tryToReuseConstantFromSelectInComparison(SelectInst &Sel, ICmpInst &Cmp,
 1383 Instruction *InstCombiner::foldSelectInstWithICmp(SelectInst &SI,
 1509                                                    const SelectInst &SI) {
 1606     SelectInst *SI = cast<SelectInst>(Inner);
 1606     SelectInst *SI = cast<SelectInst>(Inner);
 1665 static Instruction *foldAddSubSelect(SelectInst &SI,
 1735 Instruction *InstCombiner::foldSelectExtConst(SelectInst &Sel) {
 1784       return SelectInst::Create(Cond, AllOnesOrOne, C, "", nullptr, &Sel);
 1789       return SelectInst::Create(Cond, C, Zero, "", nullptr, &Sel);
 1798 static Instruction *canonicalizeSelectToShuffle(SelectInst &SI) {
 1839     SelectInst &Sel, InstCombiner::BuilderTy &Builder) {
 1861 static Instruction *foldSelectCmpBitcasts(SelectInst &Sel,
 1928 static Instruction *foldSelectCmpXchg(SelectInst &SI) {
 1945     if (auto *Select = dyn_cast<SelectInst>(SI.user_back()))
 1945     if (auto *Select = dyn_cast<SelectInst>(SI.user_back()))
 2015 Instruction *InstCombiner::matchSAddSubSat(SelectInst &MinMax1) {
 2133   return SelectInst::Create(CmpABC, MinMaxOp, ThirdOp);
 2140 static Instruction *foldSelectRotate(SelectInst &Sel) {
 2190 Instruction *InstCombiner::visitSelectInst(SelectInst &SI) {
 2319         return SelectInst::Create(NewCond, FalseVal, TrueVal,
 2337         return SelectInst::Create(NewCond, FalseVal, TrueVal,
 2483             cast<SelectInst>(NewMinMax)->setMetadata(LLVMContext::MD_prof, MD);
 2486               cast<SelectInst>(NewMinMax)->swapProfMetadata();
 2531   if (SelectInst *TrueSI = dyn_cast<SelectInst>(TrueVal)) {
 2531   if (SelectInst *TrueSI = dyn_cast<SelectInst>(TrueVal)) {
 2551   if (SelectInst *FalseSI = dyn_cast<SelectInst>(FalseVal)) {
 2551   if (SelectInst *FalseSI = dyn_cast<SelectInst>(FalseVal)) {
 2589     if (auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->getOperand(0))) {
 2589     if (auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->getOperand(0))) {
 2596     if (auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->getOperand(1))) {
 2596     if (auto *TrueBOSI = dyn_cast<SelectInst>(TrueBO->getOperand(1))) {
 2609     if (auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->getOperand(0))) {
 2609     if (auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->getOperand(0))) {
 2616     if (auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->getOperand(1))) {
 2616     if (auto *FalseBOSI = dyn_cast<SelectInst>(FalseBO->getOperand(1))) {

lib/Transforms/InstCombine/InstCombineShifts.cpp

  303     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
  303     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
  447     SelectInst *SI = cast<SelectInst>(I);
  447     SelectInst *SI = cast<SelectInst>(I);
  818         return SelectInst::Create(Cond, NewOp, NewShift);
  837         return SelectInst::Create(Cond, NewShift, NewOp);
  954       return SelectInst::Create(X, NewC, ConstantInt::getNullValue(Ty));

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

 1358     SelectInst *Sel = cast<SelectInst>(I);
 1358     SelectInst *Sel = cast<SelectInst>(I);

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

 1713   return SelectInst::Create(NarrowCond, NarrowX, NarrowY);

lib/Transforms/InstCombine/InstructionCombining.cpp

  857 Instruction *InstCombiner::FoldOpIntoSelect(Instruction &Op, SelectInst *SI) {
  904   return SelectInst::Create(SI->getCondition(), NewTV, NewFV, "", nullptr, SI);
  996   if (SelectInst *SI = dyn_cast<SelectInst>(&I)) {
  996   if (SelectInst *SI = dyn_cast<SelectInst>(&I)) {
 1078   if (auto *Sel = dyn_cast<SelectInst>(I.getOperand(0))) {
 1078   if (auto *Sel = dyn_cast<SelectInst>(I.getOperand(0))) {

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  166   SmallVector<SelectInst *, 8> Selects;
  307   DenseSet<SelectInst *> TrueBiasedSelects;
  308   DenseSet<SelectInst *> FalseBiasedSelects;
  392   void fixupSelect(SelectInst* SI,
  415   DenseSet<SelectInst *> TrueBiasedSelectsGlobal;
  417   DenseSet<SelectInst *> FalseBiasedSelectsGlobal;
  421   DenseMap<SelectInst *, BranchProbability> SelectBiasMap;
  496   return isa<BinaryOperator>(I) || isa<CastInst>(I) || isa<SelectInst>(I) ||
  641 static bool checkBias(K *Key, BranchProbability TrueProb,
  691     SelectInst *SI, Region *R,
  692     DenseSet<SelectInst *> &TrueBiasedSelectsGlobal,
  693     DenseSet<SelectInst *> &FalseBiasedSelectsGlobal,
  694     DenseMap<SelectInst *, BranchProbability> &SelectBiasMap) {
  716   for (SelectInst *SI : RI.Selects) {
  729   for (SelectInst *SI : RI.Selects) {
  816     SmallVector<SelectInst *, 8> Selects;
  826         if (auto *SI = dyn_cast<SelectInst>(&I)) {
  826         if (auto *SI = dyn_cast<SelectInst>(&I)) {
  834         for (auto *SI : Selects)
  893   SmallVector<SelectInst *, 8> &Selects = RI.Selects;
  902     for (SelectInst *SI : Selects) {
  907       SelectInst *SI = *it;
  946         for (SelectInst *SI : Selects) {
  971     for (auto *SI : Selects) {
  983     for (auto *SI : Selects) {
 1046   for (SelectInst *SI : RI.Selects) {
 1125     for (SelectInst *SI : RI.Selects)
 1317     for (SelectInst *SI : RI.Selects) {
 1393     for (SelectInst *SI : RI.Selects) {
 1415     for (SelectInst *SI : RI.Selects) {
 1510     for (SelectInst *SI : RI.Selects) {
 1531     if (isa<SelectInst>(U) && cast<SelectInst>(U)->getCondition() == ICmp)
 1531     if (isa<SelectInst>(U) && cast<SelectInst>(U)->getCondition() == ICmp)
 1548     if (auto *SI = dyn_cast<SelectInst>(U)) {
 1548     if (auto *SI = dyn_cast<SelectInst>(U)) {
 1645     for (SelectInst *SI : RI.Selects)
 1678     for (SelectInst *SI : RI.Selects) {
 1855     for (SelectInst *SI : RI.Selects) {
 1926 void CHR::fixupSelect(SelectInst *SI, CHRScope *Scope,

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  456   void visitSelectInst(SelectInst &I);
 1459 void DFSanVisitor::visitSelectInst(SelectInst &I) {
 1475           SelectInst::Create(I.getCondition(), TrueShadow, FalseShadow, "", &I);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 3505   void visitSelectInst(SelectInst& I) {

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

  347   void instrumentOneSelectInst(SelectInst &SI);
  348   void annotateOneSelectInst(SelectInst &SI);
  351   void visitSelectInst(SelectInst &SI);
 1347 void SelectInstVisitor::instrumentOneSelectInst(SelectInst &SI) {
 1361 void SelectInstVisitor::annotateOneSelectInst(SelectInst &SI) {
 1379 void SelectInstVisitor::visitSelectInst(SelectInst &SI) {
 1799       if (!isa<SelectInst>(I))

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

   41 bool ProvenanceAnalysis::relatedSelect(const SelectInst *A,
   46   if (const SelectInst *SB = dyn_cast<SelectInst>(B))
   46   if (const SelectInst *SB = dyn_cast<SelectInst>(B))
  154   if (const SelectInst *S = dyn_cast<SelectInst>(A))
  154   if (const SelectInst *S = dyn_cast<SelectInst>(A))
  156   if (const SelectInst *S = dyn_cast<SelectInst>(B))
  156   if (const SelectInst *S = dyn_cast<SelectInst>(B))

lib/Transforms/ObjCARC/ProvenanceAnalysis.h

   62   bool relatedSelect(const SelectInst *A, const Value *B);

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  125 static bool processSelect(SelectInst *S, LazyValueInfo *LVI) {
  227       SelectInst *SI = dyn_cast<SelectInst>(Incoming);
  227       SelectInst *SI = dyn_cast<SelectInst>(Incoming);
  843         BBChanged |= processSelect(cast<SelectInst>(II), LVI);

lib/Transforms/Scalar/EarlyCSE.cpp

  113            isa<CmpInst>(Inst) || isa<SelectInst>(Inst) ||

lib/Transforms/Scalar/InferAddressSpaces.cpp

  493     return SelectInst::Create(I->getOperand(0), NewPointerOperands[1],

lib/Transforms/Scalar/JumpThreading.cpp

  911   if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
  911   if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
 2425                                           SelectInst *SI, PHINode *SIUse,
 2467     SelectInst *PredSI = dyn_cast<SelectInst>(CondPHI->getIncomingValue(I));
 2467     SelectInst *PredSI = dyn_cast<SelectInst>(CondPHI->getIncomingValue(I));
 2508     SelectInst *SI = dyn_cast<SelectInst>(CondLHS->getIncomingValue(I));
 2508     SelectInst *SI = dyn_cast<SelectInst>(CondLHS->getIncomingValue(I));
 2583     SelectInst *SI = nullptr;
 2590           if (SelectInst *SelectI = dyn_cast<SelectInst>(Cmp->user_back()))
 2590           if (SelectInst *SelectI = dyn_cast<SelectInst>(Cmp->user_back()))
 2595       } else if (SelectInst *SelectI = dyn_cast<SelectInst>(U.getUser())) {
 2595       } else if (SelectInst *SelectI = dyn_cast<SelectInst>(U.getUser())) {

lib/Transforms/Scalar/LICM.cpp

 1038           isa<SelectInst>(I) || isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2253   SelectInst *Sel = dyn_cast<SelectInst>(Cond->getOperand(1));
 2253   SelectInst *Sel = dyn_cast<SelectInst>(Cond->getOperand(1));

lib/Transforms/Scalar/LoopUnswitch.cpp

  621   SelectInst *LSI = dyn_cast<SelectInst>(LHS);
  621   SelectInst *LSI = dyn_cast<SelectInst>(LHS);
  622   SelectInst *RSI = dyn_cast<SelectInst>(RHS);
  622   SelectInst *RSI = dyn_cast<SelectInst>(RHS);
  813       if (SelectInst *SI = dyn_cast<SelectInst>(BBI)) {
  813       if (SelectInst *SI = dyn_cast<SelectInst>(BBI)) {

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  238 template <class BrSelInst> static bool handleBrSelExpect(BrSelInst &BSI) {
  341         if (SelectInst *SI = dyn_cast<SelectInst>(Inst)) {
  341         if (SelectInst *SI = dyn_cast<SelectInst>(Inst)) {

lib/Transforms/Scalar/NewGVN.cpp

 1156   } else if (isa<SelectInst>(I)) {
 2578   return isa<BinaryOperator>(I) || isa<SelectInst>(I) || isa<CmpInst>(I) ||

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  638   if (!isa<PHINode>(V) && !isa<SelectInst>(V) &&
  791     return isa<PHINode>(BDV) || isa<SelectInst>(BDV) ||
  828       } else if (SelectInst *SI = dyn_cast<SelectInst>(Current)) {
  828       } else if (SelectInst *SI = dyn_cast<SelectInst>(Current)) {
  885       if (SelectInst *SI = dyn_cast<SelectInst>(BDV)) {
  885       if (SelectInst *SI = dyn_cast<SelectInst>(BDV)) {
  969       } else if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
  969       } else if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
  973         return SelectInst::Create(SI->getCondition(), Undef, Undef, Name, SI);
 1078     } else if (SelectInst *BaseSI =
 1079                    dyn_cast<SelectInst>(State.getBaseValue())) {
 1080       SelectInst *SI = cast<SelectInst>(BDV);
 1080       SelectInst *SI = cast<SelectInst>(BDV);

lib/Transforms/Scalar/SCCP.cpp

  617   void visitSelectInst(SelectInst &I);
  941 void SCCPSolver::visitSelectInst(SelectInst &I) {

lib/Transforms/Scalar/SROA.cpp

  622 static Value *foldSelectInst(SelectInst &SI) {
  640   return foldSelectInst(cast<SelectInst>(I));
  979                  !isa<SelectInst>(I) && !isa<AddrSpaceCastInst>(I)) {
 1044   void visitSelectInst(SelectInst &SI) { visitPHINodeOrSelectInst(SI); }
 1330 static bool isSafeSelectToSpeculate(SelectInst &SI) {
 1354 static void speculateSelectInstLoads(SelectInst &SI) {
 2313   SmallSetVector<SelectInst *, 8> &SelectUsers;
 2326                       SmallSetVector<SelectInst *, 8> &SelectUsers)
 3178   bool visitSelectInst(SelectInst &SI) {
 3454   bool visitSelectInst(SelectInst &SI) {
 4184   SmallSetVector<SelectInst *, 8> SelectUsers;
 4212   for (SelectInst *Sel : SelectUsers)
 4230       for (SelectInst *SelectUser : SelectUsers)

lib/Transforms/Scalar/Scalarizer.cpp

  185   bool visitSelectInst(SelectInst &SI);
  552 bool ScalarizerVisitor::visitSelectInst(SelectInst &SI) {

lib/Transforms/Utils/Evaluator.cpp

  416     } else if (SelectInst *SI = dyn_cast<SelectInst>(CurInst)) {
  416     } else if (SelectInst *SI = dyn_cast<SelectInst>(CurInst)) {

lib/Transforms/Utils/GlobalStatus.cpp

  145       } else if (isa<SelectInst>(I) || isa<PHINode>(I)) {

lib/Transforms/Utils/SimplifyCFG.cpp

 1395   std::map<std::pair<Value *, Value *>, SelectInst *> InsertedSelects;
 1405       SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)];
 1407         SI = cast<SelectInst>(
 3421       SelectInst *NV = cast<SelectInst>(
 3421       SelectInst *NV = cast<SelectInst>(
 3521 static bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select) {
 3557 static bool SimplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI) {
 4646   if (SelectInst *Select = dyn_cast<SelectInst>(I)) {
 4646   if (SelectInst *Select = dyn_cast<SelectInst>(I)) {
 5644     if (SelectInst *Select = dyn_cast<SelectInst>(Cond))
 5644     if (SelectInst *Select = dyn_cast<SelectInst>(Cond))
 5715   if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {
 5715   if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {

lib/Transforms/Utils/SimplifyIndVar.cpp

  345   SelectInst *Sel =
  346       SelectInst::Create(ICmp, ConstantInt::get(T, 0), N, "iv.rem", Rem);

lib/Transforms/Utils/SimplifyLibCalls.cpp

  713   if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {
  713   if (SelectInst *SI = dyn_cast<SelectInst>(Src)) {

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  492   if (auto *SelectA = dyn_cast<SelectInst>(PtrA)) {
  492   if (auto *SelectA = dyn_cast<SelectInst>(PtrA)) {
  493     if (auto *SelectB = dyn_cast<SelectInst>(PtrB)) {
  493     if (auto *SelectB = dyn_cast<SelectInst>(PtrB)) {
  728   if (const auto *Sel = dyn_cast<SelectInst>(ObjPtr)) {
  728   if (const auto *Sel = dyn_cast<SelectInst>(ObjPtr)) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 3335       } else if (auto *SI = dyn_cast<SelectInst>(I)) {
 3335       } else if (auto *SI = dyn_cast<SelectInst>(I)) {
 3731         if (isa<SelectInst>(U)) {
 6227     SelectInst *SI = cast<SelectInst>(I);
 6227     SelectInst *SI = cast<SelectInst>(I);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4961              isa<CmpInst>(I) || isa<SelectInst>(I) || isa<BinaryOperator>(I)) {
 5026     SelectInst *SI = cast<SelectInst>(I);
 5026     SelectInst *SI = cast<SelectInst>(I);
 5888         auto *Cmp = cast<Instruction>(cast<SelectInst>(I)->getCondition());
 5909                 cast<SelectInst>(I)->getCondition()->hasOneUse());
 5946         ReductionOps[0].emplace_back(cast<SelectInst>(I)->getCondition());
 6037         if (auto *SI = dyn_cast<SelectInst>(Op))
 6037         if (auto *SI = dyn_cast<SelectInst>(Op))
 6061         if (auto *SI = dyn_cast<SelectInst>(Op)) {
 6061         if (auto *SI = dyn_cast<SelectInst>(Op)) {
 6063                            cast<SelectInst>(I)->getCondition());
 6144     if (auto *Select = dyn_cast<SelectInst>(V)) {
 6144     if (auto *Select = dyn_cast<SelectInst>(V)) {
 6762     auto *SI = dyn_cast<SelectInst>(Inst);
 6762     auto *SI = dyn_cast<SelectInst>(Inst);

tools/llvm-stress/llvm-stress.cpp

  635     Value *V = SelectInst::Create(Cond, Val0, Val1, "Sl", BB->getTerminator());

unittests/Analysis/ScalarEvolutionTest.cpp

  188   SelectInst *Sel = SelectInst::Create(Cmp, Gep1, Gep2, "select", Br);
  188   SelectInst *Sel = SelectInst::Create(Cmp, Gep1, Gep2, "select", Br);

usr/include/c++/7.4.0/type_traits

  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1983     { typedef _Up     type; };