[Lint][Verifier] NFC: Rename 'Assert*' macros to 'Check*'.

[tahonermann]

Summary

The LLVM IR verifier and analysis linter defines and uses several macros in
code that performs validation of IR expectations. Previously, these macros
were named with an 'Assert' prefix. These names were misleading since the
macro definitions are not conditioned on build kind; they are defined
identically in builds that have asserts enabled and those that do not. This
was confusing since an LLVM developer might expect these macros to be
conditionally enabled as 'assert' is. Further confusion was possible since
the LLVM IR verifier is implicitly disabled (in Clang::ConstructJob()) for
builds without asserts enabled, but only for Clang driver invocations; not
for clang -cc1 invocations. This could make it appear that the macros were
not active for builds without asserts enabled, e.g. when investigating
behavior using the Clang driver, and thus lead to surprises when running
tests that exercise the clang -cc1 interface.

This change renames this set of macros as follows:

Assert -> Check
AssertDI -> CheckDI
AssertTBAA -> CheckTBAA

[tahonermann]

I've added some reviewers based on prior git history for the changed files. Please feel free to resign or nominate another reviewer!

[aeubanks]

I like this change, let's see what others think of it

perhaps Verify() makes a bit more sense than Check() at least for the verifier?

[nikic]

My reading on the "assert" terminology here was that we don't continue executing the rest of the function if a condition fails. Basically with the same implication as ASSERT in gunit tests (vs EXPECT, which reports an error but continues running the test).

But I don't particularly care either way.

[tahonermann]

perhaps Verify() makes a bit more sense than Check() at least for the verifier?

I thought about Verify() as well, but went with Check() for consistency with CheckFailed().

[tahonermann]

Thanks for the approval @aeubanks! If no objections are raised, I'll land this Tuesday morning.

[tahonermann]

Closing per commit c54ad1360248e28a436a6a6c560ba5952d8e98cb (I failed to get "Differential Revision" added to the commit message).

llvm/lib/Analysis/Lint.cpp

public:
   template <typename T1, typename... Ts>
   void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) {
     CheckFailed(Message);
     WriteValues({V1, Vs...});
   }
 };
 } // end anonymous namespace
 
-// Assert - We know that cond should be true, if not print an error message.
-#define Assert(C, ...)                                                         \
+// Check - We know that cond should be true, if not print an error message.
+#define Check(C, ...)                                                          \
   do {                                                                         \
     if (!(C)) {                                                                \
       CheckFailed(__VA_ARGS__);                                                \
       return;                                                                  \
     }                                                                          \
   } while (false)
 
 void Lint::visitFunction(Function &F) {
   // This isn't undefined behavior, it's just a little unusual, and it's a
   // fairly common mistake to neglect to name a function.
-  Assert(F.hasName() || F.hasLocalLinkage(),
-         "Unusual: Unnamed function with non-local linkage", &F);
+  Check(F.hasName() || F.hasLocalLinkage(),
 
   // TODO: Check for irreducible control flow.
 }
 
 void Lint::visitCallBase(CallBase &I) {
   Value *Callee = I.getCalledOperand();
 
   visitMemoryReference(I, MemoryLocation::getAfter(Callee), None, nullptr,
                        MemRef::Callee);
 
   if (Function *F = dyn_cast<Function>(findValue(Callee,
                                                  /*OffsetOk=*/false))) {
-    Assert(I.getCallingConv() == F->getCallingConv(),
-           "Undefined behavior: Caller and callee calling convention differ",
-           &I);
+    Check(I.getCallingConv() == F->getCallingConv(),
 
     FunctionType *FT = F->getFunctionType();
     unsigned NumActualArgs = I.arg_size();
 
-    Assert(FT->isVarArg() ? FT->getNumParams() <= NumActualArgs
-                          : FT->getNumParams() == NumActualArgs,
-           "Undefined behavior: Call argument count mismatches callee "
-           "argument count",
-           &I);
+    Check(FT->isVarArg() ? FT->getNumParams() <= NumActualArgs
 
-    Assert(FT->getReturnType() == I.getType(),
-           "Undefined behavior: Call return type mismatches "
-           "callee return type",
-           &I);
+    Check(FT->getReturnType() == I.getType(),
 
     // Check argument types (in case the callee was casted) and attributes.
     // TODO: Verify that caller and callee attributes are compatible.
     Function::arg_iterator PI = F->arg_begin(), PE = F->arg_end();
     auto AI = I.arg_begin(), AE = I.arg_end();
     for (; AI != AE; ++AI) {
       Value *Actual = *AI;
       if (PI != PE) {
         Argument *Formal = &*PI++;
-        Assert(Formal->getType() == Actual->getType(),
-               "Undefined behavior: Call argument type mismatches "
-               "callee parameter type",
-               &I);
+        Check(Formal->getType() == Actual->getType(),
 
         // Check that noalias arguments don't alias other arguments. This is
         // not fully precise because we don't know the sizes of the dereferenced
         // memory regions.
         if (Formal->hasNoAliasAttr() && Actual->getType()->isPointerTy()) {
           AttributeList PAL = I.getAttributes();
           unsigned ArgNo = 0;
           for (auto BI = I.arg_begin(); BI != AE; ++BI, ++ArgNo) {
             // Skip ByVal arguments since they will be memcpy'd to the callee's
             // stack so we're not really passing the pointer anyway.
             if (PAL.hasParamAttr(ArgNo, Attribute::ByVal))
               continue;
             // If both arguments are readonly, they have no dependence.
             if (Formal->onlyReadsMemory() && I.onlyReadsMemory(ArgNo))
               continue;
             if (AI != BI && (*BI)->getType()->isPointerTy()) {
               AliasResult Result = AA->alias(*AI, *BI);
-              Assert(Result != AliasResult::MustAlias &&
-                         Result != AliasResult::PartialAlias,
-                     "Unusual: noalias argument aliases another argument", &I);
+              Check(Result != AliasResult::MustAlias &&
             }
           }
         }
 
         // Check that an sret argument points to valid memory.
         if (Formal->hasStructRetAttr() && Actual->getType()->isPointerTy()) {
           Type *Ty = Formal->getParamStructRetType();
           MemoryLocation Loc(
if (CI->isTailCall()) {
       const AttributeList &PAL = CI->getAttributes();
       unsigned ArgNo = 0;
       for (Value *Arg : I.args()) {
         // Skip ByVal arguments since they will be memcpy'd to the callee's
         // stack anyway.
         if (PAL.hasParamAttr(ArgNo++, Attribute::ByVal))
           continue;
         Value *Obj = findValue(Arg, /*OffsetOk=*/true);
-        Assert(!isa<AllocaInst>(Obj),
-               "Undefined behavior: Call with \"tail\" keyword references "
-               "alloca",
-               &I);
+        Check(!isa<AllocaInst>(Obj),
       }
     }
   }
 
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I))
     switch (II->getIntrinsicID()) {
     default:
       break;
case Intrinsic::memcpy: {
       // isn't expressive enough for what we really want to do. Known partial
       // overlap is not distinguished from the case where nothing is known.
       auto Size = LocationSize::afterPointer();
       if (const ConstantInt *Len =
               dyn_cast<ConstantInt>(findValue(MCI->getLength(),
                                               /*OffsetOk=*/false)))
         if (Len->getValue().isIntN(32))
           Size = LocationSize::precise(Len->getValue().getZExtValue());
-      Assert(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) !=
-                 AliasResult::MustAlias,
-             "Undefined behavior: memcpy source and destination overlap", &I);
+      Check(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) !=
       break;
     }
     case Intrinsic::memcpy_inline: {
       MemCpyInlineInst *MCII = cast<MemCpyInlineInst>(&I);
       const uint64_t Size = MCII->getLength()->getValue().getLimitedValue();
       visitMemoryReference(I, MemoryLocation::getForDest(MCII),
                            MCII->getDestAlign(), nullptr, MemRef::Write);
       visitMemoryReference(I, MemoryLocation::getForSource(MCII),
                            MCII->getSourceAlign(), nullptr, MemRef::Read);
 
       // Check that the memcpy arguments don't overlap. The AliasAnalysis API
       // isn't expressive enough for what we really want to do. Known partial
       // overlap is not distinguished from the case where nothing is known.
       const LocationSize LS = LocationSize::precise(Size);
-      Assert(AA->alias(MCII->getSource(), LS, MCII->getDest(), LS) !=
-                 AliasResult::MustAlias,
-             "Undefined behavior: memcpy source and destination overlap", &I);
+      Check(AA->alias(MCII->getSource(), LS, MCII->getDest(), LS) !=
       break;
     }
     case Intrinsic::memmove: {
       MemMoveInst *MMI = cast<MemMoveInst>(&I);
       visitMemoryReference(I, MemoryLocation::getForDest(MMI),
                            MMI->getDestAlign(), nullptr, MemRef::Write);
       visitMemoryReference(I, MemoryLocation::getForSource(MMI),
                            MMI->getSourceAlign(), nullptr, MemRef::Read);
       break;
     }
     case Intrinsic::memset: {
       MemSetInst *MSI = cast<MemSetInst>(&I);
       visitMemoryReference(I, MemoryLocation::getForDest(MSI),
                            MSI->getDestAlign(), nullptr, MemRef::Write);
       break;
     }
 
     case Intrinsic::vastart:
-      Assert(I.getParent()->getParent()->isVarArg(),
-             "Undefined behavior: va_start called in a non-varargs function",
-             &I);
+      Check(I.getParent()->getParent()->isVarArg(),
 
       visitMemoryReference(I, MemoryLocation::getForArgument(&I, 0, TLI), None,
                            nullptr, MemRef::Read | MemRef::Write);
       break;
     case Intrinsic::vacopy:
       visitMemoryReference(I, MemoryLocation::getForArgument(&I, 0, TLI), None,
                            nullptr, MemRef::Write);
       visitMemoryReference(I, MemoryLocation::getForArgument(&I, 1, TLI), None,
                            nullptr, MemRef::Read);
       break;
     case Intrinsic::vaend:
       visitMemoryReference(I, MemoryLocation::getForArgument(&I, 0, TLI), None,
                            nullptr, MemRef::Read | MemRef::Write);
       break;
 
     case Intrinsic::stackrestore:
       // Stackrestore doesn't read or write memory, but it sets the
       // stack pointer, which the compiler may read from or write to
       // at any time, so check it for both readability and writeability.
       visitMemoryReference(I, MemoryLocation::getForArgument(&I, 0, TLI), None,
                            nullptr, MemRef::Read | MemRef::Write);
       break;
     case Intrinsic::get_active_lane_mask:
       if (auto *TripCount = dyn_cast<ConstantInt>(I.getArgOperand(1)))
-        Assert(!TripCount->isZero(), "get_active_lane_mask: operand #2 "
-               "must be greater than 0", &I);
+        Check(!TripCount->isZero(),
+              "get_active_lane_mask: operand #2 "
+              "must be greater than 0",
+              &I);
       break;
     }
 }
 
 void Lint::visitReturnInst(ReturnInst &I) {
   Function *F = I.getParent()->getParent();
-  Assert(!F->doesNotReturn(),
-         "Unusual: Return statement in function with noreturn attribute", &I);
+  Check(!F->doesNotReturn(),
 
   if (Value *V = I.getReturnValue()) {
     Value *Obj = findValue(V, /*OffsetOk=*/true);
-    Assert(!isa<AllocaInst>(Obj), "Unusual: Returning alloca value", &I);
+    Check(!isa<AllocaInst>(Obj), "Unusual: Returning alloca value", &I);
   }
 }
 
 // TODO: Check that the reference is in bounds.
 // TODO: Check readnone/readonly function attributes.
 void Lint::visitMemoryReference(Instruction &I, const MemoryLocation &Loc,
                                 MaybeAlign Align, Type *Ty, unsigned Flags) {
   // If no memory is being referenced, it doesn't matter if the pointer
   // is valid.
   if (Loc.Size.isZero())
     return;
 
   Value *Ptr = const_cast<Value *>(Loc.Ptr);
   Value *UnderlyingObject = findValue(Ptr, /*OffsetOk=*/true);
-  Assert(!isa<ConstantPointerNull>(UnderlyingObject),
-         "Undefined behavior: Null pointer dereference", &I);
-  Assert(!isa<UndefValue>(UnderlyingObject),
-         "Undefined behavior: Undef pointer dereference", &I);
-  Assert(!isa<ConstantInt>(UnderlyingObject) ||
-             !cast<ConstantInt>(UnderlyingObject)->isMinusOne(),
-         "Unusual: All-ones pointer dereference", &I);
-  Assert(!isa<ConstantInt>(UnderlyingObject) ||
-             !cast<ConstantInt>(UnderlyingObject)->isOne(),
-         "Unusual: Address one pointer dereference", &I);
+  Check(!isa<ConstantPointerNull>(UnderlyingObject),
+  Check(!isa<UndefValue>(UnderlyingObject),
+  Check(!isa<ConstantInt>(UnderlyingObject) ||
+  Check(!isa<ConstantInt>(UnderlyingObject) ||
 
   if (Flags & MemRef::Write) {
     if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(UnderlyingObject))
-      Assert(!GV->isConstant(), "Undefined behavior: Write to read-only memory",
-             &I);
-    Assert(!isa<Function>(UnderlyingObject) &&
-               !isa<BlockAddress>(UnderlyingObject),
-           "Undefined behavior: Write to text section", &I);
+      Check(!GV->isConstant(), "Undefined behavior: Write to read-only memory",
+    Check(!isa<Function>(UnderlyingObject) &&
   }
   if (Flags & MemRef::Read) {
-    Assert(!isa<Function>(UnderlyingObject), "Unusual: Load from function body",
-           &I);
-    Assert(!isa<BlockAddress>(UnderlyingObject),
-           "Undefined behavior: Load from block address", &I);
+    Check(!isa<Function>(UnderlyingObject), "Unusual: Load from function body",
+    Check(!isa<BlockAddress>(UnderlyingObject),
   }
   if (Flags & MemRef::Callee) {
-    Assert(!isa<BlockAddress>(UnderlyingObject),
-           "Undefined behavior: Call to block address", &I);
+    Check(!isa<BlockAddress>(UnderlyingObject),
   }
   if (Flags & MemRef::Branchee) {
-    Assert(!isa<Constant>(UnderlyingObject) ||
-               isa<BlockAddress>(UnderlyingObject),
-           "Undefined behavior: Branch to non-blockaddress", &I);
+    Check(!isa<Constant>(UnderlyingObject) ||
   }
 
   // Check for buffer overflows and misalignment.
   // Only handles memory references that read/write something simple like an
   // alloca instruction or a global variable.
   int64_t Offset = 0;
   if (Value *Base = GetPointerBaseWithConstantOffset(Ptr, Offset, *DL)) {
     // OK, so the access is to a constant offset from Ptr.  Check that Ptr is
if (AllocaInst *AI = dyn_cast<AllocaInst>(Base)) {
         BaseAlign = GV->getAlign();
         if (!BaseAlign && GTy->isSized())
           BaseAlign = DL->getABITypeAlign(GTy);
       }
     }
 
     // Accesses from before the start or after the end of the object are not
     // defined.
-    Assert(!Loc.Size.hasValue() || BaseSize == MemoryLocation::UnknownSize ||
-               (Offset >= 0 && Offset + Loc.Size.getValue() <= BaseSize),
-           "Undefined behavior: Buffer overflow", &I);
+    Check(!Loc.Size.hasValue() || BaseSize == MemoryLocation::UnknownSize ||
 
     // Accesses that say that the memory is more aligned than it is are not
     // defined.
     if (!Align && Ty && Ty->isSized())
       Align = DL->getABITypeAlign(Ty);
     if (BaseAlign && Align)
-      Assert(*Align <= commonAlignment(*BaseAlign, Offset),
-             "Undefined behavior: Memory reference address is misaligned", &I);
+      Check(*Align <= commonAlignment(*BaseAlign, Offset),
   }
 }
 
 void Lint::visitLoadInst(LoadInst &I) {
   visitMemoryReference(I, MemoryLocation::get(&I), I.getAlign(), I.getType(),
                        MemRef::Read);
 }
 
 void Lint::visitStoreInst(StoreInst &I) {
   visitMemoryReference(I, MemoryLocation::get(&I), I.getAlign(),
                        I.getOperand(0)->getType(), MemRef::Write);
 }
 
 void Lint::visitXor(BinaryOperator &I) {
-  Assert(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
-         "Undefined result: xor(undef, undef)", &I);
+  Check(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
 }
 
 void Lint::visitSub(BinaryOperator &I) {
-  Assert(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
-         "Undefined result: sub(undef, undef)", &I);
+  Check(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
 }
 
 void Lint::visitLShr(BinaryOperator &I) {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(1),
                                                         /*OffsetOk=*/false)))
-    Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
-           "Undefined result: Shift count out of range", &I);
+    Check(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
 }
 
 void Lint::visitAShr(BinaryOperator &I) {
   if (ConstantInt *CI =
           dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
-    Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
-           "Undefined result: Shift count out of range", &I);
+    Check(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
 }
 
 void Lint::visitShl(BinaryOperator &I) {
   if (ConstantInt *CI =
           dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
-    Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
-           "Undefined result: Shift count out of range", &I);
+    Check(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
 }
 
 static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT,
                    AssumptionCache *AC) {
   // Assume undef could be zero.
   if (isa<UndefValue>(V))
     return true;
 
for (unsigned I = 0, N = cast<FixedVectorType>(VecTy)->getNumElements();
     if (Known.isZero())
       return true;
   }
 
   return false;
 }
 
 void Lint::visitSDiv(BinaryOperator &I) {
-  Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
-         "Undefined behavior: Division by zero", &I);
+  Check(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
 }
 
 void Lint::visitUDiv(BinaryOperator &I) {
-  Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
-         "Undefined behavior: Division by zero", &I);
+  Check(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
 }
 
 void Lint::visitSRem(BinaryOperator &I) {
-  Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
-         "Undefined behavior: Division by zero", &I);
+  Check(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
 }
 
 void Lint::visitURem(BinaryOperator &I) {
-  Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
-         "Undefined behavior: Division by zero", &I);
+  Check(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
 }
 
 void Lint::visitAllocaInst(AllocaInst &I) {
   if (isa<ConstantInt>(I.getArraySize()))
     // This isn't undefined behavior, it's just an obvious pessimization.
-    Assert(&I.getParent()->getParent()->getEntryBlock() == I.getParent(),
-           "Pessimization: Static alloca outside of entry block", &I);
+    Check(&I.getParent()->getParent()->getEntryBlock() == I.getParent(),
 
   // TODO: Check for an unusual size (MSB set?)
 }
 
 void Lint::visitVAArgInst(VAArgInst &I) {
   visitMemoryReference(I, MemoryLocation::get(&I), None, nullptr,
                        MemRef::Read | MemRef::Write);
 }
 
 void Lint::visitIndirectBrInst(IndirectBrInst &I) {
   visitMemoryReference(I, MemoryLocation::getAfter(I.getAddress()), None,
                        nullptr, MemRef::Branchee);
 
-  Assert(I.getNumDestinations() != 0,
-         "Undefined behavior: indirectbr with no destinations", &I);
+  Check(I.getNumDestinations() != 0,
 }
 
 void Lint::visitExtractElementInst(ExtractElementInst &I) {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getIndexOperand(),
                                                         /*OffsetOk=*/false)))
-    Assert(
+    Check(
         CI->getValue().ult(
             cast<FixedVectorType>(I.getVectorOperandType())->getNumElements()),
         "Undefined result: extractelement index out of range", &I);
 }
 
 void Lint::visitInsertElementInst(InsertElementInst &I) {
   if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(2),
                                                         /*OffsetOk=*/false)))
-    Assert(CI->getValue().ult(
-               cast<FixedVectorType>(I.getType())->getNumElements()),
-           "Undefined result: insertelement index out of range", &I);
+    Check(CI->getValue().ult(
 }
 
 void Lint::visitUnreachableInst(UnreachableInst &I) {
   // This isn't undefined behavior, it's merely suspicious.
-  Assert(&I == &I.getParent()->front() ||
-             std::prev(I.getIterator())->mayHaveSideEffects(),
-         "Unusual: unreachable immediately preceded by instruction without "
-         "side effects",
-         &I);
+  Check(&I == &I.getParent()->front() ||
 }
 
 /// findValue - Look through bitcasts and simple memory reference patterns
 /// to identify an equivalent, but more informative, value.  If OffsetOk
 /// is true, look through getelementptrs with non-zero offsets too.
 ///
 /// Most analysis passes don't require this logic, because instcombine
 /// will simplify most of these kinds of things away. But it's a goal of

llvm/lib/IR/Verifier.cpp

#include "llvm/IR/Metadata.def"
 
   /// Verify the llvm.experimental.noalias.scope.decl declarations
   void verifyNoAliasScopeDecl();
 };
 
 } // end anonymous namespace
 
 /// We know that cond should be true, if not print an error message.
-#define Assert(C, ...) \
-  do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (false)
+#define Check(C, ...)                                                          \
+  do {                                                                         \
+    if (!(C)) {                                                                \
+      CheckFailed(__VA_ARGS__);                                                \
+      return;                                                                  \
+    }                                                                          \
+  } while (false)
 
 /// We know that a debug info condition should be true, if not print
 /// an error message.
-#define AssertDI(C, ...) \
-  do { if (!(C)) { DebugInfoCheckFailed(__VA_ARGS__); return; } } while (false)
+#define CheckDI(C, ...)                                                        \
+  do {                                                                         \
+    if (!(C)) {                                                                \
+      DebugInfoCheckFailed(__VA_ARGS__);                                       \
+      return;                                                                  \
+    }                                                                          \
+  } while (false)
 
 void Verifier::visit(Instruction &I) {
   for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
-    Assert(I.getOperand(i) != nullptr, "Operand is null", &I);
+    Check(I.getOperand(i) != nullptr, "Operand is null", &I);
   InstVisitor<Verifier>::visit(I);
 }
 
 // Helper to iterate over indirect users. By returning false, the callback can ask to stop traversing further.
 static void forEachUser(const Value *User,
                         SmallPtrSet<const Value *, 32> &Visited,
                         llvm::function_ref<bool(const Value *)> Callback) {
   if (!Visited.insert(User).second)
     return;
 
   SmallVector<const Value *> WorkList;
   append_range(WorkList, User->materialized_users());
   while (!WorkList.empty()) {
    const Value *Cur = WorkList.pop_back_val();
     if (!Visited.insert(Cur).second)
       continue;
     if (Callback(Cur))
       append_range(WorkList, Cur->materialized_users());
   }
 }
 
 void Verifier::visitGlobalValue(const GlobalValue &GV) {
-  Assert(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),
-         "Global is external, but doesn't have external or weak linkage!", &GV);
+  Check(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),
 
   if (const GlobalObject *GO = dyn_cast<GlobalObject>(&GV)) {
 
     if (MaybeAlign A = GO->getAlign()) {
-      Assert(A->value() <= Value::MaximumAlignment,
-             "huge alignment values are unsupported", GO);
+      Check(A->value() <= Value::MaximumAlignment,
     }
   }
-  Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
-         "Only global variables can have appending linkage!", &GV);
+  Check(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
 
   if (GV.hasAppendingLinkage()) {
     const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
-    Assert(GVar && GVar->getValueType()->isArrayTy(),
-           "Only global arrays can have appending linkage!", GVar);
+    Check(GVar && GVar->getValueType()->isArrayTy(),
   }
 
   if (GV.isDeclarationForLinker())
-    Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
+    Check(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
 
   if (GV.hasDLLImportStorageClass()) {
-    Assert(!GV.isDSOLocal(),
-           "GlobalValue with DLLImport Storage is dso_local!", &GV);
+    Check(!GV.isDSOLocal(), "GlobalValue with DLLImport Storage is dso_local!",
+          &GV);
 
-    Assert((GV.isDeclaration() &&
-            (GV.hasExternalLinkage() || GV.hasExternalWeakLinkage())) ||
-               GV.hasAvailableExternallyLinkage(),
-           "Global is marked as dllimport, but not external", &GV);
+    Check((GV.isDeclaration() &&
   }
 
   if (GV.isImplicitDSOLocal())
-    Assert(GV.isDSOLocal(),
-           "GlobalValue with local linkage or non-default "
-           "visibility must be dso_local!",
-           &GV);
+    Check(GV.isDSOLocal(),
 
   forEachUser(&GV, GlobalValueVisited, [&](const Value *V) -> bool {
     if (const Instruction *I = dyn_cast<Instruction>(V)) {
       if (!I->getParent() || !I->getParent()->getParent())
         CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
                     I);
       else if (I->getParent()->getParent()->getParent() != &M)
         CheckFailed("Global is referenced in a different module!", &GV, &M, I,
                     I->getParent()->getParent(),
                     I->getParent()->getParent()->getParent());
       return false;
     } else if (const Function *F = dyn_cast<Function>(V)) {
       if (F->getParent() != &M)
         CheckFailed("Global is used by function in a different module", &GV, &M,
                     F, F->getParent());
       return false;
     }
     return true;
   });
 }
 
 void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
   if (GV.hasInitializer()) {
-    Assert(GV.getInitializer()->getType() == GV.getValueType(),
-           "Global variable initializer type does not match global "
-           "variable type!",
-           &GV);
+    Check(GV.getInitializer()->getType() == GV.getValueType(),
     // If the global has common linkage, it must have a zero initializer and
     // cannot be constant.
     if (GV.hasCommonLinkage()) {
-      Assert(GV.getInitializer()->isNullValue(),
-             "'common' global must have a zero initializer!", &GV);
-      Assert(!GV.isConstant(), "'common' global may not be marked constant!",
-             &GV);
-      Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
+      Check(GV.getInitializer()->isNullValue(),
+      Check(!GV.isConstant(), "'common' global may not be marked constant!",
+      Check(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
     }
   }
 
   if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
                        GV.getName() == "llvm.global_dtors")) {
-    Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
-           "invalid linkage for intrinsic global variable", &GV);
+    Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
     // Don't worry about emitting an error for it not being an array,
     // visitGlobalValue will complain on appending non-array.
     if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
       StructType *STy = dyn_cast<StructType>(ATy->getElementType());
       PointerType *FuncPtrTy =
           FunctionType::get(Type::getVoidTy(Context), false)->
           getPointerTo(DL.getProgramAddressSpace());
-      Assert(STy &&
-                 (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
-                 STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
-                 STy->getTypeAtIndex(1) == FuncPtrTy,
-             "wrong type for intrinsic global variable", &GV);
-      Assert(STy->getNumElements() == 3,
-             "the third field of the element type is mandatory, "
-             "specify i8* null to migrate from the obsoleted 2-field form");
+      Check(STy && (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
+      Check(STy->getNumElements() == 3,
       Type *ETy = STy->getTypeAtIndex(2);
       Type *Int8Ty = Type::getInt8Ty(ETy->getContext());
-      Assert(ETy->isPointerTy() &&
-                 cast<PointerType>(ETy)->isOpaqueOrPointeeTypeMatches(Int8Ty),
-             "wrong type for intrinsic global variable", &GV);
+      Check(ETy->isPointerTy() &&
     }
   }
 
   if (GV.hasName() && (GV.getName() == "llvm.used" ||
                        GV.getName() == "llvm.compiler.used")) {
-    Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
-           "invalid linkage for intrinsic global variable", &GV);
+    Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
     Type *GVType = GV.getValueType();
     if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
       PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
-      Assert(PTy, "wrong type for intrinsic global variable", &GV);
+      Check(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);
+        Check(InitArray, "wrong initalizer for intrinsic global variable",
         for (Value *Op : InitArray->operands()) {
           Value *V = Op->stripPointerCasts();
-          Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
-                     isa<GlobalAlias>(V),
-                 Twine("invalid ") + GV.getName() + " member", V);
-          Assert(V->hasName(),
-                 Twine("members of ") + GV.getName() + " must be named", V);
+          Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
+          Check(V->hasName(),
         }
       }
     }
   }
 
   // Visit any debug info attachments.
   SmallVector<MDNode *, 1> MDs;
   GV.getMetadata(LLVMContext::MD_dbg, MDs);
   for (auto *MD : MDs) {
     if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
       visitDIGlobalVariableExpression(*GVE);
     else
-      AssertDI(false, "!dbg attachment of global variable must be a "
-                      "DIGlobalVariableExpression");
+      CheckDI(false, "!dbg attachment of global variable must be a "
   }
 
   // Scalable vectors cannot be global variables, since we don't know
   // the runtime size. If the global is an array containing scalable vectors,
   // that will be caught by the isValidElementType methods in StructType or
   // ArrayType instead.
-  Assert(!isa<ScalableVectorType>(GV.getValueType()),
-         "Globals cannot contain scalable vectors", &GV);
+  Check(!isa<ScalableVectorType>(GV.getValueType()),
 
   if (auto *STy = dyn_cast<StructType>(GV.getValueType()))
-    Assert(!STy->containsScalableVectorType(),
-           "Globals cannot contain scalable vectors", &GV);
+    Check(!STy->containsScalableVectorType(),
 
   if (!GV.hasInitializer()) {
     visitGlobalValue(GV);
     return;
   }
 
   // Walk any aggregate initializers looking for bitcasts between address spaces
   visitConstantExprsRecursively(GV.getInitializer());
 
   visitGlobalValue(GV);
 }
 
 void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
   SmallPtrSet<const GlobalAlias*, 4> Visited;
   Visited.insert(&GA);
   visitAliaseeSubExpr(Visited, GA, C);
 }
 
 void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
                                    const GlobalAlias &GA, const Constant &C) {
   if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
-    Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition",
-           &GA);
+    Check(!GV->isDeclarationForLinker(), "Alias must point to a definition",
 
     if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
-      Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
+      Check(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
 
-      Assert(!GA2->isInterposable(), "Alias cannot point to an interposable alias",
-             &GA);
+      Check(!GA2->isInterposable(),
+            "Alias cannot point to an interposable alias", &GA);
     } else {
       // Only continue verifying subexpressions of GlobalAliases.
       // Do not recurse into global initializers.
       return;
     }
   }
 
   if (const auto *CE = dyn_cast<ConstantExpr>(&C))
     visitConstantExprsRecursively(CE);
 
   for (const Use &U : C.operands()) {
     Value *V = &*U;
     if (const auto *GA2 = dyn_cast<GlobalAlias>(V))
       visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
     else if (const auto *C2 = dyn_cast<Constant>(V))
       visitAliaseeSubExpr(Visited, GA, *C2);
   }
 }
 
 void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
-  Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),
-         "Alias should have private, internal, linkonce, weak, linkonce_odr, "
-         "weak_odr, or external linkage!",
-         &GA);
+  Check(GlobalAlias::isValidLinkage(GA.getLinkage()),
   const Constant *Aliasee = GA.getAliasee();
-  Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
-  Assert(GA.getType() == Aliasee->getType(),
-         "Alias and aliasee types should match!", &GA);
+  Check(Aliasee, "Aliasee cannot be NULL!", &GA);
+  Check(GA.getType() == Aliasee->getType(),
 
-  Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
-         "Aliasee should be either GlobalValue or ConstantExpr", &GA);
+  Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
 
   visitAliaseeSubExpr(GA, *Aliasee);
 
   visitGlobalValue(GA);
 }
 
 void Verifier::visitGlobalIFunc(const GlobalIFunc &GI) {
-  Assert(GlobalIFunc::isValidLinkage(GI.getLinkage()),
-         "IFunc should have private, internal, linkonce, weak, linkonce_odr, "
-         "weak_odr, or external linkage!",
-         &GI);
+  Check(GlobalIFunc::isValidLinkage(GI.getLinkage()),
   // Pierce through ConstantExprs and GlobalAliases and check that the resolver
   // is a Function definition.
   const Function *Resolver = GI.getResolverFunction();
-  Assert(Resolver, "IFunc must have a Function resolver", &GI);
-  Assert(!Resolver->isDeclarationForLinker(),
-         "IFunc resolver must be a definition", &GI);
+  Check(Resolver, "IFunc must have a Function resolver", &GI);
+  Check(!Resolver->isDeclarationForLinker(),
 
   // Check that the immediate resolver operand (prior to any bitcasts) has the
   // correct type.
   const Type *ResolverTy = GI.getResolver()->getType();
   const Type *ResolverFuncTy =
       GlobalIFunc::getResolverFunctionType(GI.getValueType());
-  Assert(ResolverTy == ResolverFuncTy->getPointerTo(),
-         "IFunc resolver has incorrect type", &GI);
+  Check(ResolverTy == ResolverFuncTy->getPointerTo(),
 }
 
 void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
   // There used to be various other llvm.dbg.* nodes, but we don't support
   // upgrading them and we want to reserve the namespace for future uses.
   if (NMD.getName().startswith("llvm.dbg."))
-    AssertDI(NMD.getName() == "llvm.dbg.cu",
-             "unrecognized named metadata node in the llvm.dbg namespace",
-             &NMD);
+    CheckDI(NMD.getName() == "llvm.dbg.cu",
+            "unrecognized named metadata node in the llvm.dbg namespace", &NMD);
   for (const MDNode *MD : NMD.operands()) {
     if (NMD.getName() == "llvm.dbg.cu")
-      AssertDI(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD);
+      CheckDI(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD);
 
     if (!MD)
       continue;
 
     visitMDNode(*MD, AreDebugLocsAllowed::Yes);
   }
 }
 
 void Verifier::visitMDNode(const MDNode &MD, AreDebugLocsAllowed AllowLocs) {
   // Only visit each node once.  Metadata can be mutually recursive, so this
   // avoids infinite recursion here, as well as being an optimization.
   if (!MDNodes.insert(&MD).second)
     return;
 
-  Assert(&MD.getContext() == &Context,
-         "MDNode context does not match Module context!", &MD);
+  Check(&MD.getContext() == &Context,
 
   switch (MD.getMetadataID()) {
   default:
     llvm_unreachable("Invalid MDNode subclass");
   case Metadata::MDTupleKind:
     break;
 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)                                  \
   case Metadata::CLASS##Kind:                                                  \
     visit##CLASS(cast<CLASS>(MD));                                             \
     break;
 #include "llvm/IR/Metadata.def"
   }
 
   for (const Metadata *Op : MD.operands()) {
     if (!Op)
       continue;
-    Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
-           &MD, Op);
-    AssertDI(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed::Yes,
-             "DILocation not allowed within this metadata node", &MD, Op);
+    Check(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
+    CheckDI(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed::Yes,
     if (auto *N = dyn_cast<MDNode>(Op)) {
       visitMDNode(*N, AllowLocs);
       continue;
     }
     if (auto *V = dyn_cast<ValueAsMetadata>(Op)) {
       visitValueAsMetadata(*V, nullptr);
       continue;
     }
   }
 
   // Check these last, so we diagnose problems in operands first.
-  Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD);
-  Assert(MD.isResolved(), "All nodes should be resolved!", &MD);
+  Check(!MD.isTemporary(), "Expected no forward declarations!", &MD);
+  Check(MD.isResolved(), "All nodes should be resolved!", &MD);
 }
 
 void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
-  Assert(MD.getValue(), "Expected valid value", &MD);
-  Assert(!MD.getValue()->getType()->isMetadataTy(),
-         "Unexpected metadata round-trip through values", &MD, MD.getValue());
+  Check(MD.getValue(), "Expected valid value", &MD);
+  Check(!MD.getValue()->getType()->isMetadataTy(),
 
   auto *L = dyn_cast<LocalAsMetadata>(&MD);
   if (!L)
     return;
 
-  Assert(F, "function-local metadata used outside a function", L);
+  Check(F, "function-local metadata used outside a function", L);
 
   // If this was an instruction, bb, or argument, verify that it is in the
   // function that we expect.
   Function *ActualF = nullptr;
   if (Instruction *I = dyn_cast<Instruction>(L->getValue())) {
-    Assert(I->getParent(), "function-local metadata not in basic block", L, I);
+    Check(I->getParent(), "function-local metadata not in basic block", L, I);
     ActualF = I->getParent()->getParent();
   } else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue()))
     ActualF = BB->getParent();
   else if (Argument *A = dyn_cast<Argument>(L->getValue()))
     ActualF = A->getParent();
   assert(ActualF && "Unimplemented function local metadata case!");
 
-  Assert(ActualF == F, "function-local metadata used in wrong function", L);
+  Check(ActualF == F, "function-local metadata used in wrong function", L);
 }
 
 void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
   Metadata *MD = MDV.getMetadata();
   if (auto *N = dyn_cast<MDNode>(MD)) {
     visitMDNode(*N, AreDebugLocsAllowed::No);
     return;
   }
 
   // Only visit each node once.  Metadata can be mutually recursive, so this
   // avoids infinite recursion here, as well as being an optimization.
   if (!MDNodes.insert(MD).second)
     return;
 
   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
     visitValueAsMetadata(*V, F);
 }
 
 static bool isType(const Metadata *MD) { return !MD || isa<DIType>(MD); }
 static bool isScope(const Metadata *MD) { return !MD || isa<DIScope>(MD); }
 static bool isDINode(const Metadata *MD) { return !MD || isa<DINode>(MD); }
 
 void Verifier::visitDILocation(const DILocation &N) {
-  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
-           "location requires a valid scope", &N, N.getRawScope());
+  CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
   if (auto *IA = N.getRawInlinedAt())
-    AssertDI(isa<DILocation>(IA), "inlined-at should be a location", &N, IA);
+    CheckDI(isa<DILocation>(IA), "inlined-at should be a location", &N, IA);
   if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
-    AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
+    CheckDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
 }
 
 void Verifier::visitGenericDINode(const GenericDINode &N) {
-  AssertDI(N.getTag(), "invalid tag", &N);
+  CheckDI(N.getTag(), "invalid tag", &N);
 }
 
 void Verifier::visitDIScope(const DIScope &N) {
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
 }
 
 void Verifier::visitDISubrange(const DISubrange &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
   bool HasAssumedSizedArraySupport = dwarf::isFortran(CurrentSourceLang);
-  AssertDI(HasAssumedSizedArraySupport || N.getRawCountNode() ||
-               N.getRawUpperBound(),
-           "Subrange must contain count or upperBound", &N);
-  AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(),
-           "Subrange can have any one of count or upperBound", &N);
+  CheckDI(HasAssumedSizedArraySupport || N.getRawCountNode() ||
+  CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
   auto *CBound = N.getRawCountNode();
-  AssertDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
-               isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-           "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
   auto Count = N.getCount();
-  AssertDI(!Count || !Count.is<ConstantInt *>() ||
-               Count.get<ConstantInt *>()->getSExtValue() >= -1,
-           "invalid subrange count", &N);
+  CheckDI(!Count || !Count.is<ConstantInt *>() ||
   auto *LBound = N.getRawLowerBound();
-  AssertDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
-               isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-           "LowerBound must be signed constant or DIVariable or DIExpression",
-           &N);
+  CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
   auto *UBound = N.getRawUpperBound();
-  AssertDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
-               isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-           "UpperBound must be signed constant or DIVariable or DIExpression",
-           &N);
+  CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
   auto *Stride = N.getRawStride();
-  AssertDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
-               isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-           "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
 }
 
 void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N);
-  AssertDI(N.getRawCountNode() || N.getRawUpperBound(),
-           "GenericSubrange must contain count or upperBound", &N);
-  AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(),
-           "GenericSubrange can have any one of count or upperBound", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N);
+  CheckDI(N.getRawCountNode() || N.getRawUpperBound(),
+  CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
   auto *CBound = N.getRawCountNode();
-  AssertDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
-           "Count must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
   auto *LBound = N.getRawLowerBound();
-  AssertDI(LBound, "GenericSubrange must contain lowerBound", &N);
-  AssertDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
-           "LowerBound must be signed constant or DIVariable or DIExpression",
-           &N);
+  CheckDI(LBound, "GenericSubrange must contain lowerBound", &N);
+  CheckDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
   auto *UBound = N.getRawUpperBound();
-  AssertDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
-           "UpperBound must be signed constant or DIVariable or DIExpression",
-           &N);
+  CheckDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
   auto *Stride = N.getRawStride();
-  AssertDI(Stride, "GenericSubrange must contain stride", &N);
-  AssertDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
-           "Stride must be signed constant or DIVariable or DIExpression", &N);
+  CheckDI(Stride, "GenericSubrange must contain stride", &N);
+  CheckDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
 }
 
 void Verifier::visitDIEnumerator(const DIEnumerator &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
 }
 
 void Verifier::visitDIBasicType(const DIBasicType &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_base_type ||
-               N.getTag() == dwarf::DW_TAG_unspecified_type ||
-               N.getTag() == dwarf::DW_TAG_string_type,
-           "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_base_type ||
 }
 
 void Verifier::visitDIStringType(const DIStringType &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N);
-  AssertDI(!(N.isBigEndian() && N.isLittleEndian()) ,
-            "has conflicting flags", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N);
+  CheckDI(!(N.isBigEndian() && N.isLittleEndian()), "has conflicting flags",
+          &N);
 }
 
 void Verifier::visitDIDerivedType(const DIDerivedType &N) {
   // Common scope checks.
   visitDIScope(N);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||
-               N.getTag() == dwarf::DW_TAG_pointer_type ||
-               N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
-               N.getTag() == dwarf::DW_TAG_reference_type ||
-               N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
-               N.getTag() == dwarf::DW_TAG_const_type ||
-               N.getTag() == dwarf::DW_TAG_immutable_type ||
-               N.getTag() == dwarf::DW_TAG_volatile_type ||
-               N.getTag() == dwarf::DW_TAG_restrict_type ||
-               N.getTag() == dwarf::DW_TAG_atomic_type ||
-               N.getTag() == dwarf::DW_TAG_member ||
-               N.getTag() == dwarf::DW_TAG_inheritance ||
-               N.getTag() == dwarf::DW_TAG_friend ||
-               N.getTag() == dwarf::DW_TAG_set_type,
-           "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_typedef ||
   if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
-    AssertDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
-             N.getRawExtraData());
+    CheckDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
   }
 
   if (N.getTag() == dwarf::DW_TAG_set_type) {
     if (auto *T = N.getRawBaseType()) {
       auto *Enum = dyn_cast_or_null<DICompositeType>(T);
       auto *Basic = dyn_cast_or_null<DIBasicType>(T);
-      AssertDI(
+      CheckDI(
           (Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||
               (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned ||
                          Basic->getEncoding() == dwarf::DW_ATE_signed ||
                          Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||
                          Basic->getEncoding() == dwarf::DW_ATE_signed_char ||
                          Basic->getEncoding() == dwarf::DW_ATE_boolean)),
           "invalid set base type", &N, T);
     }
   }
 
-  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
-  AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,
-           N.getRawBaseType());
+  CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
+  CheckDI(isType(N.getRawBaseType()), "invalid base type", &N,
 
   if (N.getDWARFAddressSpace()) {
-    AssertDI(N.getTag() == dwarf::DW_TAG_pointer_type ||
-                 N.getTag() == dwarf::DW_TAG_reference_type ||
-                 N.getTag() == dwarf::DW_TAG_rvalue_reference_type,
-             "DWARF address space only applies to pointer or reference types",
-             &N);
+    CheckDI(N.getTag() == dwarf::DW_TAG_pointer_type ||
   }
 }
 
 /// Detect mutually exclusive flags.
 static bool hasConflictingReferenceFlags(unsigned Flags) {
   return ((Flags & DINode::FlagLValueReference) &&
           (Flags & DINode::FlagRValueReference)) ||
          ((Flags & DINode::FlagTypePassByValue) &&
           (Flags & DINode::FlagTypePassByReference));
 }
 
 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
   auto *Params = dyn_cast<MDTuple>(&RawParams);
-  AssertDI(Params, "invalid template params", &N, &RawParams);
+  CheckDI(Params, "invalid template params", &N, &RawParams);
   for (Metadata *Op : Params->operands()) {
-    AssertDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
-             &N, Params, Op);
+    CheckDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
   }
 }
 
 void Verifier::visitDICompositeType(const DICompositeType &N) {
   // Common scope checks.
   visitDIScope(N);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_array_type ||
-               N.getTag() == dwarf::DW_TAG_structure_type ||
-               N.getTag() == dwarf::DW_TAG_union_type ||
-               N.getTag() == dwarf::DW_TAG_enumeration_type ||
-               N.getTag() == dwarf::DW_TAG_class_type ||
-               N.getTag() == dwarf::DW_TAG_variant_part ||
-               N.getTag() == dwarf::DW_TAG_namelist,
-           "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_array_type ||
 
-  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
-  AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,
-           N.getRawBaseType());
+  CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
+  CheckDI(isType(N.getRawBaseType()), "invalid base type", &N,
 
-  AssertDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
-           "invalid composite elements", &N, N.getRawElements());
-  AssertDI(isType(N.getRawVTableHolder()), "invalid vtable holder", &N,
-           N.getRawVTableHolder());
-  AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
-           "invalid reference flags", &N);
+  CheckDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
+  CheckDI(isType(N.getRawVTableHolder()), "invalid vtable holder", &N,
+  CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
   unsigned DIBlockByRefStruct = 1 << 4;
-  AssertDI((N.getFlags() & DIBlockByRefStruct) == 0,
-           "DIBlockByRefStruct on DICompositeType is no longer supported", &N);
+  CheckDI((N.getFlags() & DIBlockByRefStruct) == 0,
 
   if (N.isVector()) {
     const DINodeArray Elements = N.getElements();
-    AssertDI(Elements.size() == 1 &&
+    CheckDI(Elements.size() == 1 &&
                 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,
-             "invalid vector, expected one element of type subrange", &N);
   }
 
   if (auto *Params = N.getRawTemplateParams())
     visitTemplateParams(N, *Params);
 
   if (auto *D = N.getRawDiscriminator()) {
-    AssertDI(isa<DIDerivedType>(D) && N.getTag() == dwarf::DW_TAG_variant_part,
-             "discriminator can only appear on variant part");
+    CheckDI(isa<DIDerivedType>(D) && N.getTag() == dwarf::DW_TAG_variant_part,
   }
 
   if (N.getRawDataLocation()) {
-    AssertDI(N.getTag() == dwarf::DW_TAG_array_type,
-             "dataLocation can only appear in array type");
+    CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
   }
 
   if (N.getRawAssociated()) {
-    AssertDI(N.getTag() == dwarf::DW_TAG_array_type,
-             "associated can only appear in array type");
+    CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
   }
 
   if (N.getRawAllocated()) {
-    AssertDI(N.getTag() == dwarf::DW_TAG_array_type,
-             "allocated can only appear in array type");
+    CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
   }
 
   if (N.getRawRank()) {
-    AssertDI(N.getTag() == dwarf::DW_TAG_array_type,
-             "rank can only appear in array type");
+    CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
   }
 }
 
 void Verifier::visitDISubroutineType(const DISubroutineType &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
   if (auto *Types = N.getRawTypeArray()) {
-    AssertDI(isa<MDTuple>(Types), "invalid composite elements", &N, Types);
+    CheckDI(isa<MDTuple>(Types), "invalid composite elements", &N, Types);
     for (Metadata *Ty : N.getTypeArray()->operands()) {
-      AssertDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty);
+      CheckDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty);
     }
   }
-  AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
-           "invalid reference flags", &N);
+  CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
 }
 
 void Verifier::visitDIFile(const DIFile &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
   Optional<DIFile::ChecksumInfo<StringRef>> Checksum = N.getChecksum();
   if (Checksum) {
-    AssertDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,
-             "invalid checksum kind", &N);
+    CheckDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,
     size_t Size;
     switch (Checksum->Kind) {
     case DIFile::CSK_MD5:
       Size = 32;
       break;
     case DIFile::CSK_SHA1:
       Size = 40;
       break;
     case DIFile::CSK_SHA256:
       Size = 64;
       break;
     }
-    AssertDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
-    AssertDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,
-             "invalid checksum", &N);
+    CheckDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
+    CheckDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,
   }
 }
 
 void Verifier::visitDICompileUnit(const DICompileUnit &N) {
-  AssertDI(N.isDistinct(), "compile units must be distinct", &N);
-  AssertDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
+  CheckDI(N.isDistinct(), "compile units must be distinct", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
 
   // Don't bother verifying the compilation directory or producer string
   // as those could be empty.
-  AssertDI(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N,
-           N.getRawFile());
-  AssertDI(!N.getFile()->getFilename().empty(), "invalid filename", &N,
-           N.getFile());
+  CheckDI(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N,
+  CheckDI(!N.getFile()->getFilename().empty(), "invalid filename", &N,
 
   CurrentSourceLang = (dwarf::SourceLanguage)N.getSourceLanguage();
 
   verifySourceDebugInfo(N, *N.getFile());
 
-  AssertDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),
-           "invalid emission kind", &N);
+  CheckDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),
 
   if (auto *Array = N.getRawEnumTypes()) {
-    AssertDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
     for (Metadata *Op : N.getEnumTypes()->operands()) {
       auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
-      AssertDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
-               "invalid enum type", &N, N.getEnumTypes(), Op);
+      CheckDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
     }
   }
   if (auto *Array = N.getRawRetainedTypes()) {
-    AssertDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
     for (Metadata *Op : N.getRetainedTypes()->operands()) {
-      AssertDI(Op && (isa<DIType>(Op) ||
-                      (isa<DISubprogram>(Op) &&
+      CheckDI(
+          Op && (isa<DIType>(Op) || (isa<DISubprogram>(Op) &&
                                      !cast<DISubprogram>(Op)->isDefinition())),
-               "invalid retained type", &N, Op);
     }
   }
   if (auto *Array = N.getRawGlobalVariables()) {
-    AssertDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
     for (Metadata *Op : N.getGlobalVariables()->operands()) {
-      AssertDI(Op && (isa<DIGlobalVariableExpression>(Op)),
-               "invalid global variable ref", &N, Op);
+      CheckDI(Op && (isa<DIGlobalVariableExpression>(Op)),
     }
   }
   if (auto *Array = N.getRawImportedEntities()) {
-    AssertDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
     for (Metadata *Op : N.getImportedEntities()->operands()) {
-      AssertDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",
-               &N, Op);
+      CheckDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",
     }
   }
   if (auto *Array = N.getRawMacros()) {
-    AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
     for (Metadata *Op : N.getMacros()->operands()) {
-      AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
+      CheckDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
     }
   }
   CUVisited.insert(&N);
 }
 
 void Verifier::visitDISubprogram(const DISubprogram &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
-  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
+  CheckDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
+  CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
   else
-    AssertDI(N.getLine() == 0, "line specified with no file", &N, N.getLine());
+    CheckDI(N.getLine() == 0, "line specified with no file", &N, N.getLine());
   if (auto *T = N.getRawType())
-    AssertDI(isa<DISubroutineType>(T), "invalid subroutine type", &N, T);
-  AssertDI(isType(N.getRawContainingType()), "invalid containing type", &N,
-           N.getRawContainingType());
+    CheckDI(isa<DISubroutineType>(T), "invalid subroutine type", &N, T);
+  CheckDI(isType(N.getRawContainingType()), "invalid containing type", &N,
   if (auto *Params = N.getRawTemplateParams())
     visitTemplateParams(N, *Params);
   if (auto *S = N.getRawDeclaration())
-    AssertDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
-             "invalid subprogram declaration", &N, S);
+    CheckDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
   if (auto *RawNode = N.getRawRetainedNodes()) {
     auto *Node = dyn_cast<MDTuple>(RawNode);
-    AssertDI(Node, "invalid retained nodes list", &N, RawNode);
+    CheckDI(Node, "invalid retained nodes list", &N, RawNode);
     for (Metadata *Op : Node->operands()) {
-      AssertDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),
-               "invalid retained nodes, expected DILocalVariable or DILabel",
-               &N, Node, Op);
+      CheckDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),
+              "invalid retained nodes, expected DILocalVariable or DILabel", &N,
+              Node, Op);
     }
   }
-  AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
-           "invalid reference flags", &N);
+  CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
 
   auto *Unit = N.getRawUnit();
   if (N.isDefinition()) {
     // Subprogram definitions (not part of the type hierarchy).
-    AssertDI(N.isDistinct(), "subprogram definitions must be distinct", &N);
-    AssertDI(Unit, "subprogram definitions must have a compile unit", &N);
-    AssertDI(isa<DICompileUnit>(Unit), "invalid unit type", &N, Unit);
+    CheckDI(N.isDistinct(), "subprogram definitions must be distinct", &N);
+    CheckDI(Unit, "subprogram definitions must have a compile unit", &N);
+    CheckDI(isa<DICompileUnit>(Unit), "invalid unit type", &N, Unit);
     if (N.getFile())
       verifySourceDebugInfo(*N.getUnit(), *N.getFile());
   } else {
     // Subprogram declarations (part of the type hierarchy).
-    AssertDI(!Unit, "subprogram declarations must not have a compile unit", &N);
+    CheckDI(!Unit, "subprogram declarations must not have a compile unit", &N);
   }
 
   if (auto *RawThrownTypes = N.getRawThrownTypes()) {
     auto *ThrownTypes = dyn_cast<MDTuple>(RawThrownTypes);
-    AssertDI(ThrownTypes, "invalid thrown types list", &N, RawThrownTypes);
+    CheckDI(ThrownTypes, "invalid thrown types list", &N, RawThrownTypes);
     for (Metadata *Op : ThrownTypes->operands())
-      AssertDI(Op && isa<DIType>(Op), "invalid thrown type", &N, ThrownTypes,
-               Op);
+      CheckDI(Op && isa<DIType>(Op), "invalid thrown type", &N, ThrownTypes,
   }
 
   if (N.areAllCallsDescribed())
-    AssertDI(N.isDefinition(),
-             "DIFlagAllCallsDescribed must be attached to a definition");
+    CheckDI(N.isDefinition(),
 }
 
 void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
-  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
-           "invalid local scope", &N, N.getRawScope());
+  CheckDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
+  CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
   if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
-    AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
+    CheckDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
 }
 
 void Verifier::visitDILexicalBlock(const DILexicalBlock &N) {
   visitDILexicalBlockBase(N);
 
-  AssertDI(N.getLine() || !N.getColumn(),
-           "cannot have column info without line info", &N);
+  CheckDI(N.getLine() || !N.getColumn(),
 }
 
 void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) {
   visitDILexicalBlockBase(N);
 }
 
 void Verifier::visitDICommonBlock(const DICommonBlock &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_common_block, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_common_block, "invalid tag", &N);
   if (auto *S = N.getRawScope())
-    AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S);
+    CheckDI(isa<DIScope>(S), "invalid scope ref", &N, S);
   if (auto *S = N.getRawDecl())
-    AssertDI(isa<DIGlobalVariable>(S), "invalid declaration", &N, S);
+    CheckDI(isa<DIGlobalVariable>(S), "invalid declaration", &N, S);
 }
 
 void Verifier::visitDINamespace(const DINamespace &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
   if (auto *S = N.getRawScope())
-    AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S);
+    CheckDI(isa<DIScope>(S), "invalid scope ref", &N, S);
 }
 
 void Verifier::visitDIMacro(const DIMacro &N) {
-  AssertDI(N.getMacinfoType() == dwarf::DW_MACINFO_define ||
-               N.getMacinfoType() == dwarf::DW_MACINFO_undef,
-           "invalid macinfo type", &N);
-  AssertDI(!N.getName().empty(), "anonymous macro", &N);
+  CheckDI(N.getMacinfoType() == dwarf::DW_MACINFO_define ||
+  CheckDI(!N.getName().empty(), "anonymous macro", &N);
   if (!N.getValue().empty()) {
     assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix");
   }
 }
 
 void Verifier::visitDIMacroFile(const DIMacroFile &N) {
-  AssertDI(N.getMacinfoType() == dwarf::DW_MACINFO_start_file,
-           "invalid macinfo type", &N);
+  CheckDI(N.getMacinfoType() == dwarf::DW_MACINFO_start_file,
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
 
   if (auto *Array = N.getRawElements()) {
-    AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
+    CheckDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
     for (Metadata *Op : N.getElements()->operands()) {
-      AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
+      CheckDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
     }
   }
 }
 
 void Verifier::visitDIArgList(const DIArgList &N) {
-  AssertDI(!N.getNumOperands(),
-           "DIArgList should have no operands other than a list of "
-           "ValueAsMetadata",
-           &N);
+  CheckDI(!N.getNumOperands(),
 }
 
 void Verifier::visitDIModule(const DIModule &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N);
-  AssertDI(!N.getName().empty(), "anonymous module", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N);
+  CheckDI(!N.getName().empty(), "anonymous module", &N);
 }
 
 void Verifier::visitDITemplateParameter(const DITemplateParameter &N) {
-  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
+  CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
 }
 
 void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) {
   visitDITemplateParameter(N);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
-           &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
 }
 
 void Verifier::visitDITemplateValueParameter(
     const DITemplateValueParameter &N) {
   visitDITemplateParameter(N);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
-               N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
-               N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
-           "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
 }
 
 void Verifier::visitDIVariable(const DIVariable &N) {
   if (auto *S = N.getRawScope())
-    AssertDI(isa<DIScope>(S), "invalid scope", &N, S);
+    CheckDI(isa<DIScope>(S), "invalid scope", &N, S);
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
 }
 
 void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) {
   // Checks common to all variables.
   visitDIVariable(N);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
-  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
-  // Assert only if the global variable is not an extern
+  CheckDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
+  CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
+  // Check only if the global variable is not an extern
   if (N.isDefinition())
-    AssertDI(N.getType(), "missing global variable type", &N);
+    CheckDI(N.getType(), "missing global variable type", &N);
   if (auto *Member = N.getRawStaticDataMemberDeclaration()) {
-    AssertDI(isa<DIDerivedType>(Member),
-             "invalid static data member declaration", &N, Member);
+    CheckDI(isa<DIDerivedType>(Member),
   }
 }
 
 void Verifier::visitDILocalVariable(const DILocalVariable &N) {
   // Checks common to all variables.
   visitDIVariable(N);
 
-  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
-  AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
-  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
-           "local variable requires a valid scope", &N, N.getRawScope());
+  CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
+  CheckDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
+  CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
   if (auto Ty = N.getType())
-    AssertDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType());
+    CheckDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType());
 }
 
 void Verifier::visitDILabel(const DILabel &N) {
   if (auto *S = N.getRawScope())
-    AssertDI(isa<DIScope>(S), "invalid scope", &N, S);
+    CheckDI(isa<DIScope>(S), "invalid scope", &N, S);
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
 
-  AssertDI(N.getTag() == dwarf::DW_TAG_label, "invalid tag", &N);
-  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
-           "label requires a valid scope", &N, N.getRawScope());
+  CheckDI(N.getTag() == dwarf::DW_TAG_label, "invalid tag", &N);
+  CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
 }
 
 void Verifier::visitDIExpression(const DIExpression &N) {
-  AssertDI(N.isValid(), "invalid expression", &N);
+  CheckDI(N.isValid(), "invalid expression", &N);
 }
 
 void Verifier::visitDIGlobalVariableExpression(
     const DIGlobalVariableExpression &GVE) {
-  AssertDI(GVE.getVariable(), "missing variable");
+  CheckDI(GVE.getVariable(), "missing variable");
   if (auto *Var = GVE.getVariable())
     visitDIGlobalVariable(*Var);
   if (auto *Expr = GVE.getExpression()) {
     visitDIExpression(*Expr);
     if (auto Fragment = Expr->getFragmentInfo())
       verifyFragmentExpression(*GVE.getVariable(), *Fragment, &GVE);
   }
 }
 
 void Verifier::visitDIObjCProperty(const DIObjCProperty &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
   if (auto *T = N.getRawType())
-    AssertDI(isType(T), "invalid type ref", &N, T);
+    CheckDI(isType(T), "invalid type ref", &N, T);
   if (auto *F = N.getRawFile())
-    AssertDI(isa<DIFile>(F), "invalid file", &N, F);
+    CheckDI(isa<DIFile>(F), "invalid file", &N, F);
 }
 
 void Verifier::visitDIImportedEntity(const DIImportedEntity &N) {
-  AssertDI(N.getTag() == dwarf::DW_TAG_imported_module ||
-               N.getTag() == dwarf::DW_TAG_imported_declaration,
-           "invalid tag", &N);
+  CheckDI(N.getTag() == dwarf::DW_TAG_imported_module ||
   if (auto *S = N.getRawScope())
-    AssertDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S);
-  AssertDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,
-           N.getRawEntity());
+    CheckDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S);
+  CheckDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,
 }
 
 void Verifier::visitComdat(const Comdat &C) {
   // In COFF the Module is invalid if the GlobalValue has private linkage.
   // Entities with private linkage don't have entries in the symbol table.
   if (TT.isOSBinFormatCOFF())
     if (const GlobalValue *GV = M.getNamedValue(C.getName()))
-      Assert(!GV->hasPrivateLinkage(),
-             "comdat global value has private linkage", GV);
+      Check(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
+            GV);
 }
 
 void Verifier::visitModuleIdents() {
   const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident");
   if (!Idents)
     return;
 
   // llvm.ident takes a list of metadata entry. Each entry has only one string.
   // Scan each llvm.ident entry and make sure that this requirement is met.
   for (const MDNode *N : Idents->operands()) {
-    Assert(N->getNumOperands() == 1,
-           "incorrect number of operands in llvm.ident metadata", N);
-    Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
-           ("invalid value for llvm.ident metadata entry operand"
-            "(the operand should be a string)"),
-           N->getOperand(0));
+    Check(N->getNumOperands() == 1,
+    Check(dyn_cast_or_null<MDString>(N->getOperand(0)),
   }
 }
 
 void Verifier::visitModuleCommandLines() {
   const NamedMDNode *CommandLines = M.getNamedMetadata("llvm.commandline");
   if (!CommandLines)
     return;
 
   // llvm.commandline takes a list of metadata entry. Each entry has only one
   // string. Scan each llvm.commandline entry and make sure that this
   // requirement is met.
   for (const MDNode *N : CommandLines->operands()) {
-    Assert(N->getNumOperands() == 1,
-           "incorrect number of operands in llvm.commandline metadata", N);
-    Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
-           ("invalid value for llvm.commandline metadata entry operand"
-            "(the operand should be a string)"),
-           N->getOperand(0));
+    Check(N->getNumOperands() == 1,
+    Check(dyn_cast_or_null<MDString>(N->getOperand(0)),
   }
 }
 
 void Verifier::visitModuleFlags() {
   const NamedMDNode *Flags = M.getModuleFlagsMetadata();
   if (!Flags) return;
 
   // Scan each flag, and track the flags and requirements.

 }
 
 void
 Verifier::visitModuleFlag(const MDNode *Op,
                           DenseMap<const MDString *, const MDNode *> &SeenIDs,
                           SmallVectorImpl<const MDNode *> &Requirements) {
   // Each module flag should have three arguments, the merge behavior (a
   // constant int), the flag ID (an MDString), and the value.
-  Assert(Op->getNumOperands() == 3,
-         "incorrect number of operands in module flag", Op);
+  Check(Op->getNumOperands() == 3,
   Module::ModFlagBehavior MFB;
   if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
-    Assert(
-        mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
+    Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
           "invalid behavior operand in module flag (expected constant integer)",
           Op->getOperand(0));
-    Assert(false,
-           "invalid behavior operand in module flag (unexpected constant)",
-           Op->getOperand(0));
+    Check(false,
   }
   MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
-  Assert(ID, "invalid ID operand in module flag (expected metadata string)",
-         Op->getOperand(1));
+  Check(ID, "invalid ID operand in module flag (expected metadata string)",
 
   // Check the values for behaviors with additional requirements.
   switch (MFB) {
   case Module::Error:
   case Module::Warning:
   case Module::Override:
     // These behavior types accept any value.
     break;
 
   case Module::Max: {
-    Assert(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),
-           "invalid value for 'max' module flag (expected constant integer)",
-           Op->getOperand(2));
+    Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),
     break;
   }
 
   case Module::Require: {
     // The value should itself be an MDNode with two operands, a flag ID (an
     // MDString), and a value.
     MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
-    Assert(Value && Value->getNumOperands() == 2,
-           "invalid value for 'require' module flag (expected metadata pair)",
-           Op->getOperand(2));
-    Assert(isa<MDString>(Value->getOperand(0)),
-           ("invalid value for 'require' module flag "
-            "(first value operand should be a string)"),
-           Value->getOperand(0));
+    Check(Value && Value->getNumOperands() == 2,
+    Check(isa<MDString>(Value->getOperand(0)),
 
     // Append it to the list of requirements, to check once all module flags are
     // scanned.
     Requirements.push_back(Value);
     break;
   }
 
   case Module::Append:
   case Module::AppendUnique: {
     // These behavior types require the operand be an MDNode.
-    Assert(isa<MDNode>(Op->getOperand(2)),
-           "invalid value for 'append'-type module flag "
-           "(expected a metadata node)",
-           Op->getOperand(2));
+    Check(isa<MDNode>(Op->getOperand(2)),
     break;
   }
   }
 
   // Unless this is a "requires" flag, check the ID is unique.
   if (MFB != Module::Require) {
     bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
-    Assert(Inserted,
-           "module flag identifiers must be unique (or of 'require' type)", ID);
+    Check(Inserted,
   }
 
   if (ID->getString() == "wchar_size") {
     ConstantInt *Value
       = mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2));
-    Assert(Value, "wchar_size metadata requires constant integer argument");
+    Check(Value, "wchar_size metadata requires constant integer argument");
   }
 
   if (ID->getString() == "Linker Options") {
     // If the llvm.linker.options named metadata exists, we assume that the
     // bitcode reader has upgraded the module flag. Otherwise the flag might
     // have been created by a client directly.
-    Assert(M.getNamedMetadata("llvm.linker.options"),
-           "'Linker Options' named metadata no longer supported");
+    Check(M.getNamedMetadata("llvm.linker.options"),
   }
 
   if (ID->getString() == "SemanticInterposition") {
     ConstantInt *Value =
         mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2));
-    Assert(Value,
-           "SemanticInterposition metadata requires constant integer argument");
+    Check(Value,
   }
 
   if (ID->getString() == "CG Profile") {
     for (const MDOperand &MDO : cast<MDNode>(Op->getOperand(2))->operands())
       visitModuleFlagCGProfileEntry(MDO);
   }
 }
 
 void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) {
   auto CheckFunction = [&](const MDOperand &FuncMDO) {
     if (!FuncMDO)
       return;
     auto F = dyn_cast<ValueAsMetadata>(FuncMDO);
-    Assert(F && isa<Function>(F->getValue()->stripPointerCasts()),
-           "expected a Function or null", FuncMDO);
+    Check(F && isa<Function>(F->getValue()->stripPointerCasts()),
   };
   auto Node = dyn_cast_or_null<MDNode>(MDO);
-  Assert(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO);
+  Check(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO);
   CheckFunction(Node->getOperand(0));
   CheckFunction(Node->getOperand(1));
   auto Count = dyn_cast_or_null<ConstantAsMetadata>(Node->getOperand(2));
-  Assert(Count && Count->getType()->isIntegerTy(),
-         "expected an integer constant", Node->getOperand(2));
+  Check(Count && Count->getType()->isIntegerTy(),
 }
 
 void Verifier::verifyAttributeTypes(AttributeSet Attrs, const Value *V) {
   for (Attribute A : Attrs) {
 
     if (A.isStringAttribute()) {
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)

 void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
                                     const Value *V) {
   if (!Attrs.hasAttributes())
     return;
 
   verifyAttributeTypes(Attrs, V);
 
   for (Attribute Attr : Attrs)
-    Assert(Attr.isStringAttribute() ||
+    Check(Attr.isStringAttribute() ||
               Attribute::canUseAsParamAttr(Attr.getKindAsEnum()),
-           "Attribute '" + Attr.getAsString() +
-               "' does not apply to parameters",
-           V);
+          "Attribute '" + Attr.getAsString() + "' does not apply to parameters",
 
   if (Attrs.hasAttribute(Attribute::ImmArg)) {
-    Assert(Attrs.getNumAttributes() == 1,
-           "Attribute 'immarg' is incompatible with other attributes", V);
+    Check(Attrs.getNumAttributes() == 1,
   }
 
   // Check for mutually incompatible attributes.  Only inreg is compatible with
   // sret.
   unsigned AttrCount = 0;
   AttrCount += Attrs.hasAttribute(Attribute::ByVal);
   AttrCount += Attrs.hasAttribute(Attribute::InAlloca);
   AttrCount += Attrs.hasAttribute(Attribute::Preallocated);
   AttrCount += Attrs.hasAttribute(Attribute::StructRet) ||
                Attrs.hasAttribute(Attribute::InReg);
   AttrCount += Attrs.hasAttribute(Attribute::Nest);
   AttrCount += Attrs.hasAttribute(Attribute::ByRef);
-  Assert(AttrCount <= 1,
-         "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
-         "'byref', and 'sret' are incompatible!",
-         V);
+  Check(AttrCount <= 1,
 
-  Assert(!(Attrs.hasAttribute(Attribute::InAlloca) &&
-           Attrs.hasAttribute(Attribute::ReadOnly)),
-         "Attributes "
-         "'inalloca and readonly' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::InAlloca) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::StructRet) &&
-           Attrs.hasAttribute(Attribute::Returned)),
-         "Attributes "
-         "'sret and returned' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::StructRet) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::ZExt) &&
-           Attrs.hasAttribute(Attribute::SExt)),
-         "Attributes "
-         "'zeroext and signext' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::ZExt) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&
-           Attrs.hasAttribute(Attribute::ReadOnly)),
-         "Attributes "
-         "'readnone and readonly' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&
-           Attrs.hasAttribute(Attribute::WriteOnly)),
-         "Attributes "
-         "'readnone and writeonly' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
-           Attrs.hasAttribute(Attribute::WriteOnly)),
-         "Attributes "
-         "'readonly and writeonly' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
 
-  Assert(!(Attrs.hasAttribute(Attribute::NoInline) &&
-           Attrs.hasAttribute(Attribute::AlwaysInline)),
-         "Attributes "
-         "'noinline and alwaysinline' are incompatible!",
-         V);
+  Check(!(Attrs.hasAttribute(Attribute::NoInline) &&
 
   AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(Ty);
   for (Attribute Attr : Attrs) {
     if (!Attr.isStringAttribute() &&
         IncompatibleAttrs.contains(Attr.getKindAsEnum())) {
       CheckFailed("Attribute '" + Attr.getAsString() +
                   "' applied to incompatible type!", V);
       return;
     }
   }
 
   if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
     if (Attrs.hasAttribute(Attribute::ByVal)) {
       SmallPtrSet<Type *, 4> Visited;
-      Assert(Attrs.getByValType()->isSized(&Visited),
-             "Attribute 'byval' does not support unsized types!", V);
+      Check(Attrs.getByValType()->isSized(&Visited),
     }
     if (Attrs.hasAttribute(Attribute::ByRef)) {
       SmallPtrSet<Type *, 4> Visited;
-      Assert(Attrs.getByRefType()->isSized(&Visited),
-             "Attribute 'byref' does not support unsized types!", V);
+      Check(Attrs.getByRefType()->isSized(&Visited),
     }
     if (Attrs.hasAttribute(Attribute::InAlloca)) {
       SmallPtrSet<Type *, 4> Visited;
-      Assert(Attrs.getInAllocaType()->isSized(&Visited),
-             "Attribute 'inalloca' does not support unsized types!", V);
+      Check(Attrs.getInAllocaType()->isSized(&Visited),
     }
     if (Attrs.hasAttribute(Attribute::Preallocated)) {
       SmallPtrSet<Type *, 4> Visited;
-      Assert(Attrs.getPreallocatedType()->isSized(&Visited),
-             "Attribute 'preallocated' does not support unsized types!", V);
+      Check(Attrs.getPreallocatedType()->isSized(&Visited),
     }
     if (!PTy->isOpaque()) {
       if (!isa<PointerType>(PTy->getNonOpaquePointerElementType()))
-        Assert(!Attrs.hasAttribute(Attribute::SwiftError),
-               "Attribute 'swifterror' only applies to parameters "
-               "with pointer to pointer type!",
-               V);
+        Check(!Attrs.hasAttribute(Attribute::SwiftError),
       if (Attrs.hasAttribute(Attribute::ByRef)) {
-        Assert(Attrs.getByRefType() == PTy->getNonOpaquePointerElementType(),
-               "Attribute 'byref' type does not match parameter!", V);
+        Check(Attrs.getByRefType() == PTy->getNonOpaquePointerElementType(),
       }
 
       if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) {
-        Assert(Attrs.getByValType() == PTy->getNonOpaquePointerElementType(),
-               "Attribute 'byval' type does not match parameter!", V);
+        Check(Attrs.getByValType() == PTy->getNonOpaquePointerElementType(),
       }
 
       if (Attrs.hasAttribute(Attribute::Preallocated)) {
-        Assert(Attrs.getPreallocatedType() ==
-                   PTy->getNonOpaquePointerElementType(),
-               "Attribute 'preallocated' type does not match parameter!", V);
+        Check(Attrs.getPreallocatedType() ==
       }
 
       if (Attrs.hasAttribute(Attribute::InAlloca)) {
-        Assert(Attrs.getInAllocaType() == PTy->getNonOpaquePointerElementType(),
-               "Attribute 'inalloca' type does not match parameter!", V);
+        Check(Attrs.getInAllocaType() == PTy->getNonOpaquePointerElementType(),
       }
 
       if (Attrs.hasAttribute(Attribute::ElementType)) {
-        Assert(Attrs.getElementType() == PTy->getNonOpaquePointerElementType(),
-               "Attribute 'elementtype' type does not match parameter!", V);
+        Check(Attrs.getElementType() == PTy->getNonOpaquePointerElementType(),
       }
     }
   }
 }
 
 void Verifier::checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
                                             const Value *V) {
   if (Attrs.hasFnAttr(Attr)) {
     StringRef S = Attrs.getFnAttr(Attr).getValueAsString();
     unsigned N;
     if (S.getAsInteger(10, N))
       CheckFailed("\"" + Attr + "\" takes an unsigned integer: " + S, V);
   }
 }
 
 // Check parameter attributes against a function type.
 // The value V is printed in error messages.
 void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
                                    const Value *V, bool IsIntrinsic,
                                    bool IsInlineAsm) {
   if (Attrs.isEmpty())
     return;
 
   if (AttributeListsVisited.insert(Attrs.getRawPointer()).second) {
-    Assert(Attrs.hasParentContext(Context),
-           "Attribute list does not match Module context!", &Attrs, V);
+    Check(Attrs.hasParentContext(Context),
     for (const auto &AttrSet : Attrs) {
-      Assert(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),
-             "Attribute set does not match Module context!", &AttrSet, V);
+      Check(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),
       for (const auto &A : AttrSet) {
-        Assert(A.hasParentContext(Context),
-               "Attribute does not match Module context!", &A, V);
+        Check(A.hasParentContext(Context),
       }
     }
   }
 
   bool SawNest = false;
   bool SawReturned = false;
   bool SawSRet = false;
   bool SawSwiftSelf = false;
   bool SawSwiftAsync = false;
   bool SawSwiftError = false;
 
   // Verify return value attributes.
   AttributeSet RetAttrs = Attrs.getRetAttrs();
   for (Attribute RetAttr : RetAttrs)
-    Assert(RetAttr.isStringAttribute() ||
+    Check(RetAttr.isStringAttribute() ||
               Attribute::canUseAsRetAttr(RetAttr.getKindAsEnum()),
-           "Attribute '" + RetAttr.getAsString() +
-               "' does not apply to function return values",
-           V);
 
   verifyParameterAttrs(RetAttrs, FT->getReturnType(), V);
 
   // Verify parameter attributes.
   for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
     Type *Ty = FT->getParamType(i);
     AttributeSet ArgAttrs = Attrs.getParamAttrs(i);
 
     if (!IsIntrinsic) {
-      Assert(!ArgAttrs.hasAttribute(Attribute::ImmArg),
-             "immarg attribute only applies to intrinsics",V);
+      Check(!ArgAttrs.hasAttribute(Attribute::ImmArg),
+            "immarg attribute only applies to intrinsics", V);
       if (!IsInlineAsm)
-        Assert(!ArgAttrs.hasAttribute(Attribute::ElementType),
-               "Attribute 'elementtype' can only be applied to intrinsics"
-               " and inline asm.", V);
+        Check(!ArgAttrs.hasAttribute(Attribute::ElementType),
+              " and inline asm.",
+              V);
     }
 
     verifyParameterAttrs(ArgAttrs, Ty, V);
 
     if (ArgAttrs.hasAttribute(Attribute::Nest)) {
-      Assert(!SawNest, "More than one parameter has attribute nest!", V);
+      Check(!SawNest, "More than one parameter has attribute nest!", V);
       SawNest = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::Returned)) {
-      Assert(!SawReturned, "More than one parameter has attribute returned!",
-             V);
-      Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
-             "Incompatible argument and return types for 'returned' attribute",
-             V);
+      Check(!SawReturned, "More than one parameter has attribute returned!", V);
+      Check(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
       SawReturned = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::StructRet)) {
-      Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
-      Assert(i == 0 || i == 1,
-             "Attribute 'sret' is not on first or second parameter!", V);
+      Check(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
+      Check(i == 0 || i == 1,
       SawSRet = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::SwiftSelf)) {
-      Assert(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V);
+      Check(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V);
       SawSwiftSelf = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::SwiftAsync)) {
-      Assert(!SawSwiftAsync, "Cannot have multiple 'swiftasync' parameters!", V);
+      Check(!SawSwiftAsync, "Cannot have multiple 'swiftasync' parameters!", V);
       SawSwiftAsync = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::SwiftError)) {
-      Assert(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!",
-             V);
+      Check(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!", V);
       SawSwiftError = true;
     }
 
     if (ArgAttrs.hasAttribute(Attribute::InAlloca)) {
-      Assert(i == FT->getNumParams() - 1,
-             "inalloca isn't on the last parameter!", V);
+      Check(i == FT->getNumParams() - 1,
     }
   }
 
   if (!Attrs.hasFnAttrs())
     return;
 
   verifyAttributeTypes(Attrs.getFnAttrs(), V);
   for (Attribute FnAttr : Attrs.getFnAttrs())
-    Assert(FnAttr.isStringAttribute() ||
+    Check(FnAttr.isStringAttribute() ||
               Attribute::canUseAsFnAttr(FnAttr.getKindAsEnum()),
-           "Attribute '" + FnAttr.getAsString() +
-               "' does not apply to functions!",
-           V);
 
-  Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
-           Attrs.hasFnAttr(Attribute::ReadOnly)),
-         "Attributes 'readnone and readonly' are incompatible!", V);
+  Check(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
-           Attrs.hasFnAttr(Attribute::WriteOnly)),
-         "Attributes 'readnone and writeonly' are incompatible!", V);
+  Check(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasFnAttr(Attribute::ReadOnly) &&
-           Attrs.hasFnAttr(Attribute::WriteOnly)),
-         "Attributes 'readonly and writeonly' are incompatible!", V);
+  Check(!(Attrs.hasFnAttr(Attribute::ReadOnly) &&
 
-  Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
-           Attrs.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)),
-         "Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
-         "incompatible!",
-         V);
+  Check(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
-           Attrs.hasFnAttr(Attribute::InaccessibleMemOnly)),
-         "Attributes 'readnone and inaccessiblememonly' are incompatible!", V);
+  Check(!(Attrs.hasFnAttr(Attribute::ReadNone) &&
 
-  Assert(!(Attrs.hasFnAttr(Attribute::NoInline) &&
-           Attrs.hasFnAttr(Attribute::AlwaysInline)),
-         "Attributes 'noinline and alwaysinline' are incompatible!", V);
+  Check(!(Attrs.hasFnAttr(Attribute::NoInline) &&
 
   if (Attrs.hasFnAttr(Attribute::OptimizeNone)) {
-    Assert(Attrs.hasFnAttr(Attribute::NoInline),
-           "Attribute 'optnone' requires 'noinline'!", V);
+    Check(Attrs.hasFnAttr(Attribute::NoInline),
 
-    Assert(!Attrs.hasFnAttr(Attribute::OptimizeForSize),
-           "Attributes 'optsize and optnone' are incompatible!", V);
+    Check(!Attrs.hasFnAttr(Attribute::OptimizeForSize),
 
-    Assert(!Attrs.hasFnAttr(Attribute::MinSize),
-           "Attributes 'minsize and optnone' are incompatible!", V);
+    Check(!Attrs.hasFnAttr(Attribute::MinSize),
   }
 
   if (Attrs.hasFnAttr(Attribute::JumpTable)) {
     const GlobalValue *GV = cast<GlobalValue>(V);
-    Assert(GV->hasGlobalUnnamedAddr(),
-           "Attribute 'jumptable' requires 'unnamed_addr'", V);
+    Check(GV->hasGlobalUnnamedAddr(),
   }
 
   if (Attrs.hasFnAttr(Attribute::AllocSize)) {
     std::pair<unsigned, Optional<unsigned>> Args =
         Attrs.getFnAttrs().getAllocSizeArgs();
 
     auto CheckParam = [&](StringRef Name, unsigned ParamNo) {
       if (ParamNo >= FT->getNumParams()) {
void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
   checkUnsignedBaseTenFuncAttr(Attrs, "warn-stack-size", V);
 }
 
 void Verifier::verifyFunctionMetadata(
     ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
   for (const auto &Pair : MDs) {
     if (Pair.first == LLVMContext::MD_prof) {
       MDNode *MD = Pair.second;
-      Assert(MD->getNumOperands() >= 2,
-             "!prof annotations should have no less than 2 operands", MD);
+      Check(MD->getNumOperands() >= 2,
 
       // Check first operand.
-      Assert(MD->getOperand(0) != nullptr, "first operand should not be null",
-             MD);
-      Assert(isa<MDString>(MD->getOperand(0)),
-             "expected string with name of the !prof annotation", MD);
+      Check(MD->getOperand(0) != nullptr, "first operand should not be null",
+      Check(isa<MDString>(MD->getOperand(0)),
       MDString *MDS = cast<MDString>(MD->getOperand(0));
       StringRef ProfName = MDS->getString();
-      Assert(ProfName.equals("function_entry_count") ||
-                 ProfName.equals("synthetic_function_entry_count"),
-             "first operand should be 'function_entry_count'"
-             " or 'synthetic_function_entry_count'",
-             MD);
+      Check(ProfName.equals("function_entry_count") ||
 
       // Check second operand.
-      Assert(MD->getOperand(1) != nullptr, "second operand should not be null",
-             MD);
-      Assert(isa<ConstantAsMetadata>(MD->getOperand(1)),
-             "expected integer argument to function_entry_count", MD);
+      Check(MD->getOperand(1) != nullptr, "second operand should not be null",
+      Check(isa<ConstantAsMetadata>(MD->getOperand(1)),
     }
   }
 }
 
 void Verifier::visitConstantExprsRecursively(const Constant *EntryC) {
   if (!ConstantExprVisited.insert(EntryC).second)
     return;
 
   SmallVector<const Constant *, 16> Stack;
   Stack.push_back(EntryC);
 
   while (!Stack.empty()) {
     const Constant *C = Stack.pop_back_val();
 
     // Check this constant expression.
     if (const auto *CE = dyn_cast<ConstantExpr>(C))
       visitConstantExpr(CE);
 
     if (const auto *GV = dyn_cast<GlobalValue>(C)) {
       // Global Values get visited separately, but we do need to make sure
       // that the global value is in the correct module
-      Assert(GV->getParent() == &M, "Referencing global in another module!",
-             EntryC, &M, GV, GV->getParent());
+      Check(GV->getParent() == &M, "Referencing global in another module!",
       continue;
     }
 
     // Visit all sub-expressions.
     for (const Use &U : C->operands()) {
       const auto *OpC = dyn_cast<Constant>(U);
       if (!OpC)
         continue;
       if (!ConstantExprVisited.insert(OpC).second)
         continue;
       Stack.push_back(OpC);
     }
   }
 }
 
 void Verifier::visitConstantExpr(const ConstantExpr *CE) {
   if (CE->getOpcode() == Instruction::BitCast)
-    Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
-                                 CE->getType()),
-           "Invalid bitcast", CE);
+    Check(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
 }
 
 bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
   // There shouldn't be more attribute sets than there are parameters plus the
   // function and return value.
   return Attrs.getNumAttrSets() <= Params + 2;
 }
 
 void Verifier::verifyInlineAsmCall(const CallBase &Call) {
   const InlineAsm *IA = cast<InlineAsm>(Call.getCalledOperand());
   unsigned ArgNo = 0;
   for (const InlineAsm::ConstraintInfo &CI : IA->ParseConstraints()) {
     // Only deal with constraints that correspond to call arguments.
     if (!CI.hasArg())
       continue;
 
     if (CI.isIndirect) {
       const Value *Arg = Call.getArgOperand(ArgNo);
-      Assert(Arg->getType()->isPointerTy(),
-             "Operand for indirect constraint must have pointer type",
-             &Call);
+      Check(Arg->getType()->isPointerTy(),
+            "Operand for indirect constraint must have pointer type", &Call);
 
-      Assert(Call.getParamElementType(ArgNo),
-             "Operand for indirect constraint must have elementtype attribute",
-             &Call);
+      Check(Call.getParamElementType(ArgNo),
     } else {
-      Assert(!Call.paramHasAttr(ArgNo, Attribute::ElementType),
-             "Elementtype attribute can only be applied for indirect "
-             "constraints", &Call);
+      Check(!Call.paramHasAttr(ArgNo, Attribute::ElementType),
+            "constraints",
+            &Call);
     }
 
     ArgNo++;
   }
 }
 
 /// Verify that statepoint intrinsic is well formed.
 void Verifier::verifyStatepoint(const CallBase &Call) {
   assert(Call.getCalledFunction() &&
          Call.getCalledFunction()->getIntrinsicID() ==
              Intrinsic::experimental_gc_statepoint);
 
-  Assert(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory() &&
-             !Call.onlyAccessesArgMemory(),
-         "gc.statepoint must read and write all memory to preserve "
-         "reordering restrictions required by safepoint semantics",
-         Call);
+  Check(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory() &&
 
   const int64_t NumPatchBytes =
       cast<ConstantInt>(Call.getArgOperand(1))->getSExtValue();
   assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!");
-  Assert(NumPatchBytes >= 0,
-         "gc.statepoint number of patchable bytes must be "
-         "positive",
-         Call);
+  Check(NumPatchBytes >= 0,
 
   Type *TargetElemType = Call.getParamElementType(2);
-  Assert(TargetElemType,
-         "gc.statepoint callee argument must have elementtype attribute", Call);
+  Check(TargetElemType,
   FunctionType *TargetFuncType = dyn_cast<FunctionType>(TargetElemType);
-  Assert(TargetFuncType,
-         "gc.statepoint callee elementtype must be function type", Call);
+  Check(TargetFuncType,
 
   const int NumCallArgs = cast<ConstantInt>(Call.getArgOperand(3))->getZExtValue();
-  Assert(NumCallArgs >= 0,
-         "gc.statepoint number of arguments to underlying call "
-         "must be positive",
-         Call);
+  Check(NumCallArgs >= 0,
   const int NumParams = (int)TargetFuncType->getNumParams();
   if (TargetFuncType->isVarArg()) {
-    Assert(NumCallArgs >= NumParams,
-           "gc.statepoint mismatch in number of vararg call args", Call);
+    Check(NumCallArgs >= NumParams,
 
     // TODO: Remove this limitation
-    Assert(TargetFuncType->getReturnType()->isVoidTy(),
-           "gc.statepoint doesn't support wrapping non-void "
-           "vararg functions yet",
-           Call);
+    Check(TargetFuncType->getReturnType()->isVoidTy(),
   } else
-    Assert(NumCallArgs == NumParams,
-           "gc.statepoint mismatch in number of call args", Call);
+    Check(NumCallArgs == NumParams,
 
   const uint64_t Flags
     = cast<ConstantInt>(Call.getArgOperand(4))->getZExtValue();
-  Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
-         "unknown flag used in gc.statepoint flags argument", Call);
+  Check((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
 
   // Verify that the types of the call parameter arguments match
   // the type of the wrapped callee.
   AttributeList Attrs = Call.getAttributes();
   for (int i = 0; i < NumParams; i++) {
     Type *ParamType = TargetFuncType->getParamType(i);
     Type *ArgType = Call.getArgOperand(5 + i)->getType();
-    Assert(ArgType == ParamType,
-           "gc.statepoint call argument does not match wrapped "
-           "function type",
-           Call);
+    Check(ArgType == ParamType,
 
     if (TargetFuncType->isVarArg()) {
       AttributeSet ArgAttrs = Attrs.getParamAttrs(5 + i);
-      Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
-             "Attribute 'sret' cannot be used for vararg call arguments!",
-             Call);
+      Check(!ArgAttrs.hasAttribute(Attribute::StructRet),
+            "Attribute 'sret' cannot be used for vararg call arguments!", Call);
     }
   }
 
   const int EndCallArgsInx = 4 + NumCallArgs;
 
   const Value *NumTransitionArgsV = Call.getArgOperand(EndCallArgsInx + 1);
-  Assert(isa<ConstantInt>(NumTransitionArgsV),
-         "gc.statepoint number of transition arguments "
-         "must be constant integer",
-         Call);
+  Check(isa<ConstantInt>(NumTransitionArgsV),
   const int NumTransitionArgs =
       cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
-  Assert(NumTransitionArgs == 0,
-         "gc.statepoint w/inline transition bundle is deprecated", Call);
+  Check(NumTransitionArgs == 0,
   const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
 
   const Value *NumDeoptArgsV = Call.getArgOperand(EndTransitionArgsInx + 1);
-  Assert(isa<ConstantInt>(NumDeoptArgsV),
-         "gc.statepoint number of deoptimization arguments "
-         "must be constant integer",
-         Call);
+  Check(isa<ConstantInt>(NumDeoptArgsV),
   const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
-  Assert(NumDeoptArgs == 0,
-         "gc.statepoint w/inline deopt operands is deprecated", Call);
+  Check(NumDeoptArgs == 0,
 
   const int ExpectedNumArgs = 7 + NumCallArgs;
-  Assert(ExpectedNumArgs == (int)Call.arg_size(),
-         "gc.statepoint too many arguments", Call);
+  Check(ExpectedNumArgs == (int)Call.arg_size(),
 
   // 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 : Call.users()) {
     const CallInst *UserCall = dyn_cast<const CallInst>(U);
-    Assert(UserCall, "illegal use of statepoint token", Call, U);
+    Check(UserCall, "illegal use of statepoint token", Call, U);
     if (!UserCall)
       continue;
-    Assert(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
-           "gc.result or gc.relocate are the only value uses "
-           "of a gc.statepoint",
-           Call, U);
+    Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
     if (isa<GCResultInst>(UserCall)) {
-      Assert(UserCall->getArgOperand(0) == &Call,
-             "gc.result connected to wrong gc.statepoint", Call, UserCall);
+      Check(UserCall->getArgOperand(0) == &Call,
     } else if (isa<GCRelocateInst>(Call)) {
-      Assert(UserCall->getArgOperand(0) == &Call,
-             "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
+      Check(UserCall->getArgOperand(0) == &Call,
     }
   }
 
   // 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
   // can recognize equality properties that the insertion logic doesn't know
   // about.  See example statepoint.ll in the verifier subdirectory
 }
 
 void Verifier::verifyFrameRecoverIndices() {
   for (auto &Counts : FrameEscapeInfo) {
     Function *F = Counts.first;
     unsigned EscapedObjectCount = Counts.second.first;
     unsigned MaxRecoveredIndex = Counts.second.second;
-    Assert(MaxRecoveredIndex <= EscapedObjectCount,
-           "all indices passed to llvm.localrecover must be less than the "
-           "number of arguments passed to llvm.localescape in the parent "
-           "function",
-           F);
+    Check(MaxRecoveredIndex <= EscapedObjectCount,
   }
 }
 
 static Instruction *getSuccPad(Instruction *Terminator) {
   BasicBlock *UnwindDest;
   if (auto *II = dyn_cast<InvokeInst>(Terminator))
     UnwindDest = II->getUnwindDest();
   else if (auto *CSI = dyn_cast<CatchSwitchInst>(Terminator))
do {
         SmallVector<Instruction *, 8> CycleNodes;
         do {
           CycleNodes.push_back(CyclePad);
           Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
           if (CycleTerminator != CyclePad)
             CycleNodes.push_back(CycleTerminator);
           CyclePad = getSuccPad(CycleTerminator);
         } while (CyclePad != SuccPad);
-        Assert(false, "EH pads can't handle each other's exceptions",
-               ArrayRef<Instruction *>(CycleNodes));
+        Check(false, "EH pads can't handle each other's exceptions",
       }
       // Don't re-walk a node we've already checked
       if (!Visited.insert(SuccPad).second)
         break;
       // Walk to this successor if it has a map entry.
       PredPad = SuccPad;
       auto TermI = SiblingFuncletInfo.find(PredPad);
       if (TermI == SiblingFuncletInfo.end())

 //
 void Verifier::visitFunction(const Function &F) {
   visitGlobalValue(F);
 
   // Check function arguments.
   FunctionType *FT = F.getFunctionType();
   unsigned NumArgs = F.arg_size();
 
-  Assert(&Context == &F.getContext(),
-         "Function context does not match Module context!", &F);
+  Check(&Context == &F.getContext(),
 
-  Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
-  Assert(FT->getNumParams() == NumArgs,
-         "# formal arguments must match # of arguments for function type!", &F,
-         FT);
-  Assert(F.getReturnType()->isFirstClassType() ||
-             F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
-         "Functions cannot return aggregate values!", &F);
+  Check(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
+  Check(FT->getNumParams() == NumArgs,
+  Check(F.getReturnType()->isFirstClassType() ||
 
-  Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
-         "Invalid struct return type!", &F);
+  Check(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
 
   AttributeList Attrs = F.getAttributes();
 
-  Assert(verifyAttributeCount(Attrs, FT->getNumParams()),
-         "Attribute after last parameter!", &F);
+  Check(verifyAttributeCount(Attrs, FT->getNumParams()),
 
   bool IsIntrinsic = F.isIntrinsic();
 
   // Check function attributes.
   verifyFunctionAttrs(FT, Attrs, &F, IsIntrinsic, /* IsInlineAsm */ false);
 
   // On function declarations/definitions, we do not support the builtin
   // attribute. We do not check this in VerifyFunctionAttrs since that is
   // checking for Attributes that can/can not ever be on functions.
-  Assert(!Attrs.hasFnAttr(Attribute::Builtin),
-         "Attribute 'builtin' can only be applied to a callsite.", &F);
+  Check(!Attrs.hasFnAttr(Attribute::Builtin),
 
-  Assert(!Attrs.hasAttrSomewhere(Attribute::ElementType),
-         "Attribute 'elementtype' can only be applied to a callsite.", &F);
+  Check(!Attrs.hasAttrSomewhere(Attribute::ElementType),
 
   // Check that this function meets the restrictions on this calling convention.
   // Sometimes varargs is used for perfectly forwarding thunks, so some of these
   // restrictions can be lifted.
   switch (F.getCallingConv()) {
   default:
   case CallingConv::C:
     break;
   case CallingConv::X86_INTR: {
-    Assert(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::ByVal),
-           "Calling convention parameter requires byval", &F);
+    Check(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::ByVal),
     break;
   }
   case CallingConv::AMDGPU_KERNEL:
   case CallingConv::SPIR_KERNEL:
-    Assert(F.getReturnType()->isVoidTy(),
-           "Calling convention requires void return type", &F);
+    Check(F.getReturnType()->isVoidTy(),
     LLVM_FALLTHROUGH;
   case CallingConv::AMDGPU_VS:
   case CallingConv::AMDGPU_HS:
   case CallingConv::AMDGPU_GS:
   case CallingConv::AMDGPU_PS:
   case CallingConv::AMDGPU_CS:
-    Assert(!F.hasStructRetAttr(),
-           "Calling convention does not allow sret", &F);
+    Check(!F.hasStructRetAttr(), "Calling convention does not allow sret", &F);
     if (F.getCallingConv() != CallingConv::SPIR_KERNEL) {
       const unsigned StackAS = DL.getAllocaAddrSpace();
       unsigned i = 0;
       for (const Argument &Arg : F.args()) {
-        Assert(!Attrs.hasParamAttr(i, Attribute::ByVal),
-               "Calling convention disallows byval", &F);
-        Assert(!Attrs.hasParamAttr(i, Attribute::Preallocated),
-               "Calling convention disallows preallocated", &F);
-        Assert(!Attrs.hasParamAttr(i, Attribute::InAlloca),
-               "Calling convention disallows inalloca", &F);
+        Check(!Attrs.hasParamAttr(i, Attribute::ByVal),
+        Check(!Attrs.hasParamAttr(i, Attribute::Preallocated),
+        Check(!Attrs.hasParamAttr(i, Attribute::InAlloca),
 
         if (Attrs.hasParamAttr(i, Attribute::ByRef)) {
           // FIXME: Should also disallow LDS and GDS, but we don't have the enum
           // value here.
-          Assert(Arg.getType()->getPointerAddressSpace() != StackAS,
-                 "Calling convention disallows stack byref", &F);
+          Check(Arg.getType()->getPointerAddressSpace() != StackAS,
         }
 
         ++i;
       }
     }
 
     LLVM_FALLTHROUGH;
   case CallingConv::Fast:
   case CallingConv::Cold:
   case CallingConv::Intel_OCL_BI:
   case CallingConv::PTX_Kernel:
   case CallingConv::PTX_Device:
-    Assert(!F.isVarArg(), "Calling convention does not support varargs or "
-                          "perfect forwarding!",
-           &F);
+    Check(!F.isVarArg(),
+          "Calling convention does not support varargs or "
     break;
   }
 
   // Check that the argument values match the function type for this function...
   unsigned i = 0;
   for (const Argument &Arg : F.args()) {
-    Assert(Arg.getType() == FT->getParamType(i),
-           "Argument value does not match function argument type!", &Arg,
-           FT->getParamType(i));
-    Assert(Arg.getType()->isFirstClassType(),
-           "Function arguments must have first-class types!", &Arg);
+    Check(Arg.getType() == FT->getParamType(i),
+    Check(Arg.getType()->isFirstClassType(),
     if (!IsIntrinsic) {
-      Assert(!Arg.getType()->isMetadataTy(),
-             "Function takes metadata but isn't an intrinsic", &Arg, &F);
-      Assert(!Arg.getType()->isTokenTy(),
-             "Function takes token but isn't an intrinsic", &Arg, &F);
-      Assert(!Arg.getType()->isX86_AMXTy(),
-             "Function takes x86_amx but isn't an intrinsic", &Arg, &F);
+      Check(!Arg.getType()->isMetadataTy(),
+      Check(!Arg.getType()->isTokenTy(),
+      Check(!Arg.getType()->isX86_AMXTy(),
     }
 
     // Check that swifterror argument is only used by loads and stores.
     if (Attrs.hasParamAttr(i, Attribute::SwiftError)) {
       verifySwiftErrorValue(&Arg);
     }
     ++i;
   }
 
   if (!IsIntrinsic) {
-    Assert(!F.getReturnType()->isTokenTy(),
-           "Function returns a token but isn't an intrinsic", &F);
-    Assert(!F.getReturnType()->isX86_AMXTy(),
-           "Function returns a x86_amx but isn't an intrinsic", &F);
+    Check(!F.getReturnType()->isTokenTy(),
+    Check(!F.getReturnType()->isX86_AMXTy(),
   }
 
   // Get the function metadata attachments.
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   F.getAllMetadata(MDs);
   assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync");
   verifyFunctionMetadata(MDs);
 
   // Check validity of the personality function
   if (F.hasPersonalityFn()) {
     auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
     if (Per)
-      Assert(Per->getParent() == F.getParent(),
-             "Referencing personality function in another module!",
-             &F, F.getParent(), Per, Per->getParent());
+      Check(Per->getParent() == F.getParent(),
+            "Referencing personality function in another module!", &F,
+            F.getParent(), Per, Per->getParent());
   }
 
   if (F.isMaterializable()) {
     // Function has a body somewhere we can't see.
-    Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
-           MDs.empty() ? nullptr : MDs.front().second);
+    Check(MDs.empty(), "unmaterialized function cannot have metadata", &F,
   } else if (F.isDeclaration()) {
     for (const auto &I : MDs) {
       // This is used for call site debug information.
-      AssertDI(I.first != LLVMContext::MD_dbg ||
-                   !cast<DISubprogram>(I.second)->isDistinct(),
-               "function declaration may only have a unique !dbg attachment",
-               &F);
-      Assert(I.first != LLVMContext::MD_prof,
-             "function declaration may not have a !prof attachment", &F);
+      CheckDI(I.first != LLVMContext::MD_dbg ||
+      Check(I.first != LLVMContext::MD_prof,
 
       // Verify the metadata itself.
       visitMDNode(*I.second, AreDebugLocsAllowed::Yes);
     }
-    Assert(!F.hasPersonalityFn(),
-           "Function declaration shouldn't have a personality routine", &F);
+    Check(!F.hasPersonalityFn(),
   } else {
     // Verify that this function (which has a body) is not named "llvm.*".  It
     // is not legal to define intrinsics.
-    Assert(!IsIntrinsic, "llvm intrinsics cannot be defined!", &F);
+    Check(!IsIntrinsic, "llvm intrinsics cannot be defined!", &F);
 
     // Check the entry node
     const BasicBlock *Entry = &F.getEntryBlock();
-    Assert(pred_empty(Entry),
-           "Entry block to function must not have predecessors!", Entry);
+    Check(pred_empty(Entry),
 
     // The address of the entry block cannot be taken, unless it is dead.
     if (Entry->hasAddressTaken()) {
-      Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),
-             "blockaddress may not be used with the entry block!", Entry);
+      Check(!BlockAddress::lookup(Entry)->isConstantUsed(),
     }
 
     unsigned NumDebugAttachments = 0, NumProfAttachments = 0;
     // Visit metadata attachments.
     for (const auto &I : MDs) {
       // Verify that the attachment is legal.
       auto AllowLocs = AreDebugLocsAllowed::No;
       switch (I.first) {
       default:
         break;
       case LLVMContext::MD_dbg: {
         ++NumDebugAttachments;
-        AssertDI(NumDebugAttachments == 1,
-                 "function must have a single !dbg attachment", &F, I.second);
-        AssertDI(isa<DISubprogram>(I.second),
-                 "function !dbg attachment must be a subprogram", &F, I.second);
-        AssertDI(cast<DISubprogram>(I.second)->isDistinct(),
-                 "function definition may only have a distinct !dbg attachment",
-                 &F);
+        CheckDI(NumDebugAttachments == 1,
+        CheckDI(isa<DISubprogram>(I.second),
+        CheckDI(cast<DISubprogram>(I.second)->isDistinct(),
 
         auto *SP = cast<DISubprogram>(I.second);
         const Function *&AttachedTo = DISubprogramAttachments[SP];
-        AssertDI(!AttachedTo || AttachedTo == &F,
-                 "DISubprogram attached to more than one function", SP, &F);
+        CheckDI(!AttachedTo || AttachedTo == &F,
         AttachedTo = &F;
         AllowLocs = AreDebugLocsAllowed::Yes;
         break;
       }
       case LLVMContext::MD_prof:
         ++NumProfAttachments;
-        Assert(NumProfAttachments == 1,
-               "function must have a single !prof attachment", &F, I.second);
+        Check(NumProfAttachments == 1,
         break;
       }
 
       // Verify the metadata itself.
       visitMDNode(*I.second, AllowLocs);
     }
   }
 
   // If this function is actually an intrinsic, verify that it is only used in
   // direct call/invokes, never having its "address taken".
   // Only do this if the module is materialized, otherwise we don't have all the
   // uses.
   if (F.isIntrinsic() && F.getParent()->isMaterialized()) {
     const User *U;
     if (F.hasAddressTaken(&U, false, true, false,
                           /*IgnoreARCAttachedCall=*/true))
-      Assert(false, "Invalid user of intrinsic instruction!", U);
+      Check(false, "Invalid user of intrinsic instruction!", U);
   }
 
   // Check intrinsics' signatures.
   switch (F.getIntrinsicID()) {
   case Intrinsic::experimental_gc_get_pointer_base: {
     FunctionType *FT = F.getFunctionType();
-    Assert(FT->getNumParams() == 1, "wrong number of parameters", F);
-    Assert(isa<PointerType>(F.getReturnType()),
-           "gc.get.pointer.base must return a pointer", F);
-    Assert(FT->getParamType(0) == F.getReturnType(),
-           "gc.get.pointer.base operand and result must be of the same type",
-           F);
+    Check(FT->getNumParams() == 1, "wrong number of parameters", F);
+    Check(isa<PointerType>(F.getReturnType()),
+    Check(FT->getParamType(0) == F.getReturnType(),
+          "gc.get.pointer.base operand and result must be of the same type", F);
     break;
   }
   case Intrinsic::experimental_gc_get_pointer_offset: {
     FunctionType *FT = F.getFunctionType();
-    Assert(FT->getNumParams() == 1, "wrong number of parameters", F);
-    Assert(isa<PointerType>(FT->getParamType(0)),
-           "gc.get.pointer.offset operand must be a pointer", F);
-    Assert(F.getReturnType()->isIntegerTy(),
-           "gc.get.pointer.offset must return integer", F);
+    Check(FT->getNumParams() == 1, "wrong number of parameters", F);
+    Check(isa<PointerType>(FT->getParamType(0)),
+    Check(F.getReturnType()->isIntegerTy(),
     break;
   }
   }
 
   auto *N = F.getSubprogram();
   HasDebugInfo = (N != nullptr);
   if (!HasDebugInfo)
     return;
 
   // Check that all !dbg attachments lead to back to N.
   //
   // FIXME: Check this incrementally while visiting !dbg attachments.
   // FIXME: Only check when N is the canonical subprogram for F.
   SmallPtrSet<const MDNode *, 32> Seen;
   auto VisitDebugLoc = [&](const Instruction &I, const MDNode *Node) {
     // Be careful about using DILocation here since we might be dealing with
     // broken code (this is the Verifier after all).
     const DILocation *DL = dyn_cast_or_null<DILocation>(Node);
     if (!DL)
       return;
     if (!Seen.insert(DL).second)
       return;
 
     Metadata *Parent = DL->getRawScope();
-    AssertDI(Parent && isa<DILocalScope>(Parent),
-             "DILocation's scope must be a DILocalScope", N, &F, &I, DL,
-             Parent);
+    CheckDI(Parent && isa<DILocalScope>(Parent),
+            "DILocation's scope must be a DILocalScope", N, &F, &I, DL, Parent);
 
     DILocalScope *Scope = DL->getInlinedAtScope();
-    Assert(Scope, "Failed to find DILocalScope", DL);
+    Check(Scope, "Failed to find DILocalScope", DL);
 
     if (!Seen.insert(Scope).second)
       return;
 
     DISubprogram *SP = Scope->getSubprogram();
 
     // Scope and SP could be the same MDNode and we don't want to skip
     // validation in that case
     if (SP && ((Scope != SP) && !Seen.insert(SP).second))
       return;
 
-    AssertDI(SP->describes(&F),
-             "!dbg attachment points at wrong subprogram for function", N, &F,
-             &I, DL, Scope, SP);
+    CheckDI(SP->describes(&F),
   };
   for (auto &BB : F)
     for (auto &I : BB) {
       VisitDebugLoc(I, I.getDebugLoc().getAsMDNode());
       // The llvm.loop annotations also contain two DILocations.
       if (auto MD = I.getMetadata(LLVMContext::MD_loop))
         for (unsigned i = 1; i < MD->getNumOperands(); ++i)
           VisitDebugLoc(I, dyn_cast_or_null<MDNode>(MD->getOperand(i)));
       if (BrokenDebugInfo)
         return;
     }
 }
 
 // verifyBasicBlock - Verify that a basic block is well formed...
 //
 void Verifier::visitBasicBlock(BasicBlock &BB) {
   InstsInThisBlock.clear();
 
   // Ensure that basic blocks have terminators!
-  Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
+  Check(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
 
   // Check constraints that this basic block imposes on all of the PHI nodes in
   // it.
   if (isa<PHINode>(BB.front())) {
     SmallVector<BasicBlock *, 8> Preds(predecessors(&BB));
     SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
     llvm::sort(Preds);
     for (const PHINode &PN : BB.phis()) {
-      Assert(PN.getNumIncomingValues() == Preds.size(),
-             "PHINode should have one entry for each predecessor of its "
-             "parent basic block!",
-             &PN);
+      Check(PN.getNumIncomingValues() == Preds.size(),
 
       // Get and sort all incoming values in the PHI node...
       Values.clear();
       Values.reserve(PN.getNumIncomingValues());
       for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
         Values.push_back(
             std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));
       llvm::sort(Values);
 
       for (unsigned i = 0, e = Values.size(); i != e; ++i) {
         // Check to make sure that if there is more than one entry for a
         // particular basic block in this PHI node, that the incoming values are
         // all identical.
         //
-        Assert(i == 0 || Values[i].first != Values[i - 1].first ||
-                   Values[i].second == Values[i - 1].second,
-               "PHI node has multiple entries for the same basic block with "
-               "different incoming values!",
-               &PN, Values[i].first, Values[i].second, Values[i - 1].second);
+        Check(i == 0 || Values[i].first != Values[i - 1].first ||
 
         // Check to make sure that the predecessors and PHI node entries are
         // matched up.
-        Assert(Values[i].first == Preds[i],
-               "PHI node entries do not match predecessors!", &PN,
-               Values[i].first, Preds[i]);
+        Check(Values[i].first == Preds[i],
       }
     }
   }
 
   // Check that all instructions have their parent pointers set up correctly.
   for (auto &I : BB)
   {
-    Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!");
+    Check(I.getParent() == &BB, "Instruction has bogus parent pointer!");
   }
 }
 
 void Verifier::visitTerminator(Instruction &I) {
   // Ensure that terminators only exist at the end of the basic block.
-  Assert(&I == I.getParent()->getTerminator(),
-         "Terminator found in the middle of a basic block!", I.getParent());
+  Check(&I == I.getParent()->getTerminator(),
   visitInstruction(I);
 }
 
 void Verifier::visitBranchInst(BranchInst &BI) {
   if (BI.isConditional()) {
-    Assert(BI.getCondition()->getType()->isIntegerTy(1),
-           "Branch condition is not 'i1' type!", &BI, BI.getCondition());
+    Check(BI.getCondition()->getType()->isIntegerTy(1),
   }
   visitTerminator(BI);
 }
 
 void Verifier::visitReturnInst(ReturnInst &RI) {
   Function *F = RI.getParent()->getParent();
   unsigned N = RI.getNumOperands();
   if (F->getReturnType()->isVoidTy())
-    Assert(N == 0,
-           "Found return instr that returns non-void in Function of void "
-           "return type!",
-           &RI, F->getReturnType());
+    Check(N == 0,
   else
-    Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
-           "Function return type does not match operand "
-           "type of return inst!",
-           &RI, F->getReturnType());
+    Check(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
 
   // Check to make sure that the return value has necessary properties for
   // terminators...
   visitTerminator(RI);
 }
 
 void Verifier::visitSwitchInst(SwitchInst &SI) {
-  Assert(SI.getType()->isVoidTy(), "Switch must have void result type!", &SI);
+  Check(SI.getType()->isVoidTy(), "Switch must have void result type!", &SI);
   // Check to make sure that all of the constants in the switch instruction
   // have the same type as the switched-on value.
   Type *SwitchTy = SI.getCondition()->getType();
   SmallPtrSet<ConstantInt*, 32> Constants;
   for (auto &Case : SI.cases()) {
-    Assert(Case.getCaseValue()->getType() == SwitchTy,
-           "Switch constants must all be same type as switch value!", &SI);
-    Assert(Constants.insert(Case.getCaseValue()).second,
-           "Duplicate integer as switch case", &SI, Case.getCaseValue());
+    Check(Case.getCaseValue()->getType() == SwitchTy,
+    Check(Constants.insert(Case.getCaseValue()).second,
   }
 
   visitTerminator(SI);
 }
 
 void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
-  Assert(BI.getAddress()->getType()->isPointerTy(),
-         "Indirectbr operand must have pointer type!", &BI);
+  Check(BI.getAddress()->getType()->isPointerTy(),
   for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
-    Assert(BI.getDestination(i)->getType()->isLabelTy(),
-           "Indirectbr destinations must all have pointer type!", &BI);
+    Check(BI.getDestination(i)->getType()->isLabelTy(),
 
   visitTerminator(BI);
 }
 
 void Verifier::visitCallBrInst(CallBrInst &CBI) {
-  Assert(CBI.isInlineAsm(), "Callbr is currently only used for asm-goto!",
-         &CBI);
+  Check(CBI.isInlineAsm(), "Callbr is currently only used for asm-goto!", &CBI);
   const InlineAsm *IA = cast<InlineAsm>(CBI.getCalledOperand());
-  Assert(!IA->canThrow(), "Unwinding from Callbr is not allowed");
+  Check(!IA->canThrow(), "Unwinding from Callbr is not allowed");
   for (unsigned i = 0, e = CBI.getNumSuccessors(); i != e; ++i)
-    Assert(CBI.getSuccessor(i)->getType()->isLabelTy(),
-           "Callbr successors must all have pointer type!", &CBI);
+    Check(CBI.getSuccessor(i)->getType()->isLabelTy(),
   for (unsigned i = 0, e = CBI.getNumOperands(); i != e; ++i) {
-    Assert(i >= CBI.arg_size() || !isa<BasicBlock>(CBI.getOperand(i)),
-           "Using an unescaped label as a callbr argument!", &CBI);
+    Check(i >= CBI.arg_size() || !isa<BasicBlock>(CBI.getOperand(i)),
     if (isa<BasicBlock>(CBI.getOperand(i)))
       for (unsigned j = i + 1; j != e; ++j)
-        Assert(CBI.getOperand(i) != CBI.getOperand(j),
-               "Duplicate callbr destination!", &CBI);
+        Check(CBI.getOperand(i) != CBI.getOperand(j),
   }
   {
     SmallPtrSet<BasicBlock *, 4> ArgBBs;
     for (Value *V : CBI.args())
       if (auto *BA = dyn_cast<BlockAddress>(V))
         ArgBBs.insert(BA->getBasicBlock());
     for (BasicBlock *BB : CBI.getIndirectDests())
-      Assert(ArgBBs.count(BB), "Indirect label missing from arglist.", &CBI);
+      Check(ArgBBs.count(BB), "Indirect label missing from arglist.", &CBI);
   }
 
   verifyInlineAsmCall(CBI);
   visitTerminator(CBI);
 }
 
 void Verifier::visitSelectInst(SelectInst &SI) {
-  Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
-                                         SI.getOperand(2)),
-         "Invalid operands for select instruction!", &SI);
+  Check(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
 
-  Assert(SI.getTrueValue()->getType() == SI.getType(),
-         "Select values must have same type as select instruction!", &SI);
+  Check(SI.getTrueValue()->getType() == SI.getType(),
   visitInstruction(SI);
 }
 
 /// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
 /// a pass, if any exist, it's an error.
 ///
 void Verifier::visitUserOp1(Instruction &I) {
-  Assert(false, "User-defined operators should not live outside of a pass!", &I);
+  Check(false, "User-defined operators should not live outside of a pass!", &I);
 }
 
 void Verifier::visitTruncInst(TruncInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
   unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
   unsigned DestBitSize = DestTy->getScalarSizeInBits();
 
-  Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
-  Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
-         "trunc source and destination must both be a vector or neither", &I);
-  Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
+  Check(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
+  Check(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+  Check(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
 
   visitInstruction(I);
 }
 
 void Verifier::visitZExtInst(ZExtInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
-  Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
-  Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
-         "zext source and destination must both be a vector or neither", &I);
+  Check(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
+  Check(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
   unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
   unsigned DestBitSize = DestTy->getScalarSizeInBits();
 
-  Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
+  Check(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
 
   visitInstruction(I);
 }
 
 void Verifier::visitSExtInst(SExtInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
   unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
   unsigned DestBitSize = DestTy->getScalarSizeInBits();
 
-  Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
-  Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
-         "sext source and destination must both be a vector or neither", &I);
-  Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
+  Check(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
+  Check(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+  Check(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
 
   visitInstruction(I);
 }
 
 void Verifier::visitFPTruncInst(FPTruncInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
   // Get the size of the types in bits, we'll need this later
   unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
   unsigned DestBitSize = DestTy->getScalarSizeInBits();
 
-  Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
-  Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
-         "fptrunc source and destination must both be a vector or neither", &I);
-  Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
+  Check(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
+  Check(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+  Check(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
 
   visitInstruction(I);
 }
 
 void Verifier::visitFPExtInst(FPExtInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
   unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
   unsigned DestBitSize = DestTy->getScalarSizeInBits();
 
-  Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
-  Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
-         "fpext source and destination must both be a vector or neither", &I);
-  Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
+  Check(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
+  Check(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
+  Check(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
 
   visitInstruction(I);
 }
 
 void Verifier::visitUIToFPInst(UIToFPInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   bool SrcVec = SrcTy->isVectorTy();
   bool DstVec = DestTy->isVectorTy();
 
-  Assert(SrcVec == DstVec,
-         "UIToFP source and dest must both be vector or scalar", &I);
-  Assert(SrcTy->isIntOrIntVectorTy(),
-         "UIToFP source must be integer or integer vector", &I);
-  Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
-         &I);
+  Check(SrcVec == DstVec,
+  Check(SrcTy->isIntOrIntVectorTy(),
+  Check(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
 
   if (SrcVec && DstVec)
-    Assert(cast<VectorType>(SrcTy)->getElementCount() ==
-               cast<VectorType>(DestTy)->getElementCount(),
-           "UIToFP source and dest vector length mismatch", &I);
+    Check(cast<VectorType>(SrcTy)->getElementCount() ==
 
   visitInstruction(I);
 }
 
 void Verifier::visitSIToFPInst(SIToFPInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   bool SrcVec = SrcTy->isVectorTy();
   bool DstVec = DestTy->isVectorTy();
 
-  Assert(SrcVec == DstVec,
-         "SIToFP source and dest must both be vector or scalar", &I);
-  Assert(SrcTy->isIntOrIntVectorTy(),
-         "SIToFP source must be integer or integer vector", &I);
-  Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
-         &I);
+  Check(SrcVec == DstVec,
+  Check(SrcTy->isIntOrIntVectorTy(),
+  Check(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
 
   if (SrcVec && DstVec)
-    Assert(cast<VectorType>(SrcTy)->getElementCount() ==
-               cast<VectorType>(DestTy)->getElementCount(),
-           "SIToFP source and dest vector length mismatch", &I);
+    Check(cast<VectorType>(SrcTy)->getElementCount() ==
 
   visitInstruction(I);
 }
 
 void Verifier::visitFPToUIInst(FPToUIInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   bool SrcVec = SrcTy->isVectorTy();
   bool DstVec = DestTy->isVectorTy();
 
-  Assert(SrcVec == DstVec,
-         "FPToUI source and dest must both be vector or scalar", &I);
-  Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
-         &I);
-  Assert(DestTy->isIntOrIntVectorTy(),
-         "FPToUI result must be integer or integer vector", &I);
+  Check(SrcVec == DstVec,
+  Check(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector", &I);
+  Check(DestTy->isIntOrIntVectorTy(),
 
   if (SrcVec && DstVec)
-    Assert(cast<VectorType>(SrcTy)->getElementCount() ==
-               cast<VectorType>(DestTy)->getElementCount(),
-           "FPToUI source and dest vector length mismatch", &I);
+    Check(cast<VectorType>(SrcTy)->getElementCount() ==
 
   visitInstruction(I);
 }
 
 void Verifier::visitFPToSIInst(FPToSIInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   bool SrcVec = SrcTy->isVectorTy();
   bool DstVec = DestTy->isVectorTy();
 
-  Assert(SrcVec == DstVec,
-         "FPToSI source and dest must both be vector or scalar", &I);
-  Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",
-         &I);
-  Assert(DestTy->isIntOrIntVectorTy(),
-         "FPToSI result must be integer or integer vector", &I);
+  Check(SrcVec == DstVec,
+  Check(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector", &I);
+  Check(DestTy->isIntOrIntVectorTy(),
 
   if (SrcVec && DstVec)
-    Assert(cast<VectorType>(SrcTy)->getElementCount() ==
-               cast<VectorType>(DestTy)->getElementCount(),
-           "FPToSI source and dest vector length mismatch", &I);
+    Check(cast<VectorType>(SrcTy)->getElementCount() ==
 
   visitInstruction(I);
 }
 
 void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
-  Assert(SrcTy->isPtrOrPtrVectorTy(), "PtrToInt source must be pointer", &I);
+  Check(SrcTy->isPtrOrPtrVectorTy(), "PtrToInt source must be pointer", &I);
 
-  Assert(DestTy->isIntOrIntVectorTy(), "PtrToInt result must be integral", &I);
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
-         &I);
+  Check(DestTy->isIntOrIntVectorTy(), "PtrToInt result must be integral", &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
 
   if (SrcTy->isVectorTy()) {
     auto *VSrc = cast<VectorType>(SrcTy);
     auto *VDest = cast<VectorType>(DestTy);
-    Assert(VSrc->getElementCount() == VDest->getElementCount(),
-           "PtrToInt Vector width mismatch", &I);
+    Check(VSrc->getElementCount() == VDest->getElementCount(),
   }
 
   visitInstruction(I);
 }
 
 void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
   // Get the source and destination types
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
-  Assert(SrcTy->isIntOrIntVectorTy(),
-         "IntToPtr source must be an integral", &I);
-  Assert(DestTy->isPtrOrPtrVectorTy(), "IntToPtr result must be a pointer", &I);
+  Check(SrcTy->isIntOrIntVectorTy(), "IntToPtr source must be an integral", &I);
+  Check(DestTy->isPtrOrPtrVectorTy(), "IntToPtr result must be a pointer", &I);
 
-  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
-         &I);
+  Check(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
   if (SrcTy->isVectorTy()) {
     auto *VSrc = cast<VectorType>(SrcTy);
     auto *VDest = cast<VectorType>(DestTy);
-    Assert(VSrc->getElementCount() == VDest->getElementCount(),
-           "IntToPtr Vector width mismatch", &I);
+    Check(VSrc->getElementCount() == VDest->getElementCount(),
   }
   visitInstruction(I);
 }
 
 void Verifier::visitBitCastInst(BitCastInst &I) {
-  Assert(
+  Check(
       CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
       "Invalid bitcast", &I);
   visitInstruction(I);
 }
 
 void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
-  Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
-         &I);
-  Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
-         &I);
-  Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
-         "AddrSpaceCast must be between different address spaces", &I);
+  Check(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
+  Check(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
+  Check(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
   if (auto *SrcVTy = dyn_cast<VectorType>(SrcTy))
-    Assert(SrcVTy->getElementCount() ==
-               cast<VectorType>(DestTy)->getElementCount(),
-           "AddrSpaceCast vector pointer number of elements mismatch", &I);
+    Check(SrcVTy->getElementCount() ==
   visitInstruction(I);
 }
 
 /// visitPHINode - Ensure that a PHI node is well formed.
 ///
 void Verifier::visitPHINode(PHINode &PN) {
   // Ensure that the PHI nodes are all grouped together at the top of the block.
   // This can be tested by checking whether the instruction before this is
   // either nonexistent (because this is begin()) or is a PHI node.  If not,
   // then there is some other instruction before a PHI.
-  Assert(&PN == &PN.getParent()->front() ||
-             isa<PHINode>(--BasicBlock::iterator(&PN)),
-         "PHI nodes not grouped at top of basic block!", &PN, PN.getParent());
+  Check(&PN == &PN.getParent()->front() ||
 
   // Check that a PHI doesn't yield a Token.
-  Assert(!PN.getType()->isTokenTy(), "PHI nodes cannot have token type!");
+  Check(!PN.getType()->isTokenTy(), "PHI nodes cannot have token type!");
 
   // Check that all of the values of the PHI node have the same type as the
   // result, and that the incoming blocks are really basic blocks.
   for (Value *IncValue : PN.incoming_values()) {
-    Assert(PN.getType() == IncValue->getType(),
-           "PHI node operands are not the same type as the result!", &PN);
+    Check(PN.getType() == IncValue->getType(),
   }
 
   // All other PHI node constraints are checked in the visitBasicBlock method.
 
   visitInstruction(PN);
 }
 
 void Verifier::visitCallBase(CallBase &Call) {
-  Assert(Call.getCalledOperand()->getType()->isPointerTy(),
-         "Called function must be a pointer!", Call);
+  Check(Call.getCalledOperand()->getType()->isPointerTy(),
   PointerType *FPTy = cast<PointerType>(Call.getCalledOperand()->getType());
 
-  Assert(FPTy->isOpaqueOrPointeeTypeMatches(Call.getFunctionType()),
-         "Called function is not the same type as the call!", Call);
+  Check(FPTy->isOpaqueOrPointeeTypeMatches(Call.getFunctionType()),
 
   FunctionType *FTy = Call.getFunctionType();
 
   // Verify that the correct number of arguments are being passed
   if (FTy->isVarArg())
-    Assert(Call.arg_size() >= FTy->getNumParams(),
-           "Called function requires more parameters than were provided!",
-           Call);
+    Check(Call.arg_size() >= FTy->getNumParams(),
+          "Called function requires more parameters than were provided!", Call);
   else
-    Assert(Call.arg_size() == FTy->getNumParams(),
-           "Incorrect number of arguments passed to called function!", Call);
+    Check(Call.arg_size() == FTy->getNumParams(),
 
   // Verify that all arguments to the call match the function type.
   for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
-    Assert(Call.getArgOperand(i)->getType() == FTy->getParamType(i),
-           "Call parameter type does not match function signature!",
-           Call.getArgOperand(i), FTy->getParamType(i), Call);
+    Check(Call.getArgOperand(i)->getType() == FTy->getParamType(i),
 
   AttributeList Attrs = Call.getAttributes();
 
-  Assert(verifyAttributeCount(Attrs, Call.arg_size()),
-         "Attribute after last parameter!", Call);
+  Check(verifyAttributeCount(Attrs, Call.arg_size()),
 
   Function *Callee =
       dyn_cast<Function>(Call.getCalledOperand()->stripPointerCasts());
   bool IsIntrinsic = Callee && Callee->isIntrinsic();
   if (IsIntrinsic)
-    Assert(Callee->getValueType() == FTy,
-           "Intrinsic called with incompatible signature", Call);
+    Check(Callee->getValueType() == FTy,
 
   if (Attrs.hasFnAttr(Attribute::Speculatable)) {
     // Don't allow speculatable on call sites, unless the underlying function
     // declaration is also speculatable.
-    Assert(Callee && Callee->isSpeculatable(),
-           "speculatable attribute may not apply to call sites", Call);
+    Check(Callee && Callee->isSpeculatable(),
   }
 
   if (Attrs.hasFnAttr(Attribute::Preallocated)) {
-    Assert(Call.getCalledFunction()->getIntrinsicID() ==
-               Intrinsic::call_preallocated_arg,
-           "preallocated as a call site attribute can only be on "
-           "llvm.call.preallocated.arg");
+    Check(Call.getCalledFunction()->getIntrinsicID() ==
   }
 
   // Verify call attributes.
   verifyFunctionAttrs(FTy, Attrs, &Call, IsIntrinsic, Call.isInlineAsm());
 
   // Conservatively check the inalloca argument.
   // We have a bug if we can find that there is an underlying alloca without
   // inalloca.
   if (Call.hasInAllocaArgument()) {
     Value *InAllocaArg = Call.getArgOperand(FTy->getNumParams() - 1);
     if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
-      Assert(AI->isUsedWithInAlloca(),
-             "inalloca argument for call has mismatched alloca", AI, Call);
+      Check(AI->isUsedWithInAlloca(),
   }
 
   // For each argument of the callsite, if it has the swifterror argument,
   // make sure the underlying alloca/parameter it comes from has a swifterror as
   // well.
   for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
     if (Call.paramHasAttr(i, Attribute::SwiftError)) {
       Value *SwiftErrorArg = Call.getArgOperand(i);
       if (auto AI = dyn_cast<AllocaInst>(SwiftErrorArg->stripInBoundsOffsets())) {
-        Assert(AI->isSwiftError(),
-               "swifterror argument for call has mismatched alloca", AI, Call);
+        Check(AI->isSwiftError(),
         continue;
       }
       auto ArgI = dyn_cast<Argument>(SwiftErrorArg);
-      Assert(ArgI,
-             "swifterror argument should come from an alloca or parameter",
-             SwiftErrorArg, Call);
-      Assert(ArgI->hasSwiftErrorAttr(),
-             "swifterror argument for call has mismatched parameter", ArgI,
-             Call);
+      Check(ArgI, "swifterror argument should come from an alloca or parameter",
+      Check(ArgI->hasSwiftErrorAttr(),
     }
 
     if (Attrs.hasParamAttr(i, Attribute::ImmArg)) {
       // Don't allow immarg on call sites, unless the underlying declaration
       // also has the matching immarg.
-      Assert(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),
-             "immarg may not apply only to call sites",
-             Call.getArgOperand(i), Call);
+      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);
-      Assert(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
-             "immarg operand has non-immediate parameter", ArgVal, Call);
+      Check(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
     }
 
     if (Call.paramHasAttr(i, Attribute::Preallocated)) {
       Value *ArgVal = Call.getArgOperand(i);
       bool hasOB =
           Call.countOperandBundlesOfType(LLVMContext::OB_preallocated) != 0;
       bool isMustTail = Call.isMustTailCall();
-      Assert(hasOB != isMustTail,
-             "preallocated operand either requires a preallocated bundle or "
-             "the call to be musttail (but not both)",
-             ArgVal, Call);
+      Check(hasOB != isMustTail,
     }
   }
 
   if (FTy->isVarArg()) {
     // FIXME? is 'nest' even legal here?
     bool SawNest = false;
     bool SawReturned = false;
 
     for (unsigned Idx = 0; Idx < FTy->getNumParams(); ++Idx) {
       if (Attrs.hasParamAttr(Idx, Attribute::Nest))
         SawNest = true;
       if (Attrs.hasParamAttr(Idx, Attribute::Returned))
         SawReturned = true;
     }
 
     // Check attributes on the varargs part.
     for (unsigned Idx = FTy->getNumParams(); Idx < Call.arg_size(); ++Idx) {
       Type *Ty = Call.getArgOperand(Idx)->getType();
       AttributeSet ArgAttrs = Attrs.getParamAttrs(Idx);
       verifyParameterAttrs(ArgAttrs, Ty, &Call);
 
       if (ArgAttrs.hasAttribute(Attribute::Nest)) {
-        Assert(!SawNest, "More than one parameter has attribute nest!", Call);
+        Check(!SawNest, "More than one parameter has attribute nest!", Call);
         SawNest = true;
       }
 
       if (ArgAttrs.hasAttribute(Attribute::Returned)) {
-        Assert(!SawReturned, "More than one parameter has attribute returned!",
-               Call);
-        Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
-               "Incompatible argument and return types for 'returned' "
-               "attribute",
-               Call);
+        Check(!SawReturned, "More than one parameter has attribute returned!",
+        Check(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
         SawReturned = true;
       }
 
       // Statepoint intrinsic is vararg but the wrapped function may be not.
       // Allow sret here and check the wrapped function in verifyStatepoint.
       if (!Call.getCalledFunction() ||
           Call.getCalledFunction()->getIntrinsicID() !=
               Intrinsic::experimental_gc_statepoint)
-        Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
-               "Attribute 'sret' cannot be used for vararg call arguments!",
-               Call);
+        Check(!ArgAttrs.hasAttribute(Attribute::StructRet),
 
       if (ArgAttrs.hasAttribute(Attribute::InAlloca))
-        Assert(Idx == Call.arg_size() - 1,
-               "inalloca isn't on the last argument!", Call);
+        Check(Idx == Call.arg_size() - 1,
     }
   }
 
   // Verify that there's no metadata unless it's a direct call to an intrinsic.
   if (!IsIntrinsic) {
     for (Type *ParamTy : FTy->params()) {
-      Assert(!ParamTy->isMetadataTy(),
-             "Function has metadata parameter but isn't an intrinsic", Call);
-      Assert(!ParamTy->isTokenTy(),
-             "Function has token parameter but isn't an intrinsic", Call);
+      Check(!ParamTy->isMetadataTy(),
+      Check(!ParamTy->isTokenTy(),
     }
   }
 
   // Verify that indirect calls don't return tokens.
   if (!Call.getCalledFunction()) {
-    Assert(!FTy->getReturnType()->isTokenTy(),
-           "Return type cannot be token for indirect call!");
-    Assert(!FTy->getReturnType()->isX86_AMXTy(),
-           "Return type cannot be x86_amx for indirect call!");
+    Check(!FTy->getReturnType()->isTokenTy(),
+    Check(!FTy->getReturnType()->isX86_AMXTy(),
   }
 
   if (Function *F = Call.getCalledFunction())
     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
       visitIntrinsicCall(ID, Call);
 
   // Verify that a callsite has at most one "deopt", at most one "funclet", at
   // most one "gc-transition", at most one "cfguardtarget", at most one
   // "preallocated" operand bundle, and at most one "ptrauth" operand bundle.
   bool FoundDeoptBundle = false, FoundFuncletBundle = false,
        FoundGCTransitionBundle = false, FoundCFGuardTargetBundle = false,
        FoundPreallocatedBundle = false, FoundGCLiveBundle = false,
        FoundPtrauthBundle = false,
        FoundAttachedCallBundle = false;
   for (unsigned i = 0, e = Call.getNumOperandBundles(); i < e; ++i) {
     OperandBundleUse BU = Call.getOperandBundleAt(i);
     uint32_t Tag = BU.getTagID();
     if (Tag == LLVMContext::OB_deopt) {
-      Assert(!FoundDeoptBundle, "Multiple deopt operand bundles", Call);
+      Check(!FoundDeoptBundle, "Multiple deopt operand bundles", Call);
       FoundDeoptBundle = true;
     } else if (Tag == LLVMContext::OB_gc_transition) {
-      Assert(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",
-             Call);
+      Check(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",
       FoundGCTransitionBundle = true;
     } else if (Tag == LLVMContext::OB_funclet) {
-      Assert(!FoundFuncletBundle, "Multiple funclet operand bundles", Call);
+      Check(!FoundFuncletBundle, "Multiple funclet operand bundles", Call);
       FoundFuncletBundle = true;
-      Assert(BU.Inputs.size() == 1,
-             "Expected exactly one funclet bundle operand", Call);
-      Assert(isa<FuncletPadInst>(BU.Inputs.front()),
-             "Funclet bundle operands should correspond to a FuncletPadInst",
-             Call);
+      Check(BU.Inputs.size() == 1,
+      Check(isa<FuncletPadInst>(BU.Inputs.front()),
     } else if (Tag == LLVMContext::OB_cfguardtarget) {
-      Assert(!FoundCFGuardTargetBundle,
-             "Multiple CFGuardTarget operand bundles", Call);
+      Check(!FoundCFGuardTargetBundle, "Multiple CFGuardTarget operand bundles",
+            Call);
       FoundCFGuardTargetBundle = true;
-      Assert(BU.Inputs.size() == 1,
-             "Expected exactly one cfguardtarget bundle operand", Call);
+      Check(BU.Inputs.size() == 1,
     } else if (Tag == LLVMContext::OB_ptrauth) {
-      Assert(!FoundPtrauthBundle, "Multiple ptrauth operand bundles", Call);
+      Check(!FoundPtrauthBundle, "Multiple ptrauth operand bundles", Call);
       FoundPtrauthBundle = true;
-      Assert(BU.Inputs.size() == 2,
-             "Expected exactly two ptrauth bundle operands", Call);
-      Assert(isa<ConstantInt>(BU.Inputs[0]) &&
+      Check(BU.Inputs.size() == 2,
+      Check(isa<ConstantInt>(BU.Inputs[0]) &&
                 BU.Inputs[0]->getType()->isIntegerTy(32),
-             "Ptrauth bundle key operand must be an i32 constant", Call);
-      Assert(BU.Inputs[1]->getType()->isIntegerTy(64),
-             "Ptrauth bundle discriminator operand must be an i64", Call);
+      Check(BU.Inputs[1]->getType()->isIntegerTy(64),
     } else if (Tag == LLVMContext::OB_preallocated) {
-      Assert(!FoundPreallocatedBundle, "Multiple preallocated operand bundles",
-             Call);
+      Check(!FoundPreallocatedBundle, "Multiple preallocated operand bundles",
       FoundPreallocatedBundle = true;
-      Assert(BU.Inputs.size() == 1,
-             "Expected exactly one preallocated bundle operand", Call);
+      Check(BU.Inputs.size() == 1,
       auto Input = dyn_cast<IntrinsicInst>(BU.Inputs.front());
-      Assert(Input &&
-                 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,
-             "\"preallocated\" argument must be a token from "
-             "llvm.call.preallocated.setup",
-             Call);
+      Check(Input &&
     } else if (Tag == LLVMContext::OB_gc_live) {
-      Assert(!FoundGCLiveBundle, "Multiple gc-live operand bundles",
-             Call);
+      Check(!FoundGCLiveBundle, "Multiple gc-live operand bundles", Call);
       FoundGCLiveBundle = true;
     } else if (Tag == LLVMContext::OB_clang_arc_attachedcall) {
-      Assert(!FoundAttachedCallBundle,
-             "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
+      Check(!FoundAttachedCallBundle,
       FoundAttachedCallBundle = true;
       verifyAttachedCallBundle(Call, BU);
     }
   }
 
   // Verify that callee and callsite agree on whether to use pointer auth.
-  Assert(!(Call.getCalledFunction() && FoundPtrauthBundle),
-         "Direct call cannot have a ptrauth bundle", Call);
+  Check(!(Call.getCalledFunction() && FoundPtrauthBundle),
 
   // Verify that each inlinable callsite of a debug-info-bearing function in a
   // debug-info-bearing function has a debug location attached to it. Failure to
   // do so causes assertion failures when the inliner sets up inline scope info.
   if (Call.getFunction()->getSubprogram() && Call.getCalledFunction() &&
       Call.getCalledFunction()->getSubprogram())
-    AssertDI(Call.getDebugLoc(),
-             "inlinable function call in a function with "
-             "debug info must have a !dbg location",
-             Call);
+    CheckDI(Call.getDebugLoc(),
 
   if (Call.isInlineAsm())
     verifyInlineAsmCall(Call);
 
   visitInstruction(Call);
 }
 
 void Verifier::verifyTailCCMustTailAttrs(const AttrBuilder &Attrs,
                                          StringRef Context) {
-  Assert(!Attrs.contains(Attribute::InAlloca),
-         Twine("inalloca attribute not allowed in ") + Context);
-  Assert(!Attrs.contains(Attribute::InReg),
-         Twine("inreg attribute not allowed in ") + Context);
-  Assert(!Attrs.contains(Attribute::SwiftError),
-         Twine("swifterror attribute not allowed in ") + Context);
-  Assert(!Attrs.contains(Attribute::Preallocated),
-         Twine("preallocated attribute not allowed in ") + Context);
-  Assert(!Attrs.contains(Attribute::ByRef),
-         Twine("byref attribute not allowed in ") + Context);
+  Check(!Attrs.contains(Attribute::InAlloca),
+  Check(!Attrs.contains(Attribute::InReg),
+  Check(!Attrs.contains(Attribute::SwiftError),
+  Check(!Attrs.contains(Attribute::Preallocated),
+  Check(!Attrs.contains(Attribute::ByRef),
 }
 
 /// Two types are "congruent" if they are identical, or if they are both pointer
 /// types with different pointee types and the same address space.
 static bool isTypeCongruent(Type *L, Type *R) {
   if (L == R)
     return true;
   PointerType *PL = dyn_cast<PointerType>(L);
static AttrBuilder getParameterABIAttributes(LLVMContext& C, unsigned I, AttributeList Attrs) {
   if (Attrs.hasParamAttr(I, Attribute::Alignment) &&
       (Attrs.hasParamAttr(I, Attribute::ByVal) ||
        Attrs.hasParamAttr(I, Attribute::ByRef)))
     Copy.addAlignmentAttr(Attrs.getParamAlignment(I));
   return Copy;
 }
 
 void Verifier::verifyMustTailCall(CallInst &CI) {
-  Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
+  Check(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
 
   Function *F = CI.getParent()->getParent();
   FunctionType *CallerTy = F->getFunctionType();
   FunctionType *CalleeTy = CI.getFunctionType();
-  Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),
-         "cannot guarantee tail call due to mismatched varargs", &CI);
-  Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
-         "cannot guarantee tail call due to mismatched return types", &CI);
+  Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
+  Check(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
 
   // - The calling conventions of the caller and callee must match.
-  Assert(F->getCallingConv() == CI.getCallingConv(),
-         "cannot guarantee tail call due to mismatched calling conv", &CI);
+  Check(F->getCallingConv() == CI.getCallingConv(),
 
   // - The call must immediately precede a :ref:`ret <i_ret>` instruction,
   //   or a pointer bitcast followed by a ret instruction.
   // - The ret instruction must return the (possibly bitcasted) value
   //   produced by the call or void.
   Value *RetVal = &CI;
   Instruction *Next = CI.getNextNode();
 
   // Handle the optional bitcast.
   if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
-    Assert(BI->getOperand(0) == RetVal,
-           "bitcast following musttail call must use the call", BI);
+    Check(BI->getOperand(0) == RetVal,
     RetVal = BI;
     Next = BI->getNextNode();
   }
 
   // Check the return.
   ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
-  Assert(Ret, "musttail call must precede a ret with an optional bitcast",
-         &CI);
-  Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal ||
-             isa<UndefValue>(Ret->getReturnValue()),
-         "musttail call result must be returned", Ret);
+  Check(Ret, "musttail call must precede a ret with an optional bitcast", &CI);
+  Check(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal ||
 
   AttributeList CallerAttrs = F->getAttributes();
   AttributeList CalleeAttrs = CI.getAttributes();
   if (CI.getCallingConv() == CallingConv::SwiftTail ||
       CI.getCallingConv() == CallingConv::Tail) {
     StringRef CCName =
         CI.getCallingConv() == CallingConv::Tail ? "tailcc" : "swifttailcc";
 
     // - Only sret, byval, swiftself, and swiftasync ABI-impacting attributes
     //   are allowed in swifttailcc call
     for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
       AttrBuilder ABIAttrs = getParameterABIAttributes(F->getContext(), I, CallerAttrs);
       SmallString<32> Context{CCName, StringRef(" musttail caller")};
       verifyTailCCMustTailAttrs(ABIAttrs, Context);
     }
     for (unsigned I = 0, E = CalleeTy->getNumParams(); I != E; ++I) {
       AttrBuilder ABIAttrs = getParameterABIAttributes(F->getContext(), I, CalleeAttrs);
       SmallString<32> Context{CCName, StringRef(" musttail callee")};
       verifyTailCCMustTailAttrs(ABIAttrs, Context);
     }
     // - Varargs functions are not allowed
-    Assert(!CallerTy->isVarArg(), Twine("cannot guarantee ") + CCName +
-                                      " tail call for varargs function");
+    Check(!CallerTy->isVarArg(), Twine("cannot guarantee ") + CCName +
     return;
   }
 
   // - The caller and callee prototypes must match.  Pointer types of
   //   parameters or return types may differ in pointee type, but not
   //   address space.
   if (!CI.getCalledFunction() || !CI.getCalledFunction()->isIntrinsic()) {
-    Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
-           "cannot guarantee tail call due to mismatched parameter counts",
-           &CI);
+    Check(CallerTy->getNumParams() == CalleeTy->getNumParams(),
+          "cannot guarantee tail call due to mismatched parameter counts", &CI);
     for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
-      Assert(
+      Check(
           isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),
           "cannot guarantee tail call due to mismatched parameter types", &CI);
     }
   }
 
   // - All ABI-impacting function attributes, such as sret, byval, inreg,
   //   returned, preallocated, and inalloca, must match.
   for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
     AttrBuilder CallerABIAttrs = getParameterABIAttributes(F->getContext(), I, CallerAttrs);
     AttrBuilder CalleeABIAttrs = getParameterABIAttributes(F->getContext(), I, CalleeAttrs);
-    Assert(CallerABIAttrs == CalleeABIAttrs,
-           "cannot guarantee tail call due to mismatched ABI impacting "
-           "function attributes",
-           &CI, CI.getOperand(I));
+    Check(CallerABIAttrs == CalleeABIAttrs,
   }
 }
 
 void Verifier::visitCallInst(CallInst &CI) {
   visitCallBase(CI);
 
   if (CI.isMustTailCall())
     verifyMustTailCall(CI);
 }
 
 void Verifier::visitInvokeInst(InvokeInst &II) {
   visitCallBase(II);
 
   // Verify that the first non-PHI instruction of the unwind destination is an
   // exception handling instruction.
-  Assert(
+  Check(
       II.getUnwindDest()->isEHPad(),
       "The unwind destination does not have an exception handling instruction!",
       &II);
 
   visitTerminator(II);
 }
 
 /// visitUnaryOperator - Check the argument to the unary operator.
 ///
 void Verifier::visitUnaryOperator(UnaryOperator &U) {
-  Assert(U.getType() == U.getOperand(0)->getType(),
-         "Unary operators must have same type for"
-         "operands and result!",
-         &U);
+  Check(U.getType() == U.getOperand(0)->getType(),
 
   switch (U.getOpcode()) {
   // Check that floating-point arithmetic operators are only used with
   // floating-point operands.
   case Instruction::FNeg:
-    Assert(U.getType()->isFPOrFPVectorTy(),
-           "FNeg operator only works with float types!", &U);
+    Check(U.getType()->isFPOrFPVectorTy(),
     break;
   default:
     llvm_unreachable("Unknown UnaryOperator opcode!");
   }
 
   visitInstruction(U);
 }
 
 /// visitBinaryOperator - Check that both arguments to the binary operator are
 /// of the same type!
 ///
 void Verifier::visitBinaryOperator(BinaryOperator &B) {
-  Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
-         "Both operands to a binary operator are not of the same type!", &B);
+  Check(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
 
   switch (B.getOpcode()) {
   // Check that integer arithmetic operators are only used with
   // integral operands.
   case Instruction::Add:
   case Instruction::Sub:
   case Instruction::Mul:
   case Instruction::SDiv:
   case Instruction::UDiv:
   case Instruction::SRem:
   case Instruction::URem:
-    Assert(B.getType()->isIntOrIntVectorTy(),
-           "Integer arithmetic operators only work with integral types!", &B);
-    Assert(B.getType() == B.getOperand(0)->getType(),
-           "Integer arithmetic operators must have same type "
-           "for operands and result!",
-           &B);
+    Check(B.getType()->isIntOrIntVectorTy(),
+    Check(B.getType() == B.getOperand(0)->getType(),
     break;
   // Check that floating-point arithmetic operators are only used with
   // floating-point operands.
   case Instruction::FAdd:
   case Instruction::FSub:
   case Instruction::FMul:
   case Instruction::FDiv:
   case Instruction::FRem:
-    Assert(B.getType()->isFPOrFPVectorTy(),
-           "Floating-point arithmetic operators only work with "
-           "floating-point types!",
-           &B);
-    Assert(B.getType() == B.getOperand(0)->getType(),
-           "Floating-point arithmetic operators must have same type "
-           "for operands and result!",
-           &B);
+    Check(B.getType()->isFPOrFPVectorTy(),
+    Check(B.getType() == B.getOperand(0)->getType(),
     break;
   // Check that logical operators are only used with integral operands.
   case Instruction::And:
   case Instruction::Or:
   case Instruction::Xor:
-    Assert(B.getType()->isIntOrIntVectorTy(),
-           "Logical operators only work with integral types!", &B);
-    Assert(B.getType() == B.getOperand(0)->getType(),
-           "Logical operators must have same type for operands and result!",
-           &B);
+    Check(B.getType()->isIntOrIntVectorTy(),
+    Check(B.getType() == B.getOperand(0)->getType(),
+          "Logical operators must have same type for operands and result!", &B);
     break;
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::AShr:
-    Assert(B.getType()->isIntOrIntVectorTy(),
-           "Shifts only work with integral types!", &B);
-    Assert(B.getType() == B.getOperand(0)->getType(),
-           "Shift return type must be same as operands!", &B);
+    Check(B.getType()->isIntOrIntVectorTy(),
+    Check(B.getType() == B.getOperand(0)->getType(),
     break;
   default:
     llvm_unreachable("Unknown BinaryOperator opcode!");
   }
 
   visitInstruction(B);
 }
 
 void Verifier::visitICmpInst(ICmpInst &IC) {
   // Check that the operands are the same type
   Type *Op0Ty = IC.getOperand(0)->getType();
   Type *Op1Ty = IC.getOperand(1)->getType();
-  Assert(Op0Ty == Op1Ty,
-         "Both operands to ICmp instruction are not of the same type!", &IC);
+  Check(Op0Ty == Op1Ty,
   // Check that the operands are the right type
-  Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy(),
-         "Invalid operand types for ICmp instruction", &IC);
+  Check(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy(),
   // Check that the predicate is valid.
-  Assert(IC.isIntPredicate(),
-         "Invalid predicate in ICmp instruction!", &IC);
+  Check(IC.isIntPredicate(), "Invalid predicate in ICmp instruction!", &IC);
 
   visitInstruction(IC);
 }
 
 void Verifier::visitFCmpInst(FCmpInst &FC) {
   // Check that the operands are the same type
   Type *Op0Ty = FC.getOperand(0)->getType();
   Type *Op1Ty = FC.getOperand(1)->getType();
-  Assert(Op0Ty == Op1Ty,
-         "Both operands to FCmp instruction are not of the same type!", &FC);
+  Check(Op0Ty == Op1Ty,
   // Check that the operands are the right type
-  Assert(Op0Ty->isFPOrFPVectorTy(),
-         "Invalid operand types for FCmp instruction", &FC);
+  Check(Op0Ty->isFPOrFPVectorTy(), "Invalid operand types for FCmp instruction",
+        &FC);
   // Check that the predicate is valid.
-  Assert(FC.isFPPredicate(),
-         "Invalid predicate in FCmp instruction!", &FC);
+  Check(FC.isFPPredicate(), "Invalid predicate in FCmp instruction!", &FC);
 
   visitInstruction(FC);
 }
 
 void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
-  Assert(
-      ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
+  Check(ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
         "Invalid extractelement operands!", &EI);
   visitInstruction(EI);
 }
 
 void Verifier::visitInsertElementInst(InsertElementInst &IE) {
-  Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
-                                            IE.getOperand(2)),
-         "Invalid insertelement operands!", &IE);
+  Check(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
   visitInstruction(IE);
 }
 
 void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
-  Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
-                                            SV.getShuffleMask()),
-         "Invalid shufflevector operands!", &SV);
+  Check(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
   visitInstruction(SV);
 }
 
 void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
 
-  Assert(isa<PointerType>(TargetTy),
-         "GEP base pointer is not a vector or a vector of pointers", &GEP);
-  Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
+  Check(isa<PointerType>(TargetTy),
+  Check(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
 
   SmallVector<Value *, 16> Idxs(GEP.indices());
-  Assert(all_of(
-      Idxs, [](Value* V) { return V->getType()->isIntOrIntVectorTy(); }),
+  Check(
+      all_of(Idxs, [](Value *V) { return V->getType()->isIntOrIntVectorTy(); }),
       "GEP indexes must be integers", &GEP);
   Type *ElTy =
       GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs);
-  Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP);
+  Check(ElTy, "Invalid indices for GEP pointer type!", &GEP);
 
-  Assert(GEP.getType()->isPtrOrPtrVectorTy() &&
-             GEP.getResultElementType() == ElTy,
-         "GEP is not of right type for indices!", &GEP, ElTy);
+  Check(GEP.getType()->isPtrOrPtrVectorTy() &&
 
   if (auto *GEPVTy = dyn_cast<VectorType>(GEP.getType())) {
     // Additional checks for vector GEPs.
     ElementCount GEPWidth = GEPVTy->getElementCount();
     if (GEP.getPointerOperandType()->isVectorTy())
-      Assert(
+      Check(
           GEPWidth ==
               cast<VectorType>(GEP.getPointerOperandType())->getElementCount(),
           "Vector GEP result width doesn't match operand's", &GEP);
     for (Value *Idx : Idxs) {
       Type *IndexTy = Idx->getType();
       if (auto *IndexVTy = dyn_cast<VectorType>(IndexTy)) {
         ElementCount IndexWidth = IndexVTy->getElementCount();
-        Assert(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP);
+        Check(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP);
       }
-      Assert(IndexTy->isIntOrIntVectorTy(),
-             "All GEP indices should be of integer type");
+      Check(IndexTy->isIntOrIntVectorTy(),
     }
   }
 
   if (auto *PTy = dyn_cast<PointerType>(GEP.getType())) {
-    Assert(GEP.getAddressSpace() == PTy->getAddressSpace(),
-           "GEP address space doesn't match type", &GEP);
+    Check(GEP.getAddressSpace() == PTy->getAddressSpace(),
   }
 
   visitInstruction(GEP);
 }
 
 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
   return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
 }
 
 void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
   assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&
          "precondition violation");
 
   unsigned NumOperands = Range->getNumOperands();
-  Assert(NumOperands % 2 == 0, "Unfinished range!", Range);
+  Check(NumOperands % 2 == 0, "Unfinished range!", Range);
   unsigned NumRanges = NumOperands / 2;
-  Assert(NumRanges >= 1, "It should have at least one range!", Range);
+  Check(NumRanges >= 1, "It should have at least one range!", Range);
 
   ConstantRange LastRange(1, true); // Dummy initial value
   for (unsigned i = 0; i < NumRanges; ++i) {
     ConstantInt *Low =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
-    Assert(Low, "The lower limit must be an integer!", Low);
+    Check(Low, "The lower limit must be an integer!", Low);
     ConstantInt *High =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
-    Assert(High, "The upper limit must be an integer!", High);
-    Assert(High->getType() == Low->getType() && High->getType() == Ty,
-           "Range types must match instruction type!", &I);
+    Check(High, "The upper limit must be an integer!", High);
+    Check(High->getType() == Low->getType() && High->getType() == Ty,
 
     APInt HighV = High->getValue();
     APInt LowV = Low->getValue();
     ConstantRange CurRange(LowV, HighV);
-    Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),
-           "Range must not be empty!", Range);
+    Check(!CurRange.isEmptySet() && !CurRange.isFullSet(),
     if (i != 0) {
-      Assert(CurRange.intersectWith(LastRange).isEmptySet(),
-             "Intervals are overlapping", Range);
-      Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
-             Range);
-      Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
-             Range);
+      Check(CurRange.intersectWith(LastRange).isEmptySet(),
+      Check(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
+      Check(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
     }
     LastRange = ConstantRange(LowV, HighV);
   }
   if (NumRanges > 2) {
     APInt FirstLow =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
     APInt FirstHigh =
         mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
     ConstantRange FirstRange(FirstLow, FirstHigh);
-    Assert(FirstRange.intersectWith(LastRange).isEmptySet(),
-           "Intervals are overlapping", Range);
-    Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
-           Range);
+    Check(FirstRange.intersectWith(LastRange).isEmptySet(),
+    Check(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
   }
 }
 
 void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
   unsigned Size = DL.getTypeSizeInBits(Ty);
-  Assert(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
-  Assert(!(Size & (Size - 1)),
-         "atomic memory access' operand must have a power-of-two size", Ty, I);
+  Check(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
+  Check(!(Size & (Size - 1)),
 }
 
 void Verifier::visitLoadInst(LoadInst &LI) {
   PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
-  Assert(PTy, "Load operand must be a pointer.", &LI);
+  Check(PTy, "Load operand must be a pointer.", &LI);
   Type *ElTy = LI.getType();
   if (MaybeAlign A = LI.getAlign()) {
-    Assert(A->value() <= Value::MaximumAlignment,
-           "huge alignment values are unsupported", &LI);
+    Check(A->value() <= Value::MaximumAlignment,
   }
-  Assert(ElTy->isSized(), "loading unsized types is not allowed", &LI);
+  Check(ElTy->isSized(), "loading unsized types is not allowed", &LI);
   if (LI.isAtomic()) {
-    Assert(LI.getOrdering() != AtomicOrdering::Release &&
-               LI.getOrdering() != AtomicOrdering::AcquireRelease,
-           "Load cannot have Release ordering", &LI);
-    Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
-           "atomic load operand must have integer, pointer, or floating point "
-           "type!",
-           ElTy, &LI);
+    Check(LI.getOrdering() != AtomicOrdering::Release &&
+    Check(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
     checkAtomicMemAccessSize(ElTy, &LI);
   } else {
-    Assert(LI.getSyncScopeID() == SyncScope::System,
-           "Non-atomic load cannot have SynchronizationScope specified", &LI);
+    Check(LI.getSyncScopeID() == SyncScope::System,
   }
 
   visitInstruction(LI);
 }
 
 void Verifier::visitStoreInst(StoreInst &SI) {
   PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
-  Assert(PTy, "Store operand must be a pointer.", &SI);
+  Check(PTy, "Store operand must be a pointer.", &SI);
   Type *ElTy = SI.getOperand(0)->getType();
-  Assert(PTy->isOpaqueOrPointeeTypeMatches(ElTy),
-         "Stored value type does not match pointer operand type!", &SI, ElTy);
+  Check(PTy->isOpaqueOrPointeeTypeMatches(ElTy),
   if (MaybeAlign A = SI.getAlign()) {
-    Assert(A->value() <= Value::MaximumAlignment,
-           "huge alignment values are unsupported", &SI);
+    Check(A->value() <= Value::MaximumAlignment,
   }
-  Assert(ElTy->isSized(), "storing unsized types is not allowed", &SI);
+  Check(ElTy->isSized(), "storing unsized types is not allowed", &SI);
   if (SI.isAtomic()) {
-    Assert(SI.getOrdering() != AtomicOrdering::Acquire &&
-               SI.getOrdering() != AtomicOrdering::AcquireRelease,
-           "Store cannot have Acquire ordering", &SI);
-    Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
-           "atomic store operand must have integer, pointer, or floating point "
-           "type!",
-           ElTy, &SI);
+    Check(SI.getOrdering() != AtomicOrdering::Acquire &&
+    Check(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
     checkAtomicMemAccessSize(ElTy, &SI);
   } else {
-    Assert(SI.getSyncScopeID() == SyncScope::System,
-           "Non-atomic store cannot have SynchronizationScope specified", &SI);
+    Check(SI.getSyncScopeID() == SyncScope::System,
   }
   visitInstruction(SI);
 }
 
 /// Check that SwiftErrorVal is used as a swifterror argument in CS.
 void Verifier::verifySwiftErrorCall(CallBase &Call,
                                     const Value *SwiftErrorVal) {
   for (const auto &I : llvm::enumerate(Call.args())) {
     if (I.value() == SwiftErrorVal) {
-      Assert(Call.paramHasAttr(I.index(), Attribute::SwiftError),
-             "swifterror value when used in a callsite should be marked "
-             "with swifterror attribute",
-             SwiftErrorVal, Call);
+      Check(Call.paramHasAttr(I.index(), Attribute::SwiftError),
     }
   }
 }
 
 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) ||
+    Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
               isa<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);
+      Check(StoreI->getOperand(1) == SwiftErrorVal,
+            "by stores",
+            SwiftErrorVal, U);
     if (auto *Call = dyn_cast<CallBase>(U))
       verifySwiftErrorCall(*const_cast<CallBase *>(Call), SwiftErrorVal);
   }
 }
 
 void Verifier::visitAllocaInst(AllocaInst &AI) {
   SmallPtrSet<Type*, 4> Visited;
-  Assert(AI.getAllocatedType()->isSized(&Visited),
-         "Cannot allocate unsized type", &AI);
-  Assert(AI.getArraySize()->getType()->isIntegerTy(),
-         "Alloca array size must have integer type", &AI);
+  Check(AI.getAllocatedType()->isSized(&Visited),
+  Check(AI.getArraySize()->getType()->isIntegerTy(),
   if (MaybeAlign A = AI.getAlign()) {
-    Assert(A->value() <= Value::MaximumAlignment,
-           "huge alignment values are unsupported", &AI);
+    Check(A->value() <= Value::MaximumAlignment,
   }
 
   if (AI.isSwiftError()) {
-    Assert(AI.getAllocatedType()->isPointerTy(),
-           "swifterror alloca must have pointer type", &AI);
-    Assert(!AI.isArrayAllocation(),
-           "swifterror alloca must not be array allocation", &AI);
+    Check(AI.getAllocatedType()->isPointerTy(),
+    Check(!AI.isArrayAllocation(),
     verifySwiftErrorValue(&AI);
   }
 
   visitInstruction(AI);
 }
 
 void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
   Type *ElTy = CXI.getOperand(1)->getType();
-  Assert(ElTy->isIntOrPtrTy(),
-         "cmpxchg operand must have integer or pointer type", ElTy, &CXI);
+  Check(ElTy->isIntOrPtrTy(),
   checkAtomicMemAccessSize(ElTy, &CXI);
   visitInstruction(CXI);
 }
 
 void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
-  Assert(RMWI.getOrdering() != AtomicOrdering::Unordered,
-         "atomicrmw instructions cannot be unordered.", &RMWI);
+  Check(RMWI.getOrdering() != AtomicOrdering::Unordered,
   auto Op = RMWI.getOperation();
   Type *ElTy = RMWI.getOperand(1)->getType();
   if (Op == AtomicRMWInst::Xchg) {
-    Assert(ElTy->isIntegerTy() || ElTy->isFloatingPointTy(), "atomicrmw " +
-           AtomicRMWInst::getOperationName(Op) +
+    Check(ElTy->isIntegerTy() || ElTy->isFloatingPointTy(),
+          "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
               " operand must have integer or floating point type!",
-           &RMWI, ElTy);
   } else if (AtomicRMWInst::isFPOperation(Op)) {
-    Assert(ElTy->isFloatingPointTy(), "atomicrmw " +
-           AtomicRMWInst::getOperationName(Op) +
+    Check(ElTy->isFloatingPointTy(),
+          "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
               " operand must have floating point type!",
-           &RMWI, ElTy);
   } else {
-    Assert(ElTy->isIntegerTy(), "atomicrmw " +
-           AtomicRMWInst::getOperationName(Op) +
+    Check(ElTy->isIntegerTy(),
+          "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
               " operand must have integer type!",
-           &RMWI, ElTy);
   }
   checkAtomicMemAccessSize(ElTy, &RMWI);
-  Assert(AtomicRMWInst::FIRST_BINOP <= Op && Op <= AtomicRMWInst::LAST_BINOP,
-         "Invalid binary operation!", &RMWI);
+  Check(AtomicRMWInst::FIRST_BINOP <= Op && Op <= AtomicRMWInst::LAST_BINOP,
   visitInstruction(RMWI);
 }
 
 void Verifier::visitFenceInst(FenceInst &FI) {
   const AtomicOrdering Ordering = FI.getOrdering();
-  Assert(Ordering == AtomicOrdering::Acquire ||
-             Ordering == AtomicOrdering::Release ||
-             Ordering == AtomicOrdering::AcquireRelease ||
-             Ordering == AtomicOrdering::SequentiallyConsistent,
-         "fence instructions may only have acquire, release, acq_rel, or "
-         "seq_cst ordering.",
-         &FI);
+  Check(Ordering == AtomicOrdering::Acquire ||
   visitInstruction(FI);
 }
 
 void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
-  Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
-                                          EVI.getIndices()) == EVI.getType(),
-         "Invalid ExtractValueInst operands!", &EVI);
+  Check(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
 
   visitInstruction(EVI);
 }
 
 void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
-  Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
-                                          IVI.getIndices()) ==
-             IVI.getOperand(1)->getType(),
-         "Invalid InsertValueInst operands!", &IVI);
+  Check(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
 
   visitInstruction(IVI);
 }
 
 static Value *getParentPad(Value *EHPad) {
   if (auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
     return FPI->getParentPad();
 
   return cast<CatchSwitchInst>(EHPad)->getParentPad();
 }
 
 void Verifier::visitEHPadPredecessors(Instruction &I) {
   assert(I.isEHPad());
 
   BasicBlock *BB = I.getParent();
   Function *F = BB->getParent();
 
-  Assert(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
+  Check(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
 
   if (auto *LPI = dyn_cast<LandingPadInst>(&I)) {
     // The landingpad instruction defines its parent as a landing pad block. The
     // landing pad block may be branched to only by the unwind edge of an
     // invoke.
     for (BasicBlock *PredBB : predecessors(BB)) {
       const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator());
-      Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
-             "Block containing LandingPadInst must be jumped to "
-             "only by the unwind edge of an invoke.",
-             LPI);
+      Check(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
     }
     return;
   }
   if (auto *CPI = dyn_cast<CatchPadInst>(&I)) {
     if (!pred_empty(BB))
-      Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
-             "Block containg CatchPadInst must be jumped to "
-             "only by its catchswitch.",
-             CPI);
-    Assert(BB != CPI->getCatchSwitch()->getUnwindDest(),
-           "Catchswitch cannot unwind to one of its catchpads",
-           CPI->getCatchSwitch(), CPI);
+      Check(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
+    Check(BB != CPI->getCatchSwitch()->getUnwindDest(),
     return;
   }
 
   // Verify that each pred has a legal terminator with a legal to/from EH
   // pad relationship.
   Instruction *ToPad = &I;
   Value *ToPadParent = getParentPad(ToPad);
   for (BasicBlock *PredBB : predecessors(BB)) {
     Instruction *TI = PredBB->getTerminator();
     Value *FromPad;
     if (auto *II = dyn_cast<InvokeInst>(TI)) {
-      Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB,
-             "EH pad must be jumped to via an unwind edge", ToPad, II);
+      Check(II->getUnwindDest() == BB && II->getNormalDest() != BB,
       if (auto Bundle = II->getOperandBundle(LLVMContext::OB_funclet))
         FromPad = Bundle->Inputs[0];
       else
         FromPad = ConstantTokenNone::get(II->getContext());
     } else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
       FromPad = CRI->getOperand(0);
-      Assert(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI);
+      Check(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI);
     } else if (auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
       FromPad = CSI;
     } else {
-      Assert(false, "EH pad must be jumped to via an unwind edge", ToPad, TI);
+      Check(false, "EH pad must be jumped to via an unwind edge", ToPad, TI);
     }
 
     // The edge may exit from zero or more nested pads.
     SmallSet<Value *, 8> Seen;
     for (;; FromPad = getParentPad(FromPad)) {
-      Assert(FromPad != ToPad,
-             "EH pad cannot handle exceptions raised within it", FromPad, TI);
+      Check(FromPad != ToPad,
       if (FromPad == ToPadParent) {
         // This is a legal unwind edge.
         break;
       }
-      Assert(!isa<ConstantTokenNone>(FromPad),
-             "A single unwind edge may only enter one EH pad", TI);
-      Assert(Seen.insert(FromPad).second,
-             "EH pad jumps through a cycle of pads", FromPad);
+      Check(!isa<ConstantTokenNone>(FromPad),
+      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.
-      Assert(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
-             "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
+      Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
     }
   }
 }
 
 void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
   // The landingpad instruction is ill-formed if it doesn't have any clauses and
   // isn't a cleanup.
-  Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
-         "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
+  Check(LPI.getNumClauses() > 0 || LPI.isCleanup(),
 
   visitEHPadPredecessors(LPI);
 
   if (!LandingPadResultTy)
     LandingPadResultTy = LPI.getType();
   else
-    Assert(LandingPadResultTy == LPI.getType(),
-           "The landingpad instruction should have a consistent result type "
-           "inside a function.",
-           &LPI);
+    Check(LandingPadResultTy == LPI.getType(),
 
   Function *F = LPI.getParent()->getParent();
-  Assert(F->hasPersonalityFn(),
-         "LandingPadInst needs to be in a function with a personality.", &LPI);
+  Check(F->hasPersonalityFn(),
 
   // The landingpad instruction must be the first non-PHI instruction in the
   // block.
-  Assert(LPI.getParent()->getLandingPadInst() == &LPI,
-         "LandingPadInst not the first non-PHI instruction in the block.",
-         &LPI);
+  Check(LPI.getParent()->getLandingPadInst() == &LPI,
+        "LandingPadInst not the first non-PHI instruction in the block.", &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);
+      Check(isa<PointerType>(Clause->getType()),
     } else {
-      Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
-      Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
-             "Filter operand is not an array of constants!", &LPI);
+      Check(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
+      Check(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
     }
   }
 
   visitInstruction(LPI);
 }
 
 void Verifier::visitResumeInst(ResumeInst &RI) {
-  Assert(RI.getFunction()->hasPersonalityFn(),
-         "ResumeInst needs to be in a function with a personality.", &RI);
+  Check(RI.getFunction()->hasPersonalityFn(),
 
   if (!LandingPadResultTy)
     LandingPadResultTy = RI.getValue()->getType();
   else
-    Assert(LandingPadResultTy == RI.getValue()->getType(),
-           "The resume instruction should have a consistent result type "
-           "inside a function.",
-           &RI);
+    Check(LandingPadResultTy == RI.getValue()->getType(),
 
   visitTerminator(RI);
 }
 
 void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
   BasicBlock *BB = CPI.getParent();
 
   Function *F = BB->getParent();
-  Assert(F->hasPersonalityFn(),
-         "CatchPadInst needs to be in a function with a personality.", &CPI);
+  Check(F->hasPersonalityFn(),
 
-  Assert(isa<CatchSwitchInst>(CPI.getParentPad()),
-         "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
-         CPI.getParentPad());
+  Check(isa<CatchSwitchInst>(CPI.getParentPad()),
 
   // The catchpad instruction must be the first non-PHI instruction in the
   // block.
-  Assert(BB->getFirstNonPHI() == &CPI,
-         "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
+  Check(BB->getFirstNonPHI() == &CPI,
 
   visitEHPadPredecessors(CPI);
   visitFuncletPadInst(CPI);
 }
 
 void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
-  Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)),
-         "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
-         CatchReturn.getOperand(0));
+  Check(isa<CatchPadInst>(CatchReturn.getOperand(0)),
 
   visitTerminator(CatchReturn);
 }
 
 void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
   BasicBlock *BB = CPI.getParent();
 
   Function *F = BB->getParent();
-  Assert(F->hasPersonalityFn(),
-         "CleanupPadInst needs to be in a function with a personality.", &CPI);
+  Check(F->hasPersonalityFn(),
 
   // 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);
+  Check(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),
-         "CleanupPadInst has an invalid parent.", &CPI);
+  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
 
   visitEHPadPredecessors(CPI);
   visitFuncletPadInst(CPI);
 }
 
 void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
   User *FirstUser = nullptr;
   Value *FirstUnwindPad = nullptr;
   SmallVector<FuncletPadInst *, 8> Worklist({&FPI});
   SmallSet<FuncletPadInst *, 8> Seen;
 
   while (!Worklist.empty()) {
     FuncletPadInst *CurrentPad = Worklist.pop_back_val();
-    Assert(Seen.insert(CurrentPad).second,
-           "FuncletPadInst must not be nested within itself", CurrentPad);
+    Check(Seen.insert(CurrentPad).second,
     Value *UnresolvedAncestorPad = nullptr;
     for (User *U : CurrentPad->users()) {
       BasicBlock *UnwindDest;
       if (auto *CRI = dyn_cast<CleanupReturnInst>(U)) {
         UnwindDest = CRI->getUnwindDest();
       } else if (auto *CSI = dyn_cast<CatchSwitchInst>(U)) {
         // We allow catchswitch unwind to caller to nest
         // within an outer pad that unwinds somewhere else,
for (User *U : CurrentPad->users()) {
         continue;
       } else if (auto *CPI = dyn_cast<CleanupPadInst>(U)) {
         // The unwind dest for a cleanup can only be found by
         // recursive search.  Add it to the worklist, and we'll
         // search for its first use that determines where it unwinds.
         Worklist.push_back(CPI);
         continue;
       } else {
-        Assert(isa<CatchReturnInst>(U), "Bogus funclet pad use", U);
+        Check(isa<CatchReturnInst>(U), "Bogus funclet pad use", U);
         continue;
       }
 
       Value *UnwindPad;
       bool ExitsFPI;
       if (UnwindDest) {
         UnwindPad = UnwindDest->getFirstNonPHI();
         if (!cast<Instruction>(UnwindPad)->isEHPad())
for (User *U : CurrentPad->users()) {
         ExitsFPI = true;
         UnresolvedAncestorPad = &FPI;
       }
 
       if (ExitsFPI) {
         // This unwind edge exits FPI.  Make sure it agrees with other
         // such edges.
         if (FirstUser) {
-          Assert(UnwindPad == FirstUnwindPad, "Unwind edges out of a funclet "
-                                              "pad must have the same unwind "
-                                              "dest",
-                 &FPI, U, FirstUser);
+          Check(UnwindPad == FirstUnwindPad,
+                "Unwind edges out of a funclet "
         } else {
           FirstUser = U;
           FirstUnwindPad = UnwindPad;
           // Record cleanup sibling unwinds for verifySiblingFuncletUnwinds
           if (isa<CleanupPadInst>(&FPI) && !isa<ConstantTokenNone>(UnwindPad) &&
               getParentPad(UnwindPad) == getParentPad(&FPI))
             SiblingFuncletInfo[&FPI] = cast<Instruction>(U);
         }
void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
   if (FirstUnwindPad) {
     if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FPI.getParentPad())) {
       BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
       Value *SwitchUnwindPad;
       if (SwitchUnwindDest)
         SwitchUnwindPad = SwitchUnwindDest->getFirstNonPHI();
       else
         SwitchUnwindPad = ConstantTokenNone::get(FPI.getContext());
-      Assert(SwitchUnwindPad == FirstUnwindPad,
-             "Unwind edges out of a catch must have the same unwind dest as "
-             "the parent catchswitch",
-             &FPI, FirstUser, CatchSwitch);
+      Check(SwitchUnwindPad == FirstUnwindPad,
     }
   }
 
   visitInstruction(FPI);
 }
 
 void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
   BasicBlock *BB = CatchSwitch.getParent();
 
   Function *F = BB->getParent();
-  Assert(F->hasPersonalityFn(),
-         "CatchSwitchInst needs to be in a function with a personality.",
-         &CatchSwitch);
+  Check(F->hasPersonalityFn(),
 
   // 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);
+  Check(BB->getFirstNonPHI() == &CatchSwitch,
 
   auto *ParentPad = CatchSwitch.getParentPad();
-  Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
-         "CatchSwitchInst has an invalid parent.", ParentPad);
+  Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(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);
+    Check(I->isEHPad() && !isa<LandingPadInst>(I),
 
     // Record catchswitch sibling unwinds for verifySiblingFuncletUnwinds
     if (getParentPad(I) == ParentPad)
       SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
   }
 
-  Assert(CatchSwitch.getNumHandlers() != 0,
-         "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
+  Check(CatchSwitch.getNumHandlers() != 0,
 
   for (BasicBlock *Handler : CatchSwitch.handlers()) {
-    Assert(isa<CatchPadInst>(Handler->getFirstNonPHI()),
-           "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
+    Check(isa<CatchPadInst>(Handler->getFirstNonPHI()),
   }
 
   visitEHPadPredecessors(CatchSwitch);
   visitTerminator(CatchSwitch);
 }
 
 void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) {
-  Assert(isa<CleanupPadInst>(CRI.getOperand(0)),
-         "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
-         CRI.getOperand(0));
+  Check(isa<CleanupPadInst>(CRI.getOperand(0)),
 
   if (BasicBlock *UnwindDest = CRI.getUnwindDest()) {
     Instruction *I = UnwindDest->getFirstNonPHI();
-    Assert(I->isEHPad() && !isa<LandingPadInst>(I),
-           "CleanupReturnInst must unwind to an EH block which is not a "
-           "landingpad.",
-           &CRI);
+    Check(I->isEHPad() && !isa<LandingPadInst>(I),
   }
 
   visitTerminator(CRI);
 }
 
 void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   Instruction *Op = cast<Instruction>(I.getOperand(i));
   // If the we have an invalid invoke, don't try to compute the dominance.
void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
   //
   // FIXME: If this operand is a MetadataAsValue (wrapping a LocalAsMetadata)
   // wrapping an SSA value, assert that we've already encountered it.  See
   // related FIXME in Mapper::mapLocalAsMetadata in ValueMapper.cpp.
   if (!isa<PHINode>(I) && InstsInThisBlock.count(Op))
     return;
 
   const Use &U = I.getOperandUse(i);
-  Assert(DT.dominates(Op, U),
-         "Instruction does not dominate all uses!", Op, &I);
+  Check(DT.dominates(Op, U), "Instruction does not dominate all uses!", Op, &I);
 }
 
 void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
-  Assert(I.getType()->isPointerTy(), "dereferenceable, dereferenceable_or_null "
-         "apply only to pointer types", &I);
-  Assert((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
-         "dereferenceable, dereferenceable_or_null apply only to load"
-         " and inttoptr instructions, use attributes for calls or invokes", &I);
-  Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null "
-         "take one operand!", &I);
+  Check(I.getType()->isPointerTy(),
+        "dereferenceable, dereferenceable_or_null "
+        "apply only to pointer types",
+        &I);
+  Check((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
+        " 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));
-  Assert(CI && CI->getType()->isIntegerTy(64), "dereferenceable, "
-         "dereferenceable_or_null metadata value must be an i64!", &I);
+  Check(CI && CI->getType()->isIntegerTy(64),
+        "dereferenceable, "
+        "dereferenceable_or_null metadata value must be an i64!",
+        &I);
 }
 
 void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) {
-  Assert(MD->getNumOperands() >= 2,
-         "!prof annotations should have no less than 2 operands", MD);
+  Check(MD->getNumOperands() >= 2,
 
   // Check first operand.
-  Assert(MD->getOperand(0) != nullptr, "first operand should not be null", MD);
-  Assert(isa<MDString>(MD->getOperand(0)),
-         "expected string with name of the !prof annotation", MD);
+  Check(MD->getOperand(0) != nullptr, "first operand should not be null", MD);
+  Check(isa<MDString>(MD->getOperand(0)),
   MDString *MDS = cast<MDString>(MD->getOperand(0));
   StringRef ProfName = MDS->getString();
 
   // Check consistency of !prof branch_weights metadata.
   if (ProfName.equals("branch_weights")) {
     if (isa<InvokeInst>(&I)) {
-      Assert(MD->getNumOperands() == 2 || MD->getNumOperands() == 3,
-             "Wrong number of InvokeInst branch_weights operands", MD);
+      Check(MD->getNumOperands() == 2 || MD->getNumOperands() == 3,
     } else {
       unsigned ExpectedNumOperands = 0;
       if (BranchInst *BI = dyn_cast<BranchInst>(&I))
         ExpectedNumOperands = BI->getNumSuccessors();
       else if (SwitchInst *SI = dyn_cast<SwitchInst>(&I))
         ExpectedNumOperands = SI->getNumSuccessors();
       else if (isa<CallInst>(&I))
         ExpectedNumOperands = 1;
       else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(&I))
         ExpectedNumOperands = IBI->getNumDestinations();
       else if (isa<SelectInst>(&I))
         ExpectedNumOperands = 2;
       else
         CheckFailed("!prof branch_weights are not allowed for this instruction",
                     MD);
 
-      Assert(MD->getNumOperands() == 1 + ExpectedNumOperands,
-             "Wrong number of operands", MD);
+      Check(MD->getNumOperands() == 1 + ExpectedNumOperands,
     }
     for (unsigned i = 1; i < MD->getNumOperands(); ++i) {
       auto &MDO = MD->getOperand(i);
-      Assert(MDO, "second operand should not be null", MD);
-      Assert(mdconst::dyn_extract<ConstantInt>(MDO),
-             "!prof brunch_weights operand is not a const int");
+      Check(MDO, "second operand should not be null", MD);
+      Check(mdconst::dyn_extract<ConstantInt>(MDO),
     }
   }
 }
 
 void Verifier::visitAnnotationMetadata(MDNode *Annotation) {
-  Assert(isa<MDTuple>(Annotation), "annotation must be a tuple");
-  Assert(Annotation->getNumOperands() >= 1,
-         "annotation must have at least one operand");
+  Check(isa<MDTuple>(Annotation), "annotation must be a tuple");
+  Check(Annotation->getNumOperands() >= 1,
   for (const MDOperand &Op : Annotation->operands())
-    Assert(isa<MDString>(Op.get()), "operands must be strings");
+    Check(isa<MDString>(Op.get()), "operands must be strings");
 }
 
 void Verifier::visitAliasScopeMetadata(const MDNode *MD) {
   unsigned NumOps = MD->getNumOperands();
-  Assert(NumOps >= 2 && NumOps <= 3, "scope must have two or three operands",
-         MD);
-  Assert(MD->getOperand(0).get() == MD || isa<MDString>(MD->getOperand(0)),
-         "first scope operand must be self-referential or string", MD);
+  Check(NumOps >= 2 && NumOps <= 3, "scope must have two or three operands",
+  Check(MD->getOperand(0).get() == MD || isa<MDString>(MD->getOperand(0)),
   if (NumOps == 3)
-    Assert(isa<MDString>(MD->getOperand(2)),
-           "third scope operand must be string (if used)", MD);
+    Check(isa<MDString>(MD->getOperand(2)),
 
   MDNode *Domain = dyn_cast<MDNode>(MD->getOperand(1));
-  Assert(Domain != nullptr, "second scope operand must be MDNode", MD);
+  Check(Domain != nullptr, "second scope operand must be MDNode", MD);
 
   unsigned NumDomainOps = Domain->getNumOperands();
-  Assert(NumDomainOps >= 1 && NumDomainOps <= 2,
-         "domain must have one or two operands", Domain);
-  Assert(Domain->getOperand(0).get() == Domain ||
-             isa<MDString>(Domain->getOperand(0)),
-         "first domain operand must be self-referential or string", Domain);
+  Check(NumDomainOps >= 1 && NumDomainOps <= 2,
+  Check(Domain->getOperand(0).get() == Domain ||
   if (NumDomainOps == 2)
-    Assert(isa<MDString>(Domain->getOperand(1)),
-           "second domain operand must be string (if used)", Domain);
+    Check(isa<MDString>(Domain->getOperand(1)),
 }
 
 void Verifier::visitAliasScopeListMetadata(const MDNode *MD) {
   for (const MDOperand &Op : MD->operands()) {
     const MDNode *OpMD = dyn_cast<MDNode>(Op);
-    Assert(OpMD != nullptr, "scope list must consist of MDNodes", MD);
+    Check(OpMD != nullptr, "scope list must consist of MDNodes", MD);
     visitAliasScopeMetadata(OpMD);
   }
 }
 
 void Verifier::visitAccessGroupMetadata(const MDNode *MD) {
   auto IsValidAccessScope = [](const MDNode *MD) {
     return MD->getNumOperands() == 0 && MD->isDistinct();
   };
 
   // It must be either an access scope itself...
   if (IsValidAccessScope(MD))
     return;
 
   // ...or a list of access scopes.
   for (const MDOperand &Op : MD->operands()) {
     const MDNode *OpMD = dyn_cast<MDNode>(Op);
-    Assert(OpMD != nullptr, "Access scope list must consist of MDNodes", MD);
-    Assert(IsValidAccessScope(OpMD),
-           "Access scope list contains invalid access scope", MD);
+    Check(OpMD != nullptr, "Access scope list must consist of MDNodes", MD);
+    Check(IsValidAccessScope(OpMD),
   }
 }
 
 /// verifyInstruction - Verify that an instruction is well formed.
 ///
 void Verifier::visitInstruction(Instruction &I) {
   BasicBlock *BB = I.getParent();
-  Assert(BB, "Instruction not embedded in basic block!", &I);
+  Check(BB, "Instruction not embedded in basic block!", &I);
 
   if (!isa<PHINode>(I)) {   // Check that non-phi nodes are not self referential
     for (User *U : I.users()) {
-      Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
-             "Only PHI nodes may reference their own value!", &I);
+      Check(U != (User *)&I || !DT.isReachableFromEntry(BB),
     }
   }
 
   // Check that void typed values don't have names
-  Assert(!I.getType()->isVoidTy() || !I.hasName(),
-         "Instruction has a name, but provides a void value!", &I);
+  Check(!I.getType()->isVoidTy() || !I.hasName(),
 
   // 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(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
 
   // 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),
-         "Invalid use of metadata!", &I);
+  Check(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(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,
-             "Instruction referencing"
-             " instruction not embedded in a basic block!",
-             &I, Used);
+      Check(Used->getParent() != nullptr,
     else {
       CheckFailed("Use of instruction is not an instruction!", U);
       return;
     }
   }
 
   // Get a pointer to the call base of the instruction if it is some form of
   // call.
   const CallBase *CBI = dyn_cast<CallBase>(&I);
 
   for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
-    Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
+    Check(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
 
     // Check to make sure that only first-class-values are operands to
     // instructions.
     if (!I.getOperand(i)->getType()->isFirstClassType()) {
-      Assert(false, "Instruction operands must be first-class values!", &I);
+      Check(false, "Instruction operands must be first-class values!", &I);
     }
 
     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
       // This code checks whether the function is used as the operand of a
       // clang_arc_attachedcall operand bundle.
       auto IsAttachedCallOperand = [](Function *F, const CallBase *CBI,
                                       int Idx) {
         return CBI && CBI->isOperandBundleOfType(
                           LLVMContext::OB_clang_arc_attachedcall, Idx);
       };
 
       // Check to make sure that the "address of" an intrinsic function is never
       // taken. Ignore cases where the address of the intrinsic function is used
       // as the argument of operand bundle "clang.arc.attachedcall" as those
       // cases are handled in verifyAttachedCallBundle.
-      Assert((!F->isIntrinsic() ||
-              (CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i)) ||
-              IsAttachedCallOperand(F, CBI, i)),
-             "Cannot take the address of an intrinsic!", &I);
-      Assert(
-          !F->isIntrinsic() || isa<CallInst>(I) ||
+      Check((!F->isIntrinsic() ||
+      Check(!F->isIntrinsic() || isa<CallInst>(I) ||
                 F->getIntrinsicID() == Intrinsic::donothing ||
                 F->getIntrinsicID() == Intrinsic::seh_try_begin ||
                 F->getIntrinsicID() == Intrinsic::seh_try_end ||
                 F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
                 F->getIntrinsicID() == Intrinsic::seh_scope_end ||
                 F->getIntrinsicID() == Intrinsic::coro_resume ||
                 F->getIntrinsicID() == Intrinsic::coro_destroy ||
-              F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
+                F->getIntrinsicID() ==
+                    Intrinsic::experimental_patchpoint_void ||
                 F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
                 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
                 F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
                 IsAttachedCallOperand(F, CBI, i),
             "Cannot invoke an intrinsic other than donothing, patchpoint, "
             "statepoint, coro_resume, coro_destroy or clang.arc.attachedcall",
             &I);
-      Assert(F->getParent() == &M, "Referencing function in another module!",
-             &I, &M, F, F->getParent());
+      Check(F->getParent() == &M, "Referencing function in another module!", &I,
+            &M, F, F->getParent());
     } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
-      Assert(OpBB->getParent() == BB->getParent(),
-             "Referring to a basic block in another function!", &I);
+      Check(OpBB->getParent() == BB->getParent(),
     } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
-      Assert(OpArg->getParent() == BB->getParent(),
-             "Referring to an argument in another function!", &I);
+      Check(OpArg->getParent() == BB->getParent(),
     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
-      Assert(GV->getParent() == &M, "Referencing global in another module!", &I,
-             &M, GV, GV->getParent());
+      Check(GV->getParent() == &M, "Referencing global in another module!", &I,
     } else if (isa<Instruction>(I.getOperand(i))) {
       verifyDominatesUse(I, i);
     } else if (isa<InlineAsm>(I.getOperand(i))) {
-      Assert(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
-             "Cannot take the address of an inline asm!", &I);
+      Check(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
     } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
       if (CE->getType()->isPtrOrPtrVectorTy()) {
         // If we have a ConstantExpr pointer, we need to see if it came from an
         // illegal bitcast.
         visitConstantExprsRecursively(CE);
       }
     }
   }
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
-    Assert(I.getType()->isFPOrFPVectorTy(),
-           "fpmath requires a floating point result!", &I);
-    Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
+    Check(I.getType()->isFPOrFPVectorTy(),
+    Check(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
     if (ConstantFP *CFP0 =
             mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) {
       const APFloat &Accuracy = CFP0->getValueAPF();
-      Assert(&Accuracy.getSemantics() == &APFloat::IEEEsingle(),
-             "fpmath accuracy must have float type", &I);
-      Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
-             "fpmath accuracy not a positive number!", &I);
+      Check(&Accuracy.getSemantics() == &APFloat::IEEEsingle(),
+      Check(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
     } else {
-      Assert(false, "invalid fpmath accuracy!", &I);
+      Check(false, "invalid fpmath accuracy!", &I);
     }
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
-    Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
-           "Ranges are only for loads, calls and invokes!", &I);
+    Check(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
     visitRangeMetadata(I, Range, I.getType());
   }
 
   if (I.hasMetadata(LLVMContext::MD_invariant_group)) {
-    Assert(isa<LoadInst>(I) || isa<StoreInst>(I),
-           "invariant.group metadata is only for loads and stores", &I);
+    Check(isa<LoadInst>(I) || isa<StoreInst>(I),
   }
 
   if (I.getMetadata(LLVMContext::MD_nonnull)) {
-    Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
-           &I);
-    Assert(isa<LoadInst>(I),
-           "nonnull applies only to load instructions, use attributes"
-           " for calls or invokes",
-           &I);
+    Check(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
+    Check(isa<LoadInst>(I),
   }
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable))
     visitDereferenceableMetadata(I, MD);
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
     visitDereferenceableMetadata(I, MD);
 
   if (MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa))
     TBAAVerifyHelper.visitTBAAMetadata(I, TBAA);
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_noalias))
     visitAliasScopeListMetadata(MD);
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_alias_scope))
     visitAliasScopeListMetadata(MD);
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_access_group))
     visitAccessGroupMetadata(MD);
 
   if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) {
-    Assert(I.getType()->isPointerTy(), "align applies only to pointer types",
-           &I);
-    Assert(isa<LoadInst>(I), "align applies only to load instructions, "
-           "use attributes for calls or invokes", &I);
-    Assert(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
+    Check(I.getType()->isPointerTy(), "align applies only to pointer types",
+    Check(isa<LoadInst>(I),
+          "align applies only to load instructions, "
+          "use attributes for calls or invokes",
+          &I);
+    Check(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
     ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
-    Assert(CI && CI->getType()->isIntegerTy(64),
-           "align metadata value must be an i64!", &I);
+    Check(CI && CI->getType()->isIntegerTy(64),
     uint64_t Align = CI->getZExtValue();
-    Assert(isPowerOf2_64(Align),
-           "align metadata value must be a power of 2!", &I);
-    Assert(Align <= Value::MaximumAlignment,
-           "alignment is larger that implementation defined limit", &I);
+    Check(isPowerOf2_64(Align), "align metadata value must be a power of 2!",
+          &I);
+    Check(Align <= Value::MaximumAlignment,
   }
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_prof))
     visitProfMetadata(I, MD);
 
   if (MDNode *Annotation = I.getMetadata(LLVMContext::MD_annotation))
     visitAnnotationMetadata(Annotation);
 
   if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
-    AssertDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
+    CheckDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
     visitMDNode(*N, AreDebugLocsAllowed::Yes);
   }
 
   if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
     verifyFragmentExpression(*DII);
     verifyNotEntryValue(*DII);
   }
 
void Verifier::visitInstruction(Instruction &I) {
   }
 
   InstsInThisBlock.insert(&I);
 }
 
 /// Allow intrinsics to be verified in different ways.
 void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
   Function *IF = Call.getCalledFunction();
-  Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!",
-         IF);
+  Check(IF->isDeclaration(), "Intrinsic functions should never be defined!",
 
   // Verify that the intrinsic prototype lines up with what the .td files
   // describe.
   FunctionType *IFTy = IF->getFunctionType();
   bool IsVarArg = IFTy->isVarArg();
 
   SmallVector<Intrinsic::IITDescriptor, 8> Table;
   getIntrinsicInfoTableEntries(ID, Table);
   ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
 
   // Walk the descriptors to extract overloaded types.
   SmallVector<Type *, 4> ArgTys;
   Intrinsic::MatchIntrinsicTypesResult Res =
       Intrinsic::matchIntrinsicSignature(IFTy, TableRef, ArgTys);
-  Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchRet,
-         "Intrinsic has incorrect return type!", IF);
-  Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchArg,
-         "Intrinsic has incorrect argument type!", IF);
+  Check(Res != Intrinsic::MatchIntrinsicTypes_NoMatchRet,
+  Check(Res != Intrinsic::MatchIntrinsicTypes_NoMatchArg,
 
   // Verify if the intrinsic call matches the vararg property.
   if (IsVarArg)
-    Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
-           "Intrinsic was not defined with variable arguments!", IF);
+    Check(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
   else
-    Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
-           "Callsite was not defined with variable arguments!", IF);
+    Check(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
 
   // All descriptors should be absorbed by now.
-  Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
+  Check(TableRef.empty(), "Intrinsic has too few arguments!", IF);
 
   // Now that we have the intrinsic ID and the actual argument types (and we
   // know they are legal for the intrinsic!) get the intrinsic name through the
   // usual means.  This allows us to verify the mangling of argument types into
   // the name.
   const std::string ExpectedName =
       Intrinsic::getName(ID, ArgTys, IF->getParent(), IFTy);
-  Assert(ExpectedName == IF->getName(),
-         "Intrinsic name not mangled correctly for type arguments! "
-         "Should be: " +
-             ExpectedName,
-         IF);
+  Check(ExpectedName == IF->getName(),
 
   // If the intrinsic takes MDNode arguments, verify that they are either global
   // or are local to *this* function.
   for (Value *V : Call.args()) {
     if (auto *MD = dyn_cast<MetadataAsValue>(V))
       visitMetadataAsValue(*MD, Call.getCaller());
     if (auto *Const = dyn_cast<Constant>(V))
-      Assert(!Const->getType()->isX86_AMXTy(),
-             "const x86_amx is not allowed in argument!");
+      Check(!Const->getType()->isX86_AMXTy(),
   }
 
   switch (ID) {
   default:
     break;
   case Intrinsic::assume: {
     for (auto &Elem : Call.bundle_op_infos()) {
-      Assert(Elem.Tag->getKey() == "ignore" ||
-                 Attribute::isExistingAttribute(Elem.Tag->getKey()),
-             "tags must be valid attribute names", Call);
+      Check(Elem.Tag->getKey() == "ignore" ||
       Attribute::AttrKind Kind =
           Attribute::getAttrKindFromName(Elem.Tag->getKey());
       unsigned ArgCount = Elem.End - Elem.Begin;
       if (Kind == Attribute::Alignment) {
-        Assert(ArgCount <= 3 && ArgCount >= 2,
-               "alignment assumptions should have 2 or 3 arguments", Call);
-        Assert(Call.getOperand(Elem.Begin)->getType()->isPointerTy(),
-               "first argument should be a pointer", Call);
-        Assert(Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(),
-               "second argument should be an integer", Call);
+        Check(ArgCount <= 3 && ArgCount >= 2,
+        Check(Call.getOperand(Elem.Begin)->getType()->isPointerTy(),
+        Check(Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(),
         if (ArgCount == 3)
-          Assert(Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(),
-                 "third argument should be an integer if present", Call);
+          Check(Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(),
         return;
       }
-      Assert(ArgCount <= 2, "too many arguments", Call);
+      Check(ArgCount <= 2, "too many arguments", Call);
       if (Kind == Attribute::None)
         break;
       if (Attribute::isIntAttrKind(Kind)) {
-        Assert(ArgCount == 2, "this attribute should have 2 arguments", Call);
-        Assert(isa<ConstantInt>(Call.getOperand(Elem.Begin + 1)),
-               "the second argument should be a constant integral value", Call);
+        Check(ArgCount == 2, "this attribute should have 2 arguments", Call);
+        Check(isa<ConstantInt>(Call.getOperand(Elem.Begin + 1)),
       } else if (Attribute::canUseAsParamAttr(Kind)) {
-        Assert((ArgCount) == 1, "this attribute should have one argument",
-               Call);
+        Check((ArgCount) == 1, "this attribute should have one argument", Call);
       } else if (Attribute::canUseAsFnAttr(Kind)) {
-        Assert((ArgCount) == 0, "this attribute has no argument", Call);
+        Check((ArgCount) == 0, "this attribute has no argument", Call);
       }
     }
     break;
   }
   case Intrinsic::coro_id: {
     auto *InfoArg = Call.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.id must refer to an initialized "
-           "constant");
+    Check(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
     Constant *Init = GV->getInitializer();
-    Assert(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
-           "info argument of llvm.coro.id must refer to either a struct or "
-           "an array");
+    Check(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
     break;
   }
   case Intrinsic::fptrunc_round: {
     // Check the rounding mode
     Metadata *MD = nullptr;
     auto *MAV = dyn_cast<MetadataAsValue>(Call.getOperand(1));
     if (MAV)
       MD = MAV->getMetadata();
 
-    Assert(MD != nullptr, "missing rounding mode argument", Call);
+    Check(MD != nullptr, "missing rounding mode argument", Call);
 
-    Assert(isa<MDString>(MD),
-           ("invalid value for llvm.fptrunc.round metadata operand"
-            " (the operand should be a string)"),
-           MD);
+    Check(isa<MDString>(MD),
 
     Optional<RoundingMode> RoundMode =
         convertStrToRoundingMode(cast<MDString>(MD)->getString());
-    Assert(RoundMode.hasValue() &&
-               RoundMode.getValue() != RoundingMode::Dynamic,
-           "unsupported rounding mode argument", Call);
+    Check(RoundMode.hasValue() && RoundMode.getValue() != RoundingMode::Dynamic,
     break;
   }
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #include "llvm/IR/VPIntrinsics.def"
     visitVPIntrinsic(cast<VPIntrinsic>(Call));
     break;
 #define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC)                        \
   case Intrinsic::INTRINSIC:
 #include "llvm/IR/ConstrainedOps.def"
     visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call));
     break;
   case Intrinsic::dbg_declare: // llvm.dbg.declare
-    Assert(isa<MetadataAsValue>(Call.getArgOperand(0)),
-           "invalid llvm.dbg.declare intrinsic call 1", Call);
+    Check(isa<MetadataAsValue>(Call.getArgOperand(0)),
     visitDbgIntrinsic("declare", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_addr: // llvm.dbg.addr
     visitDbgIntrinsic("addr", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_value: // llvm.dbg.value
     visitDbgIntrinsic("value", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_label: // llvm.dbg.label
     visitDbgLabelIntrinsic("label", cast<DbgLabelInst>(Call));
     break;
   case Intrinsic::memcpy:
   case Intrinsic::memcpy_inline:
   case Intrinsic::memmove:
   case Intrinsic::memset: {
     const auto *MI = cast<MemIntrinsic>(&Call);
     auto IsValidAlignment = [&](unsigned Alignment) -> bool {
       return Alignment == 0 || isPowerOf2_32(Alignment);
     };
-    Assert(IsValidAlignment(MI->getDestAlignment()),
-           "alignment of arg 0 of memory intrinsic must be 0 or a power of 2",
-           Call);
+    Check(IsValidAlignment(MI->getDestAlignment()),
     if (const auto *MTI = dyn_cast<MemTransferInst>(MI)) {
-      Assert(IsValidAlignment(MTI->getSourceAlignment()),
-             "alignment of arg 1 of memory intrinsic must be 0 or a power of 2",
-             Call);
+      Check(IsValidAlignment(MTI->getSourceAlignment()),
     }
 
     break;
   }
   case Intrinsic::memcpy_element_unordered_atomic:
   case Intrinsic::memmove_element_unordered_atomic:
   case Intrinsic::memset_element_unordered_atomic: {
     const auto *AMI = cast<AtomicMemIntrinsic>(&Call);
 
     ConstantInt *ElementSizeCI =
         cast<ConstantInt>(AMI->getRawElementSizeInBytes());
     const APInt &ElementSizeVal = ElementSizeCI->getValue();
-    Assert(ElementSizeVal.isPowerOf2(),
-           "element size of the element-wise atomic memory intrinsic "
-           "must be a power of 2",
-           Call);
+    Check(ElementSizeVal.isPowerOf2(),
 
     auto IsValidAlignment = [&](uint64_t Alignment) {
       return isPowerOf2_64(Alignment) && ElementSizeVal.ule(Alignment);
     };
     uint64_t DstAlignment = AMI->getDestAlignment();
-    Assert(IsValidAlignment(DstAlignment),
-           "incorrect alignment of the destination argument", Call);
+    Check(IsValidAlignment(DstAlignment),
     if (const auto *AMT = dyn_cast<AtomicMemTransferInst>(AMI)) {
       uint64_t SrcAlignment = AMT->getSourceAlignment();
-      Assert(IsValidAlignment(SrcAlignment),
-             "incorrect alignment of the source argument", Call);
+      Check(IsValidAlignment(SrcAlignment),
     }
     break;
   }
   case Intrinsic::call_preallocated_setup: {
     auto *NumArgs = dyn_cast<ConstantInt>(Call.getArgOperand(0));
-    Assert(NumArgs != nullptr,
-           "llvm.call.preallocated.setup argument must be a constant");
+    Check(NumArgs != nullptr,
     bool FoundCall = false;
     for (User *U : Call.users()) {
       auto *UseCall = dyn_cast<CallBase>(U);
-      Assert(UseCall != nullptr,
-             "Uses of llvm.call.preallocated.setup must be calls");
+      Check(UseCall != nullptr,
       const Function *Fn = UseCall->getCalledFunction();
       if (Fn && Fn->getIntrinsicID() == Intrinsic::call_preallocated_arg) {
         auto *AllocArgIndex = dyn_cast<ConstantInt>(UseCall->getArgOperand(1));
-        Assert(AllocArgIndex != nullptr,
-               "llvm.call.preallocated.alloc arg index must be a constant");
+        Check(AllocArgIndex != nullptr,
         auto AllocArgIndexInt = AllocArgIndex->getValue();
-        Assert(AllocArgIndexInt.sge(0) &&
-                   AllocArgIndexInt.slt(NumArgs->getValue()),
-               "llvm.call.preallocated.alloc arg index must be between 0 and "
-               "corresponding "
-               "llvm.call.preallocated.setup's argument count");
+        Check(AllocArgIndexInt.sge(0) &&
       } else if (Fn && Fn->getIntrinsicID() ==
                            Intrinsic::call_preallocated_teardown) {
         // nothing to do
       } else {
-        Assert(!FoundCall, "Can have at most one call corresponding to a "
-                           "llvm.call.preallocated.setup");
+        Check(!FoundCall, "Can have at most one call corresponding to a "
         FoundCall = true;
         size_t NumPreallocatedArgs = 0;
         for (unsigned i = 0; i < UseCall->arg_size(); i++) {
           if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
             ++NumPreallocatedArgs;
           }
         }
-        Assert(NumPreallocatedArgs != 0,
-               "cannot use preallocated intrinsics on a call without "
-               "preallocated arguments");
-        Assert(NumArgs->equalsInt(NumPreallocatedArgs),
-               "llvm.call.preallocated.setup arg size must be equal to number "
-               "of preallocated arguments "
-               "at call site",
-               Call, *UseCall);
+        Check(NumPreallocatedArgs != 0,
+        Check(NumArgs->equalsInt(NumPreallocatedArgs),
         // getOperandBundle() cannot be called if more than one of the operand
         // bundle exists. There is already a check elsewhere for this, so skip
         // here if we see more than one.
         if (UseCall->countOperandBundlesOfType(LLVMContext::OB_preallocated) >
             1) {
           return;
         }
         auto PreallocatedBundle =
             UseCall->getOperandBundle(LLVMContext::OB_preallocated);
-        Assert(PreallocatedBundle,
-               "Use of llvm.call.preallocated.setup outside intrinsics "
-               "must be in \"preallocated\" operand bundle");
-        Assert(PreallocatedBundle->Inputs.front().get() == &Call,
-               "preallocated bundle must have token from corresponding "
-               "llvm.call.preallocated.setup");
+        Check(PreallocatedBundle,
+        Check(PreallocatedBundle->Inputs.front().get() == &Call,
       }
     }
     break;
   }
   case Intrinsic::call_preallocated_arg: {
     auto *Token = dyn_cast<CallBase>(Call.getArgOperand(0));
-    Assert(Token && Token->getCalledFunction()->getIntrinsicID() ==
-                        Intrinsic::call_preallocated_setup,
-           "llvm.call.preallocated.arg token argument must be a "
-           "llvm.call.preallocated.setup");
-    Assert(Call.hasFnAttr(Attribute::Preallocated),
-           "llvm.call.preallocated.arg must be called with a \"preallocated\" "
-           "call site attribute");
+    Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
+    Check(Call.hasFnAttr(Attribute::Preallocated),
     break;
   }
   case Intrinsic::call_preallocated_teardown: {
     auto *Token = dyn_cast<CallBase>(Call.getArgOperand(0));
-    Assert(Token && Token->getCalledFunction()->getIntrinsicID() ==
-                        Intrinsic::call_preallocated_setup,
-           "llvm.call.preallocated.teardown token argument must be a "
-           "llvm.call.preallocated.setup");
+    Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
     break;
   }
   case Intrinsic::gcroot:
   case Intrinsic::gcwrite:
   case Intrinsic::gcread:
     if (ID == Intrinsic::gcroot) {
       AllocaInst *AI =
           dyn_cast<AllocaInst>(Call.getArgOperand(0)->stripPointerCasts());
-      Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", Call);
-      Assert(isa<Constant>(Call.getArgOperand(1)),
-             "llvm.gcroot parameter #2 must be a constant.", Call);
+      Check(AI, "llvm.gcroot parameter #1 must be an alloca.", Call);
+      Check(isa<Constant>(Call.getArgOperand(1)),
       if (!AI->getAllocatedType()->isPointerTy()) {
-        Assert(!isa<ConstantPointerNull>(Call.getArgOperand(1)),
-               "llvm.gcroot parameter #1 must either be a pointer alloca, "
-               "or argument #2 must be a non-null constant.",
-               Call);
+        Check(!isa<ConstantPointerNull>(Call.getArgOperand(1)),
       }
     }
 
-    Assert(Call.getParent()->getParent()->hasGC(),
-           "Enclosing function does not use GC.", Call);
+    Check(Call.getParent()->getParent()->hasGC(),
     break;
   case Intrinsic::init_trampoline:
-    Assert(isa<Function>(Call.getArgOperand(1)->stripPointerCasts()),
-           "llvm.init_trampoline parameter #2 must resolve to a function.",
-           Call);
+    Check(isa<Function>(Call.getArgOperand(1)->stripPointerCasts()),
     break;
   case Intrinsic::prefetch:
-    Assert(cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue() < 2 &&
+    Check(cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue() < 2 &&
               cast<ConstantInt>(Call.getArgOperand(2))->getZExtValue() < 4,
-           "invalid arguments to llvm.prefetch", Call);
     break;
   case Intrinsic::stackprotector:
-    Assert(isa<AllocaInst>(Call.getArgOperand(1)->stripPointerCasts()),
-           "llvm.stackprotector parameter #2 must resolve to an alloca.", Call);
+    Check(isa<AllocaInst>(Call.getArgOperand(1)->stripPointerCasts()),
     break;
   case Intrinsic::localescape: {
     BasicBlock *BB = Call.getParent();
-    Assert(BB == &BB->getParent()->front(),
-           "llvm.localescape used outside of entry block", Call);
-    Assert(!SawFrameEscape,
-           "multiple calls to llvm.localescape in one function", Call);
+    Check(BB == &BB->getParent()->front(),
+    Check(!SawFrameEscape, "multiple calls to llvm.localescape in one function",
+          Call);
     for (Value *Arg : Call.args()) {
       if (isa<ConstantPointerNull>(Arg))
         continue; // Null values are allowed as placeholders.
       auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
-      Assert(AI && AI->isStaticAlloca(),
-             "llvm.localescape only accepts static allocas", Call);
+      Check(AI && AI->isStaticAlloca(),
     }
     FrameEscapeInfo[BB->getParent()].first = Call.arg_size();
     SawFrameEscape = true;
     break;
   }
   case Intrinsic::localrecover: {
     Value *FnArg = Call.getArgOperand(0)->stripPointerCasts();
     Function *Fn = dyn_cast<Function>(FnArg);
-    Assert(Fn && !Fn->isDeclaration(),
-           "llvm.localrecover first "
-           "argument must be function defined in this module",
-           Call);
+    Check(Fn && !Fn->isDeclaration(),
     auto *IdxArg = cast<ConstantInt>(Call.getArgOperand(2));
     auto &Entry = FrameEscapeInfo[Fn];
     Entry.second = unsigned(
         std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));
     break;
   }
 
   case Intrinsic::experimental_gc_statepoint:
     if (auto *CI = dyn_cast<CallInst>(&Call))
-      Assert(!CI->isInlineAsm(),
-             "gc.statepoint support for inline assembly unimplemented", CI);
-    Assert(Call.getParent()->getParent()->hasGC(),
-           "Enclosing function does not use GC.", Call);
+      Check(!CI->isInlineAsm(),
+    Check(Call.getParent()->getParent()->hasGC(),
 
     verifyStatepoint(Call);
     break;
   case Intrinsic::experimental_gc_result: {
-    Assert(Call.getParent()->getParent()->hasGC(),
-           "Enclosing function does not use GC.", Call);
+    Check(Call.getParent()->getParent()->hasGC(),
     // Are we tied to a statepoint properly?
     const auto *StatepointCall = dyn_cast<CallBase>(Call.getArgOperand(0));
     const Function *StatepointFn =
         StatepointCall ? StatepointCall->getCalledFunction() : nullptr;
-    Assert(StatepointFn && StatepointFn->isDeclaration() &&
-               StatepointFn->getIntrinsicID() ==
-                   Intrinsic::experimental_gc_statepoint,
-           "gc.result operand #1 must be from a statepoint", Call,
-           Call.getArgOperand(0));
+    Check(StatepointFn && StatepointFn->isDeclaration() &&
 
-    // Assert that result type matches wrapped callee.
+    // Check that result type matches wrapped callee.
     auto *TargetFuncType =
         cast<FunctionType>(StatepointCall->getParamElementType(2));
-    Assert(Call.getType() == TargetFuncType->getReturnType(),
-           "gc.result result type does not match wrapped callee", Call);
+    Check(Call.getType() == TargetFuncType->getReturnType(),
     break;
   }
   case Intrinsic::experimental_gc_relocate: {
-    Assert(Call.arg_size() == 3, "wrong number of arguments", Call);
+    Check(Call.arg_size() == 3, "wrong number of arguments", Call);
 
-    Assert(isa<PointerType>(Call.getType()->getScalarType()),
-           "gc.relocate must return a pointer or a vector of pointers", Call);
+    Check(isa<PointerType>(Call.getType()->getScalarType()),
 
     // Check that this relocate is correctly tied to the statepoint
 
     // This is case for relocate on the unwinding path of an invoke statepoint
     if (LandingPadInst *LandingPad =
             dyn_cast<LandingPadInst>(Call.getArgOperand(0))) {
 
       const BasicBlock *InvokeBB =
           LandingPad->getParent()->getUniquePredecessor();
 
       // Landingpad relocates should have only one predecessor with invoke
       // statepoint terminator
-      Assert(InvokeBB, "safepoints should have unique landingpads",
-             LandingPad->getParent());
-      Assert(InvokeBB->getTerminator(), "safepoint block should be well formed",
-             InvokeBB);
-      Assert(isa<GCStatepointInst>(InvokeBB->getTerminator()),
-             "gc relocate should be linked to a statepoint", InvokeBB);
+      Check(InvokeBB, "safepoints should have unique landingpads",
+      Check(InvokeBB->getTerminator(), "safepoint block should be well formed",
+      Check(isa<GCStatepointInst>(InvokeBB->getTerminator()),
     } 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);
-      Assert(isa<GCStatepointInst>(Token),
-             "gc relocate is incorrectly tied to the statepoint", Call, Token);
+      Check(isa<GCStatepointInst>(Token),
     }
 
     // Verify rest of the relocate arguments.
     const CallBase &StatepointCall =
       *cast<GCRelocateInst>(Call).getStatepoint();
 
     // Both the base and derived must be piped through the safepoint.
     Value *Base = Call.getArgOperand(1);
-    Assert(isa<ConstantInt>(Base),
-           "gc.relocate operand #2 must be integer offset", Call);
+    Check(isa<ConstantInt>(Base),
 
     Value *Derived = Call.getArgOperand(2);
-    Assert(isa<ConstantInt>(Derived),
-           "gc.relocate operand #3 must be integer offset", Call);
+    Check(isa<ConstantInt>(Derived),
 
     const uint64_t BaseIndex = cast<ConstantInt>(Base)->getZExtValue();
     const uint64_t DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
 
     // Check the bounds
     if (auto Opt = StatepointCall.getOperandBundle(LLVMContext::OB_gc_live)) {
-      Assert(BaseIndex < Opt->Inputs.size(),
-             "gc.relocate: statepoint base index out of bounds", Call);
-      Assert(DerivedIndex < Opt->Inputs.size(),
-             "gc.relocate: statepoint derived index out of bounds", Call);
+      Check(BaseIndex < Opt->Inputs.size(),
+      Check(DerivedIndex < Opt->Inputs.size(),
     }
 
     // Relocated value must be either a pointer type or vector-of-pointer type,
     // but gc_relocate does not need to return the same pointer type as the
     // relocated pointer. It can be casted to the correct type later if it's
     // desired. However, they must have the same address space and 'vectorness'
     GCRelocateInst &Relocate = cast<GCRelocateInst>(Call);
-    Assert(Relocate.getDerivedPtr()->getType()->isPtrOrPtrVectorTy(),
-           "gc.relocate: relocated value must be a gc pointer", Call);
+    Check(Relocate.getDerivedPtr()->getType()->isPtrOrPtrVectorTy(),
 
     auto ResultType = Call.getType();
     auto DerivedType = Relocate.getDerivedPtr()->getType();
-    Assert(ResultType->isVectorTy() == DerivedType->isVectorTy(),
-           "gc.relocate: vector relocates to vector and pointer to pointer",
-           Call);
-    Assert(
+    Check(ResultType->isVectorTy() == DerivedType->isVectorTy(),
+    Check(
         ResultType->getPointerAddressSpace() ==
             DerivedType->getPointerAddressSpace(),
         "gc.relocate: relocating a pointer shouldn't change its address space",
         Call);
     break;
   }
   case Intrinsic::eh_exceptioncode:
   case Intrinsic::eh_exceptionpointer: {
-    Assert(isa<CatchPadInst>(Call.getArgOperand(0)),
-           "eh.exceptionpointer argument must be a catchpad", Call);
+    Check(isa<CatchPadInst>(Call.getArgOperand(0)),
     break;
   }
   case Intrinsic::get_active_lane_mask: {
-    Assert(Call.getType()->isVectorTy(), "get_active_lane_mask: must return a "
-           "vector", Call);
+    Check(Call.getType()->isVectorTy(),
+          "get_active_lane_mask: must return a "
+          "vector",
+          Call);
     auto *ElemTy = Call.getType()->getScalarType();
-    Assert(ElemTy->isIntegerTy(1), "get_active_lane_mask: element type is not "
-           "i1", Call);
+    Check(ElemTy->isIntegerTy(1),
+          "get_active_lane_mask: element type is not "
+          "i1",
+          Call);
     break;
   }
   case Intrinsic::masked_load: {
-    Assert(Call.getType()->isVectorTy(), "masked_load: must return a vector",
-           Call);
+    Check(Call.getType()->isVectorTy(), "masked_load: must return a vector",
 
     Value *Ptr = Call.getArgOperand(0);
     ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(1));
     Value *Mask = Call.getArgOperand(2);
     Value *PassThru = Call.getArgOperand(3);
-    Assert(Mask->getType()->isVectorTy(), "masked_load: mask must be vector",
-           Call);
-    Assert(Alignment->getValue().isPowerOf2(),
-           "masked_load: alignment must be a power of 2", Call);
+    Check(Mask->getType()->isVectorTy(), "masked_load: mask must be vector",
+    Check(Alignment->getValue().isPowerOf2(),
 
     PointerType *PtrTy = cast<PointerType>(Ptr->getType());
-    Assert(PtrTy->isOpaqueOrPointeeTypeMatches(Call.getType()),
-           "masked_load: return must match pointer type", Call);
-    Assert(PassThru->getType() == Call.getType(),
-           "masked_load: pass through and return type must match", Call);
-    Assert(cast<VectorType>(Mask->getType())->getElementCount() ==
-               cast<VectorType>(Call.getType())->getElementCount(),
-           "masked_load: vector mask must be same length as return", Call);
+    Check(PtrTy->isOpaqueOrPointeeTypeMatches(Call.getType()),
+    Check(PassThru->getType() == Call.getType(),
+    Check(cast<VectorType>(Mask->getType())->getElementCount() ==
     break;
   }
   case Intrinsic::masked_store: {
     Value *Val = Call.getArgOperand(0);
     Value *Ptr = Call.getArgOperand(1);
     ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(2));
     Value *Mask = Call.getArgOperand(3);
-    Assert(Mask->getType()->isVectorTy(), "masked_store: mask must be vector",
-           Call);
-    Assert(Alignment->getValue().isPowerOf2(),
-           "masked_store: alignment must be a power of 2", Call);
+    Check(Mask->getType()->isVectorTy(), "masked_store: mask must be vector",
+    Check(Alignment->getValue().isPowerOf2(),
 
     PointerType *PtrTy = cast<PointerType>(Ptr->getType());
-    Assert(PtrTy->isOpaqueOrPointeeTypeMatches(Val->getType()),
-           "masked_store: storee must match pointer type", Call);
-    Assert(cast<VectorType>(Mask->getType())->getElementCount() ==
-               cast<VectorType>(Val->getType())->getElementCount(),
-           "masked_store: vector mask must be same length as value", Call);
+    Check(PtrTy->isOpaqueOrPointeeTypeMatches(Val->getType()),
+    Check(cast<VectorType>(Mask->getType())->getElementCount() ==
     break;
   }
 
   case Intrinsic::masked_gather: {
     const APInt &Alignment =
         cast<ConstantInt>(Call.getArgOperand(1))->getValue();
-    Assert(Alignment.isZero() || Alignment.isPowerOf2(),
-           "masked_gather: alignment must be 0 or a power of 2", Call);
+    Check(Alignment.isZero() || Alignment.isPowerOf2(),
     break;
   }
   case Intrinsic::masked_scatter: {
     const APInt &Alignment =
         cast<ConstantInt>(Call.getArgOperand(2))->getValue();
-    Assert(Alignment.isZero() || Alignment.isPowerOf2(),
-           "masked_scatter: alignment must be 0 or a power of 2", Call);
+    Check(Alignment.isZero() || Alignment.isPowerOf2(),
     break;
   }
 
   case Intrinsic::experimental_guard: {
-    Assert(isa<CallInst>(Call), "experimental_guard cannot be invoked", Call);
-    Assert(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
-           "experimental_guard must have exactly one "
-           "\"deopt\" operand bundle");
+    Check(isa<CallInst>(Call), "experimental_guard cannot be invoked", Call);
+    Check(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
     break;
   }
 
   case Intrinsic::experimental_deoptimize: {
-    Assert(isa<CallInst>(Call), "experimental_deoptimize cannot be invoked",
-           Call);
-    Assert(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
-           "experimental_deoptimize must have exactly one "
-           "\"deopt\" operand bundle");
-    Assert(Call.getType() == Call.getFunction()->getReturnType(),
-           "experimental_deoptimize return type must match caller return type");
+    Check(isa<CallInst>(Call), "experimental_deoptimize cannot be invoked",
+    Check(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
+    Check(Call.getType() == Call.getFunction()->getReturnType(),
 
     if (isa<CallInst>(Call)) {
       auto *RI = dyn_cast<ReturnInst>(Call.getNextNode());
-      Assert(RI,
-             "calls to experimental_deoptimize must be followed by a return");
+      Check(RI,
 
       if (!Call.getType()->isVoidTy() && RI)
-        Assert(RI->getReturnValue() == &Call,
-               "calls to experimental_deoptimize must be followed by a return "
-               "of the value computed by experimental_deoptimize");
+        Check(RI->getReturnValue() == &Call,
     }
 
     break;
   }
   case Intrinsic::vector_reduce_and:
   case Intrinsic::vector_reduce_or:
   case Intrinsic::vector_reduce_xor:
   case Intrinsic::vector_reduce_add:
   case Intrinsic::vector_reduce_mul:
   case Intrinsic::vector_reduce_smax:
   case Intrinsic::vector_reduce_smin:
   case Intrinsic::vector_reduce_umax:
   case Intrinsic::vector_reduce_umin: {
     Type *ArgTy = Call.getArgOperand(0)->getType();
-    Assert(ArgTy->isIntOrIntVectorTy() && ArgTy->isVectorTy(),
-           "Intrinsic has incorrect argument type!");
+    Check(ArgTy->isIntOrIntVectorTy() && ArgTy->isVectorTy(),
     break;
   }
   case Intrinsic::vector_reduce_fmax:
   case Intrinsic::vector_reduce_fmin: {
     Type *ArgTy = Call.getArgOperand(0)->getType();
-    Assert(ArgTy->isFPOrFPVectorTy() && ArgTy->isVectorTy(),
-           "Intrinsic has incorrect argument type!");
+    Check(ArgTy->isFPOrFPVectorTy() && ArgTy->isVectorTy(),
     break;
   }
   case Intrinsic::vector_reduce_fadd:
   case Intrinsic::vector_reduce_fmul: {
     // Unlike the other reductions, the first argument is a start value. The
     // second argument is the vector to be reduced.
     Type *ArgTy = Call.getArgOperand(1)->getType();
-    Assert(ArgTy->isFPOrFPVectorTy() && ArgTy->isVectorTy(),
-           "Intrinsic has incorrect argument type!");
+    Check(ArgTy->isFPOrFPVectorTy() && ArgTy->isVectorTy(),
     break;
   }
   case Intrinsic::smul_fix:
   case Intrinsic::smul_fix_sat:
   case Intrinsic::umul_fix:
   case Intrinsic::umul_fix_sat:
   case Intrinsic::sdiv_fix:
   case Intrinsic::sdiv_fix_sat:
   case Intrinsic::udiv_fix:
   case Intrinsic::udiv_fix_sat: {
     Value *Op1 = Call.getArgOperand(0);
     Value *Op2 = Call.getArgOperand(1);
-    Assert(Op1->getType()->isIntOrIntVectorTy(),
-           "first operand of [us][mul|div]_fix[_sat] must be an int type or "
-           "vector of ints");
-    Assert(Op2->getType()->isIntOrIntVectorTy(),
-           "second operand of [us][mul|div]_fix[_sat] must be an int type or "
-           "vector of ints");
+    Check(Op1->getType()->isIntOrIntVectorTy(),
+    Check(Op2->getType()->isIntOrIntVectorTy(),
 
     auto *Op3 = cast<ConstantInt>(Call.getArgOperand(2));
-    Assert(Op3->getType()->getBitWidth() <= 32,
-           "third argument of [us][mul|div]_fix[_sat] must fit within 32 bits");
+    Check(Op3->getType()->getBitWidth() <= 32,
 
     if (ID == Intrinsic::smul_fix || ID == Intrinsic::smul_fix_sat ||
         ID == Intrinsic::sdiv_fix || ID == Intrinsic::sdiv_fix_sat) {
-      Assert(
-          Op3->getZExtValue() < Op1->getType()->getScalarSizeInBits(),
+      Check(Op3->getZExtValue() < Op1->getType()->getScalarSizeInBits(),
             "the scale of s[mul|div]_fix[_sat] must be less than the width of "
             "the operands");
     } else {
-      Assert(Op3->getZExtValue() <= Op1->getType()->getScalarSizeInBits(),
-             "the scale of u[mul|div]_fix[_sat] must be less than or equal "
-             "to the width of the operands");
+      Check(Op3->getZExtValue() <= Op1->getType()->getScalarSizeInBits(),
     }
     break;
   }
   case Intrinsic::lround:
   case Intrinsic::llround:
   case Intrinsic::lrint:
   case Intrinsic::llrint: {
     Type *ValTy = Call.getArgOperand(0)->getType();
     Type *ResultTy = Call.getType();
-    Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
-           "Intrinsic does not support vectors", &Call);
+    Check(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
     break;
   }
   case Intrinsic::bswap: {
     Type *Ty = Call.getType();
     unsigned Size = Ty->getScalarSizeInBits();
-    Assert(Size % 16 == 0, "bswap must be an even number of bytes", &Call);
+    Check(Size % 16 == 0, "bswap must be an even number of bytes", &Call);
     break;
   }
   case Intrinsic::invariant_start: {
     ConstantInt *InvariantSize = dyn_cast<ConstantInt>(Call.getArgOperand(0));
-    Assert(InvariantSize &&
-               (!InvariantSize->isNegative() || InvariantSize->isMinusOne()),
-           "invariant_start parameter must be -1, 0 or a positive number",
-           &Call);
+    Check(InvariantSize &&
     break;
   }
   case Intrinsic::matrix_multiply:
   case Intrinsic::matrix_transpose:
   case Intrinsic::matrix_column_major_load:
   case Intrinsic::matrix_column_major_store: {
     Function *IF = Call.getCalledFunction();
     ConstantInt *Stride = nullptr;
case Intrinsic::matrix_column_major_store: {
       if (!Op1PtrTy->isOpaque())
         Op1ElemTy = Op1PtrTy->getNonOpaquePointerElementType();
       break;
     }
     default:
       llvm_unreachable("unexpected intrinsic");
     }
 
-    Assert(ResultTy->getElementType()->isIntegerTy() ||
+    Check(ResultTy->getElementType()->isIntegerTy() ||
               ResultTy->getElementType()->isFloatingPointTy(),
-           "Result type must be an integer or floating-point type!", IF);
 
     if (Op0ElemTy)
-      Assert(ResultTy->getElementType() == Op0ElemTy,
-             "Vector element type mismatch of the result and first operand "
-             "vector!", IF);
+      Check(ResultTy->getElementType() == Op0ElemTy,
+            "vector!",
+            IF);
 
     if (Op1ElemTy)
-      Assert(ResultTy->getElementType() == Op1ElemTy,
-             "Vector element type mismatch of the result and second operand "
-             "vector!", IF);
+      Check(ResultTy->getElementType() == Op1ElemTy,
+            "vector!",
+            IF);
 
-    Assert(cast<FixedVectorType>(ResultTy)->getNumElements() ==
-               NumRows->getZExtValue() * NumColumns->getZExtValue(),
-           "Result of a matrix operation does not fit in the returned vector!");
+    Check(cast<FixedVectorType>(ResultTy)->getNumElements() ==
 
     if (Stride)
-      Assert(Stride->getZExtValue() >= NumRows->getZExtValue(),
-             "Stride must be greater or equal than the number of rows!", IF);
+      Check(Stride->getZExtValue() >= NumRows->getZExtValue(),
 
     break;
   }
   case Intrinsic::experimental_vector_splice: {
     VectorType *VecTy = cast<VectorType>(Call.getType());
     int64_t Idx = cast<ConstantInt>(Call.getArgOperand(2))->getSExtValue();
     int64_t KnownMinNumElements = VecTy->getElementCount().getKnownMinValue();
     if (Call.getParent() && Call.getParent()->getParent()) {
       AttributeList Attrs = Call.getParent()->getParent()->getAttributes();
       if (Attrs.hasFnAttr(Attribute::VScaleRange))
         KnownMinNumElements *= Attrs.getFnAttrs().getVScaleRangeMin();
     }
-    Assert((Idx < 0 && std::abs(Idx) <= KnownMinNumElements) ||
-               (Idx >= 0 && Idx < KnownMinNumElements),
-           "The splice index exceeds the range [-VL, VL-1] where VL is the "
-           "known minimum number of elements in the vector. For scalable "
-           "vectors the minimum number of elements is determined from "
-           "vscale_range.",
-           &Call);
+    Check((Idx < 0 && std::abs(Idx) <= KnownMinNumElements) ||
     break;
   }
   case Intrinsic::experimental_stepvector: {
     VectorType *VecTy = dyn_cast<VectorType>(Call.getType());
-    Assert(VecTy && VecTy->getScalarType()->isIntegerTy() &&
-               VecTy->getScalarSizeInBits() >= 8,
-           "experimental_stepvector only supported for vectors of integers "
-           "with a bitwidth of at least 8.",
-           &Call);
+    Check(VecTy && VecTy->getScalarType()->isIntegerTy() &&
     break;
   }
   case Intrinsic::experimental_vector_insert: {
     Value *Vec = Call.getArgOperand(0);
     Value *SubVec = Call.getArgOperand(1);
     Value *Idx = Call.getArgOperand(2);
     unsigned IdxN = cast<ConstantInt>(Idx)->getZExtValue();
 
     VectorType *VecTy = cast<VectorType>(Vec->getType());
     VectorType *SubVecTy = cast<VectorType>(SubVec->getType());
 
     ElementCount VecEC = VecTy->getElementCount();
     ElementCount SubVecEC = SubVecTy->getElementCount();
-    Assert(VecTy->getElementType() == SubVecTy->getElementType(),
-           "experimental_vector_insert parameters must have the same element "
-           "type.",
-           &Call);
-    Assert(IdxN % SubVecEC.getKnownMinValue() == 0,
-           "experimental_vector_insert index must be a constant multiple of "
-           "the subvector's known minimum vector length.");
+    Check(VecTy->getElementType() == SubVecTy->getElementType(),
+    Check(IdxN % SubVecEC.getKnownMinValue() == 0,
 
     // If this insertion is not the 'mixed' case where a fixed vector is
     // inserted into a scalable vector, ensure that the insertion of the
     // subvector does not overrun the parent vector.
     if (VecEC.isScalable() == SubVecEC.isScalable()) {
-      Assert(
-          IdxN < VecEC.getKnownMinValue() &&
+      Check(IdxN < VecEC.getKnownMinValue() &&
                 IdxN + SubVecEC.getKnownMinValue() <= VecEC.getKnownMinValue(),
             "subvector operand of experimental_vector_insert would overrun the "
             "vector being inserted into.");
     }
     break;
   }
   case Intrinsic::experimental_vector_extract: {
     Value *Vec = Call.getArgOperand(0);
     Value *Idx = Call.getArgOperand(1);
     unsigned IdxN = cast<ConstantInt>(Idx)->getZExtValue();
 
     VectorType *ResultTy = cast<VectorType>(Call.getType());
     VectorType *VecTy = cast<VectorType>(Vec->getType());
 
     ElementCount VecEC = VecTy->getElementCount();
     ElementCount ResultEC = ResultTy->getElementCount();
 
-    Assert(ResultTy->getElementType() == VecTy->getElementType(),
-           "experimental_vector_extract result must have the same element "
-           "type as the input vector.",
-           &Call);
-    Assert(IdxN % ResultEC.getKnownMinValue() == 0,
-           "experimental_vector_extract index must be a constant multiple of "
-           "the result type's known minimum vector length.");
+    Check(ResultTy->getElementType() == VecTy->getElementType(),
+    Check(IdxN % ResultEC.getKnownMinValue() == 0,
 
     // If this extraction is not the 'mixed' case where a fixed vector is is
     // extracted from a scalable vector, ensure that the extraction does not
     // overrun the parent vector.
     if (VecEC.isScalable() == ResultEC.isScalable()) {
-      Assert(IdxN < VecEC.getKnownMinValue() &&
-                 IdxN + ResultEC.getKnownMinValue() <= VecEC.getKnownMinValue(),
-             "experimental_vector_extract would overrun.");
+      Check(IdxN < VecEC.getKnownMinValue() &&
     }
     break;
   }
   case Intrinsic::experimental_noalias_scope_decl: {
     NoAliasScopeDecls.push_back(cast<IntrinsicInst>(&Call));
     break;
   }
   case Intrinsic::preserve_array_access_index:
   case Intrinsic::preserve_struct_access_index:
   case Intrinsic::aarch64_ldaxr:
   case Intrinsic::aarch64_ldxr:
   case Intrinsic::arm_ldaex:
   case Intrinsic::arm_ldrex: {
     Type *ElemTy = Call.getParamElementType(0);
-    Assert(ElemTy,
-           "Intrinsic requires elementtype attribute on first argument.",
-           &Call);
+    Check(ElemTy, "Intrinsic requires elementtype attribute on first argument.",
     break;
   }
   case Intrinsic::aarch64_stlxr:
   case Intrinsic::aarch64_stxr:
   case Intrinsic::arm_stlex:
   case Intrinsic::arm_strex: {
     Type *ElemTy = Call.getAttributes().getParamElementType(1);
-    Assert(ElemTy,
-           "Intrinsic requires elementtype attribute on second argument.",
-           &Call);
+    Check(ElemTy,
     break;
   }
   };
 }
 
 /// Carefully grab the subprogram from a local scope.
 ///
 /// This carefully grabs the subprogram from a local scope, avoiding the
static DISubprogram *getSubprogram(Metadata *LocalScope) {
   assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope");
   return nullptr;
 }
 
 void Verifier::visitVPIntrinsic(VPIntrinsic &VPI) {
   if (auto *VPCast = dyn_cast<VPCastIntrinsic>(&VPI)) {
     auto *RetTy = cast<VectorType>(VPCast->getType());
     auto *ValTy = cast<VectorType>(VPCast->getOperand(0)->getType());
-    Assert(RetTy->getElementCount() == ValTy->getElementCount(),
-           "VP cast intrinsic first argument and result vector lengths must be "
-           "equal",
-           *VPCast);
+    Check(RetTy->getElementCount() == ValTy->getElementCount(),
   }
 }
 
 void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) {
   unsigned NumOperands;
   bool HasRoundingMD;
   switch (FPI.getIntrinsicID()) {
 #define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC)                         \
   case Intrinsic::INTRINSIC:                                                   \
     NumOperands = NARG;                                                        \
     HasRoundingMD = ROUND_MODE;                                                \
     break;
 #include "llvm/IR/ConstrainedOps.def"
   default:
     llvm_unreachable("Invalid constrained FP intrinsic!");
   }
   NumOperands += (1 + HasRoundingMD);
   // Compare intrinsics carry an extra predicate metadata operand.
   if (isa<ConstrainedFPCmpIntrinsic>(FPI))
     NumOperands += 1;
-  Assert((FPI.arg_size() == NumOperands),
-         "invalid arguments for constrained FP intrinsic", &FPI);
+  Check((FPI.arg_size() == NumOperands),
 
   switch (FPI.getIntrinsicID()) {
   case Intrinsic::experimental_constrained_lrint:
   case Intrinsic::experimental_constrained_llrint: {
     Type *ValTy = FPI.getArgOperand(0)->getType();
     Type *ResultTy = FPI.getType();
-    Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
-           "Intrinsic does not support vectors", &FPI);
+    Check(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
   }
     break;
 
   case Intrinsic::experimental_constrained_lround:
   case Intrinsic::experimental_constrained_llround: {
     Type *ValTy = FPI.getArgOperand(0)->getType();
     Type *ResultTy = FPI.getType();
-    Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
-           "Intrinsic does not support vectors", &FPI);
+    Check(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
     break;
   }
 
   case Intrinsic::experimental_constrained_fcmp:
   case Intrinsic::experimental_constrained_fcmps: {
     auto Pred = cast<ConstrainedFPCmpIntrinsic>(&FPI)->getPredicate();
-    Assert(CmpInst::isFPPredicate(Pred),
-           "invalid predicate for constrained FP comparison intrinsic", &FPI);
+    Check(CmpInst::isFPPredicate(Pred),
     break;
   }
 
   case Intrinsic::experimental_constrained_fptosi:
   case Intrinsic::experimental_constrained_fptoui: {
     Value *Operand = FPI.getArgOperand(0);
     uint64_t NumSrcElem = 0;
-    Assert(Operand->getType()->isFPOrFPVectorTy(),
-           "Intrinsic first argument must be floating point", &FPI);
+    Check(Operand->getType()->isFPOrFPVectorTy(),
     if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) {
       NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements();
     }
 
     Operand = &FPI;
-    Assert((NumSrcElem > 0) == Operand->getType()->isVectorTy(),
-           "Intrinsic first argument and result disagree on vector use", &FPI);
-    Assert(Operand->getType()->isIntOrIntVectorTy(),
-           "Intrinsic result must be an integer", &FPI);
+    Check((NumSrcElem > 0) == Operand->getType()->isVectorTy(),
+    Check(Operand->getType()->isIntOrIntVectorTy(),
     if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) {
-      Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(),
-             "Intrinsic first argument and result vector lengths must be equal",
-             &FPI);
+      Check(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(),
     }
   }
     break;
 
   case Intrinsic::experimental_constrained_sitofp:
   case Intrinsic::experimental_constrained_uitofp: {
     Value *Operand = FPI.getArgOperand(0);
     uint64_t NumSrcElem = 0;
-    Assert(Operand->getType()->isIntOrIntVectorTy(),
-           "Intrinsic first argument must be integer", &FPI);
+    Check(Operand->getType()->isIntOrIntVectorTy(),
     if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) {
       NumSrcElem = cast<FixedVectorType>(OperandT)->getNumElements();
     }
 
     Operand = &FPI;
-    Assert((NumSrcElem > 0) == Operand->getType()->isVectorTy(),
-           "Intrinsic first argument and result disagree on vector use", &FPI);
-    Assert(Operand->getType()->isFPOrFPVectorTy(),
-           "Intrinsic result must be a floating point", &FPI);
+    Check((NumSrcElem > 0) == Operand->getType()->isVectorTy(),
+    Check(Operand->getType()->isFPOrFPVectorTy(),
     if (auto *OperandT = dyn_cast<VectorType>(Operand->getType())) {
-      Assert(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(),
-             "Intrinsic first argument and result vector lengths must be equal",
-             &FPI);
+      Check(NumSrcElem == cast<FixedVectorType>(OperandT)->getNumElements(),
     }
   } break;
 
   case Intrinsic::experimental_constrained_fptrunc:
   case Intrinsic::experimental_constrained_fpext: {
     Value *Operand = FPI.getArgOperand(0);
     Type *OperandTy = Operand->getType();
     Value *Result = &FPI;
     Type *ResultTy = Result->getType();
-    Assert(OperandTy->isFPOrFPVectorTy(),
-           "Intrinsic first argument must be FP or FP vector", &FPI);
-    Assert(ResultTy->isFPOrFPVectorTy(),
-           "Intrinsic result must be FP or FP vector", &FPI);
-    Assert(OperandTy->isVectorTy() == ResultTy->isVectorTy(),
-           "Intrinsic first argument and result disagree on vector use", &FPI);
+    Check(OperandTy->isFPOrFPVectorTy(),
+    Check(ResultTy->isFPOrFPVectorTy(),
+    Check(OperandTy->isVectorTy() == ResultTy->isVectorTy(),
     if (OperandTy->isVectorTy()) {
-      Assert(cast<FixedVectorType>(OperandTy)->getNumElements() ==
-                 cast<FixedVectorType>(ResultTy)->getNumElements(),
-             "Intrinsic first argument and result vector lengths must be equal",
-             &FPI);
+      Check(cast<FixedVectorType>(OperandTy)->getNumElements() ==
     }
     if (FPI.getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
-      Assert(OperandTy->getScalarSizeInBits() > ResultTy->getScalarSizeInBits(),
-             "Intrinsic first argument's type must be larger than result type",
-             &FPI);
+      Check(OperandTy->getScalarSizeInBits() > ResultTy->getScalarSizeInBits(),
     } else {
-      Assert(OperandTy->getScalarSizeInBits() < ResultTy->getScalarSizeInBits(),
-             "Intrinsic first argument's type must be smaller than result type",
-             &FPI);
+      Check(OperandTy->getScalarSizeInBits() < ResultTy->getScalarSizeInBits(),
     }
   }
     break;
 
   default:
     break;
   }
 
   // If a non-metadata argument is passed in a metadata slot then the
   // error will be caught earlier when the incorrect argument doesn't
   // match the specification in the intrinsic call table. Thus, no
   // argument type check is needed here.
 
-  Assert(FPI.getExceptionBehavior().hasValue(),
-         "invalid exception behavior argument", &FPI);
+  Check(FPI.getExceptionBehavior().hasValue(),
   if (HasRoundingMD) {
-    Assert(FPI.getRoundingMode().hasValue(),
-           "invalid rounding mode argument", &FPI);
+    Check(FPI.getRoundingMode().hasValue(), "invalid rounding mode argument",
+          &FPI);
   }
 }
 
 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
   auto *MD = DII.getRawLocation();
-  AssertDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
-               (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
-           "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
-  AssertDI(isa<DILocalVariable>(DII.getRawVariable()),
+  CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
+  CheckDI(isa<DILocalVariable>(DII.getRawVariable()),
           "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
           DII.getRawVariable());
-  AssertDI(isa<DIExpression>(DII.getRawExpression()),
+  CheckDI(isa<DIExpression>(DII.getRawExpression()),
           "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
           DII.getRawExpression());
 
   // Ignore broken !dbg attachments; they're checked elsewhere.
   if (MDNode *N = DII.getDebugLoc().getAsMDNode())
     if (!isa<DILocation>(N))
       return;
 
   BasicBlock *BB = DII.getParent();
   Function *F = BB ? BB->getParent() : nullptr;
 
   // The scopes for variables and !dbg attachments must agree.
   DILocalVariable *Var = DII.getVariable();
   DILocation *Loc = DII.getDebugLoc();
-  AssertDI(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment",
-           &DII, BB, F);
+  CheckDI(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment",
 
   DISubprogram *VarSP = getSubprogram(Var->getRawScope());
   DISubprogram *LocSP = getSubprogram(Loc->getRawScope());
   if (!VarSP || !LocSP)
     return; // Broken scope chains are checked elsewhere.
 
-  AssertDI(VarSP == LocSP, "mismatched subprogram between llvm.dbg." + Kind +
-                               " variable and !dbg attachment",
-           &DII, BB, F, Var, Var->getScope()->getSubprogram(), Loc,
-           Loc->getScope()->getSubprogram());
+  CheckDI(VarSP == LocSP,
+          "mismatched subprogram between llvm.dbg." + Kind +
 
   // This check is redundant with one in visitLocalVariable().
-  AssertDI(isType(Var->getRawType()), "invalid type ref", Var,
-           Var->getRawType());
+  CheckDI(isType(Var->getRawType()), "invalid type ref", Var,
   verifyFnArgs(DII);
 }
 
 void Verifier::visitDbgLabelIntrinsic(StringRef Kind, DbgLabelInst &DLI) {
-  AssertDI(isa<DILabel>(DLI.getRawLabel()),
+  CheckDI(isa<DILabel>(DLI.getRawLabel()),
           "invalid llvm.dbg." + Kind + " intrinsic variable", &DLI,
           DLI.getRawLabel());
 
   // Ignore broken !dbg attachments; they're checked elsewhere.
   if (MDNode *N = DLI.getDebugLoc().getAsMDNode())
     if (!isa<DILocation>(N))
       return;
 
   BasicBlock *BB = DLI.getParent();
   Function *F = BB ? BB->getParent() : nullptr;
 
   // The scopes for variables and !dbg attachments must agree.
   DILabel *Label = DLI.getLabel();
   DILocation *Loc = DLI.getDebugLoc();
-  Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment",
-         &DLI, BB, F);
+  Check(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment", &DLI,
+        BB, F);
 
   DISubprogram *LabelSP = getSubprogram(Label->getRawScope());
   DISubprogram *LocSP = getSubprogram(Loc->getRawScope());
   if (!LabelSP || !LocSP)
     return;
 
-  AssertDI(LabelSP == LocSP, "mismatched subprogram between llvm.dbg." + Kind +
-                             " label and !dbg attachment",
-           &DLI, BB, F, Label, Label->getScope()->getSubprogram(), Loc,
-           Loc->getScope()->getSubprogram());
+  CheckDI(LabelSP == LocSP,
+          "mismatched subprogram between llvm.dbg." + Kind +
 }
 
 void Verifier::verifyFragmentExpression(const DbgVariableIntrinsic &I) {
   DILocalVariable *V = dyn_cast_or_null<DILocalVariable>(I.getRawVariable());
   DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression());
 
   // We don't know whether this intrinsic verified correctly.
   if (!V || !E || !E->isValid())
void Verifier::verifyFragmentExpression(const DIVariable &V,
   // If there's no size, the type is broken, but that should be checked
   // elsewhere.
   auto VarSize = V.getSizeInBits();
   if (!VarSize)
     return;
 
   unsigned FragSize = Fragment.SizeInBits;
   unsigned FragOffset = Fragment.OffsetInBits;
-  AssertDI(FragSize + FragOffset <= *VarSize,
+  CheckDI(FragSize + FragOffset <= *VarSize,
           "fragment is larger than or outside of variable", Desc, &V);
-  AssertDI(FragSize != *VarSize, "fragment covers entire variable", Desc, &V);
+  CheckDI(FragSize != *VarSize, "fragment covers entire variable", Desc, &V);
 }
 
 void Verifier::verifyFnArgs(const DbgVariableIntrinsic &I) {
   // This function does not take the scope of noninlined function arguments into
   // account. Don't run it if current function is nodebug, because it may
   // contain inlined debug intrinsics.
   if (!HasDebugInfo)
     return;
 
   // For performance reasons only check non-inlined ones.
   if (I.getDebugLoc()->getInlinedAt())
     return;
 
   DILocalVariable *Var = I.getVariable();
-  AssertDI(Var, "dbg intrinsic without variable");
+  CheckDI(Var, "dbg intrinsic without variable");
 
   unsigned ArgNo = Var->getArg();
   if (!ArgNo)
     return;
 
   // Verify there are no duplicate function argument debug info entries.
   // These will cause hard-to-debug assertions in the DWARF backend.
   if (DebugFnArgs.size() < ArgNo)
     DebugFnArgs.resize(ArgNo, nullptr);
 
   auto *Prev = DebugFnArgs[ArgNo - 1];
   DebugFnArgs[ArgNo - 1] = Var;
-  AssertDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I,
-           Prev, Var);
+  CheckDI(!Prev || (Prev == Var), "conflicting debug info for argument", &I,
 }
 
 void Verifier::verifyNotEntryValue(const DbgVariableIntrinsic &I) {
   DIExpression *E = dyn_cast_or_null<DIExpression>(I.getRawExpression());
 
   // We don't know whether this intrinsic verified correctly.
   if (!E || !E->isValid())
     return;
 
-  AssertDI(!E->isEntryValue(), "Entry values are only allowed in MIR", &I);
+  CheckDI(!E->isEntryValue(), "Entry values are only allowed in MIR", &I);
 }
 
 void Verifier::verifyCompileUnits() {
   // When more than one Module is imported into the same context, such as during
   // an LTO build before linking the modules, ODR type uniquing may cause types
   // to point to a different CU. This check does not make sense in this case.
   if (M.getContext().isODRUniquingDebugTypes())
     return;
   auto *CUs = M.getNamedMetadata("llvm.dbg.cu");
   SmallPtrSet<const Metadata *, 2> Listed;
   if (CUs)
     Listed.insert(CUs->op_begin(), CUs->op_end());
   for (auto *CU : CUVisited)
-    AssertDI(Listed.count(CU), "DICompileUnit not listed in llvm.dbg.cu", CU);
+    CheckDI(Listed.count(CU), "DICompileUnit not listed in llvm.dbg.cu", CU);
   CUVisited.clear();
 }
 
 void Verifier::verifyDeoptimizeCallingConvs() {
   if (DeoptimizeDeclarations.empty())
     return;
 
   const Function *First = DeoptimizeDeclarations[0];
   for (auto *F : makeArrayRef(DeoptimizeDeclarations).slice(1)) {
-    Assert(First->getCallingConv() == F->getCallingConv(),
-           "All llvm.experimental.deoptimize declarations must have the same "
-           "calling convention",
-           First, F);
+    Check(First->getCallingConv() == F->getCallingConv(),
   }
 }
 
 void Verifier::verifyAttachedCallBundle(const CallBase &Call,
                                         const OperandBundleUse &BU) {
   FunctionType *FTy = Call.getFunctionType();
 
-  Assert((FTy->getReturnType()->isPointerTy() ||
-          (Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),
-         "a call with operand bundle \"clang.arc.attachedcall\" must call a "
-         "function returning a pointer or a non-returning function that has a "
-         "void return type",
-         Call);
+  Check((FTy->getReturnType()->isPointerTy() ||
 
-  Assert(BU.Inputs.size() == 1 && isa<Function>(BU.Inputs.front()),
-         "operand bundle \"clang.arc.attachedcall\" requires one function as "
-         "an argument",
-         Call);
+  Check(BU.Inputs.size() == 1 && isa<Function>(BU.Inputs.front()),
 
   auto *Fn = cast<Function>(BU.Inputs.front());
   Intrinsic::ID IID = Fn->getIntrinsicID();
 
   if (IID) {
-    Assert((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
-            IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue),
-           "invalid function argument", Call);
+    Check((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
   } else {
     StringRef FnName = Fn->getName();
-    Assert((FnName == "objc_retainAutoreleasedReturnValue" ||
-            FnName == "objc_unsafeClaimAutoreleasedReturnValue"),
-           "invalid function argument", Call);
+    Check((FnName == "objc_retainAutoreleasedReturnValue" ||
   }
 }
 
 void Verifier::verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F) {
   bool HasSource = F.getSource().hasValue();
   if (!HasSourceDebugInfo.count(&U))
     HasSourceDebugInfo[&U] = HasSource;
-  AssertDI(HasSource == HasSourceDebugInfo[&U],
-           "inconsistent use of embedded source");
+  CheckDI(HasSource == HasSourceDebugInfo[&U],
 }
 
 void Verifier::verifyNoAliasScopeDecl() {
   if (NoAliasScopeDecls.empty())
     return;
 
   // only a single scope must be declared at a time.
   for (auto *II : NoAliasScopeDecls) {
     assert(II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl &&
            "Not a llvm.experimental.noalias.scope.decl ?");
     const auto *ScopeListMV = dyn_cast<MetadataAsValue>(
         II->getOperand(Intrinsic::NoAliasScopeDeclScopeArg));
-    Assert(ScopeListMV != nullptr,
-           "llvm.experimental.noalias.scope.decl must have a MetadataAsValue "
-           "argument",
-           II);
+    Check(ScopeListMV != nullptr,
 
     const auto *ScopeListMD = dyn_cast<MDNode>(ScopeListMV->getMetadata());
-    Assert(ScopeListMD != nullptr, "!id.scope.list must point to an MDNode",
-           II);
-    Assert(ScopeListMD->getNumOperands() == 1,
-           "!id.scope.list must point to a list with a single scope", II);
+    Check(ScopeListMD != nullptr, "!id.scope.list must point to an MDNode", II);
+    Check(ScopeListMD->getNumOperands() == 1,
     visitAliasScopeListMetadata(ScopeListMD);
   }
 
   // Only check the domination rule when requested. Once all passes have been
   // adapted this option can go away.
   if (!VerifyNoAliasScopeDomination)
     return;
 
while (ItCurrent != NoAliasScopeDecls.end()) {
 
     // [ItCurrent, ItNext) represents the declarations for the same scope.
     // Ensure they are not dominating each other.. but only if it is not too
     // expensive.
     if (ItNext - ItCurrent < 32)
       for (auto *I : llvm::make_range(ItCurrent, ItNext))
         for (auto *J : llvm::make_range(ItCurrent, ItNext))
           if (I != J)
-            Assert(!DT.dominates(I, J),
-                   "llvm.experimental.noalias.scope.decl dominates another one "
-                   "with the same scope",
-                   I);
+            Check(!DT.dominates(I, J),
     ItCurrent = ItNext;
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Implement the public interfaces to this file...
 //===----------------------------------------------------------------------===//
 

 } // end anonymous namespace
 
 /// Helper to issue failure from the TBAA verification
 template <typename... Tys> void TBAAVerifier::CheckFailed(Tys &&... Args) {
   if (Diagnostic)
     return Diagnostic->CheckFailed(Args...);
 }
 
-#define AssertTBAA(C, ...)                                                     \
+#define CheckTBAA(C, ...)                                                      \
   do {                                                                         \
     if (!(C)) {                                                                \
       CheckFailed(__VA_ARGS__);                                                \
       return false;                                                            \
     }                                                                          \
   } while (false)
 
 /// Verify that \p BaseNode can be used as the "base type" in the struct-path

 MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(Instruction &I,
                                                    const MDNode *BaseNode,
                                                    APInt &Offset,
                                                    bool IsNewFormat) {
   assert(BaseNode->getNumOperands() >= 2 && "Invalid base node!");
 
   // Scalar nodes have only one possible "field" -- their parent in the access
   // hierarchy.  Offset must be zero at this point, but our caller is supposed
-  // to Assert that.
+  // to check that.
   if (BaseNode->getNumOperands() == 2)
     return cast<MDNode>(BaseNode->getOperand(1));
 
   unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
   unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
   for (unsigned Idx = FirstFieldOpNo; Idx < BaseNode->getNumOperands();
            Idx += NumOpsPerField) {
     auto *OffsetEntryCI =
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) {
-  AssertTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
-                 isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
-                 isa<AtomicCmpXchgInst>(I),
-             "This instruction shall not have a TBAA access tag!", &I);
+  CheckTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(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);
+  CheckTBAA(IsStructPathTBAA,
+            "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
+            &I);
 
   MDNode *BaseNode = dyn_cast_or_null<MDNode>(MD->getOperand(0));
   MDNode *AccessType = dyn_cast_or_null<MDNode>(MD->getOperand(1));
 
   bool IsNewFormat = isNewFormatTBAATypeNode(AccessType);
 
   if (IsNewFormat) {
-    AssertTBAA(MD->getNumOperands() == 4 || MD->getNumOperands() == 5,
-               "Access tag metadata must have either 4 or 5 operands", &I, MD);
+    CheckTBAA(MD->getNumOperands() == 4 || MD->getNumOperands() == 5,
   } else {
-    AssertTBAA(MD->getNumOperands() < 5,
-               "Struct tag metadata must have either 3 or 4 operands", &I, MD);
+    CheckTBAA(MD->getNumOperands() < 5,
   }
 
   // Check the access size field.
   if (IsNewFormat) {
     auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
         MD->getOperand(3));
-    AssertTBAA(AccessSizeNode, "Access size field must be a constant", &I, MD);
+    CheckTBAA(AccessSizeNode, "Access size field must be a constant", &I, MD);
   }
 
   // Check the immutability flag.
   unsigned ImmutabilityFlagOpNo = IsNewFormat ? 4 : 3;
   if (MD->getNumOperands() == ImmutabilityFlagOpNo + 1) {
     auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
         MD->getOperand(ImmutabilityFlagOpNo));
-    AssertTBAA(IsImmutableCI,
-               "Immutability tag on struct tag metadata must be a constant",
-               &I, MD);
-    AssertTBAA(
+    CheckTBAA(IsImmutableCI,
+              "Immutability tag on struct tag metadata must be a constant", &I,
+              MD);
+    CheckTBAA(
         IsImmutableCI->isZero() || IsImmutableCI->isOne(),
         "Immutability part of the struct tag metadata must be either 0 or 1",
         &I, MD);
   }
 
-  AssertTBAA(BaseNode && AccessType,
-             "Malformed struct tag metadata: base and access-type "
-             "should be non-null and point to Metadata nodes",
-             &I, MD, BaseNode, AccessType);
+  CheckTBAA(BaseNode && AccessType,
 
   if (!IsNewFormat) {
-    AssertTBAA(isValidScalarTBAANode(AccessType),
-               "Access type node must be a valid scalar type", &I, MD,
-               AccessType);
+    CheckTBAA(isValidScalarTBAANode(AccessType),
   }
 
   auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(2));
-  AssertTBAA(OffsetCI, "Offset must be constant integer", &I, MD);
+  CheckTBAA(OffsetCI, "Offset must be constant integer", &I, MD);
 
   APInt Offset = OffsetCI->getValue();
   bool SeenAccessTypeInPath = false;
 
   SmallPtrSet<MDNode *, 4> StructPath;
 
   for (/* empty */; BaseNode && !IsRootTBAANode(BaseNode);
        BaseNode = getFieldNodeFromTBAABaseNode(I, BaseNode, Offset,
for (/* empty */; BaseNode && !IsRootTBAANode(BaseNode);
     // If the base node is invalid in itself, then we've already printed all the
     // errors we wanted to print.
     if (Invalid)
       return false;
 
     SeenAccessTypeInPath |= BaseNode == AccessType;
 
     if (isValidScalarTBAANode(BaseNode) || BaseNode == AccessType)
-      AssertTBAA(Offset == 0, "Offset not zero at the point of scalar access",
-                 &I, MD, &Offset);
+      CheckTBAA(Offset == 0, "Offset not zero at the point of scalar access",
 
-    AssertTBAA(BaseNodeBitWidth == Offset.getBitWidth() ||
-                   (BaseNodeBitWidth == 0 && Offset == 0) ||
-                   (IsNewFormat && BaseNodeBitWidth == ~0u),
-               "Access bit-width not the same as description bit-width", &I, MD,
-               BaseNodeBitWidth, Offset.getBitWidth());
+    CheckTBAA(BaseNodeBitWidth == Offset.getBitWidth() ||
 
     if (IsNewFormat && SeenAccessTypeInPath)
       break;
   }
 
-  AssertTBAA(SeenAccessTypeInPath, "Did not see access type in access path!",
-             &I, MD);
+  CheckTBAA(SeenAccessTypeInPath, "Did not see access type in access path!", &I,
+            MD);
   return true;
 }
 
 char VerifierLegacyPass::ID = 0;
 INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
 
 FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
   return new VerifierLegacyPass(FatalErrors);