100#include "llvm/IR/IntrinsicsAArch64.h"
101#include "llvm/IR/IntrinsicsARM.h"
102#include "llvm/IR/IntrinsicsBPF.h"
103#include "llvm/IR/IntrinsicsNVPTX.h"
104#include "llvm/IR/IntrinsicsRISCV.h"
105#include "llvm/IR/IntrinsicsWebAssembly.h"
158 SmallPtrSet<Instruction *, 16> InstsInThisBlock;
161 SmallPtrSet<const Metadata *, 32> MDNodes;
164 DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
168 DenseMap<const Metadata *, bool> DIScopeChainReachesCycle;
171 SmallPtrSet<const Metadata *, 2> CUVisited;
174 Type *LandingPadResultTy;
181 bool HasDebugInfo =
false;
185 DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
189 MapVector<Instruction *, Instruction *> SiblingFuncletInfo;
193 DenseMap<BasicBlock *, ColorVector> BlockEHFuncletColors;
196 SmallPtrSet<const Constant *, 32> ConstantExprVisited;
202 SmallPtrSet<const void *, 32> AttributeListsVisited;
208 SmallPtrSet<const Value *, 32> GlobalValueVisited;
213 TBAAVerifier TBAAVerifyHelper;
217 unsigned MDAMDGPUExpectedActiveLanes;
218 unsigned MDAMDGPUCFS;
222 void checkAtomicMemAccessSize(
Type *Ty,
const Instruction *
I);
225 explicit Verifier(raw_ostream *OS,
bool ShouldTreatBrokenDebugInfoAsError,
227 : VerifierSupport(OS,
M), LandingPadResultTy(nullptr),
228 SawFrameEscape(
false), TBAAVerifyHelper(this),
229 MDAMDGPUExpectedActiveLanes(
230 M.
getContext().getMDKindID(
"amdgpu.expected.active.lanes")),
231 MDAMDGPUCFS(
M.
getContext().getMDKindID(
"amdgpu.cfs")) {
232 TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
235 bool hasBrokenDebugInfo()
const {
return BrokenDebugInfo; }
238 llvm::TimeTraceScope timeScope(
"Verifier");
240 "An instance of this class only works with a specific module!");
250 for (
const BasicBlock &BB :
F) {
251 if (!BB.empty() && BB.back().isTerminator())
255 *OS <<
"Basic Block in function '" <<
F.getName()
256 <<
"' does not have terminator!\n";
257 BB.printAsOperand(*OS,
true, MST);
265 DT.recalculate(
const_cast<Function &
>(
F));
267 auto FailureCB = [
this](
const Twine &Message) {
268 this->CheckFailed(Message);
270 ConvergenceVerifyHelper.initialize(OS, FailureCB,
F);
275 verifySiblingFuncletUnwinds();
277 if (ConvergenceVerifyHelper.sawTokens())
278 ConvergenceVerifyHelper.verify(DT);
280 InstsInThisBlock.clear();
282 DIScopeChainReachesCycle.clear();
283 LandingPadResultTy =
nullptr;
284 SawFrameEscape =
false;
285 SiblingFuncletInfo.clear();
286 verifyNoAliasScopeDecl();
287 NoAliasScopeDecls.clear();
298 if (
F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
299 DeoptimizeDeclarations.push_back(&
F);
303 verifyFrameRecoverIndices();
304 for (
const GlobalVariable &GV :
M.globals())
305 visitGlobalVariable(GV);
307 for (
const GlobalAlias &GA :
M.aliases())
308 visitGlobalAlias(GA);
310 for (
const GlobalIFunc &GI :
M.ifuncs())
311 visitGlobalIFunc(GI);
313 for (
const NamedMDNode &NMD :
M.named_metadata())
314 visitNamedMDNode(NMD);
316 for (
const StringMapEntry<Comdat> &SMEC :
M.getComdatSymbolTable())
317 visitComdat(SMEC.getValue());
321 visitModuleCommandLines();
322 visitModuleErrnoTBAA();
323 visitModuleRawSections();
325 verifyCompileUnits();
327 verifyDeoptimizeCallingConvs();
328 DISubprogramAttachments.clear();
329 DIScopeChainReachesCycle.clear();
335 enum class AreDebugLocsAllowed {
No,
Yes };
339 enum class RangeLikeMetadataKind {
346 void visitGlobalValue(
const GlobalValue &GV);
347 void visitGlobalVariable(
const GlobalVariable &GV);
348 void visitGlobalAlias(
const GlobalAlias &GA);
349 void visitGlobalIFunc(
const GlobalIFunc &GI);
350 void visitAliaseeSubExpr(
const GlobalAlias &
A,
const Constant &
C);
351 void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited,
352 const GlobalAlias &
A,
const Constant &
C);
353 void visitNamedMDNode(
const NamedMDNode &NMD);
354 void visitMDNode(
const MDNode &MD, AreDebugLocsAllowed AllowLocs);
355 void visitMetadataAsValue(
const MetadataAsValue &MD,
Function *
F);
356 void visitValueAsMetadata(
const ValueAsMetadata &MD,
Function *
F);
357 void visitDIArgList(
const DIArgList &AL,
Function *
F);
358 void visitComdat(
const Comdat &
C);
359 void visitModuleIdents();
360 void visitModuleCommandLines();
361 void visitModuleErrnoTBAA();
362 void visitModuleRawSections();
363 void visitModuleFlags();
364 void visitModuleFlag(
const MDNode *
Op,
365 DenseMap<const MDString *, const MDNode *> &SeenIDs,
366 SmallVectorImpl<const MDNode *> &Requirements);
367 void visitModuleFlagCGProfileEntry(
const MDOperand &MDO);
369 void visitBasicBlock(BasicBlock &BB);
370 void verifyRangeLikeMetadata(
const Value &
V,
const MDNode *
Range,
Type *Ty,
371 RangeLikeMetadataKind Kind);
372 void visitRangeMetadata(Instruction &
I, MDNode *
Range,
Type *Ty);
373 void visitNoFPClassMetadata(Instruction &
I, MDNode *
Range,
Type *Ty);
374 void visitNoaliasAddrspaceMetadata(Instruction &
I, MDNode *
Range,
Type *Ty);
375 void visitDereferenceableMetadata(Instruction &
I, MDNode *MD);
376 void visitNoFreeObjMetadata(Instruction &
I, MDNode *MD);
377 void visitProfMetadata(Instruction &
I, MDNode *MD);
378 void visitCallStackMetadata(MDNode *MD);
379 void visitMemProfMetadata(Instruction &
I, MDNode *MD);
380 void visitCallsiteMetadata(Instruction &
I, MDNode *MD);
381 void visitCalleeTypeMetadata(Instruction &
I, MDNode *MD);
382 void visitDIAssignIDMetadata(Instruction &
I, MDNode *MD);
383 void visitMMRAMetadata(Instruction &
I, MDNode *MD);
384 void visitAnnotationMetadata(MDNode *Annotation);
385 void visitAliasScopeMetadata(
const MDNode *MD);
386 void visitAliasScopeListMetadata(
const MDNode *MD);
387 void visitAccessGroupMetadata(
const MDNode *MD);
388 void visitCapturesMetadata(Instruction &
I,
const MDNode *Captures);
389 void visitAllocTokenMetadata(Instruction &
I, MDNode *MD);
390 void visitInlineHistoryMetadata(Instruction &
I, MDNode *MD);
391 void visitMemCacheHintMetadata(Instruction &
I, MDNode *MD);
393#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
394#include "llvm/IR/Metadata.def"
395 void visitDIType(
const DIType &
N);
396 void visitDIScope(
const DIScope &
N);
397 void visitDIScopeChain(
const DIScope &
N);
398 bool hasDIScopeCycle(
const Metadata *S);
428 void visitPHINode(
PHINode &PN);
458 void visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI);
459 void visitVPIntrinsic(VPIntrinsic &VPI);
460 void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
461 void visitAtomicRMWInst(AtomicRMWInst &RMWI);
462 void visitFenceInst(FenceInst &FI);
463 void visitAllocaInst(AllocaInst &AI);
464 void visitExtractValueInst(ExtractValueInst &EVI);
465 void visitInsertValueInst(InsertValueInst &IVI);
466 void visitEHPadPredecessors(Instruction &
I);
467 void visitLandingPadInst(LandingPadInst &LPI);
468 void visitResumeInst(ResumeInst &RI);
469 void visitCatchPadInst(CatchPadInst &CPI);
470 void visitCatchReturnInst(CatchReturnInst &CatchReturn);
471 void visitCleanupPadInst(CleanupPadInst &CPI);
472 void visitFuncletPadInst(FuncletPadInst &FPI);
473 void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch);
474 void visitCleanupReturnInst(CleanupReturnInst &CRI);
476 void verifySwiftErrorCall(CallBase &
Call,
const Value *SwiftErrorVal);
477 void verifySwiftErrorValue(
const Value *SwiftErrorVal);
478 void verifyTailCCMustTailAttrs(
const AttrBuilder &Attrs, StringRef
Context);
479 void verifyMustTailCall(CallInst &CI);
480 bool verifyAttributeCount(AttributeList Attrs,
unsigned Params);
481 void verifyAttributeTypes(AttributeSet Attrs,
const Value *
V);
482 void verifyParameterAttrs(AttributeSet Attrs,
Type *Ty,
const Value *
V);
483 void checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
485 void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
486 const Value *
V,
bool IsIntrinsic,
bool IsInlineAsm);
487 void verifyFunctionMetadata(
ArrayRef<std::pair<unsigned, MDNode *>> MDs);
488 void verifyUnknownProfileMetadata(MDNode *MD);
489 void visitConstantExprsRecursively(
const Constant *EntryC);
490 void visitConstantExpr(
const ConstantExpr *CE);
491 void visitConstantPtrAuth(
const ConstantPtrAuth *CPA);
492 void verifyInlineAsmCall(
const CallBase &
Call);
493 void verifyStatepoint(
const CallBase &
Call);
494 void verifyFrameRecoverIndices();
495 void verifySiblingFuncletUnwinds();
497 void verifyFragmentExpression(
const DbgVariableRecord &
I);
498 template <
typename ValueOrMetadata>
499 void verifyFragmentExpression(
const DIVariable &
V,
501 ValueOrMetadata *
Desc);
502 void verifyFnArgs(
const DbgVariableRecord &DVR);
503 void verifyNotEntryValue(
const DbgVariableRecord &
I);
506 void verifyCompileUnits();
510 void verifyDeoptimizeCallingConvs();
512 void verifyAttachedCallBundle(
const CallBase &
Call,
513 const OperandBundleUse &BU);
516 void verifyNoAliasScopeDecl();
522#define Check(C, ...) \
525 CheckFailed(__VA_ARGS__); \
532#define CheckDI(C, ...) \
535 DebugInfoCheckFailed(__VA_ARGS__); \
541 if (!
I.getDbgMarker())
543 CheckDI(
I.getDbgMarker()->MarkedInstr == &
I,
544 "Instruction has invalid DebugMarker", &
I);
546 "PHI Node must not have any attached DbgRecords", &
I);
548 CheckDI(DR.getMarker() ==
I.getDbgMarker(),
549 "DbgRecord had invalid DebugMarker", &
I, &DR);
552 visitMDNode(*
Loc, AreDebugLocsAllowed::Yes);
557 verifyFragmentExpression(*DVR);
558 verifyNotEntryValue(*DVR);
565void Verifier::visit(Instruction &
I) {
567 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
568 Check(
I.getOperand(i) !=
nullptr,
"Operand is null", &
I);
580 while (!WorkList.
empty()) {
582 if (!Visited.
insert(Cur).second)
589void Verifier::visitGlobalValue(
const GlobalValue &GV) {
591 "Global is external, but doesn't have external or weak linkage!", &GV);
594 if (
const MDNode *Associated =
595 GO->getMetadata(LLVMContext::MD_associated)) {
596 Check(Associated->getNumOperands() == 1,
597 "associated metadata must have one operand", &GV, Associated);
598 const Metadata *
Op = Associated->getOperand(0).get();
599 Check(
Op,
"associated metadata must have a global value", GO, Associated);
602 Check(VM,
"associated metadata must be ValueAsMetadata", GO, Associated);
605 "associated value must be pointer typed", GV, Associated);
607 const Value *Stripped = VM->getValue()->stripPointerCastsAndAliases();
609 "associated metadata must point to a GlobalObject", GO, Stripped);
610 Check(Stripped != GO,
611 "global values should not associate to themselves", GO,
617 if (
const MDNode *AbsoluteSymbol =
618 GO->getMetadata(LLVMContext::MD_absolute_symbol)) {
619 verifyRangeLikeMetadata(*GO, AbsoluteSymbol,
620 DL.getIntPtrType(GO->getType()),
621 RangeLikeMetadataKind::AbsoluteSymbol);
624 if (GO->hasMetadata(LLVMContext::MD_implicit_ref)) {
625 Check(!GO->isDeclaration(),
626 "ref metadata must not be placed on a declaration", GO);
629 GO->getMetadata(LLVMContext::MD_implicit_ref, MDs);
630 for (
const MDNode *MD : MDs) {
631 Check(MD->getNumOperands() == 1,
"ref metadata must have one operand",
635 Check(VM,
"ref metadata must be ValueAsMetadata", GO, MD);
638 "ref value must be pointer typed", GV, MD);
642 "ref metadata must point to a GlobalObject", GO, Stripped);
643 Check(Stripped != GO,
"values should not reference themselves", GO,
649 if (
auto *Props = GO->getMetadata(LLVMContext::MD_elf_section_properties)) {
650 Check(Props->getNumOperands() == 2,
651 "elf_section_properties metadata must have two operands", GO,
653 if (Props->getNumOperands() == 2) {
655 Check(
Type,
"type field must be ConstantAsMetadata", GO, Props);
657 Check(TypeInt,
"type field must be ConstantInt", GO, Props);
660 Check(Entsize,
"entsize field must be ConstantAsMetadata", GO, Props);
662 Check(EntsizeInt,
"entsize field must be ConstantInt", GO, Props);
668 "Only global variables can have appending linkage!", &GV);
672 Check(GVar && GVar->getValueType()->isArrayTy(),
673 "Only global arrays can have appending linkage!", GVar);
677 Check(!GV.
hasComdat(),
"Declaration may not be in a Comdat!", &GV);
681 "dllexport GlobalValue must have default or protected visibility",
686 "dllimport GlobalValue must have default visibility", &GV);
687 Check(!GV.
isDSOLocal(),
"GlobalValue with DLLImport Storage is dso_local!",
693 "Global is marked as dllimport, but not external", &GV);
698 "GlobalValue with local linkage or non-default "
699 "visibility must be dso_local!",
707 "Global is used by a constant but is not marked as possibly having "
713 if (!
I->getParent() || !
I->getParent()->getParent())
714 CheckFailed(
"Global is referenced by parentless instruction!", &GV, &M,
716 else if (
I->getParent()->getParent()->getParent() != &M)
717 CheckFailed(
"Global is referenced in a different module!", &GV, &M,
I,
718 I->getParent()->getParent(),
719 I->getParent()->getParent()->getParent());
722 if (
F->getParent() != &M)
723 CheckFailed(
"Global is used by function in a different module", &GV, &M,
731void Verifier::visitGlobalVariable(
const GlobalVariable &GV) {
739 Check(
A->value() <= Value::MaximumAlignment,
740 "huge alignment values are unsupported", &GV);
745 "Global variable initializer type does not match global "
749 "Global variable initializer must be sized", &GV);
755 "'common' global must have a zero initializer!", &GV);
758 Check(!GV.
hasComdat(),
"'common' global may not be in a Comdat!", &GV);
763 GV.
getName() ==
"llvm.global_dtors")) {
765 "invalid linkage for intrinsic global variable", &GV);
767 "invalid uses of intrinsic global variable", &GV);
774 PointerType::get(
Context,
DL.getProgramAddressSpace());
775 Check(STy && (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
776 STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
777 STy->getTypeAtIndex(1) == FuncPtrTy,
778 "wrong type for intrinsic global variable", &GV);
779 Check(STy->getNumElements() == 3,
780 "the third field of the element type is mandatory, "
781 "specify ptr null to migrate from the obsoleted 2-field form");
782 Type *ETy = STy->getTypeAtIndex(2);
791 for (
const Use &U : Init->operands()) {
793 if (!Structor || Structor->getNumOperands() != 3)
796 "signing of ctors/dtors should be requested via module flags");
802 GV.
getName() ==
"llvm.compiler.used")) {
804 "invalid linkage for intrinsic global variable", &GV);
806 "invalid uses of intrinsic global variable", &GV);
810 Check(PTy,
"wrong type for intrinsic global variable", &GV);
814 Check(InitArray,
"wrong initializer for intrinsic global variable",
816 for (
Value *
Op : InitArray->operands()) {
820 Twine(
"invalid ") + GV.
getName() +
" member",
V);
822 Twine(
"members of ") + GV.
getName() +
" must be named",
V);
831 for (MDNode *MD : MDs) {
833 visitDIGlobalVariableExpression(*GVE);
835 CheckDI(
false,
"!dbg attachment of global variable must be a "
836 "DIGlobalVariableExpression");
846 "Global @" + GV.
getName() +
" has illegal target extension type",
855 "Global variable is too large to fit into the address space", &GV,
859 visitGlobalValue(GV);
866 visitGlobalValue(GV);
869void Verifier::visitAliaseeSubExpr(
const GlobalAlias &GA,
const Constant &
C) {
870 SmallPtrSet<const GlobalAlias*, 4> Visited;
872 visitAliaseeSubExpr(Visited, GA,
C);
875void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
876 const GlobalAlias &GA,
const Constant &
C) {
880 "available_externally alias must point to available_externally "
891 Check(Visited.
insert(GA2).second,
"Aliases cannot form a cycle", &GA);
893 Check(!GA2->isInterposable(),
894 "Alias cannot point to an interposable alias", &GA);
903 visitConstantExprsRecursively(CE);
905 for (
const Use &U :
C.operands()) {
908 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
910 visitAliaseeSubExpr(Visited, GA, *C2);
914void Verifier::visitGlobalAlias(
const GlobalAlias &GA) {
916 "Alias should have private, internal, linkonce, weak, linkonce_odr, "
917 "weak_odr, external, or available_externally linkage!",
920 Check(Aliasee,
"Aliasee cannot be NULL!", &GA);
922 "Alias and aliasee types should match!", &GA);
925 "Aliasee should be either GlobalValue or ConstantExpr", &GA);
927 visitAliaseeSubExpr(GA, *Aliasee);
929 visitGlobalValue(GA);
932void Verifier::visitGlobalIFunc(
const GlobalIFunc &GI) {
933 visitGlobalValue(GI);
937 for (
const auto &
I : MDs) {
938 CheckDI(
I.first != LLVMContext::MD_dbg,
939 "an ifunc may not have a !dbg attachment", &GI);
940 Check(
I.first != LLVMContext::MD_prof,
941 "an ifunc may not have a !prof attachment", &GI);
942 visitMDNode(*
I.second, AreDebugLocsAllowed::No);
946 "IFunc should have private, internal, linkonce, weak, linkonce_odr, "
947 "weak_odr, or external linkage!",
952 Check(Resolver,
"IFunc must have a Function resolver", &GI);
954 "IFunc resolver must be a definition", &GI);
961 "IFunc resolver must return a pointer", &GI);
964 "IFunc resolver has incorrect type", &GI);
967void Verifier::visitNamedMDNode(
const NamedMDNode &NMD) {
972 "unrecognized named metadata node in the llvm.dbg namespace", &NMD);
973 for (
const MDNode *MD : NMD.
operands()) {
974 if (NMD.
getName() ==
"llvm.dbg.cu")
980 visitMDNode(*MD, AreDebugLocsAllowed::Yes);
991 return T->getRawScope();
993 return SP->getRawScope();
995 return LB->getRawScope();
997 return NS->getRawScope();
999 return CB->getRawScope();
1001 return M->getRawScope();
1006bool Verifier::hasDIScopeCycle(
const Metadata *S) {
1007 SmallPtrSet<const Metadata *, 8> Seen;
1008 auto CacheSeen = [&](
bool HasCycle) {
1010 DIScopeChainReachesCycle[
M] = HasCycle;
1015 auto It = DIScopeChainReachesCycle.
find(Scope);
1016 bool IsInCache = It != DIScopeChainReachesCycle.
end();
1018 return CacheSeen(It->second);
1019 bool AlreadySeen = !Seen.
insert(Scope).second;
1021 return CacheSeen(
true);
1027 return CacheSeen(
false);
1030void Verifier::visitDIScopeChain(
const DIScope &
N) {
1031 CheckDI(!hasDIScopeCycle(&
N),
"DIScope scope chain must not contain a cycle",
1035void Verifier::visitMDNode(
const MDNode &BaseMD,
1036 AreDebugLocsAllowed AllowLocs) {
1039 if (!MDNodes.
insert(&BaseMD).second)
1042 std::queue<const MDNode *> Worklist;
1043 Worklist.push(&BaseMD);
1045 while (!Worklist.empty()) {
1046 const MDNode *CurrentMD = Worklist.front();
1049 "MDNode context does not match Module context!", CurrentMD);
1054 case Metadata::MDTupleKind:
1056#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
1057 case Metadata::CLASS##Kind: \
1058 visit##CLASS(cast<CLASS>(*CurrentMD)); \
1060#include "llvm/IR/Metadata.def"
1065 visitDIScopeChain(*S);
1073 "DILocation not allowed within this metadata node", CurrentMD,
1081 visitValueAsMetadata(*
V,
nullptr);
1102 "Expected second operand to be an integer constant of type i32 or "
1114 Check(AlignMD && AlignMD->getType()->isIntegerTy(32),
1115 "Expected the alignment to be an integer constant of type i32",
1120 "Expected the alignment to be a power of two", CurrentMD);
1121 Check(Align <= Value::MaximumAlignment,
1122 "Alignment is larger than the implementation defined limit",
1134 "Expecting only the metadata name", CurrentMD);
1139 Check(CurrentMD->
isResolved(),
"All nodes should be resolved!", CurrentMD);
1143void Verifier::visitValueAsMetadata(
const ValueAsMetadata &MD,
Function *
F) {
1146 "Unexpected metadata round-trip through values", &MD, MD.
getValue());
1152 Check(
F,
"function-local metadata used outside a function", L);
1158 Check(
I->getParent(),
"function-local metadata not in basic block", L,
I);
1165 assert(ActualF &&
"Unimplemented function local metadata case!");
1167 Check(ActualF ==
F,
"function-local metadata used in wrong function", L);
1170void Verifier::visitDIArgList(
const DIArgList &AL,
Function *
F) {
1171 for (
const ValueAsMetadata *VAM :
AL.getArgs())
1172 visitValueAsMetadata(*VAM,
F);
1175void Verifier::visitMetadataAsValue(
const MetadataAsValue &MDV,
Function *
F) {
1178 visitMDNode(*
N, AreDebugLocsAllowed::No);
1184 if (!MDNodes.
insert(MD).second)
1188 visitValueAsMetadata(*
V,
F);
1191 visitDIArgList(*AL,
F);
1199void Verifier::visitDILocation(
const DILocation &
N) {
1201 "location requires a valid scope", &
N,
N.getRawScope());
1202 if (
auto *IA =
N.getRawInlinedAt())
1205 CheckDI(
SP->isDefinition(),
"scope points into the type hierarchy", &
N);
1206 if (
auto *L =
N.getRawIRLayers())
1210void Verifier::visitDILayerLoc(
const DILayerLoc &
N) {
1212 "layer kind must be a non-null MDString", &
N,
N.getRawKind());
1214 "layer file must be a non-null DIFile", &
N,
N.getRawFile());
1217void Verifier::visitDILayerLocList(
const DILayerLocList &
N) {
1218 CheckDI(
N.getNumLayers() > 0,
"DILayerLocList must be non-empty", &
N);
1219 for (
const MDOperand &
Op :
N.layers())
1221 "DILayerLocList entry must be a DILayerLoc", &
N,
Op.get());
1224void Verifier::visitGenericDINode(
const GenericDINode &
N) {
1228void Verifier::visitDIScope(
const DIScope &
N) {
1229 if (
auto *
F =
N.getRawFile())
1233void Verifier::visitDIType(
const DIType &
N) {
1236 CheckDI(
N.getRawFile() ||
N.getLine() == 0,
"line specified with no file", &
N,
1240void Verifier::visitDISubrangeType(
const DISubrangeType &
N) {
1243 CheckDI(
N.getTag() == dwarf::DW_TAG_subrange_type,
"invalid tag", &
N);
1246 auto *LBound =
N.getRawLowerBound();
1250 "LowerBound must be signed constant or DIVariable or DIExpression or "
1253 auto *UBound =
N.getRawUpperBound();
1257 "UpperBound must be signed constant or DIVariable or DIExpression or "
1260 auto *Stride =
N.getRawStride();
1263 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1264 auto *Bias =
N.getRawBias();
1267 "Bias must be signed constant or DIVariable or DIExpression", &
N);
1269 auto *
Size =
N.getRawSizeInBits();
1271 "SizeInBits must be a constant");
1274void Verifier::visitDISubrange(
const DISubrange &
N) {
1275 CheckDI(
N.getTag() == dwarf::DW_TAG_subrange_type,
"invalid tag", &
N);
1276 CheckDI(!
N.getRawCountNode() || !
N.getRawUpperBound(),
1277 "Subrange can have any one of count or upperBound", &
N);
1278 auto *CBound =
N.getRawCountNode();
1281 "Count must be signed constant or DIVariable or DIExpression", &
N);
1282 auto Count =
N.getCount();
1285 "invalid subrange count", &
N);
1286 auto *LBound =
N.getRawLowerBound();
1289 "LowerBound must be signed constant or DIVariable or DIExpression",
1291 auto *UBound =
N.getRawUpperBound();
1294 "UpperBound must be signed constant or DIVariable or DIExpression",
1296 auto *Stride =
N.getRawStride();
1299 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1302void Verifier::visitDIGenericSubrange(
const DIGenericSubrange &
N) {
1303 CheckDI(
N.getTag() == dwarf::DW_TAG_generic_subrange,
"invalid tag", &
N);
1304 CheckDI(!
N.getRawCountNode() || !
N.getRawUpperBound(),
1305 "GenericSubrange can have any one of count or upperBound", &
N);
1306 auto *CBound =
N.getRawCountNode();
1308 "Count must be signed constant or DIVariable or DIExpression", &
N);
1309 auto *LBound =
N.getRawLowerBound();
1310 CheckDI(LBound,
"GenericSubrange must contain lowerBound", &
N);
1312 "LowerBound must be signed constant or DIVariable or DIExpression",
1314 auto *UBound =
N.getRawUpperBound();
1316 "UpperBound must be signed constant or DIVariable or DIExpression",
1318 auto *Stride =
N.getRawStride();
1319 CheckDI(Stride,
"GenericSubrange must contain stride", &
N);
1321 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1324void Verifier::visitDIEnumerator(
const DIEnumerator &
N) {
1325 CheckDI(
N.getTag() == dwarf::DW_TAG_enumerator,
"invalid tag", &
N);
1328void Verifier::visitDIBasicType(
const DIBasicType &
N) {
1331 CheckDI(
N.getTag() == dwarf::DW_TAG_base_type ||
1332 N.getTag() == dwarf::DW_TAG_unspecified_type ||
1333 N.getTag() == dwarf::DW_TAG_string_type,
1336 auto *
Size =
N.getRawSizeInBits();
1338 "SizeInBits must be a constant");
1341void Verifier::visitDIFixedPointType(
const DIFixedPointType &
N) {
1342 visitDIBasicType(
N);
1344 CheckDI(
N.getTag() == dwarf::DW_TAG_base_type,
"invalid tag", &
N);
1345 CheckDI(
N.getEncoding() == dwarf::DW_ATE_signed_fixed ||
1346 N.getEncoding() == dwarf::DW_ATE_unsigned_fixed,
1347 "invalid encoding", &
N);
1351 "invalid kind", &
N);
1353 N.getFactorRaw() == 0,
1354 "factor should be 0 for rationals", &
N);
1356 (
N.getNumeratorRaw() == 0 &&
N.getDenominatorRaw() == 0),
1357 "numerator and denominator should be 0 for non-rationals", &
N);
1360void Verifier::visitDIStringType(
const DIStringType &
N) {
1363 CheckDI(
N.getTag() == dwarf::DW_TAG_string_type,
"invalid tag", &
N);
1364 CheckDI(!(
N.isBigEndian() &&
N.isLittleEndian()),
"has conflicting flags",
1366 if (
N.getRawCharType())
1368 N.getRawCharType());
1371void Verifier::visitDIDerivedType(
const DIDerivedType &
N) {
1375 CheckDI(
N.getTag() == dwarf::DW_TAG_typedef ||
1376 N.getTag() == dwarf::DW_TAG_pointer_type ||
1377 N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
1378 N.getTag() == dwarf::DW_TAG_reference_type ||
1379 N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
1380 N.getTag() == dwarf::DW_TAG_const_type ||
1381 N.getTag() == dwarf::DW_TAG_immutable_type ||
1382 N.getTag() == dwarf::DW_TAG_volatile_type ||
1383 N.getTag() == dwarf::DW_TAG_restrict_type ||
1384 N.getTag() == dwarf::DW_TAG_atomic_type ||
1385 N.getTag() == dwarf::DW_TAG_LLVM_ptrauth_type ||
1386 N.getTag() == dwarf::DW_TAG_member ||
1387 (
N.getTag() == dwarf::DW_TAG_variable &&
N.isStaticMember()) ||
1388 N.getTag() == dwarf::DW_TAG_inheritance ||
1389 N.getTag() == dwarf::DW_TAG_friend ||
1390 N.getTag() == dwarf::DW_TAG_set_type ||
1391 N.getTag() == dwarf::DW_TAG_template_alias,
1393 if (
N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
1394 CheckDI(
isType(
N.getRawExtraData()),
"invalid pointer to member type", &
N,
1395 N.getRawExtraData());
1396 }
else if (
N.getTag() == dwarf::DW_TAG_template_alias) {
1398 N.getRawExtraData());
1399 }
else if (
N.getTag() == dwarf::DW_TAG_inheritance ||
1400 N.getTag() == dwarf::DW_TAG_member ||
1401 N.getTag() == dwarf::DW_TAG_variable) {
1402 auto *ExtraData =
N.getRawExtraData();
1403 auto IsValidExtraData = [&]() {
1404 if (ExtraData ==
nullptr)
1410 if (
Tuple->getNumOperands() != 1)
1417 "extraData must be ConstantAsMetadata, MDString, DIObjCProperty, "
1418 "or MDTuple with single ConstantAsMetadata operand",
1422 if (
N.getTag() == dwarf::DW_TAG_set_type) {
1423 if (
auto *
T =
N.getRawBaseType()) {
1428 (Enum &&
Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||
1429 (Subrange &&
Subrange->getTag() == dwarf::DW_TAG_subrange_type) ||
1430 (
Basic && (
Basic->getEncoding() == dwarf::DW_ATE_unsigned ||
1431 Basic->getEncoding() == dwarf::DW_ATE_signed ||
1432 Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||
1433 Basic->getEncoding() == dwarf::DW_ATE_signed_char ||
1434 Basic->getEncoding() == dwarf::DW_ATE_boolean)),
1435 "invalid set base type", &
N,
T);
1440 N.getRawBaseType());
1442 if (
N.getDWARFAddressSpace()) {
1443 CheckDI(
N.getTag() == dwarf::DW_TAG_pointer_type ||
1444 N.getTag() == dwarf::DW_TAG_reference_type ||
1445 N.getTag() == dwarf::DW_TAG_rvalue_reference_type,
1446 "DWARF address space only applies to pointer or reference types",
1450 auto *
Size =
N.getRawSizeInBits();
1453 "SizeInBits must be a constant or DIVariable or DIExpression");
1458 return ((Flags & DINode::FlagLValueReference) &&
1459 (Flags & DINode::FlagRValueReference)) ||
1460 ((Flags & DINode::FlagTypePassByValue) &&
1461 (Flags & DINode::FlagTypePassByReference));
1464void Verifier::visitTemplateParams(
const MDNode &
N,
const Metadata &RawParams) {
1466 CheckDI(Params,
"invalid template params", &
N, &RawParams);
1473void Verifier::visitDICompositeType(
const DICompositeType &
N) {
1477 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type ||
1478 N.getTag() == dwarf::DW_TAG_structure_type ||
1479 N.getTag() == dwarf::DW_TAG_union_type ||
1480 N.getTag() == dwarf::DW_TAG_enumeration_type ||
1481 N.getTag() == dwarf::DW_TAG_class_type ||
1482 N.getTag() == dwarf::DW_TAG_variant_part ||
1483 N.getTag() == dwarf::DW_TAG_variant ||
1484 N.getTag() == dwarf::DW_TAG_namelist,
1488 N.getRawBaseType());
1491 "invalid composite elements", &
N,
N.getRawElements());
1493 N.getRawVTableHolder());
1495 "invalid reference flags", &
N);
1496 unsigned DIBlockByRefStruct = 1 << 4;
1497 CheckDI((
N.getFlags() & DIBlockByRefStruct) == 0,
1498 "DIBlockByRefStruct on DICompositeType is no longer supported", &
N);
1500 "DISubprogram contains null entry in `elements` field", &
N);
1503 const DINodeArray
Elements =
N.getElements();
1505 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,
1506 "invalid vector, expected one element of type subrange", &
N);
1509 if (
auto *Params =
N.getRawTemplateParams())
1510 visitTemplateParams(
N, *Params);
1512 if (
auto *
D =
N.getRawDiscriminator()) {
1514 "discriminator can only appear on variant part");
1517 if (
N.getRawDataLocation()) {
1518 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1519 "dataLocation can only appear in array type");
1522 if (
N.getRawAssociated()) {
1523 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1524 "associated can only appear in array type");
1527 if (
N.getRawAllocated()) {
1528 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1529 "allocated can only appear in array type");
1532 if (
N.getRawRank()) {
1533 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1534 "rank can only appear in array type");
1537 if (
N.getTag() == dwarf::DW_TAG_array_type) {
1538 CheckDI(
N.getRawBaseType(),
"array types must have a base type", &
N);
1541 auto *
Size =
N.getRawSizeInBits();
1544 "SizeInBits must be a constant or DIVariable or DIExpression");
1547void Verifier::visitDISubroutineType(
const DISubroutineType &
N) {
1549 CheckDI(
N.getTag() == dwarf::DW_TAG_subroutine_type,
"invalid tag", &
N);
1550 if (
auto *Types =
N.getRawTypeArray()) {
1552 for (
Metadata *Ty :
N.getTypeArray()->operands()) {
1553 CheckDI(
isType(Ty),
"invalid subroutine type ref", &
N, Types, Ty);
1557 "invalid reference flags", &
N);
1560void Verifier::visitDIFile(
const DIFile &
N) {
1561 CheckDI(
N.getTag() == dwarf::DW_TAG_file_type,
"invalid tag", &
N);
1562 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum =
N.getChecksum();
1564 CheckDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,
1565 "invalid checksum kind", &
N);
1567 switch (Checksum->Kind) {
1578 CheckDI(Checksum->Value.size() ==
Size,
"invalid checksum length", &
N);
1580 "invalid checksum", &
N);
1584void Verifier::visitDICompileUnit(
const DICompileUnit &
N) {
1585 CheckDI(
N.isDistinct(),
"compile units must be distinct", &
N);
1586 CheckDI(
N.getTag() == dwarf::DW_TAG_compile_unit,
"invalid tag", &
N);
1592 CheckDI(!
N.getFile()->getFilename().empty(),
"invalid filename", &
N,
1596 "invalid emission kind", &
N);
1599 "invalid language dialect", &
N);
1601 if (
auto *Array =
N.getRawEnumTypes()) {
1603 for (
Metadata *
Op :
N.getEnumTypes()->operands()) {
1605 CheckDI(Enum &&
Enum->getTag() == dwarf::DW_TAG_enumeration_type,
1606 "invalid enum type", &
N,
N.getEnumTypes(),
Op);
1608 "function-local enum in a DICompileUnit's enum list", &
N,
1609 N.getEnumTypes(),
Op);
1612 if (
auto *Array =
N.getRawRetainedTypes()) {
1614 for (
Metadata *
Op :
N.getRetainedTypes()->operands()) {
1618 "invalid retained type", &
N,
Op);
1621 if (
auto *Array =
N.getRawGlobalVariables()) {
1623 for (
Metadata *
Op :
N.getGlobalVariables()->operands()) {
1625 CheckDI(GVE,
"invalid global variable ref", &
N,
Op);
1627 "function-local variables are not allowed in a DICompileUnit's "
1628 "global variables list",
1632 if (
auto *Array =
N.getRawImportedEntities()) {
1634 for (
Metadata *
Op :
N.getImportedEntities()->operands()) {
1636 CheckDI(IE,
"invalid imported entity ref", &
N,
Op);
1638 "function-local imports are not allowed in a DICompileUnit's "
1639 "imported entities list",
1643 if (
auto *Array =
N.getRawMacros()) {
1652void Verifier::visitDISubprogram(
const DISubprogram &
N) {
1653 CheckDI(
N.getTag() == dwarf::DW_TAG_subprogram,
"invalid tag", &
N);
1655 if (
auto *
F =
N.getRawFile())
1658 CheckDI(
N.getLine() == 0,
"line specified with no file", &
N,
N.getLine());
1659 auto *
T =
N.getRawType();
1660 CheckDI(
T,
"DISubprogram requires a non-null type", &
N);
1662 CheckDI(
isType(
N.getRawContainingType()),
"invalid containing type", &
N,
1663 N.getRawContainingType());
1664 if (
auto *Params =
N.getRawTemplateParams())
1665 visitTemplateParams(
N, *Params);
1666 if (
auto *S =
N.getRawDeclaration())
1668 "invalid subprogram declaration", &
N, S);
1669 if (
auto *RawNode =
N.getRawRetainedNodes()) {
1671 CheckDI(Node,
"invalid retained nodes list", &
N, RawNode);
1673 DenseMap<unsigned, DILocalVariable *>
Args;
1675 CheckDI(
Op,
"nullptr in retained nodes", &
N, Node);
1679 bool IsTypeCorrect = DISubprogram::visitRetainedNode<bool>(
1682 "invalid retained nodes, expected DILocalVariable, DILabel, "
1683 "DIImportedEntity, DIType or DIGlobalVariableExpression",
1690 "invalid retained nodes, retained node is not local", &
N, Node,
1693 DISubprogram *RetainedNodeSP =
getSubprogram(RetainedNodeScope);
1694 DICompileUnit *RetainedNodeUnit =
1695 RetainedNodeSP ? RetainedNodeSP->getUnit() :
nullptr;
1697 RetainedNodeSP == &
N,
1698 "invalid retained nodes, retained node does not belong to subprogram",
1699 &
N, Node, RetainedNode, RetainedNodeScope, RetainedNodeSP,
1705 if (
unsigned ArgNum = DV->getArg()) {
1707 CheckDI(Inserted || DV == ArgI->second,
1708 "invalid retained nodes, more than one local variable with the "
1709 "same argument index",
1710 &
N,
N.getUnit(), Node, RetainedNode, Args[ArgNum]);
1715 "invalid reference flags", &
N);
1717 auto *
Unit =
N.getRawUnit();
1718 if (
N.isDefinition()) {
1720 CheckDI(
N.isDistinct(),
"subprogram definitions must be distinct", &
N);
1721 CheckDI(Unit,
"subprogram definitions must have a compile unit", &
N);
1726 if (CT && CT->getRawIdentifier() &&
1727 M.getContext().isODRUniquingDebugTypes())
1729 "definition subprograms cannot be nested within DICompositeType "
1730 "when enabling ODR",
1734 CheckDI(!Unit,
"subprogram declarations must not have a compile unit", &
N);
1736 "subprogram declaration must not have a declaration field");
1739 if (
auto *RawThrownTypes =
N.getRawThrownTypes()) {
1741 CheckDI(ThrownTypes,
"invalid thrown types list", &
N, RawThrownTypes);
1747 if (
N.areAllCallsDescribed())
1749 "DIFlagAllCallsDescribed must be attached to a definition");
1752void Verifier::visitDILexicalBlockBase(
const DILexicalBlockBase &
N) {
1753 CheckDI(
N.getTag() == dwarf::DW_TAG_lexical_block,
"invalid tag", &
N);
1755 "invalid local scope", &
N,
N.getRawScope());
1757 CheckDI(
SP->isDefinition(),
"scope points into the type hierarchy", &
N);
1760void Verifier::visitDILexicalBlock(
const DILexicalBlock &
N) {
1761 visitDILexicalBlockBase(
N);
1764 "cannot have column info without line info", &
N);
1767void Verifier::visitDILexicalBlockFile(
const DILexicalBlockFile &
N) {
1768 visitDILexicalBlockBase(
N);
1771void Verifier::visitDICommonBlock(
const DICommonBlock &
N) {
1772 CheckDI(
N.getTag() == dwarf::DW_TAG_common_block,
"invalid tag", &
N);
1773 if (
auto *S =
N.getRawScope())
1775 if (
auto *S =
N.getRawDecl())
1779void Verifier::visitDINamespace(
const DINamespace &
N) {
1780 CheckDI(
N.getTag() == dwarf::DW_TAG_namespace,
"invalid tag", &
N);
1781 if (
auto *S =
N.getRawScope())
1785void Verifier::visitDIMacro(
const DIMacro &
N) {
1788 "invalid macinfo type", &
N);
1789 CheckDI(!
N.getName().empty(),
"anonymous macro", &
N);
1790 if (!
N.getValue().empty()) {
1791 assert(
N.getValue().data()[0] !=
' ' &&
"Macro value has a space prefix");
1795void Verifier::visitDIMacroFile(
const DIMacroFile &
N) {
1797 "invalid macinfo type", &
N);
1798 if (
auto *
F =
N.getRawFile())
1801 if (
auto *Array =
N.getRawElements()) {
1803 for (
Metadata *
Op :
N.getElements()->operands()) {
1809void Verifier::visitDIModule(
const DIModule &
N) {
1810 CheckDI(
N.getTag() == dwarf::DW_TAG_module,
"invalid tag", &
N);
1811 CheckDI(!
N.getName().empty(),
"anonymous module", &
N);
1814void Verifier::visitDITemplateParameter(
const DITemplateParameter &
N) {
1818void Verifier::visitDITemplateTypeParameter(
const DITemplateTypeParameter &
N) {
1819 visitDITemplateParameter(
N);
1821 CheckDI(
N.getTag() == dwarf::DW_TAG_template_type_parameter,
"invalid tag",
1825void Verifier::visitDITemplateValueParameter(
1826 const DITemplateValueParameter &
N) {
1827 visitDITemplateParameter(
N);
1829 CheckDI(
N.getTag() == dwarf::DW_TAG_template_value_parameter ||
1830 N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
1831 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
1835void Verifier::visitDIVariable(
const DIVariable &
N) {
1836 if (
auto *S =
N.getRawScope())
1838 if (
auto *
F =
N.getRawFile())
1842void Verifier::visitDIGlobalVariable(
const DIGlobalVariable &
N) {
1846 CheckDI(
N.getTag() == dwarf::DW_TAG_variable,
"invalid tag", &
N);
1849 if (
N.isDefinition())
1850 CheckDI(
N.getType(),
"missing global variable type", &
N);
1851 if (
auto *Member =
N.getRawStaticDataMemberDeclaration()) {
1853 "invalid static data member declaration", &
N, Member);
1857void Verifier::visitDILocalVariable(
const DILocalVariable &
N) {
1862 CheckDI(
N.getTag() == dwarf::DW_TAG_variable,
"invalid tag", &
N);
1864 "local variable requires a valid scope", &
N,
N.getRawScope());
1865 if (
auto Ty =
N.getType())
1869void Verifier::visitDIAssignID(
const DIAssignID &
N) {
1870 CheckDI(!
N.getNumOperands(),
"DIAssignID has no arguments", &
N);
1871 CheckDI(
N.isDistinct(),
"DIAssignID must be distinct", &
N);
1874void Verifier::visitDILabel(
const DILabel &
N) {
1875 if (
auto *S =
N.getRawScope())
1877 if (
auto *
F =
N.getRawFile())
1880 CheckDI(
N.getTag() == dwarf::DW_TAG_label,
"invalid tag", &
N);
1882 "label requires a valid scope", &
N,
N.getRawScope());
1885void Verifier::visitDIExpression(
const DIExpression &
N) {
1886 CheckDI(
N.isValid(),
"invalid expression", &
N);
1889void Verifier::visitDIGlobalVariableExpression(
1890 const DIGlobalVariableExpression &GVE) {
1893 visitDIGlobalVariable(*Var);
1895 visitDIExpression(*Expr);
1896 if (
auto Fragment = Expr->getFragmentInfo())
1901void Verifier::visitDIObjCProperty(
const DIObjCProperty &
N) {
1902 CheckDI(
N.getTag() == dwarf::DW_TAG_APPLE_property,
"invalid tag", &
N);
1903 if (
auto *
T =
N.getRawType())
1905 if (
auto *
F =
N.getRawFile())
1909void Verifier::visitDIProperty(
const DIProperty &
N) {
1910 CheckDI(
N.getTag() == dwarf::DW_TAG_property,
"invalid tag", &
N);
1911 if (
auto *
T =
N.getRawType())
1913 if (
auto *
F =
N.getRawFile())
1917 if (DINode *BackingStorage =
N.getBackingStorage()) {
1919 CheckDI(DT && DT->getTag() == dwarf::DW_TAG_member,
1920 "property backing storage must be a member", &
N, BackingStorage);
1924void Verifier::visitDIImportedEntity(
const DIImportedEntity &
N) {
1925 CheckDI(
N.getTag() == dwarf::DW_TAG_imported_module ||
1926 N.getTag() == dwarf::DW_TAG_imported_declaration,
1928 if (
auto *S =
N.getRawScope())
1934void Verifier::visitComdat(
const Comdat &
C) {
1939 if (
TT.isOSBinFormatCOFF()) {
1940 const GlobalValue *GV =
M.getNamedValue(
C.getName());
1946 Check(
C.getUsers().empty(),
1947 "COFF comdats must have a defined global value with the same name",
1952void Verifier::visitModuleIdents() {
1953 const NamedMDNode *Idents =
M.getNamedMetadata(
"llvm.ident");
1959 for (
const MDNode *
N : Idents->
operands()) {
1960 Check(
N->getNumOperands() == 1,
1961 "incorrect number of operands in llvm.ident metadata",
N);
1963 (
"invalid value for llvm.ident metadata entry operand"
1964 "(the operand should be a string)"),
1969void Verifier::visitModuleCommandLines() {
1970 const NamedMDNode *CommandLines =
M.getNamedMetadata(
"llvm.commandline");
1977 for (
const MDNode *
N : CommandLines->
operands()) {
1978 Check(
N->getNumOperands() == 1,
1979 "incorrect number of operands in llvm.commandline metadata",
N);
1981 (
"invalid value for llvm.commandline metadata entry operand"
1982 "(the operand should be a string)"),
1987void Verifier::visitModuleErrnoTBAA() {
1988 const NamedMDNode *ErrnoTBAA =
M.getNamedMetadata(
"llvm.errno.tbaa");
1993 "llvm.errno.tbaa must have at least one operand", ErrnoTBAA);
1995 for (
const MDNode *
N : ErrnoTBAA->
operands())
1999void Verifier::visitModuleRawSections() {
2000 const NamedMDNode *RawSections =
M.getNamedMetadata(
"llvm.raw.sections");
2004 for (
const MDNode *
N : RawSections->
operands()) {
2005 if (
N->getNumOperands() != 4) {
2006 CheckFailed(
"llvm.raw.sections entry must have four operands",
N);
2010 "llvm.raw.sections entry operand 0 must be a string "
2015 "llvm.raw.sections entry operand 1 must be an integer "
2019 CheckFailed(
"llvm.raw.sections entry operand 1 must be a power of two "
2026 "llvm.raw.sections entry operand 2 must be an integer "
2029 if (FlagsCI->getZExtValue() != 0) {
2030 CheckFailed(
"llvm.raw.sections entry operand 2 must be zero (flags are "
2031 "reserved for future use)",
2036 "llvm.raw.sections entry operand 3 must be a string "
2042void Verifier::visitModuleFlags() {
2043 const NamedMDNode *
Flags =
M.getModuleFlagsMetadata();
2047 DenseMap<const MDString*, const MDNode*> SeenIDs;
2051 std::optional<uint64_t> PAuthABIPlatform;
2052 std::optional<uint64_t> PAuthABIVersion;
2055 uint64_t HasPtrauthInitFiniAddr = 0;
2057 for (
const MDNode *MDN :
Flags->operands()) {
2058 visitModuleFlag(MDN, SeenIDs, Requirements);
2059 if (MDN->getNumOperands() != 3)
2063 auto GetFlagNamed = [&](StringRef
Name) -> std::optional<uint64_t> {
2064 if (FlagName->getString() != Name)
2065 return std::nullopt;
2066 if (
const auto *FlagValue =
2068 return FlagValue->getZExtValue();
2070 CheckFailed(Name +
": module flag expects integer value");
2071 return std::nullopt;
2074 if (
auto Value = GetFlagNamed(
"aarch64-elf-pauthabi-platform"))
2075 PAuthABIPlatform = *
Value;
2076 else if (
auto Value = GetFlagNamed(
"aarch64-elf-pauthabi-version"))
2077 PAuthABIVersion = *
Value;
2078 else if (
auto Value = GetFlagNamed(
"ptrauth-init-fini"))
2079 HasPtrauthInitFini = *
Value;
2080 else if (
auto Value =
2081 GetFlagNamed(
"ptrauth-init-fini-address-discrimination"))
2082 HasPtrauthInitFiniAddr = *
Value;
2087 "ptrauth-init-fini must be 0 or 1");
2089 "ptrauth-init-fini-address-discrimination must be 0 or 1, if set");
2090 if (HasPtrauthInitFiniAddr)
2091 Check(HasPtrauthInitFini,
"ptrauth-init-fini-address-discrimination module "
2092 "flag requires ptrauth-init-fini");
2094 if (PAuthABIPlatform.has_value() != PAuthABIVersion.has_value())
2095 CheckFailed(
"either both or no 'aarch64-elf-pauthabi-platform' and "
2096 "'aarch64-elf-pauthabi-version' module flags must be present");
2099 for (
const MDNode *Requirement : Requirements) {
2103 const MDNode *
Op = SeenIDs.
lookup(Flag);
2105 CheckFailed(
"invalid requirement on flag, flag is not present in module",
2110 if (
Op->getOperand(2) != ReqValue) {
2111 CheckFailed((
"invalid requirement on flag, "
2112 "flag does not have the required value"),
2120Verifier::visitModuleFlag(
const MDNode *
Op,
2121 DenseMap<const MDString *, const MDNode *> &SeenIDs,
2122 SmallVectorImpl<const MDNode *> &Requirements) {
2126 "incorrect number of operands in module flag",
Op);
2127 Module::ModFlagBehavior MFB;
2128 if (!Module::isValidModFlagBehavior(
Op->getOperand(0), MFB)) {
2130 "invalid behavior operand in module flag (expected constant integer)",
2133 "invalid behavior operand in module flag (unexpected constant)",
2137 Check(ID,
"invalid ID operand in module flag (expected metadata string)",
2143 case Module::Warning:
2144 case Module::Override:
2150 Check(
V &&
V->getValue().isNonNegative(),
2151 "invalid value for 'min' module flag (expected constant non-negative "
2159 "invalid value for 'max' module flag (expected constant integer)",
2164 case Module::Require: {
2169 "invalid value for 'require' module flag (expected metadata pair)",
2172 (
"invalid value for 'require' module flag "
2173 "(first value operand should be a string)"),
2174 Value->getOperand(0));
2182 case Module::Append:
2183 case Module::AppendUnique: {
2186 "invalid value for 'append'-type module flag "
2187 "(expected a metadata node)",
2194 if (MFB != Module::Require) {
2197 "module flag identifiers must be unique (or of 'require' type)", ID);
2200 StringRef
Name =
ID->getString();
2201 if (Name ==
"wchar_size") {
2205 "wchar_size metadata requires constant positive integer argument");
2209 if (Name ==
"long-double-type") {
2210 Check(MFB == Module::Error,
2211 "long-double-type module flag must use 'error' merge behavior",
Op);
2213 Check(
Value,
"long-double-type metadata requires a string argument");
2216 "invalid long-double-type metadata value",
Op);
2220 if (Name ==
"float-abi") {
2221 Check(MFB == Module::Error,
2222 "float-abi module flag must use 'error' merge behavior",
Op);
2224 Check(
Value,
"float-abi metadata requires a string argument");
2227 "invalid float-abi metadata value",
Op);
2231 if (Name ==
"thread-model") {
2232 Check(MFB == Module::Error,
2233 "thread-model module flag must use 'error' merge behavior",
Op);
2235 Check(
Value,
"thread-model metadata requires a string argument");
2238 "invalid thread-model metadata value",
Op);
2242 if (Name ==
"target-abi") {
2245 "target-abi metadata requires a non-empty string argument",
Op);
2249 if (
ID->getString() ==
"exception-model") {
2250 Check(MFB == Module::Error,
2251 "exception-model module flag must use 'error' merge behavior",
Op);
2253 Check(
Value,
"exception-model metadata requires a string argument");
2256 "invalid exception-model metadata value",
Op);
2260 if (Name ==
"debugger-tuning") {
2263 "debugger-tuning metadata requires a non-empty string argument",
Op);
2267 if (Name ==
"Linker Options") {
2271 Check(
M.getNamedMetadata(
"llvm.linker.options"),
2272 "'Linker Options' named metadata no longer supported");
2276 if (Name ==
"SemanticInterposition") {
2277 ConstantInt *
Value =
2280 "SemanticInterposition metadata requires constant integer argument");
2284 if (Name ==
"CG Profile") {
2285 for (
const MDOperand &MDO :
cast<MDNode>(
Op->getOperand(2))->operands())
2286 visitModuleFlagCGProfileEntry(MDO);
2294void Verifier::visitModuleFlagCGProfileEntry(
const MDOperand &MDO) {
2295 auto CheckFunction = [&](
const MDOperand &FuncMDO) {
2300 "expected a Function or null", FuncMDO);
2303 Check(Node &&
Node->getNumOperands() == 3,
"expected a MDNode triple", MDO);
2304 CheckFunction(
Node->getOperand(0));
2305 CheckFunction(
Node->getOperand(1));
2308 "expected an integer constant",
Node->getOperand(2));
2311void Verifier::verifyAttributeTypes(AttributeSet Attrs,
const Value *
V) {
2314 if (
A.isStringAttribute()) {
2315#define GET_ATTR_NAMES
2316#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)
2317#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
2318 if (A.getKindAsString() == #DISPLAY_NAME) { \
2319 auto V = A.getValueAsString(); \
2320 if (!(V.empty() || V == "true" || V == "false")) \
2321 CheckFailed("invalid value for '" #DISPLAY_NAME "' attribute: " + V + \
2325#include "llvm/IR/Attributes.inc"
2329 if (
A.isIntAttribute() != Attribute::isIntAttrKind(
A.getKindAsEnum())) {
2330 CheckFailed(
"Attribute '" +
A.getAsString() +
"' should have an Argument",
2339void Verifier::verifyParameterAttrs(AttributeSet Attrs,
Type *Ty,
2341 if (!
Attrs.hasAttributes())
2344 verifyAttributeTypes(Attrs,
V);
2347 Check(Attr.isStringAttribute() ||
2348 Attribute::canUseAsParamAttr(Attr.getKindAsEnum()),
2349 "Attribute '" + Attr.getAsString() +
"' does not apply to parameters",
2353 if (
Attrs.getNumAttributes() > 1) {
2354 if (
Attrs.hasAttribute(Attribute::ImmArg)) {
2355 unsigned AttrCount =
2356 Attrs.getNumAttributes() -
Attrs.hasAttribute(Attribute::Range);
2359 "Attribute 'immarg' is incompatible with other attributes except the "
2360 "'range' attribute",
2366 unsigned AttrCount = 0;
2367 AttrCount +=
Attrs.hasAttribute(Attribute::ByVal);
2368 AttrCount +=
Attrs.hasAttribute(Attribute::InAlloca);
2369 AttrCount +=
Attrs.hasAttribute(Attribute::Preallocated);
2370 AttrCount +=
Attrs.hasAttribute(Attribute::StructRet) ||
2371 Attrs.hasAttribute(Attribute::InReg);
2372 AttrCount +=
Attrs.hasAttribute(Attribute::Nest);
2373 AttrCount +=
Attrs.hasAttribute(Attribute::ByRef);
2374 Check(AttrCount <= 1,
2375 "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
2376 "'byref', and 'sret' are incompatible!",
2379 Check(!(
Attrs.hasAttribute(Attribute::InAlloca) &&
2380 Attrs.hasAttribute(Attribute::ReadOnly)),
2382 "'inalloca and readonly' are incompatible!",
2385 Check(!(
Attrs.hasAttribute(Attribute::StructRet) &&
2386 Attrs.hasAttribute(Attribute::Returned)),
2388 "'sret and returned' are incompatible!",
2391 Check(!(
Attrs.hasAttribute(Attribute::ZExt) &&
2392 Attrs.hasAttribute(Attribute::SExt)),
2394 "'zeroext and signext' are incompatible!",
2397 Check(!(
Attrs.hasAttribute(Attribute::ReadNone) &&
2398 Attrs.hasAttribute(Attribute::ReadOnly)),
2400 "'readnone and readonly' are incompatible!",
2403 Check(!(
Attrs.hasAttribute(Attribute::ReadNone) &&
2404 Attrs.hasAttribute(Attribute::WriteOnly)),
2406 "'readnone and writeonly' are incompatible!",
2409 Check(!(
Attrs.hasAttribute(Attribute::ReadOnly) &&
2410 Attrs.hasAttribute(Attribute::WriteOnly)),
2412 "'readonly and writeonly' are incompatible!",
2415 Check(!(
Attrs.hasAttribute(Attribute::NoInline) &&
2416 Attrs.hasAttribute(Attribute::AlwaysInline)),
2418 "'noinline and alwaysinline' are incompatible!",
2421 Check(!(
Attrs.hasAttribute(Attribute::Writable) &&
2422 Attrs.hasAttribute(Attribute::ReadNone)),
2423 "Attributes writable and readnone are incompatible!",
V);
2425 Check(!(
Attrs.hasAttribute(Attribute::Writable) &&
2426 Attrs.hasAttribute(Attribute::ReadOnly)),
2427 "Attributes writable and readonly are incompatible!",
V);
2430 AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(Ty, Attrs);
2432 if (!Attr.isStringAttribute() &&
2433 IncompatibleAttrs.
contains(Attr.getKindAsEnum())) {
2434 CheckFailed(
"Attribute '" + Attr.getAsString() +
2435 "' applied to incompatible type!",
V);
2441 if (
Attrs.hasAttribute(Attribute::Alignment)) {
2442 Align AttrAlign =
Attrs.getAlignment().valueOrOne();
2443 Check(AttrAlign.
value() <= Value::MaximumAlignment,
2444 "huge alignment values are unsupported",
V);
2446 if (
Attrs.hasAttribute(Attribute::ByVal)) {
2449 "Attribute 'byval' does not support unsized types!",
V);
2453 "'byval' argument has illegal target extension type",
V);
2457 "scalable 'byval' arguments are unsupported",
V);
2458 Check(
DL.getTypeAllocSize(ByValTy).getKnownMinValue() < (1ULL << 32),
2459 "huge 'byval' arguments are unsupported",
V);
2461 if (
Attrs.hasAttribute(Attribute::ByRef)) {
2463 "Attribute 'byref' does not support unsized types!",
V);
2464 Check(
DL.getTypeAllocSize(
Attrs.getByRefType()).getKnownMinValue() <
2466 "huge 'byref' arguments are unsupported",
V);
2468 if (
Attrs.hasAttribute(Attribute::InAlloca)) {
2470 "Attribute 'inalloca' does not support unsized types!",
V);
2471 Check(
DL.getTypeAllocSize(
Attrs.getInAllocaType()).getKnownMinValue() <
2473 "huge 'inalloca' arguments are unsupported",
V);
2475 if (
Attrs.hasAttribute(Attribute::Preallocated)) {
2476 Check(
Attrs.getPreallocatedType()->isSized(),
2477 "Attribute 'preallocated' does not support unsized types!",
V);
2479 DL.getTypeAllocSize(
Attrs.getPreallocatedType()).getKnownMinValue() <
2481 "huge 'preallocated' arguments are unsupported",
V);
2485 if (
Attrs.hasAttribute(Attribute::Initializes)) {
2486 auto Inits =
Attrs.getAttribute(Attribute::Initializes).getInitializes();
2487 Check(!Inits.empty(),
"Attribute 'initializes' does not support empty list",
2490 "Attribute 'initializes' does not support unordered ranges",
V);
2493 if (
Attrs.hasAttribute(Attribute::NoFPClass)) {
2494 uint64_t Val =
Attrs.getAttribute(Attribute::NoFPClass).getValueAsInt();
2495 Check(Val != 0,
"Attribute 'nofpclass' must have at least one test bit set",
2498 "Invalid value for 'nofpclass' test mask",
V);
2500 if (
Attrs.hasAttribute(Attribute::Range)) {
2501 const ConstantRange &CR =
2502 Attrs.getAttribute(Attribute::Range).getValueAsConstantRange();
2504 "Range bit width must match type bit width!",
V);
2508void Verifier::checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
2510 if (
Attrs.hasFnAttr(Attr)) {
2511 StringRef S =
Attrs.getFnAttr(Attr).getValueAsString();
2514 CheckFailed(
"\"" + Attr +
"\" takes an unsigned integer: " + S,
V);
2520void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
2521 const Value *
V,
bool IsIntrinsic,
2523 if (
Attrs.isEmpty())
2526 if (AttributeListsVisited.
insert(
Attrs.getRawPointer()).second) {
2528 "Attribute list does not match Module context!", &Attrs,
V);
2529 for (
const auto &AttrSet : Attrs) {
2530 Check(!AttrSet.hasAttributes() || AttrSet.hasParentContext(
Context),
2531 "Attribute set does not match Module context!", &AttrSet,
V);
2532 for (
const auto &
A : AttrSet) {
2534 "Attribute does not match Module context!", &
A,
V);
2539 bool SawNest =
false;
2540 bool SawReturned =
false;
2541 bool SawSRet =
false;
2542 bool SawSwiftSelf =
false;
2543 bool SawSwiftAsync =
false;
2544 bool SawSwiftError =
false;
2547 AttributeSet RetAttrs =
Attrs.getRetAttrs();
2550 Attribute::canUseAsRetAttr(
RetAttr.getKindAsEnum()),
2551 "Attribute '" +
RetAttr.getAsString() +
2552 "' does not apply to function return values",
2555 unsigned MaxParameterWidth = 0;
2556 auto GetMaxParameterWidth = [&MaxParameterWidth](
Type *Ty) {
2559 unsigned Size = VT->getPrimitiveSizeInBits().getFixedValue();
2560 if (
Size > MaxParameterWidth)
2561 MaxParameterWidth =
Size;
2565 GetMaxParameterWidth(FT->getReturnType());
2566 verifyParameterAttrs(RetAttrs, FT->getReturnType(),
V);
2569 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2570 Type *Ty = FT->getParamType(i);
2571 AttributeSet ArgAttrs =
Attrs.getParamAttrs(i);
2575 "immarg attribute only applies to intrinsics",
V);
2578 "Attribute 'elementtype' can only be applied to intrinsics"
2583 verifyParameterAttrs(ArgAttrs, Ty,
V);
2584 GetMaxParameterWidth(Ty);
2587 Check(!SawNest,
"More than one parameter has attribute nest!",
V);
2592 Check(!SawReturned,
"More than one parameter has attribute returned!",
V);
2594 "Incompatible argument and return types for 'returned' attribute",
2600 Check(!SawSRet,
"Cannot have multiple 'sret' parameters!",
V);
2601 Check(i == 0 || i == 1,
2602 "Attribute 'sret' is not on first or second parameter!",
V);
2607 Check(!SawSwiftSelf,
"Cannot have multiple 'swiftself' parameters!",
V);
2608 SawSwiftSelf =
true;
2612 Check(!SawSwiftAsync,
"Cannot have multiple 'swiftasync' parameters!",
V);
2613 SawSwiftAsync =
true;
2617 Check(!SawSwiftError,
"Cannot have multiple 'swifterror' parameters!",
V);
2618 SawSwiftError =
true;
2622 Check(i == FT->getNumParams() - 1,
2623 "inalloca isn't on the last parameter!",
V);
2627 if (!
Attrs.hasFnAttrs())
2630 verifyAttributeTypes(
Attrs.getFnAttrs(),
V);
2633 Attribute::canUseAsFnAttr(
FnAttr.getKindAsEnum()),
2634 "Attribute '" +
FnAttr.getAsString() +
2635 "' does not apply to functions!",
2638 Check(!(
Attrs.hasFnAttr(Attribute::NoInline) &&
2639 Attrs.hasFnAttr(Attribute::AlwaysInline)),
2640 "Attributes 'noinline and alwaysinline' are incompatible!",
V);
2642 if (
Attrs.hasFnAttr(Attribute::OptimizeNone)) {
2643 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2644 "Attributes 'optsize and optnone' are incompatible!",
V);
2647 "Attributes 'minsize and optnone' are incompatible!",
V);
2649 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForDebugging),
2650 "Attributes 'optdebug and optnone' are incompatible!",
V);
2653 Check(!(
Attrs.hasFnAttr(Attribute::SanitizeRealtime) &&
2654 Attrs.hasFnAttr(Attribute::SanitizeRealtimeBlocking)),
2656 "'sanitize_realtime and sanitize_realtime_blocking' are incompatible!",
2659 Check(!(
Attrs.hasFnAttr(Attribute::SanitizeThread) &&
2660 Attrs.hasFnAttr(Attribute::SanitizeConcurrency)),
2661 "Attributes 'sanitize_thread and sanitize_concurrency' are "
2665 if (
Attrs.hasFnAttr(Attribute::OptimizeForDebugging)) {
2666 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2667 "Attributes 'optsize and optdebug' are incompatible!",
V);
2670 "Attributes 'minsize and optdebug' are incompatible!",
V);
2673 Check(!
Attrs.hasAttrSomewhere(Attribute::Writable) ||
2674 isModSet(
Attrs.getMemoryEffects().getModRef(IRMemLocation::ArgMem)),
2675 "Attribute writable and memory without argmem: write are incompatible!",
2678 if (
Attrs.hasFnAttr(
"aarch64_pstate_sm_enabled")) {
2679 Check(!
Attrs.hasFnAttr(
"aarch64_pstate_sm_compatible"),
2680 "Attributes 'aarch64_pstate_sm_enabled and "
2681 "aarch64_pstate_sm_compatible' are incompatible!",
2685 Check((
Attrs.hasFnAttr(
"aarch64_new_za") +
Attrs.hasFnAttr(
"aarch64_in_za") +
2686 Attrs.hasFnAttr(
"aarch64_inout_za") +
2687 Attrs.hasFnAttr(
"aarch64_out_za") +
2688 Attrs.hasFnAttr(
"aarch64_preserves_za") +
2689 Attrs.hasFnAttr(
"aarch64_za_state_agnostic")) <= 1,
2690 "Attributes 'aarch64_new_za', 'aarch64_in_za', 'aarch64_out_za', "
2691 "'aarch64_inout_za', 'aarch64_preserves_za' and "
2692 "'aarch64_za_state_agnostic' are mutually exclusive",
2696 Attrs.hasFnAttr(
"aarch64_in_zt0") +
2697 Attrs.hasFnAttr(
"aarch64_inout_zt0") +
2698 Attrs.hasFnAttr(
"aarch64_out_zt0") +
2699 Attrs.hasFnAttr(
"aarch64_preserves_zt0") +
2700 Attrs.hasFnAttr(
"aarch64_za_state_agnostic")) <= 1,
2701 "Attributes 'aarch64_new_zt0', 'aarch64_in_zt0', 'aarch64_out_zt0', "
2702 "'aarch64_inout_zt0', 'aarch64_preserves_zt0' and "
2703 "'aarch64_za_state_agnostic' are mutually exclusive",
2706 if (
Attrs.hasFnAttr(Attribute::JumpTable)) {
2709 "Attribute 'jumptable' requires 'unnamed_addr'",
V);
2712 if (
auto Args =
Attrs.getFnAttrs().getAllocSizeArgs()) {
2713 auto CheckParam = [&](StringRef
Name,
unsigned ParamNo) {
2714 if (ParamNo >= FT->getNumParams()) {
2715 CheckFailed(
"'allocsize' " + Name +
" argument is out of bounds",
V);
2719 if (!FT->getParamType(ParamNo)->isIntegerTy()) {
2720 CheckFailed(
"'allocsize' " + Name +
2721 " argument must refer to an integer parameter",
2729 if (!CheckParam(
"element size",
Args->first))
2732 if (
Args->second && !CheckParam(
"number of elements", *
Args->second))
2736 if (
Attrs.hasFnAttr(Attribute::AllocKind)) {
2739 K & (AllocFnKind::Alloc | AllocFnKind::Realloc | AllocFnKind::Free);
2741 {AllocFnKind::Alloc, AllocFnKind::Realloc, AllocFnKind::Free},
2744 "'allockind()' requires exactly one of alloc, realloc, and free");
2745 if ((
Type == AllocFnKind::Free) &&
2746 ((K & (AllocFnKind::Uninitialized | AllocFnKind::Zeroed |
2747 AllocFnKind::Aligned)) != AllocFnKind::Unknown))
2748 CheckFailed(
"'allockind(\"free\")' doesn't allow uninitialized, zeroed, "
2749 "or aligned modifiers.");
2750 AllocFnKind ZeroedUninit = AllocFnKind::Uninitialized | AllocFnKind::Zeroed;
2751 if ((K & ZeroedUninit) == ZeroedUninit)
2752 CheckFailed(
"'allockind()' can't be both zeroed and uninitialized");
2756 StringRef S =
A.getValueAsString();
2757 Check(!S.
empty(),
"'alloc-variant-zeroed' must not be empty");
2765 "'alloc-variant-zeroed' must name a function belonging to the "
2766 "same 'alloc-family'");
2769 (
Variant->getFnAttribute(Attribute::AllocKind).getAllocKind() &
2770 AllocFnKind::Zeroed) != AllocFnKind::Unknown,
2771 "'alloc-variant-zeroed' must name a function with "
2772 "'allockind(\"zeroed\")'");
2775 "'alloc-variant-zeroed' must name a function with the same "
2780 "'alloc-variant-zeroed' must name a function with the same "
2781 "calling convention");
2785 if (
Attrs.hasFnAttr(Attribute::VScaleRange)) {
2786 unsigned VScaleMin =
Attrs.getFnAttrs().getVScaleRangeMin();
2788 CheckFailed(
"'vscale_range' minimum must be greater than 0",
V);
2790 CheckFailed(
"'vscale_range' minimum must be power-of-two value",
V);
2791 std::optional<unsigned> VScaleMax =
Attrs.getFnAttrs().getVScaleRangeMax();
2792 if (VScaleMax && VScaleMin > VScaleMax)
2793 CheckFailed(
"'vscale_range' minimum cannot be greater than maximum",
V);
2795 CheckFailed(
"'vscale_range' maximum must be power-of-two value",
V);
2798 if (
Attribute FPAttr =
Attrs.getFnAttr(
"frame-pointer"); FPAttr.isValid()) {
2799 StringRef
FP = FPAttr.getValueAsString();
2800 if (
FP !=
"all" &&
FP !=
"non-leaf" &&
FP !=
"none" &&
FP !=
"reserved" &&
2801 FP !=
"non-leaf-no-reserve")
2802 CheckFailed(
"invalid value for 'frame-pointer' attribute: " +
FP,
V);
2805 checkUnsignedBaseTenFuncAttr(Attrs,
"tail-pad-to-size",
V);
2806 checkUnsignedBaseTenFuncAttr(Attrs,
"tail-pad-value",
V);
2807 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-prefix",
V);
2808 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-entry",
V);
2809 if (
Attrs.hasFnAttr(
"patchable-function-entry-section"))
2810 Check(!
Attrs.getFnAttr(
"patchable-function-entry-section")
2813 "\"patchable-function-entry-section\" must not be empty");
2814 checkUnsignedBaseTenFuncAttr(Attrs,
"warn-stack-size",
V);
2815 checkUnsignedBaseTenFuncAttr(Attrs,
"unsafe-stack-size",
V);
2817 checkUnsignedBaseTenFuncAttr(Attrs, Attr,
V);
2819 if (
auto A =
Attrs.getFnAttr(
"sign-return-address");
A.isValid()) {
2820 StringRef S =
A.getValueAsString();
2821 if (S !=
"none" && S !=
"all" && S !=
"non-leaf")
2822 CheckFailed(
"invalid value for 'sign-return-address' attribute: " + S,
V);
2825 if (
auto A =
Attrs.getFnAttr(
"sign-return-address-key");
A.isValid()) {
2826 StringRef S =
A.getValueAsString();
2827 if (S !=
"a_key" && S !=
"b_key")
2828 CheckFailed(
"invalid value for 'sign-return-address-key' attribute: " + S,
2830 if (
auto AA =
Attrs.getFnAttr(
"sign-return-address"); !AA.isValid()) {
2832 "'sign-return-address-key' present without `sign-return-address`");
2836 if (
auto A =
Attrs.getFnAttr(
"sign-return-address-harden");
A.isValid()) {
2837 StringRef S =
A.getValueAsString();
2838 if (S !=
"load-return-address" && S !=
"none")
2840 "invalid value for 'sign-return-address-harden' attribute: " + S,
V);
2841 auto SignRetA =
Attrs.getFnAttr(
"sign-return-address");
2842 auto PAuthRetA =
Attrs.getFnAttr(
"ptrauth-returns");
2843 if (!SignRetA.isValid() && !PAuthRetA.isValid())
2844 CheckFailed(
"'sign-return-address-harden' present without "
2845 "'sign-return-address' or 'ptrauth-returns'");
2848 if (
auto A =
Attrs.getFnAttr(
"branch-target-enforcement");
A.isValid()) {
2849 StringRef S =
A.getValueAsString();
2850 if (S !=
"" && S !=
"true" && S !=
"false")
2852 "invalid value for 'branch-target-enforcement' attribute: " + S,
V);
2855 if (
auto A =
Attrs.getFnAttr(
"branch-protection-pauth-lr");
A.isValid()) {
2856 StringRef S =
A.getValueAsString();
2857 if (S !=
"" && S !=
"true" && S !=
"false")
2859 "invalid value for 'branch-protection-pauth-lr' attribute: " + S,
V);
2862 if (
auto A =
Attrs.getFnAttr(
"guarded-control-stack");
A.isValid()) {
2863 StringRef S =
A.getValueAsString();
2864 if (S !=
"" && S !=
"true" && S !=
"false")
2865 CheckFailed(
"invalid value for 'guarded-control-stack' attribute: " + S,
2869 if (
auto A =
Attrs.getFnAttr(
"vector-function-abi-variant");
A.isValid()) {
2870 StringRef S =
A.getValueAsString();
2873 CheckFailed(
"invalid name for a VFABI variant: " + S,
V);
2876 if (
auto A =
Attrs.getFnAttr(
"modular-format");
A.isValid()) {
2877 StringRef S =
A.getValueAsString();
2881 "modular-format attribute requires at least 5 arguments",
V);
2882 unsigned UpperBound = FT->getNumParams() + (FT->isVarArg() ? 1 : 0);
2884 Check(!Args[1].getAsInteger(10, FormatIdx),
2885 "modular-format attribute format string index is not an integer",
V);
2886 Check(FormatIdx > 0,
2887 "modular-format attribute format string index must be greater than 0",
2889 Check(FormatIdx <= UpperBound,
2890 "modular-format attribute format string index is out of bounds",
V);
2891 unsigned FirstArgIdx;
2892 Check(!Args[2].getAsInteger(10, FirstArgIdx),
2893 "modular-format attribute first arg index is not an integer",
V);
2894 Check(FirstArgIdx <= UpperBound,
2895 "modular-format attribute first arg index is out of bounds",
V);
2897 "modular-format attribute modular implementation function name "
2901 "modular-format attribute implementation name cannot be empty",
V);
2904 if (
auto A =
Attrs.getFnAttr(
"target-features");
A.isValid()) {
2905 StringRef S =
A.getValueAsString();
2907 for (
auto FeatureFlag :
split(S,
',')) {
2908 if (FeatureFlag.empty())
2910 "target-features attribute should not contain an empty string");
2912 Check(FeatureFlag[0] ==
'+' || FeatureFlag[0] ==
'-',
2913 "target feature '" + FeatureFlag +
2914 "' must start with a '+' or '-'",
2920 Check(!(
Attrs.hasFnAttr(Attribute::Hot) &&
Attrs.hasFnAttr(Attribute::Cold)),
2921 "Attributes 'hot' and 'cold' are incompatible");
2923 if (
Attrs.hasFnAttr(
"mnop-mcount")) {
2924 auto A =
Attrs.getFnAttr(
"fentry-call");
2925 Check(
A.isValid() &&
A.getValueAsString() ==
"true",
2926 "mnop-mcount only supported with fentry-call");
2929 if (
Attrs.hasFnAttr(
"mrecord-mcount")) {
2930 auto A =
Attrs.getFnAttr(
"fentry-call");
2931 Check(
A.isValid() &&
A.getValueAsString() ==
"true",
2932 "mrecord-mcount only supported with fentry-call");
2935 if (
Attrs.hasFnAttr(
"oracle-function")) {
2937 Check(
F,
"\"oracle-function\" attribute only applies to functions",
V);
2938 Check(
F->hasLocalLinkage(),
"oracle function must have local linkage",
V);
2939 Check(
F->onlyReadsMemory() &&
F->onlyAccessesArgMemory() &&
2940 F->doesNotThrow() &&
F->hasNoSync() &&
F->willReturn(),
2941 "oracle function must be nounwind, nosync and willreturn, must not "
2942 "have side effects and may only read memory through its arguments",
2944 Check(FT->getReturnType()->isIntegerTy(64),
2945 "oracle function must return i64",
V);
2946 Check(!FT->isVarArg(),
"oracle function must have a fixed argument list",
2948 if (
M.isMaterialized()) {
2949 for (
const Use &U :
F->uses()) {
2951 Check(
II &&
II->getIntrinsicID() == Intrinsic::speculative_load &&
2952 II->isArgOperand(&U) &&
II->getArgOperandNo(&U) == 2,
2953 "oracle function may only be used as the oracle operand of "
2954 "llvm.speculative.load",
2961void Verifier::verifyUnknownProfileMetadata(MDNode *MD) {
2963 "'unknown' !prof should have a single additional operand", MD);
2966 "'unknown' !prof should have an additional operand of type "
2969 "the 'unknown' !prof operand should not be an empty string");
2972void Verifier::verifyFunctionMetadata(
2973 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
2974 for (
const auto &Pair : MDs) {
2975 if (Pair.first == LLVMContext::MD_prof) {
2976 MDNode *MD = Pair.second;
2978 "!prof annotations should have no less than 2 operands", MD);
2983 verifyUnknownProfileMetadata(MD);
2988 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null",
2991 "expected string with name of the !prof annotation", MD);
2995 "first operand should be 'function_entry_count'", MD);
2998 Check(MD->
getOperand(1) !=
nullptr,
"second operand should not be null",
3001 "expected integer argument to function_entry_count", MD);
3002 }
else if (Pair.first == LLVMContext::MD_kcfi_type) {
3003 MDNode *MD = Pair.second;
3005 "!kcfi_type must have exactly one operand", MD);
3006 Check(MD->
getOperand(0) !=
nullptr,
"!kcfi_type operand must not be null",
3009 "expected a constant operand for !kcfi_type", MD);
3012 "expected a constant integer operand for !kcfi_type", MD);
3014 "expected a 32-bit integer constant operand for !kcfi_type", MD);
3015 }
else if (Pair.first ==
Context.getMDKindID(
"reqd_work_group_size")) {
3016 MDNode *MD = Pair.second;
3018 "reqd_work_group_size must have exactly three operands", MD);
3023 for (
unsigned I = 0;
I != 3; ++
I) {
3025 Check(
C,
"reqd_work_group_size operands must be integer constants", MD);
3029 const APInt &
Value =
C->getValue();
3031 "reqd_work_group_size operands must fit in 64 bits", MD);
3032 if (
Value.getActiveBits() > 64)
3036 Check(Dim == 0 || Product <= std::numeric_limits<uint64_t>::max() / Dim,
3037 "reqd_work_group_size product must fit in 64 bits", MD);
3038 if (Dim != 0 && Product > std::numeric_limits<uint64_t>::max() / Dim)
3046void Verifier::visitConstantExprsRecursively(
const Constant *EntryC) {
3050 if (!ConstantExprVisited.
insert(EntryC).second)
3054 Stack.push_back(EntryC);
3056 while (!
Stack.empty()) {
3061 visitConstantExpr(CE);
3064 visitConstantPtrAuth(CPA);
3069 Check(GV->
getParent() == &M,
"Referencing global in another module!",
3075 for (
const Use &U :
C->operands()) {
3079 if (!ConstantExprVisited.
insert(OpC).second)
3081 Stack.push_back(OpC);
3086void Verifier::visitConstantExpr(
const ConstantExpr *CE) {
3087 if (
CE->getOpcode() == Instruction::BitCast) {
3090 "Invalid bitcast", CE);
3091 Check(
DL.getTypeSizeInBits(
CE->getOperand(0)->getType()) ==
3092 DL.getTypeSizeInBits(
CE->getType()),
3093 "Invalid bitcast", CE);
3094 }
else if (
CE->getOpcode() == Instruction::PtrToAddr)
3095 checkPtrToAddr(
CE->getOperand(0)->getType(),
CE->getType(), *CE);
3096 else if (
CE->getOpcode() == Instruction::GetElementPtr)
3100void Verifier::visitConstantPtrAuth(
const ConstantPtrAuth *CPA) {
3102 "signed ptrauth constant base pointer must have pointer type");
3105 "signed ptrauth constant must have same type as its base pointer");
3108 "signed ptrauth constant key must be i32 constant integer");
3111 "signed ptrauth constant address discriminator must be a pointer");
3114 "signed ptrauth constant discriminator must be i64 constant integer");
3117 "signed ptrauth constant deactivation symbol must be a pointer");
3121 "signed ptrauth constant deactivation symbol must be a global value "
3125bool Verifier::verifyAttributeCount(AttributeList Attrs,
unsigned Params) {
3128 return Attrs.getNumAttrSets() <= Params + 2;
3131void Verifier::verifyInlineAsmCall(
const CallBase &
Call) {
3134 unsigned LabelNo = 0;
3135 for (
const InlineAsm::ConstraintInfo &CI :
IA->ParseConstraints()) {
3145 if (CI.isIndirect) {
3148 "Operand for indirect constraint must have pointer type", &
Call);
3151 "Operand for indirect constraint must have elementtype attribute",
3155 "Elementtype attribute can only be applied for indirect "
3164 Check(LabelNo == CallBr->getNumIndirectDests(),
3165 "Number of label constraints does not match number of callbr dests",
3168 Check(LabelNo == 0,
"Label constraints can only be used with callbr",
3174void Verifier::verifyStatepoint(
const CallBase &
Call) {
3179 "gc.statepoint must read and write all memory to preserve "
3180 "reordering restrictions required by safepoint semantics",
3183 const int64_t NumPatchBytes =
3186 Check(NumPatchBytes >= 0,
3187 "gc.statepoint number of patchable bytes must be "
3192 Check(TargetElemType,
3193 "gc.statepoint callee argument must have elementtype attribute",
Call);
3195 Check(TargetFuncType,
3196 "gc.statepoint callee elementtype must be function type",
Call);
3199 Check(NumCallArgs >= 0,
3200 "gc.statepoint number of arguments to underlying call "
3203 const int NumParams = (int)TargetFuncType->getNumParams();
3204 if (TargetFuncType->isVarArg()) {
3205 Check(NumCallArgs >= NumParams,
3206 "gc.statepoint mismatch in number of vararg call args",
Call);
3209 Check(TargetFuncType->getReturnType()->isVoidTy(),
3210 "gc.statepoint doesn't support wrapping non-void "
3211 "vararg functions yet",
3214 Check(NumCallArgs == NumParams,
3215 "gc.statepoint mismatch in number of call args",
Call);
3220 "unknown flag used in gc.statepoint flags argument",
Call);
3225 for (
int i = 0; i < NumParams; i++) {
3226 Type *ParamType = TargetFuncType->getParamType(i);
3228 Check(ArgType == ParamType,
3229 "gc.statepoint call argument does not match wrapped "
3233 if (TargetFuncType->isVarArg()) {
3234 AttributeSet ArgAttrs =
Attrs.getParamAttrs(5 + i);
3236 "Attribute 'sret' cannot be used for vararg call arguments!",
Call);
3240 const int EndCallArgsInx = 4 + NumCallArgs;
3244 "gc.statepoint number of transition arguments "
3245 "must be constant integer",
3247 const int NumTransitionArgs =
3249 Check(NumTransitionArgs == 0,
3250 "gc.statepoint w/inline transition bundle is deprecated",
Call);
3251 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
3255 "gc.statepoint number of deoptimization arguments "
3256 "must be constant integer",
3259 Check(NumDeoptArgs == 0,
3260 "gc.statepoint w/inline deopt operands is deprecated",
Call);
3262 const int ExpectedNumArgs = 7 + NumCallArgs;
3264 "gc.statepoint too many arguments",
Call);
3271 Check(UserCall,
"illegal use of statepoint token",
Call, U);
3275 "gc.result or gc.relocate are the only value uses "
3276 "of a gc.statepoint",
3279 Check(UserCall->getArgOperand(0) == &
Call,
3280 "gc.result connected to wrong gc.statepoint",
Call, UserCall);
3282 Check(UserCall->getArgOperand(0) == &
Call,
3283 "gc.relocate connected to wrong gc.statepoint",
Call, UserCall);
3297void Verifier::verifyFrameRecoverIndices() {
3298 for (
auto &Counts : FrameEscapeInfo) {
3300 unsigned EscapedObjectCount = Counts.second.first;
3301 unsigned MaxRecoveredIndex = Counts.second.second;
3302 Check(MaxRecoveredIndex <= EscapedObjectCount,
3303 "all indices passed to llvm.localrecover must be less than the "
3304 "number of arguments passed to llvm.localescape in the parent "
3313 UnwindDest =
II->getUnwindDest();
3315 UnwindDest = CSI->getUnwindDest();
3321void Verifier::verifySiblingFuncletUnwinds() {
3322 llvm::TimeTraceScope timeScope(
"Verifier verify sibling funclet unwinds");
3323 SmallPtrSet<Instruction *, 8> Visited;
3324 SmallPtrSet<Instruction *, 8>
Active;
3325 for (
const auto &Pair : SiblingFuncletInfo) {
3327 if (Visited.
count(PredPad))
3333 if (
Active.count(SuccPad)) {
3336 SmallVector<Instruction *, 8> CycleNodes;
3339 Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
3340 if (CycleTerminator != CyclePad)
3343 }
while (CyclePad != SuccPad);
3344 Check(
false,
"EH pads can't handle each other's exceptions",
3345 ArrayRef<Instruction *>(CycleNodes));
3348 if (!Visited.
insert(SuccPad).second)
3352 auto TermI = SiblingFuncletInfo.find(PredPad);
3353 if (TermI == SiblingFuncletInfo.end())
3366void Verifier::visitFunction(
const Function &
F) {
3367 visitGlobalValue(
F);
3370 FunctionType *FT =
F.getFunctionType();
3371 unsigned NumArgs =
F.arg_size();
3374 "Function context does not match Module context!", &
F);
3376 Check(!
F.hasCommonLinkage(),
"Functions may not have common linkage", &
F);
3377 Check(FT->getNumParams() == NumArgs,
3378 "# formal arguments must match # of arguments for function type!", &
F,
3380 Check(
F.getReturnType()->isFirstClassType() ||
3381 F.getReturnType()->isVoidTy() ||
F.getReturnType()->isStructTy(),
3382 "Functions cannot return aggregate values!", &
F);
3384 Check(!
F.hasStructRetAttr() ||
F.getReturnType()->isVoidTy(),
3385 "Invalid struct return type!", &
F);
3387 if (MaybeAlign
A =
F.getAlign()) {
3388 Check(
A->value() <= Value::MaximumAlignment,
3389 "huge alignment values are unsupported", &
F);
3392 AttributeList
Attrs =
F.getAttributes();
3394 Check(verifyAttributeCount(Attrs, FT->getNumParams()),
3395 "Attribute after last parameter!", &
F);
3397 bool IsIntrinsic =
F.isIntrinsic();
3400 verifyFunctionAttrs(FT, Attrs, &
F, IsIntrinsic,
false);
3406 "Attribute 'builtin' can only be applied to a callsite.", &
F);
3408 Check(!
Attrs.hasAttrSomewhere(Attribute::ElementType),
3409 "Attribute 'elementtype' can only be applied to a callsite.", &
F);
3411 if (
Attrs.hasFnAttr(Attribute::Naked))
3412 for (
const Argument &Arg :
F.args())
3413 Check(Arg.use_empty(),
"cannot use argument of naked function", &Arg);
3418 switch (
F.getCallingConv()) {
3420 case CallingConv::C:
3422 case CallingConv::X86_INTR: {
3423 Check(
F.arg_empty() ||
Attrs.hasParamAttr(0, Attribute::ByVal),
3424 "Calling convention parameter requires byval", &
F);
3427 case CallingConv::AMDGPU_KERNEL:
3428 case CallingConv::SPIR_KERNEL:
3429 case CallingConv::AMDGPU_CS_Chain:
3430 case CallingConv::AMDGPU_CS_ChainPreserve:
3431 Check(
F.getReturnType()->isVoidTy(),
3432 "Calling convention requires void return type", &
F);
3434 case CallingConv::AMDGPU_VS:
3435 case CallingConv::AMDGPU_HS:
3436 case CallingConv::AMDGPU_GS:
3437 case CallingConv::AMDGPU_PS:
3438 case CallingConv::AMDGPU_CS:
3439 Check(!
F.hasStructRetAttr(),
"Calling convention does not allow sret", &
F);
3440 if (
F.getCallingConv() != CallingConv::SPIR_KERNEL) {
3441 const unsigned StackAS =
DL.getAllocaAddrSpace();
3443 for (
const Argument &Arg :
F.args()) {
3444 Check(!
Attrs.hasParamAttr(i, Attribute::ByVal),
3445 "Calling convention disallows byval", &
F);
3446 Check(!
Attrs.hasParamAttr(i, Attribute::Preallocated),
3447 "Calling convention disallows preallocated", &
F);
3448 Check(!
Attrs.hasParamAttr(i, Attribute::InAlloca),
3449 "Calling convention disallows inalloca", &
F);
3451 if (
Attrs.hasParamAttr(i, Attribute::ByRef)) {
3454 Check(Arg.getType()->getPointerAddressSpace() != StackAS,
3455 "Calling convention disallows stack byref", &
F);
3463 case CallingConv::Fast:
3464 case CallingConv::Cold:
3465 case CallingConv::Intel_OCL_BI:
3466 case CallingConv::PTX_Device:
3468 "Calling convention does not support varargs or "
3469 "perfect forwarding!",
3472 case CallingConv::PTX_Kernel:
3476 Check(!
F.hasFnAttribute(Attr),
3477 "'" + Attr +
"' is not allowed on kernel functions", &
F);
3479 "Calling convention does not support varargs or "
3480 "perfect forwarding!",
3483 case CallingConv::AMDGPU_Gfx_WholeWave:
3484 Check(!
F.arg_empty() &&
F.arg_begin()->getType()->isIntegerTy(1),
3485 "Calling convention requires first argument to be i1", &
F);
3486 Check(!
F.arg_begin()->hasInRegAttr(),
3487 "Calling convention requires first argument to not be inreg", &
F);
3489 "Calling convention does not support varargs or "
3490 "perfect forwarding!",
3497 for (
const Argument &Arg :
F.args()) {
3498 Check(Arg.getType() == FT->getParamType(i),
3499 "Argument value does not match function argument type!", &Arg,
3500 FT->getParamType(i));
3501 Check(Arg.getType()->isFirstClassType(),
3502 "Function arguments must have first-class types!", &Arg);
3504 Check(!Arg.getType()->isMetadataTy(),
3505 "Function takes metadata but isn't an intrinsic", &Arg, &
F);
3506 Check(!Arg.getType()->isTokenLikeTy(),
3507 "Function takes token but isn't an intrinsic", &Arg, &
F);
3508 Check(!Arg.getType()->isX86_AMXTy(),
3509 "Function takes x86_amx but isn't an intrinsic", &Arg, &
F);
3513 if (
Attrs.hasParamAttr(i, Attribute::SwiftError)) {
3514 verifySwiftErrorValue(&Arg);
3520 Check(!
F.getReturnType()->isTokenLikeTy(),
3521 "Function returns a token but isn't an intrinsic", &
F);
3522 Check(!
F.getReturnType()->isX86_AMXTy(),
3523 "Function returns a x86_amx but isn't an intrinsic", &
F);
3528 F.getAllMetadata(MDs);
3529 assert(
F.hasMetadata() != MDs.
empty() &&
"Bit out-of-sync");
3530 verifyFunctionMetadata(MDs);
3536 if (
F.hasPersonalityFn()) {
3539 Check(Per->getParent() ==
F.getParent(),
3540 "Referencing personality function in another module!", &
F,
3541 F.getParent(), Per, Per->getParent());
3545 BlockEHFuncletColors.
clear();
3547 if (
F.isMaterializable()) {
3549 Check(MDs.
empty(),
"unmaterialized function cannot have metadata", &
F,
3551 }
else if (
F.isDeclaration()) {
3552 for (
const auto &
I : MDs) {
3554 CheckDI(
I.first != LLVMContext::MD_dbg ||
3556 "function declaration may only have a unique !dbg attachment",
3558 Check(
I.first != LLVMContext::MD_prof,
3559 "function declaration may not have a !prof attachment", &
F);
3562 visitMDNode(*
I.second, AreDebugLocsAllowed::Yes);
3564 Check(!
F.hasPersonalityFn(),
3565 "Function declaration shouldn't have a personality routine", &
F);
3569 Check(!IsIntrinsic,
"llvm intrinsics cannot be defined!", &
F);
3574 "Entry block to function must not have predecessors!", Entry);
3577 if (
Entry->hasAddressTaken()) {
3579 "blockaddress may not be used with the entry block!", Entry);
3582 unsigned NumDebugAttachments = 0, NumProfAttachments = 0,
3583 NumKCFIAttachments = 0;
3585 for (
const auto &
I : MDs) {
3587 auto AllowLocs = AreDebugLocsAllowed::No;
3591 case LLVMContext::MD_dbg: {
3592 ++NumDebugAttachments;
3593 CheckDI(NumDebugAttachments == 1,
3594 "function must have a single !dbg attachment", &
F,
I.second);
3596 "function !dbg attachment must be a subprogram", &
F,
I.second);
3598 "function definition may only have a distinct !dbg attachment",
3602 const Function *&AttachedTo = DISubprogramAttachments[
SP];
3603 CheckDI(!AttachedTo || AttachedTo == &
F,
3604 "DISubprogram attached to more than one function", SP, &
F);
3606 AllowLocs = AreDebugLocsAllowed::Yes;
3609 case LLVMContext::MD_prof:
3610 ++NumProfAttachments;
3611 Check(NumProfAttachments == 1,
3612 "function must have a single !prof attachment", &
F,
I.second);
3614 case LLVMContext::MD_kcfi_type:
3615 ++NumKCFIAttachments;
3616 Check(NumKCFIAttachments == 1,
3617 "function must have a single !kcfi_type attachment", &
F,
3620 case LLVMContext::MD_annotation:
3621 visitAnnotationMetadata(
I.second);
3626 visitMDNode(*
I.second, AllowLocs);
3634 bool isMaterialized =
F.getParent()->isMaterialized();
3635 if (
F.isIntrinsic() && isMaterialized) {
3637 if (
F.hasAddressTaken(&U,
false,
true,
false,
3639 Check(
false,
"Invalid user of intrinsic instruction!", U);
3646 if (IID && (isMaterialized || !
F.materialized_use_empty())) {
3650 raw_string_ostream ErrOS(ErrMsg);
3653 Printable PrintDecl([&
F](raw_ostream &OS) {
F.print(OS); });
3654 Check(IsValid, ErrMsg, PrintDecl);
3661 IID, OverloadTys,
const_cast<Module *
>(
F.getParent()), FT);
3662 Check(ExpectedName ==
F.getName(),
3663 "Intrinsic name not mangled correctly for type arguments! "
3669 auto *
N =
F.getSubprogram();
3670 HasDebugInfo = (
N !=
nullptr);
3678 SmallPtrSet<const MDNode *, 32> Seen;
3690 "DILocation's scope must be a DILocalScope",
N, &
F, &
I,
DL, Parent);
3692 DILocalScope *
Scope =
DL->getInlinedAtScope();
3693 Check(Scope,
"Failed to find DILocalScope",
DL);
3695 if (!Seen.
insert(Scope).second)
3699 if (hasDIScopeCycle(Scope))
3702 DISubprogram *
SP =
Scope->getSubprogram();
3706 if ((Scope != SP) && !Seen.
insert(SP).second)
3710 "!dbg attachment points at wrong subprogram for function",
N, &
F,
3714 for (
auto &
I : BB) {
3715 VisitDebugLoc(
I,
I.getDebugLoc().getAsMDNode());
3717 if (
auto MD =
I.getMetadata(LLVMContext::MD_loop))
3720 if (BrokenDebugInfo)
3727void Verifier::visitBasicBlock(BasicBlock &BB) {
3728 InstsInThisBlock.
clear();
3729 ConvergenceVerifyHelper.
visit(BB);
3737 for (
const PHINode &PN : BB.
phis()) {
3738 Check(PN.getNumIncomingValues() == Preds.size(),
3739 "PHINode should have one entry for each predecessor of its "
3740 "parent basic block!",
3745 Values.reserve(PN.getNumIncomingValues());
3746 for (
unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
3748 std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));
3751 for (
unsigned i = 0, e =
Values.size(); i != e; ++i) {
3758 "PHI node has multiple entries for the same basic block with "
3759 "different incoming values!",
3765 "PHI node entries do not match predecessors!", &PN,
3766 Values[i].first, Preds[i]);
3774 Check(
I.getParent() == &BB,
"Instruction has bogus parent pointer!");
3778 CheckDI(!BB.getTrailingDbgRecords(),
"Basic Block has trailing DbgRecords!",
3782void Verifier::visitTerminator(Instruction &
I) {
3784 Check(&
I ==
I.getParent()->getTerminator(),
3785 "Terminator found in the middle of a basic block!",
I.getParent());
3786 visitInstruction(
I);
3789void Verifier::visitCondBrInst(CondBrInst &BI) {
3791 "Branch condition is not 'i1' type!", &BI, BI.
getCondition());
3792 visitTerminator(BI);
3795void Verifier::visitReturnInst(ReturnInst &RI) {
3798 if (
F->getReturnType()->isVoidTy())
3800 "Found return instr that returns non-void in Function of void "
3802 &RI,
F->getReturnType());
3805 "Function return type does not match operand "
3806 "type of return inst!",
3807 &RI,
F->getReturnType());
3811 visitTerminator(RI);
3814void Verifier::visitSwitchInst(SwitchInst &SI) {
3815 Check(
SI.getType()->isVoidTy(),
"Switch must have void result type!", &SI);
3818 Type *SwitchTy =
SI.getCondition()->getType();
3819 SmallPtrSet<ConstantInt*, 32>
Constants;
3820 for (
auto &Case :
SI.cases()) {
3822 "Case value is not a constant integer.", &SI);
3823 Check(Case.getCaseValue()->getType() == SwitchTy,
3824 "Switch constants must all be same type as switch value!", &SI);
3826 "Duplicate integer as switch case", &SI, Case.getCaseValue());
3829 visitTerminator(SI);
3832void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
3834 "Indirectbr operand must have pointer type!", &BI);
3837 "Indirectbr destinations must all have pointer type!", &BI);
3839 visitTerminator(BI);
3848void Verifier::visitCallBrInst(CallBrInst &CBI) {
3851 "callbr: indirect function / invalid signature");
3853 "callbr for intrinsics currently doesn't support operand bundles");
3857 "callbr currently only supports asm-goto and selected intrinsics");
3862 Check(!
IA->canThrow(),
"Unwinding from Callbr is not allowed");
3864 verifyInlineAsmCall(CBI);
3866 visitTerminator(CBI);
3869void Verifier::visitSelectInst(SelectInst &SI) {
3872 "Invalid operands for select instruction!", &SI);
3874 Check(
SI.getTrueValue()->getType() ==
SI.getType(),
3875 "Select values must have same type as select instruction!", &SI);
3876 visitInstruction(SI);
3882void Verifier::visitUserOp1(Instruction &
I) {
3883 Check(
false,
"User-defined operators should not live outside of a pass!", &
I);
3886void Verifier::visitTruncInst(TruncInst &
I) {
3888 Type *SrcTy =
I.getOperand(0)->getType();
3889 Type *DestTy =
I.getType();
3898 "trunc source and destination must both be a vector or neither", &
I);
3899 Check(SrcBitSize > DestBitSize,
"DestTy too big for Trunc", &
I);
3901 visitInstruction(
I);
3904void Verifier::visitZExtInst(ZExtInst &
I) {
3906 Type *SrcTy =
I.getOperand(0)->getType();
3907 Type *DestTy =
I.getType();
3913 "zext source and destination must both be a vector or neither", &
I);
3917 Check(SrcBitSize < DestBitSize,
"Type too small for ZExt", &
I);
3919 visitInstruction(
I);
3922void Verifier::visitSExtInst(SExtInst &
I) {
3924 Type *SrcTy =
I.getOperand(0)->getType();
3925 Type *DestTy =
I.getType();
3934 "sext source and destination must both be a vector or neither", &
I);
3935 Check(SrcBitSize < DestBitSize,
"Type too small for SExt", &
I);
3937 visitInstruction(
I);
3940void Verifier::visitFPTruncInst(FPTruncInst &
I) {
3942 Type *SrcTy =
I.getOperand(0)->getType();
3943 Type *DestTy =
I.getType();
3951 "fptrunc source and destination must both be a vector or neither", &
I);
3952 Check(SrcBitSize > DestBitSize,
"DestTy too big for FPTrunc", &
I);
3954 visitInstruction(
I);
3957void Verifier::visitFPExtInst(FPExtInst &
I) {
3959 Type *SrcTy =
I.getOperand(0)->getType();
3960 Type *DestTy =
I.getType();
3969 "fpext source and destination must both be a vector or neither", &
I);
3970 Check(SrcBitSize < DestBitSize,
"DestTy too small for FPExt", &
I);
3972 visitInstruction(
I);
3975void Verifier::visitUIToFPInst(UIToFPInst &
I) {
3977 Type *SrcTy =
I.getOperand(0)->getType();
3978 Type *DestTy =
I.getType();
3983 Check(SrcVec == DstVec,
3984 "UIToFP source and dest must both be vector or scalar", &
I);
3986 "UIToFP source must be integer or integer vector", &
I);
3990 if (SrcVec && DstVec)
3993 "UIToFP source and dest vector length mismatch", &
I);
3995 visitInstruction(
I);
3998void Verifier::visitSIToFPInst(SIToFPInst &
I) {
4000 Type *SrcTy =
I.getOperand(0)->getType();
4001 Type *DestTy =
I.getType();
4006 Check(SrcVec == DstVec,
4007 "SIToFP source and dest must both be vector or scalar", &
I);
4009 "SIToFP source must be integer or integer vector", &
I);
4013 if (SrcVec && DstVec)
4016 "SIToFP source and dest vector length mismatch", &
I);
4018 visitInstruction(
I);
4021void Verifier::visitFPToUIInst(FPToUIInst &
I) {
4023 Type *SrcTy =
I.getOperand(0)->getType();
4024 Type *DestTy =
I.getType();
4029 Check(SrcVec == DstVec,
4030 "FPToUI source and dest must both be vector or scalar", &
I);
4033 "FPToUI result must be integer or integer vector", &
I);
4035 if (SrcVec && DstVec)
4038 "FPToUI source and dest vector length mismatch", &
I);
4040 visitInstruction(
I);
4043void Verifier::visitFPToSIInst(FPToSIInst &
I) {
4045 Type *SrcTy =
I.getOperand(0)->getType();
4046 Type *DestTy =
I.getType();
4051 Check(SrcVec == DstVec,
4052 "FPToSI source and dest must both be vector or scalar", &
I);
4055 "FPToSI result must be integer or integer vector", &
I);
4057 if (SrcVec && DstVec)
4060 "FPToSI source and dest vector length mismatch", &
I);
4062 visitInstruction(
I);
4065void Verifier::checkPtrToAddr(
Type *SrcTy,
Type *DestTy,
const Value &
V) {
4074 Check(VSrc->getElementCount() == VDest->getElementCount(),
4075 "PtrToAddr vector length mismatch",
V);
4078 Type *AddrTy =
DL.getAddressType(SrcTy);
4079 Check(AddrTy == DestTy,
"PtrToAddr result must be address width",
V);
4082void Verifier::visitPtrToAddrInst(PtrToAddrInst &
I) {
4083 checkPtrToAddr(
I.getOperand(0)->getType(),
I.getType(),
I);
4084 visitInstruction(
I);
4087void Verifier::visitPtrToIntInst(PtrToIntInst &
I) {
4089 Type *SrcTy =
I.getOperand(0)->getType();
4090 Type *DestTy =
I.getType();
4101 Check(VSrc->getElementCount() == VDest->getElementCount(),
4102 "PtrToInt Vector length mismatch", &
I);
4105 visitInstruction(
I);
4108void Verifier::visitIntToPtrInst(IntToPtrInst &
I) {
4110 Type *SrcTy =
I.getOperand(0)->getType();
4111 Type *DestTy =
I.getType();
4121 Check(VSrc->getElementCount() == VDest->getElementCount(),
4122 "IntToPtr Vector length mismatch", &
I);
4124 visitInstruction(
I);
4127void Verifier::visitBitCastInst(BitCastInst &
I) {
4130 "Invalid bitcast", &
I);
4131 Check(
DL.getTypeSizeInBits(
I.getSrcTy()) ==
4132 DL.getTypeSizeInBits(
I.getDestTy()),
4133 "Invalid bitcast", &
I);
4134 visitInstruction(
I);
4137void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &
I) {
4138 Type *SrcTy =
I.getOperand(0)->getType();
4139 Type *DestTy =
I.getType();
4146 "AddrSpaceCast must be between different address spaces", &
I);
4148 Check(SrcVTy->getElementCount() ==
4150 "AddrSpaceCast vector pointer number of elements mismatch", &
I);
4151 visitInstruction(
I);
4156void Verifier::visitPHINode(PHINode &PN) {
4163 "PHI nodes not grouped at top of basic block!", &PN, PN.
getParent());
4172 "PHI node operands are not the same type as the result!", &PN);
4177 visitInstruction(PN);
4180void Verifier::visitCallBase(CallBase &
Call) {
4182 "Called function must be a pointer!",
Call);
4186 if (FTy->isVarArg())
4188 "Called function requires more parameters than were provided!",
Call);
4191 "Incorrect number of arguments passed to called function!",
Call);
4194 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
4196 "Call parameter type does not match function signature!",
4202 "Attribute after last parameter!",
Call);
4209 "Intrinsic called with incompatible signature",
Call);
4213 "calling convention does not permit calls",
Call);
4219 auto VerifyTypeAlign = [&](
Type *Ty,
const Twine &Message) {
4222 Align ABIAlign =
DL.getABITypeAlign(Ty);
4223 Check(ABIAlign.
value() <= Value::MaximumAlignment,
4224 "Incorrect alignment of " + Message +
" to called function!",
Call);
4228 VerifyTypeAlign(FTy->getReturnType(),
"return type");
4229 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
4230 Type *Ty = FTy->getParamType(i);
4231 VerifyTypeAlign(Ty,
"argument passed");
4235 if (
Attrs.hasFnAttr(Attribute::Speculatable)) {
4239 "speculatable attribute may not apply to call sites",
Call);
4242 if (
Attrs.hasFnAttr(Attribute::Preallocated)) {
4244 "preallocated as a call site attribute can only be on "
4245 "llvm.call.preallocated.arg");
4248 Check(!
Attrs.hasFnAttr(Attribute::DenormalFPEnv),
4249 "denormal_fpenv attribute may not apply to call sites",
Call);
4260 Check(AI->isUsedWithInAlloca(),
4261 "inalloca argument for call has mismatched alloca", AI,
Call);
4267 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
4271 Check(AI->isSwiftError(),
4272 "swifterror argument for call has mismatched alloca", AI,
Call);
4276 Check(ArgI,
"swifterror argument should come from an alloca or parameter",
4277 SwiftErrorArg,
Call);
4278 Check(ArgI->hasSwiftErrorAttr(),
4279 "swifterror argument for call has mismatched parameter", ArgI,
4283 if (
Attrs.hasParamAttr(i, Attribute::ImmArg)) {
4286 Check(Callee &&
Callee->hasParamAttribute(i, Attribute::ImmArg),
4295 "immarg operand has non-immediate parameter", ArgVal,
Call);
4301 const ConstantRange &CR =
4304 formatv(
"immarg value {} for arg {} out of range {}",
4305 CI->getValue(), i, CR),
4312 formatv(
"immarg value {} for arg {} out of range set",
4322 Check(hasOB != isMustTail,
4323 "preallocated operand either requires a preallocated bundle or "
4324 "the call to be musttail (but not both)",
4329 if (FTy->isVarArg()) {
4331 bool SawNest =
false;
4332 bool SawReturned =
false;
4334 for (
unsigned Idx = 0;
Idx < FTy->getNumParams(); ++
Idx) {
4335 if (
Attrs.hasParamAttr(Idx, Attribute::Nest))
4337 if (
Attrs.hasParamAttr(Idx, Attribute::Returned))
4342 for (
unsigned Idx = FTy->getNumParams(); Idx <
Call.
arg_size(); ++Idx) {
4344 AttributeSet ArgAttrs =
Attrs.getParamAttrs(Idx);
4345 verifyParameterAttrs(ArgAttrs, Ty, &
Call);
4348 Check(!SawNest,
"More than one parameter has attribute nest!",
Call);
4353 Check(!SawReturned,
"More than one parameter has attribute returned!",
4356 "Incompatible argument and return types for 'returned' "
4366 "Attribute 'sret' cannot be used for vararg call arguments!",
4371 "inalloca isn't on the last argument!",
Call);
4377 for (
Type *ParamTy : FTy->params()) {
4378 Check(!ParamTy->isMetadataTy(),
4379 "Function has metadata parameter but isn't an intrinsic",
Call);
4380 Check(!ParamTy->isTokenLikeTy(),
4381 "Function has token parameter but isn't an intrinsic",
Call);
4387 Check(!FTy->getReturnType()->isTokenLikeTy(),
4388 "Return type cannot be token for indirect call!");
4389 Check(!FTy->getReturnType()->isX86_AMXTy(),
4390 "Return type cannot be x86_amx for indirect call!");
4394 visitIntrinsicCall(ID,
Call);
4399 bool FoundDeoptBundle =
false, FoundFuncletBundle =
false,
4400 FoundGCTransitionBundle =
false, FoundCFGuardTargetBundle =
false,
4401 FoundPreallocatedBundle =
false, FoundGCLiveBundle =
false,
4402 FoundPtrauthBundle =
false, FoundKCFIBundle =
false,
4403 FoundAttachedCallBundle =
false;
4408 "Operand bundle operands cannot be labels",
Call);
4411 Check(!FoundDeoptBundle,
"Multiple deopt operand bundles",
Call);
4412 FoundDeoptBundle =
true;
4414 Check(!FoundGCTransitionBundle,
"Multiple gc-transition operand bundles",
4416 FoundGCTransitionBundle =
true;
4418 Check(!FoundFuncletBundle,
"Multiple funclet operand bundles",
Call);
4419 FoundFuncletBundle =
true;
4421 "Expected exactly one funclet bundle operand",
Call);
4423 "Funclet bundle operands should correspond to a FuncletPadInst",
4426 Check(!FoundCFGuardTargetBundle,
"Multiple CFGuardTarget operand bundles",
4428 FoundCFGuardTargetBundle =
true;
4430 "Expected exactly one cfguardtarget bundle operand",
Call);
4432 Check(!FoundPtrauthBundle,
"Multiple ptrauth operand bundles",
Call);
4433 FoundPtrauthBundle =
true;
4435 "Expected exactly two ptrauth bundle operands",
Call);
4437 BU.
Inputs[0]->getType()->isIntegerTy(32),
4438 "Ptrauth bundle key operand must be an i32 constant",
Call);
4440 "Ptrauth bundle discriminator operand must be an i64",
Call);
4442 Check(!FoundKCFIBundle,
"Multiple kcfi operand bundles",
Call);
4443 FoundKCFIBundle =
true;
4444 Check(BU.
Inputs.size() == 1,
"Expected exactly one kcfi bundle operand",
4447 BU.
Inputs[0]->getType()->isIntegerTy(32),
4448 "Kcfi bundle operand must be an i32 constant",
Call);
4450 Check(!FoundPreallocatedBundle,
"Multiple preallocated operand bundles",
4452 FoundPreallocatedBundle =
true;
4454 "Expected exactly one preallocated bundle operand",
Call);
4457 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,
4458 "\"preallocated\" argument must be a token from "
4459 "llvm.call.preallocated.setup",
4462 Check(!FoundGCLiveBundle,
"Multiple gc-live operand bundles",
Call);
4463 FoundGCLiveBundle =
true;
4465 Check(!FoundAttachedCallBundle,
4466 "Multiple \"clang.arc.attachedcall\" operand bundles",
Call);
4467 FoundAttachedCallBundle =
true;
4468 verifyAttachedCallBundle(
Call, BU);
4474 "Direct call cannot have a ptrauth bundle",
Call);
4486 "inlinable function call in a function with "
4487 "debug info must have a !dbg location",
4491 verifyInlineAsmCall(
Call);
4495 visitInstruction(
Call);
4498void Verifier::verifyTailCCMustTailAttrs(
const AttrBuilder &Attrs,
4501 Twine(
"inalloca attribute not allowed in ") +
Context);
4503 Twine(
"inreg attribute not allowed in ") +
Context);
4504 Check(!
Attrs.contains(Attribute::SwiftError),
4505 Twine(
"swifterror attribute not allowed in ") +
Context);
4506 Check(!
Attrs.contains(Attribute::Preallocated),
4507 Twine(
"preallocated attribute not allowed in ") +
Context);
4509 Twine(
"byref attribute not allowed in ") +
Context);
4514 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
4515 Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf,
4516 Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated,
4518 AttrBuilder Copy(
C);
4519 for (
auto AK : ABIAttrs) {
4520 Attribute Attr = Attrs.getParamAttrs(
I).getAttribute(AK);
4522 Copy.addAttribute(Attr);
4526 if (Attrs.hasParamAttr(
I, Attribute::Alignment) &&
4527 (Attrs.hasParamAttr(
I, Attribute::ByVal) ||
4528 Attrs.hasParamAttr(
I, Attribute::ByRef)))
4529 Copy.addAlignmentAttr(Attrs.getParamAlignment(
I));
4533void Verifier::verifyMustTailCall(CallInst &CI) {
4537 FunctionType *CallerTy =
F->getFunctionType();
4539 Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
4540 "cannot guarantee tail call due to mismatched varargs", &CI);
4541 Check(CallerTy->getReturnType() == CalleeTy->getReturnType(),
4542 "cannot guarantee tail call due to mismatched return types", &CI);
4546 "cannot guarantee tail call due to mismatched calling conv", &CI);
4554 Check(Ret,
"musttail call must precede a ret", &CI);
4557 "musttail call result must be returned", Ret);
4559 AttributeList CallerAttrs =
F->getAttributes();
4564 CI.
getCallingConv() == CallingConv::Tail ?
"tailcc" :
"swifttailcc";
4568 for (
unsigned I = 0,
E = CallerTy->getNumParams();
I !=
E; ++
I) {
4570 SmallString<32>
Context{CCName, StringRef(
" musttail caller")};
4571 verifyTailCCMustTailAttrs(ABIAttrs,
Context);
4573 for (
unsigned I = 0,
E = CalleeTy->getNumParams();
I !=
E; ++
I) {
4575 SmallString<32>
Context{CCName, StringRef(
" musttail callee")};
4576 verifyTailCCMustTailAttrs(ABIAttrs,
Context);
4579 Check(!CallerTy->isVarArg(), Twine(
"cannot guarantee ") + CCName +
4580 " tail call for varargs function");
4586 Check(CallerTy->getNumParams() == CalleeTy->getNumParams(),
4587 "cannot guarantee tail call due to mismatched parameter counts", &CI);
4588 for (
unsigned I = 0,
E = CallerTy->getNumParams();
I !=
E; ++
I) {
4589 Check(CallerTy->getParamType(
I) == CalleeTy->getParamType(
I),
4590 "cannot guarantee tail call due to mismatched parameter types",
4597 for (
unsigned I = 0,
E = CallerTy->getNumParams();
I !=
E; ++
I) {
4600 Check(CallerABIAttrs == CalleeABIAttrs,
4601 "cannot guarantee tail call due to mismatched ABI impacting "
4602 "function attributes",
4607void Verifier::visitCallInst(CallInst &CI) {
4611 verifyMustTailCall(CI);
4614void Verifier::visitInvokeInst(InvokeInst &
II) {
4620 II.getUnwindDest()->isEHPad(),
4621 "The unwind destination does not have an exception handling instruction!",
4624 visitTerminator(
II);
4629void Verifier::visitUnaryOperator(UnaryOperator &U) {
4630 Check(
U.getType() ==
U.getOperand(0)->getType(),
4631 "Unary operators must have same type for"
4632 "operands and result!",
4635 switch (
U.getOpcode()) {
4638 case Instruction::FNeg:
4639 Check(
U.getType()->isFPOrFPVectorTy(),
4640 "FNeg operator only works with float types!", &U);
4646 visitInstruction(U);
4652void Verifier::visitBinaryOperator(BinaryOperator &
B) {
4653 Check(
B.getOperand(0)->getType() ==
B.getOperand(1)->getType(),
4654 "Both operands to a binary operator are not of the same type!", &
B);
4656 switch (
B.getOpcode()) {
4659 case Instruction::Add:
4660 case Instruction::Sub:
4661 case Instruction::Mul:
4662 case Instruction::SDiv:
4663 case Instruction::UDiv:
4664 case Instruction::SRem:
4665 case Instruction::URem:
4666 Check(
B.getType()->isIntOrIntVectorTy(),
4667 "Integer arithmetic operators only work with integral types!", &
B);
4668 Check(
B.getType() ==
B.getOperand(0)->getType(),
4669 "Integer arithmetic operators must have same type "
4670 "for operands and result!",
4675 case Instruction::FAdd:
4676 case Instruction::FSub:
4677 case Instruction::FMul:
4678 case Instruction::FDiv:
4679 case Instruction::FRem:
4680 Check(
B.getType()->isFPOrFPVectorTy(),
4681 "Floating-point arithmetic operators only work with "
4682 "floating-point types!",
4684 Check(
B.getType() ==
B.getOperand(0)->getType(),
4685 "Floating-point arithmetic operators must have same type "
4686 "for operands and result!",
4690 case Instruction::And:
4691 case Instruction::Or:
4692 case Instruction::Xor:
4693 Check(
B.getType()->isIntOrIntVectorTy(),
4694 "Logical operators only work with integral types!", &
B);
4695 Check(
B.getType() ==
B.getOperand(0)->getType(),
4696 "Logical operators must have same type for operands and result!", &
B);
4698 case Instruction::Shl:
4699 case Instruction::LShr:
4700 case Instruction::AShr:
4701 Check(
B.getType()->isIntOrIntVectorTy(),
4702 "Shifts only work with integral types!", &
B);
4703 Check(
B.getType() ==
B.getOperand(0)->getType(),
4704 "Shift return type must be same as operands!", &
B);
4710 visitInstruction(
B);
4713void Verifier::visitICmpInst(ICmpInst &IC) {
4717 Check(Op0Ty == Op1Ty,
4718 "Both operands to ICmp instruction are not of the same type!", &IC);
4721 "Invalid operand types for ICmp instruction", &IC);
4725 visitInstruction(IC);
4728void Verifier::visitFCmpInst(FCmpInst &FC) {
4730 Type *Op0Ty =
FC.getOperand(0)->getType();
4731 Type *Op1Ty =
FC.getOperand(1)->getType();
4732 Check(Op0Ty == Op1Ty,
4733 "Both operands to FCmp instruction are not of the same type!", &FC);
4738 Check(
FC.isFPPredicate(),
"Invalid predicate in FCmp instruction!", &FC);
4740 visitInstruction(FC);
4743void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
4745 "Invalid extractelement operands!", &EI);
4746 visitInstruction(EI);
4749void Verifier::visitInsertElementInst(InsertElementInst &IE) {
4752 "Invalid insertelement operands!", &IE);
4753 visitInstruction(IE);
4756void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
4758 SV.getShuffleMask()),
4759 "Invalid shufflevector operands!", &SV);
4760 visitInstruction(SV);
4763void Verifier::visitBitInsertInst(BitInsertInst &BII) {
4766 Check(
false, Reason, &BII);
4769 "bitinsert val type cannot be wider than base type!", &BII);
4770 visitInstruction(BII);
4773void Verifier::visitVAArgInst(VAArgInst &VAA) {
4776 "va_arg with an aggregate type is not supported", &VAA);
4777 visitInstruction(VAA);
4780void Verifier::visitBitExtractInst(BitExtractInst &BEI) {
4783 Check(
false, Reason, &BEI);
4786 "bitextract result type cannot be wider than source type!", &BEI);
4787 visitInstruction(BEI);
4790void Verifier::checkGEPOperator(
const GEPOperator &
GEP) {
4791 Type *TargetTy =
GEP.getPointerOperandType()->getScalarType();
4794 "GEP base pointer is not a vector or a vector of pointers", &
GEP);
4795 Check(
GEP.getSourceElementType()->isSized(),
"GEP into unsized type!", &
GEP);
4797 Type *SrcTy =
GEP.getSourceElementType();
4799 SrcTy = ATy->getElementType();
4801 "getelementptr cannot target structure that contains scalable vector "
4805 SmallVector<Value *, 16> Idxs(
GEP.indices());
4807 all_of(Idxs, [](
Value *
V) {
return V->getType()->isIntOrIntVectorTy(); }),
4808 "GEP indexes must be integers", &
GEP);
4811 Check(ElTy,
"Invalid indices for GEP pointer type!", &
GEP);
4815 Check(PtrTy &&
GEP.getResultElementType() == ElTy,
4816 "GEP is not of right type for indices!", &
GEP, ElTy);
4820 ElementCount GEPWidth = GEPVTy->getElementCount();
4821 if (
GEP.getPointerOperandType()->isVectorTy())
4825 "Vector GEP result width doesn't match operand's", &
GEP);
4826 for (
Value *Idx : Idxs) {
4827 Type *IndexTy =
Idx->getType();
4829 ElementCount IndexWidth = IndexVTy->getElementCount();
4830 Check(IndexWidth == GEPWidth,
"Invalid GEP index vector width", &
GEP);
4833 "All GEP indices should be of integer type");
4840 GTI != GTE; ++GTI) {
4841 if (GTI.isVector()) {
4842 Type *ElemTy = GTI.getIndexedType();
4843 Check(
DL.typeSizeEqualsStoreSize(ElemTy),
4844 "GEP into vector with non-byte-addressable element type", &
GEP);
4848 Check(
GEP.getPointerAddressSpace() == PtrTy->getAddressSpace(),
4849 "GEP address space doesn't match type", &
GEP);
4852void Verifier::visitGetElementPtrInst(GetElementPtrInst &
GEP) {
4854 GEP.getModule()->getModuleFlag(
"require-logical-pointer")))
4855 Check(!MD->getZExtValue(),
4856 "Non-logical getelementptr disallowed for this module.");
4859 visitInstruction(
GEP);
4863 return A.getUpper() ==
B.getLower() ||
A.getLower() ==
B.getUpper();
4868void Verifier::verifyRangeLikeMetadata(
const Value &
I,
const MDNode *
Range,
4869 Type *Ty, RangeLikeMetadataKind Kind) {
4870 unsigned NumOperands =
Range->getNumOperands();
4871 Check(NumOperands % 2 == 0,
"Unfinished range!",
Range);
4872 unsigned NumRanges = NumOperands / 2;
4873 Check(NumRanges >= 1,
"It should have at least one range!",
Range);
4875 ConstantRange LastRange(1,
true);
4876 for (
unsigned i = 0; i < NumRanges; ++i) {
4879 Check(
Low,
"The lower limit must be an integer!",
Low);
4884 Check(
High->getType() ==
Low->getType(),
"Range pair types must match!",
4887 if (Kind == RangeLikeMetadataKind::NoaliasAddrspace) {
4889 "noalias.addrspace type must be i32!", &
I);
4892 "Range types must match instruction type!", &
I);
4895 APInt HighV =
High->getValue();
4896 APInt LowV =
Low->getValue();
4901 "The upper and lower limits cannot be the same value", &
I);
4903 ConstantRange CurRange(LowV, HighV);
4904 Check(!CurRange.isEmptySet() &&
4905 (Kind == RangeLikeMetadataKind::AbsoluteSymbol ||
4906 !CurRange.isFullSet()),
4907 "Range must not be empty!",
Range);
4909 Check(CurRange.intersectWith(LastRange).isEmptySet(),
4910 "Intervals are overlapping",
Range);
4911 Check(LowV.
sgt(LastRange.getLower()),
"Intervals are not in order",
4916 LastRange = ConstantRange(LowV, HighV);
4918 if (NumRanges > 2) {
4923 ConstantRange FirstRange(FirstLow, FirstHigh);
4924 Check(FirstRange.intersectWith(LastRange).isEmptySet(),
4925 "Intervals are overlapping",
Range);
4931void Verifier::visitRangeMetadata(Instruction &
I, MDNode *
Range,
Type *Ty) {
4933 "precondition violation");
4934 verifyRangeLikeMetadata(
I,
Range, Ty, RangeLikeMetadataKind::Range);
4937void Verifier::visitNoFPClassMetadata(Instruction &
I, MDNode *NoFPClass,
4939 Check(AttributeFuncs::isNoFPClassCompatibleType(Ty),
4940 "nofpclass only applies to floating-point typed loads",
I);
4943 "nofpclass must have exactly one entry", NoFPClass);
4944 ConstantInt *MaskVal =
4947 "nofpclass entry must be a constant i32", NoFPClass);
4949 Check(Val != 0,
"'nofpclass' must have at least one test bit set", NoFPClass,
4953 "Invalid value for 'nofpclass' test mask", NoFPClass,
I);
4956void Verifier::visitNoaliasAddrspaceMetadata(Instruction &
I, MDNode *
Range,
4959 "precondition violation");
4960 verifyRangeLikeMetadata(
I,
Range, Ty,
4961 RangeLikeMetadataKind::NoaliasAddrspace);
4964void Verifier::checkAtomicMemAccessSize(
Type *Ty,
const Instruction *
I) {
4965 unsigned Size =
DL.getTypeSizeInBits(Ty).getFixedValue();
4966 Check(
Size >= 8,
"atomic memory access' size must be byte-sized", Ty,
I);
4968 "atomic memory access' operand must have a power-of-two size", Ty,
I);
4971void Verifier::visitLoadInst(LoadInst &LI) {
4973 Check(PTy,
"Load operand must be a pointer.", &LI);
4976 Check(
A->value() <= Value::MaximumAlignment,
4977 "huge alignment values are unsupported", &LI);
4979 Check(ElTy->
isSized(),
"loading unsized types is not allowed", &LI);
4982 LI.
getOrdering() != AtomicOrdering::AcquireRelease,
4983 "Load cannot have Release ordering", &LI);
4987 "atomic elementwise load cannot be sequentially consistent.", &LI);
4990 "atomic elementwise load operand must have fixed vector type!", &LI,
4993 checkAtomicMemAccessSize(VecTy->getElementType(), &LI);
4999 "atomic load operand must have integer, byte, pointer, floating "
5000 "point, or vector type!",
5003 checkAtomicMemAccessSize(ElTy, &LI);
5007 "Non-atomic load cannot have SynchronizationScope specified", &LI);
5010 visitInstruction(LI);
5013void Verifier::visitStoreInst(StoreInst &SI) {
5015 Check(PTy,
"Store operand must be a pointer.", &SI);
5016 Type *ElTy =
SI.getOperand(0)->getType();
5017 if (MaybeAlign
A =
SI.getAlign()) {
5018 Check(
A->value() <= Value::MaximumAlignment,
5019 "huge alignment values are unsupported", &SI);
5021 Check(ElTy->
isSized(),
"storing unsized types is not allowed", &SI);
5022 if (
SI.isAtomic()) {
5023 Check(
SI.getOrdering() != AtomicOrdering::Acquire &&
5024 SI.getOrdering() != AtomicOrdering::AcquireRelease,
5025 "Store cannot have Acquire ordering", &SI);
5027 if (
SI.isElementwise()) {
5028 Check(
SI.getOrdering() != AtomicOrdering::SequentiallyConsistent,
5029 "atomic elementwise store cannot be sequentially consistent.", &SI);
5033 "atomic elementwise store operand must have fixed vector type!",
5036 checkAtomicMemAccessSize(VecTy->getElementType(), &SI);
5042 "atomic store operand must have integer, byte, pointer, floating "
5043 "point, or vector type!",
5045 checkAtomicMemAccessSize(ElTy, &SI);
5047 Check(!
SI.isElementwise(),
"non-atomic store cannot be elementwise", &SI);
5049 "Non-atomic store cannot have SynchronizationScope specified", &SI);
5051 visitInstruction(SI);
5055void Verifier::verifySwiftErrorCall(CallBase &
Call,
5056 const Value *SwiftErrorVal) {
5058 if (
I.value() == SwiftErrorVal) {
5060 "swifterror value when used in a callsite should be marked "
5061 "with swifterror attribute",
5062 SwiftErrorVal,
Call);
5067void Verifier::verifySwiftErrorValue(
const Value *SwiftErrorVal) {
5070 for (
const User *U : SwiftErrorVal->
users()) {
5073 "swifterror value can only be loaded and stored from, or "
5074 "as a swifterror argument!",
5078 Check(StoreI->getOperand(1) == SwiftErrorVal,
5079 "swifterror value should be the second operand when used "
5083 verifySwiftErrorCall(*
const_cast<CallBase *
>(
Call), SwiftErrorVal);
5087void Verifier::visitAllocaInst(AllocaInst &AI) {
5090 Check(!MD->getZExtValue(),
5091 "Non-logical alloca disallowed for this module.");
5094 Check(Ty->
isSized(),
"Cannot allocate unsized type", &AI);
5098 "Alloca has illegal target extension type", &AI);
5100 "Alloca array size must have integer type", &AI);
5102 Check(
A->value() <= Value::MaximumAlignment,
5103 "huge alignment values are unsupported", &AI);
5109 "swifterror alloca must not be array allocation", &AI);
5110 verifySwiftErrorValue(&AI);
5113 visitInstruction(AI);
5119void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
5122 "cmpxchg operand must have integer or pointer type", ElTy, &CXI);
5123 checkAtomicMemAccessSize(ElTy, &CXI);
5124 visitInstruction(CXI);
5127void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
5129 "atomicrmw instructions cannot be unordered.", &RMWI);
5135 "atomicrmw elementwise cannot be sequentially consistent.", &RMWI);
5137 Check(VecTy,
"atomicrmw elementwise operand must have fixed vector type!",
5140 checkAtomicMemAccessSize(VecTy->getElementType(), &RMWI);
5147 " operand must be an integer type, a floating-point type, a "
5148 "pointer type, or a fixed vector of any of these types!",
5153 " operand must have floating-point or fixed vector of "
5160 " operand must have integer or fixed vector of integer type!",
5163 checkAtomicMemAccessSize(ElTy, &RMWI);
5165 "Invalid binary operation!", &RMWI);
5166 visitInstruction(RMWI);
5169void Verifier::visitFenceInst(FenceInst &FI) {
5171 Check(Ordering == AtomicOrdering::Acquire ||
5172 Ordering == AtomicOrdering::Release ||
5173 Ordering == AtomicOrdering::AcquireRelease ||
5174 Ordering == AtomicOrdering::SequentiallyConsistent,
5175 "fence instructions may only have acquire, release, acq_rel, or "
5176 "seq_cst ordering.",
5178 visitInstruction(FI);
5181void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
5184 "Invalid ExtractValueInst operands!", &EVI);
5186 visitInstruction(EVI);
5189void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
5193 "Invalid InsertValueInst operands!", &IVI);
5195 visitInstruction(IVI);
5200 return FPI->getParentPad();
5205void Verifier::visitEHPadPredecessors(Instruction &
I) {
5211 Check(BB != &
F->getEntryBlock(),
"EH pad cannot be in entry block.", &
I);
5219 Check(
II &&
II->getUnwindDest() == BB &&
II->getNormalDest() != BB,
5220 "Block containing LandingPadInst must be jumped to "
5221 "only by the unwind edge of an invoke.",
5229 "Block containg CatchPadInst must be jumped to "
5230 "only by its catchswitch.",
5232 Check(BB != CPI->getCatchSwitch()->getUnwindDest(),
5233 "Catchswitch cannot unwind to one of its catchpads",
5234 CPI->getCatchSwitch(), CPI);
5246 Check(
II->getUnwindDest() == BB &&
II->getNormalDest() != BB,
5247 "EH pad must be jumped to via an unwind edge", ToPad,
II);
5250 if (CalledFn && CalledFn->isIntrinsic() &&
II->doesNotThrow() &&
5254 FromPad = Bundle->Inputs[0];
5258 FromPad = CRI->getOperand(0);
5259 Check(FromPad != ToPadParent,
"A cleanupret must exit its cleanup", CRI);
5263 Check(
false,
"EH pad must be jumped to via an unwind edge", ToPad, TI);
5267 SmallPtrSet<Value *, 8> Seen;
5269 Check(FromPad != ToPad,
5270 "EH pad cannot handle exceptions raised within it", FromPad, TI);
5271 if (FromPad == ToPadParent) {
5276 "A single unwind edge may only enter one EH pad", TI);
5277 Check(Seen.
insert(FromPad).second,
"EH pad jumps through a cycle of pads",
5283 "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
5288void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
5292 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
5294 visitEHPadPredecessors(LPI);
5296 if (!LandingPadResultTy)
5297 LandingPadResultTy = LPI.
getType();
5300 "The landingpad instruction should have a consistent result type "
5301 "inside a function.",
5305 Check(
F->hasPersonalityFn(),
5306 "LandingPadInst needs to be in a function with a personality.", &LPI);
5311 "LandingPadInst not the first non-PHI instruction in the block.", &LPI);
5317 "Catch operand does not have pointer type!", &LPI);
5319 Check(LPI.
isFilter(i),
"Clause is neither catch nor filter!", &LPI);
5321 "Filter operand is not an array of constants!", &LPI);
5325 visitInstruction(LPI);
5328void Verifier::visitResumeInst(ResumeInst &RI) {
5330 "ResumeInst needs to be in a function with a personality.", &RI);
5332 if (!LandingPadResultTy)
5336 "The resume instruction should have a consistent result type "
5337 "inside a function.",
5340 visitTerminator(RI);
5343void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
5347 Check(
F->hasPersonalityFn(),
5348 "CatchPadInst needs to be in a function with a personality.", &CPI);
5351 "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
5357 "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
5362 return isa<Constant>(V) || isa<AllocaInst>(V);
5364 "Argument operand must be alloca or constant.", &CPI);
5366 visitEHPadPredecessors(CPI);
5367 visitFuncletPadInst(CPI);
5370void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
5372 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
5375 visitTerminator(CatchReturn);
5378void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
5382 Check(
F->hasPersonalityFn(),
5383 "CleanupPadInst needs to be in a function with a personality.", &CPI);
5388 "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
5392 "CleanupPadInst has an invalid parent.", &CPI);
5394 visitEHPadPredecessors(CPI);
5395 visitFuncletPadInst(CPI);
5398void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
5399 User *FirstUser =
nullptr;
5400 Value *FirstUnwindPad =
nullptr;
5402 SmallPtrSet<FuncletPadInst *, 8> Seen;
5404 while (!Worklist.empty()) {
5405 FuncletPadInst *CurrentPad = Worklist.pop_back_val();
5407 "FuncletPadInst must not be nested within itself", CurrentPad);
5408 Value *UnresolvedAncestorPad =
nullptr;
5409 for (User *U : CurrentPad->
users()) {
5412 UnwindDest = CRI->getUnwindDest();
5418 if (CSI->unwindsToCaller())
5420 UnwindDest = CSI->getUnwindDest();
5422 UnwindDest =
II->getUnwindDest();
5432 Worklist.push_back(CPI);
5447 if (UnwindParent == CurrentPad)
5453 Value *ExitedPad = CurrentPad;
5456 if (ExitedPad == &FPI) {
5461 UnresolvedAncestorPad = &FPI;
5465 if (ExitedParent == UnwindParent) {
5469 UnresolvedAncestorPad = ExitedParent;
5472 ExitedPad = ExitedParent;
5478 UnresolvedAncestorPad = &FPI;
5485 Check(UnwindPad == FirstUnwindPad,
5486 "Unwind edges out of a funclet "
5487 "pad must have the same unwind "
5489 &FPI, U, FirstUser);
5492 FirstUnwindPad = UnwindPad;
5501 if (CurrentPad != &FPI)
5504 if (UnresolvedAncestorPad) {
5505 if (CurrentPad == UnresolvedAncestorPad) {
5509 assert(CurrentPad == &FPI);
5517 Value *ResolvedPad = CurrentPad;
5518 while (!Worklist.empty()) {
5519 Value *UnclePad = Worklist.back();
5523 while (ResolvedPad != AncestorPad) {
5525 if (ResolvedParent == UnresolvedAncestorPad) {
5528 ResolvedPad = ResolvedParent;
5532 if (ResolvedPad != AncestorPad)
5535 Worklist.pop_back();
5540 if (FirstUnwindPad) {
5542 BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
5543 Value *SwitchUnwindPad;
5544 if (SwitchUnwindDest)
5548 Check(SwitchUnwindPad == FirstUnwindPad,
5549 "Unwind edges out of a catch must have the same unwind dest as "
5550 "the parent catchswitch",
5551 &FPI, FirstUser, CatchSwitch);
5555 visitInstruction(FPI);
5558void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
5562 Check(
F->hasPersonalityFn(),
5563 "CatchSwitchInst needs to be in a function with a personality.",
5569 "CatchSwitchInst not the first non-PHI instruction in the block.",
5574 "CatchSwitchInst has an invalid parent.", ParentPad);
5579 "CatchSwitchInst must unwind to an EH block which is not a "
5585 SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
5589 "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
5591 for (BasicBlock *Handler : CatchSwitch.
handlers()) {
5593 "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
5596 visitEHPadPredecessors(CatchSwitch);
5597 visitTerminator(CatchSwitch);
5600void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) {
5602 "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
5608 "CleanupReturnInst must unwind to an EH block which is not a "
5613 visitTerminator(CRI);
5616void Verifier::verifyDominatesUse(Instruction &
I,
unsigned i) {
5622 if (
II->getNormalDest() ==
II->getUnwindDest())
5636 const Use &
U =
I.getOperandUse(i);
5637 Check(DT.dominates(
Op, U),
"Instruction does not dominate all uses!",
Op, &
I);
5640void Verifier::visitDereferenceableMetadata(Instruction&
I, MDNode* MD) {
5641 Check(
I.getType()->isPointerTy(),
5642 "dereferenceable, dereferenceable_or_null "
5643 "apply only to pointer types",
5646 "dereferenceable, dereferenceable_or_null apply only to load"
5647 " and inttoptr instructions, use attributes for calls or invokes",
5650 "dereferenceable, dereferenceable_or_null "
5651 "take one operand!",
5656 "dereferenceable_or_null metadata value must be an i64!",
5660void Verifier::visitNoFreeObjMetadata(Instruction &
I, MDNode *MD) {
5661 Check(
I.getType()->isPointerTy(),
"nofreeobj applies only to pointer types",
5664 "nofreeobj applies only to inttoptr instruction", &
I);
5668void Verifier::visitProfMetadata(Instruction &
I, MDNode *MD) {
5669 auto GetBranchingTerminatorNumOperands = [&]() {
5670 unsigned ExpectedNumOperands = 0;
5674 ExpectedNumOperands =
SI->getNumSuccessors();
5676 ExpectedNumOperands = 1;
5678 ExpectedNumOperands = IBI->getNumDestinations();
5680 ExpectedNumOperands = 2;
5683 return ExpectedNumOperands;
5686 "!prof annotations should have at least 1 operand", MD);
5688 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null", MD);
5690 "expected string with name of the !prof annotation", MD);
5696 "'unknown' !prof should only appear on instructions on which "
5697 "'branch_weights' would",
5699 verifyUnknownProfileMetadata(MD);
5704 "!prof annotations should have no less than 2 operands", MD);
5710 Check(NumBranchWeights == 1 || NumBranchWeights == 2,
5711 "Wrong number of InvokeInst branch_weights operands", MD);
5713 const unsigned ExpectedNumOperands = GetBranchingTerminatorNumOperands();
5714 if (ExpectedNumOperands == 0)
5715 CheckFailed(
"!prof branch_weights are not allowed for this instruction",
5718 Check(NumBranchWeights == ExpectedNumOperands,
"Wrong number of operands",
5724 Check(MDO,
"second operand should not be null", MD);
5726 "!prof brunch_weights operand is not a const int");
5731 Check(KindInt,
"VP !prof missing kind argument", MD);
5734 Check(Kind >= InstrProfValueKind::IPVK_First &&
5735 Kind <= InstrProfValueKind::IPVK_Last,
5736 "Invalid VP !prof kind", MD);
5738 "VP !prof should have an even number "
5739 "of arguments after 'VP'",
5741 if (Kind == InstrProfValueKind::IPVK_IndirectCallTarget ||
5742 Kind == InstrProfValueKind::IPVK_MemOPSize)
5744 "VP !prof indirect call or memop size expected to be applied to "
5745 "CallBase instructions only",
5748 DenseSet<uint64_t> ProfileValues;
5750 ConstantInt *ProfileValue =
5752 Check(ProfileValue,
"VP !prof value operand is not a const int", MD);
5754 auto [ValueIt,
Inserted] = ProfileValues.
insert(ProfileValueInt);
5755 Check(Inserted,
"VP !prof should not have duplicate profile values", MD);
5758 CheckFailed(
"expected either branch_weights or VP profile name", MD);
5762void Verifier::visitDIAssignIDMetadata(Instruction &
I, MDNode *MD) {
5763 assert(
I.hasMetadata(LLVMContext::MD_DIAssignID));
5768 bool ExpectedInstTy =
5770 CheckDI(ExpectedInstTy,
"!DIAssignID attached to unexpected instruction kind",
5773 CheckDI(DVR->getFunction() ==
I.getFunction(),
5774 "DVRAssign not in same function as inst", DVR, &
I);
5777void Verifier::visitMMRAMetadata(Instruction &
I, MDNode *MD) {
5779 "!mmra metadata attached to unexpected instruction kind",
I, MD);
5790 for (
const MDOperand &MDOp : MD->
operands())
5792 "!mmra metadata tuple operand is not an MMRA tag",
I, MDOp.get());
5795void Verifier::visitCallStackMetadata(MDNode *MD) {
5799 "call stack metadata should have at least 1 operand", MD);
5803 "call stack metadata operand should be constant integer",
Op);
5806void Verifier::visitMemProfMetadata(Instruction &
I, MDNode *MD) {
5809 Check(
I.hasMetadata(LLVMContext::MD_callsite),
5810 "!memprof metadata requires !callsite metadata", &
I, MD);
5812 "!memprof annotations should have at least 1 metadata operand "
5817 for (
auto &MIBOp : MD->
operands()) {
5822 Check(MIB->getNumOperands() >= 2,
5823 "Each !memprof MemInfoBlock should have at least 2 operands", MIB);
5826 Check(MIB->getOperand(0) !=
nullptr,
5827 "!memprof MemInfoBlock first operand should not be null", MIB);
5829 "!memprof MemInfoBlock first operand should be an MDNode", MIB);
5831 visitCallStackMetadata(StackMD);
5835 "!memprof MemInfoBlock second operand should be an MDString", MIB);
5838 for (
unsigned I = 2;
I < MIB->getNumOperands(); ++
I) {
5840 Check(OpNode,
"Not all !memprof MemInfoBlock operands 2 to N are MDNode",
5842 Check(OpNode->getNumOperands() == 2,
5843 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with 2 "
5848 [](
const MDOperand &
Op) {
5849 return mdconst::hasa<ConstantInt>(Op);
5851 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with "
5852 "ConstantInt operands",
5858void Verifier::visitCallsiteMetadata(Instruction &
I, MDNode *MD) {
5862 visitCallStackMetadata(MD);
5865void Verifier::visitCalleeTypeMetadata(Instruction &
I, MDNode *MD) {
5870 "The callee_type metadata must be a list of callgraph metadata nodes",
5873 Check(CallgraphMD->getNumOperands() == 1,
5874 "Well-formed callgraph metadata must contain exactly one "
5878 "The operand of callgraph metadata for functions must be an MDString",
5883void Verifier::visitAnnotationMetadata(MDNode *Annotation) {
5886 "annotation must have at least one operand");
5888 bool TupleOfStrings =
5894 "operands must be a string or a tuple of strings");
5898void Verifier::visitAliasScopeMetadata(
const MDNode *MD) {
5903 "first scope operand must be self-referential or string", MD);
5906 "third scope operand must be string (if used)", MD);
5909 Check(
Domain !=
nullptr,
"second scope operand must be MDNode", MD);
5911 unsigned NumDomainOps =
Domain->getNumOperands();
5912 Check(NumDomainOps >= 2 && NumDomainOps <= 3,
5913 "domain must have two or three operands",
Domain);
5916 "first domain operand must be self-referential or string",
Domain);
5917 const auto *Disjoint =
5919 Check(Disjoint && Disjoint->getBitWidth() == 1,
5920 "second domain operand must be an i1 constant",
Domain);
5921 if (NumDomainOps == 3)
5923 "third domain operand must be string (if used)",
Domain);
5926void Verifier::visitAliasScopeListMetadata(
const MDNode *MD) {
5929 Check(OpMD !=
nullptr,
"scope list must consist of MDNodes", MD);
5930 visitAliasScopeMetadata(OpMD);
5934void Verifier::visitAccessGroupMetadata(
const MDNode *MD) {
5935 auto IsValidAccessScope = [](
const MDNode *MD) {
5950 Check(OpMD !=
nullptr,
"Access scope list must consist of MDNodes", MD);
5951 Check(IsValidAccessScope(OpMD),
5952 "Access scope list contains invalid access scope", MD);
5956void Verifier::visitCapturesMetadata(Instruction &
I,
const MDNode *Captures) {
5957 static const char *ValidArgs[] = {
"address_is_null",
"address",
5958 "read_provenance",
"provenance"};
5961 Check(SI,
"!captures metadata can only be applied to store instructions", &
I);
5962 Check(
SI->getValueOperand()->getType()->isPointerTy(),
5963 "!captures metadata can only be applied to store with value operand of "
5971 Check(Str,
"!captures metadata must be a list of strings", &
I);
5973 "invalid entry in !captures metadata", &
I, Str);
5977void Verifier::visitAllocTokenMetadata(Instruction &
I, MDNode *MD) {
5980 "!alloc_token must have 2 or 3 operands", MD);
5983 "expected integer constant", MD);
5986 "expected function name string", MD);
5989void Verifier::visitInlineHistoryMetadata(Instruction &
I, MDNode *MD) {
5998 ->stripPointerCastsAndAliases()),
5999 "!inline_history operands must be functions or null", MD);
6003void Verifier::visitMemCacheHintMetadata(Instruction &
I, MDNode *MD) {
6004 Check(
I.mayReadOrWriteMemory(),
6005 "!mem.cache_hint is only valid on memory operations", &
I);
6008 "!mem.cache_hint must have even number of operands "
6009 "(operand_no, hint_node pairs)",
6015 "!mem.cache_hint is not supported on non-intrinsic calls", &
I);
6017 unsigned NumOperands = CB ? CB->arg_size() :
I.getNumOperands();
6019 SmallDenseSet<unsigned, 4> SeenOperandNos;
6020 std::optional<uint64_t> LastOperandNo;
6026 "!mem.cache_hint must alternate between i32 operand numbers and "
6027 "metadata hint nodes",
6030 Check(OpNoCI->getValue().isNonNegative(),
6031 "!mem.cache_hint operand number must be non-negative", MD);
6033 uint64_t OperandNo = OpNoCI->getZExtValue();
6034 Check(OperandNo < NumOperands,
6035 "!mem.cache_hint operand number is out of range", &
I);
6038 CB ? CB->getArgOperand(OperandNo) :
I.getOperand(OperandNo);
6040 "!mem.cache_hint operand number must refer to a pointer operand", &
I);
6043 Check(Inserted,
"!mem.cache_hint contains duplicate operand number", MD);
6045 Check(!Inserted || !LastOperandNo || OperandNo > *LastOperandNo,
6046 "!mem.cache_hint operand numbers must be in increasing order", MD);
6047 LastOperandNo = OperandNo;
6051 "!mem.cache_hint must alternate between i32 operand numbers and "
6052 "metadata hint nodes",
6056 "!mem.cache_hint hint node must have even number of operands "
6057 "(key-value pairs)",
6060 StringSet<> SeenKeys;
6061 for (
unsigned K = 0;
K + 1 <
Node->getNumOperands();
K += 2) {
6063 Check(
Key,
"!mem.cache_hint key must be a string", Node);
6065 StringRef KeyStr =
Key->getString();
6067 "!mem.cache_hint hint node contains duplicate key", Node);
6072 "!mem.cache_hint value must be a string or integer", Node);
6079void Verifier::visitInstruction(Instruction &
I) {
6081 Check(BB,
"Instruction not embedded in basic block!", &
I);
6084 for (User *U :
I.users()) {
6085 Check(U != (User *)&
I || !DT.isReachableFromEntry(BB),
6086 "Only PHI nodes may reference their own value!", &
I);
6091 Check(!
I.getType()->isVoidTy() || !
I.hasName(),
6092 "Instruction has a name, but provides a void value!", &
I);
6096 Check(
I.getType()->isVoidTy() ||
I.getType()->isFirstClassType(),
6097 "Instruction returns a non-scalar type!", &
I);
6102 "Invalid use of metadata!", &
I);
6107 for (Use &U :
I.uses()) {
6110 "Instruction referencing"
6111 " instruction not embedded in a basic block!",
6114 CheckFailed(
"Use of instruction is not an instruction!", U);
6123 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i) {
6124 Check(
I.getOperand(i) !=
nullptr,
"Instruction has null operand!", &
I);
6128 if (!
I.getOperand(i)->getType()->isFirstClassType()) {
6129 Check(
false,
"Instruction operands must be first-class values!", &
I);
6135 auto IsAttachedCallOperand = [](
Function *
F,
const CallBase *CBI,
6137 return CBI && CBI->isOperandBundleOfType(
6145 Check((!
F->isIntrinsic() ||
6146 (CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i)) ||
6147 IsAttachedCallOperand(
F, CBI, i)),
6148 "Cannot take the address of an intrinsic!", &
I);
6150 F->getIntrinsicID() == Intrinsic::donothing ||
6151 F->getIntrinsicID() == Intrinsic::seh_try_begin ||
6152 F->getIntrinsicID() == Intrinsic::seh_try_end ||
6153 F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
6154 F->getIntrinsicID() == Intrinsic::seh_scope_end ||
6155 F->getIntrinsicID() == Intrinsic::coro_resume ||
6156 F->getIntrinsicID() == Intrinsic::coro_destroy ||
6157 F->getIntrinsicID() == Intrinsic::coro_await_suspend_void ||
6158 F->getIntrinsicID() == Intrinsic::coro_await_suspend_bool ||
6159 F->getIntrinsicID() == Intrinsic::coro_await_suspend_handle ||
6160 F->getIntrinsicID() ==
6161 Intrinsic::experimental_patchpoint_void ||
6162 F->getIntrinsicID() == Intrinsic::experimental_patchpoint ||
6163 F->getIntrinsicID() == Intrinsic::fake_use ||
6164 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
6165 F->getIntrinsicID() == Intrinsic::wasm_throw ||
6166 F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
6167 F->getIntrinsicID() == Intrinsic::bpf_unwind_exit ||
6168 IsAttachedCallOperand(
F, CBI, i),
6169 "Cannot invoke an intrinsic other than donothing, patchpoint, "
6170 "statepoint, coro_resume, coro_destroy, clang.arc.attachedcall, "
6171 "wasm.(re)throw or bpf.unwind.exit",
6173 Check(
F->getParent() == &M,
"Referencing function in another module!", &
I,
6174 &M,
F,
F->getParent());
6177 "Referring to a basic block in another function!", &
I);
6180 "Referring to an argument in another function!", &
I);
6182 Check(GV->
getParent() == &M,
"Referencing global in another module!", &
I,
6186 "Referring to an instruction in another function!", &
I);
6187 verifyDominatesUse(
I, i);
6189 Check(CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i),
6190 "Cannot take the address of an inline asm!", &
I);
6192 visitConstantExprsRecursively(
C);
6197 I.getAllMetadataOtherThanDebugLoc(MDs);
6198 for (
auto [Kind, MD] : MDs) {
6200 case LLVMContext::MD_fpmath:
6202 "fpmath requires a floating point result!", &
I);
6204 if (ConstantFP *CFP0 =
6206 const APFloat &Accuracy = CFP0->getValueAPF();
6208 "fpmath accuracy must have float type", &
I);
6210 "fpmath accuracy not a positive number!", &
I);
6212 Check(
false,
"invalid fpmath accuracy!", &
I);
6215 case LLVMContext::MD_range:
6217 "Ranges are only for loads, calls, invokes and phi nodes!", &
I);
6218 visitRangeMetadata(
I, MD,
I.getType());
6220 case LLVMContext::MD_nofpclass:
6222 "nofpclass is only for loads and phi nodes", &
I);
6223 visitNoFPClassMetadata(
I, MD,
I.getType());
6225 case LLVMContext::MD_noalias_addrspace:
6228 "noalias.addrspace are only for memory operations!", &
I);
6229 visitNoaliasAddrspaceMetadata(
I, MD,
I.getType());
6231 case LLVMContext::MD_invariant_group:
6233 "invariant.group metadata is only for loads and stores", &
I);
6235 case LLVMContext::MD_invariant_load: {
6238 "invariant.load metadata is only for loads and readonly "
6243 case LLVMContext::MD_nonnull:
6244 Check(
I.getType()->isPointerTy(),
"nonnull applies only to pointer types",
6247 "nonnull applies only to load instructions or phi nodes, use "
6248 "attributes for calls or invokes",
6252 case LLVMContext::MD_noundef:
6254 "noundef applies only to load instructions or phi nodes", &
I);
6257 case LLVMContext::MD_dereferenceable:
6258 case LLVMContext::MD_dereferenceable_or_null:
6259 visitDereferenceableMetadata(
I, MD);
6261 case LLVMContext::MD_nofreeobj:
6262 visitNoFreeObjMetadata(
I, MD);
6264 case LLVMContext::MD_tbaa:
6267 case LLVMContext::MD_tbaa_struct:
6270 case LLVMContext::MD_noalias:
6271 case LLVMContext::MD_alias_scope:
6272 visitAliasScopeListMetadata(MD);
6274 case LLVMContext::MD_access_group:
6275 visitAccessGroupMetadata(MD);
6277 case LLVMContext::MD_align: {
6278 Check(
I.getType()->isPointerTy(),
"align applies only to pointer types",
6281 "align applies only to load instructions or phi nodes, "
6282 "use attributes for calls or invokes",
6287 "align metadata value must be an i64!", &
I);
6291 Check(Align <= Value::MaximumAlignment,
6292 "alignment is larger that implementation defined limit", &
I);
6295 case LLVMContext::MD_prof:
6296 visitProfMetadata(
I, MD);
6298 case LLVMContext::MD_memprof:
6299 visitMemProfMetadata(
I, MD);
6301 case LLVMContext::MD_callsite:
6302 visitCallsiteMetadata(
I, MD);
6304 case LLVMContext::MD_callee_type:
6305 visitCalleeTypeMetadata(
I, MD);
6307 case LLVMContext::MD_DIAssignID:
6308 visitDIAssignIDMetadata(
I, MD);
6310 case LLVMContext::MD_mmra:
6311 visitMMRAMetadata(
I, MD);
6313 case LLVMContext::MD_annotation:
6314 visitAnnotationMetadata(MD);
6316 case LLVMContext::MD_captures:
6317 visitCapturesMetadata(
I, MD);
6319 case LLVMContext::MD_alloc_token:
6320 visitAllocTokenMetadata(
I, MD);
6322 case LLVMContext::MD_inline_history:
6323 visitInlineHistoryMetadata(
I, MD);
6325 case LLVMContext::MD_mem_cache_hint:
6326 visitMemCacheHintMetadata(
I, MD);
6329 if (Kind == MDAMDGPUExpectedActiveLanes) {
6331 "!amdgpu.expected.active.lanes must have exactly one operand", &
I,
6336 "!amdgpu.expected.active.lanes operand must be an i32 constant",
6338 }
else if (Kind == MDAMDGPUCFS) {
6340 "!amdgpu.cfs must have exactly one operand", &
I, MD);
6344 "!amdgpu.cfs operand must be an i32 constant", &
I, MD);
6346 "!amdgpu.cfs operand must be in the range [0, 3]", &
I, MD);
6352 if (MDNode *
N =
I.getDebugLoc().getAsMDNode()) {
6354 visitMDNode(*
N, AreDebugLocsAllowed::Yes);
6357 if (
DL->getAtomGroup()) {
6359 CheckDI(SP &&
SP->getKeyInstructionsEnabled(),
6360 "DbgLoc uses atomGroup but DISubprogram doesn't have Key "
6361 "Instructions enabled",
6367 for (
auto [Kind, MD] : MDs) {
6368 auto AllowLocs =
Kind == LLVMContext::MD_loop ? AreDebugLocsAllowed::Yes
6369 : AreDebugLocsAllowed::No;
6370 visitMDNode(*MD, AllowLocs);
6385 "const x86_amx is not allowed in argument!");
6397 case Intrinsic::assume: {
6401 "assume with operand bundles must have i1 true condition",
Call);
6407 auto GetTypeAt = [&](
unsigned Index) {
6408 return OBU.Inputs[
Index]->getType();
6413 CheckFailed(
"tags must be valid attribute names",
Call);
6415 case BundleAttr::Align:
6416 Check(OBU.Inputs.size() >= 2 && OBU.Inputs.size() <= 3,
6417 "alignment assumptions should have 2 or 3 arguments",
Call);
6420 Check(GetTypeAt(1)->isIntegerTy() &&
6421 GetTypeAt(1)->getIntegerBitWidth() <= 64,
6422 "second argument should be an integer with a maximum width of 64 "
6425 Check(OBU.Inputs.size() < 3 ||
6426 (GetTypeAt(2)->isIntegerTy() &&
6427 GetTypeAt(2)->getIntegerBitWidth() <= 64),
6428 "third argument should be an integer with a maximum width of 64 "
6432 case BundleAttr::Cold:
6433 Check(OBU.Inputs.size() == 0,
6434 "cold assumptions should have no arguments",
Call);
6436 case BundleAttr::Dereferenceable:
6437 case BundleAttr::DereferenceableOrNull:
6438 Check(OBU.Inputs.size() == 2,
6439 "dereferenceable assumptions should have 2 arguments",
Call);
6442 Check(GetTypeAt(1)->isIntegerTy() &&
6443 GetTypeAt(1)->getIntegerBitWidth() <= 64,
6444 "second argument should be an integer with a maximum width of 64 "
6448 case BundleAttr::Ignore:
6450 case BundleAttr::NonNull:
6451 Check(OBU.Inputs.size() == 1,
6452 "nonnull assumptions should have 1 argument",
Call);
6456 case BundleAttr::NoUndef:
6457 Check(OBU.Inputs.size() == 1,
6458 "noundef assumptions should have 1 argument",
Call);
6460 case BundleAttr::Range: {
6461 Check(OBU.Inputs.size() == 3,
6462 "range assumptions should have 3 arguments",
Call);
6463 Check(GetTypeAt(0)->isIntegerTy(),
6464 "first argument should be an integer",
Call);
6466 Check(LowerBound,
"second argument should be a constant integer",
Call);
6468 Check(UpperBound,
"third argument should be a constant integer",
Call);
6470 "an empty range has to be represented as `0, 0`");
6471 Check(GetTypeAt(0)->getIntegerBitWidth() ==
6472 GetTypeAt(1)->getIntegerBitWidth() &&
6473 GetTypeAt(1)->getIntegerBitWidth() ==
6474 GetTypeAt(2)->getIntegerBitWidth(),
6475 "all arguments should have the same bit width",
Call);
6477 case BundleAttr::SeparateStorage:
6478 Check(OBU.Inputs.size() == 2,
6479 "separate_storage assumptions should have 2 arguments",
Call);
6481 "arguments to separate_storage assumptions should be pointers",
6488 case Intrinsic::ucmp:
6489 case Intrinsic::scmp: {
6492 "result type must be at least 2 bits wide",
Call);
6495 case Intrinsic::coro_begin:
6496 case Intrinsic::coro_begin_custom_abi:
6498 "id argument of llvm.coro.begin must refer to coro.id");
6500 case Intrinsic::coro_id: {
6502 "align argument only accepts constants");
6505 "promise argument must refer to an alloca");
6510 "coro argument must refer to a function");
6514 if (BeforeCoroSplit)
6517 Check(!BeforeCoroEarly,
"cannot run CoroSplit before CoroEarly");
6519 Check(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
6520 "info argument of llvm.coro.id must refer to an initialized "
6522 Constant *Init = GV->getInitializer();
6524 "info argument of llvm.coro.id must refer to either a struct or "
6528 case Intrinsic::is_fpclass: {
6531 "unsupported bits for llvm.is.fpclass test mask");
6534 case Intrinsic::fptrunc_round: {
6539 MD = MAV->getMetadata();
6541 Check(MD !=
nullptr,
"missing rounding mode argument",
Call);
6544 (
"invalid value for llvm.fptrunc.round metadata operand"
6545 " (the operand should be a string)"),
6548 std::optional<RoundingMode> RoundMode =
6550 Check(RoundMode && *RoundMode != RoundingMode::Dynamic,
6551 "unsupported rounding mode argument",
Call);
6554 case Intrinsic::convert_to_arbitrary_fp: {
6559 Check(InterpMAV,
"missing interpretation metadata operand",
Call);
6561 Check(InterpStr,
"interpretation metadata operand must be a string",
Call);
6562 StringRef Interp = InterpStr->getString();
6564 Check(!Interp.
empty(),
"interpretation metadata string must not be empty",
6569 "unsupported interpretation metadata string",
Call);
6572 if (
unsigned FormatBits =
6575 "integer type bit width must equal the arbitrary FP format width",
6580 Check(RoundingMAV,
"missing rounding mode metadata operand",
Call);
6582 Check(RoundingStr,
"rounding mode metadata operand must be a string",
Call);
6584 std::optional<RoundingMode>
RM =
6586 Check(RM && *RM != RoundingMode::Dynamic,
6587 "unsupported rounding mode argument",
Call);
6590 case Intrinsic::convert_from_arbitrary_fp: {
6595 Check(InterpMAV,
"missing interpretation metadata operand",
Call);
6597 Check(InterpStr,
"interpretation metadata operand must be a string",
Call);
6598 StringRef Interp = InterpStr->getString();
6600 Check(!Interp.
empty(),
"interpretation metadata string must not be empty",
6605 "unsupported interpretation metadata string",
Call);
6608 if (
unsigned FormatBits =
6611 "integer type bit width must equal the arbitrary FP format width",
6615#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
6616#include "llvm/IR/VPIntrinsics.def"
6617#undef BEGIN_REGISTER_VP_INTRINSIC
6620#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
6621 case Intrinsic::INTRINSIC:
6622#include "llvm/IR/ConstrainedOps.def"
6626 case Intrinsic::dbg_declare:
6627 case Intrinsic::dbg_value:
6628 case Intrinsic::dbg_assign:
6629 case Intrinsic::dbg_label:
6636 case Intrinsic::memcpy:
6637 case Intrinsic::memcpy_inline:
6638 case Intrinsic::memmove:
6639 case Intrinsic::memset:
6640 case Intrinsic::memset_inline:
6642 case Intrinsic::experimental_memset_pattern: {
6644 Check(Memset->getValue()->getType()->isSized(),
6645 "unsized types cannot be used as memset patterns",
Call);
6648 case Intrinsic::memcpy_element_unordered_atomic:
6649 case Intrinsic::memmove_element_unordered_atomic:
6650 case Intrinsic::memset_element_unordered_atomic: {
6653 ConstantInt *ElementSizeCI =
6655 const APInt &ElementSizeVal = ElementSizeCI->
getValue();
6657 "element size of the element-wise atomic memory intrinsic "
6658 "must be a power of 2",
6661 auto IsValidAlignment = [&](MaybeAlign
Alignment) {
6664 Check(IsValidAlignment(AMI->getDestAlign()),
6665 "incorrect alignment of the destination argument",
Call);
6667 Check(IsValidAlignment(AMT->getSourceAlign()),
6668 "incorrect alignment of the source argument",
Call);
6672 case Intrinsic::call_preallocated_setup: {
6674 bool FoundCall =
false;
6677 Check(UseCall !=
nullptr,
6678 "Uses of llvm.call.preallocated.setup must be calls");
6680 if (IID == Intrinsic::call_preallocated_arg) {
6682 Check(AllocArgIndex !=
nullptr,
6683 "llvm.call.preallocated.alloc arg index must be a constant");
6684 auto AllocArgIndexInt = AllocArgIndex->getValue();
6685 Check(AllocArgIndexInt.sge(0) &&
6686 AllocArgIndexInt.slt(NumArgs->getValue()),
6687 "llvm.call.preallocated.alloc arg index must be between 0 and "
6689 "llvm.call.preallocated.setup's argument count");
6690 }
else if (IID == Intrinsic::call_preallocated_teardown) {
6693 Check(!FoundCall,
"Can have at most one call corresponding to a "
6694 "llvm.call.preallocated.setup");
6696 size_t NumPreallocatedArgs = 0;
6697 for (
unsigned i = 0; i < UseCall->arg_size(); i++) {
6698 if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
6699 ++NumPreallocatedArgs;
6702 Check(NumPreallocatedArgs != 0,
6703 "cannot use preallocated intrinsics on a call without "
6704 "preallocated arguments");
6705 Check(NumArgs->equalsInt(NumPreallocatedArgs),
6706 "llvm.call.preallocated.setup arg size must be equal to number "
6707 "of preallocated arguments "
6717 auto PreallocatedBundle =
6719 Check(PreallocatedBundle,
6720 "Use of llvm.call.preallocated.setup outside intrinsics "
6721 "must be in \"preallocated\" operand bundle");
6722 Check(PreallocatedBundle->Inputs.front().get() == &
Call,
6723 "preallocated bundle must have token from corresponding "
6724 "llvm.call.preallocated.setup");
6729 case Intrinsic::call_preallocated_arg: {
6732 Token->getIntrinsicID() == Intrinsic::call_preallocated_setup,
6733 "llvm.call.preallocated.arg token argument must be a "
6734 "llvm.call.preallocated.setup");
6736 "llvm.call.preallocated.arg must be called with a \"preallocated\" "
6737 "call site attribute");
6740 case Intrinsic::call_preallocated_teardown: {
6743 Token->getIntrinsicID() == Intrinsic::call_preallocated_setup,
6744 "llvm.call.preallocated.teardown token argument must be a "
6745 "llvm.call.preallocated.setup");
6748 case Intrinsic::gcroot:
6749 case Intrinsic::gcwrite:
6750 case Intrinsic::gcread:
6751 if (ID == Intrinsic::gcroot) {
6754 Check(AI,
"llvm.gcroot parameter #1 must be an alloca.",
Call);
6756 "llvm.gcroot parameter #2 must be a constant.",
Call);
6759 "llvm.gcroot parameter #1 must either be a pointer alloca, "
6760 "or argument #2 must be a non-null constant.",
6766 "Enclosing function does not use GC.",
Call);
6768 case Intrinsic::init_trampoline:
6770 "llvm.init_trampoline parameter #2 must resolve to a function.",
6773 case Intrinsic::reloc_none: {
6776 "llvm.reloc.none argument must be a metadata string", &
Call);
6779 case Intrinsic::stackprotector:
6781 "llvm.stackprotector parameter #2 must resolve to an alloca.",
Call);
6783 case Intrinsic::localescape: {
6787 Check(!SawFrameEscape,
"multiple calls to llvm.localescape in one function",
6794 "llvm.localescape only accepts static allocas",
Call);
6797 SawFrameEscape =
true;
6800 case Intrinsic::localrecover: {
6803 Check(Fn && !Fn->isDeclaration(),
6804 "llvm.localrecover first "
6805 "argument must be function defined in this module",
6808 auto &
Entry = FrameEscapeInfo[Fn];
6809 Entry.second = unsigned(
6810 std::max(
uint64_t(
Entry.second), IdxArg->getLimitedValue(~0U) + 1));
6814 case Intrinsic::experimental_gc_statepoint:
6816 Check(!CI->isInlineAsm(),
6817 "gc.statepoint support for inline assembly unimplemented", CI);
6819 "Enclosing function does not use GC.",
Call);
6821 verifyStatepoint(
Call);
6823 case Intrinsic::experimental_gc_result: {
6825 "Enclosing function does not use GC.",
Call);
6833 Check(StatepointCall && StatepointCall->getIntrinsicID() ==
6834 Intrinsic::experimental_gc_statepoint,
6835 "gc.result operand #1 must be from a statepoint",
Call,
6839 auto *TargetFuncType =
6842 "gc.result result type does not match wrapped callee",
Call);
6845 case Intrinsic::experimental_gc_relocate: {
6847 "gc.relocate must return a pointer or a vector of pointers",
Call);
6855 LandingPad->getParent()->getUniquePredecessor();
6859 Check(InvokeBB,
"safepoints should have unique landingpads",
6860 LandingPad->getParent());
6862 "gc relocate should be linked to a statepoint", InvokeBB);
6869 "gc relocate is incorrectly tied to the statepoint",
Call, Token);
6878 "gc.relocate operand #2 must be integer offset",
Call);
6882 "gc.relocate operand #3 must be integer offset",
Call);
6892 Check(BaseIndex < Opt->Inputs.size(),
6893 "gc.relocate: statepoint base index out of bounds",
Call);
6894 Check(DerivedIndex < Opt->Inputs.size(),
6895 "gc.relocate: statepoint derived index out of bounds",
Call);
6903 "gc.relocate: relocated value must be a pointer",
Call);
6904 Check(DerivedType->isPtrOrPtrVectorTy(),
6905 "gc.relocate: relocated value must be a pointer",
Call);
6907 "gc.relocate: must return the type of the relocated value",
Call);
6910 Check(GC,
"gc.relocate: calling function must have GCStrategy",
6913 auto isGCPtr = [&
GC](
Type *PTy) {
6914 return GC->isGCManagedPointer(PTy->getScalarType()).value_or(
true);
6917 "gc.relocate: relocated value must be a gc pointer",
Call);
6918 Check(isGCPtr(DerivedType),
6919 "gc.relocate: relocated value must be a gc pointer",
Call);
6923 case Intrinsic::experimental_patchpoint: {
6926 "patchpoint: invalid return type used with anyregcc",
Call);
6930 case Intrinsic::eh_exceptioncode:
6931 case Intrinsic::eh_exceptionpointer: {
6933 "eh.exceptionpointer argument must be a catchpad",
Call);
6936 case Intrinsic::get_active_lane_mask: {
6939 "get_active_lane_mask: element type is not i1",
Call);
6942 case Intrinsic::mask_beforefirst: {
6944 "mask.beforefirst element type must be i1",
Call);
6947 case Intrinsic::experimental_get_vector_length: {
6949 Check(!VF->isNegative() && !VF->isZero(),
6950 "get_vector_length: VF must be positive",
Call);
6953 case Intrinsic::experimental_guard: {
6956 "experimental_guard must have exactly one "
6957 "\"deopt\" operand bundle");
6961 case Intrinsic::experimental_deoptimize: {
6965 "experimental_deoptimize must have exactly one "
6966 "\"deopt\" operand bundle");
6968 "experimental_deoptimize return type must match caller return type");
6973 "calls to experimental_deoptimize must be followed by a return");
6977 "calls to experimental_deoptimize must be followed by a return "
6978 "of the value computed by experimental_deoptimize");
6983 case Intrinsic::vastart: {
6985 "va_start called in a non-varargs function");
6988 case Intrinsic::get_dynamic_area_offset: {
6989 Check(
DL.getPointerSizeInBits(
DL.getAllocaAddrSpace()) ==
6991 "get_dynamic_area_offset result type must match alloca address "
6996 case Intrinsic::smul_fix:
6997 case Intrinsic::smul_fix_sat:
6998 case Intrinsic::umul_fix:
6999 case Intrinsic::umul_fix_sat:
7000 case Intrinsic::sdiv_fix:
7001 case Intrinsic::sdiv_fix_sat:
7002 case Intrinsic::udiv_fix:
7003 case Intrinsic::udiv_fix_sat: {
7007 if (ID == Intrinsic::smul_fix || ID == Intrinsic::smul_fix_sat ||
7008 ID == Intrinsic::sdiv_fix || ID == Intrinsic::sdiv_fix_sat) {
7010 "the scale of s[mul|div]_fix[_sat] must be less than the width of "
7014 "the scale of u[mul|div]_fix[_sat] must be less than or equal "
7015 "to the width of the operands");
7019 case Intrinsic::bswap: {
7022 Check(
Size % 16 == 0,
"bswap must be an even number of bytes", &
Call);
7025 case Intrinsic::invariant_start: {
7027 Check(InvariantSize &&
7028 (!InvariantSize->isNegative() || InvariantSize->isMinusOne()),
7029 "invariant_start parameter must be -1, 0 or a positive number",
7033 case Intrinsic::matrix_multiply:
7034 case Intrinsic::matrix_transpose:
7035 case Intrinsic::matrix_column_major_load:
7036 case Intrinsic::matrix_column_major_store: {
7038 Value *Stride =
nullptr;
7039 ConstantInt *NumRows;
7040 ConstantInt *NumColumns;
7041 FixedVectorType *ResultTy;
7042 Type *Op0ElemTy =
nullptr;
7043 Type *Op1ElemTy =
nullptr;
7045 case Intrinsic::matrix_multiply: {
7052 Check(Op0Ty && Op1Ty && RetTy,
7053 "Matrix operations require fixed-length vectors!", &
Call);
7054 Check(Op0Ty->getNumElements() ==
7056 "First argument of a matrix operation does not match specified "
7058 Check(Op1Ty->getNumElements() ==
7060 "Second argument of a matrix operation does not match specified "
7064 Op0ElemTy = Op0Ty->getElementType();
7065 Op1ElemTy = Op1Ty->getElementType();
7068 case Intrinsic::matrix_transpose: {
7073 Check(Op0Ty && RetTy,
"Matrix operations require fixed-length vectors!",
7076 Op0ElemTy = Op0Ty->getElementType();
7079 case Intrinsic::matrix_column_major_load: {
7084 Check(RetTy,
"Matrix operations require fixed-length vectors!", &
Call);
7088 case Intrinsic::matrix_column_major_store: {
7093 Check(Op0Ty,
"Matrix operations require fixed-length vectors!", &
Call);
7095 Op0ElemTy = Op0Ty->getElementType();
7104 "Result type must be an integer or floating-point type!", IF);
7108 "Vector element type mismatch of the result and first operand "
7114 "Vector element type mismatch of the result and second operand "
7120 "Result of a matrix operation does not fit in the returned vector!");
7124 "Stride bitwidth cannot exceed 64!", IF);
7128 case Intrinsic::stepvector: {
7130 Check(VecTy->getScalarSizeInBits() >= 8,
7131 "stepvector only supported for vectors of integers "
7132 "with a bitwidth of at least 8.",
7136 case Intrinsic::experimental_vector_match: {
7144 "Second operand must be a fixed length vector.", &
Call);
7145 Check(Op1Ty->getElementType() == Op2Ty->getElementType(),
7146 "First two operands must have the same element type.", &
Call);
7149 case Intrinsic::speculative_load: {
7152 "llvm.speculative.load return type must be a byte type or a "
7158 "llvm.speculative.load byte type must have a bit width that is "
7163 uint64_t MinSizeInBits =
DL.getTypeSizeInBits(LoadTy).getKnownMinValue();
7165 "llvm.speculative.load return type size in bytes must be a "
7166 "positive power of 2",
7169 constexpr unsigned NumFixedArgs = 3;
7171 Check(NumArgs >= NumFixedArgs,
7172 "llvm.speculative.load requires at least 3 arguments", &
Call);
7177 Check(NumArgs == NumFixedArgs,
7178 "llvm.speculative.load direct form has too many arguments", &
Call);
7183 "llvm.speculative.load third argument must be i64 or a direct "
7184 "reference to an oracle function",
7187 Check(OracleFn->hasFnAttribute(
"oracle-function"),
7188 "llvm.speculative.load oracle function must have the "
7189 "\"oracle-function\" attribute",
7192 FunctionType *FTy = OracleFn->getFunctionType();
7193 Check(NumArgs - NumFixedArgs == FTy->getNumParams(),
7194 "llvm.speculative.load oracle function argument count mismatch",
7196 for (
auto [ParamTy, Arg] :
7198 Check(ParamTy == Arg->getType(),
7199 "llvm.speculative.load oracle function argument type mismatch",
7204 case Intrinsic::vector_repeat: {
7208 Check(ArgTy,
"vector_repeat argument must be a fixed-length vector.",
7210 Check(ResultTy,
"vector_repeat result must be a scalable vector.", &
Call);
7212 "vector_repeat argument and result must have the same element "
7215 Check(ArgTy->getNumElements() == ResultTy->getMinNumElements(),
7216 "vector_repeat argument and result must have the same minimum "
7221 case Intrinsic::vector_shuffle: {
7225 Check(MaskTy->getElementCount() == RetTy->getElementCount(),
7226 "vector_shuffle mask must have the same number of elements as the "
7231 case Intrinsic::vector_insert: {
7240 ElementCount VecEC = VecTy->getElementCount();
7241 ElementCount SubVecEC =
SubVecTy->getElementCount();
7242 Check(VecTy->getElementType() ==
SubVecTy->getElementType(),
7243 "vector_insert parameters must have the same element "
7247 "vector_insert index must be a constant multiple of "
7248 "the subvector's known minimum vector length.");
7253 Check(VecEC.
isScalable(),
"cannot vector_insert a scalable vector into "
7263 "subvector operand of vector_insert would overrun the "
7264 "vector being inserted into.");
7268 case Intrinsic::vector_extract: {
7276 ElementCount VecEC = VecTy->getElementCount();
7277 ElementCount ResultEC = ResultTy->getElementCount();
7279 Check(ResultTy->getElementType() == VecTy->getElementType(),
7280 "vector_extract result must have the same element "
7281 "type as the input vector.",
7284 "vector_extract index must be a constant multiple of "
7285 "the result type's known minimum vector length.");
7290 Check(VecEC.
isScalable(),
"cannot vector_extract a scalable vector from "
7300 "vector_extract would overrun.");
7304 case Intrinsic::vector_partial_reduce_fadd:
7305 case Intrinsic::vector_partial_reduce_add: {
7309 unsigned VecWidth = VecTy->getElementCount().getKnownMinValue();
7310 unsigned AccWidth = AccTy->getElementCount().getKnownMinValue();
7312 Check((VecWidth % AccWidth) == 0,
7313 "Invalid vector widths for partial "
7314 "reduction. The width of the input vector "
7315 "must be a positive integer multiple of "
7316 "the width of the accumulator vector.");
7318 Check(AccTy->getElementType() == VecTy->getElementType(),
7319 "The element type of the input vector must match the element type "
7320 "of the accumulator vector.",
7324 case Intrinsic::experimental_noalias_scope_decl: {
7328 case Intrinsic::preserve_array_access_index:
7329 case Intrinsic::preserve_struct_access_index:
7330 case Intrinsic::aarch64_ldaxr:
7331 case Intrinsic::aarch64_ldxr:
7332 case Intrinsic::arm_ldaex:
7333 case Intrinsic::arm_ldrex: {
7335 Check(ElemTy,
"Intrinsic requires elementtype attribute on first argument.",
7339 case Intrinsic::aarch64_stlxr:
7340 case Intrinsic::aarch64_stxr:
7341 case Intrinsic::arm_stlex:
7342 case Intrinsic::arm_strex: {
7345 "Intrinsic requires elementtype attribute on second argument.",
7349 case Intrinsic::aarch64_prefetch: {
7351 "write argument to llvm.aarch64.prefetch must be 0 or 1",
Call);
7353 "target argument to llvm.aarch64.prefetch must be 0-3",
Call);
7355 "stream argument to llvm.aarch64.prefetch must be 0 or 1",
Call);
7357 "isdata argument to llvm.aarch64.prefetch must be 0 or 1",
Call);
7360 case Intrinsic::aarch64_range_prefetch: {
7362 "write argument to llvm.aarch64.range.prefetch must be 0 or 1",
Call);
7364 "stream argument to llvm.aarch64.range.prefetch must be 0 or 1",
7368 case Intrinsic::riscv_vsetvli:
7369 case Intrinsic::riscv_vsetvlimax: {
7374 "llvm.riscv.vsetvli/vsetvlimax result must be i32 or i64", &
Call);
7377 bool HasAVL =
ID == Intrinsic::riscv_vsetvli;
7378 unsigned Offset = HasAVL ? 1 : 0;
7383 Check(VSEW <= 3,
"llvm.riscv.vsetvli/vsetvlimax VSEW must be 0-3", &
Call);
7385 "llvm.riscv.vsetvli/vsetvlimax VLMUL is reserved", &
Call);
7388 case Intrinsic::riscv_sati: {
7392 "llvm.riscv.sati immediate must be in the range [1, bitwidth]",
7396 case Intrinsic::riscv_usati: {
7400 "llvm.riscv.usati immediate must be in the range [0, bitwidth-1]",
7404 case Intrinsic::callbr_landingpad: {
7406 Check(CBR,
"intrinstic requires callbr operand", &
Call);
7413 CheckFailed(
"Intrinsic in block must have 1 unique predecessor", &
Call);
7417 CheckFailed(
"Intrinsic must have corresponding callbr in predecessor",
7422 "Intrinsic's corresponding callbr must have intrinsic's parent basic "
7423 "block in indirect destination list",
7426 Check(&
First == &
Call,
"No other instructions may proceed intrinsic",
7430 case Intrinsic::structured_gep: {
7436 "Intrinsic first parameter is missing an ElementType attribute",
7444 "Index operand type must be an integer", &
Call);
7447 T = AT->getElementType();
7449 Check(CI,
"Indexing into a struct requires a constant int", &
Call);
7451 "Indexing in a struct should be inbounds", &
Call);
7454 T = VT->getElementType();
7456 CheckFailed(
"Reached a non-composite type with more indices to process",
7462 case Intrinsic::structured_alloca:
7464 "@llvm.structured.alloca calls require elementtype attribute.",
7467 case Intrinsic::nvvm_setmaxnreg_inc_sync_aligned_u32:
7468 case Intrinsic::nvvm_setmaxnreg_dec_sync_aligned_u32: {
7471 Check(RegCount % 8 == 0,
7472 "reg_count argument to nvvm.setmaxnreg must be in multiples of 8");
7475 case Intrinsic::nvvm_cp_async_bulk_global_to_shared_cta:
7476 case Intrinsic::nvvm_cp_async_bulk_global_to_shared_cta_relaxed: {
7478 const unsigned FlagValidPatternIndex = ArgSize - 1;
7479 const unsigned IgnoreOOBFlagIndex = 8;
7482 const auto *FlagValidPattern =
7484 Check(!IgnoreOOB || FlagValidPattern->isZero(),
7485 "flag_valid_pattern must be 0 (disabled) when ignore_oob is enabled",
7489 case Intrinsic::experimental_convergence_entry:
7490 case Intrinsic::experimental_convergence_anchor:
7492 case Intrinsic::experimental_convergence_loop:
7494 case Intrinsic::ptrmask: {
7498 "llvm.ptrmask intrinsic first argument must be pointer or vector "
7502 "llvm.ptrmask intrinsic second argument bitwidth must match "
7503 "pointer index type size of first argument",
7507 case Intrinsic::thread_pointer: {
7509 DL.getDefaultGlobalsAddressSpace(),
7510 "llvm.thread.pointer intrinsic return type must be for the globals "
7515 case Intrinsic::threadlocal_address: {
7518 "llvm.threadlocal.address first argument must be a GlobalValue");
7520 "llvm.threadlocal.address operand isThreadLocal() must be true");
7523 case Intrinsic::lifetime_start:
7524 case Intrinsic::lifetime_end: {
7528 (
II &&
II->getIntrinsicID() == Intrinsic::structured_alloca),
7529 "llvm.lifetime.start/end can only be used on alloca or poison",
7533 case Intrinsic::sponentry: {
7534 const unsigned StackAS =
DL.getAllocaAddrSpace();
7537 "llvm.sponentry must return a pointer to the stack", &
Call);
7540 case Intrinsic::write_volatile_register: {
7544 "llvm.write_volatile_register metadata must be a single MDString",
7548 case Intrinsic::ptrauth_auth_with_pc_and_resign: {
7553 "ptrauth.auth.with.pc.and.resign key must be IA (0) or IB (1)",
7562 if (
F->hasPersonalityFn() &&
7566 if (BlockEHFuncletColors.
empty())
7573 auto ColorsIt = BlockEHFuncletColors.
find(CallBB);
7574 if (ColorsIt != BlockEHFuncletColors.
end()) {
7576 bool InEHFunclet =
false;
7579 for (BasicBlock *ColorFirstBB : CV)
7580 if (
auto It = ColorFirstBB->getFirstNonPHIIt();
7581 It != ColorFirstBB->end())
7586 bool HasToken =
false;
7593 Check(HasToken,
"Missing funclet token on intrinsic call", &
Call);
7607DISubprogram *Verifier::getSubprogram(
Metadata *LocalScope) {
7608 if (hasDIScopeCycle(LocalScope))
7625void Verifier::visit(DbgLabelRecord &DLR) {
7627 "invalid #dbg_label intrinsic variable", &DLR, DLR.
getRawLabel());
7640 CheckDI(Loc,
"#dbg_label record requires a !dbg attachment", &DLR, BB,
F);
7644 if (!LabelSP || !LocSP)
7648 "mismatched subprogram between #dbg_label label and !dbg attachment",
7649 &DLR, BB,
F, Label,
Label->getScope()->getSubprogram(), Loc,
7650 Loc->getScope()->getSubprogram());
7653void Verifier::visit(DbgVariableRecord &DVR) {
7657 CheckDI(DVR.
getType() == DbgVariableRecord::LocationType::Value ||
7658 DVR.
getType() == DbgVariableRecord::LocationType::Declare ||
7659 DVR.
getType() == DbgVariableRecord::LocationType::DeclareValue ||
7660 DVR.
getType() == DbgVariableRecord::LocationType::Assign,
7661 "invalid #dbg record type", &DVR, DVR.
getType(), BB,
F);
7669 "invalid #dbg record address/value", &DVR, MD, BB,
F);
7671 "!DIAssignID should only be used by Assign DVRs.", MD, &DVR);
7673 visitValueAsMetadata(*VAM,
F);
7676 Type *Ty = VAM->getValue()->getType();
7678 "location of #dbg_declare must be a pointer or int", &DVR, MD, BB,
7682 visitDIArgList(*AL,
F);
7698 for (DIExpression::ExprOperand
Op : Expr->
expr_ops()) {
7702 "#dbg record expression references nonexistent location operand",
7709 "invalid #dbg_assign DIAssignID", &DVR, DVR.
getRawAssignID(), BB,
7712 AreDebugLocsAllowed::No);
7721 "invalid #dbg_assign address", &DVR, DVR.
getRawAddress(), BB,
F);
7723 visitValueAsMetadata(*VAM,
F);
7726 "invalid #dbg_assign address expression", &DVR,
7733 "inst not in same function as #dbg_assign",
I, &DVR, BB,
F);
7743 &DVR, DLNode, BB,
F);
7749 if (!VarSP || !LocSP)
7753 "mismatched subprogram between #dbg record variable and DILocation",
7755 Loc->getScope()->getSubprogram(), BB,
F);
7760void Verifier::visitVPIntrinsic(VPIntrinsic &VPI) {
7762 case Intrinsic::experimental_vp_splice: {
7765 int64_t KnownMinNumElements = VecTy->getElementCount().getKnownMinValue();
7767 AttributeList
Attrs = VPI.
getParent()->getParent()->getAttributes();
7768 if (
Attrs.hasFnAttr(Attribute::VScaleRange))
7769 KnownMinNumElements *=
Attrs.getFnAttrs().getVScaleRangeMin();
7771 Check((Idx < 0 && std::abs(Idx) <= KnownMinNumElements) ||
7772 (Idx >= 0 && Idx < KnownMinNumElements),
7773 "The splice index exceeds the range [-VL, VL-1] where VL is the "
7774 "known minimum number of elements in the vector. For scalable "
7775 "vectors the minimum number of elements is determined from "
7783void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) {
7785 case Intrinsic::experimental_constrained_fcmp:
7786 case Intrinsic::experimental_constrained_fcmps: {
7789 "invalid predicate for constrained FP comparison intrinsic", &FPI);
7793 case Intrinsic::experimental_constrained_fptrunc:
7794 case Intrinsic::experimental_constrained_fpext: {
7797 if (FPI.
getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
7799 "Intrinsic first argument's type must be larger than result type",
7803 "Intrinsic first argument's type must be smaller than result type",
7819 "invalid exception behavior argument", &FPI);
7826void Verifier::verifyFragmentExpression(
const DbgVariableRecord &DVR) {
7831 if (!
V || !
E || !
E->isValid())
7845 if (
V->isArtificial())
7848 verifyFragmentExpression(*
V, *
Fragment, &DVR);
7851template <
typename ValueOrMetadata>
7852void Verifier::verifyFragmentExpression(
const DIVariable &
V,
7854 ValueOrMetadata *
Desc) {
7857 auto VarSize =
V.getSizeInBits();
7861 unsigned FragSize =
Fragment.SizeInBits;
7862 unsigned FragOffset =
Fragment.OffsetInBits;
7863 CheckDI(FragSize + FragOffset <= *VarSize,
7864 "fragment is larger than or outside of variable",
Desc, &
V);
7865 CheckDI(FragSize != *VarSize,
"fragment covers entire variable",
Desc, &
V);
7868void Verifier::verifyFnArgs(
const DbgVariableRecord &DVR) {
7880 CheckDI(Var,
"#dbg record without variable");
7882 unsigned ArgNo = Var->
getArg();
7888 if (DebugFnArgs.
size() < ArgNo)
7889 DebugFnArgs.
resize(ArgNo,
nullptr);
7891 auto *Prev = DebugFnArgs[ArgNo - 1];
7892 DebugFnArgs[ArgNo - 1] = Var;
7893 CheckDI(!Prev || (Prev == Var),
"conflicting debug info for argument", &DVR,
7897void Verifier::verifyNotEntryValue(
const DbgVariableRecord &DVR) {
7901 if (!
E || !
E->isValid())
7911 ArgLoc && ArgLoc->hasAttribute(Attribute::SwiftAsync))
7916 "Entry values are only allowed in MIR unless they target a "
7917 "swiftasync Argument",
7921void Verifier::verifyCompileUnits() {
7925 if (
M.getContext().isODRUniquingDebugTypes())
7927 auto *CUs =
M.getNamedMetadata(
"llvm.dbg.cu");
7928 SmallPtrSet<const Metadata *, 2> Listed;
7931 for (
const auto *CU : CUVisited)
7932 CheckDI(Listed.
count(CU),
"DICompileUnit not listed in llvm.dbg.cu", CU);
7936void Verifier::verifyDeoptimizeCallingConvs() {
7937 if (DeoptimizeDeclarations.
empty())
7941 for (
const auto *
F :
ArrayRef(DeoptimizeDeclarations).slice(1)) {
7942 Check(
First->getCallingConv() ==
F->getCallingConv(),
7943 "All llvm.experimental.deoptimize declarations must have the same "
7944 "calling convention",
7949void Verifier::verifyAttachedCallBundle(
const CallBase &
Call,
7950 const OperandBundleUse &BU) {
7953 Check((FTy->getReturnType()->isPointerTy() ||
7955 "a call with operand bundle \"clang.arc.attachedcall\" must call a "
7956 "function returning a pointer or a non-returning function that has a "
7961 "operand bundle \"clang.arc.attachedcall\" requires one function as "
7969 Check((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
7970 IID == Intrinsic::objc_claimAutoreleasedReturnValue ||
7971 IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue),
7972 "invalid function argument",
Call);
7974 StringRef FnName = Fn->getName();
7975 Check((FnName ==
"objc_retainAutoreleasedReturnValue" ||
7976 FnName ==
"objc_claimAutoreleasedReturnValue" ||
7977 FnName ==
"objc_unsafeClaimAutoreleasedReturnValue"),
7978 "invalid function argument",
Call);
7982void Verifier::verifyNoAliasScopeDecl() {
7983 if (NoAliasScopeDecls.
empty())
7987 for (
auto *
II : NoAliasScopeDecls) {
7988 assert(
II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl &&
7989 "Not a llvm.experimental.noalias.scope.decl ?");
7992 Check(ScopeListMV !=
nullptr,
7993 "llvm.experimental.noalias.scope.decl must have a MetadataAsValue "
7998 Check(ScopeListMD !=
nullptr,
"!id.scope.list must point to an MDNode",
II);
7999 Check(ScopeListMD->getNumOperands() == 1,
8000 "!id.scope.list must point to a list with a single scope",
II);
8001 visitAliasScopeListMetadata(ScopeListMD);
8006 if (!
getIROptions(
M.getContext()).verify_noalias_scope_decl_dom)
8011 auto GetScope = [](IntrinsicInst *
II) {
8014 return &
cast<MDNode>(ScopeListMV->getMetadata())->getOperand(0);
8019 auto Compare = [GetScope](IntrinsicInst *Lhs, IntrinsicInst *Rhs) {
8020 return GetScope(Lhs) < GetScope(Rhs);
8027 auto ItCurrent = NoAliasScopeDecls.begin();
8028 while (ItCurrent != NoAliasScopeDecls.end()) {
8029 auto CurScope = GetScope(*ItCurrent);
8030 auto ItNext = ItCurrent;
8033 }
while (ItNext != NoAliasScopeDecls.end() &&
8034 GetScope(*ItNext) == CurScope);
8039 if (ItNext - ItCurrent < 32)
8043 Check(!DT.dominates(
I, J),
8044 "llvm.experimental.noalias.scope.decl dominates another one "
8045 "with the same scope",
8059 Verifier
V(OS,
true, *f.getParent());
8063 return !V.verify(
F);
8067 bool *BrokenDebugInfo) {
8069 Verifier
V(OS, !BrokenDebugInfo, M);
8071 bool Broken =
false;
8073 Broken |= !V.verify(
F);
8075 Broken |= !V.verify();
8076 if (BrokenDebugInfo)
8077 *BrokenDebugInfo = V.hasBrokenDebugInfo();
8088 std::unique_ptr<Verifier>
V;
8089 bool FatalErrors =
true;
8092 explicit VerifierLegacyPass(
bool FatalErrors)
8093 : FunctionPass(
ID), FatalErrors(FatalErrors) {}
8095 bool doInitialization(
Module &M)
override {
8096 V = std::make_unique<Verifier>(
8102 if (!
V->verify(
F) && FatalErrors) {
8103 errs() <<
"in function " <<
F.getName() <<
'\n';
8109 bool doFinalization(
Module &M)
override {
8110 bool HasErrors =
false;
8112 if (
F.isDeclaration())
8113 HasErrors |= !
V->verify(
F);
8115 HasErrors |= !
V->verify();
8116 if (FatalErrors && (HasErrors ||
V->hasBrokenDebugInfo()))
8121 void getAnalysisUsage(AnalysisUsage &AU)
const override {
8129template <
typename... Tys>
void TBAAVerifier::CheckFailed(Tys &&... Args) {
8131 return Diagnostic->CheckFailed(
Args...);
8134#define CheckTBAA(C, ...) \
8137 CheckFailed(__VA_ARGS__); \
8145TBAAVerifier::TBAABaseNodeSummary
8149 CheckFailed(
"Base nodes must have at least two operands",
I, BaseNode);
8153 auto Itr = TBAABaseNodes.find(BaseNode);
8154 if (Itr != TBAABaseNodes.end())
8157 auto Result = verifyTBAABaseNodeImpl(
I, BaseNode, IsNewFormat);
8158 auto InsertResult = TBAABaseNodes.insert({BaseNode, Result});
8160 assert(InsertResult.second &&
"We just checked!");
8164TBAAVerifier::TBAABaseNodeSummary
8165TBAAVerifier::verifyTBAABaseNodeImpl(
const Instruction *
I,
8166 const MDNode *BaseNode,
bool IsNewFormat) {
8167 const TBAAVerifier::TBAABaseNodeSummary InvalidNode = {
true, ~0
u};
8171 return isValidScalarTBAANode(BaseNode)
8172 ? TBAAVerifier::TBAABaseNodeSummary({
false, 0})
8178 CheckFailed(
"Access tag nodes must have the number of operands that is a "
8179 "multiple of 3!", BaseNode);
8184 CheckFailed(
"Struct tag nodes must have an odd number of operands!",
8194 if (!TypeSizeNode) {
8195 CheckFailed(
"Type size nodes must be constants!",
I, BaseNode);
8202 CheckFailed(
"Struct tag nodes have a string as their first operand",
8209 std::optional<APInt> PrevOffset;
8214 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
8215 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
8217 Idx += NumOpsPerField) {
8218 const MDOperand &FieldTy = BaseNode->
getOperand(Idx);
8219 const MDOperand &FieldOffset = BaseNode->
getOperand(Idx + 1);
8221 CheckFailed(
"Incorrect field entry in struct type node!",
I, BaseNode);
8226 auto *OffsetEntryCI =
8228 if (!OffsetEntryCI) {
8229 CheckFailed(
"Offset entries must be constants!",
I, BaseNode);
8235 BitWidth = OffsetEntryCI->getBitWidth();
8237 if (OffsetEntryCI->getBitWidth() !=
BitWidth) {
8239 "Bitwidth between the offsets and struct type entries must match",
I,
8251 !PrevOffset || PrevOffset->ule(OffsetEntryCI->getValue());
8254 CheckFailed(
"Offsets must be increasing!",
I, BaseNode);
8258 PrevOffset = OffsetEntryCI->getValue();
8263 if (!MemberSizeNode) {
8264 CheckFailed(
"Member size entries must be constants!",
I, BaseNode);
8271 return Failed ? InvalidNode
8272 : TBAAVerifier::TBAABaseNodeSummary(
false,
BitWidth);
8294 return Parent && Visited.
insert(Parent).second &&
8298bool TBAAVerifier::isValidScalarTBAANode(
const MDNode *MD) {
8299 auto ResultIt = TBAAScalarNodes.find(MD);
8300 if (ResultIt != TBAAScalarNodes.end())
8301 return ResultIt->second;
8303 SmallPtrSet<const MDNode *, 4> Visited;
8305 auto InsertResult = TBAAScalarNodes.insert({MD,
Result});
8307 assert(InsertResult.second &&
"Just checked!");
8316MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(
const Instruction *
I,
8317 const MDNode *BaseNode,
8328 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
8329 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
8331 Idx += NumOpsPerField) {
8332 auto *OffsetEntryCI =
8334 if (OffsetEntryCI->getValue().ugt(
Offset)) {
8335 if (Idx == FirstFieldOpNo) {
8336 CheckFailed(
"Could not find TBAA parent in struct type node",
I,
8341 unsigned PrevIdx =
Idx - NumOpsPerField;
8342 auto *PrevOffsetEntryCI =
8344 Offset -= PrevOffsetEntryCI->getValue();
8352 Offset -= LastOffsetEntryCI->getValue();
8357 if (!
Type ||
Type->getNumOperands() < 3)
8369 if (!Visited.
insert(
N).second)
8389 "This instruction shall not have a TBAA access tag!",
I);
8391 bool IsStructPathTBAA =
8395 "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
8405 "Access tag metadata must have either 4 or 5 operands",
I, MD);
8408 "Struct tag metadata must have either 3 or 4 operands",
I, MD);
8415 CheckTBAA(AccessSizeNode,
"Access size field must be a constant",
I, MD);
8419 unsigned ImmutabilityFlagOpNo = IsNewFormat ? 4 : 3;
8424 "Immutability tag on struct tag metadata must be a constant",
I,
8427 IsImmutableCI->isZero() || IsImmutableCI->isOne(),
8428 "Immutability part of the struct tag metadata must be either 0 or 1",
I,
8433 "Malformed struct tag metadata: base and access-type "
8434 "should be non-null and point to Metadata nodes",
8435 I, MD, BaseNode, AccessType);
8438 CheckTBAA(isValidScalarTBAANode(AccessType),
8439 "Access type node must be a valid scalar type",
I, MD,
8443 "Cycle detected in access type parent chain",
I, MD, AccessType);
8447 CheckTBAA(OffsetCI,
"Offset must be constant integer",
I, MD);
8450 bool SeenAccessTypeInPath =
false;
8456 getFieldNodeFromTBAABaseNode(
I, BaseNode,
Offset, IsNewFormat)) {
8457 if (!StructPath.
insert(BaseNode).second) {
8458 CheckFailed(
"Cycle detected in struct path",
I, MD);
8463 unsigned BaseNodeBitWidth;
8464 std::tie(
Invalid, BaseNodeBitWidth) =
8465 verifyTBAABaseNode(
I, BaseNode, IsNewFormat);
8472 SeenAccessTypeInPath |= BaseNode == AccessType;
8474 if (isValidScalarTBAANode(BaseNode) || BaseNode == AccessType)
8479 (BaseNodeBitWidth == 0 &&
Offset == 0) ||
8480 (IsNewFormat && BaseNodeBitWidth == ~0u),
8481 "Access bit-width not the same as description bit-width",
I, MD,
8482 BaseNodeBitWidth,
Offset.getBitWidth());
8484 if (IsNewFormat && SeenAccessTypeInPath)
8488 CheckTBAA(SeenAccessTypeInPath,
"Did not see access type in access path!",
I,
8499 "!tbaa.struct operands must come in groups of three",
I, MD);
8501 std::optional<APInt> PrevOffset;
8502 for (
unsigned Idx = 0, E = MD->
getNumOperands(); Idx != E; Idx += 3) {
8505 CheckTBAA(OffsetCI,
"!tbaa.struct field offset must be a constant integer",
8509 "!tbaa.struct field size must be a constant integer",
I, MD);
8512 CheckTBAA(
Tag,
"!tbaa.struct field tag must be null or an MDNode",
I, MD);
8520 std::max(PrevOffset->getBitWidth(),
Offset.getBitWidth());
8522 "!tbaa.struct field offsets must be non-decreasing",
I, MD);
8529char VerifierLegacyPass::ID = 0;
8530INITIALIZE_PASS(VerifierLegacyPass,
"verify",
"Module Verifier",
false,
false)
8533 return new VerifierLegacyPass(FatalErrors);
8551 if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
8559 if (res.IRBroken && FatalErrors)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis false
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file declares the LLVM IR specialization of the GenericConvergenceVerifier template.
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
static bool runOnFunction(Function &F, bool PostInlining)
This file contains the declarations of entities that describe floating point environment and related ...
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
This defines the Use class.
static constexpr Value * getValue(Ty &ValueOrUse)
const size_t AbstractManglingParser< Derived, Alloc >::NumOps
Machine Check Debug Module
This file implements a map that provides insertion order iteration.
This file provides utility for Memory Model Relaxation Annotations (MMRAs).
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
This file contains the declarations for profiling metadata utility functions.
SmallVector< MachineOperand, 4 > Cond
Func getContext().diagnose(DiagnosticInfoUnsupported(Func
static void visit(BasicBlock &Start, std::function< bool(BasicBlock *)> op)
verify safepoint Safepoint IR Verifier
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
static bool IsScalarTBAANodeImpl(const MDNode *MD, SmallPtrSetImpl< const MDNode * > &Visited)
static bool isType(const Metadata *MD)
static Instruction * getSuccPad(Instruction *Terminator)
static bool isMDTuple(const Metadata *MD)
#define CheckDI(C,...)
We know that a debug info condition should be true, if not print an error message.
static void forEachUser(const Value *User, SmallPtrSet< const Value *, 32 > &Visited, llvm::function_ref< bool(const Value *)> Callback)
static const Metadata * getRawDIScopeParent(const Metadata *S)
Parent scope operand of S, or null if S has no parent (a DIFile, DICompileUnit, or non-scope).
static bool isDINode(const Metadata *MD)
static bool isSupportedCallBrIntrinsic(Intrinsic::ID ID)
static bool isScope(const Metadata *MD)
static bool hasAcyclicTBAAParentChain(const MDNode *MD)
Returns true if the parent chain of the TBAA type node MD is acyclic.
static bool IsRootTBAANode(const MDNode *MD)
static Value * getParentPad(Value *EHPad)
static bool hasConflictingReferenceFlags(unsigned Flags)
Detect mutually exclusive flags.
static AttrBuilder getParameterABIAttributes(LLVMContext &C, unsigned I, AttributeList Attrs)
static bool isNewFormatTBAATypeNode(const MDNode *Type)
static const char PassName[]
static LLVM_ABI bool isValidArbitraryFPFormat(StringRef Format)
Returns true if the given string is a valid arbitrary floating-point format interpretation for llvm....
static LLVM_ABI unsigned getArbitraryFPFormatSizeInBits(StringRef Format)
Returns the size in bits of a valid arbitrary floating-point format string, or 0 if the string is not...
bool isFiniteNonZero() const
const fltSemantics & getSemantics() const
Class for arbitrary precision integers.
bool sgt(const APInt &RHS) const
Signed greater than comparison.
bool isMinValue() const
Determine if this is the smallest unsigned value.
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
bool isMaxValue() const
Determine if this is the largest unsigned value.
This class represents a conversion between pointers from one address space to another.
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
LLVM_ABI bool isStaticAlloca() const
Return true if this alloca is in the entry block of the function and is a constant size.
Align getAlign() const
Return the alignment of the memory that is being allocated by the instruction.
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
LLVM_ABI bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1.
const Value * getArraySize() const
Get the number of elements allocated.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
void setPreservesAll()
Set by analyses that do not transform their input at all.
bool isElementwise() const
Return true if this RMW has elementwise vector semantics.
static bool isFPOperation(BinOp Op)
BinOp getOperation() const
static LLVM_ABI StringRef getOperationName(BinOp Op)
AtomicOrdering getOrdering() const
Returns the ordering constraint of this rmw instruction.
bool contains(Attribute::AttrKind A) const
Return true if the builder has the specified attribute.
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
Functions, function parameters, and return types can have attributes to indicate how they should be t...
LLVM_ABI const ConstantRange & getValueAsConstantRange() const
Return the attribute's value as a ConstantRange.
LLVM_ABI StringRef getValueAsString() const
Return the attribute's value as a string.
bool isValid() const
Return true if the attribute is any kind of attribute.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
LLVM_ABI Type * getValueAsType() const
Return the attribute's value as a Type.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
const Function * getParent() const
Return the enclosing method, or null if none.
LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const
Returns an iterator to the first instruction in this block that is not a PHINode instruction.
LLVM_ABI bool isEntryBlock() const
Return true if this is the entry block of the containing function.
const Instruction & front() const
LLVM_ABI const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
This class represents a no-op cast from one type to another.
static LLVM_ABI const char * areInvalidOperands(Value *Base, Value *Val, Value *Offset)
Return a string if the specified operands are invalid for a bitinsert operation, otherwise return nul...
static LLVM_ABI BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
bool isInlineAsm() const
Check if this call is an inline asm statement.
auto operand_bundles() const
bool hasInAllocaArgument() const
Determine if there are is an inalloca argument.
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool doesNotAccessMemory(unsigned OpNo) const
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
CallingConv::ID getCallingConv() const
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Get the attribute of a given kind from a given arg.
unsigned countOperandBundlesOfType(StringRef Name) const
Return the number of operand bundles with the tag Name attached to this instruction.
bool onlyReadsMemory(unsigned OpNo) const
Value * getCalledOperand() const
Type * getParamElementType(unsigned ArgNo) const
Extract the elementtype type for a parameter.
Value * getArgOperand(unsigned i) const
FunctionType * getFunctionType() const
LLVM_ABI Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
bool doesNotReturn() const
Determine if the call cannot return.
LLVM_ABI bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
unsigned arg_size() const
AttributeList getAttributes() const
Return the attributes for this call.
bool hasOperandBundles() const
Return true if this User has any operand bundles.
LLVM_ABI Function * getCaller()
Helper to get the caller (the parent function).
CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...
This class represents a function call, abstracting a target machine's calling convention.
bool isMustTailCall() const
static LLVM_ABI bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)
This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.
unsigned getNumHandlers() const
return the number of 'handlers' in this catchswitch instruction, except the default handler
Value * getParentPad() const
BasicBlock * getUnwindDest() const
handler_range handlers()
iteration adapter for range-for loops.
BasicBlock * getUnwindDest() const
bool isFPPredicate() const
static bool isIntPredicate(Predicate P)
Conditional Branch instruction.
Value * getCondition() const
unsigned getBitWidth() const
getBitWidth - Return the scalar bitwidth of this constant.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
const APInt & getValue() const
Return the constant as an APInt value reference.
Constant * getAddrDiscriminator() const
The address discriminator if any, or the null constant.
Constant * getPointer() const
The pointer that is signed in this ptrauth signed pointer.
ConstantInt * getKey() const
The Key ID, an i32 constant.
Constant * getDeactivationSymbol() const
ConstantInt * getDiscriminator() const
The integer discriminator, an i64 constant, or 0.
static LLVM_ABI bool isOrderedRanges(ArrayRef< ConstantRange > RangesRef)
This class represents a range of values.
LLVM_ABI bool contains(const APInt &Val) const
Return true if the specified value is in the set.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
static LLVM_ABI ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
LLVM_ABI std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
LLVM_ABI std::optional< RoundingMode > getRoundingMode() const
iterator_range< expr_op_iterator > expr_ops() const
DbgVariableFragmentInfo FragmentInfo
LLVM_ABI bool isValid() const
@ FixedPointBinary
Scale factor 2^Factor.
@ FixedPointDecimal
Scale factor 10^Factor.
@ FixedPointRational
Arbitrary rational scale factor.
DIGlobalVariable * getVariable() const
DIExpression * getExpression() const
LLVM_ABI DISubprogram * getSubprogram() const
Get the subprogram for this scope.
DILocalScope * getScope() const
Get the local scope for this variable.
Metadata * getRawScope() const
Base class for scope-like contexts.
Subprogram description. Uses SubclassData1.
static LLVM_ABI const DIScope * getRawRetainedNodeScope(const MDNode *N)
Base class for template parameters.
Base class for variables.
Metadata * getRawType() const
Metadata * getRawScope() const
uint64_t getNumOperands() const
Records a position in IR for a source label (DILabel).
MDNode * getRawLabel() const
DILabel * getLabel() const
Base class for non-instruction debug metadata records that have positions within IR.
DebugLoc getDebugLoc() const
LLVM_ABI BasicBlock * getParent()
LLVM_ABI Function * getFunction()
Record of a variable value-assignment, aka a non instruction representation of the dbg....
LLVM_ABI bool isKillLocation() const
LocationType getType() const
MDNode * getRawExpression() const
MDNode * getRawAddressExpression() const
LLVM_ABI Value * getVariableLocationOp(unsigned OpIdx) const
LLVM_ABI unsigned getNumVariableLocationOps() const
DIExpression * getExpression() const
Metadata * getRawAssignID() const
MDNode * getRawVariable() const
DILocalVariable * getVariable() const
Metadata * getRawLocation() const
Returns the metadata operand for the first location description.
bool isDbgDeclare() const
Metadata * getRawAddress() const
DIExpression * getAddressExpression() const
LLVM_ABI MDNode * getAsMDNode() const
Return this as a bar MDNode.
iterator find(const_arg_type_t< KeyT > Val)
ValueT lookup(const_arg_type_t< KeyT > Val) const
Return the entry for the specified key, or a default constructed value if no such entry exists.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
This instruction compares its operands according to the predicate given to the constructor.
This class represents an extension of floating point types.
static bool isSupportedFloatingPointType(Type *Ty)
Returns true if Ty is a supported floating-point type for phi, select, or call FPMathOperators.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this fence instruction.
unsigned getNumElements() const
op_range arg_operands()
arg_operands - iteration adapter for range-for loops.
Value * getParentPad() const
Convenience accessors.
FunctionPass class - This class is used to implement most global optimizations.
Type * getReturnType() const
FunctionType * getFunctionType() const
Returns the FunctionType for me.
DISubprogram * getSubprogram() const
Get the attached subprogram.
bool hasPersonalityFn() const
Check whether this function has a personality function.
const Function & getFunction() const
const std::string & getGC() const
Type * getReturnType() const
Returns the type of the ret val.
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
LLVM_ABI Value * getBasePtr() const
LLVM_ABI Value * getDerivedPtr() const
void visit(const BlockT &BB)
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
static LLVM_ABI Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the result type of a getelementptr with the given source element type and indexes.
static bool isValidLinkage(LinkageTypes L)
const Constant * getAliasee() const
LLVM_ABI const Function * getResolverFunction() const
static bool isValidLinkage(LinkageTypes L)
const Constant * getResolver() const
LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this GlobalObject.
bool hasExternalLinkage() const
bool isImplicitDSOLocal() const
LLVM_ABI bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
bool hasValidDeclarationLinkage() const
LinkageTypes getLinkage() const
bool hasDefaultVisibility() const
bool hasPrivateLinkage() const
bool hasHiddenVisibility() const
bool hasExternalWeakLinkage() const
bool hasDLLImportStorageClass() const
bool hasDLLExportStorageClass() const
bool isDeclarationForLinker() const
unsigned getAddressSpace() const
Module * getParent()
Get the module that this global value is contained inside of...
PointerType * getType() const
Global values are always pointers.
bool hasCommonLinkage() const
bool hasGlobalUnnamedAddr() const
bool hasAppendingLinkage() const
bool mayHaveConstantUsers() const
Return true if a constant other than a GlobalValue may use this global, that is, if removeDeadConstan...
bool hasAvailableExternallyLinkage() const
Type * getValueType() const
LLVM_ABI bool isInterposable(bool CheckNoIPA=true) const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
LLVM_ABI uint64_t getGlobalSize(const DataLayout &DL) const
Get the size of this global variable in bytes.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
This instruction compares its operands according to the predicate given to the constructor.
Indirect Branch Instruction.
BasicBlock * getDestination(unsigned i)
Return the specified destination.
unsigned getNumDestinations() const
return the number of possible destinations in this indirectbr instruction.
unsigned getNumSuccessors() const
This instruction inserts a single (scalar) element into a VectorType value.
static LLVM_ABI bool isValidOperands(const Value *Vec, const Value *NewElt, const Value *Idx)
Return true if an insertelement instruction can be formed with the specified operands.
Value * getAggregateOperand()
ArrayRef< unsigned > getIndices() const
Base class for instruction visitors.
void visit(Iterator Start, Iterator End)
LLVM_ABI unsigned getNumSuccessors() const LLVM_READONLY
Return the number of successors that this instruction has.
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
iterator_range< user_iterator > users()
This class represents a cast from an integer to a pointer.
static LLVM_ABI bool mayLowerToFunctionCall(Intrinsic::ID IID)
Check if the intrinsic might lower into a regular function call in the course of IR transformations.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
This is an important class for using LLVM in a threaded context.
@ OB_clang_arc_attachedcall
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
bool isCatch(unsigned Idx) const
Return 'true' if the clause and index Idx is a catch clause.
bool isFilter(unsigned Idx) const
Return 'true' if the clause and index Idx is a filter clause.
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
An instruction for reading from memory.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this load instruction.
bool isAtomic() const
Return true if this load has an atomic ordering.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this load instruction.
bool isElementwise() const
Return true if this is an elementwise atomic load.
Align getAlign() const
Return the alignment of the access that is being performed.
const MDOperand & getOperand(unsigned I) const
ArrayRef< MDOperand > operands() const
unsigned getNumOperands() const
Return number of MDNode operands.
bool isResolved() const
Check if node is fully resolved.
LLVMContext & getContext() const
bool equalsStr(StringRef Str) const
LLVM_ABI StringRef getString() const
A Module instance is used to store all the information related to an LLVM module.
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
LLVM_ABI StringRef getName() const
LLVM_ABI unsigned getNumOperands() const
iterator_range< op_iterator > operands()
op_range incoming_values()
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
This class represents a cast from a pointer to an address (non-capturing ptrtoint).
This class represents a cast from a pointer to an integer.
Value * getValue() const
Convenience accessor.
Return a value (possibly void), from a function.
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
This class represents a sign extension of integer types.
This class represents a cast from signed integer to floating point.
This class represents the LLVM 'select' instruction.
static LLVM_ABI const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
Return a string if the specified operands are invalid for a select operation, otherwise return null.
This instruction constructs a fixed permutation of two input vectors.
static LLVM_ABI bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
Return true if a shufflevector instruction can be formed with the specified operands.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
void insert_range(Range &&R)
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
static constexpr size_t npos
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
Check if the string is empty.
std::pair< typename Base::iterator, bool > insert(StringRef key)
LLVM_ABI bool visitTBAAMetadata(const Instruction *I, const MDNode *MD)
Visit an instruction, or a TBAA node itself as part of a metadata, and return true if it is valid,...
LLVM_ABI bool visitTBAAStructMetadata(const Instruction *I, const MDNode *MD)
This class represents a truncation of integer types.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM_ABI unsigned getIntegerBitWidth() const
bool isByteTy() const
True if this is an instance of ByteType.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isLabelTy() const
Return true if this is 'label'.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
LLVM_ABI bool isTokenLikeTy() const
Returns true if this is 'token' or a token-like target type.s.
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
bool isSingleValueType() const
Return true if the type is a valid type for a register in codegen.
LLVM_ABI bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
bool isSized() const
Return true if it makes sense to take the size of this type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isByteOrByteVectorTy() const
Return true if this is a byte type or a vector of byte types.
bool isAggregateType() const
Return true if the type is an aggregate type.
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
LLVM_ABI unsigned getByteBitWidth() const
LLVM_ABI bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
bool isIntOrPtrTy() const
Return true if this is an integer type or a pointer type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
LLVM_ABI bool containsNonLocalTargetExtType() const
Return true if this type is or contains a target extension type that disallows being used as a local.
LLVM_ABI bool containsNonGlobalTargetExtType() const
Return true if this type is or contains a target extension type that disallows being used as a global...
bool isVoidTy() const
Return true if this is 'void'.
bool isMetadataTy() const
Return true if this is 'metadata'.
This class represents a cast unsigned integer to floating point.
Value * getOperand(unsigned i) const
unsigned getNumOperands() const
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
LLVM Value Representation.
iterator_range< user_iterator > materialized_users()
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
iterator_range< user_iterator > users()
bool materialized_use_empty() const
LLVM_ABI const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
Type * getElementType() const
Check a module for errors, and report separate error states for IR and debug info errors.
LLVM_ABI Result run(Module &M, ModuleAnalysisManager &)
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
This class represents zero extension of integer types.
std::pair< iterator, bool > insert(const ValueT &V)
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
An efficient, type-erasing, non-owning reference to a callable.
const ParentTy * getParent() const
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
This class implements an extremely fast bulk output stream that can only output to a stream.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
std::optional< ABIType > parseABIType(StringRef S)
Parse the string spelling used by the "float-abi" IR module flag into an ABIType.
@ BasicBlock
Various leaf nodes.
LLVM_ABI bool hasConstrainedFPRoundingModeOperand(ID QID)
Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics" that take r...
LLVM_ABI StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
static const int NoAliasScopeDeclScopeArg
LLVM_ABI bool isSignatureValid(Intrinsic::ID ID, FunctionType *FT, SmallVectorImpl< Type * > &OverloadTys, raw_ostream &OS=nulls())
Returns true if FT is a valid function type for intrinsic ID.
LLVM_ABI bool isImmArgValueInRangeSet(ID IID, unsigned ArgIdx, const APInt &Value)
Returns true if Value satisfies the range constraints specified for argument ArgIdx of intrinsic IID.
std::variant< std::monostate, Loc::Single, Loc::Multi, Loc::MMI, Loc::EntryValue > Variant
Alias for the std::variant specialization base class of DbgVariable.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
constexpr StringLiteral AbiPreserveAttrs[]
@ System
Synchronized with respect to all concurrently executing threads.
LLVM_ABI std::optional< VFInfo > tryDemangleForVFABI(StringRef MangledName, const FunctionType *FTy)
Function to construct a VFInfo out of a mangled names in the following format:
@ CE
Windows NT (Windows on ARM)
AssignmentInstRange getAssignmentInsts(DIAssignID *ID)
Return a range of instructions (typically just one) that have ID as an attachment.
SmallVector< DbgVariableRecord * > getAssignmentMarkers(DIAssignID *ID)
@ DW_LLVM_LANG_DIALECT_max
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract_or_null(Y &&MD)
Extract a Value from Metadata, if any, allowing null.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract_or_null(Y &&MD)
Extract a Value from Metadata, allowing null.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)
Extract a Value from Metadata, if any.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
@ User
could "use" a pointer
NodeAddr< UseNode * > Use
NodeAddr< NodeBase * > Node
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
std::optional< LongDoubleFormat > parseLongDoubleFormat(StringRef Name)
Parses an IR floating-point type name into a LongDoubleFormat, returning std::nullopt if it does not ...
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI bool canInstructionHaveMMRAs(const Instruction &I)
detail::zippy< detail::zip_first, T, U, Args... > zip_equal(T &&t, U &&u, Args &&...args)
zip iterator that assumes that all iteratees have the same length.
LLVM_ABI unsigned getBranchWeightOffset(const MDNode *ProfileData)
Return the offset to the first branch weight data.
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
RelativeUniformCounterPtr Values
BundleAttr getBundleAttrFromOBU(OperandBundleUse OBU)
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI bool verifyFunction(const Function &F, raw_ostream *OS=nullptr)
Check a function for errors, useful for use when debugging a pass.
testing::Matcher< const detail::ErrorHolder & > Failed()
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
LLVM_ABI DenseMap< BasicBlock *, ColorVector > colorEHFunclets(Function &F)
If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks...
constexpr bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
void verifyAMDGPUAlloca(VerifierSupport &VS, const AllocaInst &AI)
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
gep_type_iterator gep_type_end(const User *GEP)
bool isa_and_nonnull(const Y &Val)
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
void verifyAMDGPUFunctionMetadata(VerifierSupport &VS, const Function &F)
std::optional< ExceptionHandling > parseExceptionModel(StringRef Name)
Parses the string spelling used by the "exception-model" IR module flag into an ExceptionHandling val...
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
GenericConvergenceVerifier< SSAContext > ConvergenceVerifier
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
bool isModSet(const ModRefInfo MRI)
void sort(IteratorTy Start, IteratorTy End)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID, CallBase &Call)
bool isPointerTy(const Type *T)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
generic_gep_type_iterator<> gep_type_iterator
LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
iterator_range< SplittingIterator > split(StringRef Str, StringRef Separator)
Split the specified string over a separator and return a range-compatible iterable over its partition...
constexpr BooleanLoopTags OldBooleanLoopTags[]
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI bool isValueProfileMD(const MDNode *ProfileData)
Checks if an MDNode contains value profiling Metadata.
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
LLVM_ABI unsigned getNumBranchWeights(const MDNode &ProfileData)
AtomicOrdering
Atomic ordering for LLVM's memory model.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
LLVM_ABI FunctionPass * createVerifierPass(bool FatalErrors=true)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
DWARFExpression::Operation Op
std::optional< ThreadModel > parseThreadModel(StringRef S)
Parse the string spelling used by the "thread-model" IR module flag into a ThreadModel.
ArrayRef(const T &OneElt) -> ArrayRef< T >
const IROptions & getIROptions(const LLVMContext &C)
constexpr unsigned BitWidth
TinyPtrVector< BasicBlock * > ColorVector
LLVM_ABI const char * LLVMLoopEstimatedTripCount
Profile-based loop metadata that should be accessed only by using llvm::getLoopEstimatedTripCount and...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI std::optional< RoundingMode > convertStrToRoundingMode(StringRef)
Returns a valid RoundingMode enumerator when given a string that is valid as input in constrained int...
gep_type_iterator gep_type_begin(const User *GEP)
LLVM_ABI std::unique_ptr< GCStrategy > getGCStrategy(const StringRef Name)
Lookup the GCStrategy object associated with the given gc name.
auto predecessors(const MachineBasicBlock *BB)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
void verifyNVVMIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID, CallBase &Call)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Next
bool pred_empty(const BasicBlock *BB)
void verifyAMDGPUGlobalVariable(VerifierSupport &VS, const GlobalVariable &GV)
bool isHexDigit(char C)
Checks if character C is a hexadecimal numeric character.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
void verifyAMDGPUModuleFlag(VerifierSupport &VS, const MDString *ID, Module::ModFlagBehavior MFB, const MDNode *Op)
bool isAMDGPUCallBrIntrinsic(Intrinsic::ID ID)
constexpr bool isCallableCC(CallingConv::ID CC)
LLVM_ABI bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
A special type used by analysis passes to provide an address that identifies that particular analysis...
static LLVM_ABI const char * UnknownBranchWeightsMarker
static LLVM_ABI const char * ValueProfile
static LLVM_ABI const char * FunctionEntryCount
static LLVM_ABI const char * BranchWeights
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.