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

References

lib/IR/Verifier.cpp
  547     Assert(I.getOperand(i) != nullptr, "Operand is null", &I);
  565   Assert(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),
  568   Assert(GV.getAlignment() <= Value::MaximumAlignment,
  570   Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
  575     Assert(GVar && GVar->getValueType()->isArrayTy(),
  580     Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
  583     Assert(!GV.isDSOLocal(),
  586     Assert((GV.isDeclaration() && GV.hasExternalLinkage()) ||
  592     Assert(GV.isDSOLocal(),
  597     Assert(GV.isDSOLocal(),
  603         CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
  606         CheckFailed("Global is referenced in a different module!", &GV, &M, I,
  612         CheckFailed("Global is used by function in a different module", &GV, &M,
  622     Assert(GV.getInitializer()->getType() == GV.getValueType(),
  629       Assert(GV.getInitializer()->isNullValue(),
  631       Assert(!GV.isConstant(), "'common' global may not be marked constant!",
  633       Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
  639     Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
  648       Assert(STy &&
  657       Assert(ETy->isPointerTy() &&
  665     Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
  670       Assert(PTy, "wrong type for intrinsic global variable", &GV);
  674         Assert(InitArray, "wrong initalizer for intrinsic global variable",
  678           Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
  681           Assert(V->hasName(), "members of llvm.used must be named", V);
  703     Assert(!VTy->isScalable(), "Globals cannot contain scalable vectors", &GV);
  725     Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition",
  729       Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
  731       Assert(!GA2->isInterposable(), "Alias cannot point to an interposable alias",
  753   Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),
  758   Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
  759   Assert(GA.getType() == Aliasee->getType(),
  762   Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
  809     Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
  822   Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD);
  823   Assert(MD.isResolved(), "All nodes should be resolved!", &MD);
  827   Assert(MD.getValue(), "Expected valid value", &MD);
  828   Assert(!MD.getValue()->getType()->isMetadataTy(),
  835   Assert(F, "function-local metadata used outside a function", L);
  841     Assert(I->getParent(), "function-local metadata not in basic block", L, I);
  849   Assert(ActualF == F, "function-local metadata used in wrong function", L);
 1320       Assert(!GV->hasPrivateLinkage(),
 1332     Assert(N->getNumOperands() == 1,
 1334     Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
 1350     Assert(N->getNumOperands() == 1,
 1352     Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
 1376       CheckFailed("invalid requirement on flag, flag is not present in module",
 1382       CheckFailed(("invalid requirement on flag, "
 1396   Assert(Op->getNumOperands() == 3,
 1400     Assert(
 1404     Assert(false,
 1409   Assert(ID, "invalid ID operand in module flag (expected metadata string)",
 1421     Assert(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),
 1431     Assert(Value && Value->getNumOperands() == 2,
 1434     Assert(isa<MDString>(Value->getOperand(0)),
 1448     Assert(isa<MDNode>(Op->getOperand(2)),
 1459     Assert(Inserted,
 1488     Assert(F && isa<Function>(F->getValue()), "expected a Function or null",
 1492   Assert(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO);
 1496   Assert(Count && Count->getType()->isIntegerTy(),
 1569         CheckFailed("Attribute '" + A.getAsString() +
 1575       CheckFailed("Attribute '" + A.getAsString() +
 1593     Assert(Attrs.getNumAttributes() == 1,
 1605   Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', "
 1609   Assert(!(Attrs.hasAttribute(Attribute::InAlloca) &&
 1615   Assert(!(Attrs.hasAttribute(Attribute::StructRet) &&
 1621   Assert(!(Attrs.hasAttribute(Attribute::ZExt) &&
 1627   Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&
 1633   Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&
 1639   Assert(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
 1645   Assert(!(Attrs.hasAttribute(Attribute::NoInline) &&
 1652     Assert(Attrs.getByValType() == cast<PointerType>(Ty)->getElementType(),
 1657   Assert(!AttrBuilder(Attrs).overlaps(IncompatibleAttrs),
 1665       Assert(!Attrs.hasAttribute(Attribute::ByVal) &&
 1671       Assert(!Attrs.hasAttribute(Attribute::SwiftError),
 1676     Assert(!Attrs.hasAttribute(Attribute::ByVal),
 1679     Assert(!Attrs.hasAttribute(Attribute::SwiftError),
 1701   Assert((!RetAttrs.hasAttribute(Attribute::ByVal) &&
 1713   Assert((!RetAttrs.hasAttribute(Attribute::ReadOnly) &&
 1727       Assert(!ArgAttrs.hasAttribute(Attribute::ImmArg),
 1734       Assert(!SawNest, "More than one parameter has attribute nest!", V);
 1739       Assert(!SawReturned, "More than one parameter has attribute returned!",
 1741       Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
 1748       Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
 1749       Assert(i == 0 || i == 1,
 1755       Assert(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V);
 1760       Assert(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!",
 1766       Assert(i == FT->getNumParams() - 1,
 1776   Assert(!(Attrs.hasFnAttribute(Attribute::ReadNone) &&
 1780   Assert(!(Attrs.hasFnAttribute(Attribute::ReadNone) &&
 1784   Assert(!(Attrs.hasFnAttribute(Attribute::ReadOnly) &&
 1788   Assert(!(Attrs.hasFnAttribute(Attribute::ReadNone) &&
 1794   Assert(!(Attrs.hasFnAttribute(Attribute::ReadNone) &&
 1798   Assert(!(Attrs.hasFnAttribute(Attribute::NoInline) &&
 1803     Assert(Attrs.hasFnAttribute(Attribute::NoInline),
 1806     Assert(!Attrs.hasFnAttribute(Attribute::OptimizeForSize),
 1809     Assert(!Attrs.hasFnAttribute(Attribute::MinSize),
 1815     Assert(GV->hasGlobalUnnamedAddr(),
 1825         CheckFailed("'allocsize' " + Name + " argument is out of bounds", V);
 1830         CheckFailed("'allocsize' " + Name +
 1852       Assert(MD->getNumOperands() >= 2,
 1856       Assert(MD->getOperand(0) != nullptr, "first operand should not be null",
 1858       Assert(isa<MDString>(MD->getOperand(0)),
 1862       Assert(ProfName.equals("function_entry_count") ||
 1869       Assert(MD->getOperand(1) != nullptr, "second operand should not be null",
 1871       Assert(isa<ConstantAsMetadata>(MD->getOperand(1)),
 1894       Assert(GV->getParent() == &M, "Referencing global in another module!",
 1913     Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
 1943   Assert(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory() &&
 1952   Assert(NumPatchBytes >= 0,
 1959   Assert(PT && PT->getElementType()->isFunctionTy(),
 1964   Assert(NumCallArgs >= 0,
 1970     Assert(NumCallArgs >= NumParams,
 1974     Assert(TargetFuncType->getReturnType()->isVoidTy(),
 1979     Assert(NumCallArgs == NumParams,
 1984   Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
 1993     Assert(ArgType == ParamType,
 2000       Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
 2009   Assert(isa<ConstantInt>(NumTransitionArgsV),
 2015   Assert(NumTransitionArgs >= 0,
 2020   Assert(isa<ConstantInt>(NumDeoptArgsV),
 2025   Assert(NumDeoptArgs >= 0,
 2032   Assert(ExpectedNumArgs <= (int)Call.arg_size(),
 2040     Assert(UserCall, "illegal use of statepoint token", Call, U);
 2043     Assert(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
 2048       Assert(UserCall->getArgOperand(0) == &Call,
 2051       Assert(UserCall->getArgOperand(0) == &Call,
 2071     Assert(MaxRecoveredIndex <= EscapedObjectCount,
 2112         Assert(false, "EH pads can't handle each other's exceptions",
 2141   Assert(&Context == &F.getContext(),
 2144   Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
 2145   Assert(FT->getNumParams() == NumArgs,
 2148   Assert(F.getReturnType()->isFirstClassType() ||
 2152   Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
 2157   Assert(verifyAttributeCount(Attrs, FT->getNumParams()),
 2169   Assert(!Attrs.hasFnAttribute(Attribute::Builtin),
 2181     Assert(F.getReturnType()->isVoidTy(),
 2189     Assert(!F.hasStructRetAttr(),
 2197     Assert(!F.isVarArg(), "Calling convention does not support varargs or "
 2206     Assert(Arg.getType() == FT->getParamType(i),
 2209     Assert(Arg.getType()->isFirstClassType(),
 2212       Assert(!Arg.getType()->isMetadataTy(),
 2214       Assert(!Arg.getType()->isTokenTy(),
 2226     Assert(!F.getReturnType()->isTokenTy(),
 2239       Assert(Per->getParent() == F.getParent(),
 2246     Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
 2255       Assert(I.first != LLVMContext::MD_prof,
 2261     Assert(!F.hasPersonalityFn(),
 2266     Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
 2270     Assert(pred_empty(Entry),
 2275       Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),
 2301         Assert(NumProfAttachments == 1,
 2318       Assert(false, "Invalid user of intrinsic instruction!", U);
 2379   Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
 2389       Assert(PN.getNumIncomingValues() != 0,
 2393       Assert(PN.getNumIncomingValues() == Preds.size(),
 2411         Assert(i == 0 || Values[i].first != Values[i - 1].first ||
 2419         Assert(Values[i].first == Preds[i],
 2435   Assert(&I == I.getParent()->getTerminator(),
 2442     Assert(BI.getCondition()->getType()->isIntegerTy(1),
 2452     Assert(N == 0,
 2457     Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
 2473     Assert(Case.getCaseValue()->getType() == SwitchTy,
 2475     Assert(Constants.insert(Case.getCaseValue()).second,
 2483   Assert(BI.getAddress()->getType()->isPointerTy(),
 2486     Assert(BI.getDestination(i)->getType()->isLabelTy(),
 2493   Assert(CBI.isInlineAsm(), "Callbr is currently only used for asm-goto!",
 2495   Assert(CBI.getType()->isVoidTy(), "Callbr return value is not supported!",
 2498     Assert(CBI.getSuccessor(i)->getType()->isLabelTy(),
 2501     Assert(i >= CBI.getNumArgOperands() || !isa<BasicBlock>(CBI.getOperand(i)),
 2505         Assert(CBI.getOperand(i) != CBI.getOperand(j),
 2514       Assert(ArgBBs.find(BB) != ArgBBs.end(),
 2522   Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
 2526   Assert(SI.getTrueValue()->getType() == SI.getType(),
 2535   Assert(false, "User-defined operators should not live outside of a pass!", &I);
 2547   Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
 2548   Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
 2549   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
 2551   Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
 2562   Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
 2563   Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
 2564   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
 2569   Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
 2583   Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
 2584   Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
 2585   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
 2587   Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
 2600   Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
 2601   Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
 2602   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
 2604   Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
 2618   Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
 2619   Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
 2620   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
 2622   Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
 2635   Assert(SrcVec == DstVec,
 2637   Assert(SrcTy->isIntOrIntVectorTy(),
 2639   Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
 2643     Assert(cast<VectorType>(SrcTy)->getNumElements() ==
 2658   Assert(SrcVec == DstVec,
 2660   Assert(SrcTy->isIntOrIntVectorTy(),
 2662   Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
 2666     Assert(cast<VectorType>(SrcTy)->getNumElements() ==
 2681   Assert(SrcVec == DstVec,
 2683   Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
 2685   Assert(DestTy->isIntOrIntVectorTy(),
 2689     Assert(cast<VectorType>(SrcTy)->getNumElements() ==
 2704   Assert(SrcVec == DstVec,
 2706   Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",
 2708   Assert(DestTy->isIntOrIntVectorTy(),
 2712     Assert(cast<VectorType>(SrcTy)->getNumElements() ==
 2724   Assert(SrcTy->isPtrOrPtrVectorTy(), "PtrToInt source must be pointer", &I);
 2730   Assert(DestTy->isIntOrIntVectorTy(), "PtrToInt result must be integral", &I);
 2731   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
 2737     Assert(VSrc->getNumElements() == VDest->getNumElements(),
 2749   Assert(SrcTy->isIntOrIntVectorTy(),
 2751   Assert(DestTy->isPtrOrPtrVectorTy(), "IntToPtr result must be a pointer", &I);
 2757   Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
 2762     Assert(VSrc->getNumElements() == VDest->getNumElements(),
 2769   Assert(
 2779   Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
 2781   Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
 2783   Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
 2786     Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(),
 2798   Assert(&PN == &PN.getParent()->front() ||
 2808     Assert(PN.getType() == IncValue->getType(),
 2818   Assert(Call.getCalledValue()->getType()->isPointerTy(),
 2822   Assert(FPTy->getElementType()->isFunctionTy(),
 2825   Assert(FPTy->getElementType() == Call.getFunctionType(),
 2832     Assert(Call.arg_size() >= FTy->getNumParams(),
 2836     Assert(Call.arg_size() == FTy->getNumParams(),
 2841     Assert(Call.getArgOperand(i)->getType() == FTy->getParamType(i),
 2847   Assert(verifyAttributeCount(Attrs, Call.arg_size()),
 2859     Assert(Callee && Callee->isSpeculatable(),
 2872       Assert(AI->isUsedWithInAlloca(),
 2883         Assert(AI->isSwiftError(),
 2888       Assert(ArgI,
 2891       Assert(ArgI->hasSwiftErrorAttr(),
 2899       Assert(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),
 2906       Assert(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
 2930         Assert(!SawNest, "More than one parameter has attribute nest!", Call);
 2935         Assert(!SawReturned, "More than one parameter has attribute returned!",
 2937         Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
 2949         Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
 2954         Assert(Idx == Call.arg_size() - 1,
 2962       Assert(!ParamTy->isMetadataTy(),
 2964       Assert(!ParamTy->isTokenTy(),
 2986       Assert(!FoundDeoptBundle, "Multiple deopt operand bundles", Call);
 2989       Assert(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",
 2993       Assert(!FoundFuncletBundle, "Multiple funclet operand bundles", Call);
 2995       Assert(BU.Inputs.size() == 1,
 2997       Assert(isa<FuncletPadInst>(BU.Inputs.front()),
 3001       Assert(!FoundCFGuardTargetBundle,
 3004       Assert(BU.Inputs.size() == 1,
 3050   Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
 3059     Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
 3063       Assert(
 3068   Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),
 3070   Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
 3074   Assert(F->getCallingConv() == CI.getCallingConv(),
 3084     Assert(CallerABIAttrs == CalleeABIAttrs,
 3099     Assert(BI->getOperand(0) == RetVal,
 3107   Assert(Ret, "musttail call must precede a ret with an optional bitcast",
 3109   Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal,
 3125   Assert(
 3136   Assert(U.getType() == U.getOperand(0)->getType(), 
 3145     Assert(U.getType()->isFPOrFPVectorTy(),
 3159   Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
 3172     Assert(B.getType()->isIntOrIntVectorTy(),
 3174     Assert(B.getType() == B.getOperand(0)->getType(),
 3186     Assert(B.getType()->isFPOrFPVectorTy(),
 3190     Assert(B.getType() == B.getOperand(0)->getType(),
 3199     Assert(B.getType()->isIntOrIntVectorTy(),
 3201     Assert(B.getType() == B.getOperand(0)->getType(),
 3208     Assert(B.getType()->isIntOrIntVectorTy(),
 3210     Assert(B.getType() == B.getOperand(0)->getType(),
 3224   Assert(Op0Ty == Op1Ty,
 3227   Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy(),
 3230   Assert(IC.isIntPredicate(),
 3240   Assert(Op0Ty == Op1Ty,
 3243   Assert(Op0Ty->isFPOrFPVectorTy(),
 3246   Assert(FC.isFPPredicate(),
 3253   Assert(
 3260   Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
 3267   Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
 3276   Assert(isa<PointerType>(TargetTy),
 3278   Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
 3281   Assert(all_of(
 3286   Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP);
 3288   Assert(GEP.getType()->isPtrOrPtrVectorTy() &&
 3296       Assert(GEPWidth == GEP.getPointerOperandType()->getVectorNumElements(),
 3302         Assert(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP);
 3310     Assert(GEP.getAddressSpace() == PTy->getAddressSpace(),
 3326   Assert(NumOperands % 2 == 0, "Unfinished range!", Range);
 3328   Assert(NumRanges >= 1, "It should have at least one range!", Range);
 3334     Assert(Low, "The lower limit must be an integer!", Low);
 3337     Assert(High, "The upper limit must be an integer!", High);
 3338     Assert(High->getType() == Low->getType() && High->getType() == Ty,
 3344     Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),
 3347       Assert(CurRange.intersectWith(LastRange).isEmptySet(),
 3349       Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
 3351       Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
 3362     Assert(FirstRange.intersectWith(LastRange).isEmptySet(),
 3364     Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
 3371   Assert(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
 3372   Assert(!(Size & (Size - 1)),
 3378   Assert(PTy, "Load operand must be a pointer.", &LI);
 3380   Assert(LI.getAlignment() <= Value::MaximumAlignment,
 3382   Assert(ElTy->isSized(), "loading unsized types is not allowed", &LI);
 3384     Assert(LI.getOrdering() != AtomicOrdering::Release &&
 3387     Assert(LI.getAlignment() != 0,
 3389     Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
 3395     Assert(LI.getSyncScopeID() == SyncScope::System,
 3404   Assert(PTy, "Store operand must be a pointer.", &SI);
 3406   Assert(ElTy == SI.getOperand(0)->getType(),
 3408   Assert(SI.getAlignment() <= Value::MaximumAlignment,
 3410   Assert(ElTy->isSized(), "storing unsized types is not allowed", &SI);
 3412     Assert(SI.getOrdering() != AtomicOrdering::Acquire &&
 3415     Assert(SI.getAlignment() != 0,
 3417     Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
 3423     Assert(SI.getSyncScopeID() == SyncScope::System,
 3435       Assert(Call.paramHasAttr(Idx, Attribute::SwiftError),
 3447     Assert(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
 3454       Assert(StoreI->getOperand(1) == SwiftErrorVal,
 3466   Assert(PTy->getAddressSpace() == DL.getAllocaAddrSpace(),
 3469   Assert(AI.getAllocatedType()->isSized(&Visited),
 3471   Assert(AI.getArraySize()->getType()->isIntegerTy(),
 3473   Assert(AI.getAlignment() <= Value::MaximumAlignment,
 3486   Assert(CXI.getSuccessOrdering() != AtomicOrdering::NotAtomic,
 3488   Assert(CXI.getFailureOrdering() != AtomicOrdering::NotAtomic,
 3490   Assert(CXI.getSuccessOrdering() != AtomicOrdering::Unordered,
 3492   Assert(CXI.getFailureOrdering() != AtomicOrdering::Unordered,
 3494   Assert(!isStrongerThan(CXI.getFailureOrdering(), CXI.getSuccessOrdering()),
 3498   Assert(CXI.getFailureOrdering() != AtomicOrdering::Release &&
 3503   Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI);
 3505   Assert(ElTy->isIntOrPtrTy(),
 3508   Assert(ElTy == CXI.getOperand(1)->getType(),
 3511   Assert(ElTy == CXI.getOperand(2)->getType(),
 3517   Assert(RMWI.getOrdering() != AtomicOrdering::NotAtomic,
 3519   Assert(RMWI.getOrdering() != AtomicOrdering::Unordered,
 3523   Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
 3526     Assert(ElTy->isIntegerTy() || ElTy->isFloatingPointTy(), "atomicrmw " +
 3531     Assert(ElTy->isFloatingPointTy(), "atomicrmw " +
 3536     Assert(ElTy->isIntegerTy(), "atomicrmw " +
 3542   Assert(ElTy == RMWI.getOperand(1)->getType(),
 3545   Assert(AtomicRMWInst::FIRST_BINOP <= Op && Op <= AtomicRMWInst::LAST_BINOP,
 3552   Assert(Ordering == AtomicOrdering::Acquire ||
 3563   Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
 3571   Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
 3592   Assert(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
 3600       Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
 3609       Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
 3613     Assert(BB != CPI->getCatchSwitch()->getUnwindDest(),
 3627       Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB,
 3635       Assert(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI);
 3639       Assert(false, "EH pad must be jumped to via an unwind edge", ToPad, TI);
 3645       Assert(FromPad != ToPad,
 3651       Assert(!isa<ConstantTokenNone>(FromPad),
 3653       Assert(Seen.insert(FromPad).second,
 3662   Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
 3670     Assert(LandingPadResultTy == LPI.getType(),
 3676   Assert(F->hasPersonalityFn(),
 3681   Assert(LPI.getParent()->getLandingPadInst() == &LPI,
 3688       Assert(isa<PointerType>(Clause->getType()),
 3691       Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
 3692       Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
 3701   Assert(RI.getFunction()->hasPersonalityFn(),
 3707     Assert(LandingPadResultTy == RI.getValue()->getType(),
 3719   Assert(F->hasPersonalityFn(),
 3722   Assert(isa<CatchSwitchInst>(CPI.getParentPad()),
 3728   Assert(BB->getFirstNonPHI() == &CPI,
 3736   Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)),
 3747   Assert(F->hasPersonalityFn(),
 3752   Assert(BB->getFirstNonPHI() == &CPI,
 3757   Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
 3772     Assert(Seen.insert(CurrentPad).second,
 3801         Assert(isa<CatchReturnInst>(U), "Bogus funclet pad use", U);
 3851           Assert(UnwindPad == FirstUnwindPad, "Unwind edges out of a funclet "
 3913       Assert(SwitchUnwindPad == FirstUnwindPad,
 3927   Assert(F->hasPersonalityFn(),
 3933   Assert(BB->getFirstNonPHI() == &CatchSwitch,
 3938   Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
 3943     Assert(I->isEHPad() && !isa<LandingPadInst>(I),
 3953   Assert(CatchSwitch.getNumHandlers() != 0,
 3957     Assert(isa<CatchPadInst>(Handler->getFirstNonPHI()),
 3966   Assert(isa<CleanupPadInst>(CRI.getOperand(0)),
 3972     Assert(I->isEHPad() && !isa<LandingPadInst>(I),
 4002   Assert(DT.dominates(Op, U),
 4007   Assert(I.getType()->isPointerTy(), "dereferenceable, dereferenceable_or_null "
 4009   Assert((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
 4012   Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null "
 4015   Assert(CI && CI->getType()->isIntegerTy(64), "dereferenceable, "
 4020   Assert(MD->getNumOperands() >= 2,
 4024   Assert(MD->getOperand(0) != nullptr, "first operand should not be null", MD);
 4025   Assert(isa<MDString>(MD->getOperand(0)),
 4044       CheckFailed("!prof branch_weights are not allowed for this instruction",
 4047     Assert(MD->getNumOperands() == 1 + ExpectedNumOperands,
 4051       Assert(MDO, "second operand should not be null", MD);
 4062   Assert(BB, "Instruction not embedded in basic block!", &I);
 4066       Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
 4072   Assert(!I.getType()->isVoidTy() || !I.hasName(),
 4077   Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
 4082   Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
 4090       Assert(Used->getParent() != nullptr,
 4095       CheckFailed("Use of instruction is not an instruction!", U);
 4105     Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
 4110       Assert(false, "Instruction operands must be first-class values!", &I);
 4116       Assert(!F->isIntrinsic() ||
 4119       Assert(
 4131       Assert(F->getParent() == &M, "Referencing function in another module!",
 4134       Assert(OpBB->getParent() == BB->getParent(),
 4137       Assert(OpArg->getParent() == BB->getParent(),
 4140       Assert(GV->getParent() == &M, "Referencing global in another module!", &I,
 4145       Assert(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
 4160     Assert(I.getType()->isFPOrFPVectorTy(),
 4162     Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
 4166       Assert(&Accuracy.getSemantics() == &APFloat::IEEEsingle(),
 4168       Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
 4171       Assert(false, "invalid fpmath accuracy!", &I);
 4176     Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
 4182     Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
 4184     Assert(isa<LoadInst>(I),
 4200     Assert(I.getType()->isPointerTy(), "align applies only to pointer types",
 4202     Assert(isa<LoadInst>(I), "align applies only to load instructions, "
 4204     Assert(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
 4206     Assert(CI && CI->getType()->isIntegerTy(64),
 4209     Assert(isPowerOf2_64(Align),
 4211     Assert(Align <= Value::MaximumAlignment,
 4234   Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!",
 4250   Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchRet,
 4252   Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchArg,
 4257     Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
 4260     Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
 4264   Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
 4271   Assert(ExpectedName == IF->getName(),
 4335     Assert(isa<MetadataAsValue>(Call.getArgOperand(0)),
 4355     Assert(IsValidAlignment(MI->getDestAlignment()),
 4359       Assert(IsValidAlignment(MTI->getSourceAlignment()),
 4374     Assert(ElementSizeVal.isPowerOf2(),
 4382       Assert((Length % ElementSize) == 0,
 4392     Assert(IsValidAlignment(DstAlignment),
 4396       Assert(IsValidAlignment(SrcAlignment),
 4407       Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", Call);
 4408       Assert(isa<Constant>(Call.getArgOperand(1)),
 4411         Assert(!isa<ConstantPointerNull>(Call.getArgOperand(1)),
 4418     Assert(Call.getParent()->getParent()->hasGC(),
 4422     Assert(isa<Function>(Call.getArgOperand(1)->stripPointerCasts()),
 4427     Assert(cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue() < 2 &&
 4432     Assert(isa<AllocaInst>(Call.getArgOperand(1)->stripPointerCasts()),
 4437     Assert(BB == &BB->getParent()->front(),
 4439     Assert(!SawFrameEscape,
 4445       Assert(AI && AI->isStaticAlloca(),
 4455     Assert(Fn && !Fn->isDeclaration(),
 4468       Assert(!CI->isInlineAsm(),
 4470     Assert(Call.getParent()->getParent()->hasGC(),
 4476     Assert(Call.getParent()->getParent()->hasGC(),
 4482     Assert(StatepointFn && StatepointFn->isDeclaration() &&
 4492     Assert(Call.getType() == TargetFuncType->getReturnType(),
 4497     Assert(Call.getNumArgOperands() == 3, "wrong number of arguments", Call);
 4499     Assert(isa<PointerType>(Call.getType()->getScalarType()),
 4513       Assert(InvokeBB, "safepoints should have unique landingpads",
 4515       Assert(InvokeBB->getTerminator(), "safepoint block should be well formed",
 4517       Assert(isStatepoint(InvokeBB->getTerminator()),
 4524       Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)),
 4534     Assert(isa<ConstantInt>(Base),
 4538     Assert(isa<ConstantInt>(Derived),
 4544     Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCall.arg_size(),
 4546     Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCall.arg_size(),
 4574     Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,
 4578     Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd,
 4588     Assert(Relocate.getDerivedPtr()->getType()->isPtrOrPtrVectorTy(),
 4593     Assert(ResultType->isVectorTy() == DerivedType->isVectorTy(),
 4596     Assert(
 4605     Assert(isa<CatchPadInst>(Call.getArgOperand(0)),
 4610     Assert(Call.getType()->isVectorTy(), "masked_load: must return a vector",
 4617     Assert(Mask->getType()->isVectorTy(), "masked_load: mask must be vector",
 4619     Assert(Alignment->getValue().isPowerOf2(),
 4624     Assert(DataTy == Call.getType(),
 4626     Assert(PassThru->getType() == DataTy,
 4628     Assert(Mask->getType()->getVectorNumElements() ==
 4638     Assert(Mask->getType()->isVectorTy(), "masked_store: mask must be vector",
 4640     Assert(Alignment->getValue().isPowerOf2(),
 4645     Assert(DataTy == Val->getType(),
 4647     Assert(Mask->getType()->getVectorNumElements() ==
 4654     Assert(isa<CallInst>(Call), "experimental_guard cannot be invoked", Call);
 4662     Assert(isa<CallInst>(Call), "experimental_deoptimize cannot be invoked",
 4731     Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
 4776     Assert((NumOperands == 3), "invalid arguments for constrained FP intrinsic",
 4784     Assert((NumOperands == 3), "invalid arguments for constrained FP intrinsic",
 4788     Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
 4797     Assert((NumOperands == 2), "invalid arguments for constrained FP intrinsic",
 4801     Assert(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
 4808     Assert((NumOperands == 5), "invalid arguments for constrained FP intrinsic",
 4823     Assert((NumOperands == 4), "invalid arguments for constrained FP intrinsic",
 4831     Assert((NumOperands == 2),
 4837     Assert(Operand->getType()->isFPOrFPVectorTy(),
 4844     Assert((NumSrcElem > 0) == Operand->getType()->isVectorTy(),
 4846     Assert(Operand->getType()->isIntOrIntVectorTy(),
 4849       Assert(NumSrcElem == OperandT->getNumElements(),
 4859       Assert((NumOperands == 3),
 4863       Assert((NumOperands == 2),
 4872     Assert(OperandTy->isFPOrFPVectorTy(),
 4874     Assert(ResultTy->isFPOrFPVectorTy(),
 4876     Assert(OperandTy->isVectorTy() == ResultTy->isVectorTy(),
 4881       Assert(OperandVecTy->getNumElements() == ResultVecTy->getNumElements(),
 4886       Assert(OperandTy->getScalarSizeInBits() > ResultTy->getScalarSizeInBits(),
 4890       Assert(OperandTy->getScalarSizeInBits() < ResultTy->getScalarSizeInBits(),
 4907     Assert(FPI.getExceptionBehavior().hasValue(),
 4911     Assert(FPI.getRoundingMode().hasValue(),
 4974   Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment",
 5090     Assert(First->getCallingConv() == F->getCallingConv(),
 5190     return Diagnostic->CheckFailed(Args...);