Introduce isoneof<T0, T1, ...> as an extension of isa<T>

[serge-sans-paille]

Summary

In many places, the idiom:

if(isa<T0>(V) || isa<T1>(V) || isa<T2>(V)) //...

is used. This commit introduces a new function, isoneof, that captures this idiom:

if(isa<anyof<T0, T1, T2>>(V)) //...

That's somehow similar to the tuple version of isinstance in Python.

Note to the reviewers: I wonder whether isa<> should be made variadic instead?

[serge-sans-paille]

Added documentation in `docs/ProgrammersManual.rst`

[sanjoy]

Overall, I think this is a really good abstraction, but given the scope of the change I'll wait for other stakeholders to chime in.

Right now it looks like isoneof<C> won't do the right thing -- we should definitely have it "gracefully degrade" to isa.

I won't vote for making isa variadic since that would read weird. isoneof, OTOH, is very understandable so my suggestion would be to stick with that.

[grandinj]

lib/Analysis/MemoryDependenceAnalysis.cpp

747

accidental delete?

[serge-sans-paille]

lib/Analysis/MemoryDependenceAnalysis.cpp

747

No, there's a `operator bool() on CallSite that basically checks isoneof<CallInst, InvolkeInst>(...)` so I removed the duplicate here.

[serge-sans-paille]

Make `isoneof<T> compatible with isa<T>`

[serge-sans-paille]

@sanjoy I updated the `isoneof implementation to behave like isa` when only one parameter is provided

[• dberlin]

The only issue i have with this is that for a bunch of these class hierarchies, multiple isa is inefficient compared to switch based.
Unfortunately, i don't think C++ gives us a good way to specialize for that.

Oh well.
Still LGTM

[serge-sans-paille]

@dberlin I agree. Not that to that respect, this commit does not change anything to the performance issue. Still it opens funny opportunities: one could imagine a constexpr function that would pre-compute the type lookup based on the argument type information, but that's definitively not part of this commit!

[serge-sans-paille]

Any extra comments on this review? ready for merging ?

[chandlerc]

I'd like to request that you make this patch just introduce the tool, and maybe add a few usages. I think rewriting this much in a single patch seems like a bad idea. It'll make reverts if anything goes wrong pointlessly hard, etc.

Then when the build bots are all happy you can migrate chunks of code in more focused patches.

[chandlerc]

Another high-level comment: I don't like the name isoneof. To me, that parses to the relationship being tested is rather than isa which loses an important distinction. I'm not really sure what would be the best name though.

include/llvm/Support/Casting.h

145–153

Please make this a doxygen comment, and no need to repeat the name in it.

Also, your example code calls this isa instead of isonef.

[sanjoy]

In D33125#760296, @chandlerc wrote:

Another high-level comment: I don't like the name isoneof. To me, that parses to the relationship being tested is rather than isa which loses an important distinction. I'm not really sure what would be the best name though.

One possibility is to figure out the C++ to make code like this work:

if (isa<oneof<T0, T1, T2>>(X))
  ...;

That's a bit more verbose, but we can read oneof<T0, T1, T2> as a sum type of T0, T1 and T2. I'd even be up for calling it sum or sumty, but not sure how others feel about that.

[serge-sans-paille]

@chandlerc Here is a minimal version of the patch, with the minimal hackery to support the `isa<anyof<...>> syntax. Note that it should support isa<anyof<>> (which is always false) and isa<anyof<T>> which should be quivalent to isa<T>`.

[serge-sans-paille]

Up :-) All remarks have been taken into account and only a minimal patch is provided, I'll apply the change next in separated commits.

[serge-sans-paille]

@chandlerc @mehdi_amini @sanjoy if that's okay with you, can you approve the review?

[chandlerc]

Honestly, the more I think about this, the more I think that the complexity it involves doesn't pull its weight.

First, we either have to deal with the semantic confusion of isa<T0, T1, T2, ...> or the readability burden of inventing and using a somewhat terrible name like isa_anyof or the technical complexity of magical tag templates that are *unqualified* and jammed in here for isa<anyof<...>>. Note that we have llvm::any_of already and it is very different! =[ None of these are insurmountable issues, but they add cost to this abstraction.

Second, the benefit is relatively small. Until the list of types is loooooong, isa<T0> || isa<T1> || isa<T2> really doesn't seem that bad. It's a bit more characters to type, but it neatly solves any and all of the semantic / syntactic ambiguity with zero complex implementation. Kinda nice.

But even worse, when these lists *do* get long, using isa, even with the new tool, is usually *the wrong approach*. People should instead be writing a proper switch over whatever data field is available rather than a series of tests. Once that series is long, I worry will not be reliable. And we have historically seen places where isa and dyn_cast did show up on the profile.

I feel like if we want to make chains of these things easier to code, that easier to code pattern should actually provide more value such as succinctly packaging up the single-dispatch approach. But currently, I don't think our system really exposes enough information to implement that more pattern-match-y approach, and it isn't clear that we really want to make such a big change as to introduce it.

Anyways, long story short, I'm no longer sure we should pursue this direction. Curious what others think though.

[serge-sans-paille]

@chandlerc the extra complexity is worth 15 lines of codes, and thanks to your `anyof<>` proposal, it's very local.

As you noted, the benefits of the `anyof<...> syntax compared to a chaining of ||` is not on the performance side. It's slightly more concise, and when I did the full replacement, I often met example like this:

if(isa<T0>(Inst->getOperand(0)) || isa<T1>(Inst->getOperand(0))
    /* stuff*/;

With this proposal, it naturally turns into

if(isa<anyof<T0, T1>>(Inst->getOperand(0)))
    /* stuff*/;

which avoids the redundancy. Not a big deal yet it avoids some kind of redundancy. In other examples, you had

if (isa<T0>(V0) || isa <T1>(V1>)) 
    /* stuff*/

which cannot be reduced, but could be confusing while introducing `anyof<>` make the two situations visually different.

Again I admit the added value is arguable, so let see what the other think about it.

[• dberlin]

I actually like this syntax, because i think it's more concise *and* significantly less prone to errors (for the reason serge pointed out).
We *could* make it faster if we wanted (I think we could metaprogram a version that used switch if it could and there are greater than X args).
The other way requires every caller to be cognizant of when switch becomes more performant, and implement it themselves.

Bottom line: I'd rather see it abstracted than not abstracted.

[mehdi_amini]

In D33125#769930, @chandlerc wrote:

Honestly, the more I think about this, the more I think that the complexity it involves doesn't pull its weight.

I'm fairly neutral on this.

First, we either have to deal with the semantic confusion of isa<T0, T1, T2, ...> or the readability burden of inventing and using a somewhat terrible name like isa_anyof

For a non-native speaker, I still don't understand why the correct form isn't is_anyof ( "is any of")? You may explain this to me tonight :)

or the technical complexity of magical tag templates that are *unqualified* and jammed in here for isa<anyof<...>>. Note that we have llvm::any_of already and it is very different! =[ None of these are insurmountable issues, but they add cost to this abstraction.

I thought exactly about these after the last update!

Second, the benefit is relatively small. Until the list of types is loooooong, isa<T0> || isa<T1> || isa<T2> really doesn't seem that bad. It's a bit more characters to type, but it neatly solves any and all of the semantic / syntactic ambiguity with zero complex implementation. Kinda nice.

Well I can't refrain but remembering all the people that didn't want to use the STL algorithm and write raw for loop using this same argument.
What's missing is that "any_of" express clearly the intent and is a lot easier to parse for a human. As Serge mentioned in his last example, DRY can be annoying to attain without such construct.

But even worse, when these lists *do* get long, using isa, even with the new tool, is usually *the wrong approach*. People should instead be writing a proper switch over whatever data field is available rather than a series of tests. Once that series is long, I worry will not be reliable.

Reliable on which aspect? Optimization?

And we have historically seen places where isa and dyn_cast did show up on the profile.

I see the positive aspect of it: more opportunities to improve compiler optimizations ;)
Driving syntactic changes because of optimizer failure makes me sad...

[serge-sans-paille]

So three options:

1. We give up with this idea
2. We introduce the `isa<anyof<>>` syntax
3. We introduce the `is_anyof<>` syntax

I leave the choice to the reviewers, here is my preference : 3 > 2 > 1

[serge-sans-paille]

@mehdi_amini so what's the status? No consensus /reaction :-/

[mehdi_amini]

I'm fine either way with this patch, and @chandlerc didn't answer my last comment.

[serge-sans-paille]

@chandlerc any thoughts on @mehdi_amini ? i also think that the `is_anyof<T0,...>` construct raises the abstraction without any gory implementation detail.

[serge-sans-paille]

@chandlerc up!

[serge-sans-paille]

According to @chandlerc tehre is not much benefit in this idiom, closing the patch.

include/llvm/Analysis/ObjCARCAnalysisUtils.h

 /// \brief Assuming the given instruction is one of the special calls such as
 /// objc_retain or objc_release, return the RCIdentity root of the argument of
 /// the call.
 inline Value *GetArgRCIdentityRoot(Value *Inst) {
   return GetRCIdentityRoot(cast<CallInst>(Inst)->getArgOperand(0));
 }
 
 inline bool IsNullOrUndef(const Value *V) {
-  return isa<ConstantPointerNull>(V) || isa<UndefValue>(V);
+  return isoneof<ConstantPointerNull, UndefValue>(V);
 }
 
 inline bool IsNoopInstruction(const Instruction *I) {
   return isa<BitCastInst>(I) ||
     (isa<GetElementPtrInst>(I) &&
      cast<GetElementPtrInst>(I)->hasAllZeroIndices());
 }
 
 /// \brief Test whether the given value is possible a retainable object pointer.
 inline bool IsPotentialRetainableObjPtr(const Value *Op) {
   // Pointers to static or stack storage are not valid retainable object
   // pointers.
-  if (isa<Constant>(Op) || isa<AllocaInst>(Op))
+  if (isoneof<Constant, AllocaInst>(Op))
     return false;
   // Special arguments can not be a valid retainable object pointer.
   if (const Argument *Arg = dyn_cast<Argument>(Op))
     if (Arg->hasByValAttr() ||
         Arg->hasInAllocaAttr() ||
         Arg->hasNestAttr() ||
         Arg->hasStructRetAttr())
       return false;

 /// object.
 ///
 /// This is similar to AliasAnalysis's isIdentifiedObject, except that it uses
 /// special knowledge of ObjC conventions.
 inline bool IsObjCIdentifiedObject(const Value *V) {
   // Assume that call results and arguments have their own "provenance".
   // Constants (including GlobalVariables) and Allocas are never
   // reference-counted.
-  if (isa<CallInst>(V) || isa<InvokeInst>(V) ||
-      isa<Argument>(V) || isa<Constant>(V) ||
-      isa<AllocaInst>(V))
+  if (isoneof<CallInst, InvokeInst, Argument, Constant, AllocaInst>(V))
     return true;
 
   if (const LoadInst *LI = dyn_cast<LoadInst>(V)) {
     const Value *Pointer =
       GetRCIdentityRoot(LI->getPointerOperand());
     if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Pointer)) {
       // A constant pointer can't be pointing to an object on the heap. It may
       // be reference-counted, but it won't be deleted.

include/llvm/Analysis/TargetTransformInfoImpl.h

public:
   bool shouldExpandReduction(const IntrinsicInst *II) const {
     return true;
   }
 
 protected:
   // Obtain the minimum required size to hold the value (without the sign)
   // In case of a vector it returns the min required size for one element.
   unsigned minRequiredElementSize(const Value* Val, bool &isSigned) {
-    if (isa<ConstantDataVector>(Val) || isa<ConstantVector>(Val)) {
+    if (isoneof<ConstantDataVector, ConstantVector>(Val)) {
       const auto* VectorValue = cast<Constant>(Val);
 
       // In case of a vector need to pick the max between the min
       // required size for each element
       auto *VT = cast<VectorType>(Val->getType());
 
       // Assume unsigned elements
       isSigned = false;

include/llvm/CodeGen/BasicTTIImpl.h

else
       return;
 
     // Scan the loop: don't unroll loops with calls.
     for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E;
          ++I) {
       BasicBlock *BB = *I;
 
       for (BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE; ++J)
-        if (isa<CallInst>(J) || isa<InvokeInst>(J)) {
-          ImmutableCallSite CS(&*J);
+        if (ImmutableCallSite CS{&*J}) {
           if (const Function *F = CS.getCalledFunction()) {
             if (!static_cast<T *>(this)->isLoweredToCall(F))
               continue;
           }
 
           return;
         }
     }

include/llvm/IR/CallSite.h

FunTy *getCalledFunction() const {
     return dyn_cast<FunTy>(getCalledValue());
   }
 
   /// Return true if the callsite is an indirect call.
   bool isIndirectCall() const {
     Value *V = getCalledValue();
     if (!V)
       return false;
-    if (isa<FunTy>(V) || isa<Constant>(V))
+    if (isoneof<FunTy, Constant>(V))
       return false;
     if (CallInst *CI = dyn_cast<CallInst>(getInstruction())) {
       if (CI->isInlineAsm())
         return false;
     }
     return true;
   }
 

include/llvm/IR/Operator.h

static unsigned getOpcode(const Value *V) {
     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
       return CE->getOpcode();
     return Instruction::UserOp1;
   }
 
   static inline bool classof(const Instruction *) { return true; }
   static inline bool classof(const ConstantExpr *) { return true; }
   static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) || isa<ConstantExpr>(V);
+    return isoneof<Instruction, ConstantExpr>(V);
   }
 };
 
 /// Utility class for integer arithmetic operators which may exhibit overflow -
 /// Add, Sub, and Mul. It does not include SDiv, despite that operator having
 /// the potential for overflow.
 class OverflowingBinaryOperator : public Operator {
 public:

include/llvm/IR/PatternMatch.h

template <typename OpTy> bool match(OpTy *V) {
     if (auto *O = dyn_cast<Operator>(V))
       if (O->getOpcode() == Instruction::Xor)
         return matchIfNot(O->getOperand(0), O->getOperand(1));
     return false;
   }
 
 private:
   bool matchIfNot(Value *LHS, Value *RHS) {
-    return (isa<ConstantInt>(RHS) || isa<ConstantDataVector>(RHS) ||
+    return (isoneof<ConstantInt, ConstantDataVector>(RHS) ||
             // FIXME: Remove CV.
             isa<ConstantVector>(RHS)) &&
            cast<Constant>(RHS)->isAllOnesValue() && L.match(LHS);
   }
 };
 
 template <typename LHS> inline not_match<LHS> m_Not(const LHS &L) { return L; }
 

include/llvm/IR/Statepoint.h

static inline bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 
   /// Return true if this relocate is tied to the invoke statepoint.
   /// This includes relocates which are on the unwinding path.
   bool isTiedToInvoke() const {
     const Value *Token = getArgOperand(0);
 
-    return isa<LandingPadInst>(Token) || isa<InvokeInst>(Token);
+    return isoneof<LandingPadInst, InvokeInst>(Token);
   }
 
   /// The statepoint with which this gc.relocate is associated.
   const Instruction *getStatepoint() const {
     const Value *Token = getArgOperand(0);
 
     // This takes care both of relocates for call statepoints and relocates
     // on normal path of invoke statepoint.

include/llvm/IR/User.h

public:
   /// \brief Replace uses of one Value with another.
   ///
   /// Replaces all references to the "From" definition with references to the
   /// "To" definition.
   void replaceUsesOfWith(Value *From, Value *To);
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) || isa<Constant>(V);
+    return isoneof<Instruction, Constant>(V);
   }
 };
 
 // Either Use objects, or a Use pointer can be prepended to User.
 static_assert(alignof(Use) >= alignof(User),
               "Alignment is insufficient after objects prepended to User");
 static_assert(alignof(Use *) >= alignof(User),
               "Alignment is insufficient after objects prepended to User");

include/llvm/IR/Value.h

 template <> struct isa_impl<GlobalIFunc, Value> {
   static inline bool doit(const Value &Val) {
     return Val.getValueID() == Value::GlobalIFuncVal;
   }
 };
 
 template <> struct isa_impl<GlobalIndirectSymbol, Value> {
   static inline bool doit(const Value &Val) {
-    return isa<GlobalAlias>(Val) || isa<GlobalIFunc>(Val);
+    return isoneof<GlobalAlias, GlobalIFunc>(Val);
   }
 };
 
 template <> struct isa_impl<GlobalValue, Value> {
   static inline bool doit(const Value &Val) {
-    return isa<GlobalObject>(Val) || isa<GlobalIndirectSymbol>(Val);
+    return isoneof<GlobalObject, GlobalIndirectSymbol>(Val);
   }
 };
 
 template <> struct isa_impl<GlobalObject, Value> {
   static inline bool doit(const Value &Val) {
-    return isa<GlobalVariable>(Val) || isa<Function>(Val);
+    return isoneof<GlobalVariable, Function>(Val);
   }
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_ISA_CONVERSION_FUNCTIONS(Value, LLVMValueRef)
 
 // Specialized opaque value conversions.
 inline Value **unwrap(LLVMValueRef *Vals) {

include/llvm/Support/Casting.h

 //
 //  if (isa<Type>(myVal)) { ... }
 //
 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
   return isa_impl_wrap<X, const Y,
                        typename simplify_type<const Y>::SimpleType>::doit(Val);
 }
 
+// isoneof<X...> - Return true if the parameter to the template is an instance
+// of one of the template type argument.  Used like this:
+//
+//  if (isa<Type0, Type1, Type2>(myVal)) { ... }
+//
+//  which is equivalent to
+//
+//  if (isa<Type0>(myVal) || isa<Type1>(myVal) || isa<Type2>(myVal)) { ... }
+//
+template <class Y> LLVM_NODISCARD inline bool isoneof(const Y &Val) {
+  return false;
+}
+template <class Ty, class... Tys, class Y>
+LLVM_NODISCARD inline bool isoneof(const Y &Val) {
+  return isa<Ty>(Val) || isoneof<Tys...>(Val);
+}
+
 //===----------------------------------------------------------------------===//
 //                          cast<x> Support Templates
 //===----------------------------------------------------------------------===//
 
 template<class To, class From> struct cast_retty;
 
 
 // Calculate what type the 'cast' function should return, based on a requested

lib/Analysis/AliasAnalysis.cpp

ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
                                          const MemoryLocation &MemLoc,
                                          DominatorTree *DT,
                                          OrderedBasicBlock *OBB) {
   if (!DT)
     return MRI_ModRef;
 
   const Value *Object =
       GetUnderlyingObject(MemLoc.Ptr, I->getModule()->getDataLayout());
-  if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) ||
-      isa<Constant>(Object))
+  if (!isIdentifiedObject(Object) || isoneof<GlobalValue, Constant>(Object))
     return MRI_ModRef;
 
   ImmutableCallSite CS(I);
   if (!CS.getInstruction() || CS.getInstruction() == Object)
     return MRI_ModRef;
 
   if (llvm::PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
                                        /* StoreCaptures */ true, I, DT,

lib/Analysis/AssumptionCache.cpp

auto AddAffected = [&Affected](Value *V) {
     } else if (auto *I = dyn_cast<Instruction>(V)) {
       Affected.push_back(I);
 
       // Peek through unary operators to find the source of the condition.
       Value *Op;
       if (match(I, m_BitCast(m_Value(Op))) ||
           match(I, m_PtrToInt(m_Value(Op))) ||
           match(I, m_Not(m_Value(Op)))) {
-        if (isa<Instruction>(Op) || isa<Argument>(Op))
+        if (isoneof<Instruction, Argument>(Op))
           Affected.push_back(Op);
       }
     }
   };
 
   Value *Cond = CI->getArgOperand(0), *A, *B;
   AddAffected(Cond);
 

lib/Analysis/BasicAliasAnalysis.cpp

if (A->hasByValAttr() || A->hasNoAliasAttr())
       return !PointerMayBeCaptured(V, false, /*StoreCaptures=*/true);
 
   return false;
 }
 
 /// Returns true if the pointer is one which would have been considered an
 /// escape by isNonEscapingLocalObject.
 static bool isEscapeSource(const Value *V) {
-  if (isa<CallInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V))
+  if (isoneof<CallInst, InvokeInst, Argument>(V))
     return true;
 
   // The load case works because isNonEscapingLocalObject considers all
   // stores to be escapes (it passes true for the StoreCaptures argument
   // to PointerMayBeCaptured).
   if (isa<LoadInst>(V))
     return true;
 
if (ConstantInt *RHSC = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
       }
       return V;
     }
   }
 
   // Since GEP indices are sign extended anyway, we don't care about the high
   // bits of a sign or zero extended value - just scales and offsets.  The
   // extensions have to be consistent though.
-  if (isa<SExtInst>(V) || isa<ZExtInst>(V)) {
+  if (isoneof<SExtInst, ZExtInst>(V)) {
     Value *CastOp = cast<CastInst>(V)->getOperand(0);
     unsigned NewWidth = V->getType()->getPrimitiveSizeInBits();
     unsigned SmallWidth = CastOp->getType()->getPrimitiveSizeInBits();
     unsigned OldZExtBits = ZExtBits, OldSExtBits = SExtBits;
     const Value *Result =
         GetLinearExpression(CastOp, Scale, Offset, ZExtBits, SExtBits, DL,
                             Depth + 1, AC, DT, NSW, NUW);
 
bool BasicAAResult::isGEPBaseAtNegativeOffset(const GEPOperator *GEPOp,
       uint64_t ObjectAccessSize) {
   // If the object access size is unknown, or the GEP isn't inbounds, bail.
   if (ObjectAccessSize == MemoryLocation::UnknownSize || !GEPOp->isInBounds())
     return false;
 
   // We need the object to be an alloca or a globalvariable, and want to know
   // the offset of the pointer from the object precisely, so no variable
   // indices are allowed.
-  if (!(isa<AllocaInst>(DecompObject.Base) ||
-        isa<GlobalVariable>(DecompObject.Base)) ||
+  if (!isoneof<AllocaInst, GlobalVariable>(DecompObject.Base) ||
       !DecompObject.VarIndices.empty())
     return false;
 
   int64_t ObjectBaseOffset = DecompObject.StructOffset +
                              DecompObject.OtherOffset;
 
   // If the GEP has no variable indices, we know the precise offset
   // from the base, then use it. If the GEP has variable indices, we're in

lib/Analysis/CFLSteensAliasAnalysis.cpp

static bool canSkipAddingToSets(Value *Val) {
   // store i32* null, i32** %ptr2
   // clearly ptr1 and ptr2 should not be unified into the same set, so
   // we should filter out the (potentially shared) instance to
   // i32* null.
   if (isa<Constant>(Val)) {
     // TODO: Because all of these things are constant, we can determine whether
     // the data is *actually* mutable at graph building time. This will probably
     // come for free/cheap with offset awareness.
-    bool CanStoreMutableData = isa<GlobalValue>(Val) ||
-                               isa<ConstantExpr>(Val) ||
-                               isa<ConstantAggregate>(Val);
+    bool CanStoreMutableData =
+        isoneof<GlobalValue, ConstantExpr, ConstantAggregate>(Val);
     return !CanStoreMutableData;
   }
 
   return false;
 }
 
 CFLSteensAAResult::FunctionInfo::FunctionInfo(
     Function &Fn, const SmallVectorImpl<Value *> &RetVals,

lib/Analysis/CodeMetrics.cpp

void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB,
   ++NumBlocks;
   unsigned NumInstsBeforeThisBB = NumInsts;
   for (const Instruction &I : *BB) {
     // Skip ephemeral values.
     if (EphValues.count(&I))
       continue;
 
     // Special handling for calls.
-    if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
-      ImmutableCallSite CS(&I);
+    if (ImmutableCallSite CS{&I}) {
 
       if (const Function *F = CS.getCalledFunction()) {
         // If a function is both internal and has a single use, then it is
         // extremely likely to get inlined in the future (it was probably
         // exposed by an interleaved devirtualization pass).
         if (!CS.isNoInline() && F->hasInternalLinkage() && F->hasOneUse())
           ++NumInlineCandidates;
 

lib/Analysis/ConstantFolding.cpp

Constant *FoldBitCast(Constant *C, Type *DestTy, const DataLayout &DL) {
 
   // The code below only handles casts to vectors currently.
   auto *DestVTy = dyn_cast<VectorType>(DestTy);
   if (!DestVTy)
     return ConstantExpr::getBitCast(C, DestTy);
 
   // If this is a scalar -> vector cast, convert the input into a <1 x scalar>
   // vector so the code below can handle it uniformly.
-  if (isa<ConstantFP>(C) || isa<ConstantInt>(C)) {
+  if (isoneof<ConstantFP, ConstantInt>(C)) {
     Constant *Ops = C; // don't take the address of C!
     return FoldBitCast(ConstantVector::get(Ops), DestTy, DL);
   }
 
   // If this is a bitcast from constant vector -> vector, fold it.
   if (!isa<ConstantDataVector>(C) && !isa<ConstantVector>(C))
     return ConstantExpr::getBitCast(C, DestTy);
 

 /// the CurPtr buffer. DL is the DataLayout.
 bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, unsigned char *CurPtr,
                         unsigned BytesLeft, const DataLayout &DL) {
   assert(ByteOffset <= DL.getTypeAllocSize(C->getType()) &&
          "Out of range access");
 
   // If this element is zero or undefined, we can just return since *CurPtr is
   // zero initialized.
-  if (isa<ConstantAggregateZero>(C) || isa<UndefValue>(C))
+  if (isoneof<ConstantAggregateZero, UndefValue>(C))
     return true;
 
   if (auto *CI = dyn_cast<ConstantInt>(C)) {
     if (CI->getBitWidth() > 64 ||
         (CI->getBitWidth() & 7) != 0)
       return false;
 
     uint64_t Val = CI->getZExtValue();
while (true) {
       CurPtr += NextEltOffset - CurEltOffset - ByteOffset;
       BytesLeft -= NextEltOffset - CurEltOffset - ByteOffset;
       ByteOffset = 0;
       CurEltOffset = NextEltOffset;
     }
     // not reached.
   }
 
-  if (isa<ConstantArray>(C) || isa<ConstantVector>(C) ||
-      isa<ConstantDataSequential>(C)) {
+  if (isoneof<ConstantArray, ConstantVector, ConstantDataSequential>(C)) {
     Type *EltTy = C->getType()->getSequentialElementType();
     uint64_t EltSize = DL.getTypeAllocSize(EltTy);
     uint64_t Index = ByteOffset / EltSize;
     uint64_t Offset = ByteOffset - Index * EltSize;
     uint64_t NumElts;
     if (auto *AT = dyn_cast<ArrayType>(C->getType()))
       NumElts = AT->getNumElements();
     else
ConstantFoldConstantImpl(const Constant *C, const DataLayout &DL,
   if (!isa<ConstantVector>(C) && !isa<ConstantExpr>(C))
     return nullptr;
 
   SmallVector<Constant *, 8> Ops;
   for (const Use &NewU : C->operands()) {
     auto *NewC = cast<Constant>(&NewU);
     // Recursively fold the ConstantExpr's operands. If we have already folded
     // a ConstantExpr, we don't have to process it again.
-    if (isa<ConstantVector>(NewC) || isa<ConstantExpr>(NewC)) {
+    if (isoneof<ConstantVector, ConstantExpr>(NewC)) {
       auto It = FoldedOps.find(NewC);
       if (It == FoldedOps.end()) {
         if (auto *FoldedC =
                 ConstantFoldConstantImpl(NewC, DL, TLI, FoldedOps)) {
           FoldedOps.insert({NewC, FoldedC});
           NewC = FoldedC;
         } else {
           FoldedOps.insert({NewC, NewC});
if (auto *Op = dyn_cast<ConstantInt>(Operands[0])) {
         return ConstantFP::get(Ty->getContext(), Val);
       }
       default:
         return nullptr;
       }
     }
 
     // Support ConstantVector in case we have an Undef in the top.
-    if (isa<ConstantVector>(Operands[0]) ||
-        isa<ConstantDataVector>(Operands[0])) {
+    if (isoneof<ConstantVector, ConstantDataVector>(Operands[0])) {
       auto *Op = cast<Constant>(Operands[0]);
       switch (IntrinsicID) {
       default: break;
       case Intrinsic::x86_sse_cvtss2si:
       case Intrinsic::x86_sse_cvtss2si64:
       case Intrinsic::x86_sse2_cvtsd2si:
       case Intrinsic::x86_sse2_cvtsd2si64:
         if (ConstantFP *FPOp =

lib/Analysis/CostModel.cpp

static bool isAlternateVectorMask(ArrayRef<int> Mask) {
   return isAlternate;
 }
 
 static TargetTransformInfo::OperandValueKind getOperandInfo(Value *V) {
   TargetTransformInfo::OperandValueKind OpInfo =
       TargetTransformInfo::OK_AnyValue;
 
   // Check for a splat of a constant or for a non uniform vector of constants.
-  if (isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) {
+  if (isoneof<ConstantVector, ConstantDataVector>(V)) {
     OpInfo = TargetTransformInfo::OK_NonUniformConstantValue;
     if (cast<Constant>(V)->getSplatValue() != nullptr)
       OpInfo = TargetTransformInfo::OK_UniformConstantValue;
   }
 
   // Check for a splat of a uniform value. This is not loop aware, so return
   // true only for the obviously uniform cases (argument, globalvalue)
   const Value *Splat = getSplatValue(V);
-  if (Splat && (isa<Argument>(Splat) || isa<GlobalValue>(Splat)))
+  if (Splat && isoneof<Argument, GlobalValue>(Splat))
     OpInfo = TargetTransformInfo::OK_UniformValue;
 
   return OpInfo;
 }
 
 static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
                                      unsigned Level) {
   // We don't need a shuffle if we just want to have element 0 in position 0 of

lib/Analysis/DemandedBits.cpp

void DemandedBitsWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }
 
 void DemandedBitsWrapperPass::print(raw_ostream &OS, const Module *M) const {
   DB->print(OS);
 }
 
 static bool isAlwaysLive(Instruction *I) {
-  return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) ||
-      I->isEHPad() || I->mayHaveSideEffects();
+  return isoneof<TerminatorInst, DbgInfoIntrinsic>(I) || I->isEHPad() ||
+         I->mayHaveSideEffects();
 }
 
 void DemandedBits::determineLiveOperandBits(
     const Instruction *UserI, const Instruction *I, unsigned OperandNo,
     const APInt &AOut, APInt &AB, KnownBits &Known, KnownBits &Known2) {
   unsigned BitWidth = AB.getBitWidth();
 
   // We're called once per operand, but for some instructions, we need to

lib/Analysis/DependenceAnalysis.cpp

 // Used to test the dependence analyzer.
 // Looks through the function, noting loads and stores.
 // Calls depends() on every possible pair and prints out the result.
 // Ignores all other instructions.
 static void dumpExampleDependence(raw_ostream &OS, DependenceInfo *DA) {
   auto *F = DA->getFunction();
   for (inst_iterator SrcI = inst_begin(F), SrcE = inst_end(F); SrcI != SrcE;
        ++SrcI) {
-    if (isa<StoreInst>(*SrcI) || isa<LoadInst>(*SrcI)) {
+    if (isoneof<StoreInst, LoadInst>(*SrcI)) {
       for (inst_iterator DstI = SrcI, DstE = inst_end(F);
            DstI != DstE; ++DstI) {
-        if (isa<StoreInst>(*DstI) || isa<LoadInst>(*DstI)) {
+        if (isoneof<StoreInst, LoadInst>(*DstI)) {
           OS << "da analyze - ";
           if (auto D = DA->depends(&*SrcI, &*DstI, true)) {
             D->dump(OS);
             for (unsigned Level = 1; Level <= D->getLevels(); Level++) {
               if (D->isSplitable(Level)) {
                 OS << "da analyze - split level = " << Level;
                 OS << ", iteration = " << *DA->getSplitIteration(*D, Level);
                 OS << "!\n";

lib/Analysis/GlobalsModRef.cpp

static bool isNonEscapingGlobalNoAliasWithLoad(const GlobalValue *GV,
                                                int &Depth,
                                                const DataLayout &DL) {
   SmallPtrSet<const Value *, 8> Visited;
   SmallVector<const Value *, 8> Inputs;
   Visited.insert(V);
   Inputs.push_back(V);
   do {
     const Value *Input = Inputs.pop_back_val();
-    
-    if (isa<GlobalValue>(Input) || isa<Argument>(Input) || isa<CallInst>(Input) ||
-        isa<InvokeInst>(Input))
+    if (isoneof<GlobalValue, Argument, CallInst, InvokeInst>(Input))
       // Arguments to functions or returns from functions are inherently
       // escaping, so we can immediately classify those as not aliasing any
       // non-addr-taken globals.
       //
       // (Transitive) loads from a global are also safe - if this aliased
       // another global, its address would escape, so no alias.
       continue;
 
if (auto *InputGV = dyn_cast<GlobalValue>(Input)) {
           continue;
       }
 
       // Conservatively return false, even though we could be smarter
       // (e.g. look through GlobalAliases).
       return false;
     }
 
-    if (isa<Argument>(Input) || isa<CallInst>(Input) ||
-        isa<InvokeInst>(Input)) {
+    if (isoneof<Argument, CallInst, InvokeInst>(Input)) {
       // Arguments to functions or returns from functions are inherently
       // escaping, so we can immediately classify those as not aliasing any
       // non-addr-taken globals.
       continue;
     }
     
     // Recurse through a limited number of selects, loads and PHIs. This is an
     // arbitrary depth of 4, lower numbers could be used to fix compile time

lib/Analysis/InstructionSimplify.cpp

 
   // Shifting by the bitwidth or more is undefined.
   if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
     if (CI->getValue().getLimitedValue() >=
         CI->getType()->getScalarSizeInBits())
       return true;
 
   // If all lanes of a vector shift are undefined the whole shift is.
-  if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) {
+  if (isoneof<ConstantVector, ConstantDataVector>(C)) {
     for (unsigned I = 0, E = C->getType()->getVectorNumElements(); I != E; ++I)
       if (!isUndefShift(C->getAggregateElement(I)))
         return false;
     return true;
   }
 
   return false;
 }

     // for now.
     //
     // With all that, if the offsets are within the bounds of their allocations
     // (and not one-past-the-end! so we can't use inbounds!), and their
     // allocations aren't the same, the pointers are not equal.
     //
     // Note that it's not necessary to check for LHS being a global variable
     // address, due to canonicalization and constant folding.
-    if (isa<AllocaInst>(LHS) &&
-        (isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) {
+    if (isa<AllocaInst>(LHS) && isoneof<AllocaInst, GlobalVariable>(RHS)) {
       ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset);
       ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset);
       uint64_t LHSSize, RHSSize;
       if (LHSOffsetCI && RHSOffsetCI &&
           getObjectSize(LHS, LHSSize, DL, TLI) &&
           getObjectSize(RHS, RHSSize, DL, TLI)) {
         const APInt &LHSOffsetValue = LHSOffsetCI->getValue();
         const APInt &RHSOffsetValue = RHSOffsetCI->getValue();

       auto InversedSatisfied_CR = ConstantRange::makeSatisfyingICmpRegion(
                 CmpInst::getInversePredicate(Pred), RHS_CR);
       if (InversedSatisfied_CR.contains(LHS_CR))
         return ConstantInt::getFalse(RHS->getContext());
     }
   }
 
   // Compare of cast, for example (zext X) != 0 -> X != 0
-  if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
+  if (isa<CastInst>(LHS) && isoneof<Constant, CastInst>(RHS)) {
     Instruction *LI = cast<CastInst>(LHS);
     Value *SrcOp = LI->getOperand(0);
     Type *SrcTy = SrcOp->getType();
     Type *DstTy = LI->getType();
 
     // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input
     // if the integer type is the same size as the pointer type.
     if (MaxRecurse && isa<PtrToIntInst>(LI) &&

                            const SimplifyQuery &Q, unsigned MaxRecurse) {
   Type *Ty = V->getType();
   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
     Ty = PTy->getElementType();
   FunctionType *FTy = cast<FunctionType>(Ty);
 
   // call undef -> undef
   // call null -> undef
-  if (isa<UndefValue>(V) || isa<ConstantPointerNull>(V))
+  if (isoneof<UndefValue, ConstantPointerNull>(V))
     return UndefValue::get(FTy->getReturnType());
 
   Function *F = dyn_cast<Function>(V);
   if (!F)
     return nullptr;
 
   if (F->isIntrinsic())
     if (Value *Ret = SimplifyIntrinsic(F, ArgBegin, ArgEnd, Q, MaxRecurse))

lib/Analysis/Loads.cpp

static bool AreEquivalentAddressValues(const Value *A, const Value *B) {
   if (A == B)
     return true;
 
   // Test if the values come from identical arithmetic instructions.
   // Use isIdenticalToWhenDefined instead of isIdenticalTo because
   // this function is only used when one address use dominates the
   // other, which means that they'll always either have the same
   // value or one of them will have an undefined value.
-  if (isa<BinaryOperator>(A) || isa<CastInst>(A) || isa<PHINode>(A) ||
-      isa<GetElementPtrInst>(A))
+  if (isoneof<BinaryOperator, CastInst, PHINode, GetElementPtrInst>(A))
     if (const Instruction *BI = dyn_cast<Instruction>(B))
       if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
         return true;
 
   // Otherwise they may not be equivalent.
   return false;
 }
 
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
         if (IsLoadCSE)
           *IsLoadCSE = false;
         return SI->getOperand(0);
       }
 
       // If both StrippedPtr and StorePtr reach all the way to an alloca or
       // global and they are different, ignore the store. This is a trivial form
       // of alias analysis that is important for reg2mem'd code.
-      if ((isa<AllocaInst>(StrippedPtr) || isa<GlobalVariable>(StrippedPtr)) &&
-          (isa<AllocaInst>(StorePtr) || isa<GlobalVariable>(StorePtr)) &&
+      if (isoneof<AllocaInst, GlobalVariable>(StrippedPtr) &&
+          isoneof<AllocaInst, GlobalVariable>(StorePtr) &&
           StrippedPtr != StorePtr)
         continue;
 
       // If we have alias analysis and it says the store won't modify the loaded
       // value, ignore the store.
       if (AA && (AA->getModRefInfo(SI, StrippedPtr, AccessSize) & MRI_Mod) == 0)
         continue;
 

lib/Analysis/MemDepPrinter.cpp

if (!Res.isNonLocal()) {
 
       DepSet &InstDeps = Deps[Inst];
       for (const NonLocalDepEntry &I : NLDI) {
         const MemDepResult &Res = I.getResult();
         InstDeps.insert(std::make_pair(getInstTypePair(Res), I.getBB()));
       }
     } else {
       SmallVector<NonLocalDepResult, 4> NLDI;
-      assert( (isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
-               isa<VAArgInst>(Inst)) && "Unknown memory instruction!"); 
+      assert((isoneof<LoadInst, StoreInst, VAArgInst>(Inst)) &&
+             "Unknown memory instruction!");
       MDA.getNonLocalPointerDependency(Inst, NLDI);
 
       DepSet &InstDeps = Deps[Inst];
       for (const NonLocalDepResult &I : NLDI) {
         const MemDepResult &Res = I.getResult();
         InstDeps.insert(std::make_pair(getInstTypePair(Res), I.getBB()));
       }
     }

lib/Analysis/MemoryBuiltins.cpp

if (!SeenVals.insert(V).second) {
     Result = unknown();
   } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
     Result = visitGEPOperator(*GEP);
   } else if (Instruction *I = dyn_cast<Instruction>(V)) {
     Result = visit(*I);
   } else if (isa<Argument>(V) ||
              (isa<ConstantExpr>(V) &&
               cast<ConstantExpr>(V)->getOpcode() == Instruction::IntToPtr) ||
-             isa<GlobalAlias>(V) ||
-             isa<GlobalVariable>(V)) {
+             isoneof<GlobalAlias, GlobalVariable>(V)) {
     // Ignore values where we cannot do more than ObjectSizeVisitor.
     Result = unknown();
   } else {
     DEBUG(dbgs() << "ObjectSizeOffsetEvaluator::compute() unhandled value: "
           << *V << '\n');
     Result = unknown();
   }
 

lib/Analysis/MemoryDependenceAnalysis.cpp

for (const Use &Us : Ptr->uses()) {
         if (GEP->hasAllZeroIndices()) {
           LoadOperandsQueue.push_back(U);
           continue;
         }
 
       // If we hit load/store with the same invariant.group metadata (and the
       // same pointer operand) we can assume that value pointed by pointer
       // operand didn't change.
-      if ((isa<LoadInst>(U) || isa<StoreInst>(U)) &&
+      if (isoneof<LoadInst, StoreInst>(U) &&
           U->getMetadata(LLVMContext::MD_invariant_group) == InvariantGroupMD)
         ClosestDependency = GetClosestDependency(ClosestDependency, U);
     }
   }
 
   if (!ClosestDependency)
     return MemDepResult::getUnknown();
   if (ClosestDependency->getParent() == BB)
if (BasicBlock::iterator(QueryInst) == QueryParent->begin()) {
     if (MemLoc.Ptr) {
       // If we can do a pointer scan, make it happen.
       bool isLoad = !(MR & MRI_Mod);
       if (auto *II = dyn_cast<IntrinsicInst>(QueryInst))
         isLoad |= II->getIntrinsicID() == Intrinsic::lifetime_start;
 
       LocalCache = getPointerDependencyFrom(
           MemLoc, isLoad, ScanPos->getIterator(), QueryParent, QueryInst);
-    } else if (isa<CallInst>(QueryInst) || isa<InvokeInst>(QueryInst)) {
-      CallSite QueryCS(QueryInst);
+    } else if (CallSite QueryCS{QueryInst}) {
       bool isReadOnly = AA.onlyReadsMemory(QueryCS);
       LocalCache = getCallSiteDependencyFrom(
           QueryCS, isReadOnly, ScanPos->getIterator(), QueryParent);
     } else
       // Non-memory instruction.
       LocalCache = MemDepResult::getUnknown();
   }
 

lib/Analysis/PHITransAddr.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 static bool CanPHITrans(Instruction *Inst) {
-  if (isa<PHINode>(Inst) ||
-      isa<GetElementPtrInst>(Inst))
+  if (isoneof<PHINode, GetElementPtrInst>(Inst))
     return true;
 
   if (isa<CastInst>(Inst) &&
       isSafeToSpeculativelyExecute(Inst))
     return true;
 
   if (Inst->getOpcode() == Instruction::Add &&
       isa<ConstantInt>(Inst->getOperand(1)))
     return true;
 
   //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
-  //   if (isa<BitCastInst>(PtrInst) || isa<GetElementPtrInst>(PtrInst))
+  //   if (isoneof<BitCastInst, GetElementPtrInst>(PtrInst))
   //     cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
   return false;
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void PHITransAddr::dump() const {
   if (!Addr) {
     dbgs() << "PHITransAddr: null\n";

lib/Analysis/ProfileSummaryInfo.cpp

bool ProfileSummaryInfo::computeSummary() {
   return true;
 }
 
 Optional<uint64_t>
 ProfileSummaryInfo::getProfileCount(const Instruction *Inst,
                                     BlockFrequencyInfo *BFI) {
   if (!Inst)
     return None;
-  assert((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
+  assert((isoneof<CallInst, InvokeInst>(Inst)) &&
          "We can only get profile count for call/invoke instruction.");
   if (computeSummary() && Summary->getKind() == ProfileSummary::PSK_Sample) {
     // In sample PGO mode, check if there is a profile metadata on the
     // instruction. If it is present, determine hotness solely based on that,
     // since the sampled entry count may not be accurate.
     uint64_t TotalCount;
     if (Inst->extractProfTotalWeight(TotalCount))
       return TotalCount;
if (!F || !computeSummary())
     return false;
   if (auto FunctionCount = F->getEntryCount())
     if (isHotCount(FunctionCount.getValue()))
       return true;
 
   uint64_t TotalCallCount = 0;
   for (const auto &BB : *F)
     for (const auto &I : BB)
-      if (isa<CallInst>(I) || isa<InvokeInst>(I))
+      if (isoneof<CallInst, InvokeInst>(I))
         if (auto CallCount = getProfileCount(&I, nullptr))
           TotalCallCount += CallCount.getValue();
   return isHotCount(TotalCallCount);
 }
 
 /// Returns true if the function's entry and total call edge count is cold.
 /// If it returns false, it either means it is not cold or it is unknown
 /// whether it is cold or not (for example, no profile data is available).
 bool ProfileSummaryInfo::isFunctionColdInCallGraph(const Function *F) {
   if (!F || !computeSummary())
     return false;
   if (auto FunctionCount = F->getEntryCount())
     if (!isColdCount(FunctionCount.getValue()))
       return false;
   
   uint64_t TotalCallCount = 0;
   for (const auto &BB : *F)
-    for (const auto &I : BB) 
-      if (isa<CallInst>(I) || isa<InvokeInst>(I))
+    for (const auto &I : BB)
+      if (isoneof<CallInst, InvokeInst>(I))
         if (auto CallCount = getProfileCount(&I, nullptr))
           TotalCallCount += CallCount.getValue();
   return isColdCount(TotalCallCount);
 }
 
 /// Returns true if the function's entry is a cold. If it returns false, it
 /// either means it is not cold or it is unknown whether it is cold or not (for
 /// example, no profile data is available).

lib/Analysis/ScalarEvolution.cpp

         Ok = false;
         break;
       }
     }
     if (Ok) {
       // Evaluate the expression in the larger type.
       const SCEV *Fold = getAddExpr(LargeOps, Flags, Depth + 1);
       // If it folds to something simple, use it. Otherwise, don't.
-      if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
+      if (isoneof<SCEVConstant, SCEVUnknown>(Fold))
         return getTruncateExpr(Fold, DstType);
     }
   }
 
   // Skip past any other cast SCEVs.
   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
     ++Idx;
 

 static bool containsConstantSomewhere(const SCEV *StartExpr) {
   SmallVector<const SCEV *, 4> Ops;
   Ops.push_back(StartExpr);
   while (!Ops.empty()) {
     const SCEV *CurrentExpr = Ops.pop_back_val();
     if (isa<SCEVConstant>(*CurrentExpr))
       return true;
 
-    if (isa<SCEVAddExpr>(*CurrentExpr) || isa<SCEVMulExpr>(*CurrentExpr)) {
+    if (isoneof<SCEVAddExpr, SCEVMulExpr>(*CurrentExpr)) {
       const auto *CurrentNAry = cast<SCEVNAryExpr>(CurrentExpr);
       Ops.append(CurrentNAry->op_begin(), CurrentNAry->op_end());
     }
   }
   return false;
 }
 
 /// Get a canonical multiply expression, or something simpler if possible.

   }
 
   return getCouldNotCompute();
 }
 
 /// Return true if we can constant fold an instruction of the specified type,
 /// assuming that all operands were constants.
 static bool CanConstantFold(const Instruction *I) {
-  if (isa<BinaryOperator>(I) || isa<CmpInst>(I) ||
-      isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I) ||
-      isa<LoadInst>(I))
+  if (isoneof<BinaryOperator, CmpInst, SelectInst, CastInst, GetElementPtrInst,
+              LoadInst>(I))
     return true;
 
   if (const CallInst *CI = dyn_cast<CallInst>(I))
     if (const Function *F = CI->getCalledFunction())
       return canConstantFoldCallTo(F);
   return false;
 }
 

 static bool HasSameValue(const SCEV *A, const SCEV *B) {
   // Quick check to see if they are the same SCEV.
   if (A == B) return true;
 
   auto ComputesEqualValues = [](const Instruction *A, const Instruction *B) {
     // Not all instructions that are "identical" compute the same value.  For
     // instance, two distinct alloca instructions allocating the same type are
     // identical and do not read memory; but compute distinct values.
-    return A->isIdenticalTo(B) && (isa<BinaryOperator>(A) || isa<GetElementPtrInst>(A));
+    return A->isIdenticalTo(B) && isoneof<BinaryOperator, GetElementPtrInst>(A);
   };
 
   // Otherwise, if they're both SCEVUnknown, it's possible that they hold
   // two different instructions with the same value. Check for this case.
   if (const SCEVUnknown *AU = dyn_cast<SCEVUnknown>(A))
     if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
       if (const Instruction *AI = dyn_cast<Instruction>(AU->getValue()))
         if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))

 // Collect all SCEVUnknown and SCEVMulExpr expressions.
 struct SCEVCollectTerms {
   SmallVectorImpl<const SCEV *> &Terms;
 
   SCEVCollectTerms(SmallVectorImpl<const SCEV *> &T)
       : Terms(T) {}
 
   bool follow(const SCEV *S) {
-    if (isa<SCEVUnknown>(S) || isa<SCEVMulExpr>(S) ||
-        isa<SCEVSignExtendExpr>(S)) {
+    if (isoneof<SCEVUnknown, SCEVMulExpr, SCEVSignExtendExpr>(S)) {
       if (!containsUndefs(S))
         Terms.push_back(S);
 
       // Stop recursion: once we collected a term, do not walk its operands.
       return false;
     }
 
     // Keep looking.

lib/Analysis/ScalarEvolutionExpander.cpp

static BasicBlock::iterator findInsertPointAfter(Instruction *I,
                                                  BasicBlock *MustDominate) {
   BasicBlock::iterator IP = ++I->getIterator();
   if (auto *II = dyn_cast<InvokeInst>(I))
     IP = II->getNormalDest()->begin();
 
   while (isa<PHINode>(IP))
     ++IP;
 
-  if (isa<FuncletPadInst>(IP) || isa<LandingPadInst>(IP)) {
+  if (isoneof<FuncletPadInst, LandingPadInst>(IP)) {
     ++IP;
   } else if (isa<CatchSwitchInst>(IP)) {
     IP = MustDominate->getFirstInsertionPt();
   } else {
     assert(!IP->isEHPad() && "unexpected eh pad!");
   }
 
   return IP;
if (!At)
       At = &ExitingBB->back();
     if (!getRelatedExistingExpansion(
             SE.getAddExpr(S, SE.getConstant(S->getType(), 1)), At, L))
       return true;
   }
 
   // HowManyLessThans uses a Max expression whenever the loop is not guarded by
   // the exit condition.
-  if (isa<SCEVSMaxExpr>(S) || isa<SCEVUMaxExpr>(S))
+  if (isoneof<SCEVSMaxExpr, SCEVUMaxExpr>(S))
     return true;
 
   // Recurse past nary expressions, which commonly occur in the
   // BackedgeTakenCount. They may already exist in program code, and if not,
   // they are not too expensive rematerialize.
   if (const SCEVNAryExpr *NAry = dyn_cast<SCEVNAryExpr>(S)) {
     for (auto *Op : NAry->operands())
       if (isHighCostExpansionHelper(Op, L, At, Processed))

lib/Analysis/ValueTracking.cpp

   const APInt *C;
   if (match(V, m_APInt(C))) {
     // We know all of the bits for a scalar constant or a splat vector constant!
     Known.One = *C;
     Known.Zero = ~Known.One;
     return;
   }
   // Null and aggregate-zero are all-zeros.
-  if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
+  if (isoneof<ConstantPointerNull, ConstantAggregateZero>(V)) {
     Known.setAllZero();
     return;
   }
   // Handle a constant vector by taking the intersection of the known bits of
   // each element.
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V)) {
     // We know that CDS must be a vector of integers. Take the intersection of
     // each element.

   unsigned BitWidth = getBitWidth(V->getType()->getScalarType(), Q.DL);
 
   // X | Y != 0 if X != 0 or Y != 0.
   Value *X = nullptr, *Y = nullptr;
   if (match(V, m_Or(m_Value(X), m_Value(Y))))
     return isKnownNonZero(X, Depth, Q) || isKnownNonZero(Y, Depth, Q);
 
   // ext X != 0 if X != 0.
-  if (isa<SExtInst>(V) || isa<ZExtInst>(V))
+  if (isoneof<SExtInst, ZExtInst>(V))
     return isKnownNonZero(cast<Instruction>(V)->getOperand(0), Depth, Q);
 
   // shl X, Y != 0 if X is odd.  Note that the value of the shift is undefined
   // if the lowest bit is shifted off the end.
   if (match(V, m_Shl(m_Value(X), m_Value(Y)))) {
     // shl nuw can't remove any non-zero bits.
     const OverflowingBinaryOperator *BO = cast<OverflowingBinaryOperator>(V);
     if (BO->hasNoUnsignedWrap())

 
   // (add x, 0.0) is guaranteed to return +0.0, not -0.0.
   if (I->getOpcode() == Instruction::FAdd)
     if (ConstantFP *CFP = dyn_cast<ConstantFP>(I->getOperand(1)))
       if (CFP->isNullValue())
         return true;
 
   // sitofp and uitofp turn into +0.0 for zero.
-  if (isa<SIToFPInst>(I) || isa<UIToFPInst>(I))
+  if (isoneof<SIToFPInst, UIToFPInst>(I))
     return true;
 
   if (const CallInst *CI = dyn_cast<CallInst>(I)) {
     Intrinsic::ID IID = getIntrinsicForCallSite(CI, TLI);
     switch (IID) {
     default:
       break;
     // sqrt(-0.0) = -0.0, no other negative results are possible.

     }
   }
 
   return false;
 }
 
 bool llvm::isKnownNonNullAt(const Value *V, const Instruction *CtxI,
                             const DominatorTree *DT) {
-  if (isa<ConstantPointerNull>(V) || isa<UndefValue>(V))
+  if (isoneof<ConstantPointerNull, UndefValue>(V))
     return false;
 
   if (isKnownNonNull(V))
     return true;
 
   if (!CtxI || !DT)
     return false;
 

lib/Analysis/VectorUtils.cpp

llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
   MapVector<Instruction *, uint64_t> MinBWs;
 
   // Determine the roots. We work bottom-up, from truncs or icmps.
   bool SeenExtFromIllegalType = false;
   for (auto *BB : Blocks)
     for (auto &I : *BB) {
       InstructionSet.insert(&I);
 
-      if (TTI && (isa<ZExtInst>(&I) || isa<SExtInst>(&I)) &&
+      if (TTI && isoneof<ZExtInst, SExtInst>(&I) &&
           !TTI->isTypeLegal(I.getOperand(0)->getType()))
         SeenExtFromIllegalType = true;
 
       // Only deal with non-vector integers up to 64-bits wide.
-      if ((isa<TruncInst>(&I) || isa<ICmpInst>(&I)) &&
-          !I.getType()->isVectorTy() &&
+      if (isoneof<TruncInst, ICmpInst>(&I) && !I.getType()->isVectorTy() &&
           I.getOperand(0)->getType()->getScalarSizeInBits() <= 64) {
         // Don't make work for ourselves. If we know the loaded type is legal,
         // don't add it to the worklist.
         if (TTI && isa<TruncInst>(&I) && TTI->isTypeLegal(I.getType()))
           continue;
 
         Worklist.push_back(&I);
         Roots.insert(&I);
if (DB.getDemandedBits(I).getBitWidth() > 64)
       return MapVector<Instruction *, uint64_t>();
 
     uint64_t V = DB.getDemandedBits(I).getZExtValue();
     DBits[Leader] |= V;
     DBits[I] = V;
 
     // Casts, loads and instructions outside of our range terminate a chain
     // successfully.
-    if (isa<SExtInst>(I) || isa<ZExtInst>(I) || isa<LoadInst>(I) ||
-        !InstructionSet.count(I))
+    if (isoneof<SExtInst, ZExtInst, LoadInst>(I) || !InstructionSet.count(I))
       continue;
 
     // Unsafe casts terminate a chain unsuccessfully. We can't do anything
     // useful with bitcasts, ptrtoints or inttoptrs and it'd be unsafe to
     // transform anything that relies on them.
-    if (isa<BitCastInst>(I) || isa<PtrToIntInst>(I) || isa<IntToPtrInst>(I) ||
+    if (isoneof<BitCastInst, PtrToIntInst, IntToPtrInst>(I) ||
         !I->getType()->isIntegerTy()) {
       DBits[Leader] |= ~0ULL;
       continue;
     }
 
     // We don't modify the types of PHIs. Reductions will already have been
     // truncated if possible, and inductions' sizes will have been chosen by
     // indvars.

lib/Bitcode/Writer/ValueEnumerator.cpp

if (F.isDeclaration())
       continue;
     for (const BasicBlock &BB : F)
       predictValueUseListOrder(&BB, &F, OM, Stack);
     for (const Argument &A : F.args())
       predictValueUseListOrder(&A, &F, OM, Stack);
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         for (const Value *Op : I.operands())
-          if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
+          if (isoneof<Constant, InlineAsm>(*Op)) // Visit GlobalValues.
             predictValueUseListOrder(Op, &F, OM, Stack);
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         predictValueUseListOrder(&I, &F, OM, Stack);
   }
 
   // Visit globals last, since the module-level use-list block will be seen
   // before the function bodies are processed.
while (!Worklist.empty()) {
     }
   }
 }
 
 const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) {
   if (!MD)
     return nullptr;
 
-  assert(
-      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) &&
+  assert((isoneof<MDNode, MDString, ConstantAsMetadata>(MD)) &&
          "Invalid metadata kind");
 
   auto Insertion = MetadataMap.insert(std::make_pair(MD, MDIndex(F)));
   MDIndex &Entry = Insertion.first->second;
   if (!Insertion.second) {
     // Already mapped.  If F doesn't match the function tag, drop it.
     if (Entry.hasDifferentFunction(F))
       dropFunctionFromMetadata(*Insertion.first);
     return nullptr;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

   uint64_t Size = DL.getTypeAllocSize(CV->getType());
 
   // Globals with sub-elements such as combinations of arrays and structs
   // are handled recursively by emitGlobalConstantImpl. Keep track of the
   // constant symbol base and the current position with BaseCV and Offset.
   if (!BaseCV && CV->hasOneUse())
     BaseCV = dyn_cast<Constant>(CV->user_back());
 
-  if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
+  if (isoneof<ConstantAggregateZero, UndefValue>(CV))
     return AP.OutStreamer->EmitZeros(Size);
 
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
     switch (Size) {
     case 1:
     case 2:
     case 4:
     case 8:

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
       // A runtime language of 0 actually means C/C++ and that any
       // non-negative value is some version of Objective-C/C++.
       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
     }
     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
     DD->addAccelType(Ty->getName(), TyDIE, Flags);
 
-    if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
-        isa<DINamespace>(Context))
+    if (!Context || isoneof<DICompileUnit, DIFile, DINamespace>(Context))
       addGlobalType(Ty, TyDIE, Context);
   }
 }
 
 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
                         dwarf::Attribute Attribute) {
   assert(Ty && "Trying to add a type that doesn't exist?");
   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));

lib/CodeGen/CodeGenPrepare.cpp

   // switch or indirect branch instruction, and BB is used as an incoming block
   // of PHIs in DestBB. In such case, merging BB and DestBB would cause ISel to
   // add COPY instructions in the predecessor of BB instead of BB (if it is not
   // merged). Note that the critical edge created by merging such blocks wont be
   // split in MachineSink because the jump table is not analyzable. By keeping
   // such empty block (BB), ISel will place COPY instructions in BB, not in the
   // predecessor of BB.
   BasicBlock *Pred = BB->getUniquePredecessor();
-  if (!Pred ||
-      !(isa<SwitchInst>(Pred->getTerminator()) ||
-        isa<IndirectBrInst>(Pred->getTerminator())))
+  if (!Pred || !isoneof<SwitchInst, IndirectBrInst>(Pred->getTerminator()))
     return true;
 
   if (BB->getTerminator() != BB->getFirstNonPHI())
     return true;
 
   // We use a simple cost heuristic which determine skipping merging is
   // profitable if the cost of skipping merging is less than the cost of
   // merging : Cost(skipping merging) < Cost(merging BB), where the

   // #2 check that the truncate just drops extended bits.
   return Inst->getType()->getIntegerBitWidth() >=
          OpndType->getIntegerBitWidth();
 }
 
 TypePromotionHelper::Action TypePromotionHelper::getAction(
     Instruction *Ext, const SetOfInstrs &InsertedInsts,
     const TargetLowering &TLI, const InstrToOrigTy &PromotedInsts) {
-  assert((isa<SExtInst>(Ext) || isa<ZExtInst>(Ext)) &&
-         "Unexpected instruction type");
+  assert((isoneof<SExtInst, ZExtInst>(Ext)) && "Unexpected instruction type");
   Instruction *ExtOpnd = dyn_cast<Instruction>(Ext->getOperand(0));
   Type *ExtTy = Ext->getType();
   bool IsSExt = isa<SExtInst>(Ext);
   // If the operand of the extension is not an instruction, we cannot
   // get through.
   // If it, check we can get through.
   if (!ExtOpnd || !canGetThrough(ExtOpnd, ExtTy, PromotedInsts, IsSExt))
     return nullptr;
 
   // Do not promote if the operand has been added by codegenprepare.
   // Otherwise, it means we are undoing an optimization that is likely to be
   // redone, thus causing potential infinite loop.
   if (isa<TruncInst>(ExtOpnd) && InsertedInsts.count(ExtOpnd))
     return nullptr;
 
   // SExt or Trunc instructions.
   // Return the related handler.
-  if (isa<SExtInst>(ExtOpnd) || isa<TruncInst>(ExtOpnd) ||
-      isa<ZExtInst>(ExtOpnd))
+  if (isoneof<SExtInst, TruncInst, ZExtInst>(ExtOpnd))
     return promoteOperandForTruncAndAnyExt;
 
   // Regular instruction.
   // Abort early if we will have to insert non-free instructions.
   if (!ExtOpnd->hasOneUse() && !TLI.isTruncateFree(ExtTy, ExtOpnd->getType()))
     return nullptr;
   return IsSExt ? signExtendOperandForOther : zeroExtendOperandForOther;
 }

 
   // Make sure none of the uses are PHI nodes.
   for (User *U : Src->users()) {
     Instruction *UI = cast<Instruction>(U);
     BasicBlock *UserBB = UI->getParent();
     if (UserBB == DefBB) continue;
     // Be conservative. We don't want this xform to end up introducing
     // reloads just before load / store instructions.
-    if (isa<PHINode>(UI) || isa<LoadInst>(UI) || isa<StoreInst>(UI))
+    if (isoneof<PHINode, LoadInst, StoreInst>(UI))
       return false;
   }
 
   // InsertedTruncs - Only insert one trunc in each block once.
   DenseMap<BasicBlock*, Instruction*> InsertedTruncs;
 
   bool MadeChange = false;
   for (Use &U : Src->uses()) {

         TTI.getVectorInstrCost(Transition->getOpcode(), PromotedType, Index);
     uint64_t VectorCost = StoreExtractCombineCost;
     for (const auto &Inst : InstsToBePromoted) {
       // Compute the cost.
       // By construction, all instructions being promoted are arithmetic ones.
       // Moreover, one argument is a constant that can be viewed as a splat
       // constant.
       Value *Arg0 = Inst->getOperand(0);
-      bool IsArg0Constant = isa<UndefValue>(Arg0) || isa<ConstantInt>(Arg0) ||
-                            isa<ConstantFP>(Arg0);
+      bool IsArg0Constant = isoneof<UndefValue, ConstantInt, ConstantFP>(Arg0);
       TargetTransformInfo::OperandValueKind Arg0OVK =
           IsArg0Constant ? TargetTransformInfo::OK_UniformConstantValue
                          : TargetTransformInfo::OK_AnyValue;
       TargetTransformInfo::OperandValueKind Arg1OVK =
           !IsArg0Constant ? TargetTransformInfo::OK_UniformConstantValue
                           : TargetTransformInfo::OK_AnyValue;
       ScalarCost += TTI.getArithmeticInstrCost(
           Inst->getOpcode(), Inst->getType(), Arg0OVK, Arg1OVK);

   // 3. Update all the operands of the promoted operation with promoted
   // operands.
   // b = ToBePromoted ty1 Def => b = ToBePromoted ty1 a.
   for (Use &U : ToBePromoted->operands()) {
     Value *Val = U.get();
     Value *NewVal = nullptr;
     if (Val == Transition)
       NewVal = Transition->getOperand(getTransitionOriginalValueIdx());
-    else if (isa<UndefValue>(Val) || isa<ConstantInt>(Val) ||
-             isa<ConstantFP>(Val)) {
+    else if (isoneof<UndefValue, ConstantInt, ConstantFP>(Val)) {
       // Use a splat constant if it is not safe to use undef.
       NewVal = getConstantVector(
           cast<Constant>(Val),
           isa<UndefValue>(Val) ||
               canCauseUndefinedBehavior(ToBePromoted, U.getOperandNo()));
     } else
       llvm_unreachable("Did you modified shouldPromote and forgot to update "
                        "this?");

     // the address of globals out of a loop).  If this is the case, we don't
     // want to forward-subst the cast.
     if (isa<Constant>(CI->getOperand(0)))
       return false;
 
     if (TLI && OptimizeNoopCopyExpression(CI, *TLI, *DL))
       return true;
 
-    if (isa<ZExtInst>(I) || isa<SExtInst>(I)) {
+    if (isoneof<ZExtInst, SExtInst>(I)) {
       /// Sink a zext or sext into its user blocks if the target type doesn't
       /// fit in one register
       if (TLI &&
           TLI->getTypeAction(CI->getContext(),
                              TLI->getValueType(*DL, CI->getType())) ==
               TargetLowering::TypeExpandInteger) {
         return SinkCast(CI);
       } else {

lib/CodeGen/GCRootLowering.cpp

static bool CouldBecomeSafePoint(Instruction *I) {
   //   - call, invoke (AfterCall, BeforeCall)
   //   - phis (Loops)
   //   - invoke, ret, unwind (Exit)
   //
   // However, instructions as seemingly inoccuous as arithmetic can become
   // libcalls upon lowering (e.g., div i64 on a 32-bit platform), so instead
   // it is necessary to take a conservative approach.
 
-  if (isa<AllocaInst>(I) || isa<GetElementPtrInst>(I) || isa<StoreInst>(I) ||
-      isa<LoadInst>(I))
+  if (isoneof<AllocaInst, GetElementPtrInst, StoreInst, LoadInst>(I))
     return false;
 
   // llvm.gcroot is safe because it doesn't do anything at runtime.
   if (CallInst *CI = dyn_cast<CallInst>(I))
     if (Function *F = CI->getCalledFunction())
       if (Intrinsic::ID IID = F->getIntrinsicID())
         if (IID == Intrinsic::gcroot)
           return false;

lib/CodeGen/MachineFunction.cpp

static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B,
   // Handle the trivial case quickly.
   if (A == B) return true;
 
   // If they have the same type but weren't the same constant, quickly
   // reject them.
   if (A->getType() == B->getType()) return false;
 
   // We can't handle structs or arrays.
-  if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||
-      isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))
+  if (isoneof<StructType, ArrayType>(A->getType()) ||
+      isoneof<StructType, ArrayType>(B->getType()))
     return false;
 
   // For now, only support constants with the same size.
   uint64_t StoreSize = DL.getTypeStoreSize(A->getType());
   if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)
     return false;
 
   Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

     EVT DestEltVT = N->getValueType(0).getVectorElementType();
     assert(!DestEltVT.isVector() &&
            "Element type of vector ValueType must not be vector!");
     if (isSimple)
       return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(), DestEltVT);
   }
 
   // If the input is a constant, let getNode fold it.
-  if (isa<ConstantSDNode>(N0) || isa<ConstantFPSDNode>(N0)) {
+  if (isoneof<ConstantSDNode, ConstantFPSDNode>(N0)) {
     // If we can't allow illegal operations, we need to check that this is just
     // a fp -> int or int -> conversion and that the resulting operation will
     // be legal.
     if (!LegalOperations ||
         (isa<ConstantSDNode>(N0) && VT.isFloatingPoint() && !VT.isVector() &&
          TLI.isOperationLegal(ISD::ConstantFP, VT)) ||
         (isa<ConstantFPSDNode>(N0) && VT.isInteger() && !VT.isVector() &&
          TLI.isOperationLegal(ISD::Constant, VT)))

   // 2) If N is a store and the new base ptr is either the same as or is a
   //    predecessor of the value being stored.
   // 3) Another use of old base ptr is a predecessor of N. If ptr is folded
   //    that would create a cycle.
   // 4) All uses are load / store ops that use it as old base ptr.
 
   // Check #1.  Preinc'ing a frame index would require copying the stack pointer
   // (plus the implicit offset) to a register to preinc anyway.
-  if (isa<FrameIndexSDNode>(BasePtr) || isa<RegisterSDNode>(BasePtr))
+  if (isoneof<FrameIndexSDNode, RegisterSDNode>(BasePtr))
     return false;
 
   // Check #2.
   if (!isLoad) {
     SDValue Val = cast<StoreSDNode>(N)->getValue();
     if (Val == BasePtr || BasePtr.getNode()->isPredecessorOf(Val.getNode()))
       return false;
   }

 
       // Try turning it into a post-indexed load / store except when
       // 1) All uses are load / store ops that use it as base ptr (and
       //    it may be folded as addressing mmode).
       // 2) Op must be independent of N, i.e. Op is neither a predecessor
       //    nor a successor of N. Otherwise, if Op is folded that would
       //    create a cycle.
 
-      if (isa<FrameIndexSDNode>(BasePtr) || isa<RegisterSDNode>(BasePtr))
+      if (isoneof<FrameIndexSDNode, RegisterSDNode>(BasePtr))
         continue;
 
       // Check for #1.
       bool TryNext = false;
       for (SDNode *Use : BasePtr.getNode()->uses()) {
         if (Use == Ptr.getNode())
           continue;
 

   if (!BasePtr.Base.getNode())
     return;
 
   // Do not handle stores to undef base pointers.
   if (BasePtr.Base.isUndef())
     return;
 
   bool IsLoadSrc = isa<LoadSDNode>(St->getValue());
-  bool IsConstantSrc = isa<ConstantSDNode>(St->getValue()) ||
-                       isa<ConstantFPSDNode>(St->getValue());
+  bool IsConstantSrc =
+      isoneof<ConstantSDNode, ConstantFPSDNode>(St->getValue());
   bool IsExtractVecSrc =
       (St->getValue().getOpcode() == ISD::EXTRACT_VECTOR_ELT ||
        St->getValue().getOpcode() == ISD::EXTRACT_SUBVECTOR);
   auto CandidateMatch = [&](StoreSDNode *Other, BaseIndexOffset &Ptr) -> bool {
     if (Other->isVolatile() || Other->isIndexed())
       return false;
     // We can merge constant floats to equivalent integers
     if (Other->getMemoryVT() != MemVT)
       if (!(MemVT.isInteger() && MemVT.bitsEq(Other->getMemoryVT()) &&
             isa<ConstantFPSDNode>(Other->getValue())))
         return false;
     if (IsLoadSrc)
       if (!isa<LoadSDNode>(Other->getValue()))
         return false;
     if (IsConstantSrc)
-      if (!(isa<ConstantSDNode>(Other->getValue()) ||
-            isa<ConstantFPSDNode>(Other->getValue())))
+      if (!isoneof<ConstantSDNode, ConstantFPSDNode>(Other->getValue()))
         return false;
     if (IsExtractVecSrc)
       if (!(Other->getValue().getOpcode() == ISD::EXTRACT_VECTOR_ELT ||
             Other->getValue().getOpcode() == ISD::EXTRACT_SUBVECTOR))
         return false;
     Ptr = BaseIndexOffset::match(Other->getBasePtr(), DAG);
     return (Ptr.equalBaseIndex(BasePtr));
   };

 
   if (!MemVT.isSimple())
     return false;
 
   // Perform an early exit check. Do not bother looking at stored values that
   // are not constants, loads, or extracted vector elements.
   SDValue StoredVal = St->getValue();
   bool IsLoadSrc = isa<LoadSDNode>(StoredVal);
-  bool IsConstantSrc = isa<ConstantSDNode>(StoredVal) ||
-                       isa<ConstantFPSDNode>(StoredVal);
+  bool IsConstantSrc = isoneof<ConstantSDNode, ConstantFPSDNode>(StoredVal);
   bool IsExtractVecSrc = (StoredVal.getOpcode() == ISD::EXTRACT_VECTOR_ELT ||
                           StoredVal.getOpcode() == ISD::EXTRACT_SUBVECTOR);
 
   if (!IsConstantSrc && !IsLoadSrc && !IsExtractVecSrc)
     return false;
 
   // Don't merge vectors into wider vectors if the source data comes from loads.
   // TODO: This restriction can be lifted by using logic similar to the

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

for (const Instruction &I : BB) {
           if (Align <= StackAlign)
             Align = 0;
           // Inform the Frame Information that we have variable-sized objects.
           MF->getFrameInfo().CreateVariableSizedObject(Align ? Align : 1, AI);
         }
       }
 
       // Look for inline asm that clobbers the SP register.
-      if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
-        ImmutableCallSite CS(&I);
+      if (ImmutableCallSite CS{&I}) {
         if (isa<InlineAsm>(CS.getCalledValue())) {
           unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
           const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
           std::vector<TargetLowering::AsmOperandInfo> Ops =
               TLI->ParseConstraints(Fn->getParent()->getDataLayout(), TRI, CS);
           for (TargetLowering::AsmOperandInfo &Op : Ops) {
             if (Op.Type == InlineAsm::isClobber) {
               // Clobbers don't have SDValue operands, hence SDValue().
void FunctionLoweringInfo::ComputePHILiveOutRegInfo(const PHINode *PN) {
 
   unsigned DestReg = ValueMap[PN];
   if (!TargetRegisterInfo::isVirtualRegister(DestReg))
     return;
   LiveOutRegInfo.grow(DestReg);
   LiveOutInfo &DestLOI = LiveOutRegInfo[DestReg];
 
   Value *V = PN->getIncomingValue(0);
-  if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) {
+  if (isoneof<UndefValue, ConstantExpr>(V)) {
     DestLOI.NumSignBits = 1;
     DestLOI.Known = KnownBits(BitWidth);
     return;
   }
 
   if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
     APInt Val = CI->getValue().zextOrTrunc(BitWidth);
     DestLOI.NumSignBits = Val.getNumSignBits();
void FunctionLoweringInfo::ComputePHILiveOutRegInfo(const PHINode *PN) {
   }
 
   assert(DestLOI.Known.Zero.getBitWidth() == BitWidth &&
          DestLOI.Known.One.getBitWidth() == BitWidth &&
          "Masks should have the same bit width as the type.");
 
   for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) {
     Value *V = PN->getIncomingValue(i);
-    if (isa<UndefValue>(V) || isa<ConstantExpr>(V)) {
+    if (isoneof<UndefValue, ConstantExpr>(V)) {
       DestLOI.NumSignBits = 1;
       DestLOI.Known = KnownBits(BitWidth);
       return;
     }
 
     if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       APInt Val = CI->getValue().zextOrTrunc(BitWidth);
       DestLOI.NumSignBits = std::min(DestLOI.NumSignBits, Val.getNumSignBits());

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 }
 
 /// getNonRegisterValue - Return an SDValue for the given Value, but
 /// don't look in FuncInfo.ValueMap for a virtual register.
 SDValue SelectionDAGBuilder::getNonRegisterValue(const Value *V) {
   // If we already have an SDValue for this value, use it.
   SDValue &N = NodeMap[V];
   if (N.getNode()) {
-    if (isa<ConstantSDNode>(N) || isa<ConstantFPSDNode>(N)) {
+    if (isoneof<ConstantSDNode, ConstantFPSDNode>(N)) {
       // Remove the debug location from the node as the node is about to be used
       // in a location which may differ from the original debug location.  This
       // is relevant to Constant and ConstantFP nodes because they can appear
       // as constant expressions inside PHI nodes.
       N->setDebugLoc(DebugLoc());
     }
     return N;
   }

 
     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
       visit(CE->getOpcode(), *CE);
       SDValue N1 = NodeMap[V];
       assert(N1.getNode() && "visit didn't populate the NodeMap!");
       return N1;
     }
 
-    if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
+    if (isoneof<ConstantStruct, ConstantArray>(C)) {
       SmallVector<SDValue, 4> Constants;
       for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
            OI != OE; ++OI) {
         SDNode *Val = getValue(*OI).getNode();
         // If the operand is an empty aggregate, there are no values.
         if (!Val) continue;
         // Add each leaf value from the operand to the Constants list
         // to form a flattened list of all the values.

       }
 
       if (isa<ArrayType>(CDS->getType()))
         return DAG.getMergeValues(Ops, getCurSDLoc());
       return NodeMap[V] = DAG.getBuildVector(VT, getCurSDLoc(), Ops);
     }
 
     if (C->getType()->isStructTy() || C->getType()->isArrayTy()) {
-      assert((isa<ConstantAggregateZero>(C) || isa<UndefValue>(C)) &&
+      assert((isoneof<ConstantAggregateZero, UndefValue>(C)) &&
              "Unknown struct or array constant!");
 
       SmallVector<EVT, 4> ValueVTs;
       ComputeValueVTs(TLI, DAG.getDataLayout(), C->getType(), ValueVTs);
       unsigned NumElts = ValueVTs.size();
       if (NumElts == 0)
         return SDValue(); // empty struct
       SmallVector<SDValue, 4> Constants(NumElts);

       if (BOpc == Instruction::And)
         BOpc = Instruction::Or;
       else if (BOpc == Instruction::Or)
         BOpc = Instruction::And;
     }
   }
 
   // If this node is not part of the or/and tree, emit it as a branch.
-  if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) ||
-      BOpc != Opc || !BOp->hasOneUse() ||
-      BOp->getParent() != CurBB->getBasicBlock() ||
+  if (!BOp || !isoneof<BinaryOperator, CmpInst>(BOp) || BOpc != Opc ||
+      !BOp->hasOneUse() || BOp->getParent() != CurBB->getBasicBlock() ||
       !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) ||
       !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) {
     EmitBranchForMergedCondition(Cond, TBB, FBB, CurBB, SwitchBB,
                                  TProb, FProb, InvertCond);
     return;
   }
 
   //  Create TmpBB after CurBB.

     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     uint64_t Offset = DI.getOffset();
     const Value *V = DI.getValue();
     if (!V)
       return nullptr;
 
     SDDbgValue *SDV;
-    if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V)) {
+    if (isoneof<ConstantInt, ConstantFP, UndefValue>(V)) {
       SDV = DAG.getConstantDbgValue(Variable, Expression, V, Offset, dl,
                                     SDNodeOrder);
       DAG.AddDbgValue(SDV, nullptr, false);
       return nullptr;
     }
 
     // Do not use getValue() in here; we don't want to generate code at
     // this point if it hasn't been done yet.

   // TODO: This isn't quite right. We need to handle these according to
   // the addressing mode that the constraint wants. Also, this may take
   // an additional register for the computation and we don't want that
   // either.
 
   // If the operand is a float, integer, or vector constant, spill to a
   // constant pool entry to get its address.
   const Value *OpVal = OpInfo.CallOperandVal;
-  if (isa<ConstantFP>(OpVal) || isa<ConstantInt>(OpVal) ||
-      isa<ConstantVector>(OpVal) || isa<ConstantDataVector>(OpVal)) {
+  if (isoneof<ConstantFP, ConstantInt, ConstantVector, ConstantDataVector>(
+          OpVal)) {
     OpInfo.CallOperand = DAG.getConstantPool(
         cast<Constant>(OpVal), TLI.getPointerTy(DAG.getDataLayout()));
     return Chain;
   }
 
   // Otherwise, create a stack slot and emit a store to it before the asm.
   Type *Ty = OpVal->getType();
   auto &DL = DAG.getDataLayout();

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

if (OptLevel != CodeGenOpt::None && TLI->supportSplitCSR(MF)) {
     FuncInfo->SplitCSR = true;
 
     // Collect all the return blocks.
     for (const BasicBlock &BB : Fn) {
       if (!succ_empty(&BB))
         continue;
 
       const TerminatorInst *Term = BB.getTerminator();
-      if (isa<UnreachableInst>(Term) || isa<ReturnInst>(Term))
+      if (isoneof<UnreachableInst, ReturnInst>(Term))
         continue;
 
       // Bail out if the exit block is not Return nor Unreachable.
       FuncInfo->SplitCSR = false;
       break;
     }
   }
 

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

 /// mark that slot as allocated, and reuse the same slot for this safepoint.
 /// This helps to avoid series of loads and stores that only serve to reshuffle
 /// values on the stack between calls.
 static void reservePreviousStackSlotForValue(const Value *IncomingValue,
                                              SelectionDAGBuilder &Builder) {
 
   SDValue Incoming = Builder.getValue(IncomingValue);
 
-  if (isa<ConstantSDNode>(Incoming) || isa<FrameIndexSDNode>(Incoming)) {
+  if (isoneof<ConstantSDNode, FrameIndexSDNode>(Incoming)) {
     // We won't need to spill this, so no need to check for previously
     // allocated stack slots
     return;
   }
 
   SDValue OldLocation = Builder.StatepointLowering.getLocation(Incoming);
   if (OldLocation.getNode())
     // Duplicates in input

lib/CodeGen/SelectionDAG/TargetLowering.cpp

   }
 
   // 'X' matches anything.
   if (OpInfo.ConstraintCode == "X" && OpInfo.CallOperandVal) {
     // Labels and constants are handled elsewhere ('X' is the only thing
     // that matches labels).  For Functions, the type here is the type of
     // the result, which is not what we want to look at; leave them alone.
     Value *v = OpInfo.CallOperandVal;
-    if (isa<BasicBlock>(v) || isa<ConstantInt>(v) || isa<Function>(v)) {
+    if (isoneof<BasicBlock, ConstantInt, Function>(v)) {
       OpInfo.CallOperandVal = v;
       return;
     }
 
     // Otherwise, try to resolve it to something we know about by looking at
     // the actual operand type.
     if (const char *Repl = LowerXConstraint(OpInfo.ConstraintVT)) {
       OpInfo.ConstraintCode = Repl;

lib/IR/AsmWriter.cpp

if (F.isDeclaration())
       continue;
     for (const BasicBlock &BB : F)
       predictValueUseListOrder(&BB, &F, OM, Stack);
     for (const Argument &A : F.args())
       predictValueUseListOrder(&A, &F, OM, Stack);
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         for (const Value *Op : I.operands())
-          if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
+          if (isoneof<Constant, InlineAsm>(*Op)) // Visit GlobalValues.
             predictValueUseListOrder(Op, &F, OM, Stack);
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         predictValueUseListOrder(&I, &F, OM, Stack);
   }
 
   // Visit globals last.
   for (const GlobalVariable &G : M->globals())
if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
     }
 
     Out << '}';
     if (CS->getType()->isPacked())
       Out << '>';
     return;
   }
 
-  if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
+  if (isoneof<ConstantVector, ConstantDataVector>(CV)) {
     Type *ETy = CV->getType()->getVectorElementType();
     Out << '<';
     TypePrinter.print(ETy, Out);
     Out << ' ';
     WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
                            Machine, Context);
     for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
       Out << ", ";
if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
 
     // PrintAllTypes - Instructions who have operands of all the same type
     // omit the type from all but the first operand.  If the instruction has
     // different type operands (for example br), then they are all printed.
     bool PrintAllTypes = false;
     Type *TheType = Operand->getType();
 
     // Select, Store and ShuffleVector always print all types.
-    if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
-        || isa<ReturnInst>(I)) {
+    if (isoneof<SelectInst, StoreInst, ShuffleVectorInst, ReturnInst>(I)) {
       PrintAllTypes = true;
     } else {
       for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
         Operand = I.getOperand(i);
         // note that Operand shouldn't be null, but the test helps make dump()
         // more tolerant of malformed IR
         if (Operand && Operand->getType() != TheType) {
           PrintAllTypes = true;    // We have differing types!  Print them all!
else
       W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
   } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
     V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
   } else if (const Constant *C = dyn_cast<Constant>(this)) {
     TypePrinting TypePrinter;
     TypePrinter.print(C->getType(), OS);
     OS << ' ';
     WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
-  } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
+  } else if (isoneof<InlineAsm, Argument>(this)) {
     this->printAsOperand(OS, /* PrintType */ true, MST);
   } else {
     llvm_unreachable("Unknown value to print out!");
   }
 }
 
 /// Print without a type, skipping the TypePrinting object.
 ///

lib/IR/BasicBlock.cpp

const Instruction* BasicBlock::getFirstNonPHIOrDbg() const {
   for (const Instruction &I : *this)
     if (!isa<PHINode>(I) && !isa<DbgInfoIntrinsic>(I))
       return &I;
   return nullptr;
 }
 
 const Instruction* BasicBlock::getFirstNonPHIOrDbgOrLifetime() const {
   for (const Instruction &I : *this) {
-    if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I))
+    if (isoneof<PHINode, DbgInfoIntrinsic>(I))
       continue;
 
     if (auto *II = dyn_cast<IntrinsicInst>(&I))
       if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
           II->getIntrinsicID() == Intrinsic::lifetime_end)
         continue;
 
     return &I;

lib/IR/ConstantFold.cpp

if (VectorType *SrcTy = dyn_cast<VectorType>(V->getType())) {
 
       // Handle ConstantVector and ConstantAggregateVector.
       return BitCastConstantVector(V, DestPTy);
     }
 
     // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts
     // This allows for other simplifications (although some of them
     // can only be handled by Analysis/ConstantFolding.cpp).
-    if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
+    if (isoneof<ConstantInt, ConstantFP>(V))
       return ConstantExpr::getBitCast(ConstantVector::get(V), DestPTy);
   }
 
   // Finally, implement bitcast folding now.   The code below doesn't handle
   // bitcast right.
   if (isa<ConstantPointerNull>(V))  // ptr->ptr cast.
     return ConstantPointerNull::get(cast<PointerType>(DestTy));
 
if (CE->isCast()) {
         // This is casting one pointer type to another, always BitCast
         return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy);
     }
   }
 
   // If the cast operand is a constant vector, perform the cast by
   // operating on each element. In the cast of bitcasts, the element
   // count may be mismatched; don't attempt to handle that here.
-  if ((isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) &&
+  if ((isoneof<ConstantVector, ConstantDataVector>(V)) &&
       DestTy->isVectorTy() &&
       DestTy->getVectorNumElements() == V->getType()->getVectorNumElements()) {
     SmallVector<Constant*, 16> res;
     VectorType *DestVecTy = cast<VectorType>(DestTy);
     Type *DstEltTy = DestVecTy->getElementType();
     Type *Ty = IntegerType::get(V->getContext(), 32);
     for (unsigned i = 0, e = V->getType()->getVectorNumElements(); i != e; ++i) {
       Constant *C =
if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
     if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
       // Block address in another function can't equal this one, but block
       // addresses in the current function might be the same if blocks are
       // empty.
       if (BA2->getFunction() != BA->getFunction())
         return ICmpInst::ICMP_NE;
     } else {
       // Block addresses aren't null, don't equal the address of globals.
-      assert((isa<ConstantPointerNull>(V2) || isa<GlobalValue>(V2)) &&
+      assert((isoneof<ConstantPointerNull, GlobalValue>(V2)) &&
              "Canonicalization guarantee!");
       return ICmpInst::ICMP_NE;
     }
   } else {
     // Ok, the LHS is known to be a constantexpr.  The RHS can be any of a
     // constantexpr, a global, block address, or a simple constant.
     ConstantExpr *CE1 = cast<ConstantExpr>(V1);
     Constant *CE1Op0 = CE1->getOperand(0);

lib/IR/Constants.cpp

if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     return CI->isZero();
 
   // +0.0 is null.
   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     return CFP->isZero() && !CFP->isNegative();
 
   // constant zero is zero for aggregates, cpnull is null for pointers, none for
   // tokens.
-  return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this) ||
-         isa<ConstantTokenNone>(this);
+  return isoneof<ConstantAggregateZero, ConstantPointerNull, ConstantTokenNone>(
+      this);
 }
 
 bool Constant::isAllOnesValue() const {
   // Check for -1 integers
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
     return CI->isMinusOne();
 
   // Check for FP which are bitcasted from -1 integers
Constant *ConstantVector::getImpl(ArrayRef<Constant*> V) {
   // Otherwise, the element type isn't compatible with ConstantDataVector, or
   // the operand list contains a ConstantExpr or something else strange.
   return nullptr;
 }
 
 Constant *ConstantVector::getSplat(unsigned NumElts, Constant *V) {
   // If this splat is compatible with ConstantDataVector, use it instead of
   // ConstantVector.
-  if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
+  if (isoneof<ConstantFP, ConstantInt>(V) &&
       ConstantDataSequential::isElementTypeCompatible(V->getType()))
     return ConstantDataVector::getSplat(NumElts, V);
 
   SmallVector<Constant*, 32> Elts(NumElts, V);
   return get(Elts);
 }
 
 ConstantTokenNone *ConstantTokenNone::get(LLVMContext &Context) {

lib/IR/Core.cpp

LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
   return nullptr;
 }
 
 // MetadataAsValue uses a canonical format which strips the actual MDNode for
 // MDNode with just a single constant value, storing just a ConstantAsMetadata
 // This undoes this canonicalization, reconstructing the MDNode.
 static MDNode *extractMDNode(MetadataAsValue *MAV) {
   Metadata *MD = MAV->getMetadata();
-  assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
+  assert((isoneof<MDNode, ConstantAsMetadata>(MD)) &&
          "Expected a metadata node or a canonicalized constant");
 
   if (MDNode *N = dyn_cast<MDNode>(MD))
     return N;
 
   return MDNode::get(MAV->getContext(), MD);
 }
 
 void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
   MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
 
   unwrap<Instruction>(Inst)->setMetadata(KindID, N);
 }
 
 /*--.. Conversion functions ................................................--*/
 
 #define LLVM_DEFINE_VALUE_CAST(name)                                       \
   LLVMValueRef LLVMIsA##name(LLVMValueRef Val) {                           \
     return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
   }
 
 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST)
 
 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) {
   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
-    if (isa<MDNode>(MD->getMetadata()) ||
-        isa<ValueAsMetadata>(MD->getMetadata()))
+    if (isoneof<MDNode, ValueAsMetadata>(MD->getMetadata()))
       return Val;
   return nullptr;
 }
 
 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) {
   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
     if (isa<MDString>(MD->getMetadata()))
       return Val;

lib/IR/DebugInfoMetadata.cpp

if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
     return LB->getScope();
 
   if (auto *NS = dyn_cast<DINamespace>(this))
     return NS->getScope();
 
   if (auto *M = dyn_cast<DIModule>(this))
     return M->getScope();
 
-  assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&
-         "Unhandled type of scope.");
+  assert((isoneof<DIFile, DICompileUnit>(this)) && "Unhandled type of scope.");
   return nullptr;
 }
 
 StringRef DIScope::getName() const {
   if (auto *T = dyn_cast<DIType>(this))
     return T->getName();
   if (auto *SP = dyn_cast<DISubprogram>(this))
     return SP->getName();
   if (auto *NS = dyn_cast<DINamespace>(this))
     return NS->getName();
   if (auto *M = dyn_cast<DIModule>(this))
     return M->getName();
-  assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||
-          isa<DICompileUnit>(this)) &&
+  assert((isoneof<DILexicalBlockBase, DIFile, DICompileUnit>(this)) &&
          "Unhandled type of scope.");
   return "";
 }
 
 #ifndef NDEBUG
 static bool isCanonical(const MDString *S) {
   return !S || !S->getString().empty();
 }

lib/IR/DiagnosticInfo.cpp

if (auto *F = dyn_cast<Function>(V)) {
     if (DISubprogram *SP = F->getSubprogram())
       Loc = SP;
   }
   else if (auto *I = dyn_cast<Instruction>(V))
     Loc = I->getDebugLoc();
 
   // Only include names that correspond to user variables.  FIXME: we should use
   // debug info if available to get the name of the user variable.
-  if (isa<llvm::Argument>(V) || isa<GlobalValue>(V))
+  if (isoneof<llvm::Argument, GlobalValue>(V))
     Val = GlobalValue::getRealLinkageName(V->getName());
   else if (isa<Constant>(V)) {
     raw_string_ostream OS(Val);
     V->printAsOperand(OS, /*PrintType=*/false);
   } else if (auto *I = dyn_cast<Instruction>(V))
     Val = I->getOpcodeName();
 }
 

lib/IR/Instruction.cpp

for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
       Vals.push_back(MDB.createConstant(
           ConstantInt::get(Type::getInt64Ty(getContext()),
                            Val.udiv(APT).getLimitedValue())));
     }
   setMetadata(LLVMContext::MD_prof, MDNode::get(getContext(), Vals));
 }
 
 void Instruction::setProfWeight(uint64_t W) {
-  assert((isa<CallInst>(this) || isa<InvokeInst>(this)) &&
+  assert((isoneof<CallInst, InvokeInst>(this)) &&
          "Can only set weights for call and invoke instrucitons");
   SmallVector<uint32_t, 1> Weights;
   Weights.push_back(W);
   MDBuilder MDB(getContext());
   setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
 }

lib/IR/Instructions.cpp

     return false;
   
   // Mask must be vector of i32.
   auto *MaskTy = dyn_cast<VectorType>(Mask->getType());
   if (!MaskTy || !MaskTy->getElementType()->isIntegerTy(32))
     return false;
 
   // Check to see if Mask is valid.
-  if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask))
+  if (isoneof<UndefValue, ConstantAggregateZero>(Mask))
     return true;
 
   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {
     unsigned V1Size = cast<VectorType>(V1->getType())->getNumElements();
     for (Value *Op : MV->operands()) {
       if (auto *CI = dyn_cast<ConstantInt>(Op)) {
         if (CI->uge(V1Size*2))
           return false;

lib/IR/Metadata.cpp

 }
 
 ValueAsMetadata *ValueAsMetadata::get(Value *V) {
   assert(V && "Unexpected null Value");
 
   auto &Context = V->getContext();
   auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
   if (!Entry) {
-    assert((isa<Constant>(V) || isa<Argument>(V) || isa<Instruction>(V)) &&
+    assert((isoneof<Constant, Argument, Instruction>(V)) &&
            "Expected constant or function-local value");
     assert(!V->IsUsedByMD && "Expected this to be the only metadata use");
     V->IsUsedByMD = true;
     if (auto *C = dyn_cast<Constant>(V))
       Entry = new ConstantAsMetadata(C);
     else
       Entry = new LocalAsMetadata(V);
   }

lib/IR/Verifier.cpp

if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
       Assert(PTy, "wrong type for intrinsic global variable", &GV);
       if (GV.hasInitializer()) {
         const Constant *Init = GV.getInitializer();
         const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
         Assert(InitArray, "wrong initalizer for intrinsic global variable",
                Init);
         for (Value *Op : InitArray->operands()) {
           Value *V = Op->stripPointerCastsNoFollowAliases();
-          Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
-                     isa<GlobalAlias>(V),
+          Assert((isoneof<GlobalVariable, Function, GlobalAlias>(V)),
                  "invalid llvm.used member", V);
           Assert(V->hasName(), "members of llvm.used must be named", V);
         }
       }
     }
   }
 
   Assert(!GV.hasDLLImportStorageClass() ||
Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),
          "Alias should have private, internal, linkonce, weak, linkonce_odr, "
          "weak_odr, or external linkage!",
          &GA);
   const Constant *Aliasee = GA.getAliasee();
   Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
   Assert(GA.getType() == Aliasee->getType(),
          "Alias and aliasee types should match!", &GA);
 
-  Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
+  Assert((isoneof<GlobalValue, ConstantExpr>(Aliasee)),
          "Aliasee should be either GlobalValue or ConstantExpr", &GA);
 
   visitAliaseeSubExpr(GA, *Aliasee);
 
   visitGlobalValue(GA);
 }
 
 void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
void Verifier::verifyStatepoint(ImmutableCallSite CS) {
 
   // Check that the only uses of this gc.statepoint are gc.result or
   // gc.relocate calls which are tied to this statepoint and thus part
   // of the same statepoint sequence
   for (const User *U : CI.users()) {
     const CallInst *Call = dyn_cast<const CallInst>(U);
     Assert(Call, "illegal use of statepoint token", &CI, U);
     if (!Call) continue;
-    Assert(isa<GCRelocateInst>(Call) || isa<GCResultInst>(Call),
+    Assert((isoneof<GCRelocateInst, GCResultInst>(Call)),
            "gc.result or gc.relocate are the only value uses "
            "of a gc.statepoint",
            &CI, U);
     if (isa<GCResultInst>(Call)) {
       Assert(Call->getArgOperand(0) == &CI,
              "gc.result connected to wrong gc.statepoint", &CI, Call);
     } else if (isa<GCRelocateInst>(Call)) {
       Assert(Call->getArgOperand(0) == &CI,
for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
     }
   }
 }
 
 void Verifier::verifySwiftErrorValue(const Value *SwiftErrorVal) {
   // Check that swifterror value is only used by loads, stores, or as
   // a swifterror argument.
   for (const User *U : SwiftErrorVal->users()) {
-    Assert(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
-           isa<InvokeInst>(U),
+    Assert((isoneof<LoadInst, StoreInst, CallInst, InvokeInst>(U)),
            "swifterror value can only be loaded and stored from, or "
            "as a swifterror argument!",
            SwiftErrorVal, U);
     // If it is used by a store, check it is the second operand.
     if (auto StoreI = dyn_cast<StoreInst>(U))
       Assert(StoreI->getOperand(1) == SwiftErrorVal,
              "swifterror value should be the second operand when used "
              "by stores", SwiftErrorVal, U);
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
 
   for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
     Constant *Clause = LPI.getClause(i);
     if (LPI.isCatch(i)) {
       Assert(isa<PointerType>(Clause->getType()),
              "Catch operand does not have pointer type!", &LPI);
     } else {
       Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
-      Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
+      Assert((isoneof<ConstantArray, ConstantAggregateZero>(Clause)),
              "Filter operand is not an array of constants!", &LPI);
     }
   }
 
   visitInstruction(LPI);
 }
 
 void Verifier::visitResumeInst(ResumeInst &RI) {
void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
 
   // The cleanuppad instruction must be the first non-PHI instruction in the
   // block.
   Assert(BB->getFirstNonPHI() == &CPI,
          "CleanupPadInst not the first non-PHI instruction in the block.",
          &CPI);
 
   auto *ParentPad = CPI.getParentPad();
-  Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Assert((isoneof<ConstantTokenNone, FuncletPadInst>(ParentPad)),
          "CleanupPadInst has an invalid parent.", &CPI);
 
   visitEHPadPredecessors(CPI);
   visitFuncletPadInst(CPI);
 }
 
 void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
   User *FirstUser = nullptr;
void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
 
   // The catchswitch instruction must be the first non-PHI instruction in the
   // block.
   Assert(BB->getFirstNonPHI() == &CatchSwitch,
          "CatchSwitchInst not the first non-PHI instruction in the block.",
          &CatchSwitch);
 
   auto *ParentPad = CatchSwitch.getParentPad();
-  Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Assert((isoneof<ConstantTokenNone, FuncletPadInst>(ParentPad)),
          "CatchSwitchInst has an invalid parent.", ParentPad);
 
   if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
     Assert(I->isEHPad() && !isa<LandingPadInst>(I),
            "CatchSwitchInst must unwind to an EH block which is not a "
            "landingpad.",
            &CatchSwitch);
void Verifier::visitInstruction(Instruction &I) {
 
   // Check that the return value of the instruction is either void or a legal
   // value type.
   Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
          "Instruction returns a non-scalar type!", &I);
 
   // Check that the instruction doesn't produce metadata. Calls are already
   // checked against the callee type.
-  Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
+  Assert((!I.getType()->isMetadataTy() || isoneof<CallInst, InvokeInst>(I)),
          "Invalid use of metadata!", &I);
 
   // Check that all uses of the instruction, if they are instructions
   // themselves, actually have parent basic blocks.  If the use is not an
   // instruction, it is an error!
   for (Use &U : I.uses()) {
     if (Instruction *Used = dyn_cast<Instruction>(U.getUser()))
       Assert(Used->getParent() != nullptr,
if (ConstantFP *CFP0 =
       Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
              "fpmath accuracy not a positive number!", &I);
     } else {
       Assert(false, "invalid fpmath accuracy!", &I);
     }
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
-    Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
+    Assert((isoneof<LoadInst, CallInst, InvokeInst>(I)),
            "Ranges are only for loads, calls and invokes!", &I);
     visitRangeMetadata(I, Range, I.getType());
   }
 
   if (I.getMetadata(LLVMContext::MD_nonnull)) {
     Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
            &I);
     Assert(isa<LoadInst>(I),
case Intrinsic::coro_id: {
     auto *InfoArg = CS.getArgOperand(3)->stripPointerCasts();
     if (isa<ConstantPointerNull>(InfoArg))
       break;
     auto *GV = dyn_cast<GlobalVariable>(InfoArg);
     Assert(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
       "info argument of llvm.coro.begin must refer to an initialized "
       "constant");
     Constant *Init = GV->getInitializer();
-    Assert(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
+    Assert((isoneof<ConstantStruct, ConstantArray>(Init)),
            "info argument of llvm.coro.begin must refer to either a struct or "
            "an array");
     break;
   }
   case Intrinsic::ctlz:  // llvm.ctlz
   case Intrinsic::cttz:  // llvm.cttz
     Assert(isa<ConstantInt>(CS.getArgOperand(1)),
            "is_zero_undef argument of bit counting intrinsics must be a "
            "constant int",
            CS);
MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(Instruction &I,
   auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
       BaseNode->getOperand(BaseNode->getNumOperands() - 1));
 
   Offset -= LastOffsetEntryCI->getValue();
   return cast<MDNode>(BaseNode->getOperand(BaseNode->getNumOperands() - 2));
 }
 
 bool TBAAVerifier::visitTBAAMetadata(Instruction &I, const MDNode *MD) {
-  AssertTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
-                 isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
-                 isa<AtomicCmpXchgInst>(I),
+  AssertTBAA((isoneof<LoadInst, StoreInst, CallInst, VAArgInst, AtomicRMWInst,
+                      AtomicCmpXchgInst>(I)),
              "TBAA is only for loads, stores and calls!", &I);
 
   bool IsStructPathTBAA =
       isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
 
   AssertTBAA(
       IsStructPathTBAA,
       "Old-style TBAA is no longer allowed, use struct-path TBAA instead", &I);

lib/MC/MCExpr.cpp

case MCExpr::Unary: {
     UE.getSubExpr()->print(OS, MAI);
     return;
   }
 
   case MCExpr::Binary: {
     const MCBinaryExpr &BE = cast<MCBinaryExpr>(*this);
 
     // Only print parens around the LHS if it is non-trivial.
-    if (isa<MCConstantExpr>(BE.getLHS()) || isa<MCSymbolRefExpr>(BE.getLHS())) {
+    if (isoneof<MCConstantExpr, MCSymbolRefExpr>(BE.getLHS())) {
       BE.getLHS()->print(OS, MAI);
     } else {
       OS << '(';
       BE.getLHS()->print(OS, MAI);
       OS << ')';
     }
 
     switch (BE.getOpcode()) {
case MCExpr::Binary: {
     case MCBinaryExpr::NE:   OS << "!="; break;
     case MCBinaryExpr::Or:   OS <<  '|'; break;
     case MCBinaryExpr::Shl:  OS << "<<"; break;
     case MCBinaryExpr::Sub:  OS <<  '-'; break;
     case MCBinaryExpr::Xor:  OS <<  '^'; break;
     }
 
     // Only print parens around the LHS if it is non-trivial.
-    if (isa<MCConstantExpr>(BE.getRHS()) || isa<MCSymbolRefExpr>(BE.getRHS())) {
+    if (isoneof<MCConstantExpr, MCSymbolRefExpr>(BE.getRHS())) {
       BE.getRHS()->print(OS, MAI);
     } else {
       OS << '(';
       BE.getRHS()->print(OS, MAI);
       OS << ')';
     }
     return;
   }

lib/Target/AArch64/AArch64FastISel.cpp

 };
 
 } // end anonymous namespace
 
 #include "AArch64GenCallingConv.inc"
 
 /// \brief Check if the sign-/zero-extend will be a noop.
 static bool isIntExtFree(const Instruction *I) {
-  assert((isa<ZExtInst>(I) || isa<SExtInst>(I)) &&
+  assert((isoneof<ZExtInst, SExtInst>(I)) &&
          "Unexpected integer extend instruction.");
   assert(!I->getType()->isVectorTy() && I->getType()->isIntegerTy() &&
          "Unexpected value type.");
   bool IsZExt = isa<ZExtInst>(I);
 
   if (const auto *LI = dyn_cast<LoadInst>(I->getOperand(0)))
     if (LI->hasOneUse())
       return true;

     Reg = MI->getOperand(1).getReg();
     MI->eraseFromParent();
   }
   updateValueMap(I, Reg);
   return true;
 }
 
 bool AArch64FastISel::selectIntExt(const Instruction *I) {
-  assert((isa<ZExtInst>(I) || isa<SExtInst>(I)) &&
+  assert((isoneof<ZExtInst, SExtInst>(I)) &&
          "Unexpected integer extend instruction.");
   MVT RetVT;
   MVT SrcVT;
   if (!isTypeSupported(I->getType(), RetVT))
     return false;
 
   if (!isTypeSupported(I->getOperand(0)->getType(), SrcVT))
     return false;

lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

bool AArch64DAGToDAGISel::SelectAddrModeWRO(SDValue N, unsigned Size,
   if (N.getOpcode() != ISD::ADD)
     return false;
   SDValue LHS = N.getOperand(0);
   SDValue RHS = N.getOperand(1);
   SDLoc dl(N);
 
   // We don't want to match immediate adds here, because they are better lowered
   // to the register-immediate addressing modes.
-  if (isa<ConstantSDNode>(LHS) || isa<ConstantSDNode>(RHS))
+  if (isoneof<ConstantSDNode, ConstantSDNode>(RHS))
     return false;
 
   // Check if this particular node is reused in any non-memory related
   // operation.  If yes, do not try to fold this node into the address
   // computation, since the computation will be kept.
   const SDNode *Node = N.getNode();
   for (SDNode *UI : Node->uses()) {
     if (!isa<MemSDNode>(*UI))

lib/Target/AArch64/AArch64ISelLowering.cpp

   SDValue Value;
   SDValue ConstantValue;
   for (unsigned i = 0; i < NumElts; ++i) {
     SDValue V = Op.getOperand(i);
     if (V.isUndef())
       continue;
     if (i > 0)
       isOnlyLowElement = false;
-    if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V))
+    if (!isoneof<ConstantFPSDNode, ConstantSDNode>(V))
       isConstant = false;
 
-    if (isa<ConstantSDNode>(V) || isa<ConstantFPSDNode>(V)) {
+    if (isoneof<ConstantSDNode, ConstantFPSDNode>(V)) {
       ++NumConstantLanes;
       if (!ConstantValue.getNode())
         ConstantValue = V;
       else if (ConstantValue != V)
         usesOnlyOneConstantValue = false;
     }
 
     if (!Value.getNode())

lib/Target/AArch64/AArch64PromoteConstant.cpp

bool AArch64PromoteConstant::runOnFunction(Function &F,
   for (Instruction &I : instructions(&F)) {
     // Traverse the operand, looking for constant vectors. Replace them by a
     // load of a global variable of constant vector type.
     for (Use &U : I.operands()) {
       Constant *Cst = dyn_cast<Constant>(U);
       // There is no point in promoting global values as they are already
       // global. Do not promote constant expressions either, as they may
       // require some code expansion.
-      if (!Cst || isa<GlobalValue>(Cst) || isa<ConstantExpr>(Cst))
+      if (!Cst || isoneof<GlobalValue, ConstantExpr>(Cst))
         continue;
 
       // Check if this constant is worth promoting.
       if (!shouldConvert(*Cst, PromotionCache))
         continue;
 
       // Check if this use should be promoted.
       unsigned OpNo = &U - I.op_begin();

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

bool AArch64TTIImpl::isWideningInstruction(Type *DstTy, unsigned Opcode,
   default:
     return false;
   }
 
   // To be a widening instruction (either the "wide" or "long" versions), the
   // second operand must be a sign- or zero extend having a single user. We
   // only consider extends having a single user because they may otherwise not
   // be eliminated.
-  if (Args.size() != 2 ||
-      (!isa<SExtInst>(Args[1]) && !isa<ZExtInst>(Args[1])) ||
+  if (Args.size() != 2 || !isoneof<SExtInst, ZExtInst>(Args[1]) ||
       !Args[1]->hasOneUse())
     return false;
   auto *Extend = cast<CastInst>(Args[1]);
 
   // Legalize the destination type and ensure it can be used in a widening
   // operation.
   auto DstTyL = TLI->getTypeLegalizationCost(DL, DstTy);
   unsigned DstElTySize = DstTyL.second.getScalarSizeInBits();

lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp

void AMDGPUAnnotateUniformValues::visitLoadInst(LoadInst &I) {
   };
   // We're tracking up to the Function boundaries
   // We cannot go beyond because of FunctionPass restrictions
   // Thus we can ensure that memory not clobbered for memory
   // operations that live in kernel only.
   bool NotClobbered = isKernelFunc &&   !isClobberedInFunction(&I);
   Instruction *PtrI = dyn_cast<Instruction>(Ptr);
   if (!PtrI && NotClobbered && isGlobalLoad(I)) {
-    if (isa<Argument>(Ptr) || isa<GlobalValue>(Ptr)) {
+    if (isoneof<Argument, GlobalValue>(Ptr)) {
       // Lookup for the existing GEP
       if (noClobberClones.count(Ptr)) {
         PtrI = noClobberClones[Ptr];
       } else {
         // Create GEP of the Value
         Function *F = I.getParent()->getParent();
         Value *Idx = Constant::getIntegerValue(
           Type::getInt32Ty(Ptr->getContext()), APInt(64, 0));

lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp

static bool isInstrUniform(const MachineInstr &MI) {
 
   const MachineMemOperand *MMO = *MI.memoperands_begin();
   const Value *Ptr = MMO->getValue();
 
   // UndefValue means this is a load of a kernel input.  These are uniform.
   // Sometimes LDS instructions have constant pointers.
   // If Ptr is null, then that means this mem operand contains a
   // PseudoSourceValue like GOT.
-  if (!Ptr || isa<UndefValue>(Ptr) || isa<Argument>(Ptr) ||
-      isa<Constant>(Ptr) || isa<GlobalValue>(Ptr))
+  if (!Ptr || isoneof<UndefValue, Argument, Constant, GlobalValue>(Ptr))
     return true;
 
   const Instruction *I = dyn_cast<Instruction>(Ptr);
   return I && I->getMetadata("amdgpu.uniform");
 }
 
 static unsigned getSmrdOpcode(unsigned BaseOpcode, unsigned LoadSize) {
 

lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

bool AMDGPUTTIImpl::isSourceOfDivergence(const Value *V) const {
   // same arguments, they will always get the same result.
   if (const LoadInst *Load = dyn_cast<LoadInst>(V))
     return Load->getPointerAddressSpace() == ST->getAMDGPUAS().PRIVATE_ADDRESS;
 
   // Atomics are divergent because they are executed sequentially: when an
   // atomic operation refers to the same address in each thread, then each
   // thread after the first sees the value written by the previous thread as
   // original value.
-  if (isa<AtomicRMWInst>(V) || isa<AtomicCmpXchgInst>(V))
+  if (isoneof<AtomicRMWInst, AtomicCmpXchgInst>(V))
     return true;
 
   if (const IntrinsicInst *Intrinsic = dyn_cast<IntrinsicInst>(V))
     return isIntrinsicSourceOfDivergence(Intrinsic);
 
   // Assume all function calls are a source of divergence.
-  if (isa<CallInst>(V) || isa<InvokeInst>(V))
+  if (isoneof<CallInst, InvokeInst>(V))
     return true;
 
   return false;
 }
 
 unsigned AMDGPUTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
                                        Type *SubTp) {
   if (ST->hasVOP3PInsts()) {

lib/Target/AMDGPU/R600ISelLowering.cpp

   }
 
   int ConstantBlock = ConstantAddressBlock(LoadNode->getAddressSpace(),
       AMDGPUASI);
   if (ConstantBlock > -1 &&
       ((LoadNode->getExtensionType() == ISD::NON_EXTLOAD) ||
        (LoadNode->getExtensionType() == ISD::ZEXTLOAD))) {
     SDValue Result;
-    if (isa<ConstantExpr>(LoadNode->getMemOperand()->getValue()) ||
-        isa<Constant>(LoadNode->getMemOperand()->getValue()) ||
+    if (isoneof<ConstantExpr, Constant>(
+            LoadNode->getMemOperand()->getValue()) ||
         isa<ConstantSDNode>(Ptr)) {
       SDValue Slots[4];
       for (unsigned i = 0; i < 4; i++) {
         // We want Const position encoded with the following formula :
         // (((512 + (kc_bank << 12) + const_index) << 2) + chan)
         // const_index is Ptr computed by llvm using an alignment of 16.
         // Thus we add (((512 + (kc_bank << 12)) + chan ) * 4 here and
         // then div by 4 at the ISel step

lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp

 }
 
 bool isUniformMMO(const MachineMemOperand *MMO) {
   const Value *Ptr = MMO->getValue();
   // UndefValue means this is a load of a kernel input.  These are uniform.
   // Sometimes LDS instructions have constant pointers.
   // If Ptr is null, then that means this mem operand contains a
   // PseudoSourceValue like GOT.
-  if (!Ptr || isa<UndefValue>(Ptr) || isa<Argument>(Ptr) ||
-      isa<Constant>(Ptr) || isa<GlobalValue>(Ptr))
+  if (!Ptr || isoneof<UndefValue, Argument, Constant, GlobalValue>(Ptr))
     return true;
 
   const Instruction *I = dyn_cast<Instruction>(Ptr);
   return I && I->getMetadata("amdgpu.uniform");
 }
 
 int64_t getSMRDEncodedOffset(const MCSubtargetInfo &ST, int64_t ByteOffset) {
   if (isSI(ST) || isCI(ST))

lib/Target/AVR/AVRISelDAGToDAG.cpp

 
 template <> bool AVRDAGToDAGISel::select<ISD::STORE>(SDNode *N) {
   // Use the STD{W}SPQRr pseudo instruction when passing arguments through
   // the stack on function calls for further expansion during the PEI phase.
   const StoreSDNode *ST = cast<StoreSDNode>(N);
   SDValue BasePtr = ST->getBasePtr();
 
   // Early exit when the base pointer is a frame index node or a constant.
-  if (isa<FrameIndexSDNode>(BasePtr) || isa<ConstantSDNode>(BasePtr) ||
-      BasePtr.isUndef()) {
+  if (isoneof<FrameIndexSDNode, ConstantSDNode>(BasePtr) || BasePtr.isUndef()) {
     return false;
   }
 
   const RegisterSDNode *RN = dyn_cast<RegisterSDNode>(BasePtr.getOperand(0));
   // Only stores where SP is the base pointer are valid.
   if (!RN || (RN->getReg() != AVR::SP)) {
     return false;
   }

lib/Target/Hexagon/HexagonCommonGEP.cpp

for (NodeVect::iterator I = Cs.begin(), E = Cs.end(); I != E; ++I)
       recalculatePlacementRec(*I, NCM, Loc);
   }
   BasicBlock *LB = recalculatePlacement(Node, NCM, Loc);
   DEBUG(dbgs() << "LocRec end for node:" << Node << '\n');
   return LB;
 }
 
 bool HexagonCommonGEP::isInvariantIn(Value *Val, Loop *L) {
-  if (isa<Constant>(Val) || isa<Argument>(Val))
+  if (isoneof<Constant, Argument>(Val))
     return true;
   Instruction *In = dyn_cast<Instruction>(Val);
   if (!In)
     return false;
   BasicBlock *HdrB = L->getHeader(), *DefB = In->getParent();
   return DT->properlyDominates(DefB, HdrB);
 }
 

 
 bool HexagonCommonGEP::runOnFunction(Function &F) {
   if (skipFunction(F))
     return false;
 
   // For now bail out on C++ exception handling.
   for (Function::iterator A = F.begin(), Z = F.end(); A != Z; ++A)
     for (BasicBlock::iterator I = A->begin(), E = A->end(); I != E; ++I)
-      if (isa<InvokeInst>(I) || isa<LandingPadInst>(I))
+      if (isoneof<InvokeInst, LandingPadInst>(I))
         return false;
 
   Fn = &F;
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   Ctx = &F.getContext();
 

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

   }
 
   // Scan all instructions in the loop, if any of them have a user outside
   // of the loop, or outside of the expressions collected above, then either
   // the loop has a side-effect visible outside of it, or there are
   // instructions in it that are not involved in the original set Insts.
   for (auto *B : L->blocks()) {
     for (auto &In : *B) {
-      if (isa<BranchInst>(In) || isa<DbgInfoIntrinsic>(In))
+      if (isoneof<BranchInst, DbgInfoIntrinsic>(In))
         continue;
       if (!Worklist.count(&In) && In.mayHaveSideEffects())
         return false;
       for (const auto &K : In.users()) {
         Instruction *UseI = dyn_cast<Instruction>(K);
         if (!UseI)
           continue;
         BasicBlock *UseB = UseI->getParent();

lib/Target/Mips/Mips16ISelDAGToDAG.cpp

if (Addr.getOpcode() == ISD::ADD) {
     //  addiu $2, $2, %lo($CPI1_0)
     //  lwc1 $f0, 0($2)
     // Generate:
     //  lui $2, %hi($CPI1_0)
     //  lwc1 $f0, %lo($CPI1_0)($2)
     if (Addr.getOperand(1).getOpcode() == MipsISD::Lo ||
         Addr.getOperand(1).getOpcode() == MipsISD::GPRel) {
       SDValue Opnd0 = Addr.getOperand(1).getOperand(0);
-      if (isa<ConstantPoolSDNode>(Opnd0) || isa<GlobalAddressSDNode>(Opnd0) ||
-          isa<JumpTableSDNode>(Opnd0)) {
+      if (isoneof<ConstantPoolSDNode, GlobalAddressSDNode, JumpTableSDNode>(
+              Opnd0)) {
         Base = Addr.getOperand(0);
         Offset = Opnd0;
         return true;
       }
     }
   }
   Base = Addr;
   Offset = CurDAG->getTargetConstant(0, DL, ValTy);

lib/Target/Mips/MipsSEISelDAGToDAG.cpp

if (Addr.getOpcode() == ISD::ADD) {
     //  addiu $2, $2, %lo($CPI1_0)
     //  lwc1 $f0, 0($2)
     // Generate:
     //  lui $2, %hi($CPI1_0)
     //  lwc1 $f0, %lo($CPI1_0)($2)
     if (Addr.getOperand(1).getOpcode() == MipsISD::Lo ||
         Addr.getOperand(1).getOpcode() == MipsISD::GPRel) {
       SDValue Opnd0 = Addr.getOperand(1).getOperand(0);
-      if (isa<ConstantPoolSDNode>(Opnd0) || isa<GlobalAddressSDNode>(Opnd0) ||
-          isa<JumpTableSDNode>(Opnd0)) {
+      if (isoneof<ConstantPoolSDNode, GlobalAddressSDNode, JumpTableSDNode>(
+              Opnd0)) {
         Base = Addr.getOperand(0);
         Offset = Opnd0;
         return true;
       }
     }
   }
 
   return false;

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

     unsigned int s = DL.getTypeAllocSize(CPV->getType());
     aggBuffer->addZeros(s);
     break;
   }
 
   case Type::ArrayTyID:
   case Type::VectorTyID:
   case Type::StructTyID: {
-    if (isa<ConstantAggregate>(CPV) || isa<ConstantDataSequential>(CPV)) {
+    if (isoneof<ConstantAggregate, ConstantDataSequential>(CPV)) {
       int ElementSize = DL.getTypeAllocSize(CPV->getType());
       bufferAggregateConstant(CPV, aggBuffer);
       if (Bytes > ElementSize)
         aggBuffer->addZeros(Bytes - ElementSize);
     } else if (isa<ConstantAggregateZero>(CPV))
       aggBuffer->addZeros(Bytes);
     else
       llvm_unreachable("Unexpected Constant type");

       uint8_t Byte = Val.getLoBits(8).getZExtValue();
       aggBuffer->addBytes(&Byte, 1, 1);
       Val.lshrInPlace(8);
     }
     return;
   }
 
   // Old constants
-  if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV)) {
+  if (isoneof<ConstantArray, ConstantVector>(CPV)) {
     if (CPV->getNumOperands())
       for (unsigned i = 0, e = CPV->getNumOperands(); i != e; ++i)
         bufferLEByte(cast<Constant>(CPV->getOperand(i)), 0, aggBuffer);
     return;
   }
 
   if (const ConstantDataSequential *CDS =
           dyn_cast<ConstantDataSequential>(CPV)) {

     printMCExpr(*UE.getSubExpr(), OS);
     return;
   }
 
   case MCExpr::Binary: {
     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
 
     // Only print parens around the LHS if it is non-trivial.
-    if (isa<MCConstantExpr>(BE.getLHS()) || isa<MCSymbolRefExpr>(BE.getLHS()) ||
-        isa<NVPTXGenericMCSymbolRefExpr>(BE.getLHS())) {
+    if (isoneof<MCConstantExpr, MCSymbolRefExpr, NVPTXGenericMCSymbolRefExpr>(
+            BE.getLHS())) {
       printMCExpr(*BE.getLHS(), OS);
     } else {
       OS << '(';
       printMCExpr(*BE.getLHS(), OS);
       OS<< ')';
     }
 
     switch (BE.getOpcode()) {
     case MCBinaryExpr::Add:
       // Print "X-42" instead of "X+-42".
       if (const MCConstantExpr *RHSC = dyn_cast<MCConstantExpr>(BE.getRHS())) {
         if (RHSC->getValue() < 0) {
           OS << RHSC->getValue();
           return;
         }
       }
 
       OS <<  '+';
       break;
     default: llvm_unreachable("Unhandled binary operator");
     }
 
     // Only print parens around the LHS if it is non-trivial.
-    if (isa<MCConstantExpr>(BE.getRHS()) || isa<MCSymbolRefExpr>(BE.getRHS())) {
+    if (isoneof<MCConstantExpr, MCSymbolRefExpr>(BE.getRHS())) {
       printMCExpr(*BE.getRHS(), OS);
     } else {
       OS << '(';
       printMCExpr(*BE.getRHS(), OS);
       OS << ')';
     }
     return;
   }

lib/Target/PowerPC/PPCBoolRetToInt.cpp

for (auto &BB : F)
       for (auto &I : BB)
         if (const auto *P = dyn_cast<PHINode>(&I))
           if (P->getType()->isIntegerTy(1))
             Promotable.insert(P);
 
     SmallVector<const PHINode *, 8> ToRemove;
     for (const PHINode *P : Promotable) {
       // Condition 2 and 3
-      auto IsValidUser = [] (const Value *V) -> bool {
-        return isa<ReturnInst>(V) || isa<CallInst>(V) || isa<PHINode>(V) ||
-        isa<DbgInfoIntrinsic>(V);
+      auto IsValidUser = [](const Value *V) -> bool {
+        return isoneof<ReturnInst, CallInst, PHINode, DbgInfoIntrinsic>(V);
       };
-      auto IsValidOperand = [] (const Value *V) -> bool {
-        return isa<Constant>(V) || isa<Argument>(V) || isa<CallInst>(V) ||
-        isa<PHINode>(V);
+      auto IsValidOperand = [](const Value *V) -> bool {
+        return isoneof<Constant, Argument, CallInst, PHINode>(V);
       };
       const auto &Users = P->users();
       const auto &Operands = P->operands();
       if (!llvm::all_of(Users, IsValidUser) ||
           !llvm::all_of(Operands, IsValidOperand))
         ToRemove.push_back(P);
     }
 

lib/Target/PowerPC/PPCCTRLoops.cpp

#endif
         }
       }
 
       return true;
     } else if (isa<BinaryOperator>(J) &&
                J->getType()->getScalarType()->isPPC_FP128Ty()) {
       // Most operations on ppc_f128 values become calls.
       return true;
-    } else if (isa<UIToFPInst>(J) || isa<SIToFPInst>(J) ||
-               isa<FPToUIInst>(J) || isa<FPToSIInst>(J)) {
+    } else if (isoneof<UIToFPInst, SIToFPInst, FPToUIInst, FPToSIInst>(J)) {
       CastInst *CI = cast<CastInst>(J);
       if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() ||
           CI->getDestTy()->getScalarType()->isPPC_FP128Ty() ||
           isLargeIntegerTy(TT.isArch32Bit(), CI->getSrcTy()->getScalarType()) ||
           isLargeIntegerTy(TT.isArch32Bit(), CI->getDestTy()->getScalarType()))
         return true;
     } else if (isLargeIntegerTy(TT.isArch32Bit(),
                                 J->getType()->getScalarType()) &&
                (J->getOpcode() == Instruction::UDiv ||
                 J->getOpcode() == Instruction::SDiv ||
                 J->getOpcode() == Instruction::URem ||
                 J->getOpcode() == Instruction::SRem)) {
       return true;
     } else if (TT.isArch32Bit() &&
                isLargeIntegerTy(false, J->getType()->getScalarType()) &&
                (J->getOpcode() == Instruction::Shl ||
                 J->getOpcode() == Instruction::AShr ||
                 J->getOpcode() == Instruction::LShr)) {
       // Only on PPC32, for 128-bit integers (specifically not 64-bit
       // integers), these might be runtime calls.
       return true;
-    } else if (isa<IndirectBrInst>(J) || isa<InvokeInst>(J)) {
+    } else if (isoneof<IndirectBrInst, InvokeInst>(J)) {
       // On PowerPC, indirect jumps use the counter register.
       return true;
     } else if (SwitchInst *SI = dyn_cast<SwitchInst>(J)) {
       if (!TM)
         return true;
       const TargetLowering *TLI =
           TM->getSubtargetImpl(*BB->getParent())->getTargetLowering();
 

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

     //   LDtocL(<ga:@sym>, ADDIStocHA(%X2, <ga:@sym>))
     // Otherwise we generate:
     //   ADDItocL(ADDIStocHA(%X2, <ga:@sym>), <ga:@sym>)
     SDValue GA = N->getOperand(0);
     SDValue TOCbase = N->getOperand(1);
     SDNode *Tmp = CurDAG->getMachineNode(PPC::ADDIStocHA, dl, MVT::i64,
                                          TOCbase, GA);
 
-    if (isa<JumpTableSDNode>(GA) || isa<BlockAddressSDNode>(GA) ||
+    if (isoneof<JumpTableSDNode, BlockAddressSDNode>(GA) ||
         CModel == CodeModel::Large) {
       SDNode *MN = CurDAG->getMachineNode(PPC::LDtocL, dl, MVT::i64, GA,
                                           SDValue(Tmp, 0));
       transferMemOperands(N, MN);
       ReplaceNode(N, MN);
       return;
     }
 

lib/Target/PowerPC/PPCISelLowering.cpp

 
   if (SelectAddressRegReg(Ptr, Base, Offset, DAG)) {
     // Common code will reject creating a pre-inc form if the base pointer
     // is a frame index, or if N is a store and the base pointer is either
     // the same as or a predecessor of the value being stored.  Check for
     // those situations here, and try with swapped Base/Offset instead.
     bool Swap = false;
 
-    if (isa<FrameIndexSDNode>(Base) || isa<RegisterSDNode>(Base))
+    if (isoneof<FrameIndexSDNode, RegisterSDNode>(Base))
       Swap = true;
     else if (!isLoad) {
       SDValue Val = cast<StoreSDNode>(N)->getValue();
       if (Val == Base || Base.getNode()->isPredecessorOf(Val.getNode()))
         Swap = true;
     }
 
     if (Swap)

lib/Target/SystemZ/SystemZISelLowering.cpp

if (!Subtarget.hasVector())
     return true;
 
   // * Use LDE instead of LE/LEY to avoid partial register
   //   dependencies (LDE only supports small offsets).
   // * Utilize the vector registers to hold floating point
   //   values (vector load / store instructions only support small
   //   offsets).
 
-  assert (isa<LoadInst>(I) || isa<StoreInst>(I));
+  assert((isoneof<LoadInst, StoreInst>(I)));
   Type *MemAccessTy = (isa<LoadInst>(I) ? I->getType() :
                        I->getOperand(0)->getType());
   bool IsFPAccess = MemAccessTy->isFloatingPointTy();
   bool IsVectorAccess = MemAccessTy->isVectorTy();
 
   // A store of an extracted vector element will be combined into a VSTE type
   // instruction.
   if (!IsVectorAccess && isa<StoreInst>(I)) {

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

 void SystemZTTIImpl::getUnrollingPreferences(Loop *L,
                                              TTI::UnrollingPreferences &UP) {
   // Find out if L contains a call, what the machine instruction count
   // estimate is, and how many stores there are.
   bool HasCall = false;
   unsigned NumStores = 0;
   for (auto &BB : L->blocks())
     for (auto &I : *BB) {
-      if (isa<CallInst>(&I) || isa<InvokeInst>(&I)) {
-        ImmutableCallSite CS(&I);
+      if (ImmutableCallSite CS{&I}) {
         if (const Function *F = CS.getCalledFunction()) {
           if (isLoweredToCall(F))
             HasCall = true;
           if (F->getIntrinsicID() == Intrinsic::memcpy ||
               F->getIntrinsicID() == Intrinsic::memset)
             NumStores++;
         } else { // indirect call.
           HasCall = true;

lib/Target/X86/X86FastISel.cpp

       MachineMemOperand *MMO = FuncInfo.MF->getMachineMemOperand(
           MachinePointerInfo::getStack(*FuncInfo.MF, LocMemOffset),
           MachineMemOperand::MOStore, ArgVT.getStoreSize(), Alignment);
       if (Flags.isByVal()) {
         X86AddressMode SrcAM;
         SrcAM.Base.Reg = ArgReg;
         if (!TryEmitSmallMemcpy(AM, SrcAM, Flags.getByValSize()))
           return false;
-      } else if (isa<ConstantInt>(ArgVal) || isa<ConstantPointerNull>(ArgVal)) {
+      } else if (isoneof<ConstantInt, ConstantPointerNull>(ArgVal)) {
         // If this is a really simple value, emit this with the Value* version
         // of X86FastEmitStore.  If it isn't simple, we don't want to do this,
         // as it can cause us to reevaluate the argument.
         if (!X86FastEmitStore(ArgVT, ArgVal, AM, MMO))
           return false;
       } else {
         bool ValIsKill = hasTrivialKill(ArgVal);
         if (!X86FastEmitStore(ArgVT, ArgReg, ValIsKill, AM, MMO))

lib/Transforms/Coroutines/CoroFrame.cpp

static void rewritePHIs(Function &F) {
 
   for (BasicBlock *BB : WorkList)
     rewritePHIs(*BB);
 }
 
 // Check for instructions that we can recreate on resume as opposed to spill
 // the result into a coroutine frame.
 static bool materializable(Instruction &V) {
-  return isa<CastInst>(&V) || isa<GetElementPtrInst>(&V) ||
-         isa<BinaryOperator>(&V) || isa<CmpInst>(&V) || isa<SelectInst>(&V);
+  return isoneof<CastInst, GetElementPtrInst, BinaryOperator, CmpInst,
+                 SelectInst>(&V);
 }
 
 // Check for structural coroutine intrinsics that should not be spilled into
 // the coroutine frame.
 static bool isCoroutineStructureIntrinsic(Instruction &I) {
-  return isa<CoroIdInst>(&I) || isa<CoroBeginInst>(&I) ||
-         isa<CoroSaveInst>(&I) || isa<CoroSuspendInst>(&I);
+  return isoneof<CoroIdInst, CoroBeginInst, CoroSaveInst, CoroSuspendInst>(&I);
 }
 
 // For every use of the value that is across suspend point, recreate that value
 // after a suspend point.
 static void rewriteMaterializableInstructions(IRBuilder<> &IRB,
                                               SpillInfo const &Spills) {
   BasicBlock *CurrentBlock = nullptr;
   Instruction *CurrentMaterialization = nullptr;

lib/Transforms/Coroutines/CoroInstr.h

public:
   }
 
   void clearPromise() {
     Value *Arg = getArgOperand(PromiseArg);
     setArgOperand(PromiseArg,
                   ConstantPointerNull::get(Type::getInt8PtrTy(getContext())));
     if (isa<AllocaInst>(Arg))
       return;
-    assert((isa<BitCastInst>(Arg) || isa<GetElementPtrInst>(Arg)) &&
+    assert((isoneof<BitCastInst, GetElementPtrInst>(Arg)) &&
            "unexpected instruction designating the promise");
     // TODO: Add a check that any remaining users of Inst are after coro.begin
     // or add code to move the users after coro.begin.
     auto *Inst = cast<Instruction>(Arg);
     if (Inst->use_empty()) {
       Inst->eraseFromParent();
       return;
     }

lib/Transforms/IPO/ArgumentPromotion.cpp

static bool canPaddingBeAccessed(Argument *arg) {
 
   // Scan through the uses recursively to make sure the pointer is always used
   // sanely.
   SmallVector<Value *, 16> WorkList;
   WorkList.insert(WorkList.end(), arg->user_begin(), arg->user_end());
   while (!WorkList.empty()) {
     Value *V = WorkList.back();
     WorkList.pop_back();
-    if (isa<GetElementPtrInst>(V) || isa<PHINode>(V)) {
+    if (isoneof<GetElementPtrInst, PHINode>(V)) {
       if (PtrValues.insert(V).second)
         WorkList.insert(WorkList.end(), V->user_begin(), V->user_end());
     } else if (StoreInst *Store = dyn_cast<StoreInst>(V)) {
       Stores.push_back(Store);
     } else if (!isa<LoadInst>(V)) {
       return true;
     }
   }

lib/Transforms/IPO/GlobalOpt.cpp

 /// it's safe to remove the store and the chain of computation that feeds the
 /// store.
 static bool IsSafeComputationToRemove(Value *V, const TargetLibraryInfo *TLI) {
   do {
     if (isa<Constant>(V))
       return true;
     if (!V->hasOneUse())
       return false;
-    if (isa<LoadInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V) ||
-        isa<GlobalValue>(V))
+    if (isoneof<LoadInst, InvokeInst, Argument, GlobalValue>(V))
       return false;
     if (isAllocationFn(V, TLI))
       return true;
 
     Instruction *I = cast<Instruction>(V);
     if (I->mayHaveSideEffects())
       return false;
     if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) {
for (auto UI = V->user_begin(), E = V->user_end(); UI != E; ) {
     if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
       LI->setOperand(0, NewV);
       Changed = true;
     } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
       if (SI->getOperand(1) == V) {
         SI->setOperand(1, NewV);
         Changed = true;
       }
-    } else if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
-      CallSite CS(I);
+    } else if (CallSite CS{I}) {
       if (CS.getCalledValue() == V) {
         // Calling through the pointer!  Turn into a direct call, but be careful
         // that the pointer is not also being passed as an argument.
         CS.setCalledFunction(NewV);
         Changed = true;
         bool PassedAsArg = false;
         for (unsigned i = 0, e = CS.arg_size(); i != e; ++i)
           if (CS.getArgument(i) == V) {
if (LoadInst *LI = dyn_cast<LoadInst>(GlobalUser)) {
       // Ignore the store that stores "LV" to the global.
       assert(GlobalUser->getOperand(1) == GV &&
              "Must be storing *to* the global");
     } else {
       AllNonStoreUsesGone = false;
 
       // If we get here we could have other crazy uses that are transitively
       // loaded.
-      assert((isa<PHINode>(GlobalUser) || isa<SelectInst>(GlobalUser) ||
-              isa<ConstantExpr>(GlobalUser) || isa<CmpInst>(GlobalUser) ||
-              isa<BitCastInst>(GlobalUser) ||
-              isa<GetElementPtrInst>(GlobalUser)) &&
+      assert((isoneof<PHINode, SelectInst, ConstantExpr, CmpInst, BitCastInst,
+                      GetElementPtrInst>(GlobalUser)) &&
              "Only expect load and stores!");
     }
   }
 
   if (Changed) {
     DEBUG(dbgs() << "OPTIMIZED LOADS FROM STORED ONCE POINTER: " << *GV << "\n");
     ++NumGlobUses;
   }

 /// of V.  We permit simple things like dereferencing the pointer, but not
 /// storing through the address, unless it is to the specified global.
 static bool ValueIsOnlyUsedLocallyOrStoredToOneGlobal(const Instruction *V,
                                                       const GlobalVariable *GV,
                                         SmallPtrSetImpl<const PHINode*> &PHIs) {
   for (const User *U : V->users()) {
     const Instruction *Inst = cast<Instruction>(U);
 
-    if (isa<LoadInst>(Inst) || isa<CmpInst>(Inst)) {
+    if (isoneof<LoadInst, CmpInst>(Inst)) {
       continue; // Fine, ignore.
     }
 
     if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
       if (SI->getOperand(0) == V && SI->getOperand(1) != GV)
         return false;  // Storing the pointer itself... bad.
       continue; // Otherwise, storing through it, or storing into GV... fine.
     }
if (StoreInst *SI = dyn_cast<StoreInst>(UI)) {
         // select instruction.  If not, it will be a load of the original
         // global.
         if (LoadInst *LI = dyn_cast<LoadInst>(StoredVal)) {
           assert(LI->getOperand(0) == GV && "Not a copy!");
           // Insert a new load, to preserve the saved value.
           StoreVal = new LoadInst(NewGV, LI->getName()+".b", false, 0,
                                   LI->getOrdering(), LI->getSynchScope(), LI);
         } else {
-          assert((isa<CastInst>(StoredVal) || isa<SelectInst>(StoredVal)) &&
+          assert((isoneof<CastInst, SelectInst>(StoredVal)) &&
                  "This is not a form that we understand!");
           StoreVal = StoredVal->getOperand(0);
           assert(isa<LoadInst>(StoreVal) && "Not a load of NewGV!");
         }
       }
       new StoreInst(StoreVal, NewGV, false, 0,
                     SI->getOrdering(), SI->getSynchScope(), SI);
     } else {

lib/Transforms/IPO/IPConstantPropagation.cpp

if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
           V = FindInsertedValue(RI->getOperand(0), i);
 
         if (V) {
           // Ignore undefs, we can change them into anything
           if (isa<UndefValue>(V))
             continue;
           
           // Try to see if all the rets return the same constant or argument.
-          if (isa<Constant>(V) || isa<Argument>(V)) {
+          if (isoneof<Constant, Argument>(V)) {
             if (isa<UndefValue>(RV)) {
               // No value found yet? Try the current one.
               RetVals[i] = V;
               continue;
             }
             // Returning the same value? Good.
             if (RV == V)
               continue;

lib/Transforms/IPO/SampleProfile.cpp

ErrorOr<uint64_t> SampleProfileLoader::getInstWeight(const Instruction &Inst) {
 
   const FunctionSamples *FS = findFunctionSamples(Inst);
   if (!FS)
     return std::error_code();
 
   // Ignore all intrinsics and branch instructions.
   // Branch instruction usually contains debug info from sources outside of
   // the residing basic block, thus we ignore them during annotation.
-  if (isa<BranchInst>(Inst) || isa<IntrinsicInst>(Inst))
+  if (isoneof<BranchInst, IntrinsicInst>(Inst))
     return std::error_code();
 
   // If a call/invoke instruction is inlined in profile, but not inlined here,
   // it means that the inlined callsite has no sample, thus the call
   // instruction should have 0 count.
-  if ((isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) &&
-      findCalleeFunctionSamples(Inst))
+  if ((isoneof<CallInst, InvokeInst>(Inst)) && findCalleeFunctionSamples(Inst))
     return 0;
 
   const DILocation *DIL = DLoc;
   uint32_t LineOffset = getOffset(DIL);
   uint32_t Discriminator = DIL->getBaseDiscriminator();
   ErrorOr<uint64_t> R = FS->findSamplesAt(LineOffset, Discriminator);
   if (R) {
     bool FirstMark =
bool SampleProfileLoader::inlineHotFunctions(
   while (true) {
     bool LocalChanged = false;
     SmallVector<Instruction *, 10> CIS;
     for (auto &BB : F) {
       bool Hot = false;
       SmallVector<Instruction *, 10> Candidates;
       for (auto &I : BB.getInstList()) {
         const FunctionSamples *FS = nullptr;
-        if ((isa<CallInst>(I) || isa<InvokeInst>(I)) &&
-            !isa<IntrinsicInst>(I) && (FS = findCalleeFunctionSamples(I))) {
+        if (isoneof<CallInst, InvokeInst>(I) && !isa<IntrinsicInst>(I) &&
+            (FS = findCalleeFunctionSamples(I))) {
           Candidates.push_back(&I);
           if (callsiteIsHot(Samples, FS))
             Hot = true;
         }
       }
       if (Hot) {
         CIS.insert(CIS.begin(), Candidates.begin(), Candidates.end());
       }

lib/Transforms/InstCombine/InstCombineCalls.cpp

 
 /// Return a constant boolean vector that has true elements in all positions
 /// where the input constant data vector has an element with the sign bit set.
 static Constant *getNegativeIsTrueBoolVec(ConstantDataVector *V) {
   SmallVector<Constant *, 32> BoolVec;
   IntegerType *BoolTy = Type::getInt1Ty(V->getContext());
   for (unsigned I = 0, E = V->getNumElements(); I != E; ++I) {
     Constant *Elt = V->getElementAsConstant(I);
-    assert((isa<ConstantInt>(Elt) || isa<ConstantFP>(Elt)) &&
+    assert((isoneof<ConstantInt, ConstantFP>(Elt)) &&
            "Unexpected constant data vector element type");
     bool Sign = V->getElementType()->isIntegerTy()
                     ? cast<ConstantInt>(Elt)->isNegative()
                     : cast<ConstantFP>(Elt)->isNegative();
     BoolVec.push_back(ConstantInt::get(BoolTy, Sign));
   }
   return ConstantVector::get(BoolVec);
 }

     if (Constant *Mask = dyn_cast<Constant>(II->getArgOperand(2))) {
       assert(Mask->getType()->getVectorNumElements() == 16 &&
              "Bad type for intrinsic!");
 
       // Check that all of the elements are integer constants or undefs.
       bool AllEltsOk = true;
       for (unsigned i = 0; i != 16; ++i) {
         Constant *Elt = Mask->getAggregateElement(i);
-        if (!Elt || !(isa<ConstantInt>(Elt) || isa<UndefValue>(Elt))) {
+        if (!Elt || !isoneof<ConstantInt, UndefValue>(Elt)) {
           AllEltsOk = false;
           break;
         }
       }
 
       if (AllEltsOk) {
         // Cast the input vectors to byte vectors.
         Value *Op0 = Builder->CreateBitCast(II->getArgOperand(0),

           break;
         }
       }
     }
 
     // If the stack restore is in a return, resume, or unwind block and if there
     // are no allocas or calls between the restore and the return, nuke the
     // restore.
-    if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
+    if (!CannotRemove && isoneof<ReturnInst, ResumeInst>(TI))
       return eraseInstFromFunction(CI);
     break;
   }
   case Intrinsic::lifetime_start:
     // Asan needs to poison memory to detect invalid access which is possible
     // even for empty lifetime range.
     if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress))
       break;

       // We cannot remove an invoke, because it would change the CFG, just
       // change the callee to a null pointer.
       cast<InvokeInst>(OldCall)->setCalledFunction(
                                     Constant::getNullValue(CalleeF->getType()));
       return nullptr;
     }
   }
 
-  if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
+  if (isoneof<ConstantPointerNull, UndefValue>(Callee)) {
     // If CS does not return void then replaceAllUsesWith undef.
     // This allows ValueHandlers and custom metadata to adjust itself.
     if (!CS.getInstruction()->getType()->isVoidTy())
       replaceInstUsesWith(*CS.getInstruction(),
                           UndefValue::get(CS.getInstruction()->getType()));
 
     if (isa<InvokeInst>(CS.getInstruction())) {
       // Can't remove an invoke because we cannot change the CFG.

lib/Transforms/InstCombine/InstCombineCasts.cpp

static bool canEvaluateTruncated(Value *V, Type *Ty, InstCombiner &IC,
 
   Instruction *I = dyn_cast<Instruction>(V);
   if (!I) return false;
 
   Type *OrigTy = V->getType();
 
   // If this is an extension from the dest type, we can eliminate it, even if it
   // has multiple uses.
-  if ((isa<ZExtInst>(I) || isa<SExtInst>(I)) &&
-      I->getOperand(0)->getType() == Ty)
+  if (isoneof<ZExtInst, SExtInst>(I) && I->getOperand(0)->getType() == Ty)
     return true;
 
   // We can't extend or shrink something that has multiple uses: doing so would
   // require duplicating the instruction in general, which isn't profitable.
   if (!I->hasOneUse()) return false;
 
   unsigned Opc = I->getOpcode();
   switch (Opc) {
if (DestVTy->getNumElements() == 1 && !SrcTy->isVectorTy()) {
                      Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
       // FIXME: Canonicalize bitcast(insertelement) -> insertelement(bitcast)
     }
 
     if (isa<IntegerType>(SrcTy)) {
       // If this is a cast from an integer to vector, check to see if the input
       // is a trunc or zext of a bitcast from vector.  If so, we can replace all
       // the casts with a shuffle and (potentially) a bitcast.
-      if (isa<TruncInst>(Src) || isa<ZExtInst>(Src)) {
+      if (isoneof<TruncInst, ZExtInst>(Src)) {
         CastInst *SrcCast = cast<CastInst>(Src);
         if (BitCastInst *BCIn = dyn_cast<BitCastInst>(SrcCast->getOperand(0)))
           if (isa<VectorType>(BCIn->getOperand(0)->getType()))
             if (Instruction *I = optimizeVectorResize(BCIn->getOperand(0),
                                                cast<VectorType>(DestTy), *this))
               return I;
       }
 

lib/Transforms/InstCombine/InstCombineCompares.cpp

       }
 
       if (!isa<IntToPtrInst>(V) && !isa<PtrToIntInst>(V) &&
           !isa<GetElementPtrInst>(V) && !isa<PHINode>(V))
         // We've found some value that we can't explore which is different from
         // the base. Therefore we can't do this transformation.
         return false;
 
-      if (isa<IntToPtrInst>(V) || isa<PtrToIntInst>(V)) {
+      if (isoneof<IntToPtrInst, PtrToIntInst>(V)) {
         auto *CI = dyn_cast<CastInst>(V);
         if (!CI->isNoopCast(DL))
           return false;
 
         if (Explored.count(CI->getOperand(0)) == 0)
           WorkList.push_back(CI->getOperand(0));
       }
 

 
   unsigned NumCmps = 0;
   while (!Worklist.empty()) {
     assert(Worklist.size() <= MaxIter);
     const Use *U = Worklist.pop_back_val();
     const Value *V = U->getUser();
     --MaxIter;
 
-    if (isa<BitCastInst>(V) || isa<GetElementPtrInst>(V) || isa<PHINode>(V) ||
-        isa<SelectInst>(V)) {
+    if (isoneof<BitCastInst, GetElementPtrInst, PHINode, SelectInst>(V)) {
       // Track the uses.
     } else if (isa<LoadInst>(V)) {
       // Loading from the pointer doesn't escape it.
       continue;
     } else if (const auto *SI = dyn_cast<StoreInst>(V)) {
       // Storing *to* the pointer is fine, but storing the pointer escapes it.
       if (SI->getValueOperand() == U->get())
         return nullptr;

       if (Instruction *New = foldAllocaCmp(I, Alloca, Op0))
         return New;
   }
 
   // Test to see if the operands of the icmp are casted versions of other
   // values.  If the ptr->ptr cast can be stripped off both arguments, we do so
   // now.
   if (BitCastInst *CI = dyn_cast<BitCastInst>(Op0)) {
-    if (Op0->getType()->isPointerTy() &&
-        (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) {
+    if (Op0->getType()->isPointerTy() && isoneof<Constant, BitCastInst>(Op1)) {
       // We keep moving the cast from the left operand over to the right
       // operand, where it can often be eliminated completely.
       Op0 = CI->getOperand(0);
 
       // If operand #1 is a bitcast instruction, it must also be a ptr->ptr cast
       // so eliminate it as well.
       if (BitCastInst *CI2 = dyn_cast<BitCastInst>(Op1))
         Op1 = CI2->getOperand(0);

 
   if (isa<CastInst>(Op0)) {
     // Handle the special case of: icmp (cast bool to X), <cst>
     // This comes up when you have code like
     //   int X = A < B;
     //   if (X) ...
     // For generality, we handle any zero-extension of any operand comparison
     // with a constant or another cast from the same type.
-    if (isa<Constant>(Op1) || isa<CastInst>(Op1))
+    if (isoneof<Constant, CastInst>(Op1))
       if (Instruction *R = foldICmpWithCastAndCast(I))
         return R;
   }
 
   if (Instruction *Res = foldICmpBinOp(I))
     return Res;
 
   if (Instruction *Res = foldICmpWithMinMax(I))

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

for (auto &U : ValuePair.first->uses()) {
       auto *I = cast<Instruction>(U.getUser());
 
       if (auto *LI = dyn_cast<LoadInst>(I)) {
         // Ignore non-volatile loads, they are always ok.
         if (!LI->isSimple()) return false;
         continue;
       }
 
-      if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) {
+      if (isoneof<BitCastInst, AddrSpaceCastInst>(I)) {
         // If uses of the bitcast are ok, we are ok.
         ValuesToInspect.emplace_back(I, IsOffset);
         continue;
       }
       if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
         // If the GEP has all zero indices, it doesn't offset the pointer. If it
         // doesn't, it does.
         ValuesToInspect.emplace_back(I, IsOffset || !GEP->hasAllZeroIndices());
if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) {
     Type *NewTy = ArrayType::get(AI.getAllocatedType(), C->getZExtValue());
     AllocaInst *New = IC.Builder->CreateAlloca(NewTy, nullptr, AI.getName());
     New->setAlignment(AI.getAlignment());
 
     // Scan to the end of the allocation instructions, to skip over a block of
     // allocas if possible...also skip interleaved debug info
     //
     BasicBlock::iterator It(New);
-    while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
+    while (isoneof<AllocaInst, DbgInfoIntrinsic>(*It))
       ++It;
 
     // Now that I is pointing to the first non-allocation-inst in the block,
     // insert our getelementptr instruction...
     //
     Type *IdxTy = IC.getDataLayout().getIntPtrType(AI.getType());
     Value *NullIdx = Constant::getNullValue(IdxTy);
     Value *Idx[2] = {NullIdx, NullIdx};
for (auto U : I.users()) {
     auto *Inst = dyn_cast<Instruction>(&*U);
     if (!Inst)
       return;
     DEBUG(dbgs() << "Found pointer user: " << *U << '\n');
     if (isa<LoadInst>(Inst)) {
       for (auto P : Path)
         replace(P);
       replace(Inst);
-    } else if (isa<GetElementPtrInst>(Inst) || isa<BitCastInst>(Inst)) {
+    } else if (isoneof<GetElementPtrInst, BitCastInst>(Inst)) {
       Path.push_back(Inst);
       findLoadAndReplace(*Inst);
       Path.pop_back();
     } else {
       return;
     }
   }
 }
static bool equivalentAddressValues(Value *A, Value *B) {
   // Test if the values are trivially equivalent.
   if (A == B) return true;
 
   // Test if the values come form identical arithmetic instructions.
   // This uses isIdenticalToWhenDefined instead of isIdenticalTo because
   // its only used to compare two uses within the same basic block, which
   // means that they'll always either have the same value or one of them
   // will have an undefined value.
-  if (isa<BinaryOperator>(A) ||
-      isa<CastInst>(A) ||
-      isa<PHINode>(A) ||
-      isa<GetElementPtrInst>(A))
+  if (isoneof<BinaryOperator, CastInst, PHINode, GetElementPtrInst>(A))
     if (Instruction *BI = dyn_cast<Instruction>(B))
       if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
         return true;
 
   // Otherwise they may not be equivalent.
   return false;
 }
 

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

   APInt Mask(APInt::getSignMask(I.getType()->getScalarSizeInBits()));
   if (MaskedValueIsZero(Op1, Mask, 0, &I) &&
       MaskedValueIsZero(Op0, Mask, 0, &I)) {
     // X srem Y -> X urem Y, iff X and Y don't have sign bit set
     return BinaryOperator::CreateURem(Op0, Op1, I.getName());
   }
 
   // If it's a constant vector, flip any negative values positive.
-  if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
+  if (isoneof<ConstantVector, ConstantDataVector>(Op1)) {
     Constant *C = cast<Constant>(Op1);
     unsigned VWidth = C->getType()->getVectorNumElements();
 
     bool hasNegative = false;
     bool hasMissing = false;
     for (unsigned i = 0; i != VWidth; ++i) {
       Constant *Elt = C->getAggregateElement(i);
       if (!Elt) {

lib/Transforms/InstCombine/InstCombinePHI.cpp

DebugLoc InstCombiner::PHIArgMergedDebugLoc(PHINode &PN) {
 
   return Loc;
 }
 
 /// If we have something like phi [add (a,b), add(a,c)] and if a/b/c and the
 /// adds all have a single use, turn this into a phi and a single binop.
 Instruction *InstCombiner::FoldPHIArgBinOpIntoPHI(PHINode &PN) {
   Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
-  assert(isa<BinaryOperator>(FirstInst) || isa<CmpInst>(FirstInst));
+  assert((isoneof<BinaryOperator, CmpInst>(FirstInst)));
   unsigned Opc = FirstInst->getOpcode();
   Value *LHSVal = FirstInst->getOperand(0);
   Value *RHSVal = FirstInst->getOperand(1);
 
   Type *LHSType = LHSVal->getType();
   Type *RHSType = RHSVal->getType();
 
   // Scan to see if all operands are the same opcode, and all have one use.
if (isa<CastInst>(FirstInst)) {
     CastSrcTy = FirstInst->getOperand(0)->getType();
 
     // Be careful about transforming integer PHIs.  We don't want to pessimize
     // the code by turning an i32 into an i1293.
     if (PN.getType()->isIntegerTy() && CastSrcTy->isIntegerTy()) {
       if (!shouldChangeType(PN.getType(), CastSrcTy))
         return nullptr;
     }
-  } else if (isa<BinaryOperator>(FirstInst) || isa<CmpInst>(FirstInst)) {
+  } else if (isoneof<BinaryOperator, CmpInst>(FirstInst)) {
     // Can fold binop, compare or shift here if the RHS is a constant,
     // otherwise call FoldPHIArgBinOpIntoPHI.
     ConstantOp = dyn_cast<Constant>(FirstInst->getOperand(1));
     if (!ConstantOp)
       return FoldPHIArgBinOpIntoPHI(PN);
   } else {
     return nullptr;  // Cannot fold this operation.
   }
if (PN.hasOneUse()) {
 
     // If this phi has a single use, and if that use just computes a value for
     // the next iteration of a loop, delete the phi.  This occurs with unused
     // induction variables, e.g. "for (int j = 0; ; ++j);".  Detecting this
     // common case here is good because the only other things that catch this
     // are induction variable analysis (sometimes) and ADCE, which is only run
     // late.
     if (PHIUser->hasOneUse() &&
-        (isa<BinaryOperator>(PHIUser) || isa<GetElementPtrInst>(PHIUser)) &&
+        isoneof<BinaryOperator, GetElementPtrInst>(PHIUser) &&
         PHIUser->user_back() == &PN) {
       return replaceInstUsesWith(PN, UndefValue::get(PN.getType()));
     }
     // When a PHI is used only to be compared with zero, it is safe to replace
     // an incoming value proved as known nonzero with any non-zero constant.
     // For example, in the code below, the incoming value %v can be replaced
     // with any non-zero constant based on the fact that the PHI is only used to
     // be compared with zero and %v is a known non-zero value:

lib/Transforms/InstCombine/InstructionCombining.cpp

   // If one argument is a shuffle within one vector, the other is a constant,
   // try moving the shuffle after the binary operation.
   ShuffleVectorInst *Shuffle = nullptr;
   Constant *C1 = nullptr;
   if (isa<ShuffleVectorInst>(LHS)) Shuffle = cast<ShuffleVectorInst>(LHS);
   if (isa<ShuffleVectorInst>(RHS)) Shuffle = cast<ShuffleVectorInst>(RHS);
   if (isa<Constant>(LHS)) C1 = cast<Constant>(LHS);
   if (isa<Constant>(RHS)) C1 = cast<Constant>(RHS);
-  if (Shuffle && C1 &&
-      (isa<ConstantVector>(C1) || isa<ConstantDataVector>(C1)) &&
+  if (Shuffle && C1 && isoneof<ConstantVector, ConstantDataVector>(C1) &&
       isa<UndefValue>(Shuffle->getOperand(1)) &&
       Shuffle->getType() == Shuffle->getOperand(0)->getType()) {
     SmallVector<int, 16> ShMask = Shuffle->getShuffleMask();
     // Find constant C2 that has property:
     //   shuffle(C2, ShMask) = C1
     // If such constant does not exist (example: ShMask=<0,0> and C1=<1,2>)
     // reorder is not possible.
     SmallVector<Constant*, 16> C2M(VWidth,

         continue;
 
       Instruction *I = cast<Instruction>(&*Users[i]);
 
       if (ICmpInst *C = dyn_cast<ICmpInst>(I)) {
         replaceInstUsesWith(*C,
                             ConstantInt::get(Type::getInt1Ty(C->getContext()),
                                              C->isFalseWhenEqual()));
-      } else if (isa<BitCastInst>(I) || isa<GetElementPtrInst>(I)) {
+      } else if (isoneof<BitCastInst, GetElementPtrInst>(I)) {
         replaceInstUsesWith(*I, UndefValue::get(I->getType()));
       }
       eraseInstFromFunction(*I);
     }
 
     if (InvokeInst *II = dyn_cast<InvokeInst>(&MI)) {
       // Replace invoke with a NOP intrinsic to maintain the original CFG
       Module *M = II->getModule();

lib/Transforms/Instrumentation/BoundsChecking.cpp

ObjectSizeOffsetEvaluator TheObjSizeEval(DL, TLI, F.getContext(),
                                            /*RoundToAlign=*/true);
   ObjSizeEval = &TheObjSizeEval;
 
   // check HANDLE_MEMORY_INST in include/llvm/Instruction.def for memory
   // touching instructions
   std::vector<Instruction*> WorkList;
   for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) {
     Instruction *I = &*i;
-    if (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<AtomicCmpXchgInst>(I) ||
+    if (isoneof<LoadInst, StoreInst, AtomicCmpXchgInst>(I) ||
         isa<AtomicRMWInst>(I))
-        WorkList.push_back(I);
   }
 
   bool MadeChange = false;
   for (Instruction *i : WorkList) {
     Inst = i;
 
     Builder->SetInsertPoint(Inst);
     if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

for (Function *i : FnsToInstrument) {
     // instrumentation.
     if (ClDebugNonzeroLabels) {
       for (Value *V : DFSF.NonZeroChecks) {
         Instruction *Pos;
         if (Instruction *I = dyn_cast<Instruction>(V))
           Pos = I->getNextNode();
         else
           Pos = &DFSF.F->getEntryBlock().front();
-        while (isa<PHINode>(Pos) || isa<AllocaInst>(Pos))
+        while (isoneof<PHINode, AllocaInst>(Pos))
           Pos = Pos->getNextNode();
         IRBuilder<> IRB(Pos);
         Value *Ne = IRB.CreateICmpNE(V, DFSF.DFS.ZeroShadow);
         BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
             Ne, Pos, /*Unreachable=*/false, ColdCallWeights));
         IRBuilder<> ThenIRB(BI);
         ThenIRB.CreateCall(DFSF.DFS.DFSanNonzeroLabelFn, {});
       }
if (AllocaInst *AI = dyn_cast<AllocaInst>(Addr)) {
     }
   }
 
   uint64_t ShadowAlign = Align * DFS.ShadowWidth / 8;
   SmallVector<Value *, 2> Objs;
   GetUnderlyingObjects(Addr, Objs, Pos->getModule()->getDataLayout());
   bool AllConstants = true;
   for (Value *Obj : Objs) {
-    if (isa<Function>(Obj) || isa<BlockAddress>(Obj))
+    if (isoneof<Function, BlockAddress>(Obj))
       continue;
     if (isa<GlobalVariable>(Obj) && cast<GlobalVariable>(Obj)->isConstant())
       continue;
 
     AllConstants = false;
     break;
   }
   if (AllConstants)

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

bool EfficiencySanitizer::runOnFunction(Function &F, Module &M) {
   SmallVector<Instruction *, 8> GetElementPtrs;
   bool Res = false;
   const DataLayout &DL = M.getDataLayout();
   const TargetLibraryInfo *TLI =
       &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
   for (auto &BB : F) {
     for (auto &Inst : BB) {
-      if ((isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
-           isa<AtomicRMWInst>(Inst) || isa<AtomicCmpXchgInst>(Inst)) &&
+      if (isoneof<LoadInst, StoreInst, AtomicRMWInst, AtomicCmpXchgInst>(
+              Inst) &&
           !shouldIgnoreMemoryAccess(&Inst))
         LoadsAndStores.push_back(&Inst);
       else if (isa<MemIntrinsic>(Inst))
         MemIntrinCalls.push_back(&Inst);
       else if (isa<GetElementPtrInst>(Inst))
         GetElementPtrs.push_back(&Inst);
       else if (CallInst *CI = dyn_cast<CallInst>(&Inst))
         maybeMarkSanitizerLibraryCallNoBuiltin(CI, TLI);

lib/Transforms/Instrumentation/GCOVProfiling.cpp

for (auto &F : M->functions()) {
       DISubprogram *SP = F.getSubprogram();
       if (!SP) continue;
       if (!functionHasLines(F)) continue;
 
       // gcov expects every function to start with an entry block that has a
       // single successor, so split the entry block to make sure of that.
       BasicBlock &EntryBlock = F.getEntryBlock();
       BasicBlock::iterator It = EntryBlock.begin();
-      while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
+      while (isoneof<AllocaInst, DbgInfoIntrinsic>(*It))
         ++It;
       EntryBlock.splitBasicBlock(It);
 
       Funcs.push_back(make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++,
                                                 Options.UseCfgChecksum,
                                                 Options.ExitBlockBeforeBody));
       GCOVFunction &Func = *Funcs.back();
 

lib/Transforms/Instrumentation/MemorySanitizer.cpp

   /// (initialized).
   Constant *getCleanShadow(Value *V) {
     return getCleanShadow(V->getType());
   }
 
   /// \brief Create a dirty shadow of a given shadow type.
   Constant *getPoisonedShadow(Type *ShadowTy) {
     assert(ShadowTy);
-    if (isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy))
+    if (isoneof<IntegerType, VectorType>(ShadowTy))
       return Constant::getAllOnesValue(ShadowTy);
     if (ArrayType *AT = dyn_cast<ArrayType>(ShadowTy)) {
       SmallVector<Constant *, 4> Vals(AT->getNumElements(),
                                       getPoisonedShadow(AT->getElementType()));
       return ConstantArray::get(AT, Vals);
     }
     if (StructType *ST = dyn_cast<StructType>(ShadowTy)) {
       SmallVector<Constant *, 4> Vals;

     return getShadow(I->getOperand(i));
   }
 
   /// \brief Get the origin for a value.
   Value *getOrigin(Value *V) {
     if (!MS.TrackOrigins) return nullptr;
     if (!PropagateShadow) return getCleanOrigin();
     if (isa<Constant>(V)) return getCleanOrigin();
-    assert((isa<Instruction>(V) || isa<Argument>(V)) &&
+    assert((isoneof<Instruction, Argument>(V)) &&
            "Unexpected value type in getOrigin()");
     Value *Origin = OriginMap[V];
     assert(Origin && "Missing origin");
     return Origin;
   }
 
   /// \brief Get the origin for i-th argument of the instruction I.
   Value *getOrigin(Instruction *I, int i) {
     return getOrigin(I->getOperand(i));
   }
 
   /// \brief Remember the place where a shadow check should be inserted.
   ///
   /// This location will be later instrumented with a check that will print a
   /// UMR warning in runtime if the shadow value is not 0.
   void insertShadowCheck(Value *Shadow, Value *Origin, Instruction *OrigIns) {
     assert(Shadow);
     if (!InsertChecks) return;
 #ifndef NDEBUG
     Type *ShadowTy = Shadow->getType();
-    assert((isa<IntegerType>(ShadowTy) || isa<VectorType>(ShadowTy)) &&
+    assert((isoneof<IntegerType, VectorType>(ShadowTy)) &&
            "Can only insert checks for integer and vector shadow types");
 #endif
     InstrumentationList.push_back(
         ShadowOriginAndInsertPoint(Shadow, Origin, OrigIns));
   }
 
   /// \brief Remember the place where a shadow check should be inserted.
   ///

   ///
   /// Stores the corresponding shadow and (optionally) origin.
   /// Optionally, checks that the store address is fully defined.
   void visitStoreInst(StoreInst &I) {
     StoreList.push_back(&I);
   }
 
   void handleCASOrRMW(Instruction &I) {
-    assert(isa<AtomicRMWInst>(I) || isa<AtomicCmpXchgInst>(I));
+    assert((isoneof<AtomicRMWInst, AtomicCmpXchgInst>(I)));
 
     IRBuilder<> IRB(&I);
     Value *Addr = I.getOperand(0);
     Value *ShadowPtr = getShadowPtr(Addr, I.getType(), IRB);
 
     if (ClCheckAccessAddress)
       insertShadowCheck(Addr, &I);
 

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

bool ThreadSanitizer::runOnFunction(Function &F) {
   const TargetLibraryInfo *TLI =
       &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
   // Traverse all instructions, collect loads/stores/returns, check for calls.
   for (auto &BB : F) {
     for (auto &Inst : BB) {
       if (isAtomic(&Inst))
         AtomicAccesses.push_back(&Inst);
-      else if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
+      else if (isoneof<LoadInst, StoreInst>(Inst))
         LocalLoadsAndStores.push_back(&Inst);
-      else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) {
+      else if (isoneof<CallInst, InvokeInst>(Inst)) {
         if (CallInst *CI = dyn_cast<CallInst>(&Inst))
           maybeMarkSanitizerLibraryCallNoBuiltin(CI, TLI);
         if (isa<MemIntrinsic>(Inst))
           MemIntrinCalls.push_back(&Inst);
         HasCalls = true;
         chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores,
                                        DL);
       }

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

 
     DEBUG(dbgs() << "Visiting: " << *Retain << "\n");
 
     Value *Arg = GetArgRCIdentityRoot(Retain);
 
     // If the object being released is in static or stack storage, we know it's
     // not being managed by ObjC reference counting, so we can delete pairs
     // regardless of what possible decrements or uses lie between them.
-    bool KnownSafe = isa<Constant>(Arg) || isa<AllocaInst>(Arg);
+    bool KnownSafe = isoneof<Constant, AllocaInst>(Arg);
 
     // A constant pointer can't be pointing to an object on the heap. It may
     // be reference-counted, but it won't be deleted.
     if (const LoadInst *LI = dyn_cast<LoadInst>(Arg))
       if (const GlobalVariable *GV =
             dyn_cast<GlobalVariable>(
               GetRCIdentityRoot(LI->getPointerOperand())))
         if (GV->isConstant())

lib/Transforms/Scalar/ADCE.cpp

if (I.isEHPad() || I.mayHaveSideEffects()) {
     // Skip any value profile instrumentation calls if they are
     // instrumenting constants.
     if (isInstrumentsConstant(I))
       return false;
     return true;
   }
   if (!isa<TerminatorInst>(I))
     return false;
-  if (RemoveControlFlowFlag && (isa<BranchInst>(I) || isa<SwitchInst>(I)))
+  if (RemoveControlFlowFlag && isoneof<BranchInst, SwitchInst>(I))
     return false;
   return true;
 }
 
 // Check if this instruction is a runtime call for value profiling and
 // if it's instrumenting a constant.
 bool AggressiveDeadCodeElimination::isInstrumentsConstant(Instruction &I) {
   // TODO -- move this test into llvm::isInstructionTriviallyDead

lib/Transforms/Scalar/DeadStoreElimination.cpp

static void removeAccessedObjects(const MemoryLocation &LoadedLoc,
   const Value *UnderlyingPointer = GetUnderlyingObject(LoadedLoc.Ptr, DL);
 
   // A constant can't be in the dead pointer set.
   if (isa<Constant>(UnderlyingPointer))
     return;
 
   // If the kill pointer can be easily reduced to an alloca, don't bother doing
   // extraneous AA queries.
-  if (isa<AllocaInst>(UnderlyingPointer) || isa<Argument>(UnderlyingPointer)) {
+  if (isoneof<AllocaInst, Argument>(UnderlyingPointer)) {
     DeadStackObjects.remove(const_cast<Value*>(UnderlyingPointer));
     return;
   }
 
   // Remove objects that could alias LoadedLoc.
   DeadStackObjects.remove_if([&](Value *I) {
     // See if the loaded location could alias the stack location.
     MemoryLocation StackLoc(I, getPointerSize(I, DL, *TLI));

lib/Transforms/Scalar/EarlyCSE.cpp

bool isSentinel() const {
     return Inst == DenseMapInfo<Instruction *>::getEmptyKey() ||
            Inst == DenseMapInfo<Instruction *>::getTombstoneKey();
   }
 
   static bool canHandle(Instruction *Inst) {
     // This can only handle non-void readnone functions.
     if (CallInst *CI = dyn_cast<CallInst>(Inst))
       return CI->doesNotAccessMemory() && !CI->getType()->isVoidTy();
-    return isa<CastInst>(Inst) || isa<BinaryOperator>(Inst) ||
-           isa<GetElementPtrInst>(Inst) || isa<CmpInst>(Inst) ||
-           isa<SelectInst>(Inst) || isa<ExtractElementInst>(Inst) ||
-           isa<InsertElementInst>(Inst) || isa<ShuffleVectorInst>(Inst) ||
-           isa<ExtractValueInst>(Inst) || isa<InsertValueInst>(Inst);
+    return isoneof<CastInst, BinaryOperator, GetElementPtrInst, CmpInst,
+                   SelectInst, ExtractElementInst, InsertElementInst,
+                   ShuffleVectorInst, ExtractValueInst, InsertValueInst>(Inst);
   }
 };
 }
 
 namespace llvm {
 template <> struct DenseMapInfo<SimpleValue> {
   static inline SimpleValue getEmptyKey() {
     return DenseMapInfo<Instruction *>::getEmptyKey();
if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst))
     return hash_combine(EVI->getOpcode(), EVI->getOperand(0),
                         hash_combine_range(EVI->idx_begin(), EVI->idx_end()));
 
   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst))
     return hash_combine(IVI->getOpcode(), IVI->getOperand(0),
                         IVI->getOperand(1),
                         hash_combine_range(IVI->idx_begin(), IVI->idx_end()));
 
-  assert((isa<CallInst>(Inst) || isa<BinaryOperator>(Inst) ||
-          isa<GetElementPtrInst>(Inst) || isa<SelectInst>(Inst) ||
-          isa<ExtractElementInst>(Inst) || isa<InsertElementInst>(Inst) ||
-          isa<ShuffleVectorInst>(Inst)) &&
+  assert((isoneof<CallInst, BinaryOperator, GetElementPtrInst, SelectInst,
+                  ExtractElementInst, InsertElementInst, ShuffleVectorInst>(
+             Inst)) &&
          "Invalid/unknown instruction");
 
   // Mix in the opcode.
   return hash_combine(
       Inst->getOpcode(),
       hash_combine_range(Inst->value_op_begin(), Inst->value_op_end()));
 }
 

lib/Transforms/Scalar/GVN.cpp

static void reportMayClobberedLoad(LoadInst *LI, MemDepResult DepInfo,
   using namespace ore;
   User *OtherAccess = nullptr;
 
   OptimizationRemarkMissed R(DEBUG_TYPE, "LoadClobbered", LI);
   R << "load of type " << NV("Type", LI->getType()) << " not eliminated"
     << setExtraArgs();
 
   for (auto *U : LI->getPointerOperand()->users())
-    if (U != LI && (isa<LoadInst>(U) || isa<StoreInst>(U)) &&
+    if (U != LI && isoneof<LoadInst, StoreInst>(U) &&
         DT->dominates(cast<Instruction>(U), LI)) {
       // FIXME: for now give up if there are multiple memory accesses that
       // dominate the load.  We need further analysis to decide which one is
       // that we're forwarding from.
       if (OtherAccess)
         OtherAccess = nullptr;
       else
         OtherAccess = U;
while (!Worklist.empty()) {
 
     // Don't try to propagate equalities between constants.
     if (isa<Constant>(LHS) && isa<Constant>(RHS))
       continue;
 
     // Prefer a constant on the right-hand side, or an Argument if no constants.
     if (isa<Constant>(LHS) || (isa<Argument>(LHS) && !isa<Constant>(RHS)))
       std::swap(LHS, RHS);
-    assert((isa<Argument>(LHS) || isa<Instruction>(LHS)) && "Unexpected value!");
+    assert((isoneof<Argument, Instruction>(LHS)) && "Unexpected value!");
 
     // If there is no obvious reason to prefer the left-hand side over the
     // right-hand side, ensure the longest lived term is on the right-hand side,
     // so the shortest lived term will be replaced by the longest lived.
     // This tends to expose more simplifications.
     uint32_t LVN = VN.lookupOrAdd(LHS);
     if ((isa<Argument>(LHS) && isa<Argument>(RHS)) ||
         (isa<Instruction>(LHS) && isa<Instruction>(RHS))) {
bool GVN::processInstruction(Instruction *I) {
   if (I->getType()->isVoidTy())
     return false;
 
   uint32_t NextNum = VN.getNextUnusedValueNumber();
   unsigned Num = VN.lookupOrAdd(I);
 
   // Allocations are always uniquely numbered, so we can save time and memory
   // by fast failing them.
-  if (isa<AllocaInst>(I) || isa<TerminatorInst>(I) || isa<PHINode>(I)) {
+  if (isoneof<AllocaInst, TerminatorInst, PHINode>(I)) {
     addToLeaderTable(Num, I, I->getParent());
     return false;
   }
 
   // If the number we were assigned was a brand new VN, then we don't
   // need to do a lookup to see if the number already exists
   // somewhere in the domtree: it can't!
   if (Num >= NextNum) {
bool GVN::performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
                                     unsigned int ValNo) {
   // Because we are going top-down through the block, all value numbers
   // will be available in the predecessor by the time we need them.  Any
   // that weren't originally present will have been instantiated earlier
   // in this loop.
   bool success = true;
   for (unsigned i = 0, e = Instr->getNumOperands(); i != e; ++i) {
     Value *Op = Instr->getOperand(i);
-    if (isa<Argument>(Op) || isa<Constant>(Op) || isa<GlobalValue>(Op))
+    if (isoneof<Argument, Constant, GlobalValue>(Op))
       continue;
     // This could be a newly inserted instruction, in which case, we won't
     // find a value number, and should give up before we hurt ourselves.
     // FIXME: Rewrite the infrastructure to let it easier to value number
     // and process newly inserted instructions.
     if (!VN.exists(Op)) {
       success = false;
       break;
bool GVN::performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
   VN.add(Instr, ValNo);
 
   // Update the availability map to include the new instruction.
   addToLeaderTable(ValNo, Instr, Pred);
   return true;
 }
 
 bool GVN::performScalarPRE(Instruction *CurInst) {
-  if (isa<AllocaInst>(CurInst) || isa<TerminatorInst>(CurInst) ||
-      isa<PHINode>(CurInst) || CurInst->getType()->isVoidTy() ||
-      CurInst->mayReadFromMemory() || CurInst->mayHaveSideEffects() ||
-      isa<DbgInfoIntrinsic>(CurInst))
+  if (isoneof<AllocaInst, TerminatorInst, PHINode>(CurInst) ||
+      CurInst->getType()->isVoidTy() || CurInst->mayReadFromMemory() ||
+      CurInst->mayHaveSideEffects() || isa<DbgInfoIntrinsic>(CurInst))
     return false;
 
   // Don't do PRE on compares. The PHI would prevent CodeGenPrepare from
   // sinking the compare again, and it would force the code generator to
   // move the i1 from processor flags or predicate registers into a general
   // purpose register.
   if (isa<CmpInst>(CurInst))
     return false;

lib/Transforms/Scalar/IndVarSimplify.cpp

 
   // Conservatively handle non-constant non-instructions. For example, Arguments
   // may be undef.
   Instruction *I = dyn_cast<Instruction>(V);
   if (!I)
     return false;
 
   // Load and return values may be undef.
-  if(I->mayReadFromMemory() || isa<CallInst>(I) || isa<InvokeInst>(I))
+  if (I->mayReadFromMemory() || isoneof<CallInst, InvokeInst>(I))
     return false;
 
   // Optimistically handle other instructions.
   for (Value *Op : I->operands()) {
     if (!Visited.insert(Op).second)
       continue;
     if (!hasConcreteDefImpl(Op, Visited, Depth+1))
       return false;

lib/Transforms/Scalar/LoadCombine.cpp

 PointerOffsetPair LoadCombine::getPointerOffsetPair(LoadInst &LI) {
   auto &DL = LI.getModule()->getDataLayout();
 
   PointerOffsetPair POP;
   POP.Pointer = LI.getPointerOperand();
   unsigned BitWidth = DL.getPointerSizeInBits(LI.getPointerAddressSpace());
   POP.Offset = APInt(BitWidth, 0);
 
-  while (isa<BitCastInst>(POP.Pointer) || isa<GetElementPtrInst>(POP.Pointer)) {
+  while (isoneof<BitCastInst, GetElementPtrInst>(POP.Pointer)) {
     if (auto *GEP = dyn_cast<GetElementPtrInst>(POP.Pointer)) {
       APInt LastOffset = POP.Offset;
       if (!GEP->accumulateConstantOffset(DL, POP.Offset)) {
         // Can't handle GEPs with variable indices.
         POP.Offset = LastOffset;
         return POP;
       }
       POP.Pointer = GEP->getPointerOperand();

lib/Transforms/Scalar/LoopInterchange.cpp

if (!InnerIndexVarInc)
     return true;
 
   // Since we split the inner loop latch on this induction variable. Make sure
   // we do not have any instruction between the induction variable and branch
   // instruction.
 
   bool FoundInduction = false;
   for (const Instruction &I : reverse(*InnerLoopLatch)) {
-    if (isa<BranchInst>(I) || isa<CmpInst>(I) || isa<TruncInst>(I))
+    if (isoneof<BranchInst, CmpInst, TruncInst>(I))
       continue;
     // We found an instruction. If this is not induction variable then it is not
     // safe to split this loop latch.
     if (!I.isIdenticalTo(InnerIndexVarInc))
       return true;
 
     FoundInduction = true;
     break;

lib/Transforms/Scalar/LoopStrengthReduce.cpp

           return;
       }
     }
   }
   ++NumRegs;
 
   // Rough heuristic; favor registers which don't require extra setup
   // instructions in the preheader.
-  if (!isa<SCEVUnknown>(Reg) &&
-      !isa<SCEVConstant>(Reg) &&
-      !(isa<SCEVAddRecExpr>(Reg) &&
-        (isa<SCEVUnknown>(cast<SCEVAddRecExpr>(Reg)->getStart()) ||
-         isa<SCEVConstant>(cast<SCEVAddRecExpr>(Reg)->getStart()))))
+  if (!isa<SCEVUnknown>(Reg) && !isa<SCEVConstant>(Reg) &&
+      !(isa<SCEVAddRecExpr>(Reg) && isoneof<SCEVUnknown, SCEVConstant>(
+                                        cast<SCEVAddRecExpr>(Reg)->getStart())))
     ++SetupCost;
 
   NumIVMuls += isa<SCEVMulExpr>(Reg) &&
                SE.hasComputableLoopEvolution(Reg, L);
 }
 
 /// Record this register in the set. If we haven't seen it before, rate
 /// it. Optional LoserRegs provides a way to declare any formula that refers to

     if (F.BaseGV)
       ImmCost += 64; // Handle symbolic values conservatively.
                      // TODO: This should probably be the pointer size.
     else if (Offset != 0)
       ImmCost += APInt(64, Offset, true).getMinSignedBits();
 
     // Check with target if this offset with this instruction is
     // specifically not supported.
-    if ((isa<LoadInst>(Fixup.UserInst) || isa<StoreInst>(Fixup.UserInst)) &&
+    if (isoneof<LoadInst, StoreInst>(Fixup.UserInst) &&
         !TTI.isFoldableMemAccessOffset(Fixup.UserInst, Offset))
       NumBaseAdds++;
   }
 
   // If ICmpZero formula ends with not 0, it could not be replaced by
   // just add or sub. We'll need to compare final result of AddRec.
   // That means we'll need an additional instruction.
   // For -10 + {0, +, 1}:

       DEBUG(dbgs() << "LSR skipping loop, too many IV Users in " << U << "\n");
       return;
     }
     // Bail out if we have a PHI on an EHPad that gets a value from a
     // CatchSwitchInst.  Because the CatchSwitchInst cannot be split, there is
     // no good place to stick any instructions.
     if (auto *PN = dyn_cast<PHINode>(U.getUser())) {
        auto *FirstNonPHI = PN->getParent()->getFirstNonPHI();
-       if (isa<FuncletPadInst>(FirstNonPHI) ||
-           isa<CatchSwitchInst>(FirstNonPHI))
+       if (isoneof<FuncletPadInst, CatchSwitchInst>(FirstNonPHI))
          for (BasicBlock *PredBB : PN->blocks())
            if (isa<CatchSwitchInst>(PredBB->getFirstNonPHI()))
              return;
     }
   }
 
 #ifndef NDEBUG
   // All dominating loops must have preheaders, or SCEVExpander may not be able

lib/Transforms/Scalar/MemCpyOptimizer.cpp

if (MayAlias) {
       if (AA.getModRefInfo(C, LoadLoc) & MRI_Mod)
         return false;
       else if (auto CS = ImmutableCallSite(C)) {
         // If we can't lift this before P, it's game over.
         if (AA.getModRefInfo(P, CS) != MRI_NoModRef)
           return false;
 
         CallSites.push_back(CS);
-      } else if (isa<LoadInst>(C) || isa<StoreInst>(C) || isa<VAArgInst>(C)) {
+      } else if (isoneof<LoadInst, StoreInst, VAArgInst>(C)) {
         // If we can't lift this before P, it's game over.
         auto ML = MemoryLocation::get(C);
         if (AA.getModRefInfo(P, ML) != MRI_NoModRef)
           return false;
 
         MemLocs.push_back(ML);
       } else
         // We don't know how to lift this instruction.
bool MemCpyOptPass::performCallSlotOptzn(Instruction *cpy, Value *cpyDest,
   // guarantees that it holds only undefined values when passed in (so the final
   // memcpy can be dropped), that it is not read or written between the call and
   // the memcpy, and that writing beyond the end of it is undefined.
   SmallVector<User*, 8> srcUseList(srcAlloca->user_begin(),
                                    srcAlloca->user_end());
   while (!srcUseList.empty()) {
     User *U = srcUseList.pop_back_val();
 
-    if (isa<BitCastInst>(U) || isa<AddrSpaceCastInst>(U)) {
+    if (isoneof<BitCastInst, AddrSpaceCastInst>(U)) {
       for (User *UU : U->users())
         srcUseList.push_back(UU);
       continue;
     }
     if (GetElementPtrInst *G = dyn_cast<GetElementPtrInst>(U)) {
       if (!G->hasAllZeroIndices())
         return false;
 

lib/Transforms/Scalar/NewGVN.cpp

PHIExpression *NewGVN::createPHIExpression(Instruction *I, bool &HasBackedge,
   });
 
   std::transform(Filtered.begin(), Filtered.end(), op_inserter(E),
                  [&](const Use *U) -> Value * {
                    auto *BB = PN->getIncomingBlock(*U);
                    auto *DTN = DT->getNode(BB);
                    if (RPOOrdering.lookup(DTN) >= PHIRPO)
                      HasBackedge = true;
-                   AllConstant &= isa<UndefValue>(*U) || isa<Constant>(*U);
+                   AllConstant &= isoneof<UndefValue, Constant>(*U);
 
                    // Don't try to transform self-defined phis.
                    if (*U == PN)
                      return PN;
                    return lookupOperandLeader(*U);
                  });
   return E;
 }
if (auto *C = dyn_cast<Constant>(V)) {
     if (I)
       DEBUG(dbgs() << "Simplified " << *I << " to "
                    << " constant " << *C << "\n");
     NumGVNOpsSimplified++;
     assert(isa<BasicExpression>(E) &&
            "We should always have had a basic expression here");
     deleteExpression(E);
     return createConstantExpression(C);
-  } else if (isa<Argument>(V) || isa<GlobalVariable>(V)) {
+  } else if (isoneof<Argument, GlobalVariable>(V)) {
     if (I)
       DEBUG(dbgs() << "Simplified " << *I << " to "
                    << " variable " << *V << "\n");
     deleteExpression(E);
     return createVariableExpression(V);
   }
 
   CongruenceClass *CC = ValueToClass.lookup(V);
const Expression *NewGVN::performSymbolicCmpEvaluation(Instruction *I) const {
   return createExpression(I);
 }
 
 // Substitute and symbolize the value before value numbering.
 const Expression *NewGVN::performSymbolicEvaluation(Value *V) const {
   const Expression *E = nullptr;
   if (auto *C = dyn_cast<Constant>(V))
     E = createConstantExpression(C);
-  else if (isa<Argument>(V) || isa<GlobalVariable>(V)) {
+  else if (isoneof<Argument, GlobalVariable>(V)) {
     E = createVariableExpression(V);
   } else {
     // TODO: memory intrinsics.
     // TODO: Some day, we should do the forward propagation and reassociation
     // parts of the algorithm.
     auto *I = cast<Instruction>(V);
     switch (I->getOpcode()) {
     case Instruction::ExtractValue:
bool NewGVN::runGVN() {
   cleanupTables();
   return Changed;
 }
 
 // Return true if V is a value that will always be available (IE can
 // be placed anywhere) in the function.  We don't do globals here
 // because they are often worse to put in place.
 // TODO: Separate cost from availability
-static bool alwaysAvailable(Value *V) {
-  return isa<Constant>(V) || isa<Argument>(V);
-}
+static bool alwaysAvailable(Value *V) { return isoneof<Constant, Argument>(V); }
 
 struct NewGVN::ValueDFS {
   int DFSIn = 0;
   int DFSOut = 0;
   int LocalNum = 0;
   // Only one of Def and U will be set.
   // The bool in the Def tells us whether the Def is the stored value of a
   // store.

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

findBaseDefiningValueOfVector(Value *I) {
 
   // The behavior of getelementptr instructions is the same for vector and
   // non-vector data types.
   if (auto *GEP = dyn_cast<GetElementPtrInst>(I))
     return findBaseDefiningValue(GEP->getPointerOperand());
 
   // A PHI or Select is a base defining value.  The outer findBasePointer
   // algorithm is responsible for constructing a base value for this BDV.
-  assert((isa<SelectInst>(I) || isa<PHINode>(I)) &&
+  assert((isoneof<SelectInst, PHINode>(I)) &&
          "unknown vector instruction - no base found for vector element");
   return BaseDefiningValueResult(I, false);
 }
 
 /// Helper function for findBasePointer - Will return a value which either a)
 /// defines the base pointer for the input, b) blocks the simple search
 /// (i.e. a PHI or Select of two derived pointers), or c) involves a change
 /// from pointer to vector type or back.
case Intrinsic::gcroot:
       // implications much.
       llvm_unreachable(
           "interaction with the gcroot mechanism is not supported");
     }
   }
   // We assume that functions in the source language only return base
   // pointers.  This should probably be generalized via attributes to support
   // both source language and internal functions.
-  if (isa<CallInst>(I) || isa<InvokeInst>(I))
+  if (isoneof<CallInst, InvokeInst>(I))
     return BaseDefiningValueResult(I, true);
 
   // TODO: I have absolutely no idea how to implement this part yet.  It's not
   // necessarily hard, I just haven't really looked at it yet.
   assert(!isa<LandingPadInst>(I) && "Landing Pad is unimplemented");
 
   if (isa<AtomicCmpXchgInst>(I))
     // A CAS is effectively a atomic store and load combined under a
if (isa<ExtractElementInst>(I))
     // handled after the main base pointer inference algorithm to make writing
     // test cases to exercise that code easier.
     return BaseDefiningValueResult(I, false);
 
   // The last two cases here don't return a base pointer.  Instead, they
   // return a value which dynamically selects from among several base
   // derived pointers (each with it's own base potentially).  It's the job of
   // the caller to resolve these.
-  assert((isa<SelectInst>(I) || isa<PHINode>(I)) &&
+  assert((isoneof<SelectInst, PHINode>(I)) &&
          "missing instruction case in findBaseDefiningValing");
   return BaseDefiningValueResult(I, false);
 }
 
 /// Returns the base defining value for this value.
 static Value *findBaseDefiningValueCached(Value *I, DefiningValueMapTy &Cache) {
   Value *&Cached = Cache[I];
   if (!Cached) {
static Value *findBasePointer(Value *I, DefiningValueMapTy &Cache) {
   //
   // Note: A simpler form of this would be to add the conflict form of all
   // PHIs without running the optimistic algorithm.  This would be
   // analogous to pessimistic data flow and would likely lead to an
   // overall worse solution.
 
 #ifndef NDEBUG
   auto isExpectedBDVType = [](Value *BDV) {
-    return isa<PHINode>(BDV) || isa<SelectInst>(BDV) ||
-           isa<ExtractElementInst>(BDV) || isa<InsertElementInst>(BDV) ||
-           isa<ShuffleVectorInst>(BDV);
+    return isoneof<PHINode, SelectInst, ExtractElementInst, InsertElementInst,
+                   ShuffleVectorInst>(BDV);
   };
 #endif
 
   // Once populated, will contain a mapping from each potentially non-base BDV
   // to a lattice value (described above) which corresponds to that BDV.
   // We use the order of insertion (DFS over the def/use graph) to provide a
   // stable deterministic ordering for visiting DenseMaps (which are unordered)
   // below.  This is important for deterministic compilation.
auto rematerializeChain = [&ChainToBase](
         Instruction *InsertBefore, Value *RootOfChain, Value *AlternateLiveBase) {
       Instruction *LastClonedValue = nullptr;
       Instruction *LastValue = nullptr;
       for (Instruction *Instr: ChainToBase) {
         // Only GEP's and casts are suported as we need to be careful to not
         // introduce any new uses of pointers not in the liveset.
         // Note that it's fine to introduce new uses of pointers which were
         // otherwise not used after this statepoint.
-        assert(isa<GetElementPtrInst>(Instr) || isa<CastInst>(Instr));
+        assert((isoneof<GetElementPtrInst, CastInst>(Instr)));
 
         Instruction *ClonedValue = Instr->clone();
         ClonedValue->insertBefore(InsertBefore);
         ClonedValue->setName(Instr->getName() + ".remat");
 
         // If it is not first instruction in the chain then it uses previously
         // cloned value. We should update it to use cloned value.
         if (LastClonedValue) {

lib/Transforms/Scalar/SCCP.cpp

         // Tracked calls must never be marked overdefined in ResolvedUndefsIn.
         if (CallSite CS = CallSite(&I))
           if (Function *F = CS.getCalledFunction())
             if (MRVFunctionsTracked.count(F))
               continue;
 
         // extractvalue and insertvalue don't need to be marked; they are
         // tracked as precisely as their operands.
-        if (isa<ExtractValueInst>(I) || isa<InsertValueInst>(I))
+        if (isoneof<ExtractValueInst, InsertValueInst>(I))
           continue;
 
         // Send the results of everything else to overdefined.  We could be
         // more precise than this but it isn't worth bothering.
         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
           LatticeVal &LV = getStructValueState(&I, i);
           if (LV.isUnknown())
             markOverdefined(LV, &I);

   // Delete any dead constantexpr klingons.
   GV->removeDeadConstantUsers();
 
   for (const Use &U : GV->uses()) {
     const User *UR = U.getUser();
     if (const auto *SI = dyn_cast<StoreInst>(UR)) {
       if (SI->getOperand(0) == GV || SI->isVolatile())
         return true;  // Storing addr of GV.
-    } else if (isa<InvokeInst>(UR) || isa<CallInst>(UR)) {
+    } else if (ImmutableCallSite CS{UR}) {
       // Make sure we are calling the function, not passing the address.
-      ImmutableCallSite CS(cast<Instruction>(UR));
       if (!CS.isCallee(&U))
         return true;
     } else if (const auto *LI = dyn_cast<LoadInst>(UR)) {
       if (LI->isVolatile())
         return true;
     } else if (isa<BlockAddress>(UR)) {
       // blockaddress doesn't take the address of the function, it takes addr
       // of label.

lib/Transforms/Scalar/SROA.cpp

         if (Visited.insert(cast<Instruction>(U)).second)
           Uses.push_back(std::make_pair(I, cast<Instruction>(U)));
     } while (!Uses.empty());
 
     return nullptr;
   }
 
   void visitPHINodeOrSelectInst(Instruction &I) {
-    assert(isa<PHINode>(I) || isa<SelectInst>(I));
+    assert((isoneof<PHINode, SelectInst>(I)));
     if (I.use_empty())
       return markAsDead(I);
 
     // TODO: We could use SimplifyInstruction here to fold PHINodes and
     // SelectInsts. However, doing so requires to change the current
     // dead-operand-tracking mechanism. For instance, suppose neither loading
     // from %U nor %other traps. Then "load (select undef, %U, %other)" does not
     // trap either.  However, if we simply replace %U with undef using the

       continue;
     // FIXME: We currently leave whole-alloca splittable loads and stores. This
     // used to be the only splittable loads and stores and we need to be
     // confident that the above handling of splittable loads and stores is
     // completely sufficient before we forcibly disable the remaining handling.
     if (S.beginOffset() == 0 &&
         S.endOffset() >= DL.getTypeAllocSize(AI.getAllocatedType()))
       continue;
-    if (isa<LoadInst>(S.getUse()->getUser()) ||
-        isa<StoreInst>(S.getUse()->getUser())) {
+    if (isoneof<LoadInst, StoreInst>(S.getUse()->getUser())) {
       S.makeUnsplittable();
       IsSorted = false;
     }
   }
   if (!IsSorted)
     std::sort(AS.begin(), AS.end());
 
   /// Describes the allocas introduced by rewritePartition in order to migrate

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

ConstantOffsetExtractor::distributeExtsAndCloneChain(unsigned ChainIndex) {
   User *U = UserChain[ChainIndex];
   if (ChainIndex == 0) {
     assert(isa<ConstantInt>(U));
     // If U is a ConstantInt, applyExts will return a ConstantInt as well.
     return UserChain[ChainIndex] = cast<ConstantInt>(applyExts(U));
   }
 
   if (CastInst *Cast = dyn_cast<CastInst>(U)) {
-    assert((isa<SExtInst>(Cast) || isa<ZExtInst>(Cast)) &&
+    assert((isoneof<SExtInst, ZExtInst>(Cast)) &&
            "We only traced into two types of CastInst: sext and zext");
     ExtInsts.push_back(Cast);
     UserChain[ChainIndex] = nullptr;
     return distributeExtsAndCloneChain(ChainIndex - 1);
   }
 
   // Function find only trace into BinaryOperator and CastInst.
   BinaryOperator *BO = cast<BinaryOperator>(U);

lib/Transforms/Scalar/Sink.cpp

static bool isSafeToMove(Instruction *Inst, AliasAnalysis &AA,
 
   if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
     MemoryLocation Loc = MemoryLocation::get(L);
     for (Instruction *S : Stores)
       if (AA.getModRefInfo(S, Loc) & MRI_Mod)
         return false;
   }
 
-  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst) || Inst->isEHPad() ||
+  if (isoneof<TerminatorInst, PHINode>(Inst) || Inst->isEHPad() ||
       Inst->mayThrow())
     return false;
 
   if (auto CS = CallSite(Inst)) {
     // Convergent operations cannot be made control-dependent on additional
     // values.
     if (CS.hasFnAttr(Attribute::Convergent))
       return false;

lib/Transforms/Utils/CodeExtractor.cpp

 /// \brief Test whether a block is valid for extraction.
 bool CodeExtractor::isBlockValidForExtraction(const BasicBlock &BB) {
   // Landing pads must be in the function where they were inserted for cleanup.
   if (BB.isEHPad())
     return false;
 
   // Don't hoist code containing allocas, invokes, or vastarts.
   for (BasicBlock::const_iterator I = BB.begin(), E = BB.end(); I != E; ++I) {
-    if (isa<AllocaInst>(I) || isa<InvokeInst>(I))
+    if (isoneof<AllocaInst, InvokeInst>(I))
       return false;
     if (const CallInst *CI = dyn_cast<CallInst>(I))
       if (const Function *F = CI->getCalledFunction())
         if (F->getIntrinsicID() == Intrinsic::vastart)
           return false;
   }
 
   return true;

lib/Transforms/Utils/Evaluator.cpp

if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
         return false;  // Cannot handle array allocs.
       }
       Type *Ty = AI->getAllocatedType();
       AllocaTmps.push_back(
           make_unique<GlobalVariable>(Ty, false, GlobalValue::InternalLinkage,
                                       UndefValue::get(Ty), AI->getName()));
       InstResult = AllocaTmps.back().get();
       DEBUG(dbgs() << "Found an alloca. Result: " << *InstResult << "\n");
-    } else if (isa<CallInst>(CurInst) || isa<InvokeInst>(CurInst)) {
-      CallSite CS(&*CurInst);
+    } else if (CallSite CS{&*CurInst}) {
 
       // Debug info can safely be ignored here.
       if (isa<DbgInfoIntrinsic>(CS.getInstruction())) {
         DEBUG(dbgs() << "Ignoring debug info.\n");
         ++CurInst;
         continue;
       }
 

lib/Transforms/Utils/InlineFunction.cpp

if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(CurrentPad)) {
             UnwindDestToken = RetUnwindDest->getFirstNonPHI();
           else
             UnwindDestToken = ConstantTokenNone::get(CleanupPad->getContext());
           break;
         }
         Value *ChildUnwindDestToken;
         if (auto *Invoke = dyn_cast<InvokeInst>(U)) {
           ChildUnwindDestToken = Invoke->getUnwindDest()->getFirstNonPHI();
-        } else if (isa<CleanupPadInst>(U) || isa<CatchSwitchInst>(U)) {
+        } else if (isoneof<CleanupPadInst, CatchSwitchInst>(U)) {
           Instruction *ChildPad = cast<Instruction>(U);
           auto Memo = MemoMap.find(ChildPad);
           if (Memo == MemoMap.end()) {
             // Haven't resolved this child yet; queue it and keep searching.
             Worklist.push_back(ChildPad);
             continue;
           }
           // We've checked this child, but still need to ignore it if it
if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(UselessPad)) {
         auto *CatchPad = HandlerBlock->getFirstNonPHI();
         for (User *U : CatchPad->users()) {
           assert(
               (!isa<InvokeInst>(U) ||
                (getParentPad(
                     cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
                 CatchPad)) &&
               "Expected useless pad");
-          if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
+          if (isoneof<CatchSwitchInst, CleanupPadInst>(U))
             Worklist.push_back(cast<Instruction>(U));
         }
       }
     } else {
       assert(isa<CleanupPadInst>(UselessPad));
       for (User *U : UselessPad->users()) {
         assert(!isa<CleanupReturnInst>(U) && "Expected useless pad");
         assert((!isa<InvokeInst>(U) ||
                 (getParentPad(
                      cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
                  UselessPad)) &&
                "Expected useless pad");
-        if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
+        if (isoneof<CatchSwitchInst, CleanupPadInst>(U))
           Worklist.push_back(cast<Instruction>(U));
       }
     }
   }
 
   return UnwindDestToken;
 }
 
if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
 
       // Figure out if we're derived from anything that is not a noalias
       // argument.
       bool CanDeriveViaCapture = false, UsesAliasingPtr = false;
       for (const Value *V : ObjSet) {
         // Is this value a constant that cannot be derived from any pointer
         // value (we need to exclude constant expressions, for example, that
         // are formed from arithmetic on global symbols).
-        bool IsNonPtrConst = isa<ConstantInt>(V) || isa<ConstantFP>(V) ||
-                             isa<ConstantPointerNull>(V) ||
-                             isa<ConstantDataVector>(V) || isa<UndefValue>(V);
+        bool IsNonPtrConst =
+            isoneof<ConstantInt, ConstantFP, ConstantPointerNull,
+                    ConstantDataVector, UndefValue>(V);
         if (IsNonPtrConst)
           continue;
 
         // If this is anything other than a noalias argument, then we cannot
         // completely describe the aliasing properties using alias.scope
         // metadata (and, thus, won't add any).
         if (const Argument *A = dyn_cast<Argument>(V)) {
           if (!A->hasNoAliasAttr())

lib/Transforms/Utils/Local.cpp

               Changed = true;
               break;
             }
         }
       }
 
       if (auto *CI = dyn_cast<CallInst>(&I)) {
         Value *Callee = CI->getCalledValue();
-        if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
+        if (isoneof<ConstantPointerNull, UndefValue>(Callee)) {
           changeToUnreachable(CI, /*UseLLVMTrap=*/false);
           Changed = true;
           break;
         }
         if (CI->doesNotReturn()) {
           // If we found a call to a no-return function, insert an unreachable
           // instruction after it.  Make sure there isn't *already* one there
           // though.

         }
       }
     }
 
     TerminatorInst *Terminator = BB->getTerminator();
     if (auto *II = dyn_cast<InvokeInst>(Terminator)) {
       // Turn invokes that call 'nounwind' functions into ordinary calls.
       Value *Callee = II->getCalledValue();
-      if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
+      if (isoneof<ConstantPointerNull, UndefValue>(Callee)) {
         changeToUnreachable(II, true);
         Changed = true;
       } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
         if (II->use_empty() && II->onlyReadsMemory()) {
           // jump to the normal destination branch.
           BranchInst::Create(II->getNormalDest(), II);
           II->getUnwindDest()->removePredecessor(II->getParent());
           II->eraseFromParent();

   }
   // Set !invariant.group from J if J has it. If both instructions have it
   // then we will just pick it from J - even when they are different.
   // Also make sure that K is load or store - f.e. combining bitcast with load
   // could produce bitcast with invariant.group metadata, which is invalid.
   // FIXME: we should try to preserve both invariant.group md if they are
   // different, but right now instruction can only have one invariant.group.
   if (auto *JMD = J->getMetadata(LLVMContext::MD_invariant_group))
-    if (isa<LoadInst>(K) || isa<StoreInst>(K))
+    if (isoneof<LoadInst, StoreInst>(K))
       K->setMetadata(LLVMContext::MD_invariant_group, JMD);
 }
 
 void llvm::combineMetadataForCSE(Instruction *K, const Instruction *J) {
   unsigned KnownIDs[] = {
       LLVMContext::MD_tbaa,            LLVMContext::MD_alias_scope,
       LLVMContext::MD_noalias,         LLVMContext::MD_range,
       LLVMContext::MD_invariant_load,  LLVMContext::MD_nonnull,

lib/Transforms/Utils/LoopUtils.cpp

while (!Worklist.empty()) {
     if (!IsAPhi && Kind != RK_IntegerMinMax && Kind != RK_FloatMinMax &&
         hasMultipleUsesOf(Cur, VisitedInsts))
       return false;
 
     // All inputs to a PHI node must be a reduction value.
     if (IsAPhi && Cur != Phi && !areAllUsesIn(Cur, VisitedInsts))
       return false;
 
-    if (Kind == RK_IntegerMinMax &&
-        (isa<ICmpInst>(Cur) || isa<SelectInst>(Cur)))
+    if (Kind == RK_IntegerMinMax && isoneof<ICmpInst, SelectInst>(Cur))
       ++NumCmpSelectPatternInst;
-    if (Kind == RK_FloatMinMax && (isa<FCmpInst>(Cur) || isa<SelectInst>(Cur)))
+    if (Kind == RK_FloatMinMax && isoneof<FCmpInst, SelectInst>(Cur))
       ++NumCmpSelectPatternInst;
 
     // Check  whether we found a reduction operator.
     FoundReduxOp |= !IsAPhi && Cur != Start;
 
     // Process users of current instruction. Push non-PHI nodes after PHI nodes
     // onto the stack. This way we are going to have seen all inputs to PHI
     // nodes once we get to them.
bool RecurrenceDescriptor::AddReductionVar(PHINode *Phi, RecurrenceKind Kind,
   return true;
 }
 
 /// Returns true if the instruction is a Select(ICmp(X, Y), X, Y) instruction
 /// pattern corresponding to a min(X, Y) or max(X, Y).
 RecurrenceDescriptor::InstDesc
 RecurrenceDescriptor::isMinMaxSelectCmpPattern(Instruction *I, InstDesc &Prev) {
 
-  assert((isa<ICmpInst>(I) || isa<FCmpInst>(I) || isa<SelectInst>(I)) &&
+  assert((isoneof<ICmpInst, FCmpInst, SelectInst>(I)) &&
          "Expect a select instruction");
   Instruction *Cmp = nullptr;
   SelectInst *Select = nullptr;
 
   // We must handle the select(cmp()) as a single instruction. Advance to the
   // select.
   if ((Cmp = dyn_cast<ICmpInst>(I)) || (Cmp = dyn_cast<FCmpInst>(I))) {
     if (!Cmp->hasOneUse() || !(Select = dyn_cast<SelectInst>(*I->user_begin())))

lib/Transforms/Utils/PredicateInfo.cpp

void collectCmpOps(CmpInst *Comparison, SmallVectorImpl<Value *> &CmpOperands) {
   auto *Op1 = Comparison->getOperand(1);
   if (Op0 == Op1)
     return;
   CmpOperands.push_back(Comparison);
   // Only want real values, not constants.  Additionally, operands with one use
   // are only being used in the comparison, which means they will not be useful
   // for us to consider for predicateinfo.
   //
-  if ((isa<Instruction>(Op0) || isa<Argument>(Op0)) && !Op0->hasOneUse())
+  if (isoneof<Instruction, Argument>(Op0) && !Op0->hasOneUse())
     CmpOperands.push_back(Op0);
-  if ((isa<Instruction>(Op1) || isa<Argument>(Op1)) && !Op1->hasOneUse())
+  if (isoneof<Instruction, Argument>(Op1) && !Op1->hasOneUse())
     CmpOperands.push_back(Op1);
 }
 
 // Add Op, PB to the list of value infos for Op, and mark Op to be renamed.
 void PredicateInfo::addInfoFor(SmallPtrSetImpl<Value *> &OpsToRename, Value *Op,
                                PredicateBase *PB) {
   OpsToRename.insert(Op);
   auto &OperandInfo = getOrCreateValueInfo(Op);
for (auto Cond : ConditionsToProcess) {
     CmpOperands.clear();
   }
 }
 // Process a block terminating switch, and place relevant operations to be
 // renamed into OpsToRename.
 void PredicateInfo::processSwitch(SwitchInst *SI, BasicBlock *BranchBB,
                                   SmallPtrSetImpl<Value *> &OpsToRename) {
   Value *Op = SI->getCondition();
-  if ((!isa<Instruction>(Op) && !isa<Argument>(Op)) || Op->hasOneUse())
+  if (!isoneof<Instruction, Argument>(Op) || Op->hasOneUse())
     return;
 
   // Remember how many outgoing edges there are to every successor.
   SmallDenseMap<BasicBlock *, unsigned, 16> SwitchEdges;
   for (unsigned i = 0, e = SI->getNumSuccessors(); i != e; ++i) {
     BasicBlock *TargetBlock = SI->getSuccessor(i);
     ++SwitchEdges[TargetBlock];
   }

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

 
 static void removeLifetimeIntrinsicUsers(AllocaInst *AI) {
   // Knowing that this alloca is promotable, we know that it's safe to kill all
   // instructions except for load and store.
 
   for (auto UI = AI->user_begin(), UE = AI->user_end(); UI != UE;) {
     Instruction *I = cast<Instruction>(*UI);
     ++UI;
-    if (isa<LoadInst>(I) || isa<StoreInst>(I))
+    if (isoneof<LoadInst, StoreInst>(I))
       continue;
 
     if (!I->getType()->isVoidTy()) {
       // The only users of this bitcast/GEP instruction are lifetime intrinsics.
       // Follow the use/def chain to erase them now instead of leaving it for
       // dead code elimination later.
       for (auto UUI = I->user_begin(), UUE = I->user_end(); UUI != UUE;) {
         Instruction *Inst = cast<Instruction>(*UUI);

lib/Transforms/Utils/SimplifyCFG.cpp

   //         [ end ]
   //
   SmallVector<BasicBlock*,4> UnconditionalPreds;
   Instruction *Cond = nullptr;
   for (auto *B : predecessors(BBEnd)) {
     auto *T = B->getTerminator();
     if (isa<BranchInst>(T) && cast<BranchInst>(T)->isUnconditional())
       UnconditionalPreds.push_back(B);
-    else if ((isa<BranchInst>(T) || isa<SwitchInst>(T)) && !Cond)
+    else if (isoneof<BranchInst, SwitchInst>(T) && !Cond)
       Cond = T;
     else
       return false;
   }
   if (UnconditionalPreds.size() < 2)
     return false;
 
   bool Changed = false;

               return false;
           }
         }
 
     if (!Cond)
       return false;
   }
 
-  if (!Cond || (!isa<CmpInst>(Cond) && !isa<BinaryOperator>(Cond)) ||
+  if (!Cond || !isoneof<CmpInst, BinaryOperator>(Cond) ||
       Cond->getParent() != BB || !Cond->hasOneUse())
     return false;
 
   // Make sure the instruction after the condition is the cond branch.
   BasicBlock::iterator CondIt = ++Cond->getIterator();
 
   // Ignore dbg intrinsics.
   while (isa<DbgInfoIntrinsic>(CondIt))

     if (!BB)
       return true;
     // Heuristic: if the block can be if-converted/phi-folded and the
     // instructions inside are all cheap (arithmetic/GEPs), it's worthwhile to
     // thread this store.
     unsigned N = 0;
     for (auto &I : *BB) {
       // Cheap instructions viable for folding.
-      if (isa<BinaryOperator>(I) || isa<GetElementPtrInst>(I) ||
-          isa<StoreInst>(I))
+      if (isoneof<BinaryOperator, GetElementPtrInst, StoreInst>(I))
         ++N;
       // Free instructions.
-      else if (isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) ||
+      else if (isoneof<TerminatorInst, DbgInfoIntrinsic>(I) ||
                IsaBitcastOfPointerType(I))
         continue;
       else
         return false;
     }
     return N <= PHINodeFoldingThreshold;
   };
 

lib/Transforms/Utils/SplitModule.cpp

 
 static void addNonConstUser(ClusterMapType &GVtoClusterMap,
                             const GlobalValue *GV, const User *U) {
   assert((!isa<Constant>(U) || isa<GlobalValue>(U)) && "Bad user");
 
   if (const Instruction *I = dyn_cast<Instruction>(U)) {
     const GlobalValue *F = I->getParent()->getParent();
     GVtoClusterMap.unionSets(GV, F);
-  } else if (isa<GlobalIndirectSymbol>(U) || isa<Function>(U) ||
-             isa<GlobalVariable>(U)) {
+  } else if (isoneof<GlobalIndirectSymbol, Function, GlobalVariable>(U)) {
     GVtoClusterMap.unionSets(GV, cast<GlobalValue>(U));
   } else {
     llvm_unreachable("Underimplemented use case");
   }
 }
 
 // Adds all GlobalValue users of V to the same cluster as GV.
 static void addAllGlobalValueUsers(ClusterMapType &GVtoClusterMap,

lib/Transforms/Vectorize/BBVectorize.cpp

inline size_t getDepthFactor(Value *V) {
       // InsertElement and ExtractElement have a depth factor of zero. This is
       // for two reasons: First, they cannot be usefully fused. Second, because
       // the pass generates a lot of these, they can confuse the simple metric
       // used to compare the dags in the next iteration. Thus, giving them a
       // weight of zero allows the pass to essentially ignore them in
       // subsequent iterations when looking for vectorization opportunities
       // while still tracking dependency chains that flow through those
       // instructions.
-      if (isa<InsertElementInst>(V) || isa<ExtractElementInst>(V))
+      if (isoneof<InsertElementInst, ExtractElementInst>(V))
         return 0;
 
       // Give a load or store half of the required depth so that load/store
       // pairs will vectorize.
-      if (!Config.NoMemOpBoost && (isa<LoadInst>(V) || isa<StoreInst>(V)))
+      if (!Config.NoMemOpBoost && isoneof<LoadInst, StoreInst>(V))
         return Config.ReqChainDepth/2;
 
       return 1;
     }
 
     // Returns the cost of the provided instruction using TTI.
     // This does not handle loads and stores.
     unsigned getInstrCost(unsigned Opcode, Type *T1, Type *T2,
if (CallInst *C = dyn_cast<CallInst>(I)) {
         return false;
     } else if (GetElementPtrInst *G = dyn_cast<GetElementPtrInst>(I)) {
       if (!Config.VectorizeGEP)
         return false;
 
       // Currently, vector GEPs exist only with one index.
       if (G->getNumIndices() != 1)
         return false;
-    } else if (!(I->isBinaryOp() || isa<ShuffleVectorInst>(I) ||
-        isa<ExtractElementInst>(I) || isa<InsertElementInst>(I))) {
+    } else if (!(I->isBinaryOp() ||
+                 isoneof<ShuffleVectorInst, ExtractElementInst,
+                         InsertElementInst>(I))) {
       return false;
     }
 
     Type *T1, *T2;
     getInstructionTypes(I, T1, T2);
 
     // Not every type can be vectorized...
     if (!(VectorType::isValidElementType(T1) || T1->isVectorTy()) ||
if (IsSimpleLoadStore) {
           if (ConstantInt *CIJ = dyn_cast<ConstantInt>(J->getOperand(1)))
             Op2VK = CII == CIJ ? TargetTransformInfo::OK_UniformConstantValue :
                                TargetTransformInfo::OK_NonUniformConstantValue;
         } else {
           // Check for a splat of a constant or for a non uniform vector
           // of constants.
           Value *IOp = I->getOperand(1);
           Value *JOp = J->getOperand(1);
-          if ((isa<ConstantVector>(IOp) || isa<ConstantDataVector>(IOp)) &&
-              (isa<ConstantVector>(JOp) || isa<ConstantDataVector>(JOp))) {
+          if (isoneof<ConstantVector, ConstantDataVector>(IOp) &&
+              isoneof<ConstantVector, ConstantDataVector>(JOp)) {
             Op2VK = TargetTransformInfo::OK_NonUniformConstantValue;
             Constant *SplatValue = cast<Constant>(IOp)->getSplatValue();
             if (SplatValue != nullptr &&
                 SplatValue == cast<Constant>(JOp)->getSplatValue())
               Op2VK = TargetTransformInfo::OK_UniformConstantValue;
           }
         }
       }

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

for (Instruction *I : Chain) {
                "All elements of Chain must be loads, or all must be stores.");
       else
         assert(isa<StoreInst>(I) &&
                "All elements of Chain must be loads, or all must be stores.");
     }
   });
 
   for (Instruction &I : make_range(getBoundaryInstrs(Chain))) {
-    if (isa<LoadInst>(I) || isa<StoreInst>(I)) {
+    if (isoneof<LoadInst, StoreInst>(I)) {
       if (!is_contained(Chain, &I))
         MemoryInstrs.push_back(&I);
       else
         ChainInstrs.push_back(&I);
     } else if (IsLoadChain && (I.mayWriteToMemory() || I.mayThrow())) {
       DEBUG(dbgs() << "LSV: Found may-write/throw operation: " << I << '\n');
       break;
     } else if (!IsLoadChain && (I.mayReadOrWriteMemory() || I.mayThrow())) {

lib/Transforms/Vectorize/LoopVectorize.cpp

     return LI->getPointerOperand();
   if (auto *SI = dyn_cast<StoreInst>(I))
     return SI->getPointerOperand();
   return nullptr;
 }
 
 /// A helper function that returns the type of loaded or stored value.
 static Type *getMemInstValueType(Value *I) {
-  assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
+  assert((isoneof<LoadInst, StoreInst>(I)) &&
          "Expected Load or Store instruction");
   if (auto *LI = dyn_cast<LoadInst>(I))
     return LI->getType();
   return cast<StoreInst>(I)->getValueOperand()->getType();
 }
 
 /// A helper function that returns the alignment of load or store instruction.
 static unsigned getMemInstAlignment(Value *I) {
-  assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
+  assert((isoneof<LoadInst, StoreInst>(I)) &&
          "Expected Load or Store instruction");
   if (auto *LI = dyn_cast<LoadInst>(I))
     return LI->getAlignment();
   return cast<StoreInst>(I)->getAlignment();
 }
 
 /// A helper function that returns the address space of the pointer operand of
 /// load or store instruction.
 static unsigned getMemInstAddressSpace(Value *I) {
-  assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
+  assert((isoneof<LoadInst, StoreInst>(I)) &&
          "Expected Load or Store instruction");
   if (auto *LI = dyn_cast<LoadInst>(I))
     return LI->getPointerAddressSpace();
   return cast<StoreInst>(I)->getPointerAddressSpace();
 }
 
 /// A helper function that returns true if the given type is irregular. The
 /// type is irregular if its allocated size doesn't equal the store size of an

   return Result;
 }
 #endif
 
 void InnerLoopVectorizer::addNewMetadata(Instruction *To,
                                          const Instruction *Orig) {
   // If the loop was versioned with memchecks, add the corresponding no-alias
   // metadata.
-  if (LVer && (isa<LoadInst>(Orig) || isa<StoreInst>(Orig)))
+  if (LVer && (isoneof<LoadInst, StoreInst>(Orig)))
     LVer->annotateInstWithNoAlias(To, Orig);
 }
 
 void InnerLoopVectorizer::addMetadata(Instruction *To,
                                       Instruction *From) {
   propagateMetadata(To, From);
   addNewMetadata(To, From);
 }

     if (PHI->getBasicBlockIndex(MiddleBlock) == -1)
       PHI->addIncoming(I.second, MiddleBlock);
   }
 }
 
 namespace {
 struct CSEDenseMapInfo {
   static bool canHandle(const Instruction *I) {
-    return isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
-           isa<ShuffleVectorInst>(I) || isa<GetElementPtrInst>(I);
+    return isoneof<InsertElementInst, ExtractElementInst, ShuffleVectorInst,
+                   GetElementPtrInst>(I);
   }
   static inline Instruction *getEmptyKey() {
     return DenseMapInfo<Instruction *>::getEmptyKey();
   }
   static inline Instruction *getTombstoneKey() {
     return DenseMapInfo<Instruction *>::getTombstoneKey();
   }
   static unsigned getHashValue(const Instruction *I) {

          "Unexpected instruction");
   Value *Divisor = I.getOperand(1);
   auto *CInt = dyn_cast<ConstantInt>(Divisor);
   return !CInt || CInt->isZero();
 }
 
 void InnerLoopVectorizer::vectorizeInstruction(Instruction &I) {
   // Scalarize instructions that should remain scalar after vectorization.
-  if (VF > 1 &&
-      !(isa<BranchInst>(&I) || isa<PHINode>(&I) || isa<DbgInfoIntrinsic>(&I)) &&
+  if (VF > 1 && !isoneof<BranchInst, PHINode, DbgInfoIntrinsic>(&I) &&
       shouldScalarizeInstruction(&I)) {
     scalarizeInstruction(&I, Legal->isScalarWithPredication(&I));
     return;
   }
 
   switch (I.getOpcode()) {
   case Instruction::Br:
     // Nothing to do for PHIs and BR, since we already took care of the

     auto *I = cast<Instruction>(Ptr);
     if (Worklist.count(I))
       return;
 
     // If the use of the pointer will be a scalar use, and all users of the
     // pointer are memory accesses, place the pointer in ScalarPtrs. Otherwise,
     // place the pointer in PossibleNonScalarPtrs.
     if (isScalarUse(MemAccess, Ptr) && all_of(I->users(), [&](User *U) {
-          return isa<LoadInst>(U) || isa<StoreInst>(U);
+          return isoneof<LoadInst, StoreInst>(U);
         }))
       ScalarPtrs.insert(I);
     else
       PossibleNonScalarPtrs.insert(I);
   };
 
   // We seed the scalars analysis with three classes of instructions: (1)
   // instructions marked uniform-after-vectorization, (2) bitcast and

   while (Idx != Worklist.size()) {
     Instruction *Dst = Worklist[Idx++];
     if (!isLoopVaryingBitCastOrGEP(Dst->getOperand(0)))
       continue;
     auto *Src = cast<Instruction>(Dst->getOperand(0));
     if (all_of(Src->users(), [&](User *U) -> bool {
           auto *J = cast<Instruction>(U);
           return !TheLoop->contains(J) || Worklist.count(J) ||
-                 ((isa<LoadInst>(J) || isa<StoreInst>(J)) &&
-                  isScalarUse(J, Src));
+                 (isoneof<LoadInst, StoreInst>(J) && isScalarUse(J, Src));
         })) {
       Worklist.insert(Src);
       DEBUG(dbgs() << "LV: Found scalar instruction: " << *Src << "\n");
     }
   }
 
   // An induction variable will remain scalar if all users of the induction
   // variable and induction variable update remain scalar.

     Value *Op2 = I->getOperand(1);
 
     // Check for a splat or for a non uniform vector of constants.
     if (isa<ConstantInt>(Op2)) {
       ConstantInt *CInt = cast<ConstantInt>(Op2);
       if (CInt && CInt->getValue().isPowerOf2())
         Op2VP = TargetTransformInfo::OP_PowerOf2;
       Op2VK = TargetTransformInfo::OK_UniformConstantValue;
-    } else if (isa<ConstantVector>(Op2) || isa<ConstantDataVector>(Op2)) {
+    } else if (isoneof<ConstantVector, ConstantDataVector>(Op2)) {
       Op2VK = TargetTransformInfo::OK_NonUniformConstantValue;
       Constant *SplatValue = cast<Constant>(Op2)->getSplatValue();
       if (SplatValue) {
         ConstantInt *CInt = dyn_cast<ConstantInt>(SplatValue);
         if (CInt && CInt->getValue().isPowerOf2())
           Op2VP = TargetTransformInfo::OP_PowerOf2;
         Op2VK = TargetTransformInfo::OK_UniformConstantValue;
       }

lib/Transforms/Vectorize/SLPVectorizer.cpp

     // If the current instruction is a load, update MaxWidth to reflect the
     // width of the loaded value.
     else if (isa<LoadInst>(I))
       MaxWidth = std::max<unsigned>(MaxWidth, DL->getTypeSizeInBits(Ty));
 
     // Otherwise, we need to visit the operands of the instruction. We only
     // handle the interesting cases from buildTree here. If an operand is an
     // instruction we haven't yet visited, we add it to the worklist.
-    else if (isa<PHINode>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I) ||
-             isa<CmpInst>(I) || isa<SelectInst>(I) || isa<BinaryOperator>(I)) {
+    else if (isoneof<PHINode, CastInst, GetElementPtrInst, CmpInst, SelectInst,
+                     BinaryOperator>(I)) {
       for (Use &U : I->operands())
         if (auto *J = dyn_cast<Instruction>(U.get()))
           if (!Visited.count(J))
             Worklist.push_back(J);
     }
 
     // If we don't yet handle the instruction, give up.
     else

           // vectorized root will precede it. This guarantees that we get an
           // instruction. The vectorized tree could have been constant folded.
           Instruction *InsertAfter = cast<Instruction>(BuildVectorSlice.back());
           unsigned VecIdx = 0;
           for (auto &V : BuildVectorSlice) {
             IRBuilder<NoFolder> Builder(InsertAfter->getParent(),
                                         ++BasicBlock::iterator(InsertAfter));
             Instruction *I = cast<Instruction>(V);
-            assert(isa<InsertElementInst>(I) || isa<InsertValueInst>(I));
+            assert((isoneof<InsertElementInst, InsertValueInst>(I)));
             Instruction *Extract =
                 cast<Instruction>(Builder.CreateExtractElement(
                     VectorizedRoot, Builder.getInt32(VecIdx++)));
             I->setOperand(1, Extract);
             I->removeFromParent();
             I->insertAfter(Extract);
             InsertAfter = I;
           }