95#include "llvm/IR/IntrinsicsAArch64.h"
96#include "llvm/IR/IntrinsicsAMDGPU.h"
97#include "llvm/IR/IntrinsicsARM.h"
98#include "llvm/IR/IntrinsicsNVPTX.h"
99#include "llvm/IR/IntrinsicsWebAssembly.h"
135 cl::desc(
"Ensure that llvm.experimental.noalias.scope.decl for identical "
136 "scopes are not dominating"));
170 if (isa<Instruction>(V)) {
174 V.printAsOperand(*
OS,
true,
MST);
242 void Write(
const unsigned i) { *
OS << i <<
'\n'; }
248 *
OS <<
A->getAsString() <<
'\n';
268 for (
const T &V : Vs)
272 template <
typename T1,
typename... Ts>
273 void WriteTs(
const T1 &V1,
const Ts &... Vs) {
278 template <
typename... Ts>
void WriteTs() {}
287 *
OS << Message <<
'\n';
295 template <
typename T1,
typename... Ts>
305 *
OS << Message <<
'\n';
311 template <
typename T1,
typename... Ts>
345 Type *LandingPadResultTy;
352 bool HasDebugInfo =
false;
395 SawFrameEscape(
false), TBAAVerifyHelper(this) {
396 TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
403 "An instance of this class only works with a specific module!");
415 if (!BB.empty() && BB.back().isTerminator())
419 *
OS <<
"Basic Block in function '" <<
F.getName()
420 <<
"' does not have terminator!\n";
421 BB.printAsOperand(*
OS,
true, MST);
427 auto FailureCB = [
this](
const Twine &Message) {
435 verifySiblingFuncletUnwinds();
438 ConvergenceVerifyHelper.
verify(DT);
440 InstsInThisBlock.
clear();
442 LandingPadResultTy =
nullptr;
443 SawFrameEscape =
false;
444 SiblingFuncletInfo.
clear();
445 verifyNoAliasScopeDecl();
446 NoAliasScopeDecls.
clear();
457 if (
F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
462 verifyFrameRecoverIndices();
464 visitGlobalVariable(GV);
467 visitGlobalAlias(GA);
470 visitGlobalIFunc(GI);
473 visitNamedMDNode(NMD);
476 visitComdat(SMEC.getValue());
480 visitModuleCommandLines();
482 verifyCompileUnits();
484 verifyDeoptimizeCallingConvs();
485 DISubprogramAttachments.
clear();
491 enum class AreDebugLocsAllowed {
No,
Yes };
495 enum class RangeLikeMetadataKind {
510 void visitMDNode(
const MDNode &MD, AreDebugLocsAllowed AllowLocs);
514 void visitComdat(
const Comdat &
C);
515 void visitModuleIdents();
516 void visitModuleCommandLines();
517 void visitModuleFlags();
518 void visitModuleFlag(
const MDNode *
Op,
521 void visitModuleFlagCGProfileEntry(
const MDOperand &MDO);
525 RangeLikeMetadataKind Kind);
530 void visitCallStackMetadata(
MDNode *MD);
535 void visitAnnotationMetadata(
MDNode *Annotation);
536 void visitAliasScopeMetadata(
const MDNode *MD);
537 void visitAliasScopeListMetadata(
const MDNode *MD);
538 void visitAccessGroupMetadata(
const MDNode *MD);
540 template <
class Ty>
bool isValidMetadataArray(
const MDTuple &
N);
541#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
542#include "llvm/IR/Metadata.def"
543 void visitDIScope(
const DIScope &
N);
570 void visitPHINode(
PHINode &PN);
579 void visitVAArgInst(
VAArgInst &VAA) { visitInstruction(VAA); }
617 void verifySwiftErrorCall(
CallBase &Call,
const Value *SwiftErrorVal);
618 void verifySwiftErrorValue(
const Value *SwiftErrorVal);
620 void verifyMustTailCall(
CallInst &CI);
621 bool verifyAttributeCount(
AttributeList Attrs,
unsigned Params);
627 const Value *V,
bool IsIntrinsic,
bool IsInlineAsm);
628 void verifyFunctionMetadata(
ArrayRef<std::pair<unsigned, MDNode *>> MDs);
630 void visitConstantExprsRecursively(
const Constant *EntryC);
633 void verifyInlineAsmCall(
const CallBase &Call);
634 void verifyStatepoint(
const CallBase &Call);
635 void verifyFrameRecoverIndices();
636 void verifySiblingFuncletUnwinds();
640 template <
typename ValueOrMetadata>
641 void verifyFragmentExpression(
const DIVariable &V,
643 ValueOrMetadata *
Desc);
650 void verifyCompileUnits();
654 void verifyDeoptimizeCallingConvs();
656 void verifyAttachedCallBundle(
const CallBase &Call,
660 void verifyNoAliasScopeDecl();
666#define Check(C, ...) \
669 CheckFailed(__VA_ARGS__); \
676#define CheckDI(C, ...) \
679 DebugInfoCheckFailed(__VA_ARGS__); \
687 CheckDI(
I.DebugMarker->MarkedInstr == &
I,
688 "Instruction has invalid DebugMarker", &
I);
689 CheckDI(!isa<PHINode>(&
I) || !
I.hasDbgRecords(),
690 "PHI Node must not have any attached DbgRecords", &
I);
693 "DbgRecord had invalid DebugMarker", &
I, &DR);
696 visitMDNode(*Loc, AreDebugLocsAllowed::Yes);
697 if (
auto *DVR = dyn_cast<DbgVariableRecord>(&DR)) {
701 verifyFragmentExpression(*DVR);
702 verifyNotEntryValue(*DVR);
703 }
else if (
auto *DLR = dyn_cast<DbgLabelRecord>(&DR)) {
711 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
712 Check(
I.getOperand(i) !=
nullptr,
"Operand is null", &
I);
725 while (!WorkList.
empty()) {
727 if (!Visited.
insert(Cur).second)
734void Verifier::visitGlobalValue(
const GlobalValue &GV) {
736 "Global is external, but doesn't have external or weak linkage!", &GV);
738 if (
const GlobalObject *GO = dyn_cast<GlobalObject>(&GV)) {
742 "huge alignment values are unsupported", GO);
745 if (
const MDNode *Associated =
746 GO->getMetadata(LLVMContext::MD_associated)) {
747 Check(Associated->getNumOperands() == 1,
748 "associated metadata must have one operand", &GV, Associated);
749 const Metadata *
Op = Associated->getOperand(0).get();
750 Check(
Op,
"associated metadata must have a global value", GO, Associated);
752 const auto *VM = dyn_cast_or_null<ValueAsMetadata>(
Op);
753 Check(VM,
"associated metadata must be ValueAsMetadata", GO, Associated);
755 Check(isa<PointerType>(VM->getValue()->getType()),
756 "associated value must be pointer typed", GV, Associated);
759 Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
760 "associated metadata must point to a GlobalObject", GO, Stripped);
761 Check(Stripped != GO,
762 "global values should not associate to themselves", GO,
768 if (
const MDNode *AbsoluteSymbol =
769 GO->getMetadata(LLVMContext::MD_absolute_symbol)) {
770 verifyRangeLikeMetadata(*GO, AbsoluteSymbol,
771 DL.getIntPtrType(GO->getType()),
772 RangeLikeMetadataKind::AbsoluteSymbol);
777 "Only global variables can have appending linkage!", &GV);
782 "Only global arrays can have appending linkage!", GVar);
786 Check(!GV.
hasComdat(),
"Declaration may not be in a Comdat!", &GV);
790 "dllexport GlobalValue must have default or protected visibility",
795 "dllimport GlobalValue must have default visibility", &GV);
796 Check(!GV.
isDSOLocal(),
"GlobalValue with DLLImport Storage is dso_local!",
802 "Global is marked as dllimport, but not external", &GV);
807 "GlobalValue with local linkage or non-default "
808 "visibility must be dso_local!",
812 Check(!GV.
hasSection(),
"tagged GlobalValue must not be in section.", &GV);
817 if (!
I->getParent() || !
I->getParent()->getParent())
818 CheckFailed(
"Global is referenced by parentless instruction!", &GV, &M,
820 else if (
I->getParent()->getParent()->getParent() != &M)
821 CheckFailed(
"Global is referenced in a different module!", &GV, &M,
I,
822 I->getParent()->getParent(),
823 I->getParent()->getParent()->getParent());
825 }
else if (
const Function *
F = dyn_cast<Function>(V)) {
826 if (
F->getParent() != &M)
827 CheckFailed(
"Global is used by function in a different module", &GV, &M,
840 "Global variable initializer type does not match global "
847 "'common' global must have a zero initializer!", &GV);
850 Check(!GV.
hasComdat(),
"'common' global may not be in a Comdat!", &GV);
855 GV.
getName() ==
"llvm.global_dtors")) {
857 "invalid linkage for intrinsic global variable", &GV);
859 "invalid uses of intrinsic global variable", &GV);
863 if (
ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
864 StructType *STy = dyn_cast<StructType>(ATy->getElementType());
870 "wrong type for intrinsic global variable", &GV);
872 "the third field of the element type is mandatory, "
873 "specify ptr null to migrate from the obsoleted 2-field form");
881 GV.
getName() ==
"llvm.compiler.used")) {
883 "invalid linkage for intrinsic global variable", &GV);
885 "invalid uses of intrinsic global variable", &GV);
887 if (
ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
888 PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
889 Check(PTy,
"wrong type for intrinsic global variable", &GV);
893 Check(InitArray,
"wrong initalizer for intrinsic global variable",
897 Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
901 Twine(
"members of ") + GV.
getName() +
" must be named", V);
910 for (
auto *MD : MDs) {
911 if (
auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
912 visitDIGlobalVariableExpression(*GVE);
914 CheckDI(
false,
"!dbg attachment of global variable must be a "
915 "DIGlobalVariableExpression");
925 "Global @" + GV.
getName() +
" has illegal target extension type",
929 visitGlobalValue(GV);
936 visitGlobalValue(GV);
942 visitAliaseeSubExpr(Visited, GA,
C);
948 Check(isa<GlobalValue>(
C) &&
949 cast<GlobalValue>(
C).hasAvailableExternallyLinkage(),
950 "available_externally alias must point to available_externally "
954 if (
const auto *GV = dyn_cast<GlobalValue>(&
C)) {
960 if (
const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
961 Check(Visited.
insert(GA2).second,
"Aliases cannot form a cycle", &GA);
963 Check(!GA2->isInterposable(),
964 "Alias cannot point to an interposable alias", &GA);
972 if (
const auto *CE = dyn_cast<ConstantExpr>(&
C))
973 visitConstantExprsRecursively(CE);
975 for (
const Use &U :
C.operands()) {
977 if (
const auto *GA2 = dyn_cast<GlobalAlias>(V))
978 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
979 else if (
const auto *C2 = dyn_cast<Constant>(V))
980 visitAliaseeSubExpr(Visited, GA, *C2);
984void Verifier::visitGlobalAlias(
const GlobalAlias &GA) {
986 "Alias should have private, internal, linkonce, weak, linkonce_odr, "
987 "weak_odr, external, or available_externally linkage!",
990 Check(Aliasee,
"Aliasee cannot be NULL!", &GA);
992 "Alias and aliasee types should match!", &GA);
994 Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
995 "Aliasee should be either GlobalValue or ConstantExpr", &GA);
997 visitAliaseeSubExpr(GA, *Aliasee);
999 visitGlobalValue(GA);
1002void Verifier::visitGlobalIFunc(
const GlobalIFunc &GI) {
1004 "IFunc should have private, internal, linkonce, weak, linkonce_odr, "
1005 "weak_odr, or external linkage!",
1010 Check(
Resolver,
"IFunc must have a Function resolver", &GI);
1012 "IFunc resolver must be a definition", &GI);
1018 Check(isa<PointerType>(
Resolver->getFunctionType()->getReturnType()),
1019 "IFunc resolver must return a pointer", &GI);
1022 "IFunc resolver has incorrect type", &GI);
1025void Verifier::visitNamedMDNode(
const NamedMDNode &NMD) {
1030 "unrecognized named metadata node in the llvm.dbg namespace", &NMD);
1032 if (NMD.
getName() ==
"llvm.dbg.cu")
1033 CheckDI(MD && isa<DICompileUnit>(MD),
"invalid compile unit", &NMD, MD);
1038 visitMDNode(*MD, AreDebugLocsAllowed::Yes);
1042void Verifier::visitMDNode(
const MDNode &MD, AreDebugLocsAllowed AllowLocs) {
1045 if (!MDNodes.
insert(&MD).second)
1049 "MDNode context does not match Module context!", &MD);
1054 case Metadata::MDTupleKind:
1056#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
1057 case Metadata::CLASS##Kind: \
1058 visit##CLASS(cast<CLASS>(MD)); \
1060#include "llvm/IR/Metadata.def"
1066 Check(!isa<LocalAsMetadata>(
Op),
"Invalid operand for global metadata!",
1068 CheckDI(!isa<DILocation>(
Op) || AllowLocs == AreDebugLocsAllowed::Yes,
1069 "DILocation not allowed within this metadata node", &MD,
Op);
1070 if (
auto *
N = dyn_cast<MDNode>(
Op)) {
1071 visitMDNode(*
N, AllowLocs);
1074 if (
auto *V = dyn_cast<ValueAsMetadata>(
Op)) {
1075 visitValueAsMetadata(*V,
nullptr);
1088 "Unexpected metadata round-trip through values", &MD, MD.
getValue());
1090 auto *
L = dyn_cast<LocalAsMetadata>(&MD);
1094 Check(
F,
"function-local metadata used outside a function", L);
1099 if (
Instruction *
I = dyn_cast<Instruction>(
L->getValue())) {
1100 Check(
I->getParent(),
"function-local metadata not in basic block", L,
I);
1101 ActualF =
I->getParent()->getParent();
1102 }
else if (
BasicBlock *BB = dyn_cast<BasicBlock>(
L->getValue()))
1104 else if (
Argument *
A = dyn_cast<Argument>(
L->getValue()))
1105 ActualF =
A->getParent();
1106 assert(ActualF &&
"Unimplemented function local metadata case!");
1108 Check(ActualF ==
F,
"function-local metadata used in wrong function", L);
1113 visitValueAsMetadata(*VAM,
F);
1118 if (
auto *
N = dyn_cast<MDNode>(MD)) {
1119 visitMDNode(*
N, AreDebugLocsAllowed::No);
1125 if (!MDNodes.
insert(MD).second)
1128 if (
auto *V = dyn_cast<ValueAsMetadata>(MD))
1129 visitValueAsMetadata(*V,
F);
1131 if (
auto *AL = dyn_cast<DIArgList>(MD))
1132 visitDIArgList(*AL,
F);
1139void Verifier::visitDILocation(
const DILocation &
N) {
1140 CheckDI(
N.getRawScope() && isa<DILocalScope>(
N.getRawScope()),
1141 "location requires a valid scope", &
N,
N.getRawScope());
1142 if (
auto *IA =
N.getRawInlinedAt())
1143 CheckDI(isa<DILocation>(IA),
"inlined-at should be a location", &
N, IA);
1144 if (
auto *SP = dyn_cast<DISubprogram>(
N.getRawScope()))
1145 CheckDI(SP->isDefinition(),
"scope points into the type hierarchy", &
N);
1152void Verifier::visitDIScope(
const DIScope &
N) {
1153 if (
auto *
F =
N.getRawFile())
1154 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1157void Verifier::visitDISubrange(
const DISubrange &
N) {
1158 CheckDI(
N.getTag() == dwarf::DW_TAG_subrange_type,
"invalid tag", &
N);
1159 CheckDI(!
N.getRawCountNode() || !
N.getRawUpperBound(),
1160 "Subrange can have any one of count or upperBound", &
N);
1161 auto *CBound =
N.getRawCountNode();
1162 CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
1163 isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
1164 "Count must be signed constant or DIVariable or DIExpression", &
N);
1165 auto Count =
N.getCount();
1166 CheckDI(!Count || !isa<ConstantInt *>(Count) ||
1167 cast<ConstantInt *>(Count)->getSExtValue() >= -1,
1168 "invalid subrange count", &
N);
1169 auto *LBound =
N.getRawLowerBound();
1170 CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
1171 isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
1172 "LowerBound must be signed constant or DIVariable or DIExpression",
1174 auto *UBound =
N.getRawUpperBound();
1175 CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
1176 isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
1177 "UpperBound must be signed constant or DIVariable or DIExpression",
1179 auto *Stride =
N.getRawStride();
1180 CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
1181 isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1182 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1186 CheckDI(
N.getTag() == dwarf::DW_TAG_generic_subrange,
"invalid tag", &
N);
1187 CheckDI(!
N.getRawCountNode() || !
N.getRawUpperBound(),
1188 "GenericSubrange can have any one of count or upperBound", &
N);
1189 auto *CBound =
N.getRawCountNode();
1190 CheckDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
1191 "Count must be signed constant or DIVariable or DIExpression", &
N);
1192 auto *LBound =
N.getRawLowerBound();
1193 CheckDI(LBound,
"GenericSubrange must contain lowerBound", &
N);
1194 CheckDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
1195 "LowerBound must be signed constant or DIVariable or DIExpression",
1197 auto *UBound =
N.getRawUpperBound();
1198 CheckDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
1199 "UpperBound must be signed constant or DIVariable or DIExpression",
1201 auto *Stride =
N.getRawStride();
1202 CheckDI(Stride,
"GenericSubrange must contain stride", &
N);
1203 CheckDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1204 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1208 CheckDI(
N.getTag() == dwarf::DW_TAG_enumerator,
"invalid tag", &
N);
1212 CheckDI(
N.getTag() == dwarf::DW_TAG_base_type ||
1213 N.getTag() == dwarf::DW_TAG_unspecified_type ||
1214 N.getTag() == dwarf::DW_TAG_string_type,
1219 CheckDI(
N.getTag() == dwarf::DW_TAG_string_type,
"invalid tag", &
N);
1220 CheckDI(!(
N.isBigEndian() &&
N.isLittleEndian()),
"has conflicting flags",
1228 CheckDI(
N.getTag() == dwarf::DW_TAG_typedef ||
1229 N.getTag() == dwarf::DW_TAG_pointer_type ||
1230 N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
1231 N.getTag() == dwarf::DW_TAG_reference_type ||
1232 N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
1233 N.getTag() == dwarf::DW_TAG_const_type ||
1234 N.getTag() == dwarf::DW_TAG_immutable_type ||
1235 N.getTag() == dwarf::DW_TAG_volatile_type ||
1236 N.getTag() == dwarf::DW_TAG_restrict_type ||
1237 N.getTag() == dwarf::DW_TAG_atomic_type ||
1238 N.getTag() == dwarf::DW_TAG_LLVM_ptrauth_type ||
1239 N.getTag() == dwarf::DW_TAG_member ||
1240 (
N.getTag() == dwarf::DW_TAG_variable &&
N.isStaticMember()) ||
1241 N.getTag() == dwarf::DW_TAG_inheritance ||
1242 N.getTag() == dwarf::DW_TAG_friend ||
1243 N.getTag() == dwarf::DW_TAG_set_type ||
1244 N.getTag() == dwarf::DW_TAG_template_alias,
1246 if (
N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
1247 CheckDI(
isType(
N.getRawExtraData()),
"invalid pointer to member type", &
N,
1248 N.getRawExtraData());
1251 if (
N.getTag() == dwarf::DW_TAG_set_type) {
1252 if (
auto *
T =
N.getRawBaseType()) {
1253 auto *
Enum = dyn_cast_or_null<DICompositeType>(
T);
1254 auto *
Basic = dyn_cast_or_null<DIBasicType>(
T);
1256 (Enum &&
Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||
1257 (
Basic && (
Basic->getEncoding() == dwarf::DW_ATE_unsigned ||
1258 Basic->getEncoding() == dwarf::DW_ATE_signed ||
1259 Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||
1260 Basic->getEncoding() == dwarf::DW_ATE_signed_char ||
1261 Basic->getEncoding() == dwarf::DW_ATE_boolean)),
1262 "invalid set base type", &
N,
T);
1268 N.getRawBaseType());
1270 if (
N.getDWARFAddressSpace()) {
1271 CheckDI(
N.getTag() == dwarf::DW_TAG_pointer_type ||
1272 N.getTag() == dwarf::DW_TAG_reference_type ||
1273 N.getTag() == dwarf::DW_TAG_rvalue_reference_type,
1274 "DWARF address space only applies to pointer or reference types",
1281 return ((Flags & DINode::FlagLValueReference) &&
1282 (Flags & DINode::FlagRValueReference)) ||
1283 ((Flags & DINode::FlagTypePassByValue) &&
1284 (Flags & DINode::FlagTypePassByReference));
1287void Verifier::visitTemplateParams(
const MDNode &
N,
const Metadata &RawParams) {
1288 auto *Params = dyn_cast<MDTuple>(&RawParams);
1289 CheckDI(Params,
"invalid template params", &
N, &RawParams);
1291 CheckDI(
Op && isa<DITemplateParameter>(
Op),
"invalid template parameter",
1300 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type ||
1301 N.getTag() == dwarf::DW_TAG_structure_type ||
1302 N.getTag() == dwarf::DW_TAG_union_type ||
1303 N.getTag() == dwarf::DW_TAG_enumeration_type ||
1304 N.getTag() == dwarf::DW_TAG_class_type ||
1305 N.getTag() == dwarf::DW_TAG_variant_part ||
1306 N.getTag() == dwarf::DW_TAG_namelist,
1311 N.getRawBaseType());
1313 CheckDI(!
N.getRawElements() || isa<MDTuple>(
N.getRawElements()),
1314 "invalid composite elements", &
N,
N.getRawElements());
1316 N.getRawVTableHolder());
1318 "invalid reference flags", &
N);
1319 unsigned DIBlockByRefStruct = 1 << 4;
1320 CheckDI((
N.getFlags() & DIBlockByRefStruct) == 0,
1321 "DIBlockByRefStruct on DICompositeType is no longer supported", &
N);
1323 "DISubprogram contains null entry in `elements` field", &
N);
1326 const DINodeArray
Elements =
N.getElements();
1328 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,
1329 "invalid vector, expected one element of type subrange", &
N);
1332 if (
auto *Params =
N.getRawTemplateParams())
1333 visitTemplateParams(
N, *Params);
1335 if (
auto *
D =
N.getRawDiscriminator()) {
1336 CheckDI(isa<DIDerivedType>(
D) &&
N.getTag() == dwarf::DW_TAG_variant_part,
1337 "discriminator can only appear on variant part");
1340 if (
N.getRawDataLocation()) {
1341 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1342 "dataLocation can only appear in array type");
1345 if (
N.getRawAssociated()) {
1346 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1347 "associated can only appear in array type");
1350 if (
N.getRawAllocated()) {
1351 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1352 "allocated can only appear in array type");
1355 if (
N.getRawRank()) {
1356 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1357 "rank can only appear in array type");
1360 if (
N.getTag() == dwarf::DW_TAG_array_type) {
1361 CheckDI(
N.getRawBaseType(),
"array types must have a base type", &
N);
1366 CheckDI(
N.getTag() == dwarf::DW_TAG_subroutine_type,
"invalid tag", &
N);
1367 if (
auto *Types =
N.getRawTypeArray()) {
1368 CheckDI(isa<MDTuple>(Types),
"invalid composite elements", &
N, Types);
1369 for (
Metadata *Ty :
N.getTypeArray()->operands()) {
1370 CheckDI(
isType(Ty),
"invalid subroutine type ref", &
N, Types, Ty);
1374 "invalid reference flags", &
N);
1377void Verifier::visitDIFile(
const DIFile &
N) {
1378 CheckDI(
N.getTag() == dwarf::DW_TAG_file_type,
"invalid tag", &
N);
1379 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum =
N.getChecksum();
1382 "invalid checksum kind", &
N);
1384 switch (Checksum->Kind) {
1395 CheckDI(Checksum->Value.size() ==
Size,
"invalid checksum length", &
N);
1397 "invalid checksum", &
N);
1402 CheckDI(
N.isDistinct(),
"compile units must be distinct", &
N);
1403 CheckDI(
N.getTag() == dwarf::DW_TAG_compile_unit,
"invalid tag", &
N);
1407 CheckDI(
N.getRawFile() && isa<DIFile>(
N.getRawFile()),
"invalid file", &
N,
1409 CheckDI(!
N.getFile()->getFilename().empty(),
"invalid filename", &
N,
1413 "invalid emission kind", &
N);
1415 if (
auto *Array =
N.getRawEnumTypes()) {
1416 CheckDI(isa<MDTuple>(Array),
"invalid enum list", &
N, Array);
1417 for (
Metadata *
Op :
N.getEnumTypes()->operands()) {
1418 auto *
Enum = dyn_cast_or_null<DICompositeType>(
Op);
1419 CheckDI(Enum &&
Enum->getTag() == dwarf::DW_TAG_enumeration_type,
1420 "invalid enum type", &
N,
N.getEnumTypes(),
Op);
1423 if (
auto *Array =
N.getRawRetainedTypes()) {
1424 CheckDI(isa<MDTuple>(Array),
"invalid retained type list", &
N, Array);
1425 for (
Metadata *
Op :
N.getRetainedTypes()->operands()) {
1427 Op && (isa<DIType>(
Op) || (isa<DISubprogram>(
Op) &&
1428 !cast<DISubprogram>(
Op)->isDefinition())),
1429 "invalid retained type", &
N,
Op);
1432 if (
auto *Array =
N.getRawGlobalVariables()) {
1433 CheckDI(isa<MDTuple>(Array),
"invalid global variable list", &
N, Array);
1434 for (
Metadata *
Op :
N.getGlobalVariables()->operands()) {
1435 CheckDI(
Op && (isa<DIGlobalVariableExpression>(
Op)),
1436 "invalid global variable ref", &
N,
Op);
1439 if (
auto *Array =
N.getRawImportedEntities()) {
1440 CheckDI(isa<MDTuple>(Array),
"invalid imported entity list", &
N, Array);
1441 for (
Metadata *
Op :
N.getImportedEntities()->operands()) {
1442 CheckDI(
Op && isa<DIImportedEntity>(
Op),
"invalid imported entity ref",
1446 if (
auto *Array =
N.getRawMacros()) {
1447 CheckDI(isa<MDTuple>(Array),
"invalid macro list", &
N, Array);
1449 CheckDI(
Op && isa<DIMacroNode>(
Op),
"invalid macro ref", &
N,
Op);
1456 CheckDI(
N.getTag() == dwarf::DW_TAG_subprogram,
"invalid tag", &
N);
1458 if (
auto *
F =
N.getRawFile())
1459 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1461 CheckDI(
N.getLine() == 0,
"line specified with no file", &
N,
N.getLine());
1462 if (
auto *
T =
N.getRawType())
1463 CheckDI(isa<DISubroutineType>(
T),
"invalid subroutine type", &
N,
T);
1464 CheckDI(
isType(
N.getRawContainingType()),
"invalid containing type", &
N,
1465 N.getRawContainingType());
1466 if (
auto *Params =
N.getRawTemplateParams())
1467 visitTemplateParams(
N, *Params);
1468 if (
auto *S =
N.getRawDeclaration())
1469 CheckDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
1470 "invalid subprogram declaration", &
N, S);
1471 if (
auto *RawNode =
N.getRawRetainedNodes()) {
1472 auto *
Node = dyn_cast<MDTuple>(RawNode);
1473 CheckDI(
Node,
"invalid retained nodes list", &
N, RawNode);
1475 CheckDI(
Op && (isa<DILocalVariable>(
Op) || isa<DILabel>(
Op) ||
1476 isa<DIImportedEntity>(
Op)),
1477 "invalid retained nodes, expected DILocalVariable, DILabel or "
1483 "invalid reference flags", &
N);
1485 auto *Unit =
N.getRawUnit();
1486 if (
N.isDefinition()) {
1488 CheckDI(
N.isDistinct(),
"subprogram definitions must be distinct", &
N);
1489 CheckDI(Unit,
"subprogram definitions must have a compile unit", &
N);
1490 CheckDI(isa<DICompileUnit>(Unit),
"invalid unit type", &
N, Unit);
1493 auto *CT = dyn_cast_or_null<DICompositeType>(
N.getRawScope());
1494 if (CT && CT->getRawIdentifier() &&
1495 M.getContext().isODRUniquingDebugTypes())
1497 "definition subprograms cannot be nested within DICompositeType "
1498 "when enabling ODR",
1502 CheckDI(!Unit,
"subprogram declarations must not have a compile unit", &
N);
1504 "subprogram declaration must not have a declaration field");
1507 if (
auto *RawThrownTypes =
N.getRawThrownTypes()) {
1508 auto *ThrownTypes = dyn_cast<MDTuple>(RawThrownTypes);
1509 CheckDI(ThrownTypes,
"invalid thrown types list", &
N, RawThrownTypes);
1511 CheckDI(
Op && isa<DIType>(
Op),
"invalid thrown type", &
N, ThrownTypes,
1515 if (
N.areAllCallsDescribed())
1517 "DIFlagAllCallsDescribed must be attached to a definition");
1521 CheckDI(
N.getTag() == dwarf::DW_TAG_lexical_block,
"invalid tag", &
N);
1522 CheckDI(
N.getRawScope() && isa<DILocalScope>(
N.getRawScope()),
1523 "invalid local scope", &
N,
N.getRawScope());
1524 if (
auto *SP = dyn_cast<DISubprogram>(
N.getRawScope()))
1525 CheckDI(SP->isDefinition(),
"scope points into the type hierarchy", &
N);
1529 visitDILexicalBlockBase(
N);
1532 "cannot have column info without line info", &
N);
1536 visitDILexicalBlockBase(
N);
1540 CheckDI(
N.getTag() == dwarf::DW_TAG_common_block,
"invalid tag", &
N);
1541 if (
auto *S =
N.getRawScope())
1542 CheckDI(isa<DIScope>(S),
"invalid scope ref", &
N, S);
1543 if (
auto *S =
N.getRawDecl())
1544 CheckDI(isa<DIGlobalVariable>(S),
"invalid declaration", &
N, S);
1548 CheckDI(
N.getTag() == dwarf::DW_TAG_namespace,
"invalid tag", &
N);
1549 if (
auto *S =
N.getRawScope())
1550 CheckDI(isa<DIScope>(S),
"invalid scope ref", &
N, S);
1553void Verifier::visitDIMacro(
const DIMacro &
N) {
1556 "invalid macinfo type", &
N);
1557 CheckDI(!
N.getName().empty(),
"anonymous macro", &
N);
1558 if (!
N.getValue().empty()) {
1559 assert(
N.getValue().data()[0] !=
' ' &&
"Macro value has a space prefix");
1565 "invalid macinfo type", &
N);
1566 if (
auto *
F =
N.getRawFile())
1567 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1569 if (
auto *Array =
N.getRawElements()) {
1570 CheckDI(isa<MDTuple>(Array),
"invalid macro list", &
N, Array);
1571 for (
Metadata *
Op :
N.getElements()->operands()) {
1572 CheckDI(
Op && isa<DIMacroNode>(
Op),
"invalid macro ref", &
N,
Op);
1577void Verifier::visitDIModule(
const DIModule &
N) {
1578 CheckDI(
N.getTag() == dwarf::DW_TAG_module,
"invalid tag", &
N);
1579 CheckDI(!
N.getName().empty(),
"anonymous module", &
N);
1587 visitDITemplateParameter(
N);
1589 CheckDI(
N.getTag() == dwarf::DW_TAG_template_type_parameter,
"invalid tag",
1593void Verifier::visitDITemplateValueParameter(
1595 visitDITemplateParameter(
N);
1597 CheckDI(
N.getTag() == dwarf::DW_TAG_template_value_parameter ||
1598 N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
1599 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
1603void Verifier::visitDIVariable(
const DIVariable &
N) {
1604 if (
auto *S =
N.getRawScope())
1605 CheckDI(isa<DIScope>(S),
"invalid scope", &
N, S);
1606 if (
auto *
F =
N.getRawFile())
1607 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1614 CheckDI(
N.getTag() == dwarf::DW_TAG_variable,
"invalid tag", &
N);
1617 if (
N.isDefinition())
1618 CheckDI(
N.getType(),
"missing global variable type", &
N);
1619 if (
auto *Member =
N.getRawStaticDataMemberDeclaration()) {
1620 CheckDI(isa<DIDerivedType>(Member),
1621 "invalid static data member declaration", &
N, Member);
1630 CheckDI(
N.getTag() == dwarf::DW_TAG_variable,
"invalid tag", &
N);
1631 CheckDI(
N.getRawScope() && isa<DILocalScope>(
N.getRawScope()),
1632 "local variable requires a valid scope", &
N,
N.getRawScope());
1633 if (
auto Ty =
N.getType())
1634 CheckDI(!isa<DISubroutineType>(Ty),
"invalid type", &
N,
N.getType());
1637void Verifier::visitDIAssignID(
const DIAssignID &
N) {
1638 CheckDI(!
N.getNumOperands(),
"DIAssignID has no arguments", &
N);
1639 CheckDI(
N.isDistinct(),
"DIAssignID must be distinct", &
N);
1642void Verifier::visitDILabel(
const DILabel &
N) {
1643 if (
auto *S =
N.getRawScope())
1644 CheckDI(isa<DIScope>(S),
"invalid scope", &
N, S);
1645 if (
auto *
F =
N.getRawFile())
1646 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1648 CheckDI(
N.getTag() == dwarf::DW_TAG_label,
"invalid tag", &
N);
1649 CheckDI(
N.getRawScope() && isa<DILocalScope>(
N.getRawScope()),
1650 "label requires a valid scope", &
N,
N.getRawScope());
1654 CheckDI(
N.isValid(),
"invalid expression", &
N);
1657void Verifier::visitDIGlobalVariableExpression(
1661 visitDIGlobalVariable(*Var);
1663 visitDIExpression(*Expr);
1664 if (
auto Fragment = Expr->getFragmentInfo())
1665 verifyFragmentExpression(*GVE.
getVariable(), *Fragment, &GVE);
1670 CheckDI(
N.getTag() == dwarf::DW_TAG_APPLE_property,
"invalid tag", &
N);
1671 if (
auto *
T =
N.getRawType())
1673 if (
auto *
F =
N.getRawFile())
1674 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1678 CheckDI(
N.getTag() == dwarf::DW_TAG_imported_module ||
1679 N.getTag() == dwarf::DW_TAG_imported_declaration,
1681 if (
auto *S =
N.getRawScope())
1682 CheckDI(isa<DIScope>(S),
"invalid scope for imported entity", &
N, S);
1687void Verifier::visitComdat(
const Comdat &
C) {
1690 if (
TT.isOSBinFormatCOFF())
1696void Verifier::visitModuleIdents() {
1697 const NamedMDNode *Idents =
M.getNamedMetadata(
"llvm.ident");
1704 Check(
N->getNumOperands() == 1,
1705 "incorrect number of operands in llvm.ident metadata",
N);
1706 Check(dyn_cast_or_null<MDString>(
N->getOperand(0)),
1707 (
"invalid value for llvm.ident metadata entry operand"
1708 "(the operand should be a string)"),
1713void Verifier::visitModuleCommandLines() {
1714 const NamedMDNode *CommandLines =
M.getNamedMetadata(
"llvm.commandline");
1722 Check(
N->getNumOperands() == 1,
1723 "incorrect number of operands in llvm.commandline metadata",
N);
1724 Check(dyn_cast_or_null<MDString>(
N->getOperand(0)),
1725 (
"invalid value for llvm.commandline metadata entry operand"
1726 "(the operand should be a string)"),
1731void Verifier::visitModuleFlags() {
1741 visitModuleFlag(MDN, SeenIDs, Requirements);
1742 if (MDN->getNumOperands() != 3)
1744 if (
const auto *FlagName = dyn_cast_or_null<MDString>(MDN->getOperand(1))) {
1745 if (FlagName->getString() ==
"aarch64-elf-pauthabi-platform") {
1746 if (
const auto *PAP =
1747 mdconst::dyn_extract_or_null<ConstantInt>(MDN->getOperand(2)))
1748 PAuthABIPlatform = PAP->getZExtValue();
1749 }
else if (FlagName->getString() ==
"aarch64-elf-pauthabi-version") {
1750 if (
const auto *PAV =
1751 mdconst::dyn_extract_or_null<ConstantInt>(MDN->getOperand(2)))
1752 PAuthABIVersion = PAV->getZExtValue();
1757 if ((PAuthABIPlatform ==
uint64_t(-1)) != (PAuthABIVersion ==
uint64_t(-1)))
1758 CheckFailed(
"either both or no 'aarch64-elf-pauthabi-platform' and "
1759 "'aarch64-elf-pauthabi-version' module flags must be present");
1762 for (
const MDNode *Requirement : Requirements) {
1763 const MDString *
Flag = cast<MDString>(Requirement->getOperand(0));
1764 const Metadata *ReqValue = Requirement->getOperand(1);
1768 CheckFailed(
"invalid requirement on flag, flag is not present in module",
1773 if (
Op->getOperand(2) != ReqValue) {
1774 CheckFailed((
"invalid requirement on flag, "
1775 "flag does not have the required value"),
1783Verifier::visitModuleFlag(
const MDNode *
Op,
1789 "incorrect number of operands in module flag",
Op);
1792 Check(mdconst::dyn_extract_or_null<ConstantInt>(
Op->getOperand(0)),
1793 "invalid behavior operand in module flag (expected constant integer)",
1796 "invalid behavior operand in module flag (unexpected constant)",
1799 MDString *
ID = dyn_cast_or_null<MDString>(
Op->getOperand(1));
1800 Check(
ID,
"invalid ID operand in module flag (expected metadata string)",
1812 auto *
V = mdconst::dyn_extract_or_null<ConstantInt>(
Op->getOperand(2));
1813 Check(V &&
V->getValue().isNonNegative(),
1814 "invalid value for 'min' module flag (expected constant non-negative "
1821 Check(mdconst::dyn_extract_or_null<ConstantInt>(
Op->getOperand(2)),
1822 "invalid value for 'max' module flag (expected constant integer)",
1832 "invalid value for 'require' module flag (expected metadata pair)",
1835 (
"invalid value for 'require' module flag "
1836 "(first value operand should be a string)"),
1837 Value->getOperand(0));
1848 Check(isa<MDNode>(
Op->getOperand(2)),
1849 "invalid value for 'append'-type module flag "
1850 "(expected a metadata node)",
1860 "module flag identifiers must be unique (or of 'require' type)",
ID);
1863 if (
ID->getString() ==
"wchar_size") {
1865 = mdconst::dyn_extract_or_null<ConstantInt>(
Op->getOperand(2));
1866 Check(
Value,
"wchar_size metadata requires constant integer argument");
1869 if (
ID->getString() ==
"Linker Options") {
1873 Check(
M.getNamedMetadata(
"llvm.linker.options"),
1874 "'Linker Options' named metadata no longer supported");
1877 if (
ID->getString() ==
"SemanticInterposition") {
1879 mdconst::dyn_extract_or_null<ConstantInt>(
Op->getOperand(2));
1881 "SemanticInterposition metadata requires constant integer argument");
1884 if (
ID->getString() ==
"CG Profile") {
1885 for (
const MDOperand &MDO : cast<MDNode>(
Op->getOperand(2))->operands())
1886 visitModuleFlagCGProfileEntry(MDO);
1890void Verifier::visitModuleFlagCGProfileEntry(
const MDOperand &MDO) {
1891 auto CheckFunction = [&](
const MDOperand &FuncMDO) {
1894 auto F = dyn_cast<ValueAsMetadata>(FuncMDO);
1895 Check(
F && isa<Function>(
F->getValue()->stripPointerCasts()),
1896 "expected a Function or null", FuncMDO);
1898 auto Node = dyn_cast_or_null<MDNode>(MDO);
1899 Check(
Node &&
Node->getNumOperands() == 3,
"expected a MDNode triple", MDO);
1900 CheckFunction(
Node->getOperand(0));
1901 CheckFunction(
Node->getOperand(1));
1902 auto Count = dyn_cast_or_null<ConstantAsMetadata>(
Node->getOperand(2));
1903 Check(Count && Count->getType()->isIntegerTy(),
1904 "expected an integer constant",
Node->getOperand(2));
1910 if (
A.isStringAttribute()) {
1911#define GET_ATTR_NAMES
1912#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)
1913#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
1914 if (A.getKindAsString() == #DISPLAY_NAME) { \
1915 auto V = A.getValueAsString(); \
1916 if (!(V.empty() || V == "true" || V == "false")) \
1917 CheckFailed("invalid value for '" #DISPLAY_NAME "' attribute: " + V + \
1921#include "llvm/IR/Attributes.inc"
1926 CheckFailed(
"Attribute '" +
A.getAsString() +
"' should have an Argument",
1937 if (!
Attrs.hasAttributes())
1940 verifyAttributeTypes(Attrs, V);
1943 Check(Attr.isStringAttribute() ||
1945 "Attribute '" + Attr.getAsString() +
"' does not apply to parameters",
1948 if (
Attrs.hasAttribute(Attribute::ImmArg)) {
1950 "Attribute 'immarg' is incompatible with other attributes", V);
1955 unsigned AttrCount = 0;
1956 AttrCount +=
Attrs.hasAttribute(Attribute::ByVal);
1957 AttrCount +=
Attrs.hasAttribute(Attribute::InAlloca);
1958 AttrCount +=
Attrs.hasAttribute(Attribute::Preallocated);
1959 AttrCount +=
Attrs.hasAttribute(Attribute::StructRet) ||
1960 Attrs.hasAttribute(Attribute::InReg);
1961 AttrCount +=
Attrs.hasAttribute(Attribute::Nest);
1962 AttrCount +=
Attrs.hasAttribute(Attribute::ByRef);
1963 Check(AttrCount <= 1,
1964 "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
1965 "'byref', and 'sret' are incompatible!",
1968 Check(!(
Attrs.hasAttribute(Attribute::InAlloca) &&
1969 Attrs.hasAttribute(Attribute::ReadOnly)),
1971 "'inalloca and readonly' are incompatible!",
1974 Check(!(
Attrs.hasAttribute(Attribute::StructRet) &&
1975 Attrs.hasAttribute(Attribute::Returned)),
1977 "'sret and returned' are incompatible!",
1980 Check(!(
Attrs.hasAttribute(Attribute::ZExt) &&
1981 Attrs.hasAttribute(Attribute::SExt)),
1983 "'zeroext and signext' are incompatible!",
1986 Check(!(
Attrs.hasAttribute(Attribute::ReadNone) &&
1987 Attrs.hasAttribute(Attribute::ReadOnly)),
1989 "'readnone and readonly' are incompatible!",
1992 Check(!(
Attrs.hasAttribute(Attribute::ReadNone) &&
1993 Attrs.hasAttribute(Attribute::WriteOnly)),
1995 "'readnone and writeonly' are incompatible!",
1998 Check(!(
Attrs.hasAttribute(Attribute::ReadOnly) &&
1999 Attrs.hasAttribute(Attribute::WriteOnly)),
2001 "'readonly and writeonly' are incompatible!",
2004 Check(!(
Attrs.hasAttribute(Attribute::NoInline) &&
2005 Attrs.hasAttribute(Attribute::AlwaysInline)),
2007 "'noinline and alwaysinline' are incompatible!",
2010 Check(!(
Attrs.hasAttribute(Attribute::Writable) &&
2011 Attrs.hasAttribute(Attribute::ReadNone)),
2012 "Attributes writable and readnone are incompatible!", V);
2014 Check(!(
Attrs.hasAttribute(Attribute::Writable) &&
2015 Attrs.hasAttribute(Attribute::ReadOnly)),
2016 "Attributes writable and readonly are incompatible!", V);
2020 if (!Attr.isStringAttribute() &&
2021 IncompatibleAttrs.
contains(Attr.getKindAsEnum())) {
2022 CheckFailed(
"Attribute '" + Attr.getAsString() +
2023 "' applied to incompatible type!", V);
2028 if (isa<PointerType>(Ty)) {
2029 if (
Attrs.hasAttribute(Attribute::Alignment)) {
2030 Align AttrAlign =
Attrs.getAlignment().valueOrOne();
2032 "huge alignment values are unsupported", V);
2034 if (
Attrs.hasAttribute(Attribute::ByVal)) {
2038 "Attribute 'byval' does not support unsized types!", V);
2042 "'byval' argument has illegal target extension type", V);
2043 Check(
DL.getTypeAllocSize(ByValTy).getKnownMinValue() < (1ULL << 32),
2044 "huge 'byval' arguments are unsupported", V);
2046 if (
Attrs.hasAttribute(Attribute::ByRef)) {
2048 Check(
Attrs.getByRefType()->isSized(&Visited),
2049 "Attribute 'byref' does not support unsized types!", V);
2050 Check(
DL.getTypeAllocSize(
Attrs.getByRefType()).getKnownMinValue() <
2052 "huge 'byref' arguments are unsupported", V);
2054 if (
Attrs.hasAttribute(Attribute::InAlloca)) {
2056 Check(
Attrs.getInAllocaType()->isSized(&Visited),
2057 "Attribute 'inalloca' does not support unsized types!", V);
2058 Check(
DL.getTypeAllocSize(
Attrs.getInAllocaType()).getKnownMinValue() <
2060 "huge 'inalloca' arguments are unsupported", V);
2062 if (
Attrs.hasAttribute(Attribute::Preallocated)) {
2064 Check(
Attrs.getPreallocatedType()->isSized(&Visited),
2065 "Attribute 'preallocated' does not support unsized types!", V);
2067 DL.getTypeAllocSize(
Attrs.getPreallocatedType()).getKnownMinValue() <
2069 "huge 'preallocated' arguments are unsupported", V);
2073 if (
Attrs.hasAttribute(Attribute::Initializes)) {
2074 auto Inits =
Attrs.getAttribute(Attribute::Initializes).getInitializes();
2075 Check(!Inits.empty(),
"Attribute 'initializes' does not support empty list",
2078 "Attribute 'initializes' does not support unordered ranges", V);
2081 if (
Attrs.hasAttribute(Attribute::NoFPClass)) {
2082 uint64_t Val =
Attrs.getAttribute(Attribute::NoFPClass).getValueAsInt();
2083 Check(Val != 0,
"Attribute 'nofpclass' must have at least one test bit set",
2086 "Invalid value for 'nofpclass' test mask", V);
2088 if (
Attrs.hasAttribute(Attribute::Range)) {
2090 Attrs.getAttribute(Attribute::Range).getValueAsConstantRange();
2092 "Range bit width must match type bit width!", V);
2098 if (
Attrs.hasFnAttr(Attr)) {
2102 CheckFailed(
"\"" + Attr +
"\" takes an unsigned integer: " + S, V);
2109 const Value *V,
bool IsIntrinsic,
2111 if (
Attrs.isEmpty())
2114 if (AttributeListsVisited.
insert(
Attrs.getRawPointer()).second) {
2116 "Attribute list does not match Module context!", &Attrs, V);
2117 for (
const auto &AttrSet : Attrs) {
2118 Check(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),
2119 "Attribute set does not match Module context!", &AttrSet, V);
2120 for (
const auto &
A : AttrSet) {
2121 Check(
A.hasParentContext(Context),
2122 "Attribute does not match Module context!", &
A, V);
2127 bool SawNest =
false;
2128 bool SawReturned =
false;
2129 bool SawSRet =
false;
2130 bool SawSwiftSelf =
false;
2131 bool SawSwiftAsync =
false;
2132 bool SawSwiftError =
false;
2139 "Attribute '" +
RetAttr.getAsString() +
2140 "' does not apply to function return values",
2143 unsigned MaxParameterWidth = 0;
2144 auto GetMaxParameterWidth = [&MaxParameterWidth](
Type *Ty) {
2146 if (
auto *VT = dyn_cast<FixedVectorType>(Ty)) {
2147 unsigned Size = VT->getPrimitiveSizeInBits().getFixedValue();
2148 if (
Size > MaxParameterWidth)
2149 MaxParameterWidth =
Size;
2153 GetMaxParameterWidth(FT->getReturnType());
2154 verifyParameterAttrs(RetAttrs, FT->getReturnType(), V);
2157 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2158 Type *Ty = FT->getParamType(i);
2163 "immarg attribute only applies to intrinsics", V);
2166 "Attribute 'elementtype' can only be applied to intrinsics"
2171 verifyParameterAttrs(ArgAttrs, Ty, V);
2172 GetMaxParameterWidth(Ty);
2175 Check(!SawNest,
"More than one parameter has attribute nest!", V);
2180 Check(!SawReturned,
"More than one parameter has attribute returned!", V);
2182 "Incompatible argument and return types for 'returned' attribute",
2188 Check(!SawSRet,
"Cannot have multiple 'sret' parameters!", V);
2189 Check(i == 0 || i == 1,
2190 "Attribute 'sret' is not on first or second parameter!", V);
2195 Check(!SawSwiftSelf,
"Cannot have multiple 'swiftself' parameters!", V);
2196 SawSwiftSelf =
true;
2200 Check(!SawSwiftAsync,
"Cannot have multiple 'swiftasync' parameters!", V);
2201 SawSwiftAsync =
true;
2205 Check(!SawSwiftError,
"Cannot have multiple 'swifterror' parameters!", V);
2206 SawSwiftError =
true;
2210 Check(i == FT->getNumParams() - 1,
2211 "inalloca isn't on the last parameter!", V);
2215 if (!
Attrs.hasFnAttrs())
2218 verifyAttributeTypes(
Attrs.getFnAttrs(), V);
2222 "Attribute '" +
FnAttr.getAsString() +
2223 "' does not apply to functions!",
2226 Check(!(
Attrs.hasFnAttr(Attribute::NoInline) &&
2227 Attrs.hasFnAttr(Attribute::AlwaysInline)),
2228 "Attributes 'noinline and alwaysinline' are incompatible!", V);
2230 if (
Attrs.hasFnAttr(Attribute::OptimizeNone)) {
2232 "Attribute 'optnone' requires 'noinline'!", V);
2234 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2235 "Attributes 'optsize and optnone' are incompatible!", V);
2238 "Attributes 'minsize and optnone' are incompatible!", V);
2240 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForDebugging),
2241 "Attributes 'optdebug and optnone' are incompatible!", V);
2244 Check(!(
Attrs.hasFnAttr(Attribute::SanitizeRealtime) &&
2245 Attrs.hasFnAttr(Attribute::SanitizeRealtimeBlocking)),
2247 "'sanitize_realtime and sanitize_realtime_blocking' are incompatible!",
2250 if (
Attrs.hasFnAttr(Attribute::OptimizeForDebugging)) {
2251 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2252 "Attributes 'optsize and optdebug' are incompatible!", V);
2255 "Attributes 'minsize and optdebug' are incompatible!", V);
2258 Check(!
Attrs.hasAttrSomewhere(Attribute::Writable) ||
2260 "Attribute writable and memory without argmem: write are incompatible!",
2263 if (
Attrs.hasFnAttr(
"aarch64_pstate_sm_enabled")) {
2264 Check(!
Attrs.hasFnAttr(
"aarch64_pstate_sm_compatible"),
2265 "Attributes 'aarch64_pstate_sm_enabled and "
2266 "aarch64_pstate_sm_compatible' are incompatible!",
2270 Check((
Attrs.hasFnAttr(
"aarch64_new_za") +
Attrs.hasFnAttr(
"aarch64_in_za") +
2271 Attrs.hasFnAttr(
"aarch64_inout_za") +
2272 Attrs.hasFnAttr(
"aarch64_out_za") +
2273 Attrs.hasFnAttr(
"aarch64_preserves_za") +
2274 Attrs.hasFnAttr(
"aarch64_za_state_agnostic")) <= 1,
2275 "Attributes 'aarch64_new_za', 'aarch64_in_za', 'aarch64_out_za', "
2276 "'aarch64_inout_za', 'aarch64_preserves_za' and "
2277 "'aarch64_za_state_agnostic' are mutually exclusive",
2281 Attrs.hasFnAttr(
"aarch64_in_zt0") +
2282 Attrs.hasFnAttr(
"aarch64_inout_zt0") +
2283 Attrs.hasFnAttr(
"aarch64_out_zt0") +
2284 Attrs.hasFnAttr(
"aarch64_preserves_zt0") +
2285 Attrs.hasFnAttr(
"aarch64_za_state_agnostic")) <= 1,
2286 "Attributes 'aarch64_new_zt0', 'aarch64_in_zt0', 'aarch64_out_zt0', "
2287 "'aarch64_inout_zt0', 'aarch64_preserves_zt0' and "
2288 "'aarch64_za_state_agnostic' are mutually exclusive",
2291 if (
Attrs.hasFnAttr(Attribute::JumpTable)) {
2294 "Attribute 'jumptable' requires 'unnamed_addr'", V);
2297 if (
auto Args =
Attrs.getFnAttrs().getAllocSizeArgs()) {
2299 if (ParamNo >= FT->getNumParams()) {
2300 CheckFailed(
"'allocsize' " +
Name +
" argument is out of bounds", V);
2304 if (!FT->getParamType(ParamNo)->isIntegerTy()) {
2305 CheckFailed(
"'allocsize' " +
Name +
2306 " argument must refer to an integer parameter",
2314 if (!CheckParam(
"element size",
Args->first))
2317 if (
Args->second && !CheckParam(
"number of elements", *
Args->second))
2321 if (
Attrs.hasFnAttr(Attribute::AllocKind)) {
2329 "'allockind()' requires exactly one of alloc, realloc, and free");
2333 CheckFailed(
"'allockind(\"free\")' doesn't allow uninitialized, zeroed, "
2334 "or aligned modifiers.");
2336 if ((K & ZeroedUninit) == ZeroedUninit)
2337 CheckFailed(
"'allockind()' can't be both zeroed and uninitialized");
2340 if (
Attrs.hasFnAttr(Attribute::VScaleRange)) {
2341 unsigned VScaleMin =
Attrs.getFnAttrs().getVScaleRangeMin();
2343 CheckFailed(
"'vscale_range' minimum must be greater than 0", V);
2345 CheckFailed(
"'vscale_range' minimum must be power-of-two value", V);
2346 std::optional<unsigned> VScaleMax =
Attrs.getFnAttrs().getVScaleRangeMax();
2347 if (VScaleMax && VScaleMin > VScaleMax)
2348 CheckFailed(
"'vscale_range' minimum cannot be greater than maximum", V);
2350 CheckFailed(
"'vscale_range' maximum must be power-of-two value", V);
2353 if (
Attrs.hasFnAttr(
"frame-pointer")) {
2355 if (
FP !=
"all" &&
FP !=
"non-leaf" &&
FP !=
"none" &&
FP !=
"reserved")
2356 CheckFailed(
"invalid value for 'frame-pointer' attribute: " +
FP, V);
2360 if (MaxParameterWidth >= 512 &&
Attrs.hasFnAttr(
"target-features") &&
2362 StringRef TF =
Attrs.getFnAttr(
"target-features").getValueAsString();
2364 "512-bit vector arguments require 'evex512' for AVX512", V);
2367 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-prefix", V);
2368 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-entry", V);
2369 checkUnsignedBaseTenFuncAttr(Attrs,
"warn-stack-size", V);
2371 if (
auto A =
Attrs.getFnAttr(
"sign-return-address");
A.isValid()) {
2373 if (S !=
"none" && S !=
"all" && S !=
"non-leaf")
2374 CheckFailed(
"invalid value for 'sign-return-address' attribute: " + S, V);
2377 if (
auto A =
Attrs.getFnAttr(
"sign-return-address-key");
A.isValid()) {
2379 if (S !=
"a_key" && S !=
"b_key")
2380 CheckFailed(
"invalid value for 'sign-return-address-key' attribute: " + S,
2382 if (
auto AA =
Attrs.getFnAttr(
"sign-return-address"); !AA.isValid()) {
2384 "'sign-return-address-key' present without `sign-return-address`");
2388 if (
auto A =
Attrs.getFnAttr(
"branch-target-enforcement");
A.isValid()) {
2390 if (S !=
"" && S !=
"true" && S !=
"false")
2392 "invalid value for 'branch-target-enforcement' attribute: " + S, V);
2395 if (
auto A =
Attrs.getFnAttr(
"branch-protection-pauth-lr");
A.isValid()) {
2397 if (S !=
"" && S !=
"true" && S !=
"false")
2399 "invalid value for 'branch-protection-pauth-lr' attribute: " + S, V);
2402 if (
auto A =
Attrs.getFnAttr(
"guarded-control-stack");
A.isValid()) {
2404 if (S !=
"" && S !=
"true" && S !=
"false")
2405 CheckFailed(
"invalid value for 'guarded-control-stack' attribute: " + S,
2409 if (
auto A =
Attrs.getFnAttr(
"vector-function-abi-variant");
A.isValid()) {
2413 CheckFailed(
"invalid name for a VFABI variant: " + S, V);
2416 if (
auto A =
Attrs.getFnAttr(
"denormal-fp-math");
A.isValid()) {
2419 CheckFailed(
"invalid value for 'denormal-fp-math' attribute: " + S, V);
2422 if (
auto A =
Attrs.getFnAttr(
"denormal-fp-math-f32");
A.isValid()) {
2425 CheckFailed(
"invalid value for 'denormal-fp-math-f32' attribute: " + S,
2430void Verifier::verifyFunctionMetadata(
2431 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
2432 for (
const auto &Pair : MDs) {
2433 if (Pair.first == LLVMContext::MD_prof) {
2434 MDNode *MD = Pair.second;
2436 "!prof annotations should have no less than 2 operands", MD);
2439 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null",
2442 "expected string with name of the !prof annotation", MD);
2445 Check(ProfName ==
"function_entry_count" ||
2446 ProfName ==
"synthetic_function_entry_count",
2447 "first operand should be 'function_entry_count'"
2448 " or 'synthetic_function_entry_count'",
2452 Check(MD->
getOperand(1) !=
nullptr,
"second operand should not be null",
2455 "expected integer argument to function_entry_count", MD);
2456 }
else if (Pair.first == LLVMContext::MD_kcfi_type) {
2457 MDNode *MD = Pair.second;
2459 "!kcfi_type must have exactly one operand", MD);
2460 Check(MD->
getOperand(0) !=
nullptr,
"!kcfi_type operand must not be null",
2463 "expected a constant operand for !kcfi_type", MD);
2465 Check(isa<ConstantInt>(
C) && isa<IntegerType>(
C->getType()),
2466 "expected a constant integer operand for !kcfi_type", MD);
2468 "expected a 32-bit integer constant operand for !kcfi_type", MD);
2473void Verifier::visitConstantExprsRecursively(
const Constant *EntryC) {
2474 if (!ConstantExprVisited.
insert(EntryC).second)
2478 Stack.push_back(EntryC);
2480 while (!
Stack.empty()) {
2484 if (
const auto *CE = dyn_cast<ConstantExpr>(
C))
2485 visitConstantExpr(CE);
2487 if (
const auto *CPA = dyn_cast<ConstantPtrAuth>(
C))
2488 visitConstantPtrAuth(CPA);
2490 if (
const auto *GV = dyn_cast<GlobalValue>(
C)) {
2493 Check(GV->
getParent() == &M,
"Referencing global in another module!",
2499 for (
const Use &U :
C->operands()) {
2500 const auto *OpC = dyn_cast<Constant>(U);
2503 if (!ConstantExprVisited.
insert(OpC).second)
2505 Stack.push_back(OpC);
2510void Verifier::visitConstantExpr(
const ConstantExpr *CE) {
2511 if (
CE->getOpcode() == Instruction::BitCast)
2514 "Invalid bitcast", CE);
2519 "signed ptrauth constant base pointer must have pointer type");
2522 "signed ptrauth constant must have same type as its base pointer");
2525 "signed ptrauth constant key must be i32 constant integer");
2528 "signed ptrauth constant address discriminator must be a pointer");
2531 "signed ptrauth constant discriminator must be i64 constant integer");
2534bool Verifier::verifyAttributeCount(
AttributeList Attrs,
unsigned Params) {
2537 return Attrs.getNumAttrSets() <= Params + 2;
2540void Verifier::verifyInlineAsmCall(
const CallBase &Call) {
2543 unsigned LabelNo = 0;
2554 if (CI.isIndirect) {
2555 const Value *Arg =
Call.getArgOperand(ArgNo);
2557 "Operand for indirect constraint must have pointer type", &Call);
2560 "Operand for indirect constraint must have elementtype attribute",
2563 Check(!
Call.paramHasAttr(ArgNo, Attribute::ElementType),
2564 "Elementtype attribute can only be applied for indirect "
2572 if (
auto *CallBr = dyn_cast<CallBrInst>(&Call)) {
2573 Check(LabelNo == CallBr->getNumIndirectDests(),
2574 "Number of label constraints does not match number of callbr dests",
2577 Check(LabelNo == 0,
"Label constraints can only be used with callbr",
2583void Verifier::verifyStatepoint(
const CallBase &Call) {
2585 Call.getCalledFunction()->getIntrinsicID() ==
2586 Intrinsic::experimental_gc_statepoint);
2588 Check(!
Call.doesNotAccessMemory() && !
Call.onlyReadsMemory() &&
2589 !
Call.onlyAccessesArgMemory(),
2590 "gc.statepoint must read and write all memory to preserve "
2591 "reordering restrictions required by safepoint semantics",
2594 const int64_t NumPatchBytes =
2595 cast<ConstantInt>(
Call.getArgOperand(1))->getSExtValue();
2596 assert(isInt<32>(NumPatchBytes) &&
"NumPatchBytesV is an i32!");
2597 Check(NumPatchBytes >= 0,
2598 "gc.statepoint number of patchable bytes must be "
2602 Type *TargetElemType =
Call.getParamElementType(2);
2603 Check(TargetElemType,
2604 "gc.statepoint callee argument must have elementtype attribute", Call);
2605 FunctionType *TargetFuncType = dyn_cast<FunctionType>(TargetElemType);
2606 Check(TargetFuncType,
2607 "gc.statepoint callee elementtype must be function type", Call);
2609 const int NumCallArgs = cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue();
2610 Check(NumCallArgs >= 0,
2611 "gc.statepoint number of arguments to underlying call "
2614 const int NumParams = (int)TargetFuncType->getNumParams();
2615 if (TargetFuncType->isVarArg()) {
2616 Check(NumCallArgs >= NumParams,
2617 "gc.statepoint mismatch in number of vararg call args", Call);
2620 Check(TargetFuncType->getReturnType()->isVoidTy(),
2621 "gc.statepoint doesn't support wrapping non-void "
2622 "vararg functions yet",
2625 Check(NumCallArgs == NumParams,
2626 "gc.statepoint mismatch in number of call args", Call);
2629 = cast<ConstantInt>(
Call.getArgOperand(4))->getZExtValue();
2631 "unknown flag used in gc.statepoint flags argument", Call);
2636 for (
int i = 0; i < NumParams; i++) {
2637 Type *ParamType = TargetFuncType->getParamType(i);
2638 Type *ArgType =
Call.getArgOperand(5 + i)->getType();
2639 Check(ArgType == ParamType,
2640 "gc.statepoint call argument does not match wrapped "
2644 if (TargetFuncType->isVarArg()) {
2647 "Attribute 'sret' cannot be used for vararg call arguments!", Call);
2651 const int EndCallArgsInx = 4 + NumCallArgs;
2653 const Value *NumTransitionArgsV =
Call.getArgOperand(EndCallArgsInx + 1);
2654 Check(isa<ConstantInt>(NumTransitionArgsV),
2655 "gc.statepoint number of transition arguments "
2656 "must be constant integer",
2658 const int NumTransitionArgs =
2659 cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
2660 Check(NumTransitionArgs == 0,
2661 "gc.statepoint w/inline transition bundle is deprecated", Call);
2662 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
2664 const Value *NumDeoptArgsV =
Call.getArgOperand(EndTransitionArgsInx + 1);
2665 Check(isa<ConstantInt>(NumDeoptArgsV),
2666 "gc.statepoint number of deoptimization arguments "
2667 "must be constant integer",
2669 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
2670 Check(NumDeoptArgs == 0,
2671 "gc.statepoint w/inline deopt operands is deprecated", Call);
2673 const int ExpectedNumArgs = 7 + NumCallArgs;
2674 Check(ExpectedNumArgs == (
int)
Call.arg_size(),
2675 "gc.statepoint too many arguments", Call);
2680 for (
const User *U :
Call.users()) {
2681 const CallInst *UserCall = dyn_cast<const CallInst>(U);
2682 Check(UserCall,
"illegal use of statepoint token", Call, U);
2685 Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
2686 "gc.result or gc.relocate are the only value uses "
2687 "of a gc.statepoint",
2689 if (isa<GCResultInst>(UserCall)) {
2691 "gc.result connected to wrong gc.statepoint", Call, UserCall);
2692 }
else if (isa<GCRelocateInst>(Call)) {
2694 "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
2708void Verifier::verifyFrameRecoverIndices() {
2709 for (
auto &Counts : FrameEscapeInfo) {
2711 unsigned EscapedObjectCount = Counts.second.first;
2712 unsigned MaxRecoveredIndex = Counts.second.second;
2713 Check(MaxRecoveredIndex <= EscapedObjectCount,
2714 "all indices passed to llvm.localrecover must be less than the "
2715 "number of arguments passed to llvm.localescape in the parent "
2723 if (
auto *
II = dyn_cast<InvokeInst>(Terminator))
2724 UnwindDest =
II->getUnwindDest();
2725 else if (
auto *CSI = dyn_cast<CatchSwitchInst>(Terminator))
2726 UnwindDest = CSI->getUnwindDest();
2728 UnwindDest = cast<CleanupReturnInst>(Terminator)->getUnwindDest();
2732void Verifier::verifySiblingFuncletUnwinds() {
2735 for (
const auto &Pair : SiblingFuncletInfo) {
2737 if (Visited.
count(PredPad))
2743 if (
Active.count(SuccPad)) {
2749 Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
2750 if (CycleTerminator != CyclePad)
2753 }
while (CyclePad != SuccPad);
2754 Check(
false,
"EH pads can't handle each other's exceptions",
2758 if (!Visited.
insert(SuccPad).second)
2762 auto TermI = SiblingFuncletInfo.find(PredPad);
2763 if (TermI == SiblingFuncletInfo.end())
2776void Verifier::visitFunction(
const Function &
F) {
2777 visitGlobalValue(
F);
2781 unsigned NumArgs =
F.arg_size();
2783 Check(&Context == &
F.getContext(),
2784 "Function context does not match Module context!", &
F);
2786 Check(!
F.hasCommonLinkage(),
"Functions may not have common linkage", &
F);
2787 Check(FT->getNumParams() == NumArgs,
2788 "# formal arguments must match # of arguments for function type!", &
F,
2790 Check(
F.getReturnType()->isFirstClassType() ||
2791 F.getReturnType()->isVoidTy() ||
F.getReturnType()->isStructTy(),
2792 "Functions cannot return aggregate values!", &
F);
2794 Check(!
F.hasStructRetAttr() ||
F.getReturnType()->isVoidTy(),
2795 "Invalid struct return type!", &
F);
2799 Check(verifyAttributeCount(Attrs, FT->getNumParams()),
2800 "Attribute after last parameter!", &
F);
2802 CheckDI(
F.IsNewDbgInfoFormat ==
F.getParent()->IsNewDbgInfoFormat,
2803 "Function debug format should match parent module", &
F,
2804 F.IsNewDbgInfoFormat,
F.getParent(),
2805 F.getParent()->IsNewDbgInfoFormat);
2807 bool IsIntrinsic =
F.isIntrinsic();
2810 verifyFunctionAttrs(FT, Attrs, &
F, IsIntrinsic,
false);
2816 "Attribute 'builtin' can only be applied to a callsite.", &
F);
2818 Check(!
Attrs.hasAttrSomewhere(Attribute::ElementType),
2819 "Attribute 'elementtype' can only be applied to a callsite.", &
F);
2821 if (
Attrs.hasFnAttr(Attribute::Naked))
2823 Check(Arg.use_empty(),
"cannot use argument of naked function", &Arg);
2828 switch (
F.getCallingConv()) {
2833 Check(
F.arg_empty() ||
Attrs.hasParamAttr(0, Attribute::ByVal),
2834 "Calling convention parameter requires byval", &
F);
2841 Check(
F.getReturnType()->isVoidTy(),
2842 "Calling convention requires void return type", &
F);
2849 Check(!
F.hasStructRetAttr(),
"Calling convention does not allow sret", &
F);
2851 const unsigned StackAS =
DL.getAllocaAddrSpace();
2854 Check(!
Attrs.hasParamAttr(i, Attribute::ByVal),
2855 "Calling convention disallows byval", &
F);
2856 Check(!
Attrs.hasParamAttr(i, Attribute::Preallocated),
2857 "Calling convention disallows preallocated", &
F);
2858 Check(!
Attrs.hasParamAttr(i, Attribute::InAlloca),
2859 "Calling convention disallows inalloca", &
F);
2861 if (
Attrs.hasParamAttr(i, Attribute::ByRef)) {
2864 Check(Arg.getType()->getPointerAddressSpace() != StackAS,
2865 "Calling convention disallows stack byref", &
F);
2879 "Calling convention does not support varargs or "
2880 "perfect forwarding!",
2888 Check(Arg.getType() == FT->getParamType(i),
2889 "Argument value does not match function argument type!", &Arg,
2890 FT->getParamType(i));
2891 Check(Arg.getType()->isFirstClassType(),
2892 "Function arguments must have first-class types!", &Arg);
2894 Check(!Arg.getType()->isMetadataTy(),
2895 "Function takes metadata but isn't an intrinsic", &Arg, &
F);
2896 Check(!Arg.getType()->isTokenTy(),
2897 "Function takes token but isn't an intrinsic", &Arg, &
F);
2898 Check(!Arg.getType()->isX86_AMXTy(),
2899 "Function takes x86_amx but isn't an intrinsic", &Arg, &
F);
2903 if (
Attrs.hasParamAttr(i, Attribute::SwiftError)) {
2904 verifySwiftErrorValue(&Arg);
2910 Check(!
F.getReturnType()->isTokenTy(),
2911 "Function returns a token but isn't an intrinsic", &
F);
2912 Check(!
F.getReturnType()->isX86_AMXTy(),
2913 "Function returns a x86_amx but isn't an intrinsic", &
F);
2918 F.getAllMetadata(MDs);
2919 assert(
F.hasMetadata() != MDs.
empty() &&
"Bit out-of-sync");
2920 verifyFunctionMetadata(MDs);
2923 if (
F.hasPersonalityFn()) {
2924 auto *Per = dyn_cast<Function>(
F.getPersonalityFn()->stripPointerCasts());
2926 Check(Per->getParent() ==
F.getParent(),
2927 "Referencing personality function in another module!", &
F,
2928 F.getParent(), Per, Per->getParent());
2932 BlockEHFuncletColors.
clear();
2934 if (
F.isMaterializable()) {
2936 Check(MDs.
empty(),
"unmaterialized function cannot have metadata", &
F,
2938 }
else if (
F.isDeclaration()) {
2939 for (
const auto &
I : MDs) {
2941 CheckDI(
I.first != LLVMContext::MD_dbg ||
2942 !cast<DISubprogram>(
I.second)->isDistinct(),
2943 "function declaration may only have a unique !dbg attachment",
2945 Check(
I.first != LLVMContext::MD_prof,
2946 "function declaration may not have a !prof attachment", &
F);
2949 visitMDNode(*
I.second, AreDebugLocsAllowed::Yes);
2951 Check(!
F.hasPersonalityFn(),
2952 "Function declaration shouldn't have a personality routine", &
F);
2956 Check(!IsIntrinsic,
"llvm intrinsics cannot be defined!", &
F);
2961 "Entry block to function must not have predecessors!", Entry);
2964 if (
Entry->hasAddressTaken()) {
2966 "blockaddress may not be used with the entry block!", Entry);
2969 unsigned NumDebugAttachments = 0, NumProfAttachments = 0,
2970 NumKCFIAttachments = 0;
2972 for (
const auto &
I : MDs) {
2974 auto AllowLocs = AreDebugLocsAllowed::No;
2978 case LLVMContext::MD_dbg: {
2979 ++NumDebugAttachments;
2980 CheckDI(NumDebugAttachments == 1,
2981 "function must have a single !dbg attachment", &
F,
I.second);
2982 CheckDI(isa<DISubprogram>(
I.second),
2983 "function !dbg attachment must be a subprogram", &
F,
I.second);
2984 CheckDI(cast<DISubprogram>(
I.second)->isDistinct(),
2985 "function definition may only have a distinct !dbg attachment",
2988 auto *SP = cast<DISubprogram>(
I.second);
2989 const Function *&AttachedTo = DISubprogramAttachments[SP];
2990 CheckDI(!AttachedTo || AttachedTo == &
F,
2991 "DISubprogram attached to more than one function", SP, &
F);
2993 AllowLocs = AreDebugLocsAllowed::Yes;
2996 case LLVMContext::MD_prof:
2997 ++NumProfAttachments;
2998 Check(NumProfAttachments == 1,
2999 "function must have a single !prof attachment", &
F,
I.second);
3001 case LLVMContext::MD_kcfi_type:
3002 ++NumKCFIAttachments;
3003 Check(NumKCFIAttachments == 1,
3004 "function must have a single !kcfi_type attachment", &
F,
3010 visitMDNode(*
I.second, AllowLocs);
3018 if (
F.isIntrinsic() &&
F.getParent()->isMaterialized()) {
3020 if (
F.hasAddressTaken(&U,
false,
true,
false,
3022 Check(
false,
"Invalid user of intrinsic instruction!", U);
3026 switch (
F.getIntrinsicID()) {
3027 case Intrinsic::experimental_gc_get_pointer_base: {
3029 Check(FT->getNumParams() == 1,
"wrong number of parameters",
F);
3030 Check(isa<PointerType>(
F.getReturnType()),
3031 "gc.get.pointer.base must return a pointer",
F);
3032 Check(FT->getParamType(0) ==
F.getReturnType(),
3033 "gc.get.pointer.base operand and result must be of the same type",
F);
3036 case Intrinsic::experimental_gc_get_pointer_offset: {
3038 Check(FT->getNumParams() == 1,
"wrong number of parameters",
F);
3039 Check(isa<PointerType>(FT->getParamType(0)),
3040 "gc.get.pointer.offset operand must be a pointer",
F);
3041 Check(
F.getReturnType()->isIntegerTy(),
3042 "gc.get.pointer.offset must return integer",
F);
3047 auto *
N =
F.getSubprogram();
3048 HasDebugInfo = (
N !=
nullptr);
3067 CheckDI(Parent && isa<DILocalScope>(Parent),
3068 "DILocation's scope must be a DILocalScope",
N, &
F, &
I,
DL, Parent);
3071 Check(Scope,
"Failed to find DILocalScope",
DL);
3073 if (!Seen.
insert(Scope).second)
3080 if (SP && ((Scope != SP) && !Seen.
insert(SP).second))
3084 "!dbg attachment points at wrong subprogram for function",
N, &
F,
3088 for (
auto &
I : BB) {
3089 VisitDebugLoc(
I,
I.getDebugLoc().getAsMDNode());
3091 if (
auto MD =
I.getMetadata(LLVMContext::MD_loop))
3093 VisitDebugLoc(
I, dyn_cast_or_null<MDNode>(MD->
getOperand(i)));
3094 if (BrokenDebugInfo)
3101void Verifier::visitBasicBlock(
BasicBlock &BB) {
3102 InstsInThisBlock.
clear();
3103 ConvergenceVerifyHelper.
visit(BB);
3110 if (isa<PHINode>(BB.
front())) {
3115 Check(PN.getNumIncomingValues() == Preds.size(),
3116 "PHINode should have one entry for each predecessor of its "
3117 "parent basic block!",
3122 Values.
reserve(PN.getNumIncomingValues());
3123 for (
unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
3125 std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));
3128 for (
unsigned i = 0, e = Values.
size(); i != e; ++i) {
3133 Check(i == 0 || Values[i].first != Values[i - 1].first ||
3134 Values[i].second == Values[i - 1].second,
3135 "PHI node has multiple entries for the same basic block with "
3136 "different incoming values!",
3137 &PN, Values[i].first, Values[i].second, Values[i - 1].second);
3141 Check(Values[i].first == Preds[i],
3142 "PHI node entries do not match predecessors!", &PN,
3143 Values[i].first, Preds[i]);
3151 Check(
I.getParent() == &BB,
"Instruction has bogus parent pointer!");
3154 CheckDI(BB.IsNewDbgInfoFormat == BB.getParent()->IsNewDbgInfoFormat,
3155 "BB debug format should match parent function", &BB,
3156 BB.IsNewDbgInfoFormat, BB.getParent(),
3157 BB.getParent()->IsNewDbgInfoFormat);
3160 if (BB.IsNewDbgInfoFormat)
3161 CheckDI(!BB.getTrailingDbgRecords(),
"Basic Block has trailing DbgRecords!",
3167 Check(&
I ==
I.getParent()->getTerminator(),
3168 "Terminator found in the middle of a basic block!",
I.getParent());
3172void Verifier::visitBranchInst(
BranchInst &BI) {
3175 "Branch condition is not 'i1' type!", &BI, BI.
getCondition());
3180void Verifier::visitReturnInst(
ReturnInst &RI) {
3183 if (
F->getReturnType()->isVoidTy())
3185 "Found return instr that returns non-void in Function of void "
3187 &RI,
F->getReturnType());
3190 "Function return type does not match operand "
3191 "type of return inst!",
3192 &RI,
F->getReturnType());
3199void Verifier::visitSwitchInst(
SwitchInst &SI) {
3200 Check(
SI.getType()->isVoidTy(),
"Switch must have void result type!", &SI);
3203 Type *SwitchTy =
SI.getCondition()->getType();
3205 for (
auto &Case :
SI.cases()) {
3206 Check(isa<ConstantInt>(
SI.getOperand(Case.getCaseIndex() * 2 + 2)),
3207 "Case value is not a constant integer.", &SI);
3208 Check(Case.getCaseValue()->getType() == SwitchTy,
3209 "Switch constants must all be same type as switch value!", &SI);
3211 "Duplicate integer as switch case", &SI, Case.getCaseValue());
3219 "Indirectbr operand must have pointer type!", &BI);
3222 "Indirectbr destinations must all have pointer type!", &BI);
3227void Verifier::visitCallBrInst(
CallBrInst &CBI) {
3228 Check(CBI.
isInlineAsm(),
"Callbr is currently only used for asm-goto!", &CBI);
3230 Check(!
IA->canThrow(),
"Unwinding from Callbr is not allowed");
3232 verifyInlineAsmCall(CBI);
3236void Verifier::visitSelectInst(
SelectInst &SI) {
3239 "Invalid operands for select instruction!", &SI);
3241 Check(
SI.getTrueValue()->getType() ==
SI.getType(),
3242 "Select values must have same type as select instruction!", &SI);
3250 Check(
false,
"User-defined operators should not live outside of a pass!", &
I);
3255 Type *SrcTy =
I.getOperand(0)->getType();
3256 Type *DestTy =
I.getType();
3265 "trunc source and destination must both be a vector or neither", &
I);
3266 Check(SrcBitSize > DestBitSize,
"DestTy too big for Trunc", &
I);
3271void Verifier::visitZExtInst(
ZExtInst &
I) {
3273 Type *SrcTy =
I.getOperand(0)->getType();
3274 Type *DestTy =
I.getType();
3280 "zext source and destination must both be a vector or neither", &
I);
3284 Check(SrcBitSize < DestBitSize,
"Type too small for ZExt", &
I);
3289void Verifier::visitSExtInst(
SExtInst &
I) {
3291 Type *SrcTy =
I.getOperand(0)->getType();
3292 Type *DestTy =
I.getType();
3301 "sext source and destination must both be a vector or neither", &
I);
3302 Check(SrcBitSize < DestBitSize,
"Type too small for SExt", &
I);
3309 Type *SrcTy =
I.getOperand(0)->getType();
3310 Type *DestTy =
I.getType();
3318 "fptrunc source and destination must both be a vector or neither", &
I);
3319 Check(SrcBitSize > DestBitSize,
"DestTy too big for FPTrunc", &
I);
3326 Type *SrcTy =
I.getOperand(0)->getType();
3327 Type *DestTy =
I.getType();
3336 "fpext source and destination must both be a vector or neither", &
I);
3337 Check(SrcBitSize < DestBitSize,
"DestTy too small for FPExt", &
I);
3344 Type *SrcTy =
I.getOperand(0)->getType();
3345 Type *DestTy =
I.getType();
3350 Check(SrcVec == DstVec,
3351 "UIToFP source and dest must both be vector or scalar", &
I);
3353 "UIToFP source must be integer or integer vector", &
I);
3357 if (SrcVec && DstVec)
3358 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3359 cast<VectorType>(DestTy)->getElementCount(),
3360 "UIToFP source and dest vector length mismatch", &
I);
3367 Type *SrcTy =
I.getOperand(0)->getType();
3368 Type *DestTy =
I.getType();
3373 Check(SrcVec == DstVec,
3374 "SIToFP source and dest must both be vector or scalar", &
I);
3376 "SIToFP source must be integer or integer vector", &
I);
3380 if (SrcVec && DstVec)
3381 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3382 cast<VectorType>(DestTy)->getElementCount(),
3383 "SIToFP source and dest vector length mismatch", &
I);
3390 Type *SrcTy =
I.getOperand(0)->getType();
3391 Type *DestTy =
I.getType();
3396 Check(SrcVec == DstVec,
3397 "FPToUI source and dest must both be vector or scalar", &
I);
3400 "FPToUI result must be integer or integer vector", &
I);
3402 if (SrcVec && DstVec)
3403 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3404 cast<VectorType>(DestTy)->getElementCount(),
3405 "FPToUI source and dest vector length mismatch", &
I);
3412 Type *SrcTy =
I.getOperand(0)->getType();
3413 Type *DestTy =
I.getType();
3418 Check(SrcVec == DstVec,
3419 "FPToSI source and dest must both be vector or scalar", &
I);
3422 "FPToSI result must be integer or integer vector", &
I);
3424 if (SrcVec && DstVec)
3425 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3426 cast<VectorType>(DestTy)->getElementCount(),
3427 "FPToSI source and dest vector length mismatch", &
I);
3434 Type *SrcTy =
I.getOperand(0)->getType();
3435 Type *DestTy =
I.getType();
3444 auto *VSrc = cast<VectorType>(SrcTy);
3445 auto *VDest = cast<VectorType>(DestTy);
3446 Check(VSrc->getElementCount() == VDest->getElementCount(),
3447 "PtrToInt Vector width mismatch", &
I);
3455 Type *SrcTy =
I.getOperand(0)->getType();
3456 Type *DestTy =
I.getType();
3464 auto *VSrc = cast<VectorType>(SrcTy);
3465 auto *VDest = cast<VectorType>(DestTy);
3466 Check(VSrc->getElementCount() == VDest->getElementCount(),
3467 "IntToPtr Vector width mismatch", &
I);
3475 "Invalid bitcast", &
I);
3480 Type *SrcTy =
I.getOperand(0)->getType();
3481 Type *DestTy =
I.getType();
3488 "AddrSpaceCast must be between different address spaces", &
I);
3489 if (
auto *SrcVTy = dyn_cast<VectorType>(SrcTy))
3490 Check(SrcVTy->getElementCount() ==
3491 cast<VectorType>(DestTy)->getElementCount(),
3492 "AddrSpaceCast vector pointer number of elements mismatch", &
I);
3498void Verifier::visitPHINode(
PHINode &PN) {
3505 "PHI nodes not grouped at top of basic block!", &PN, PN.
getParent());
3514 "PHI node operands are not the same type as the result!", &PN);
3522void Verifier::visitCallBase(
CallBase &Call) {
3523 Check(
Call.getCalledOperand()->getType()->isPointerTy(),
3524 "Called function must be a pointer!", Call);
3528 if (FTy->isVarArg())
3529 Check(
Call.arg_size() >= FTy->getNumParams(),
3530 "Called function requires more parameters than were provided!", Call);
3532 Check(
Call.arg_size() == FTy->getNumParams(),
3533 "Incorrect number of arguments passed to called function!", Call);
3536 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
3537 Check(
Call.getArgOperand(i)->getType() == FTy->getParamType(i),
3538 "Call parameter type does not match function signature!",
3539 Call.getArgOperand(i), FTy->getParamType(i), Call);
3543 Check(verifyAttributeCount(Attrs,
Call.arg_size()),
3544 "Attribute after last parameter!", Call);
3547 dyn_cast<Function>(
Call.getCalledOperand()->stripPointerCasts());
3551 "Intrinsic called with incompatible signature", Call);
3555 auto CC =
Call.getCallingConv();
3558 "Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions "
3559 "not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.",
3566 auto VerifyTypeAlign = [&](
Type *Ty,
const Twine &Message) {
3569 Align ABIAlign =
DL.getABITypeAlign(Ty);
3571 "Incorrect alignment of " + Message +
" to called function!", Call);
3575 VerifyTypeAlign(FTy->getReturnType(),
"return type");
3576 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3577 Type *Ty = FTy->getParamType(i);
3578 VerifyTypeAlign(Ty,
"argument passed");
3582 if (
Attrs.hasFnAttr(Attribute::Speculatable)) {
3586 "speculatable attribute may not apply to call sites", Call);
3589 if (
Attrs.hasFnAttr(Attribute::Preallocated)) {
3590 Check(
Call.getCalledFunction()->getIntrinsicID() ==
3591 Intrinsic::call_preallocated_arg,
3592 "preallocated as a call site attribute can only be on "
3593 "llvm.call.preallocated.arg");
3597 verifyFunctionAttrs(FTy, Attrs, &Call, IsIntrinsic,
Call.isInlineAsm());
3602 if (
Call.hasInAllocaArgument()) {
3603 Value *InAllocaArg =
Call.getArgOperand(FTy->getNumParams() - 1);
3605 Check(AI->isUsedWithInAlloca(),
3606 "inalloca argument for call has mismatched alloca", AI, Call);
3612 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3613 if (
Call.paramHasAttr(i, Attribute::SwiftError)) {
3614 Value *SwiftErrorArg =
Call.getArgOperand(i);
3616 Check(AI->isSwiftError(),
3617 "swifterror argument for call has mismatched alloca", AI, Call);
3620 auto ArgI = dyn_cast<Argument>(SwiftErrorArg);
3621 Check(ArgI,
"swifterror argument should come from an alloca or parameter",
3622 SwiftErrorArg, Call);
3623 Check(ArgI->hasSwiftErrorAttr(),
3624 "swifterror argument for call has mismatched parameter", ArgI,
3628 if (
Attrs.hasParamAttr(i, Attribute::ImmArg)) {
3631 Check(Callee &&
Callee->hasParamAttribute(i, Attribute::ImmArg),
3632 "immarg may not apply only to call sites",
Call.getArgOperand(i),
3636 if (
Call.paramHasAttr(i, Attribute::ImmArg)) {
3638 Check(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
3639 "immarg operand has non-immediate parameter", ArgVal, Call);
3642 if (
Call.paramHasAttr(i, Attribute::Preallocated)) {
3646 bool isMustTail =
Call.isMustTailCall();
3647 Check(hasOB != isMustTail,
3648 "preallocated operand either requires a preallocated bundle or "
3649 "the call to be musttail (but not both)",
3654 if (FTy->isVarArg()) {
3656 bool SawNest =
false;
3657 bool SawReturned =
false;
3659 for (
unsigned Idx = 0;
Idx < FTy->getNumParams(); ++
Idx) {
3660 if (
Attrs.hasParamAttr(
Idx, Attribute::Nest))
3662 if (
Attrs.hasParamAttr(
Idx, Attribute::Returned))
3667 for (
unsigned Idx = FTy->getNumParams();
Idx <
Call.arg_size(); ++
Idx) {
3670 verifyParameterAttrs(ArgAttrs, Ty, &Call);
3673 Check(!SawNest,
"More than one parameter has attribute nest!", Call);
3678 Check(!SawReturned,
"More than one parameter has attribute returned!",
3681 "Incompatible argument and return types for 'returned' "
3689 if (!
Call.getCalledFunction() ||
3690 Call.getCalledFunction()->getIntrinsicID() !=
3691 Intrinsic::experimental_gc_statepoint)
3693 "Attribute 'sret' cannot be used for vararg call arguments!",
3698 "inalloca isn't on the last argument!", Call);
3704 for (
Type *ParamTy : FTy->params()) {
3705 Check(!ParamTy->isMetadataTy(),
3706 "Function has metadata parameter but isn't an intrinsic", Call);
3707 Check(!ParamTy->isTokenTy(),
3708 "Function has token parameter but isn't an intrinsic", Call);
3713 if (!
Call.getCalledFunction()) {
3714 Check(!FTy->getReturnType()->isTokenTy(),
3715 "Return type cannot be token for indirect call!");
3716 Check(!FTy->getReturnType()->isX86_AMXTy(),
3717 "Return type cannot be x86_amx for indirect call!");
3722 visitIntrinsicCall(
ID, Call);
3727 bool FoundDeoptBundle =
false, FoundFuncletBundle =
false,
3728 FoundGCTransitionBundle =
false, FoundCFGuardTargetBundle =
false,
3729 FoundPreallocatedBundle =
false, FoundGCLiveBundle =
false,
3730 FoundPtrauthBundle =
false, FoundKCFIBundle =
false,
3731 FoundAttachedCallBundle =
false;
3732 for (
unsigned i = 0, e =
Call.getNumOperandBundles(); i < e; ++i) {
3736 Check(!FoundDeoptBundle,
"Multiple deopt operand bundles", Call);
3737 FoundDeoptBundle =
true;
3739 Check(!FoundGCTransitionBundle,
"Multiple gc-transition operand bundles",
3741 FoundGCTransitionBundle =
true;
3743 Check(!FoundFuncletBundle,
"Multiple funclet operand bundles", Call);
3744 FoundFuncletBundle =
true;
3746 "Expected exactly one funclet bundle operand", Call);
3748 "Funclet bundle operands should correspond to a FuncletPadInst",
3751 Check(!FoundCFGuardTargetBundle,
"Multiple CFGuardTarget operand bundles",
3753 FoundCFGuardTargetBundle =
true;
3755 "Expected exactly one cfguardtarget bundle operand", Call);
3757 Check(!FoundPtrauthBundle,
"Multiple ptrauth operand bundles", Call);
3758 FoundPtrauthBundle =
true;
3760 "Expected exactly two ptrauth bundle operands", Call);
3762 BU.
Inputs[0]->getType()->isIntegerTy(32),
3763 "Ptrauth bundle key operand must be an i32 constant", Call);
3765 "Ptrauth bundle discriminator operand must be an i64", Call);
3767 Check(!FoundKCFIBundle,
"Multiple kcfi operand bundles", Call);
3768 FoundKCFIBundle =
true;
3769 Check(BU.
Inputs.size() == 1,
"Expected exactly one kcfi bundle operand",
3772 BU.
Inputs[0]->getType()->isIntegerTy(32),
3773 "Kcfi bundle operand must be an i32 constant", Call);
3775 Check(!FoundPreallocatedBundle,
"Multiple preallocated operand bundles",
3777 FoundPreallocatedBundle =
true;
3779 "Expected exactly one preallocated bundle operand", Call);
3780 auto Input = dyn_cast<IntrinsicInst>(BU.
Inputs.front());
3782 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,
3783 "\"preallocated\" argument must be a token from "
3784 "llvm.call.preallocated.setup",
3787 Check(!FoundGCLiveBundle,
"Multiple gc-live operand bundles", Call);
3788 FoundGCLiveBundle =
true;
3790 Check(!FoundAttachedCallBundle,
3791 "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
3792 FoundAttachedCallBundle =
true;
3793 verifyAttachedCallBundle(Call, BU);
3798 Check(!(
Call.getCalledFunction() && FoundPtrauthBundle),
3799 "Direct call cannot have a ptrauth bundle", Call);
3806 if (
Call.getFunction()->getSubprogram() &&
Call.getCalledFunction() &&
3807 !
Call.getCalledFunction()->isInterposable() &&
3808 !
Call.getCalledFunction()->isDeclaration() &&
3809 Call.getCalledFunction()->getSubprogram())
3811 "inlinable function call in a function with "
3812 "debug info must have a !dbg location",
3815 if (
Call.isInlineAsm())
3816 verifyInlineAsmCall(Call);
3818 ConvergenceVerifyHelper.
visit(Call);
3823void Verifier::verifyTailCCMustTailAttrs(
const AttrBuilder &Attrs,
3826 Twine(
"inalloca attribute not allowed in ") + Context);
3828 Twine(
"inreg attribute not allowed in ") + Context);
3829 Check(!
Attrs.contains(Attribute::SwiftError),
3830 Twine(
"swifterror attribute not allowed in ") + Context);
3831 Check(!
Attrs.contains(Attribute::Preallocated),
3832 Twine(
"preallocated attribute not allowed in ") + Context);
3834 Twine(
"byref attribute not allowed in ") + Context);
3846 return PL->getAddressSpace() == PR->getAddressSpace();
3851 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
3852 Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf,
3853 Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated,
3856 for (
auto AK : ABIAttrs) {
3857 Attribute Attr = Attrs.getParamAttrs(
I).getAttribute(AK);
3859 Copy.addAttribute(Attr);
3863 if (Attrs.hasParamAttr(
I, Attribute::Alignment) &&
3864 (Attrs.hasParamAttr(
I, Attribute::ByVal) ||
3865 Attrs.hasParamAttr(
I, Attribute::ByRef)))
3866 Copy.addAlignmentAttr(Attrs.getParamAlignment(
I));
3870void Verifier::verifyMustTailCall(
CallInst &CI) {
3876 Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
3877 "cannot guarantee tail call due to mismatched varargs", &CI);
3879 "cannot guarantee tail call due to mismatched return types", &CI);
3883 "cannot guarantee tail call due to mismatched calling conv", &CI);
3889 Value *RetVal = &CI;
3893 if (
BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
3895 "bitcast following musttail call must use the call", BI);
3902 Check(Ret,
"musttail call must precede a ret with an optional bitcast", &CI);
3903 Check(!
Ret->getReturnValue() ||
Ret->getReturnValue() == RetVal ||
3904 isa<UndefValue>(
Ret->getReturnValue()),
3905 "musttail call result must be returned", Ret);
3916 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3919 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3921 for (
unsigned I = 0, E = CalleeTy->getNumParams();
I != E; ++
I) {
3924 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3927 Check(!CallerTy->isVarArg(),
Twine(
"cannot guarantee ") + CCName +
3928 " tail call for varargs function");
3936 Check(CallerTy->getNumParams() == CalleeTy->getNumParams(),
3937 "cannot guarantee tail call due to mismatched parameter counts", &CI);
3938 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3941 "cannot guarantee tail call due to mismatched parameter types", &CI);
3947 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3950 Check(CallerABIAttrs == CalleeABIAttrs,
3951 "cannot guarantee tail call due to mismatched ABI impacting "
3952 "function attributes",
3957void Verifier::visitCallInst(
CallInst &CI) {
3961 verifyMustTailCall(CI);
3970 II.getUnwindDest()->isEHPad(),
3971 "The unwind destination does not have an exception handling instruction!",
3980 Check(
U.getType() ==
U.getOperand(0)->getType(),
3981 "Unary operators must have same type for"
3982 "operands and result!",
3985 switch (
U.getOpcode()) {
3988 case Instruction::FNeg:
3989 Check(
U.getType()->isFPOrFPVectorTy(),
3990 "FNeg operator only works with float types!", &U);
4003 Check(
B.getOperand(0)->getType() ==
B.getOperand(1)->getType(),
4004 "Both operands to a binary operator are not of the same type!", &
B);
4006 switch (
B.getOpcode()) {
4009 case Instruction::Add:
4010 case Instruction::Sub:
4011 case Instruction::Mul:
4012 case Instruction::SDiv:
4013 case Instruction::UDiv:
4014 case Instruction::SRem:
4015 case Instruction::URem:
4016 Check(
B.getType()->isIntOrIntVectorTy(),
4017 "Integer arithmetic operators only work with integral types!", &
B);
4018 Check(
B.getType() ==
B.getOperand(0)->getType(),
4019 "Integer arithmetic operators must have same type "
4020 "for operands and result!",
4025 case Instruction::FAdd:
4026 case Instruction::FSub:
4027 case Instruction::FMul:
4028 case Instruction::FDiv:
4029 case Instruction::FRem:
4030 Check(
B.getType()->isFPOrFPVectorTy(),
4031 "Floating-point arithmetic operators only work with "
4032 "floating-point types!",
4034 Check(
B.getType() ==
B.getOperand(0)->getType(),
4035 "Floating-point arithmetic operators must have same type "
4036 "for operands and result!",
4040 case Instruction::And:
4041 case Instruction::Or:
4042 case Instruction::Xor:
4043 Check(
B.getType()->isIntOrIntVectorTy(),
4044 "Logical operators only work with integral types!", &
B);
4045 Check(
B.getType() ==
B.getOperand(0)->getType(),
4046 "Logical operators must have same type for operands and result!", &
B);
4048 case Instruction::Shl:
4049 case Instruction::LShr:
4050 case Instruction::AShr:
4051 Check(
B.getType()->isIntOrIntVectorTy(),
4052 "Shifts only work with integral types!", &
B);
4053 Check(
B.getType() ==
B.getOperand(0)->getType(),
4054 "Shift return type must be same as operands!", &
B);
4063void Verifier::visitICmpInst(
ICmpInst &IC) {
4067 Check(Op0Ty == Op1Ty,
4068 "Both operands to ICmp instruction are not of the same type!", &IC);
4071 "Invalid operand types for ICmp instruction", &IC);
4078void Verifier::visitFCmpInst(
FCmpInst &FC) {
4080 Type *Op0Ty =
FC.getOperand(0)->getType();
4081 Type *Op1Ty =
FC.getOperand(1)->getType();
4082 Check(Op0Ty == Op1Ty,
4083 "Both operands to FCmp instruction are not of the same type!", &FC);
4088 Check(
FC.isFPPredicate(),
"Invalid predicate in FCmp instruction!", &FC);
4095 "Invalid extractelement operands!", &EI);
4102 "Invalid insertelement operands!", &IE);
4109 "Invalid shufflevector operands!", &SV);
4114 Type *TargetTy =
GEP.getPointerOperandType()->getScalarType();
4116 Check(isa<PointerType>(TargetTy),
4117 "GEP base pointer is not a vector or a vector of pointers", &
GEP);
4118 Check(
GEP.getSourceElementType()->isSized(),
"GEP into unsized type!", &
GEP);
4120 if (
auto *STy = dyn_cast<StructType>(
GEP.getSourceElementType())) {
4122 "getelementptr cannot target structure that contains scalable vector"
4129 all_of(Idxs, [](
Value *V) {
return V->getType()->isIntOrIntVectorTy(); }),
4130 "GEP indexes must be integers", &
GEP);
4133 Check(ElTy,
"Invalid indices for GEP pointer type!", &
GEP);
4135 PointerType *PtrTy = dyn_cast<PointerType>(
GEP.getType()->getScalarType());
4137 Check(PtrTy &&
GEP.getResultElementType() == ElTy,
4138 "GEP is not of right type for indices!", &
GEP, ElTy);
4140 if (
auto *GEPVTy = dyn_cast<VectorType>(
GEP.getType())) {
4143 if (
GEP.getPointerOperandType()->isVectorTy())
4146 cast<VectorType>(
GEP.getPointerOperandType())->getElementCount(),
4147 "Vector GEP result width doesn't match operand's", &
GEP);
4149 Type *IndexTy =
Idx->getType();
4150 if (
auto *IndexVTy = dyn_cast<VectorType>(IndexTy)) {
4152 Check(IndexWidth == GEPWidth,
"Invalid GEP index vector width", &
GEP);
4155 "All GEP indices should be of integer type");
4159 Check(
GEP.getAddressSpace() == PtrTy->getAddressSpace(),
4160 "GEP address space doesn't match type", &
GEP);
4166 return A.getUpper() ==
B.getLower() ||
A.getLower() ==
B.getUpper();
4172 Type *Ty, RangeLikeMetadataKind Kind) {
4173 unsigned NumOperands =
Range->getNumOperands();
4174 Check(NumOperands % 2 == 0,
"Unfinished range!",
Range);
4175 unsigned NumRanges = NumOperands / 2;
4176 Check(NumRanges >= 1,
"It should have at least one range!",
Range);
4179 for (
unsigned i = 0; i < NumRanges; ++i) {
4181 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(2 * i));
4182 Check(
Low,
"The lower limit must be an integer!",
Low);
4184 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(2 * i + 1));
4187 Check(
High->getType() ==
Low->getType(),
"Range pair types must match!",
4190 if (Kind == RangeLikeMetadataKind::NoaliasAddrspace) {
4192 "noalias.addrspace type must be i32!", &
I);
4195 "Range types must match instruction type!", &
I);
4204 "The upper and lower limits cannot be the same value", &
I);
4207 Check(!CurRange.isEmptySet() &&
4208 (Kind == RangeLikeMetadataKind::AbsoluteSymbol ||
4209 !CurRange.isFullSet()),
4210 "Range must not be empty!",
Range);
4212 Check(CurRange.intersectWith(LastRange).isEmptySet(),
4213 "Intervals are overlapping",
Range);
4214 Check(LowV.
sgt(LastRange.getLower()),
"Intervals are not in order",
4221 if (NumRanges > 2) {
4223 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(0))->getValue();
4225 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(1))->getValue();
4227 Check(FirstRange.intersectWith(LastRange).isEmptySet(),
4228 "Intervals are overlapping",
Range);
4236 "precondition violation");
4237 verifyRangeLikeMetadata(
I,
Range, Ty, RangeLikeMetadataKind::Range);
4243 "precondition violation");
4244 verifyRangeLikeMetadata(
I,
Range, Ty,
4245 RangeLikeMetadataKind::NoaliasAddrspace);
4249 unsigned Size =
DL.getTypeSizeInBits(Ty);
4250 Check(
Size >= 8,
"atomic memory access' size must be byte-sized", Ty,
I);
4252 "atomic memory access' operand must have a power-of-two size", Ty,
I);
4255void Verifier::visitLoadInst(
LoadInst &LI) {
4257 Check(PTy,
"Load operand must be a pointer.", &LI);
4261 "huge alignment values are unsupported", &LI);
4263 Check(ElTy->
isSized(),
"loading unsized types is not allowed", &LI);
4267 "Load cannot have Release ordering", &LI);
4269 "atomic load operand must have integer, pointer, or floating point "
4272 checkAtomicMemAccessSize(ElTy, &LI);
4275 "Non-atomic load cannot have SynchronizationScope specified", &LI);
4281void Verifier::visitStoreInst(
StoreInst &SI) {
4282 PointerType *PTy = dyn_cast<PointerType>(
SI.getOperand(1)->getType());
4283 Check(PTy,
"Store operand must be a pointer.", &SI);
4284 Type *ElTy =
SI.getOperand(0)->getType();
4287 "huge alignment values are unsupported", &SI);
4289 Check(ElTy->
isSized(),
"storing unsized types is not allowed", &SI);
4290 if (
SI.isAtomic()) {
4293 "Store cannot have Acquire ordering", &SI);
4295 "atomic store operand must have integer, pointer, or floating point "
4298 checkAtomicMemAccessSize(ElTy, &SI);
4301 "Non-atomic store cannot have SynchronizationScope specified", &SI);
4307void Verifier::verifySwiftErrorCall(
CallBase &Call,
4308 const Value *SwiftErrorVal) {
4310 if (
I.value() == SwiftErrorVal) {
4311 Check(
Call.paramHasAttr(
I.index(), Attribute::SwiftError),
4312 "swifterror value when used in a callsite should be marked "
4313 "with swifterror attribute",
4314 SwiftErrorVal, Call);
4319void Verifier::verifySwiftErrorValue(
const Value *SwiftErrorVal) {
4322 for (
const User *U : SwiftErrorVal->
users()) {
4323 Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
4325 "swifterror value can only be loaded and stored from, or "
4326 "as a swifterror argument!",
4329 if (
auto StoreI = dyn_cast<StoreInst>(U))
4330 Check(StoreI->getOperand(1) == SwiftErrorVal,
4331 "swifterror value should be the second operand when used "
4334 if (
auto *Call = dyn_cast<CallBase>(U))
4335 verifySwiftErrorCall(*
const_cast<CallBase *
>(Call), SwiftErrorVal);
4339void Verifier::visitAllocaInst(
AllocaInst &AI) {
4342 Check(Ty->
isSized(&Visited),
"Cannot allocate unsized type", &AI);
4346 "Alloca has illegal target extension type", &AI);
4348 "Alloca array size must have integer type", &AI);
4351 "huge alignment values are unsupported", &AI);
4357 "swifterror alloca must not be array allocation", &AI);
4358 verifySwiftErrorValue(&AI);
4367 "cmpxchg operand must have integer or pointer type", ElTy, &CXI);
4368 checkAtomicMemAccessSize(ElTy, &CXI);
4374 "atomicrmw instructions cannot be unordered.", &RMWI);
4381 " operand must have integer or floating point type!",
4386 " operand must have floating-point or fixed vector of floating-point "
4392 " operand must have integer type!",
4395 checkAtomicMemAccessSize(ElTy, &RMWI);
4397 "Invalid binary operation!", &RMWI);
4401void Verifier::visitFenceInst(
FenceInst &FI) {
4407 "fence instructions may only have acquire, release, acq_rel, or "
4408 "seq_cst ordering.",
4416 "Invalid ExtractValueInst operands!", &EVI);
4425 "Invalid InsertValueInst operands!", &IVI);
4431 if (
auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
4432 return FPI->getParentPad();
4434 return cast<CatchSwitchInst>(EHPad)->getParentPad();
4443 Check(BB != &
F->getEntryBlock(),
"EH pad cannot be in entry block.", &
I);
4445 if (
auto *LPI = dyn_cast<LandingPadInst>(&
I)) {
4450 const auto *
II = dyn_cast<InvokeInst>(PredBB->getTerminator());
4451 Check(
II &&
II->getUnwindDest() == BB &&
II->getNormalDest() != BB,
4452 "Block containing LandingPadInst must be jumped to "
4453 "only by the unwind edge of an invoke.",
4458 if (
auto *CPI = dyn_cast<CatchPadInst>(&
I)) {
4461 "Block containg CatchPadInst must be jumped to "
4462 "only by its catchswitch.",
4464 Check(BB != CPI->getCatchSwitch()->getUnwindDest(),
4465 "Catchswitch cannot unwind to one of its catchpads",
4466 CPI->getCatchSwitch(), CPI);
4477 if (
auto *
II = dyn_cast<InvokeInst>(TI)) {
4478 Check(
II->getUnwindDest() == BB &&
II->getNormalDest() != BB,
4479 "EH pad must be jumped to via an unwind edge", ToPad,
II);
4481 dyn_cast<Function>(
II->getCalledOperand()->stripPointerCasts());
4482 if (CalledFn && CalledFn->isIntrinsic() &&
II->doesNotThrow() &&
4486 FromPad = Bundle->Inputs[0];
4489 }
else if (
auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
4490 FromPad = CRI->getOperand(0);
4491 Check(FromPad != ToPadParent,
"A cleanupret must exit its cleanup", CRI);
4492 }
else if (
auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
4495 Check(
false,
"EH pad must be jumped to via an unwind edge", ToPad, TI);
4501 Check(FromPad != ToPad,
4502 "EH pad cannot handle exceptions raised within it", FromPad, TI);
4503 if (FromPad == ToPadParent) {
4507 Check(!isa<ConstantTokenNone>(FromPad),
4508 "A single unwind edge may only enter one EH pad", TI);
4509 Check(Seen.
insert(FromPad).second,
"EH pad jumps through a cycle of pads",
4514 Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
4515 "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
4524 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
4526 visitEHPadPredecessors(LPI);
4528 if (!LandingPadResultTy)
4529 LandingPadResultTy = LPI.
getType();
4532 "The landingpad instruction should have a consistent result type "
4533 "inside a function.",
4537 Check(
F->hasPersonalityFn(),
4538 "LandingPadInst needs to be in a function with a personality.", &LPI);
4543 "LandingPadInst not the first non-PHI instruction in the block.", &LPI);
4549 "Catch operand does not have pointer type!", &LPI);
4551 Check(LPI.
isFilter(i),
"Clause is neither catch nor filter!", &LPI);
4553 "Filter operand is not an array of constants!", &LPI);
4560void Verifier::visitResumeInst(
ResumeInst &RI) {
4562 "ResumeInst needs to be in a function with a personality.", &RI);
4564 if (!LandingPadResultTy)
4568 "The resume instruction should have a consistent result type "
4569 "inside a function.",
4579 Check(
F->hasPersonalityFn(),
4580 "CatchPadInst needs to be in a function with a personality.", &CPI);
4583 "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
4589 "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
4591 visitEHPadPredecessors(CPI);
4597 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
4607 Check(
F->hasPersonalityFn(),
4608 "CleanupPadInst needs to be in a function with a personality.", &CPI);
4613 "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
4616 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
4617 "CleanupPadInst has an invalid parent.", &CPI);
4619 visitEHPadPredecessors(CPI);
4624 User *FirstUser =
nullptr;
4625 Value *FirstUnwindPad =
nullptr;
4629 while (!Worklist.empty()) {
4632 "FuncletPadInst must not be nested within itself", CurrentPad);
4633 Value *UnresolvedAncestorPad =
nullptr;
4636 if (
auto *CRI = dyn_cast<CleanupReturnInst>(U)) {
4637 UnwindDest = CRI->getUnwindDest();
4638 }
else if (
auto *CSI = dyn_cast<CatchSwitchInst>(U)) {
4643 if (CSI->unwindsToCaller())
4645 UnwindDest = CSI->getUnwindDest();
4646 }
else if (
auto *
II = dyn_cast<InvokeInst>(U)) {
4647 UnwindDest =
II->getUnwindDest();
4648 }
else if (isa<CallInst>(U)) {
4653 }
else if (
auto *CPI = dyn_cast<CleanupPadInst>(U)) {
4657 Worklist.push_back(CPI);
4660 Check(isa<CatchReturnInst>(U),
"Bogus funclet pad use", U);
4668 if (!cast<Instruction>(UnwindPad)->isEHPad())
4672 if (UnwindParent == CurrentPad)
4678 Value *ExitedPad = CurrentPad;
4681 if (ExitedPad == &FPI) {
4686 UnresolvedAncestorPad = &FPI;
4690 if (ExitedParent == UnwindParent) {
4694 UnresolvedAncestorPad = ExitedParent;
4697 ExitedPad = ExitedParent;
4698 }
while (!isa<ConstantTokenNone>(ExitedPad));
4703 UnresolvedAncestorPad = &FPI;
4710 Check(UnwindPad == FirstUnwindPad,
4711 "Unwind edges out of a funclet "
4712 "pad must have the same unwind "
4714 &FPI, U, FirstUser);
4717 FirstUnwindPad = UnwindPad;
4719 if (isa<CleanupPadInst>(&FPI) && !isa<ConstantTokenNone>(UnwindPad) &&
4721 SiblingFuncletInfo[&FPI] = cast<Instruction>(U);
4726 if (CurrentPad != &FPI)
4729 if (UnresolvedAncestorPad) {
4730 if (CurrentPad == UnresolvedAncestorPad) {
4734 assert(CurrentPad == &FPI);
4742 Value *ResolvedPad = CurrentPad;
4743 while (!Worklist.empty()) {
4744 Value *UnclePad = Worklist.back();
4748 while (ResolvedPad != AncestorPad) {
4750 if (ResolvedParent == UnresolvedAncestorPad) {
4753 ResolvedPad = ResolvedParent;
4757 if (ResolvedPad != AncestorPad)
4760 Worklist.pop_back();
4765 if (FirstUnwindPad) {
4766 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FPI.
getParentPad())) {
4767 BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
4768 Value *SwitchUnwindPad;
4769 if (SwitchUnwindDest)
4773 Check(SwitchUnwindPad == FirstUnwindPad,
4774 "Unwind edges out of a catch must have the same unwind dest as "
4775 "the parent catchswitch",
4776 &FPI, FirstUser, CatchSwitch);
4787 Check(
F->hasPersonalityFn(),
4788 "CatchSwitchInst needs to be in a function with a personality.",
4794 "CatchSwitchInst not the first non-PHI instruction in the block.",
4798 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
4799 "CatchSwitchInst has an invalid parent.", ParentPad);
4803 Check(
I->isEHPad() && !isa<LandingPadInst>(
I),
4804 "CatchSwitchInst must unwind to an EH block which is not a "
4810 SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
4814 "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
4817 Check(isa<CatchPadInst>(Handler->getFirstNonPHI()),
4818 "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
4821 visitEHPadPredecessors(CatchSwitch);
4827 "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
4832 Check(
I->isEHPad() && !isa<LandingPadInst>(
I),
4833 "CleanupReturnInst must unwind to an EH block which is not a "
4841void Verifier::verifyDominatesUse(
Instruction &
I,
unsigned i) {
4847 if (
II->getNormalDest() ==
II->getUnwindDest())
4858 if (!isa<PHINode>(
I) && InstsInThisBlock.
count(
Op))
4861 const Use &
U =
I.getOperandUse(i);
4866 Check(
I.getType()->isPointerTy(),
4867 "dereferenceable, dereferenceable_or_null "
4868 "apply only to pointer types",
4870 Check((isa<LoadInst>(
I) || isa<IntToPtrInst>(
I)),
4871 "dereferenceable, dereferenceable_or_null apply only to load"
4872 " and inttoptr instructions, use attributes for calls or invokes",
4875 "dereferenceable, dereferenceable_or_null "
4876 "take one operand!",
4881 "dereferenceable_or_null metadata value must be an i64!",
4887 "!prof annotations should have no less than 2 operands", MD);
4890 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null", MD);
4892 "expected string with name of the !prof annotation", MD);
4897 if (ProfName ==
"branch_weights") {
4899 if (isa<InvokeInst>(&
I)) {
4900 Check(NumBranchWeights == 1 || NumBranchWeights == 2,
4901 "Wrong number of InvokeInst branch_weights operands", MD);
4903 unsigned ExpectedNumOperands = 0;
4906 else if (
SwitchInst *SI = dyn_cast<SwitchInst>(&
I))
4907 ExpectedNumOperands =
SI->getNumSuccessors();
4908 else if (isa<CallInst>(&
I))
4909 ExpectedNumOperands = 1;
4911 ExpectedNumOperands = IBI->getNumDestinations();
4912 else if (isa<SelectInst>(&
I))
4913 ExpectedNumOperands = 2;
4914 else if (
CallBrInst *CI = dyn_cast<CallBrInst>(&
I))
4917 CheckFailed(
"!prof branch_weights are not allowed for this instruction",
4920 Check(NumBranchWeights == ExpectedNumOperands,
"Wrong number of operands",
4926 Check(MDO,
"second operand should not be null", MD);
4927 Check(mdconst::dyn_extract<ConstantInt>(MDO),
4928 "!prof brunch_weights operand is not a const int");
4934 assert(
I.hasMetadata(LLVMContext::MD_DIAssignID));
4935 bool ExpectedInstTy =
4936 isa<AllocaInst>(
I) || isa<StoreInst>(
I) || isa<MemIntrinsic>(
I);
4937 CheckDI(ExpectedInstTy,
"!DIAssignID attached to unexpected instruction kind",
4944 "!DIAssignID should only be used by llvm.dbg.assign intrinsics",
4947 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(
User))
4948 CheckDI(DAI->getFunction() ==
I.getFunction(),
4949 "dbg.assign not in same function as inst", DAI, &
I);
4953 cast<DIAssignID>(MD)->getAllDbgVariableRecordUsers()) {
4955 "!DIAssignID should only be used by Assign DVRs.", MD, DVR);
4956 CheckDI(DVR->getFunction() ==
I.getFunction(),
4957 "DVRAssign not in same function as inst", DVR, &
I);
4963 "!mmra metadata attached to unexpected instruction kind",
I, MD);
4973 Check(isa<MDTuple>(MD),
"!mmra expected to be a metadata tuple",
I, MD);
4976 "!mmra metadata tuple operand is not an MMRA tag",
I, MDOp.get());
4979void Verifier::visitCallStackMetadata(
MDNode *MD) {
4983 "call stack metadata should have at least 1 operand", MD);
4986 Check(mdconst::dyn_extract_or_null<ConstantInt>(
Op),
4987 "call stack metadata operand should be constant integer",
Op);
4991 Check(isa<CallBase>(
I),
"!memprof metadata should only exist on calls", &
I);
4993 "!memprof annotations should have at least 1 metadata operand "
4998 for (
auto &MIBOp : MD->
operands()) {
4999 MDNode *MIB = dyn_cast<MDNode>(MIBOp);
5004 "Each !memprof MemInfoBlock should have at least 2 operands", MIB);
5008 "!memprof MemInfoBlock first operand should not be null", MIB);
5010 "!memprof MemInfoBlock first operand should be an MDNode", MIB);
5012 visitCallStackMetadata(StackMD);
5019 "!memprof MemInfoBlock second operand should be an MDString",
5028 Check(OpNode,
"Not all !memprof MemInfoBlock operands 2 to N are MDNode",
5031 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with 2 "
5037 return mdconst::hasa<ConstantInt>(Op);
5039 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with "
5040 "ConstantInt operands",
5047 Check(isa<CallBase>(
I),
"!callsite metadata should only exist on calls", &
I);
5050 visitCallStackMetadata(MD);
5053void Verifier::visitAnnotationMetadata(
MDNode *Annotation) {
5054 Check(isa<MDTuple>(Annotation),
"annotation must be a tuple");
5056 "annotation must have at least one operand");
5058 bool TupleOfStrings =
5059 isa<MDTuple>(
Op.get()) &&
5060 all_of(cast<MDTuple>(
Op)->operands(), [](
auto &Annotation) {
5063 Check(isa<MDString>(
Op.get()) || TupleOfStrings,
5064 "operands must be a string or a tuple of strings");
5068void Verifier::visitAliasScopeMetadata(
const MDNode *MD) {
5070 Check(NumOps >= 2 && NumOps <= 3,
"scope must have two or three operands",
5073 "first scope operand must be self-referential or string", MD);
5076 "third scope operand must be string (if used)", MD);
5079 Check(
Domain !=
nullptr,
"second scope operand must be MDNode", MD);
5081 unsigned NumDomainOps =
Domain->getNumOperands();
5082 Check(NumDomainOps >= 1 && NumDomainOps <= 2,
5083 "domain must have one or two operands",
Domain);
5085 isa<MDString>(
Domain->getOperand(0)),
5086 "first domain operand must be self-referential or string",
Domain);
5087 if (NumDomainOps == 2)
5089 "second domain operand must be string (if used)",
Domain);
5092void Verifier::visitAliasScopeListMetadata(
const MDNode *MD) {
5094 const MDNode *OpMD = dyn_cast<MDNode>(
Op);
5095 Check(OpMD !=
nullptr,
"scope list must consist of MDNodes", MD);
5096 visitAliasScopeMetadata(OpMD);
5100void Verifier::visitAccessGroupMetadata(
const MDNode *MD) {
5101 auto IsValidAccessScope = [](
const MDNode *MD) {
5106 if (IsValidAccessScope(MD))
5111 const MDNode *OpMD = dyn_cast<MDNode>(
Op);
5112 Check(OpMD !=
nullptr,
"Access scope list must consist of MDNodes", MD);
5113 Check(IsValidAccessScope(OpMD),
5114 "Access scope list contains invalid access scope", MD);
5122 Check(BB,
"Instruction not embedded in basic block!", &
I);
5124 if (!isa<PHINode>(
I)) {
5125 for (
User *U :
I.users()) {
5127 "Only PHI nodes may reference their own value!", &
I);
5132 Check(!
I.getType()->isVoidTy() || !
I.hasName(),
5133 "Instruction has a name, but provides a void value!", &
I);
5137 Check(
I.getType()->isVoidTy() ||
I.getType()->isFirstClassType(),
5138 "Instruction returns a non-scalar type!", &
I);
5142 Check(!
I.getType()->isMetadataTy() || isa<CallInst>(
I) || isa<InvokeInst>(
I),
5143 "Invalid use of metadata!", &
I);
5148 for (
Use &U :
I.uses()) {
5149 if (
Instruction *Used = dyn_cast<Instruction>(
U.getUser()))
5151 "Instruction referencing"
5152 " instruction not embedded in a basic block!",
5155 CheckFailed(
"Use of instruction is not an instruction!", U);
5162 const CallBase *CBI = dyn_cast<CallBase>(&
I);
5164 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i) {
5165 Check(
I.getOperand(i) !=
nullptr,
"Instruction has null operand!", &
I);
5169 if (!
I.getOperand(i)->getType()->isFirstClassType()) {
5170 Check(
false,
"Instruction operands must be first-class values!", &
I);
5173 if (
Function *
F = dyn_cast<Function>(
I.getOperand(i))) {
5178 return CBI && CBI->isOperandBundleOfType(
5186 Check((!
F->isIntrinsic() ||
5187 (CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i)) ||
5188 IsAttachedCallOperand(
F, CBI, i)),
5189 "Cannot take the address of an intrinsic!", &
I);
5190 Check(!
F->isIntrinsic() || isa<CallInst>(
I) ||
5191 F->getIntrinsicID() == Intrinsic::donothing ||
5192 F->getIntrinsicID() == Intrinsic::seh_try_begin ||
5193 F->getIntrinsicID() == Intrinsic::seh_try_end ||
5194 F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
5195 F->getIntrinsicID() == Intrinsic::seh_scope_end ||
5196 F->getIntrinsicID() == Intrinsic::coro_resume ||
5197 F->getIntrinsicID() == Intrinsic::coro_destroy ||
5198 F->getIntrinsicID() == Intrinsic::coro_await_suspend_void ||
5199 F->getIntrinsicID() == Intrinsic::coro_await_suspend_bool ||
5200 F->getIntrinsicID() == Intrinsic::coro_await_suspend_handle ||
5201 F->getIntrinsicID() ==
5202 Intrinsic::experimental_patchpoint_void ||
5203 F->getIntrinsicID() == Intrinsic::experimental_patchpoint ||
5204 F->getIntrinsicID() == Intrinsic::fake_use ||
5205 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
5206 F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
5207 IsAttachedCallOperand(
F, CBI, i),
5208 "Cannot invoke an intrinsic other than donothing, patchpoint, "
5209 "statepoint, coro_resume, coro_destroy or clang.arc.attachedcall",
5211 Check(
F->getParent() == &M,
"Referencing function in another module!", &
I,
5212 &M,
F,
F->getParent());
5213 }
else if (
BasicBlock *OpBB = dyn_cast<BasicBlock>(
I.getOperand(i))) {
5215 "Referring to a basic block in another function!", &
I);
5216 }
else if (
Argument *OpArg = dyn_cast<Argument>(
I.getOperand(i))) {
5218 "Referring to an argument in another function!", &
I);
5219 }
else if (
GlobalValue *GV = dyn_cast<GlobalValue>(
I.getOperand(i))) {
5220 Check(GV->
getParent() == &M,
"Referencing global in another module!", &
I,
5222 }
else if (
Instruction *OpInst = dyn_cast<Instruction>(
I.getOperand(i))) {
5224 "Referring to an instruction in another function!", &
I);
5225 verifyDominatesUse(
I, i);
5226 }
else if (isa<InlineAsm>(
I.getOperand(i))) {
5227 Check(CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i),
5228 "Cannot take the address of an inline asm!", &
I);
5229 }
else if (
auto *CPA = dyn_cast<ConstantPtrAuth>(
I.getOperand(i))) {
5230 visitConstantExprsRecursively(CPA);
5231 }
else if (
ConstantExpr *CE = dyn_cast<ConstantExpr>(
I.getOperand(i))) {
5232 if (
CE->getType()->isPtrOrPtrVectorTy()) {
5235 visitConstantExprsRecursively(CE);
5240 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_fpmath)) {
5241 Check(
I.getType()->isFPOrFPVectorTy(),
5242 "fpmath requires a floating point result!", &
I);
5245 mdconst::dyn_extract_or_null<ConstantFP>(MD->
getOperand(0))) {
5246 const APFloat &Accuracy = CFP0->getValueAPF();
5248 "fpmath accuracy must have float type", &
I);
5250 "fpmath accuracy not a positive number!", &
I);
5252 Check(
false,
"invalid fpmath accuracy!", &
I);
5256 if (
MDNode *
Range =
I.getMetadata(LLVMContext::MD_range)) {
5257 Check(isa<LoadInst>(
I) || isa<CallInst>(
I) || isa<InvokeInst>(
I),
5258 "Ranges are only for loads, calls and invokes!", &
I);
5259 visitRangeMetadata(
I,
Range,
I.getType());
5262 if (
MDNode *
Range =
I.getMetadata(LLVMContext::MD_noalias_addrspace)) {
5263 Check(isa<LoadInst>(
I) || isa<StoreInst>(
I) || isa<AtomicRMWInst>(
I) ||
5264 isa<AtomicCmpXchgInst>(
I) || isa<CallInst>(
I),
5265 "noalias.addrspace are only for memory operations!", &
I);
5266 visitNoaliasAddrspaceMetadata(
I,
Range,
I.getType());
5269 if (
I.hasMetadata(LLVMContext::MD_invariant_group)) {
5270 Check(isa<LoadInst>(
I) || isa<StoreInst>(
I),
5271 "invariant.group metadata is only for loads and stores", &
I);
5274 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_nonnull)) {
5275 Check(
I.getType()->isPointerTy(),
"nonnull applies only to pointer types",
5278 "nonnull applies only to load instructions, use attributes"
5279 " for calls or invokes",
5284 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_dereferenceable))
5285 visitDereferenceableMetadata(
I, MD);
5287 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
5288 visitDereferenceableMetadata(
I, MD);
5290 if (
MDNode *TBAA =
I.getMetadata(LLVMContext::MD_tbaa))
5293 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_noalias))
5294 visitAliasScopeListMetadata(MD);
5295 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_alias_scope))
5296 visitAliasScopeListMetadata(MD);
5298 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_access_group))
5299 visitAccessGroupMetadata(MD);
5301 if (
MDNode *AlignMD =
I.getMetadata(LLVMContext::MD_align)) {
5302 Check(
I.getType()->isPointerTy(),
"align applies only to pointer types",
5305 "align applies only to load instructions, "
5306 "use attributes for calls or invokes",
5308 Check(AlignMD->getNumOperands() == 1,
"align takes one operand!", &
I);
5309 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
5311 "align metadata value must be an i64!", &
I);
5316 "alignment is larger that implementation defined limit", &
I);
5319 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_prof))
5320 visitProfMetadata(
I, MD);
5322 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_memprof))
5323 visitMemProfMetadata(
I, MD);
5325 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_callsite))
5326 visitCallsiteMetadata(
I, MD);
5328 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_DIAssignID))
5329 visitDIAssignIDMetadata(
I, MD);
5331 if (
MDNode *MMRA =
I.getMetadata(LLVMContext::MD_mmra))
5332 visitMMRAMetadata(
I, MMRA);
5334 if (
MDNode *Annotation =
I.getMetadata(LLVMContext::MD_annotation))
5335 visitAnnotationMetadata(Annotation);
5337 if (
MDNode *
N =
I.getDebugLoc().getAsMDNode()) {
5338 CheckDI(isa<DILocation>(
N),
"invalid !dbg metadata attachment", &
I,
N);
5339 visitMDNode(*
N, AreDebugLocsAllowed::Yes);
5342 if (
auto *DII = dyn_cast<DbgVariableIntrinsic>(&
I)) {
5343 verifyFragmentExpression(*DII);
5344 verifyNotEntryValue(*DII);
5348 I.getAllMetadata(MDs);
5349 for (
auto Attachment : MDs) {
5350 unsigned Kind = Attachment.first;
5352 (
Kind == LLVMContext::MD_dbg ||
Kind == LLVMContext::MD_loop)
5353 ? AreDebugLocsAllowed::Yes
5354 : AreDebugLocsAllowed::No;
5355 visitMDNode(*Attachment.second, AllowLocs);
5364 Check(
IF->isDeclaration(),
"Intrinsic functions should never be defined!",
5370 bool IsVarArg = IFTy->isVarArg();
5381 "Intrinsic has incorrect return type!", IF);
5383 "Intrinsic has incorrect argument type!", IF);
5388 "Intrinsic was not defined with variable arguments!", IF);
5391 "Callsite was not defined with variable arguments!", IF);
5400 const std::string ExpectedName =
5402 Check(ExpectedName ==
IF->getName(),
5403 "Intrinsic name not mangled correctly for type arguments! "
5411 if (
auto *MD = dyn_cast<MetadataAsValue>(V))
5412 visitMetadataAsValue(*MD,
Call.getCaller());
5413 if (
auto *Const = dyn_cast<Constant>(V))
5415 "const x86_amx is not allowed in argument!");
5421 case Intrinsic::assume: {
5422 for (
auto &Elem :
Call.bundle_op_infos()) {
5423 unsigned ArgCount = Elem.End - Elem.Begin;
5426 if (Elem.Tag->getKey() ==
"separate_storage") {
5427 Check(ArgCount == 2,
5428 "separate_storage assumptions should have 2 arguments", Call);
5429 Check(
Call.getOperand(Elem.Begin)->getType()->isPointerTy() &&
5430 Call.getOperand(Elem.Begin + 1)->getType()->isPointerTy(),
5431 "arguments to separate_storage assumptions should be pointers",
5435 Check(Elem.Tag->getKey() ==
"ignore" ||
5437 "tags must be valid attribute names", Call);
5440 if (Kind == Attribute::Alignment) {
5441 Check(ArgCount <= 3 && ArgCount >= 2,
5442 "alignment assumptions should have 2 or 3 arguments", Call);
5443 Check(
Call.getOperand(Elem.Begin)->getType()->isPointerTy(),
5444 "first argument should be a pointer", Call);
5445 Check(
Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(),
5446 "second argument should be an integer", Call);
5448 Check(
Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(),
5449 "third argument should be an integer if present", Call);
5452 Check(ArgCount <= 2,
"too many arguments", Call);
5456 Check(ArgCount == 2,
"this attribute should have 2 arguments", Call);
5457 Check(isa<ConstantInt>(
Call.getOperand(Elem.Begin + 1)),
5458 "the second argument should be a constant integral value", Call);
5460 Check((ArgCount) == 1,
"this attribute should have one argument", Call);
5462 Check((ArgCount) == 0,
"this attribute has no argument", Call);
5467 case Intrinsic::ucmp:
5468 case Intrinsic::scmp: {
5469 Type *SrcTy =
Call.getOperand(0)->getType();
5473 "result type must be at least 2 bits wide", Call);
5475 bool IsDestTypeVector = DestTy->
isVectorTy();
5477 "ucmp/scmp argument and result types must both be either vector or "
5480 if (IsDestTypeVector) {
5481 auto SrcVecLen = cast<VectorType>(SrcTy)->getElementCount();
5482 auto DestVecLen = cast<VectorType>(DestTy)->getElementCount();
5483 Check(SrcVecLen == DestVecLen,
5484 "return type and arguments must have the same number of "
5490 case Intrinsic::coro_id: {
5491 auto *InfoArg =
Call.getArgOperand(3)->stripPointerCasts();
5492 if (isa<ConstantPointerNull>(InfoArg))
5494 auto *GV = dyn_cast<GlobalVariable>(InfoArg);
5496 "info argument of llvm.coro.id must refer to an initialized "
5499 Check(isa<ConstantStruct>(
Init) || isa<ConstantArray>(
Init),
5500 "info argument of llvm.coro.id must refer to either a struct or "
5504 case Intrinsic::is_fpclass: {
5507 "unsupported bits for llvm.is.fpclass test mask");
5510 case Intrinsic::fptrunc_round: {
5513 auto *MAV = dyn_cast<MetadataAsValue>(
Call.getOperand(1));
5515 MD = MAV->getMetadata();
5517 Check(MD !=
nullptr,
"missing rounding mode argument", Call);
5519 Check(isa<MDString>(MD),
5520 (
"invalid value for llvm.fptrunc.round metadata operand"
5521 " (the operand should be a string)"),
5524 std::optional<RoundingMode> RoundMode =
5527 "unsupported rounding mode argument", Call);
5530#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
5531#include "llvm/IR/VPIntrinsics.def"
5532#undef BEGIN_REGISTER_VP_INTRINSIC
5533 visitVPIntrinsic(cast<VPIntrinsic>(Call));
5535#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
5536 case Intrinsic::INTRINSIC:
5537#include "llvm/IR/ConstrainedOps.def"
5539 visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call));
5541 case Intrinsic::dbg_declare:
5542 Check(isa<MetadataAsValue>(
Call.getArgOperand(0)),
5543 "invalid llvm.dbg.declare intrinsic call 1", Call);
5544 visitDbgIntrinsic(
"declare", cast<DbgVariableIntrinsic>(Call));
5546 case Intrinsic::dbg_value:
5547 visitDbgIntrinsic(
"value", cast<DbgVariableIntrinsic>(Call));
5549 case Intrinsic::dbg_assign:
5550 visitDbgIntrinsic(
"assign", cast<DbgVariableIntrinsic>(Call));
5552 case Intrinsic::dbg_label:
5553 visitDbgLabelIntrinsic(
"label", cast<DbgLabelInst>(Call));
5555 case Intrinsic::memcpy:
5556 case Intrinsic::memcpy_inline:
5557 case Intrinsic::memmove:
5558 case Intrinsic::memset:
5559 case Intrinsic::memset_inline:
5560 case Intrinsic::experimental_memset_pattern: {
5563 case Intrinsic::memcpy_element_unordered_atomic:
5564 case Intrinsic::memmove_element_unordered_atomic:
5565 case Intrinsic::memset_element_unordered_atomic: {
5566 const auto *AMI = cast<AtomicMemIntrinsic>(&Call);
5569 cast<ConstantInt>(AMI->getRawElementSizeInBytes());
5572 "element size of the element-wise atomic memory intrinsic "
5573 "must be a power of 2",
5576 auto IsValidAlignment = [&](
MaybeAlign Alignment) {
5577 return Alignment && ElementSizeVal.
ule(Alignment->value());
5579 Check(IsValidAlignment(AMI->getDestAlign()),
5580 "incorrect alignment of the destination argument", Call);
5581 if (
const auto *AMT = dyn_cast<AtomicMemTransferInst>(AMI)) {
5582 Check(IsValidAlignment(AMT->getSourceAlign()),
5583 "incorrect alignment of the source argument", Call);
5587 case Intrinsic::call_preallocated_setup: {
5588 auto *NumArgs = dyn_cast<ConstantInt>(
Call.getArgOperand(0));
5589 Check(NumArgs !=
nullptr,
5590 "llvm.call.preallocated.setup argument must be a constant");
5591 bool FoundCall =
false;
5593 auto *UseCall = dyn_cast<CallBase>(U);
5594 Check(UseCall !=
nullptr,
5595 "Uses of llvm.call.preallocated.setup must be calls");
5596 const Function *Fn = UseCall->getCalledFunction();
5597 if (Fn && Fn->
getIntrinsicID() == Intrinsic::call_preallocated_arg) {
5598 auto *AllocArgIndex = dyn_cast<ConstantInt>(UseCall->getArgOperand(1));
5599 Check(AllocArgIndex !=
nullptr,
5600 "llvm.call.preallocated.alloc arg index must be a constant");
5601 auto AllocArgIndexInt = AllocArgIndex->getValue();
5602 Check(AllocArgIndexInt.sge(0) &&
5603 AllocArgIndexInt.slt(NumArgs->getValue()),
5604 "llvm.call.preallocated.alloc arg index must be between 0 and "
5606 "llvm.call.preallocated.setup's argument count");
5608 Intrinsic::call_preallocated_teardown) {
5611 Check(!FoundCall,
"Can have at most one call corresponding to a "
5612 "llvm.call.preallocated.setup");
5614 size_t NumPreallocatedArgs = 0;
5615 for (
unsigned i = 0; i < UseCall->arg_size(); i++) {
5616 if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
5617 ++NumPreallocatedArgs;
5620 Check(NumPreallocatedArgs != 0,
5621 "cannot use preallocated intrinsics on a call without "
5622 "preallocated arguments");
5623 Check(NumArgs->equalsInt(NumPreallocatedArgs),
5624 "llvm.call.preallocated.setup arg size must be equal to number "
5625 "of preallocated arguments "
5635 auto PreallocatedBundle =
5637 Check(PreallocatedBundle,
5638 "Use of llvm.call.preallocated.setup outside intrinsics "
5639 "must be in \"preallocated\" operand bundle");
5640 Check(PreallocatedBundle->Inputs.front().get() == &Call,
5641 "preallocated bundle must have token from corresponding "
5642 "llvm.call.preallocated.setup");
5647 case Intrinsic::call_preallocated_arg: {
5648 auto *Token = dyn_cast<CallBase>(
Call.getArgOperand(0));
5649 Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
5650 Intrinsic::call_preallocated_setup,
5651 "llvm.call.preallocated.arg token argument must be a "
5652 "llvm.call.preallocated.setup");
5653 Check(
Call.hasFnAttr(Attribute::Preallocated),
5654 "llvm.call.preallocated.arg must be called with a \"preallocated\" "
5655 "call site attribute");
5658 case Intrinsic::call_preallocated_teardown: {
5659 auto *Token = dyn_cast<CallBase>(
Call.getArgOperand(0));
5660 Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
5661 Intrinsic::call_preallocated_setup,
5662 "llvm.call.preallocated.teardown token argument must be a "
5663 "llvm.call.preallocated.setup");
5666 case Intrinsic::gcroot:
5667 case Intrinsic::gcwrite:
5668 case Intrinsic::gcread:
5669 if (
ID == Intrinsic::gcroot) {
5671 dyn_cast<AllocaInst>(
Call.getArgOperand(0)->stripPointerCasts());
5672 Check(AI,
"llvm.gcroot parameter #1 must be an alloca.", Call);
5673 Check(isa<Constant>(
Call.getArgOperand(1)),
5674 "llvm.gcroot parameter #2 must be a constant.", Call);
5676 Check(!isa<ConstantPointerNull>(
Call.getArgOperand(1)),
5677 "llvm.gcroot parameter #1 must either be a pointer alloca, "
5678 "or argument #2 must be a non-null constant.",
5683 Check(
Call.getParent()->getParent()->hasGC(),
5684 "Enclosing function does not use GC.", Call);
5686 case Intrinsic::init_trampoline:
5687 Check(isa<Function>(
Call.getArgOperand(1)->stripPointerCasts()),
5688 "llvm.init_trampoline parameter #2 must resolve to a function.",
5691 case Intrinsic::prefetch:
5692 Check(cast<ConstantInt>(
Call.getArgOperand(1))->getZExtValue() < 2,
5693 "rw argument to llvm.prefetch must be 0-1", Call);
5694 Check(cast<ConstantInt>(
Call.getArgOperand(2))->getZExtValue() < 4,
5695 "locality argument to llvm.prefetch must be 0-3", Call);
5696 Check(cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue() < 2,
5697 "cache type argument to llvm.prefetch must be 0-1", Call);
5699 case Intrinsic::stackprotector:
5700 Check(isa<AllocaInst>(
Call.getArgOperand(1)->stripPointerCasts()),
5701 "llvm.stackprotector parameter #2 must resolve to an alloca.", Call);
5703 case Intrinsic::localescape: {
5707 Check(!SawFrameEscape,
"multiple calls to llvm.localescape in one function",
5710 if (isa<ConstantPointerNull>(Arg))
5712 auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
5714 "llvm.localescape only accepts static allocas", Call);
5717 SawFrameEscape =
true;
5720 case Intrinsic::localrecover: {
5721 Value *FnArg =
Call.getArgOperand(0)->stripPointerCasts();
5722 Function *Fn = dyn_cast<Function>(FnArg);
5724 "llvm.localrecover first "
5725 "argument must be function defined in this module",
5727 auto *IdxArg = cast<ConstantInt>(
Call.getArgOperand(2));
5728 auto &
Entry = FrameEscapeInfo[Fn];
5730 std::max(
uint64_t(
Entry.second), IdxArg->getLimitedValue(~0U) + 1));
5734 case Intrinsic::experimental_gc_statepoint:
5735 if (
auto *CI = dyn_cast<CallInst>(&Call))
5736 Check(!CI->isInlineAsm(),
5737 "gc.statepoint support for inline assembly unimplemented", CI);
5738 Check(
Call.getParent()->getParent()->hasGC(),
5739 "Enclosing function does not use GC.", Call);
5741 verifyStatepoint(Call);
5743 case Intrinsic::experimental_gc_result: {
5744 Check(
Call.getParent()->getParent()->hasGC(),
5745 "Enclosing function does not use GC.", Call);
5747 auto *Statepoint =
Call.getArgOperand(0);
5748 if (isa<UndefValue>(Statepoint))
5752 const auto *StatepointCall = dyn_cast<CallBase>(Statepoint);
5754 StatepointCall ? StatepointCall->getCalledFunction() :
nullptr;
5757 Intrinsic::experimental_gc_statepoint,
5758 "gc.result operand #1 must be from a statepoint", Call,
5759 Call.getArgOperand(0));
5762 auto *TargetFuncType =
5763 cast<FunctionType>(StatepointCall->getParamElementType(2));
5764 Check(
Call.getType() == TargetFuncType->getReturnType(),
5765 "gc.result result type does not match wrapped callee", Call);
5768 case Intrinsic::experimental_gc_relocate: {
5769 Check(
Call.arg_size() == 3,
"wrong number of arguments", Call);
5771 Check(isa<PointerType>(
Call.getType()->getScalarType()),
5772 "gc.relocate must return a pointer or a vector of pointers", Call);
5778 dyn_cast<LandingPadInst>(
Call.getArgOperand(0))) {
5781 LandingPad->
getParent()->getUniquePredecessor();
5785 Check(InvokeBB,
"safepoints should have unique landingpads",
5786 LandingPad->getParent());
5790 "gc relocate should be linked to a statepoint", InvokeBB);
5795 auto *Token =
Call.getArgOperand(0);
5796 Check(isa<GCStatepointInst>(Token) || isa<UndefValue>(Token),
5797 "gc relocate is incorrectly tied to the statepoint", Call, Token);
5801 const Value &StatepointCall = *cast<GCRelocateInst>(Call).getStatepoint();
5806 "gc.relocate operand #2 must be integer offset", Call);
5809 Check(isa<ConstantInt>(Derived),
5810 "gc.relocate operand #3 must be integer offset", Call);
5812 const uint64_t BaseIndex = cast<ConstantInt>(
Base)->getZExtValue();
5813 const uint64_t DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
5816 if (isa<UndefValue>(StatepointCall))
5818 if (
auto Opt = cast<GCStatepointInst>(StatepointCall)
5820 Check(BaseIndex < Opt->Inputs.size(),
5821 "gc.relocate: statepoint base index out of bounds", Call);
5822 Check(DerivedIndex < Opt->Inputs.size(),
5823 "gc.relocate: statepoint derived index out of bounds", Call);
5831 auto *ResultType =
Call.getType();
5836 "gc.relocate: relocated value must be a pointer", Call);
5837 Check(DerivedType->isPtrOrPtrVectorTy(),
5838 "gc.relocate: relocated value must be a pointer", Call);
5840 Check(ResultType->isVectorTy() == DerivedType->isVectorTy(),
5841 "gc.relocate: vector relocates to vector and pointer to pointer",
5844 ResultType->getPointerAddressSpace() ==
5845 DerivedType->getPointerAddressSpace(),
5846 "gc.relocate: relocating a pointer shouldn't change its address space",
5850 Check(GC,
"gc.relocate: calling function must have GCStrategy",
5851 Call.getFunction());
5853 auto isGCPtr = [&
GC](
Type *PTy) {
5854 return GC->isGCManagedPointer(PTy->getScalarType()).value_or(
true);
5856 Check(isGCPtr(ResultType),
"gc.relocate: must return gc pointer", Call);
5858 "gc.relocate: relocated value must be a gc pointer", Call);
5859 Check(isGCPtr(DerivedType),
5860 "gc.relocate: relocated value must be a gc pointer", Call);
5864 case Intrinsic::experimental_patchpoint: {
5866 Check(
Call.getType()->isSingleValueType(),
5867 "patchpoint: invalid return type used with anyregcc", Call);
5871 case Intrinsic::eh_exceptioncode:
5872 case Intrinsic::eh_exceptionpointer: {
5873 Check(isa<CatchPadInst>(
Call.getArgOperand(0)),
5874 "eh.exceptionpointer argument must be a catchpad", Call);
5877 case Intrinsic::get_active_lane_mask: {
5879 "get_active_lane_mask: must return a "
5882 auto *ElemTy =
Call.getType()->getScalarType();
5883 Check(ElemTy->isIntegerTy(1),
5884 "get_active_lane_mask: element type is not "
5889 case Intrinsic::experimental_get_vector_length: {
5892 "get_vector_length: VF must be positive", Call);
5895 case Intrinsic::masked_load: {
5896 Check(
Call.getType()->isVectorTy(),
"masked_load: must return a vector",
5901 Value *PassThru =
Call.getArgOperand(3);
5902 Check(
Mask->getType()->isVectorTy(),
"masked_load: mask must be vector",
5905 "masked_load: alignment must be a power of 2", Call);
5907 "masked_load: pass through and return type must match", Call);
5908 Check(cast<VectorType>(
Mask->getType())->getElementCount() ==
5909 cast<VectorType>(
Call.getType())->getElementCount(),
5910 "masked_load: vector mask must be same length as return", Call);
5913 case Intrinsic::masked_store: {
5917 Check(
Mask->getType()->isVectorTy(),
"masked_store: mask must be vector",
5920 "masked_store: alignment must be a power of 2", Call);
5921 Check(cast<VectorType>(
Mask->getType())->getElementCount() ==
5922 cast<VectorType>(Val->
getType())->getElementCount(),
5923 "masked_store: vector mask must be same length as value", Call);
5927 case Intrinsic::masked_gather: {
5928 const APInt &Alignment =
5931 "masked_gather: alignment must be 0 or a power of 2", Call);
5934 case Intrinsic::masked_scatter: {
5935 const APInt &Alignment =
5936 cast<ConstantInt>(
Call.getArgOperand(2))->getValue();
5938 "masked_scatter: alignment must be 0 or a power of 2", Call);
5942 case Intrinsic::experimental_guard: {
5943 Check(isa<CallInst>(Call),
"experimental_guard cannot be invoked", Call);
5945 "experimental_guard must have exactly one "
5946 "\"deopt\" operand bundle");
5950 case Intrinsic::experimental_deoptimize: {
5951 Check(isa<CallInst>(Call),
"experimental_deoptimize cannot be invoked",
5954 "experimental_deoptimize must have exactly one "
5955 "\"deopt\" operand bundle");
5956 Check(
Call.getType() ==
Call.getFunction()->getReturnType(),
5957 "experimental_deoptimize return type must match caller return type");
5959 if (isa<CallInst>(Call)) {
5960 auto *RI = dyn_cast<ReturnInst>(
Call.getNextNode());
5962 "calls to experimental_deoptimize must be followed by a return");
5964 if (!
Call.getType()->isVoidTy() && RI)
5965 Check(RI->getReturnValue() == &Call,
5966 "calls to experimental_deoptimize must be followed by a return "
5967 "of the value computed by experimental_deoptimize");
5972 case Intrinsic::vastart: {
5974 "va_start called in a non-varargs function");
5977 case Intrinsic::vector_reduce_and:
5978 case Intrinsic::vector_reduce_or:
5979 case Intrinsic::vector_reduce_xor:
5980 case Intrinsic::vector_reduce_add:
5981 case Intrinsic::vector_reduce_mul:
5982 case Intrinsic::vector_reduce_smax:
5983 case Intrinsic::vector_reduce_smin:
5984 case Intrinsic::vector_reduce_umax:
5985 case Intrinsic::vector_reduce_umin: {
5986 Type *ArgTy =
Call.getArgOperand(0)->getType();
5988 "Intrinsic has incorrect argument type!");
5991 case Intrinsic::vector_reduce_fmax:
5992 case Intrinsic::vector_reduce_fmin: {
5993 Type *ArgTy =
Call.getArgOperand(0)->getType();
5995 "Intrinsic has incorrect argument type!");
5998 case Intrinsic::vector_reduce_fadd:
5999 case Intrinsic::vector_reduce_fmul: {
6002 Type *ArgTy =
Call.getArgOperand(1)->getType();
6004 "Intrinsic has incorrect argument type!");
6007 case Intrinsic::smul_fix:
6008 case Intrinsic::smul_fix_sat:
6009 case Intrinsic::umul_fix:
6010 case Intrinsic::umul_fix_sat:
6011 case Intrinsic::sdiv_fix:
6012 case Intrinsic::sdiv_fix_sat:
6013 case Intrinsic::udiv_fix:
6014 case Intrinsic::udiv_fix_sat: {
6018 "first operand of [us][mul|div]_fix[_sat] must be an int type or "
6021 "second operand of [us][mul|div]_fix[_sat] must be an int type or "
6024 auto *Op3 = cast<ConstantInt>(
Call.getArgOperand(2));
6025 Check(Op3->getType()->isIntegerTy(),
6026 "third operand of [us][mul|div]_fix[_sat] must be an int type");
6027 Check(Op3->getBitWidth() <= 32,
6028 "third operand of [us][mul|div]_fix[_sat] must fit within 32 bits");
6030 if (
ID == Intrinsic::smul_fix ||
ID == Intrinsic::smul_fix_sat ||
6031 ID == Intrinsic::sdiv_fix ||
ID == Intrinsic::sdiv_fix_sat) {
6033 "the scale of s[mul|div]_fix[_sat] must be less than the width of "
6037 "the scale of u[mul|div]_fix[_sat] must be less than or equal "
6038 "to the width of the operands");
6042 case Intrinsic::lrint:
6043 case Intrinsic::llrint:
6044 case Intrinsic::lround:
6045 case Intrinsic::llround: {
6046 Type *ValTy =
Call.getArgOperand(0)->getType();
6048 auto *VTy = dyn_cast<VectorType>(ValTy);
6049 auto *RTy = dyn_cast<VectorType>(ResultTy);
6051 ExpectedName +
": argument must be floating-point or vector "
6052 "of floating-points, and result must be integer or "
6053 "vector of integers",
6056 ExpectedName +
": argument and result disagree on vector use", &Call);
6058 Check(VTy->getElementCount() == RTy->getElementCount(),
6059 ExpectedName +
": argument must be same length as result", &Call);
6063 case Intrinsic::bswap: {
6066 Check(
Size % 16 == 0,
"bswap must be an even number of bytes", &Call);
6069 case Intrinsic::invariant_start: {
6070 ConstantInt *InvariantSize = dyn_cast<ConstantInt>(
Call.getArgOperand(0));
6071 Check(InvariantSize &&
6073 "invariant_start parameter must be -1, 0 or a positive number",
6077 case Intrinsic::matrix_multiply:
6078 case Intrinsic::matrix_transpose:
6079 case Intrinsic::matrix_column_major_load:
6080 case Intrinsic::matrix_column_major_store: {
6086 Type *Op0ElemTy =
nullptr;
6087 Type *Op1ElemTy =
nullptr;
6089 case Intrinsic::matrix_multiply: {
6090 NumRows = cast<ConstantInt>(
Call.getArgOperand(2));
6092 NumColumns = cast<ConstantInt>(
Call.getArgOperand(4));
6093 Check(cast<FixedVectorType>(
Call.getArgOperand(0)->getType())
6094 ->getNumElements() ==
6096 "First argument of a matrix operation does not match specified "
6098 Check(cast<FixedVectorType>(
Call.getArgOperand(1)->getType())
6099 ->getNumElements() ==
6101 "Second argument of a matrix operation does not match specified "
6104 ResultTy = cast<VectorType>(
Call.getType());
6106 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
6108 cast<VectorType>(
Call.getArgOperand(1)->getType())->getElementType();
6111 case Intrinsic::matrix_transpose:
6112 NumRows = cast<ConstantInt>(
Call.getArgOperand(1));
6113 NumColumns = cast<ConstantInt>(
Call.getArgOperand(2));
6114 ResultTy = cast<VectorType>(
Call.getType());
6116 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
6118 case Intrinsic::matrix_column_major_load: {
6119 Stride = dyn_cast<ConstantInt>(
Call.getArgOperand(1));
6120 NumRows = cast<ConstantInt>(
Call.getArgOperand(3));
6121 NumColumns = cast<ConstantInt>(
Call.getArgOperand(4));
6122 ResultTy = cast<VectorType>(
Call.getType());
6125 case Intrinsic::matrix_column_major_store: {
6126 Stride = dyn_cast<ConstantInt>(
Call.getArgOperand(2));
6127 NumRows = cast<ConstantInt>(
Call.getArgOperand(4));
6128 NumColumns = cast<ConstantInt>(
Call.getArgOperand(5));
6129 ResultTy = cast<VectorType>(
Call.getArgOperand(0)->getType());
6131 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
6138 Check(ResultTy->getElementType()->isIntegerTy() ||
6139 ResultTy->getElementType()->isFloatingPointTy(),
6140 "Result type must be an integer or floating-point type!", IF);
6143 Check(ResultTy->getElementType() == Op0ElemTy,
6144 "Vector element type mismatch of the result and first operand "
6149 Check(ResultTy->getElementType() == Op1ElemTy,
6150 "Vector element type mismatch of the result and second operand "
6156 "Result of a matrix operation does not fit in the returned vector!");
6160 "Stride must be greater or equal than the number of rows!", IF);
6164 case Intrinsic::vector_splice: {
6166 int64_t
Idx = cast<ConstantInt>(
Call.getArgOperand(2))->getSExtValue();
6167 int64_t KnownMinNumElements = VecTy->getElementCount().getKnownMinValue();
6168 if (
Call.getParent() &&
Call.getParent()->getParent()) {
6170 if (
Attrs.hasFnAttr(Attribute::VScaleRange))
6171 KnownMinNumElements *=
Attrs.getFnAttrs().getVScaleRangeMin();
6173 Check((
Idx < 0 && std::abs(
Idx) <= KnownMinNumElements) ||
6174 (
Idx >= 0 &&
Idx < KnownMinNumElements),
6175 "The splice index exceeds the range [-VL, VL-1] where VL is the "
6176 "known minimum number of elements in the vector. For scalable "
6177 "vectors the minimum number of elements is determined from "
6182 case Intrinsic::stepvector: {
6184 Check(VecTy && VecTy->getScalarType()->isIntegerTy() &&
6185 VecTy->getScalarSizeInBits() >= 8,
6186 "stepvector only supported for vectors of integers "
6187 "with a bitwidth of at least 8.",
6191 case Intrinsic::experimental_vector_match: {
6200 Check(Op1Ty && Op2Ty && MaskTy,
"Operands must be vectors.", &Call);
6201 Check(isa<FixedVectorType>(Op2Ty),
6202 "Second operand must be a fixed length vector.", &Call);
6203 Check(Op1Ty->getElementType()->isIntegerTy(),
6204 "First operand must be a vector of integers.", &Call);
6205 Check(Op1Ty->getElementType() == Op2Ty->getElementType(),
6206 "First two operands must have the same element type.", &Call);
6207 Check(Op1Ty->getElementCount() == MaskTy->getElementCount(),
6208 "First operand and mask must have the same number of elements.",
6210 Check(MaskTy->getElementType()->isIntegerTy(1),
6211 "Mask must be a vector of i1's.", &Call);
6212 Check(
Call.getType() == MaskTy,
"Return type must match the mask type.",
6216 case Intrinsic::vector_insert: {
6220 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6227 Check(VecTy->getElementType() == SubVecTy->getElementType(),
6228 "vector_insert parameters must have the same element "
6232 "vector_insert index must be a constant multiple of "
6233 "the subvector's known minimum vector length.");
6241 "subvector operand of vector_insert would overrun the "
6242 "vector being inserted into.");
6246 case Intrinsic::vector_extract: {
6249 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6257 Check(ResultTy->getElementType() == VecTy->getElementType(),
6258 "vector_extract result must have the same element "
6259 "type as the input vector.",
6262 "vector_extract index must be a constant multiple of "
6263 "the result type's known minimum vector length.");
6271 "vector_extract would overrun.");
6275 case Intrinsic::experimental_vector_partial_reduce_add: {
6276 VectorType *AccTy = cast<VectorType>(
Call.getArgOperand(0)->getType());
6277 VectorType *VecTy = cast<VectorType>(
Call.getArgOperand(1)->getType());
6279 unsigned VecWidth = VecTy->getElementCount().getKnownMinValue();
6280 unsigned AccWidth = AccTy->getElementCount().getKnownMinValue();
6282 Check((VecWidth % AccWidth) == 0,
6283 "Invalid vector widths for partial "
6284 "reduction. The width of the input vector "
6285 "must be a positive integer multiple of "
6286 "the width of the accumulator vector.");
6289 case Intrinsic::experimental_noalias_scope_decl: {
6290 NoAliasScopeDecls.
push_back(cast<IntrinsicInst>(&Call));
6293 case Intrinsic::preserve_array_access_index:
6294 case Intrinsic::preserve_struct_access_index:
6295 case Intrinsic::aarch64_ldaxr:
6296 case Intrinsic::aarch64_ldxr:
6297 case Intrinsic::arm_ldaex:
6298 case Intrinsic::arm_ldrex: {
6299 Type *ElemTy =
Call.getParamElementType(0);
6300 Check(ElemTy,
"Intrinsic requires elementtype attribute on first argument.",
6304 case Intrinsic::aarch64_stlxr:
6305 case Intrinsic::aarch64_stxr:
6306 case Intrinsic::arm_stlex:
6307 case Intrinsic::arm_strex: {
6308 Type *ElemTy =
Call.getAttributes().getParamElementType(1);
6310 "Intrinsic requires elementtype attribute on second argument.",
6314 case Intrinsic::aarch64_prefetch: {
6315 Check(cast<ConstantInt>(
Call.getArgOperand(1))->getZExtValue() < 2,
6316 "write argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6317 Check(cast<ConstantInt>(
Call.getArgOperand(2))->getZExtValue() < 4,
6318 "target argument to llvm.aarch64.prefetch must be 0-3", Call);
6319 Check(cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue() < 2,
6320 "stream argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6321 Check(cast<ConstantInt>(
Call.getArgOperand(4))->getZExtValue() < 2,
6322 "isdata argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6325 case Intrinsic::callbr_landingpad: {
6326 const auto *CBR = dyn_cast<CallBrInst>(
Call.getOperand(0));
6327 Check(CBR,
"intrinstic requires callbr operand", &Call);
6334 CheckFailed(
"Intrinsic in block must have 1 unique predecessor", &Call);
6338 CheckFailed(
"Intrinsic must have corresponding callbr in predecessor",
6343 "Intrinsic's corresponding callbr must have intrinsic's parent basic "
6344 "block in indirect destination list",
6347 Check(&
First == &Call,
"No other instructions may proceed intrinsic",
6351 case Intrinsic::amdgcn_cs_chain: {
6352 auto CallerCC =
Call.getCaller()->getCallingConv();
6359 CheckFailed(
"Intrinsic can only be used from functions with the "
6360 "amdgpu_cs, amdgpu_cs_chain or amdgpu_cs_chain_preserve "
6361 "calling conventions",
6366 Check(
Call.paramHasAttr(2, Attribute::InReg),
6367 "SGPR arguments must have the `inreg` attribute", &Call);
6368 Check(!
Call.paramHasAttr(3, Attribute::InReg),
6369 "VGPR arguments must not have the `inreg` attribute", &Call);
6372 case Intrinsic::amdgcn_set_inactive_chain_arg: {
6373 auto CallerCC =
Call.getCaller()->getCallingConv();
6379 CheckFailed(
"Intrinsic can only be used from functions with the "
6380 "amdgpu_cs_chain or amdgpu_cs_chain_preserve "
6381 "calling conventions",
6386 unsigned InactiveIdx = 1;
6387 Check(!
Call.paramHasAttr(InactiveIdx, Attribute::InReg),
6388 "Value for inactive lanes must not have the `inreg` attribute",
6390 Check(isa<Argument>(
Call.getArgOperand(InactiveIdx)),
6391 "Value for inactive lanes must be a function argument", &Call);
6392 Check(!cast<Argument>(
Call.getArgOperand(InactiveIdx))->hasInRegAttr(),
6393 "Value for inactive lanes must be a VGPR function argument", &Call);
6396 case Intrinsic::amdgcn_s_prefetch_data: {
6399 Call.getArgOperand(0)->getType()->getPointerAddressSpace()),
6400 "llvm.amdgcn.s.prefetch.data only supports global or constant memory");
6403 case Intrinsic::amdgcn_mfma_scale_f32_16x16x128_f8f6f4:
6404 case Intrinsic::amdgcn_mfma_scale_f32_32x32x64_f8f6f4: {
6408 uint64_t CBSZ = cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue();
6409 uint64_t BLGP = cast<ConstantInt>(
Call.getArgOperand(4))->getZExtValue();
6410 Check(CBSZ <= 4,
"invalid value for cbsz format", Call,
6411 Call.getArgOperand(3));
6412 Check(BLGP <= 4,
"invalid value for blgp format", Call,
6413 Call.getArgOperand(4));
6416 auto getFormatNumRegs = [](
unsigned FormatVal) {
6417 switch (FormatVal) {
6432 if (!Ty || !Ty->getElementType()->
isIntegerTy(32))
6434 unsigned NumElts = Ty->getNumElements();
6435 return NumElts == 4 || NumElts == 6 || NumElts == 8;
6438 auto *Src0Ty = dyn_cast<FixedVectorType>(Src0->
getType());
6439 auto *Src1Ty = dyn_cast<FixedVectorType>(Src1->
getType());
6440 Check(isValidSrcASrcBVector(Src0Ty),
6441 "operand 0 must be 4, 6 or 8 element i32 vector", &Call, Src0);
6442 Check(isValidSrcASrcBVector(Src1Ty),
6443 "operand 1 must be 4, 6 or 8 element i32 vector", &Call, Src1);
6446 Check(Src0Ty->getNumElements() >= getFormatNumRegs(CBSZ),
6447 "invalid vector type for format", &Call, Src0,
Call.getArgOperand(3));
6448 Check(Src1Ty->getNumElements() >= getFormatNumRegs(BLGP),
6449 "invalid vector type for format", &Call, Src1,
Call.getArgOperand(5));
6452 case Intrinsic::nvvm_setmaxnreg_inc_sync_aligned_u32:
6453 case Intrinsic::nvvm_setmaxnreg_dec_sync_aligned_u32: {
6455 unsigned RegCount = cast<ConstantInt>(V)->getZExtValue();
6456 Check(RegCount % 8 == 0,
6457 "reg_count argument to nvvm.setmaxnreg must be in multiples of 8");
6458 Check((RegCount >= 24 && RegCount <= 256),
6459 "reg_count argument to nvvm.setmaxnreg must be within [24, 256]");
6462 case Intrinsic::experimental_convergence_entry:
6463 case Intrinsic::experimental_convergence_anchor:
6465 case Intrinsic::experimental_convergence_loop:
6467 case Intrinsic::ptrmask: {
6468 Type *Ty0 =
Call.getArgOperand(0)->getType();
6469 Type *Ty1 =
Call.getArgOperand(1)->getType();
6471 "llvm.ptrmask intrinsic first argument must be pointer or vector "
6476 "llvm.ptrmask intrinsic arguments must be both scalars or both vectors",
6479 Check(cast<VectorType>(Ty0)->getElementCount() ==
6480 cast<VectorType>(Ty1)->getElementCount(),
6481 "llvm.ptrmask intrinsic arguments must have the same number of "
6485 "llvm.ptrmask intrinsic second argument bitwidth must match "
6486 "pointer index type size of first argument",
6490 case Intrinsic::threadlocal_address: {
6491 const Value &Arg0 = *
Call.getArgOperand(0);
6492 Check(isa<GlobalValue>(Arg0),
6493 "llvm.threadlocal.address first argument must be a GlobalValue");
6494 Check(cast<GlobalValue>(Arg0).isThreadLocal(),
6495 "llvm.threadlocal.address operand isThreadLocal() must be true");
6498 case Intrinsic::nvvm_fence_proxy_tensormap_generic_acquire_cta:
6499 case Intrinsic::nvvm_fence_proxy_tensormap_generic_acquire_cluster:
6500 case Intrinsic::nvvm_fence_proxy_tensormap_generic_acquire_gpu:
6501 case Intrinsic::nvvm_fence_proxy_tensormap_generic_acquire_sys: {
6502 unsigned size = cast<ConstantInt>(
Call.getArgOperand(1))->getZExtValue();
6503 Check(size == 128,
" The only supported value for size operand is 128");
6511 if (
F->hasPersonalityFn() &&
6515 if (BlockEHFuncletColors.
empty())
6519 bool InEHFunclet =
false;
6524 if (dyn_cast_or_null<FuncletPadInst>(ColorFirstBB->getFirstNonPHI()))
6528 bool HasToken =
false;
6529 for (
unsigned I = 0, E =
Call.getNumOperandBundles();
I != E; ++
I)
6535 Check(HasToken,
"Missing funclet token on intrinsic call", &Call);
6548 if (
auto *SP = dyn_cast<DISubprogram>(LocalScope))
6551 if (
auto *LB = dyn_cast<DILexicalBlockBase>(LocalScope))
6555 assert(!isa<DILocalScope>(LocalScope) &&
"Unknown type of local scope");
6561 "invalid #dbg_label intrinsic variable", &DLR, DLR.
getRawLabel());
6565 if (!isa<DILocation>(
N))
6574 CheckDI(Loc,
"#dbg_label record requires a !dbg attachment", &DLR, BB,
F);
6578 if (!LabelSP || !LocSP)
6582 "mismatched subprogram between #dbg_label label and !dbg attachment",
6583 &DLR, BB,
F, Label,
Label->getScope()->getSubprogram(), Loc,
6584 Loc->getScope()->getSubprogram());
6594 "invalid #dbg record type", &DVR, DVR.
getType());
6600 CheckDI(MD && (isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
6601 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands())),
6602 "invalid #dbg record address/value", &DVR, MD);
6603 if (
auto *VAM = dyn_cast<ValueAsMetadata>(MD))
6604 visitValueAsMetadata(*VAM,
F);
6605 else if (
auto *AL = dyn_cast<DIArgList>(MD))
6606 visitDIArgList(*AL,
F);
6620 AreDebugLocsAllowed::No);
6627 isa<ValueAsMetadata>(RawAddr) ||
6628 (isa<MDNode>(RawAddr) && !cast<MDNode>(RawAddr)->getNumOperands()),
6630 if (
auto *VAM = dyn_cast<ValueAsMetadata>(RawAddr))
6631 visitValueAsMetadata(*VAM,
F);
6634 "invalid #dbg_assign address expression", &DVR,
6641 "inst not in same function as #dbg_assign",
I, &DVR);
6650 CheckDI(isa_and_nonnull<DILocation>(DLNode),
"invalid #dbg record DILocation",
6657 if (!VarSP || !LocSP)
6661 "mismatched subprogram between #dbg record variable and DILocation",
6663 Loc->getScope()->getSubprogram());
6668void Verifier::visitVPIntrinsic(
VPIntrinsic &VPI) {
6669 if (
auto *VPCast = dyn_cast<VPCastIntrinsic>(&VPI)) {
6670 auto *
RetTy = cast<VectorType>(VPCast->getType());
6671 auto *ValTy = cast<VectorType>(VPCast->getOperand(0)->getType());
6672 Check(
RetTy->getElementCount() == ValTy->getElementCount(),
6673 "VP cast intrinsic first argument and result vector lengths must be "
6677 switch (VPCast->getIntrinsicID()) {
6680 case Intrinsic::vp_trunc:
6682 "llvm.vp.trunc intrinsic first argument and result element type "
6686 "llvm.vp.trunc intrinsic the bit size of first argument must be "
6687 "larger than the bit size of the return type",
6690 case Intrinsic::vp_zext:
6691 case Intrinsic::vp_sext:
6693 "llvm.vp.zext or llvm.vp.sext intrinsic first argument and result "
6694 "element type must be integer",
6697 "llvm.vp.zext or llvm.vp.sext intrinsic the bit size of first "
6698 "argument must be smaller than the bit size of the return type",
6701 case Intrinsic::vp_fptoui:
6702 case Intrinsic::vp_fptosi:
6703 case Intrinsic::vp_lrint:
6704 case Intrinsic::vp_llrint:
6707 "llvm.vp.fptoui, llvm.vp.fptosi, llvm.vp.lrint or llvm.vp.llrint" "intrinsic first argument element "
6708 "type must be floating-point and result element type must be integer",
6711 case Intrinsic::vp_uitofp:
6712 case Intrinsic::vp_sitofp:
6715 "llvm.vp.uitofp or llvm.vp.sitofp intrinsic first argument element "
6716 "type must be integer and result element type must be floating-point",
6719 case Intrinsic::vp_fptrunc:
6721 "llvm.vp.fptrunc intrinsic first argument and result element type "
6722 "must be floating-point",
6725 "llvm.vp.fptrunc intrinsic the bit size of first argument must be "
6726 "larger than the bit size of the return type",
6729 case Intrinsic::vp_fpext:
6731 "llvm.vp.fpext intrinsic first argument and result element type "
6732 "must be floating-point",
6735 "llvm.vp.fpext intrinsic the bit size of first argument must be "
6736 "smaller than the bit size of the return type",
6739 case Intrinsic::vp_ptrtoint:
6741 "llvm.vp.ptrtoint intrinsic first argument element type must be "
6742 "pointer and result element type must be integer",
6745 case Intrinsic::vp_inttoptr:
6747 "llvm.vp.inttoptr intrinsic first argument element type must be "
6748 "integer and result element type must be pointer",
6754 auto Pred = cast<VPCmpIntrinsic>(&VPI)->getPredicate();
6756 "invalid predicate for VP FP comparison intrinsic", &VPI);
6759 auto Pred = cast<VPCmpIntrinsic>(&VPI)->getPredicate();
6761 "invalid predicate for VP integer comparison intrinsic", &VPI);
6764 auto TestMask = cast<ConstantInt>(VPI.
getOperand(1));
6766 "unsupported bits for llvm.vp.is.fpclass test mask");
6772 bool HasRoundingMD =
6776 NumOperands += (1 + HasRoundingMD);
6779 if (isa<ConstrainedFPCmpIntrinsic>(FPI))
6782 "invalid arguments for constrained FP intrinsic", &FPI);
6785 case Intrinsic::experimental_constrained_lrint:
6786 case Intrinsic::experimental_constrained_llrint: {
6790 "Intrinsic does not support vectors", &FPI);
6794 case Intrinsic::experimental_constrained_lround:
6795 case Intrinsic::experimental_constrained_llround: {
6799 "Intrinsic does not support vectors", &FPI);
6803 case Intrinsic::experimental_constrained_fcmp:
6804 case Intrinsic::experimental_constrained_fcmps: {
6805 auto Pred = cast<ConstrainedFPCmpIntrinsic>(&FPI)->getPredicate();
6807 "invalid predicate for constrained FP comparison intrinsic", &FPI);
6811 case Intrinsic::experimental_constrained_fptosi:
6812 case Intrinsic::experimental_constrained_fptoui: {
6816 "Intrinsic first argument must be floating point", &FPI);
6817 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6818 SrcEC = cast<VectorType>(OperandT)->getElementCount();
6823 "Intrinsic first argument and result disagree on vector use", &FPI);
6825 "Intrinsic result must be an integer", &FPI);
6826 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6827 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
6828 "Intrinsic first argument and result vector lengths must be equal",
6834 case Intrinsic::experimental_constrained_sitofp:
6835 case Intrinsic::experimental_constrained_uitofp: {
6839 "Intrinsic first argument must be integer", &FPI);
6840 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6841 SrcEC = cast<VectorType>(OperandT)->getElementCount();
6846 "Intrinsic first argument and result disagree on vector use", &FPI);
6848 "Intrinsic result must be a floating point", &FPI);
6849 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6850 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
6851 "Intrinsic first argument and result vector lengths must be equal",
6857 case Intrinsic::experimental_constrained_fptrunc:
6858 case Intrinsic::experimental_constrained_fpext: {
6864 "Intrinsic first argument must be FP or FP vector", &FPI);
6866 "Intrinsic result must be FP or FP vector", &FPI);
6868 "Intrinsic first argument and result disagree on vector use", &FPI);
6870 Check(cast<VectorType>(OperandTy)->getElementCount() ==
6871 cast<VectorType>(ResultTy)->getElementCount(),
6872 "Intrinsic first argument and result vector lengths must be equal",
6875 if (FPI.
getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
6877 "Intrinsic first argument's type must be larger than result type",
6881 "Intrinsic first argument's type must be smaller than result type",
6897 "invalid exception behavior argument", &FPI);
6898 if (HasRoundingMD) {
6906 CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
6907 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
6908 "invalid llvm.dbg." + Kind +
" intrinsic address/value", &DII, MD);
6910 "invalid llvm.dbg." + Kind +
" intrinsic variable", &DII,
6913 "invalid llvm.dbg." + Kind +
" intrinsic expression", &DII,
6916 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&DII)) {
6917 CheckDI(isa<DIAssignID>(DAI->getRawAssignID()),
6918 "invalid llvm.dbg.assign intrinsic DIAssignID", &DII,
6919 DAI->getRawAssignID());
6920 const auto *RawAddr = DAI->getRawAddress();
6922 isa<ValueAsMetadata>(RawAddr) ||
6923 (isa<MDNode>(RawAddr) && !cast<MDNode>(RawAddr)->getNumOperands()),
6924 "invalid llvm.dbg.assign intrinsic address", &DII,
6925 DAI->getRawAddress());
6926 CheckDI(isa<DIExpression>(DAI->getRawAddressExpression()),
6927 "invalid llvm.dbg.assign intrinsic address expression", &DII,
6928 DAI->getRawAddressExpression());
6931 CheckDI(DAI->getFunction() ==
I->getFunction(),
6932 "inst not in same function as dbg.assign",
I, DAI);
6937 if (!isa<DILocation>(
N))
6946 CheckDI(Loc,
"llvm.dbg." + Kind +
" intrinsic requires a !dbg attachment",
6951 if (!VarSP || !LocSP)
6955 "mismatched subprogram between llvm.dbg." + Kind +
6956 " variable and !dbg attachment",
6958 Loc->getScope()->getSubprogram());
6968 "invalid llvm.dbg." + Kind +
" intrinsic variable", &DLI,
6973 if (!isa<DILocation>(
N))
6982 Check(Loc,
"llvm.dbg." + Kind +
" intrinsic requires a !dbg attachment", &DLI,
6987 if (!LabelSP || !LocSP)
6991 "mismatched subprogram between llvm.dbg." + Kind +
6992 " label and !dbg attachment",
6993 &DLI, BB,
F, Label,
Label->getScope()->getSubprogram(), Loc,
6994 Loc->getScope()->getSubprogram());
6999 DIExpression *E = dyn_cast_or_null<DIExpression>(
I.getRawExpression());
7002 if (!V || !E || !E->
isValid())
7016 if (
V->isArtificial())
7019 verifyFragmentExpression(*V, *Fragment, &
I);
7026 if (!V || !E || !E->
isValid())
7040 if (
V->isArtificial())
7043 verifyFragmentExpression(*V, *Fragment, &DVR);
7046template <
typename ValueOrMetadata>
7047void Verifier::verifyFragmentExpression(
const DIVariable &V,
7049 ValueOrMetadata *
Desc) {
7052 auto VarSize =
V.getSizeInBits();
7058 CheckDI(FragSize + FragOffset <= *VarSize,
7059 "fragment is larger than or outside of variable",
Desc, &V);
7060 CheckDI(FragSize != *VarSize,
"fragment covers entire variable",
Desc, &V);
7071 if (
I.getDebugLoc()->getInlinedAt())
7075 CheckDI(Var,
"dbg intrinsic without variable");
7077 unsigned ArgNo = Var->
getArg();
7083 if (DebugFnArgs.
size() < ArgNo)
7084 DebugFnArgs.
resize(ArgNo,
nullptr);
7086 auto *Prev = DebugFnArgs[ArgNo - 1];
7087 DebugFnArgs[ArgNo - 1] = Var;
7088 CheckDI(!Prev || (Prev == Var),
"conflicting debug info for argument", &
I,
7103 CheckDI(Var,
"#dbg record without variable");
7105 unsigned ArgNo = Var->
getArg();
7111 if (DebugFnArgs.
size() < ArgNo)
7112 DebugFnArgs.
resize(ArgNo,
nullptr);
7114 auto *Prev = DebugFnArgs[ArgNo - 1];
7115 DebugFnArgs[ArgNo - 1] = Var;
7116 CheckDI(!Prev || (Prev == Var),
"conflicting debug info for argument", &DVR,
7121 DIExpression *E = dyn_cast_or_null<DIExpression>(
I.getRawExpression());
7127 if (isa<ValueAsMetadata>(
I.getRawLocation())) {
7128 Value *VarValue =
I.getVariableLocationOp(0);
7129 if (isa<UndefValue>(VarValue) || isa<PoisonValue>(VarValue))
7133 if (
auto *ArgLoc = dyn_cast_or_null<Argument>(VarValue);
7134 ArgLoc && ArgLoc->hasAttribute(Attribute::SwiftAsync))
7139 "Entry values are only allowed in MIR unless they target a "
7140 "swiftasync Argument",
7152 if (isa<UndefValue>(VarValue) || isa<PoisonValue>(VarValue))
7156 if (
auto *ArgLoc = dyn_cast_or_null<Argument>(VarValue);
7157 ArgLoc && ArgLoc->hasAttribute(Attribute::SwiftAsync))
7162 "Entry values are only allowed in MIR unless they target a "
7163 "swiftasync Argument",
7167void Verifier::verifyCompileUnits() {
7171 if (
M.getContext().isODRUniquingDebugTypes())
7173 auto *CUs =
M.getNamedMetadata(
"llvm.dbg.cu");
7176 Listed.
insert(CUs->op_begin(), CUs->op_end());
7177 for (
const auto *
CU : CUVisited)
7182void Verifier::verifyDeoptimizeCallingConvs() {
7183 if (DeoptimizeDeclarations.
empty())
7187 for (
const auto *
F :
ArrayRef(DeoptimizeDeclarations).slice(1)) {
7188 Check(
First->getCallingConv() ==
F->getCallingConv(),
7189 "All llvm.experimental.deoptimize declarations must have the same "
7190 "calling convention",
7195void Verifier::verifyAttachedCallBundle(
const CallBase &Call,
7199 Check((FTy->getReturnType()->isPointerTy() ||
7200 (
Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),
7201 "a call with operand bundle \"clang.arc.attachedcall\" must call a "
7202 "function returning a pointer or a non-returning function that has a "
7207 "operand bundle \"clang.arc.attachedcall\" requires one function as "
7211 auto *Fn = cast<Function>(BU.
Inputs.front());
7215 Check((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
7216 IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue),
7217 "invalid function argument", Call);
7220 Check((FnName ==
"objc_retainAutoreleasedReturnValue" ||
7221 FnName ==
"objc_unsafeClaimAutoreleasedReturnValue"),
7222 "invalid function argument", Call);
7226void Verifier::verifyNoAliasScopeDecl() {
7227 if (NoAliasScopeDecls.
empty())
7231 for (
auto *
II : NoAliasScopeDecls) {
7232 assert(
II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl &&
7233 "Not a llvm.experimental.noalias.scope.decl ?");
7234 const auto *ScopeListMV = dyn_cast<MetadataAsValue>(
7236 Check(ScopeListMV !=
nullptr,
7237 "llvm.experimental.noalias.scope.decl must have a MetadataAsValue "
7241 const auto *ScopeListMD = dyn_cast<MDNode>(ScopeListMV->getMetadata());
7242 Check(ScopeListMD !=
nullptr,
"!id.scope.list must point to an MDNode",
II);
7243 Check(ScopeListMD->getNumOperands() == 1,
7244 "!id.scope.list must point to a list with a single scope",
II);
7245 visitAliasScopeListMetadata(ScopeListMD);
7256 const auto *ScopeListMV = cast<MetadataAsValue>(
7258 return &cast<MDNode>(ScopeListMV->getMetadata())->getOperand(0);
7264 return GetScope(Lhs) < GetScope(Rhs);
7271 auto ItCurrent = NoAliasScopeDecls.begin();
7272 while (ItCurrent != NoAliasScopeDecls.end()) {
7273 auto CurScope = GetScope(*ItCurrent);
7274 auto ItNext = ItCurrent;
7277 }
while (ItNext != NoAliasScopeDecls.end() &&
7278 GetScope(*ItNext) == CurScope);
7283 if (ItNext - ItCurrent < 32)
7288 "llvm.experimental.noalias.scope.decl dominates another one "
7289 "with the same scope",
7307 return !V.verify(
F);
7311 bool *BrokenDebugInfo) {
7315 bool Broken =
false;
7317 Broken |= !V.verify(
F);
7319 Broken |= !V.verify();
7320 if (BrokenDebugInfo)
7321 *BrokenDebugInfo = V.hasBrokenDebugInfo();
7332 std::unique_ptr<Verifier> V;
7333 bool FatalErrors =
true;
7338 explicit VerifierLegacyPass(
bool FatalErrors)
7340 FatalErrors(FatalErrors) {
7344 bool doInitialization(
Module &M)
override {
7345 V = std::make_unique<Verifier>(
7351 if (!
V->verify(
F) && FatalErrors) {
7352 errs() <<
"in function " <<
F.getName() <<
'\n';
7358 bool doFinalization(
Module &M)
override {
7359 bool HasErrors =
false;
7361 if (
F.isDeclaration())
7362 HasErrors |= !
V->verify(
F);
7364 HasErrors |= !
V->verify();
7365 if (FatalErrors && (HasErrors ||
V->hasBrokenDebugInfo()))
7378template <
typename...
Tys>
void TBAAVerifier::CheckFailed(Tys &&... Args) {
7383#define CheckTBAA(C, ...) \
7386 CheckFailed(__VA_ARGS__); \
7394TBAAVerifier::TBAABaseNodeSummary
7398 CheckFailed(
"Base nodes must have at least two operands", &
I, BaseNode);
7402 auto Itr = TBAABaseNodes.find(BaseNode);
7403 if (Itr != TBAABaseNodes.end())
7406 auto Result = verifyTBAABaseNodeImpl(
I, BaseNode, IsNewFormat);
7407 auto InsertResult = TBAABaseNodes.insert({BaseNode, Result});
7409 assert(InsertResult.second &&
"We just checked!");
7413TBAAVerifier::TBAABaseNodeSummary
7416 const TBAAVerifier::TBAABaseNodeSummary InvalidNode = {
true, ~0
u};
7420 return isValidScalarTBAANode(BaseNode)
7421 ? TBAAVerifier::TBAABaseNodeSummary({
false, 0})
7427 CheckFailed(
"Access tag nodes must have the number of operands that is a "
7428 "multiple of 3!", BaseNode);
7433 CheckFailed(
"Struct tag nodes must have an odd number of operands!",
7441 auto *TypeSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7443 if (!TypeSizeNode) {
7444 CheckFailed(
"Type size nodes must be constants!", &
I, BaseNode);
7450 if (!IsNewFormat && !isa<MDString>(BaseNode->
getOperand(0))) {
7451 CheckFailed(
"Struct tag nodes have a string as their first operand",
7458 std::optional<APInt> PrevOffset;
7463 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
7464 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
7466 Idx += NumOpsPerField) {
7469 if (!isa<MDNode>(FieldTy)) {
7470 CheckFailed(
"Incorrect field entry in struct type node!", &
I, BaseNode);
7475 auto *OffsetEntryCI =
7476 mdconst::dyn_extract_or_null<ConstantInt>(FieldOffset);
7477 if (!OffsetEntryCI) {
7478 CheckFailed(
"Offset entries must be constants!", &
I, BaseNode);
7484 BitWidth = OffsetEntryCI->getBitWidth();
7486 if (OffsetEntryCI->getBitWidth() !=
BitWidth) {
7488 "Bitwidth between the offsets and struct type entries must match", &
I,
7500 !PrevOffset || PrevOffset->ule(OffsetEntryCI->getValue());
7503 CheckFailed(
"Offsets must be increasing!", &
I, BaseNode);
7507 PrevOffset = OffsetEntryCI->getValue();
7510 auto *MemberSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7512 if (!MemberSizeNode) {
7513 CheckFailed(
"Member size entries must be constants!", &
I, BaseNode);
7520 return Failed ? InvalidNode
7521 : TBAAVerifier::TBAABaseNodeSummary(
false,
BitWidth);
7542 auto *Parent = dyn_cast_or_null<MDNode>(MD->
getOperand(1));
7543 return Parent && Visited.
insert(Parent).second &&
7547bool TBAAVerifier::isValidScalarTBAANode(
const MDNode *MD) {
7548 auto ResultIt = TBAAScalarNodes.find(MD);
7549 if (ResultIt != TBAAScalarNodes.end())
7550 return ResultIt->second;
7554 auto InsertResult = TBAAScalarNodes.insert({MD,
Result});
7556 assert(InsertResult.second &&
"Just checked!");
7575 return cast<MDNode>(BaseNode->
getOperand(1));
7577 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
7578 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
7580 Idx += NumOpsPerField) {
7581 auto *OffsetEntryCI =
7582 mdconst::extract<ConstantInt>(BaseNode->
getOperand(
Idx + 1));
7583 if (OffsetEntryCI->getValue().ugt(
Offset)) {
7584 if (
Idx == FirstFieldOpNo) {
7585 CheckFailed(
"Could not find TBAA parent in struct type node", &
I,
7590 unsigned PrevIdx =
Idx - NumOpsPerField;
7591 auto *PrevOffsetEntryCI =
7592 mdconst::extract<ConstantInt>(BaseNode->
getOperand(PrevIdx + 1));
7593 Offset -= PrevOffsetEntryCI->getValue();
7594 return cast<MDNode>(BaseNode->
getOperand(PrevIdx));
7599 auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
7601 Offset -= LastOffsetEntryCI->getValue();
7602 return cast<MDNode>(BaseNode->
getOperand(LastIdx));
7606 if (!
Type ||
Type->getNumOperands() < 3)
7611 return isa_and_nonnull<MDNode>(
Type->getOperand(0));
7618 CheckTBAA(isa<LoadInst>(
I) || isa<StoreInst>(
I) || isa<CallInst>(
I) ||
7619 isa<VAArgInst>(
I) || isa<AtomicRMWInst>(
I) ||
7620 isa<AtomicCmpXchgInst>(
I),
7621 "This instruction shall not have a TBAA access tag!", &
I);
7623 bool IsStructPathTBAA =
7627 "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
7637 "Access tag metadata must have either 4 or 5 operands", &
I, MD);
7640 "Struct tag metadata must have either 3 or 4 operands", &
I, MD);
7645 auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7647 CheckTBAA(AccessSizeNode,
"Access size field must be a constant", &
I, MD);
7651 unsigned ImmutabilityFlagOpNo = IsNewFormat ? 4 : 3;
7653 auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
7656 "Immutability tag on struct tag metadata must be a constant", &
I,
7659 IsImmutableCI->isZero() || IsImmutableCI->isOne(),
7660 "Immutability part of the struct tag metadata must be either 0 or 1",
7665 "Malformed struct tag metadata: base and access-type "
7666 "should be non-null and point to Metadata nodes",
7667 &
I, MD, BaseNode, AccessType);
7670 CheckTBAA(isValidScalarTBAANode(AccessType),
7671 "Access type node must be a valid scalar type", &
I, MD,
7675 auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->
getOperand(2));
7676 CheckTBAA(OffsetCI,
"Offset must be constant integer", &
I, MD);
7679 bool SeenAccessTypeInPath =
false;
7684 BaseNode = getFieldNodeFromTBAABaseNode(
I, BaseNode,
Offset,
7686 if (!StructPath.
insert(BaseNode).second) {
7687 CheckFailed(
"Cycle detected in struct path", &
I, MD);
7692 unsigned BaseNodeBitWidth;
7693 std::tie(
Invalid, BaseNodeBitWidth) = verifyTBAABaseNode(
I, BaseNode,
7701 SeenAccessTypeInPath |= BaseNode == AccessType;
7703 if (isValidScalarTBAANode(BaseNode) || BaseNode == AccessType)
7704 CheckTBAA(
Offset == 0,
"Offset not zero at the point of scalar access",
7708 (BaseNodeBitWidth == 0 &&
Offset == 0) ||
7709 (IsNewFormat && BaseNodeBitWidth == ~0u),
7710 "Access bit-width not the same as description bit-width", &
I, MD,
7711 BaseNodeBitWidth,
Offset.getBitWidth());
7713 if (IsNewFormat && SeenAccessTypeInPath)
7717 CheckTBAA(SeenAccessTypeInPath,
"Did not see access type in access path!", &
I,
7722char VerifierLegacyPass::ID = 0;
7723INITIALIZE_PASS(VerifierLegacyPass,
"verify",
"Module Verifier",
false,
false)
7726 return new VerifierLegacyPass(FatalErrors);
7744 if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
7752 if (res.IRBroken && FatalErrors)
AMDGPU address space definition.
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
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
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.
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
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 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.
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.
static bool isValid(const char C)
Returns true if C is a valid mangled character: <0-9a-zA-Z_>.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static unsigned getNumElements(Type *Ty)
void visit(MachineFunction &MF, MachineBasicBlock &Start, std::function< void(MachineBasicBlock *)> op)
verify safepoint Safepoint IR Verifier
This file defines the SmallPtrSet class.
This file defines the SmallSet 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)
#define Check(C,...)
We know that cond should be true, if not print an error message.
static bool isNewFormatTBAATypeNode(llvm::MDNode *Type)
#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 bool isDINode(const Metadata *MD)
static bool isScope(const Metadata *MD)
static cl::opt< bool > VerifyNoAliasScopeDomination("verify-noalias-scope-decl-dom", cl::Hidden, cl::init(false), cl::desc("Ensure that llvm.experimental.noalias.scope.decl for identical " "scopes are not dominating"))
static DISubprogram * getSubprogram(Metadata *LocalScope)
Carefully grab the subprogram from a local scope.
static bool isTypeCongruent(Type *L, Type *R)
Two types are "congruent" if they are identical, or if they are both pointer types with different poi...
static bool IsRootTBAANode(const MDNode *MD)
static bool isContiguous(const ConstantRange &A, const ConstantRange &B)
static Value * getParentPad(Value *EHPad)
static bool hasConflictingReferenceFlags(unsigned Flags)
Detect mutually exclusive flags.
static AttrBuilder getParameterABIAttributes(LLVMContext &C, unsigned I, AttributeList Attrs)
bool isFiniteNonZero() const
const fltSemantics & getSemantics() const
Class for arbitrary precision integers.
bool sgt(const APInt &RHS) const
Signed greater than comparison.
bool isZero() const
Determine if this value is zero, i.e. all bits are clear.
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.
an instruction to allocate memory on the stack
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
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.
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.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
void setPreservesAll()
Set by analyses that do not transform their input at all.
This class represents an incoming formal argument to a Function.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool empty() const
empty - Check if the array is empty.
An instruction that atomically checks whether a specified value is in a memory location,...
an instruction that atomically reads a memory location, combines it with another value,...
static bool isFPOperation(BinOp Op)
BinOp getOperation() const
static 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.
std::string getAsString(bool InAttrGrp=false) const
static Attribute::AttrKind getAttrKindFromName(StringRef AttrName)
static bool canUseAsRetAttr(AttrKind Kind)
static bool isExistingAttribute(StringRef Name)
Return true if the provided string matches the IR name of an attribute.
static bool canUseAsFnAttr(AttrKind Kind)
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
@ None
No attributes have been set.
static bool isIntAttrKind(AttrKind Kind)
static bool canUseAsParamAttr(AttrKind Kind)
bool isValid() const
Return true if the attribute is any kind of attribute.
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 Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
const Instruction & front() const
bool isEntryBlock() const
Return true if this is the entry block of the containing function.
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
This class represents a no-op cast from one type to another.
static BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
Conditional or Unconditional Branch instruction.
bool isConditional() const
Value * getCondition() const
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.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
CallingConv::ID getCallingConv() const
Value * getCalledOperand() const
Value * getArgOperand(unsigned i) const
FunctionType * getFunctionType() const
unsigned arg_size() const
AttributeList getAttributes() const
Return the attributes for this call.
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 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
bool isIntPredicate() const
static bool isIntPredicate(Predicate P)
ConstantArray - Constant Array Declarations.
A constant value that is initialized with an expression using other constant values.
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
bool isMinusOne() const
This function will return true iff every bit in this constant is set to true.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
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.
A signed pointer, in the ptrauth sense.
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.
ConstantInt * getDiscriminator() const
The integer discriminator, an i64 constant, or 0.
static bool isOrderedRanges(ArrayRef< ConstantRange > RangesRef)
This class represents a range of values.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
This is an important base class in LLVM.
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
This is the common base class for constrained floating point intrinsics.
std::optional< fp::ExceptionBehavior > getExceptionBehavior() const
std::optional< RoundingMode > getRoundingMode() const
unsigned getNonMetadataArgCount() const
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
Basic type, like 'int' or 'float'.
bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
A pair of DIGlobalVariable and DIExpression.
DIGlobalVariable * getVariable() const
DIExpression * getExpression() const
An imported module (C++ using directive or similar).
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
DILocalScope * getScope() const
Get the local scope for this variable.
Metadata * getRawScope() const
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Tagged DWARF-like metadata node.
Base class for scope-like contexts.
String type, Fortran CHARACTER(n)
Type array for a subprogram.
Base class for template parameters.
Base class for variables.
Metadata * getRawType() const
Metadata * getRawScope() const
This class represents an Operation in the Expression.
uint64_t getNumOperands() const
A parsed version of the target data layout string in and methods for querying it.
This represents the llvm.dbg.label instruction.
Metadata * getRawLabel() const
DILabel * getLabel() 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.
void print(raw_ostream &O, bool IsForDebug=false) const
DebugLoc getDebugLoc() const
const BasicBlock * getParent() const
This is the common base class for debug info intrinsics for variables.
Metadata * getRawLocation() const
DILocalVariable * getVariable() const
Metadata * getRawVariable() const
Metadata * getRawExpression() const
Record of a variable value-assignment, aka a non instruction representation of the dbg....
LocationType getType() const
MDNode * getRawExpression() const
MDNode * getRawAddressExpression() const
DIExpression * getExpression() const
Metadata * getRawAssignID() const
Value * getVariableLocationOp(unsigned OpIdx) const
MDNode * getRawVariable() const
DILocalVariable * getVariable() const
Metadata * getRawLocation() const
Returns the metadata operand for the first location description.
Metadata * getRawAddress() const
@ End
Marks the end of the concrete types.
@ Any
To indicate all LocationTypes in searches.
DIExpression * getAddressExpression() const
MDNode * getAsMDNode() const
Return this as a bar MDNode.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
void recalculate(ParentType &Func)
recalculate - compute a dominator tree for the given function
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
This instruction compares its operands according to the predicate given to the constructor.
This class represents an extension of floating point types.
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.
An instruction for ordering other memory operations.
AtomicOrdering getOrdering() const
Returns the ordering constraint of this fence instruction.
Class to represent fixed width SIMD vectors.
Value * getParentPad() const
Convenience accessors.
FunctionPass class - This class is used to implement most global optimizations.
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
bool hasPersonalityFn() const
Check whether this function has a personality function.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
const std::string & getGC() const
Represents calls to the gc.relocate intrinsic.
Value * getBasePtr() const
Value * getDerivedPtr() const
void initialize(raw_ostream *OS, function_ref< void(const Twine &Message)> FailureCB, const FunctionT &F)
void verify(const DominatorTreeT &DT)
void visit(const BlockT &BB)
Generic tagged DWARF-like metadata node.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
static 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
const Function * getResolverFunction() const
static bool isValidLinkage(LinkageTypes L)
const Constant * getResolver() const
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
bool hasExternalLinkage() const
bool isImplicitDSOLocal() const
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 hasAvailableExternallyLinkage() const
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
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 bool isValidOperands(const Value *Vec, const Value *NewElt, const Value *Idx)
Return true if an insertelement instruction can be formed with the specified operands.
This instruction inserts a struct field of array element value into an aggregate value.
Value * getAggregateOperand()
ArrayRef< unsigned > getIndices() const
Base class for instruction visitors.
RetTy visitTerminator(Instruction &I)
RetTy visitCallBase(CallBase &I)
void visitFunction(Function &F)
void visitBasicBlock(BasicBlock &BB)
void visit(Iterator Start, Iterator End)
RetTy visitFuncletPadInst(FuncletPadInst &I)
void visitInstruction(Instruction &I)
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.
bool isAtomic() const LLVM_READONLY
Return true if this instruction has an AtomicOrdering of unordered or higher.
const Function * getFunction() const
Return the function this instruction belongs to.
This class represents a cast from an integer to a pointer.
A wrapper class for inspecting calls to intrinsic functions.
static 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
The landingpad instruction holds all of the information necessary to generate correct exception handl...
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.
SyncScope::ID getSyncScopeID() const
Returns the synchronization scope ID of this load instruction.
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
Tracking metadata reference owned by Metadata.
StringRef getString() const
Typed, array-like tuple of metadata.
This class implements a map that also provides access to all stored values in a deterministic order.
Manage lifetime of a slot tracker for printing IR.
A Module instance is used to store all the information related to an LLVM module.
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
@ AppendUnique
Appends the two values, which are required to be metadata nodes.
@ Override
Uses the specified value, regardless of the behavior or value of the other module.
@ Warning
Emits a warning if two values disagree.
@ Error
Emits an error if two values disagree, otherwise the resulting value is that of the operands.
@ Min
Takes the min of the two values, which are required to be integers.
@ Append
Appends the two values, which are required to be metadata nodes.
@ Max
Takes the max of the two values, which are required to be integers.
@ Require
Adds a requirement that another module flag be present and have a specified value after linking is pe...
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB)
Checks if Metadata represents a valid ModFlagBehavior, and stores the converted result in MFB.
StringRef getName() const
void print(raw_ostream &ROS, bool IsForDebug=false) const
iterator_range< op_iterator > operands()
op_range incoming_values()
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
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.
Simple wrapper around std::function<void(raw_ostream&)>.
This class represents a cast from a pointer to an integer.
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Resume the propagation of an exception.
Value * getValue() const
Convenience accessor.
Return a value (possibly void), from a function.
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 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 bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
Return true if a shufflevector instruction can be formed with the specified operands.
static void getShuffleMask(const Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
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.
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.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
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.
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringRef - Represent a constant reference to a string, i.e.
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.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
static constexpr size_t npos
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
Type * getTypeAtIndex(const Value *V) const
Given an index value into the type, return the type of the element.
bool isScalableTy(SmallPtrSetImpl< const Type * > &Visited) const
Returns true if this struct contains a scalable vector.
Verify that the TBAA Metadatas are valid.
bool visitTBAAMetadata(Instruction &I, const MDNode *MD)
Visit an instruction and return true if it is valid, return false if an invalid TBAA is attached.
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Triple - Helper class for working with autoconf configuration names.
This class represents a truncation of integer types.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
bool containsNonLocalTargetExtType(SmallPtrSetImpl< const Type * > &Visited) const
Return true if this type is or contains a target extension type that disallows being used as a local.
bool isArrayTy() const
True if this is an instance of ArrayType.
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.
bool containsNonGlobalTargetExtType(SmallPtrSetImpl< const Type * > &Visited) const
Return true if this type is or contains a target extension type that disallows being used as a global...
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
bool isScalableTy(SmallPtrSetImpl< const Type * > &Visited) const
Return true if this is a type whose size is a known multiple of vscale.
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.
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'.
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 isTokenTy() const
Return true if this is 'token'.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isMetadataTy() const
Return true if this is 'metadata'.
This class represents a cast unsigned integer to floating point.
A Use represents the edge between a Value definition and its users.
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...
This is the common base class for vector predication intrinsics.
LLVM Value Representation.
iterator_range< user_iterator > materialized_users()
Type * getType() const
All values are typed, get the type of this value.
static constexpr uint64_t MaximumAlignment
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
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
LLVMContext & getContext() const
All values hold a context through their type.
StringRef getName() const
Return a constant reference to the value's name.
Check a module for errors, and report separate error states for IR and debug info errors.
Result run(Module &M, ModuleAnalysisManager &)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
This class represents zero extension of integer types.
constexpr bool isNonZero() const
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 Args[]
Key for Kernel::Metadata::mArgs.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
bool isFlatGlobalAddrSpace(unsigned AS)
AttributeMask typeIncompatible(Type *Ty, AttributeSet AS, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
@ AMDGPU_CS
Used for Mesa/AMDPAL compute shaders.
@ AMDGPU_VS
Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
@ AnyReg
OBSOLETED - Used for stack based JavaScript calls.
@ AMDGPU_CS_ChainPreserve
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AMDGPU_HS
Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
@ AMDGPU_GS
Used for Mesa/AMDPAL geometry shaders.
@ X86_INTR
x86 hardware interrupt context.
@ AMDGPU_CS_Chain
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AMDGPU_PS
Used for Mesa/AMDPAL pixel shaders.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
@ PTX_Device
Call to a PTX device function.
@ SPIR_KERNEL
Used for SPIR kernel functions.
@ Fast
Attempts to make calls as fast as possible (e.g.
@ Intel_OCL_BI
Used for Intel OpenCL built-ins.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
@ PTX_Kernel
Call to a PTX kernel. Passes all arguments in parameter space.
@ SwiftTail
This follows the Swift calling convention in how arguments are passed but guarantees tail calls will ...
@ C
The default llvm calling convention, compatible with C.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
ID ArrayRef< Type * > Tys
MatchIntrinsicTypesResult matchIntrinsicSignature(FunctionType *FTy, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys)
Match the specified function type with the type constraints specified by the .td file.
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
MatchIntrinsicTypesResult
@ MatchIntrinsicTypes_NoMatchRet
@ MatchIntrinsicTypes_NoMatchArg
bool hasConstrainedFPRoundingModeOperand(ID QID)
Returns true if the intrinsic ID is for one of the "Constrained Floating-Point Intrinsics" that take ...
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
static const int NoAliasScopeDeclScopeArg
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
@ System
Synchronized with respect to all concurrently executing threads.
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.
initializer< Ty > init(const Ty &Val)
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
This is an optimization pass for GlobalISel generic memory operations.
@ 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.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool canInstructionHaveMMRAs(const Instruction &I)
unsigned getBranchWeightOffset(const MDNode *ProfileData)
Return the offset to the first branch weight data.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
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()
void initializeVerifierLegacyPassPass(PassRegistry &)
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.
DenseMap< BasicBlock *, ColorVector > colorEHFunclets(Function &F)
If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
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)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
unsigned getNumBranchWeights(const MDNode &ProfileData)
AtomicOrdering
Atomic ordering for LLVM's memory model.
@ ArgMem
Access to memory via argument pointers.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
FunctionPass * createVerifierPass(bool FatalErrors=true)
@ Dynamic
Denotes mode unknown at compile time.
@ MaskAll
A bitmask that includes all valid flags.
constexpr unsigned BitWidth
DenormalMode parseDenormalFPAttribute(StringRef Str)
Returns the denormal mode to use for inputs and outputs.
std::optional< RoundingMode > convertStrToRoundingMode(StringRef)
Returns a valid RoundingMode enumerator when given a string that is valid as input in constrained int...
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.
bool pred_empty(const BasicBlock *BB)
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
static const fltSemantics & IEEEsingle() LLVM_READNONE
This struct is a compact representation of a valid (non-zero power of two) alignment.
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...
Description of the encoding of one expression Op.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
A lightweight accessor for an operand bundle meant to be passed around by value.
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
void DebugInfoCheckFailed(const Twine &Message)
A debug info check failed.
VerifierSupport(raw_ostream *OS, const Module &M)
bool Broken
Track the brokenness of the module while recursively visiting.
void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs)
A check failed (with values to print).
bool BrokenDebugInfo
Broken debug info can be "recovered" from by stripping the debug info.
bool TreatBrokenDebugInfoAsError
Whether to treat broken debug info as an error.
void CheckFailed(const Twine &Message)
A check failed, so printout out the condition and the message.
void DebugInfoCheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs)
A debug info check failed (with values to print).