[NFC] Use variadic isa<> in LLVM IR verifier

[jurahul]

Summary

-As subject

[jurahul]

Fixup formatting

llvm/lib/IR/Verifier.cpp

if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
       Check(PTy, "wrong type for intrinsic global variable", &GV);
       if (GV.hasInitializer()) {
         const Constant *Init = GV.getInitializer();
         const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
         Check(InitArray, "wrong initalizer for intrinsic global variable",
               Init);
         for (Value *Op : InitArray->operands()) {
           Value *V = Op->stripPointerCasts();
-          Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
-                    isa<GlobalAlias>(V),
+          Check((isa<GlobalVariable, Function, GlobalAlias>(V)),
                 Twine("invalid ") + GV.getName() + " member", V);
           Check(V->hasName(),
                 Twine("members of ") + GV.getName() + " must be named", V);
         }
       }
     }
   }
 
Check(GlobalAlias::isValidLinkage(GA.getLinkage()),
         "Alias should have private, internal, linkonce, weak, linkonce_odr, "
         "weak_odr, or external linkage!",
         &GA);
   const Constant *Aliasee = GA.getAliasee();
   Check(Aliasee, "Aliasee cannot be NULL!", &GA);
   Check(GA.getType() == Aliasee->getType(),
         "Alias and aliasee types should match!", &GA);
 
-  Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
+  Check((isa<GlobalValue, ConstantExpr>(Aliasee)),
         "Aliasee should be either GlobalValue or ConstantExpr", &GA);
 
   visitAliaseeSubExpr(GA, *Aliasee);
 
   visitGlobalValue(GA);
 }
 
 void Verifier::visitGlobalIFunc(const GlobalIFunc &GI) {
void Verifier::visitDISubrange(const DISubrange &N) {
   CheckDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
   bool HasAssumedSizedArraySupport = dwarf::isFortran(CurrentSourceLang);
   CheckDI(HasAssumedSizedArraySupport || N.getRawCountNode() ||
               N.getRawUpperBound(),
           "Subrange must contain count or upperBound", &N);
   CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
           "Subrange can have any one of count or upperBound", &N);
   auto *CBound = N.getRawCountNode();
-  CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
-              isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-          "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(
+      (!CBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(CBound)),
   auto Count = N.getCount();
   CheckDI(!Count || !Count.is<ConstantInt *>() ||
               Count.get<ConstantInt *>()->getSExtValue() >= -1,
           "invalid subrange count", &N);
   auto *LBound = N.getRawLowerBound();
-  CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
-              isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-          "LowerBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI(
+      (!LBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(LBound)),
+      "LowerBound must be signed constant or DIVariable or DIExpression", &N);
   auto *UBound = N.getRawUpperBound();
-  CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
-              isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-          "UpperBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI(
+      (!UBound || isa<ConstantAsMetadata, DIVariable, DIExpression>(UBound)),
+      "UpperBound must be signed constant or DIVariable or DIExpression", &N);
   auto *Stride = N.getRawStride();
-  CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
-              isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-          "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(
+      (!Stride || isa<ConstantAsMetadata, DIVariable, DIExpression>(Stride)),
 }
 
 void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) {
   CheckDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N);
   CheckDI(N.getRawCountNode() || N.getRawUpperBound(),
           "GenericSubrange must contain count or upperBound", &N);
   CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
           "GenericSubrange can have any one of count or upperBound", &N);
   auto *CBound = N.getRawCountNode();
-  CheckDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-          "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI((!CBound || isa<DIVariable, DIExpression>(CBound)),
+          "Count must be DIVariable or DIExpression", &N);
   auto *LBound = N.getRawLowerBound();
   CheckDI(LBound, "GenericSubrange must contain lowerBound", &N);
-  CheckDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-          "LowerBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI((isa<DIVariable, DIExpression>(LBound)),
+          "LowerBound must be DIVariable or DIExpression", &N);
   auto *UBound = N.getRawUpperBound();
-  CheckDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-          "UpperBound must be signed constant or DIVariable or DIExpression",
-          &N);
+  CheckDI((!UBound || isa<DIVariable, DIExpression>(UBound)),
+          "UpperBound must be DIVariable or DIExpression", &N);
   auto *Stride = N.getRawStride();
   CheckDI(Stride, "GenericSubrange must contain stride", &N);
-  CheckDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-          "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI((isa<DIVariable, DIExpression>(Stride)),
+          "Stride must be DIVariable or DIExpression", &N);
 }
 
 void Verifier::visitDIEnumerator(const DIEnumerator &N) {
   CheckDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
 }
 
 void Verifier::visitDIBasicType(const DIBasicType &N) {
   CheckDI(N.getTag() == dwarf::DW_TAG_base_type ||
if (auto *Params = N.getRawTemplateParams())
     visitTemplateParams(N, *Params);
   if (auto *S = N.getRawDeclaration())
     CheckDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
             "invalid subprogram declaration", &N, S);
   if (auto *RawNode = N.getRawRetainedNodes()) {
     auto *Node = dyn_cast<MDTuple>(RawNode);
     CheckDI(Node, "invalid retained nodes list", &N, RawNode);
     for (Metadata *Op : Node->operands()) {
-      CheckDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),
+      CheckDI(Op && (isa<DILocalVariable, DILabel>(Op)),
               "invalid retained nodes, expected DILocalVariable or DILabel", &N,
               Node, Op);
     }
   }
   CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
           "invalid reference flags", &N);
 
   auto *Unit = N.getRawUnit();
Check(NumDeoptArgs == 0,
         "gc.statepoint w/inline deopt operands is deprecated", Call);
 
   const int ExpectedNumArgs = 7 + NumCallArgs;
   Check(ExpectedNumArgs == (int)Call.arg_size(),
         "gc.statepoint too many arguments", Call);
 
   // 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
+  // of the same statepoint sequence.
   for (const User *U : Call.users()) {
     const CallInst *UserCall = dyn_cast<const CallInst>(U);
     Check(UserCall, "illegal use of statepoint token", Call, U);
-    if (!UserCall)
-      continue;
-    Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
-          "gc.result or gc.relocate are the only value uses "
+    Check((isa<GCRelocateInst, GCResultInst>(UserCall)),
+          "gc.result or gc.relocate are the only valid uses "
           "of a gc.statepoint",
           Call, U);
-    if (isa<GCResultInst>(UserCall)) {
-      Check(UserCall->getArgOperand(0) == &Call,
-            "gc.result connected to wrong gc.statepoint", Call, UserCall);
-    } else if (isa<GCRelocateInst>(Call)) {
-      Check(UserCall->getArgOperand(0) == &Call,
-            "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
-    }
+          Twine(isa<GCRelocateInst>(UserCall) ? "gc.relocate" : "gc.result",
+                StringRef(" result connected to wrong gc.statepoint")),
+          Call, UserCall);
   }
 
   // Note: It is legal for a single derived pointer to be listed multiple
   // times.  It's non-optimal, but it is legal.  It can also happen after
   // insertion if we strip a bitcast away.
   // Note: It is really tempting to check that each base is relocated and
   // that a derived pointer is never reused as a base pointer.  This turns
   // out to be problematic since optimizations run after safepoint insertion
if (Attrs.hasParamAttr(i, Attribute::ImmArg)) {
       // also has the matching immarg.
       Check(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),
             "immarg may not apply only to call sites", Call.getArgOperand(i),
             Call);
     }
 
     if (Call.paramHasAttr(i, Attribute::ImmArg)) {
       Value *ArgVal = Call.getArgOperand(i);
-      Check(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
+      Check((isa<ConstantInt, ConstantFP>(ArgVal)),
             "immarg operand has non-immediate parameter", ArgVal, Call);
     }
 
     if (Call.paramHasAttr(i, Attribute::Preallocated)) {
       Value *ArgVal = Call.getArgOperand(i);
       bool hasOB =
           Call.countOperandBundlesOfType(LLVMContext::OB_preallocated) != 0;
       bool isMustTail = Call.isMustTailCall();
for (const auto &I : llvm::enumerate(Call.args())) {
     }
   }
 }
 
 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()) {
-    Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
-              isa<InvokeInst>(U),
+    Check((isa<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))
       Check(StoreI->getOperand(1) == SwiftErrorVal,
             "swifterror value should be the second operand when used "
             "by stores",
for (;; FromPad = getParentPad(FromPad)) {
       }
       Check(!isa<ConstantTokenNone>(FromPad),
             "A single unwind edge may only enter one EH pad", TI);
       Check(Seen.insert(FromPad).second, "EH pad jumps through a cycle of pads",
             FromPad);
 
       // This will be diagnosed on the corresponding instruction already. We
       // need the extra check here to make sure getParentPad() works.
-      Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
+      Check((isa<FuncletPadInst, CatchSwitchInst>(FromPad)),
             "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
     }
   }
 }
 
 void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
   // The landingpad instruction is ill-formed if it doesn't have any clauses and
   // isn't a cleanup.
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
 
   for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
     Constant *Clause = LPI.getClause(i);
     if (LPI.isCatch(i)) {
       Check(isa<PointerType>(Clause->getType()),
             "Catch operand does not have pointer type!", &LPI);
     } else {
       Check(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
-      Check(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
+      Check((isa<ConstantArray, ConstantAggregateZero>(Clause)),
             "Filter operand is not an array of constants!", &LPI);
     }
   }
 
   visitInstruction(LPI);
 }
 
 void Verifier::visitResumeInst(ResumeInst &RI) {
Check(F->hasPersonalityFn(),
         "CleanupPadInst needs to be in a function with a personality.", &CPI);
 
   // The cleanuppad instruction must be the first non-PHI instruction in the
   // block.
   Check(BB->getFirstNonPHI() == &CPI,
         "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
 
   auto *ParentPad = CPI.getParentPad();
-  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Check((isa<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.
   Check(BB->getFirstNonPHI() == &CatchSwitch,
         "CatchSwitchInst not the first non-PHI instruction in the block.",
         &CatchSwitch);
 
   auto *ParentPad = CatchSwitch.getParentPad();
-  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
+  Check((isa<ConstantTokenNone, FuncletPadInst>(ParentPad)),
         "CatchSwitchInst has an invalid parent.", ParentPad);
 
   if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
     Check(I->isEHPad() && !isa<LandingPadInst>(I),
           "CatchSwitchInst must unwind to an EH block which is not a "
           "landingpad.",
           &CatchSwitch);
void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   Check(DT.dominates(Op, U), "Instruction does not dominate all uses!", Op, &I);
 }
 
 void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
   Check(I.getType()->isPointerTy(),
         "dereferenceable, dereferenceable_or_null "
         "apply only to pointer types",
         &I);
-  Check((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
+  Check((isa<LoadInst, IntToPtrInst>(I)),
         "dereferenceable, dereferenceable_or_null apply only to load"
         " and inttoptr instructions, use attributes for calls or invokes",
         &I);
   Check(MD->getNumOperands() == 1,
         "dereferenceable, dereferenceable_or_null "
         "take one operand!",
         &I);
   ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
void Verifier::visitInstruction(Instruction &I) {
 
   // Check that the return value of the instruction is either void or a legal
   // value type.
   Check(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.
-  Check(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
+  Check((!I.getType()->isMetadataTy() || isa<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()))
       Check(Used->getParent() != nullptr,
if (ConstantFP *CFP0 =
       Check(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
             "fpmath accuracy not a positive number!", &I);
     } else {
       Check(false, "invalid fpmath accuracy!", &I);
     }
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
-    Check(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
+    Check((isa<LoadInst, CallInst, InvokeInst>(I)),
           "Ranges are only for loads, calls and invokes!", &I);
     visitRangeMetadata(I, Range, I.getType());
   }
 
   if (I.hasMetadata(LLVMContext::MD_invariant_group)) {
-    Check(isa<LoadInst>(I) || isa<StoreInst>(I),
+    Check((isa<LoadInst, StoreInst>(I)),
           "invariant.group metadata is only for loads and stores", &I);
   }
 
   if (I.getMetadata(LLVMContext::MD_nonnull)) {
     Check(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
           &I);
     Check(isa<LoadInst>(I),
           "nonnull applies only to load instructions, use attributes"
case Intrinsic::coro_id: {
     auto *InfoArg = Call.getArgOperand(3)->stripPointerCasts();
     if (isa<ConstantPointerNull>(InfoArg))
       break;
     auto *GV = dyn_cast<GlobalVariable>(InfoArg);
     Check(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
           "info argument of llvm.coro.id must refer to an initialized "
           "constant");
     Constant *Init = GV->getInitializer();
-    Check(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
+    Check((isa<ConstantStruct, ConstantArray>(Init)),
           "info argument of llvm.coro.id must refer to either a struct or "
           "an array");
     break;
   }
   case Intrinsic::fptrunc_round: {
     // Check the rounding mode
     Metadata *MD = nullptr;
     auto *MAV = dyn_cast<MetadataAsValue>(Call.getOperand(1));
if (LandingPadInst *LandingPad =
             InvokeBB);
       Check(isa<GCStatepointInst>(InvokeBB->getTerminator()),
             "gc relocate should be linked to a statepoint", InvokeBB);
     } else {
       // In all other cases relocate should be tied to the statepoint directly.
       // This covers relocates on a normal return path of invoke statepoint and
       // relocates of a call statepoint.
       auto *Token = Call.getArgOperand(0);
-      Check(isa<GCStatepointInst>(Token) || isa<UndefValue>(Token),
+      Check((isa<GCStatepointInst, UndefValue>(Token)),
             "gc relocate is incorrectly tied to the statepoint", Call, Token);
     }
 
     // Verify rest of the relocate arguments.
     const Value &StatepointCall = *cast<GCRelocateInst>(Call).getStatepoint();
 
     // Both the base and derived must be piped through the safepoint.
     Value *Base = Call.getArgOperand(1);
#include "llvm/IR/ConstrainedOps.def"
   if (HasRoundingMD) {
     Check(FPI.getRoundingMode().has_value(), "invalid rounding mode argument",
           &FPI);
   }
 }
 
 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
   auto *MD = DII.getRawLocation();
-  CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
+  CheckDI((isa<ValueAsMetadata, DIArgList>(MD)) ||
               (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
           "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
   CheckDI(isa<DILocalVariable>(DII.getRawVariable()),
           "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
           DII.getRawVariable());
   CheckDI(isa<DIExpression>(DII.getRawExpression()),
           "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
           DII.getRawExpression());
if (!Type || Type->getNumOperands() < 3)
     return false;
 
   // In the new format type nodes shall have a reference to the parent type as
   // its first operand.
   return isa_and_nonnull<MDNode>(Type->getOperand(0));
 }
 
 bool TBAAVerifier::visitTBAAMetadata(Instruction &I, const MDNode *MD) {
-  CheckTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
-                isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
-                isa<AtomicCmpXchgInst>(I),
+  CheckTBAA((isa<LoadInst, StoreInst, CallInst, VAArgInst, AtomicRMWInst,
+                 AtomicCmpXchgInst>(I)),
             "This instruction shall not have a TBAA access tag!", &I);
 
   bool IsStructPathTBAA =
       isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
 
   CheckTBAA(IsStructPathTBAA,
             "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
             &I);