96#include "llvm/IR/IntrinsicsAArch64.h"
97#include "llvm/IR/IntrinsicsAMDGPU.h"
98#include "llvm/IR/IntrinsicsARM.h"
99#include "llvm/IR/IntrinsicsNVPTX.h"
100#include "llvm/IR/IntrinsicsWebAssembly.h"
132 cl::desc(
"Ensure that llvm.experimental.noalias.scope.decl for identical "
133 "scopes are not dominating"));
161 void Write(
const Value *V) {
166 void Write(
const Value &V) {
167 if (isa<Instruction>(V)) {
171 V.printAsOperand(*
OS,
true,
MST);
221 void Write(
Type *
T) {
233 void Write(
const APInt *AI) {
239 void Write(
const unsigned i) { *
OS << i <<
'\n'; }
245 *
OS <<
A->getAsString() <<
'\n';
265 for (
const T &V : Vs)
269 template <
typename T1,
typename... Ts>
270 void WriteTs(
const T1 &V1,
const Ts &... Vs) {
275 template <
typename... Ts>
void WriteTs() {}
284 *
OS << Message <<
'\n';
292 template <
typename T1,
typename... Ts>
302 *
OS << Message <<
'\n';
308 template <
typename T1,
typename... Ts>
329 static constexpr unsigned ParamMaxAlignment = 1 << 14;
349 Type *LandingPadResultTy;
356 bool HasDebugInfo =
false;
402 SawFrameEscape(
false), TBAAVerifyHelper(this) {
403 TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
410 "An instance of this class only works with a specific module!");
422 if (!BB.empty() && BB.back().isTerminator())
426 *
OS <<
"Basic Block in function '" <<
F.getName()
427 <<
"' does not have terminator!\n";
428 BB.printAsOperand(*
OS,
true, MST);
434 auto FailureCB = [
this](
const Twine &Message) {
442 verifySiblingFuncletUnwinds();
445 ConvergenceVerifyHelper.
verify(DT);
447 InstsInThisBlock.
clear();
449 LandingPadResultTy =
nullptr;
450 SawFrameEscape =
false;
451 SiblingFuncletInfo.
clear();
452 verifyNoAliasScopeDecl();
453 NoAliasScopeDecls.
clear();
464 if (
F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
469 verifyFrameRecoverIndices();
471 visitGlobalVariable(GV);
474 visitGlobalAlias(GA);
477 visitGlobalIFunc(GI);
480 visitNamedMDNode(NMD);
483 visitComdat(SMEC.getValue());
487 visitModuleCommandLines();
489 verifyCompileUnits();
491 verifyDeoptimizeCallingConvs();
492 DISubprogramAttachments.
clear();
498 enum class AreDebugLocsAllowed {
No,
Yes };
509 void visitMDNode(
const MDNode &MD, AreDebugLocsAllowed AllowLocs);
513 void visitComdat(
const Comdat &
C);
514 void visitModuleIdents();
515 void visitModuleCommandLines();
516 void visitModuleFlags();
517 void visitModuleFlag(
const MDNode *
Op,
520 void visitModuleFlagCGProfileEntry(
const MDOperand &MDO);
523 void verifyRangeMetadata(
const Value &V,
const MDNode *Range,
Type *Ty,
524 bool IsAbsoluteSymbol);
528 void visitCallStackMetadata(
MDNode *MD);
532 void visitAnnotationMetadata(
MDNode *Annotation);
533 void visitAliasScopeMetadata(
const MDNode *MD);
534 void visitAliasScopeListMetadata(
const MDNode *MD);
535 void visitAccessGroupMetadata(
const MDNode *MD);
537 template <
class Ty>
bool isValidMetadataArray(
const MDTuple &
N);
538#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
539#include "llvm/IR/Metadata.def"
540 void visitDIScope(
const DIScope &
N);
567 void visitPHINode(
PHINode &PN);
576 void visitVAArgInst(
VAArgInst &VAA) { visitInstruction(VAA); }
614 void verifySwiftErrorCall(
CallBase &Call,
const Value *SwiftErrorVal);
615 void verifySwiftErrorValue(
const Value *SwiftErrorVal);
617 void verifyMustTailCall(
CallInst &CI);
618 bool verifyAttributeCount(
AttributeList Attrs,
unsigned Params);
624 const Value *V,
bool IsIntrinsic,
bool IsInlineAsm);
625 void verifyFunctionMetadata(
ArrayRef<std::pair<unsigned, MDNode *>> MDs);
627 void visitConstantExprsRecursively(
const Constant *EntryC);
629 void verifyInlineAsmCall(
const CallBase &Call);
630 void verifyStatepoint(
const CallBase &Call);
631 void verifyFrameRecoverIndices();
632 void verifySiblingFuncletUnwinds();
636 template <
typename ValueOrMetadata>
637 void verifyFragmentExpression(
const DIVariable &V,
639 ValueOrMetadata *
Desc);
646 void verifyCompileUnits();
650 void verifyDeoptimizeCallingConvs();
652 void verifyAttachedCallBundle(
const CallBase &Call,
656 void verifyNoAliasScopeDecl();
662#define Check(C, ...) \
665 CheckFailed(__VA_ARGS__); \
672#define CheckDI(C, ...) \
675 DebugInfoCheckFailed(__VA_ARGS__); \
683 CheckDI(
I.DebugMarker->MarkedInstr == &
I,
684 "Instruction has invalid DebugMarker", &
I);
685 CheckDI(!isa<PHINode>(&
I) || !
I.hasDbgRecords(),
686 "PHI Node must not have any attached DbgRecords", &
I);
689 "DbgRecord had invalid DebugMarker", &
I, &DR);
692 visitMDNode(*Loc, AreDebugLocsAllowed::Yes);
693 if (
auto *DVR = dyn_cast<DbgVariableRecord>(&DR)) {
697 verifyFragmentExpression(*DVR);
698 verifyNotEntryValue(*DVR);
699 }
else if (
auto *DLR = dyn_cast<DbgLabelRecord>(&DR)) {
707 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i)
708 Check(
I.getOperand(i) !=
nullptr,
"Operand is null", &
I);
721 while (!WorkList.
empty()) {
723 if (!Visited.
insert(Cur).second)
730void Verifier::visitGlobalValue(
const GlobalValue &GV) {
732 "Global is external, but doesn't have external or weak linkage!", &GV);
734 if (
const GlobalObject *GO = dyn_cast<GlobalObject>(&GV)) {
738 "huge alignment values are unsupported", GO);
741 if (
const MDNode *Associated =
742 GO->getMetadata(LLVMContext::MD_associated)) {
743 Check(Associated->getNumOperands() == 1,
744 "associated metadata must have one operand", &GV, Associated);
745 const Metadata *
Op = Associated->getOperand(0).get();
746 Check(
Op,
"associated metadata must have a global value", GO, Associated);
748 const auto *VM = dyn_cast_or_null<ValueAsMetadata>(
Op);
749 Check(VM,
"associated metadata must be ValueAsMetadata", GO, Associated);
751 Check(isa<PointerType>(VM->getValue()->getType()),
752 "associated value must be pointer typed", GV, Associated);
755 Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
756 "associated metadata must point to a GlobalObject", GO, Stripped);
757 Check(Stripped != GO,
758 "global values should not associate to themselves", GO,
764 if (
const MDNode *AbsoluteSymbol =
765 GO->getMetadata(LLVMContext::MD_absolute_symbol)) {
766 verifyRangeMetadata(*GO, AbsoluteSymbol,
DL.getIntPtrType(GO->getType()),
772 "Only global variables can have appending linkage!", &GV);
777 "Only global arrays can have appending linkage!", GVar);
781 Check(!GV.
hasComdat(),
"Declaration may not be in a Comdat!", &GV);
785 "dllexport GlobalValue must have default or protected visibility",
790 "dllimport GlobalValue must have default visibility", &GV);
791 Check(!GV.
isDSOLocal(),
"GlobalValue with DLLImport Storage is dso_local!",
797 "Global is marked as dllimport, but not external", &GV);
802 "GlobalValue with local linkage or non-default "
803 "visibility must be dso_local!",
808 if (!
I->getParent() || !
I->getParent()->getParent())
809 CheckFailed(
"Global is referenced by parentless instruction!", &GV, &M,
811 else if (
I->getParent()->getParent()->getParent() != &M)
812 CheckFailed(
"Global is referenced in a different module!", &GV, &M,
I,
813 I->getParent()->getParent(),
814 I->getParent()->getParent()->getParent());
816 }
else if (
const Function *
F = dyn_cast<Function>(V)) {
817 if (
F->getParent() != &M)
818 CheckFailed(
"Global is used by function in a different module", &GV, &M,
829 "Global variable initializer type does not match global "
836 "'common' global must have a zero initializer!", &GV);
839 Check(!GV.
hasComdat(),
"'common' global may not be in a Comdat!", &GV);
844 GV.
getName() ==
"llvm.global_dtors")) {
846 "invalid linkage for intrinsic global variable", &GV);
848 "invalid uses of intrinsic global variable", &GV);
853 StructType *STy = dyn_cast<StructType>(ATy->getElementType());
859 "wrong type for intrinsic global variable", &GV);
861 "the third field of the element type is mandatory, "
862 "specify ptr null to migrate from the obsoleted 2-field form");
870 GV.
getName() ==
"llvm.compiler.used")) {
872 "invalid linkage for intrinsic global variable", &GV);
874 "invalid uses of intrinsic global variable", &GV);
877 if (
ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
878 PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
879 Check(PTy,
"wrong type for intrinsic global variable", &GV);
883 Check(InitArray,
"wrong initalizer for intrinsic global variable",
887 Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
891 Twine(
"members of ") + GV.
getName() +
" must be named", V);
900 for (
auto *MD : MDs) {
901 if (
auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
902 visitDIGlobalVariableExpression(*GVE);
904 CheckDI(
false,
"!dbg attachment of global variable must be a "
905 "DIGlobalVariableExpression");
911 "Globals cannot contain scalable types", &GV);
915 if (
auto *TTy = dyn_cast<TargetExtType>(GV.
getValueType()))
917 "Global @" + GV.
getName() +
" has illegal target extension type",
921 visitGlobalValue(GV);
928 visitGlobalValue(GV);
934 visitAliaseeSubExpr(Visited, GA,
C);
940 Check(isa<GlobalValue>(
C) &&
941 cast<GlobalValue>(
C).hasAvailableExternallyLinkage(),
942 "available_externally alias must point to available_externally "
946 if (
const auto *GV = dyn_cast<GlobalValue>(&
C)) {
952 if (
const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
953 Check(Visited.
insert(GA2).second,
"Aliases cannot form a cycle", &GA);
955 Check(!GA2->isInterposable(),
956 "Alias cannot point to an interposable alias", &GA);
964 if (
const auto *CE = dyn_cast<ConstantExpr>(&
C))
965 visitConstantExprsRecursively(CE);
967 for (
const Use &U :
C.operands()) {
969 if (
const auto *GA2 = dyn_cast<GlobalAlias>(V))
970 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
971 else if (
const auto *C2 = dyn_cast<Constant>(V))
972 visitAliaseeSubExpr(Visited, GA, *C2);
976void Verifier::visitGlobalAlias(
const GlobalAlias &GA) {
978 "Alias should have private, internal, linkonce, weak, linkonce_odr, "
979 "weak_odr, external, or available_externally linkage!",
982 Check(Aliasee,
"Aliasee cannot be NULL!", &GA);
984 "Alias and aliasee types should match!", &GA);
986 Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
987 "Aliasee should be either GlobalValue or ConstantExpr", &GA);
989 visitAliaseeSubExpr(GA, *Aliasee);
991 visitGlobalValue(GA);
994void Verifier::visitGlobalIFunc(
const GlobalIFunc &GI) {
996 "IFunc should have private, internal, linkonce, weak, linkonce_odr, "
997 "weak_odr, or external linkage!",
1002 Check(
Resolver,
"IFunc must have a Function resolver", &GI);
1004 "IFunc resolver must be a definition", &GI);
1010 Check(isa<PointerType>(
Resolver->getFunctionType()->getReturnType()),
1011 "IFunc resolver must return a pointer", &GI);
1013 const Type *ResolverFuncTy =
1016 "IFunc resolver has incorrect type", &GI);
1019void Verifier::visitNamedMDNode(
const NamedMDNode &NMD) {
1024 "unrecognized named metadata node in the llvm.dbg namespace", &NMD);
1026 if (NMD.
getName() ==
"llvm.dbg.cu")
1027 CheckDI(MD && isa<DICompileUnit>(MD),
"invalid compile unit", &NMD, MD);
1032 visitMDNode(*MD, AreDebugLocsAllowed::Yes);
1036void Verifier::visitMDNode(
const MDNode &MD, AreDebugLocsAllowed AllowLocs) {
1039 if (!MDNodes.
insert(&MD).second)
1043 "MDNode context does not match Module context!", &MD);
1048 case Metadata::MDTupleKind:
1050#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
1051 case Metadata::CLASS##Kind: \
1052 visit##CLASS(cast<CLASS>(MD)); \
1054#include "llvm/IR/Metadata.def"
1060 Check(!isa<LocalAsMetadata>(
Op),
"Invalid operand for global metadata!",
1062 CheckDI(!isa<DILocation>(
Op) || AllowLocs == AreDebugLocsAllowed::Yes,
1063 "DILocation not allowed within this metadata node", &MD,
Op);
1064 if (
auto *
N = dyn_cast<MDNode>(
Op)) {
1065 visitMDNode(*
N, AllowLocs);
1068 if (
auto *V = dyn_cast<ValueAsMetadata>(
Op)) {
1069 visitValueAsMetadata(*V,
nullptr);
1082 "Unexpected metadata round-trip through values", &MD, MD.
getValue());
1084 auto *
L = dyn_cast<LocalAsMetadata>(&MD);
1088 Check(
F,
"function-local metadata used outside a function", L);
1093 if (
Instruction *
I = dyn_cast<Instruction>(
L->getValue())) {
1094 Check(
I->getParent(),
"function-local metadata not in basic block", L,
I);
1095 ActualF =
I->getParent()->getParent();
1096 }
else if (
BasicBlock *BB = dyn_cast<BasicBlock>(
L->getValue()))
1098 else if (
Argument *
A = dyn_cast<Argument>(
L->getValue()))
1099 ActualF =
A->getParent();
1100 assert(ActualF &&
"Unimplemented function local metadata case!");
1102 Check(ActualF ==
F,
"function-local metadata used in wrong function", L);
1107 visitValueAsMetadata(*VAM,
F);
1112 if (
auto *
N = dyn_cast<MDNode>(MD)) {
1113 visitMDNode(*
N, AreDebugLocsAllowed::No);
1119 if (!MDNodes.
insert(MD).second)
1122 if (
auto *V = dyn_cast<ValueAsMetadata>(MD))
1123 visitValueAsMetadata(*V,
F);
1125 if (
auto *AL = dyn_cast<DIArgList>(MD))
1126 visitDIArgList(*AL,
F);
1133void Verifier::visitDILocation(
const DILocation &
N) {
1134 CheckDI(
N.getRawScope() && isa<DILocalScope>(
N.getRawScope()),
1135 "location requires a valid scope", &
N,
N.getRawScope());
1136 if (
auto *IA =
N.getRawInlinedAt())
1137 CheckDI(isa<DILocation>(IA),
"inlined-at should be a location", &
N, IA);
1138 if (
auto *SP = dyn_cast<DISubprogram>(
N.getRawScope()))
1139 CheckDI(SP->isDefinition(),
"scope points into the type hierarchy", &
N);
1146void Verifier::visitDIScope(
const DIScope &
N) {
1147 if (
auto *
F =
N.getRawFile())
1148 CheckDI(isa<DIFile>(
F),
"invalid file", &
N,
F);
1151void Verifier::visitDISubrange(
const DISubrange &
N) {
1152 CheckDI(
N.getTag() == dwarf::DW_TAG_subrange_type,
"invalid tag", &
N);
1154 CheckDI(HasAssumedSizedArraySupport ||
N.getRawCountNode() ||
1155 N.getRawUpperBound(),
1156 "Subrange must contain count or upperBound", &
N);
1157 CheckDI(!
N.getRawCountNode() || !
N.getRawUpperBound(),
1158 "Subrange can have any one of count or upperBound", &
N);
1159 auto *CBound =
N.getRawCountNode();
1160 CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
1161 isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
1162 "Count must be signed constant or DIVariable or DIExpression", &
N);
1163 auto Count =
N.getCount();
1164 CheckDI(!Count || !isa<ConstantInt *>(Count) ||
1165 cast<ConstantInt *>(Count)->getSExtValue() >= -1,
1166 "invalid subrange count", &
N);
1167 auto *LBound =
N.getRawLowerBound();
1168 CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
1169 isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
1170 "LowerBound must be signed constant or DIVariable or DIExpression",
1172 auto *UBound =
N.getRawUpperBound();
1173 CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
1174 isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
1175 "UpperBound must be signed constant or DIVariable or DIExpression",
1177 auto *Stride =
N.getRawStride();
1178 CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
1179 isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1180 "Stride must be signed constant or DIVariable or DIExpression", &
N);
1184 CheckDI(
N.getTag() == dwarf::DW_TAG_generic_subrange,
"invalid tag", &
N);
1185 CheckDI(
N.getRawCountNode() ||
N.getRawUpperBound(),
1186 "GenericSubrange must contain count or upperBound", &
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);
1324 const DINodeArray
Elements =
N.getElements();
1326 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,
1327 "invalid vector, expected one element of type subrange", &
N);
1330 if (
auto *Params =
N.getRawTemplateParams())
1331 visitTemplateParams(
N, *Params);
1333 if (
auto *
D =
N.getRawDiscriminator()) {
1334 CheckDI(isa<DIDerivedType>(
D) &&
N.getTag() == dwarf::DW_TAG_variant_part,
1335 "discriminator can only appear on variant part");
1338 if (
N.getRawDataLocation()) {
1339 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1340 "dataLocation can only appear in array type");
1343 if (
N.getRawAssociated()) {
1344 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1345 "associated can only appear in array type");
1348 if (
N.getRawAllocated()) {
1349 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1350 "allocated can only appear in array type");
1353 if (
N.getRawRank()) {
1354 CheckDI(
N.getTag() == dwarf::DW_TAG_array_type,
1355 "rank can only appear in array type");
1358 if (
N.getTag() == dwarf::DW_TAG_array_type) {
1359 CheckDI(
N.getRawBaseType(),
"array types must have a base type", &
N);
1364 CheckDI(
N.getTag() == dwarf::DW_TAG_subroutine_type,
"invalid tag", &
N);
1365 if (
auto *Types =
N.getRawTypeArray()) {
1366 CheckDI(isa<MDTuple>(Types),
"invalid composite elements", &
N, Types);
1367 for (
Metadata *Ty :
N.getTypeArray()->operands()) {
1368 CheckDI(
isType(Ty),
"invalid subroutine type ref", &
N, Types, Ty);
1372 "invalid reference flags", &
N);
1375void Verifier::visitDIFile(
const DIFile &
N) {
1376 CheckDI(
N.getTag() == dwarf::DW_TAG_file_type,
"invalid tag", &
N);
1377 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum =
N.getChecksum();
1380 "invalid checksum kind", &
N);
1382 switch (Checksum->Kind) {
1393 CheckDI(Checksum->Value.size() ==
Size,
"invalid checksum length", &
N);
1395 "invalid checksum", &
N);
1400 CheckDI(
N.isDistinct(),
"compile units must be distinct", &
N);
1401 CheckDI(
N.getTag() == dwarf::DW_TAG_compile_unit,
"invalid tag", &
N);
1405 CheckDI(
N.getRawFile() && isa<DIFile>(
N.getRawFile()),
"invalid file", &
N,
1407 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::ByVal)) {
2030 if (
Attrs.hasAttribute(Attribute::Alignment)) {
2031 Align AttrAlign =
Attrs.getAlignment().valueOrOne();
2032 Align MaxAlign(ParamMaxAlignment);
2033 Check(AttrAlign <= MaxAlign,
2034 "Attribute 'align' exceed the max size 2^14", V);
2037 Check(
Attrs.getByValType()->isSized(&Visited),
2038 "Attribute 'byval' does not support unsized types!", V);
2040 if (
Attrs.hasAttribute(Attribute::ByRef)) {
2042 Check(
Attrs.getByRefType()->isSized(&Visited),
2043 "Attribute 'byref' does not support unsized types!", V);
2045 if (
Attrs.hasAttribute(Attribute::InAlloca)) {
2047 Check(
Attrs.getInAllocaType()->isSized(&Visited),
2048 "Attribute 'inalloca' does not support unsized types!", V);
2050 if (
Attrs.hasAttribute(Attribute::Preallocated)) {
2052 Check(
Attrs.getPreallocatedType()->isSized(&Visited),
2053 "Attribute 'preallocated' does not support unsized types!", V);
2057 if (
Attrs.hasAttribute(Attribute::NoFPClass)) {
2058 uint64_t Val =
Attrs.getAttribute(Attribute::NoFPClass).getValueAsInt();
2059 Check(Val != 0,
"Attribute 'nofpclass' must have at least one test bit set",
2062 "Invalid value for 'nofpclass' test mask", V);
2064 if (
Attrs.hasAttribute(Attribute::Range)) {
2065 auto CR =
Attrs.getAttribute(Attribute::Range).getValueAsConstantRange();
2067 "Range bit width must match type bit width!", V);
2073 if (
Attrs.hasFnAttr(Attr)) {
2077 CheckFailed(
"\"" + Attr +
"\" takes an unsigned integer: " + S, V);
2084 const Value *V,
bool IsIntrinsic,
2086 if (
Attrs.isEmpty())
2089 if (AttributeListsVisited.
insert(
Attrs.getRawPointer()).second) {
2091 "Attribute list does not match Module context!", &Attrs, V);
2092 for (
const auto &AttrSet : Attrs) {
2093 Check(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),
2094 "Attribute set does not match Module context!", &AttrSet, V);
2095 for (
const auto &
A : AttrSet) {
2096 Check(
A.hasParentContext(Context),
2097 "Attribute does not match Module context!", &
A, V);
2102 bool SawNest =
false;
2103 bool SawReturned =
false;
2104 bool SawSRet =
false;
2105 bool SawSwiftSelf =
false;
2106 bool SawSwiftAsync =
false;
2107 bool SawSwiftError =
false;
2114 "Attribute '" +
RetAttr.getAsString() +
2115 "' does not apply to function return values",
2118 unsigned MaxParameterWidth = 0;
2119 auto GetMaxParameterWidth = [&MaxParameterWidth](
Type *Ty) {
2121 if (
auto *VT = dyn_cast<FixedVectorType>(Ty)) {
2122 unsigned Size = VT->getPrimitiveSizeInBits().getFixedValue();
2123 if (
Size > MaxParameterWidth)
2124 MaxParameterWidth =
Size;
2128 GetMaxParameterWidth(FT->getReturnType());
2129 verifyParameterAttrs(RetAttrs, FT->getReturnType(), V);
2132 for (
unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2133 Type *Ty = FT->getParamType(i);
2138 "immarg attribute only applies to intrinsics", V);
2141 "Attribute 'elementtype' can only be applied to intrinsics"
2146 verifyParameterAttrs(ArgAttrs, Ty, V);
2147 GetMaxParameterWidth(Ty);
2150 Check(!SawNest,
"More than one parameter has attribute nest!", V);
2155 Check(!SawReturned,
"More than one parameter has attribute returned!", V);
2157 "Incompatible argument and return types for 'returned' attribute",
2163 Check(!SawSRet,
"Cannot have multiple 'sret' parameters!", V);
2164 Check(i == 0 || i == 1,
2165 "Attribute 'sret' is not on first or second parameter!", V);
2170 Check(!SawSwiftSelf,
"Cannot have multiple 'swiftself' parameters!", V);
2171 SawSwiftSelf =
true;
2175 Check(!SawSwiftAsync,
"Cannot have multiple 'swiftasync' parameters!", V);
2176 SawSwiftAsync =
true;
2180 Check(!SawSwiftError,
"Cannot have multiple 'swifterror' parameters!", V);
2181 SawSwiftError =
true;
2185 Check(i == FT->getNumParams() - 1,
2186 "inalloca isn't on the last parameter!", V);
2190 if (!
Attrs.hasFnAttrs())
2193 verifyAttributeTypes(
Attrs.getFnAttrs(), V);
2197 "Attribute '" +
FnAttr.getAsString() +
2198 "' does not apply to functions!",
2201 Check(!(
Attrs.hasFnAttr(Attribute::NoInline) &&
2202 Attrs.hasFnAttr(Attribute::AlwaysInline)),
2203 "Attributes 'noinline and alwaysinline' are incompatible!", V);
2205 if (
Attrs.hasFnAttr(Attribute::OptimizeNone)) {
2207 "Attribute 'optnone' requires 'noinline'!", V);
2209 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2210 "Attributes 'optsize and optnone' are incompatible!", V);
2213 "Attributes 'minsize and optnone' are incompatible!", V);
2215 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForDebugging),
2216 "Attributes 'optdebug and optnone' are incompatible!", V);
2219 if (
Attrs.hasFnAttr(Attribute::OptimizeForDebugging)) {
2220 Check(!
Attrs.hasFnAttr(Attribute::OptimizeForSize),
2221 "Attributes 'optsize and optdebug' are incompatible!", V);
2224 "Attributes 'minsize and optdebug' are incompatible!", V);
2227 Check(!
Attrs.hasAttrSomewhere(Attribute::Writable) ||
2229 "Attribute writable and memory without argmem: write are incompatible!",
2232 if (
Attrs.hasFnAttr(
"aarch64_pstate_sm_enabled")) {
2233 Check(!
Attrs.hasFnAttr(
"aarch64_pstate_sm_compatible"),
2234 "Attributes 'aarch64_pstate_sm_enabled and "
2235 "aarch64_pstate_sm_compatible' are incompatible!",
2239 Check((
Attrs.hasFnAttr(
"aarch64_new_za") +
Attrs.hasFnAttr(
"aarch64_in_za") +
2240 Attrs.hasFnAttr(
"aarch64_inout_za") +
2241 Attrs.hasFnAttr(
"aarch64_out_za") +
2242 Attrs.hasFnAttr(
"aarch64_preserves_za")) <= 1,
2243 "Attributes 'aarch64_new_za', 'aarch64_in_za', 'aarch64_out_za', "
2244 "'aarch64_inout_za' and 'aarch64_preserves_za' are mutually exclusive",
2248 (
Attrs.hasFnAttr(
"aarch64_new_zt0") +
Attrs.hasFnAttr(
"aarch64_in_zt0") +
2249 Attrs.hasFnAttr(
"aarch64_inout_zt0") +
2250 Attrs.hasFnAttr(
"aarch64_out_zt0") +
2251 Attrs.hasFnAttr(
"aarch64_preserves_zt0")) <= 1,
2252 "Attributes 'aarch64_new_zt0', 'aarch64_in_zt0', 'aarch64_out_zt0', "
2253 "'aarch64_inout_zt0' and 'aarch64_preserves_zt0' are mutually exclusive",
2256 if (
Attrs.hasFnAttr(Attribute::JumpTable)) {
2259 "Attribute 'jumptable' requires 'unnamed_addr'", V);
2262 if (
auto Args =
Attrs.getFnAttrs().getAllocSizeArgs()) {
2264 if (ParamNo >= FT->getNumParams()) {
2265 CheckFailed(
"'allocsize' " +
Name +
" argument is out of bounds", V);
2269 if (!FT->getParamType(ParamNo)->isIntegerTy()) {
2270 CheckFailed(
"'allocsize' " +
Name +
2271 " argument must refer to an integer parameter",
2279 if (!CheckParam(
"element size",
Args->first))
2282 if (
Args->second && !CheckParam(
"number of elements", *
Args->second))
2286 if (
Attrs.hasFnAttr(Attribute::AllocKind)) {
2294 "'allockind()' requires exactly one of alloc, realloc, and free");
2298 CheckFailed(
"'allockind(\"free\")' doesn't allow uninitialized, zeroed, "
2299 "or aligned modifiers.");
2301 if ((K & ZeroedUninit) == ZeroedUninit)
2302 CheckFailed(
"'allockind()' can't be both zeroed and uninitialized");
2305 if (
Attrs.hasFnAttr(Attribute::VScaleRange)) {
2306 unsigned VScaleMin =
Attrs.getFnAttrs().getVScaleRangeMin();
2308 CheckFailed(
"'vscale_range' minimum must be greater than 0", V);
2310 CheckFailed(
"'vscale_range' minimum must be power-of-two value", V);
2311 std::optional<unsigned> VScaleMax =
Attrs.getFnAttrs().getVScaleRangeMax();
2312 if (VScaleMax && VScaleMin > VScaleMax)
2313 CheckFailed(
"'vscale_range' minimum cannot be greater than maximum", V);
2315 CheckFailed(
"'vscale_range' maximum must be power-of-two value", V);
2318 if (
Attrs.hasFnAttr(
"frame-pointer")) {
2320 if (
FP !=
"all" &&
FP !=
"non-leaf" &&
FP !=
"none")
2321 CheckFailed(
"invalid value for 'frame-pointer' attribute: " +
FP, V);
2325 if (MaxParameterWidth >= 512 &&
Attrs.hasFnAttr(
"target-features") &&
2327 StringRef TF =
Attrs.getFnAttr(
"target-features").getValueAsString();
2329 "512-bit vector arguments require 'evex512' for AVX512", V);
2332 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-prefix", V);
2333 checkUnsignedBaseTenFuncAttr(Attrs,
"patchable-function-entry", V);
2334 checkUnsignedBaseTenFuncAttr(Attrs,
"warn-stack-size", V);
2336 if (
auto A =
Attrs.getFnAttr(
"sign-return-address");
A.isValid()) {
2338 if (S !=
"none" && S !=
"all" && S !=
"non-leaf")
2339 CheckFailed(
"invalid value for 'sign-return-address' attribute: " + S, V);
2342 if (
auto A =
Attrs.getFnAttr(
"sign-return-address-key");
A.isValid()) {
2344 if (S !=
"a_key" && S !=
"b_key")
2345 CheckFailed(
"invalid value for 'sign-return-address-key' attribute: " + S,
2349 if (
auto A =
Attrs.getFnAttr(
"branch-target-enforcement");
A.isValid()) {
2351 if (S !=
"true" && S !=
"false")
2353 "invalid value for 'branch-target-enforcement' attribute: " + S, V);
2356 if (
auto A =
Attrs.getFnAttr(
"vector-function-abi-variant");
A.isValid()) {
2360 CheckFailed(
"invalid name for a VFABI variant: " + S, V);
2364void Verifier::verifyFunctionMetadata(
2365 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
2366 for (
const auto &Pair : MDs) {
2367 if (Pair.first == LLVMContext::MD_prof) {
2368 MDNode *MD = Pair.second;
2370 "!prof annotations should have no less than 2 operands", MD);
2373 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null",
2376 "expected string with name of the !prof annotation", MD);
2380 ProfName.
equals(
"synthetic_function_entry_count"),
2381 "first operand should be 'function_entry_count'"
2382 " or 'synthetic_function_entry_count'",
2386 Check(MD->
getOperand(1) !=
nullptr,
"second operand should not be null",
2389 "expected integer argument to function_entry_count", MD);
2390 }
else if (Pair.first == LLVMContext::MD_kcfi_type) {
2391 MDNode *MD = Pair.second;
2393 "!kcfi_type must have exactly one operand", MD);
2394 Check(MD->
getOperand(0) !=
nullptr,
"!kcfi_type operand must not be null",
2397 "expected a constant operand for !kcfi_type", MD);
2399 Check(isa<ConstantInt>(
C) && isa<IntegerType>(
C->getType()),
2400 "expected a constant integer operand for !kcfi_type", MD);
2402 "expected a 32-bit integer constant operand for !kcfi_type", MD);
2407void Verifier::visitConstantExprsRecursively(
const Constant *EntryC) {
2408 if (!ConstantExprVisited.
insert(EntryC).second)
2412 Stack.push_back(EntryC);
2414 while (!
Stack.empty()) {
2418 if (
const auto *CE = dyn_cast<ConstantExpr>(
C))
2419 visitConstantExpr(CE);
2421 if (
const auto *GV = dyn_cast<GlobalValue>(
C)) {
2424 Check(GV->
getParent() == &M,
"Referencing global in another module!",
2430 for (
const Use &U :
C->operands()) {
2431 const auto *OpC = dyn_cast<Constant>(U);
2434 if (!ConstantExprVisited.
insert(OpC).second)
2436 Stack.push_back(OpC);
2441void Verifier::visitConstantExpr(
const ConstantExpr *CE) {
2442 if (
CE->getOpcode() == Instruction::BitCast)
2445 "Invalid bitcast", CE);
2448bool Verifier::verifyAttributeCount(
AttributeList Attrs,
unsigned Params) {
2451 return Attrs.getNumAttrSets() <= Params + 2;
2454void Verifier::verifyInlineAsmCall(
const CallBase &Call) {
2457 unsigned LabelNo = 0;
2468 if (CI.isIndirect) {
2469 const Value *Arg =
Call.getArgOperand(ArgNo);
2471 "Operand for indirect constraint must have pointer type", &Call);
2474 "Operand for indirect constraint must have elementtype attribute",
2477 Check(!
Call.paramHasAttr(ArgNo, Attribute::ElementType),
2478 "Elementtype attribute can only be applied for indirect "
2486 if (
auto *CallBr = dyn_cast<CallBrInst>(&Call)) {
2487 Check(LabelNo == CallBr->getNumIndirectDests(),
2488 "Number of label constraints does not match number of callbr dests",
2491 Check(LabelNo == 0,
"Label constraints can only be used with callbr",
2497void Verifier::verifyStatepoint(
const CallBase &Call) {
2499 Call.getCalledFunction()->getIntrinsicID() ==
2500 Intrinsic::experimental_gc_statepoint);
2502 Check(!
Call.doesNotAccessMemory() && !
Call.onlyReadsMemory() &&
2503 !
Call.onlyAccessesArgMemory(),
2504 "gc.statepoint must read and write all memory to preserve "
2505 "reordering restrictions required by safepoint semantics",
2508 const int64_t NumPatchBytes =
2509 cast<ConstantInt>(
Call.getArgOperand(1))->getSExtValue();
2510 assert(isInt<32>(NumPatchBytes) &&
"NumPatchBytesV is an i32!");
2511 Check(NumPatchBytes >= 0,
2512 "gc.statepoint number of patchable bytes must be "
2516 Type *TargetElemType =
Call.getParamElementType(2);
2517 Check(TargetElemType,
2518 "gc.statepoint callee argument must have elementtype attribute", Call);
2519 FunctionType *TargetFuncType = dyn_cast<FunctionType>(TargetElemType);
2520 Check(TargetFuncType,
2521 "gc.statepoint callee elementtype must be function type", Call);
2523 const int NumCallArgs = cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue();
2524 Check(NumCallArgs >= 0,
2525 "gc.statepoint number of arguments to underlying call "
2528 const int NumParams = (int)TargetFuncType->getNumParams();
2529 if (TargetFuncType->isVarArg()) {
2530 Check(NumCallArgs >= NumParams,
2531 "gc.statepoint mismatch in number of vararg call args", Call);
2534 Check(TargetFuncType->getReturnType()->isVoidTy(),
2535 "gc.statepoint doesn't support wrapping non-void "
2536 "vararg functions yet",
2539 Check(NumCallArgs == NumParams,
2540 "gc.statepoint mismatch in number of call args", Call);
2543 = cast<ConstantInt>(
Call.getArgOperand(4))->getZExtValue();
2545 "unknown flag used in gc.statepoint flags argument", Call);
2550 for (
int i = 0; i < NumParams; i++) {
2551 Type *ParamType = TargetFuncType->getParamType(i);
2552 Type *ArgType =
Call.getArgOperand(5 + i)->getType();
2553 Check(ArgType == ParamType,
2554 "gc.statepoint call argument does not match wrapped "
2558 if (TargetFuncType->isVarArg()) {
2561 "Attribute 'sret' cannot be used for vararg call arguments!", Call);
2565 const int EndCallArgsInx = 4 + NumCallArgs;
2567 const Value *NumTransitionArgsV =
Call.getArgOperand(EndCallArgsInx + 1);
2568 Check(isa<ConstantInt>(NumTransitionArgsV),
2569 "gc.statepoint number of transition arguments "
2570 "must be constant integer",
2572 const int NumTransitionArgs =
2573 cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
2574 Check(NumTransitionArgs == 0,
2575 "gc.statepoint w/inline transition bundle is deprecated", Call);
2576 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
2578 const Value *NumDeoptArgsV =
Call.getArgOperand(EndTransitionArgsInx + 1);
2579 Check(isa<ConstantInt>(NumDeoptArgsV),
2580 "gc.statepoint number of deoptimization arguments "
2581 "must be constant integer",
2583 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
2584 Check(NumDeoptArgs == 0,
2585 "gc.statepoint w/inline deopt operands is deprecated", Call);
2587 const int ExpectedNumArgs = 7 + NumCallArgs;
2588 Check(ExpectedNumArgs == (
int)
Call.arg_size(),
2589 "gc.statepoint too many arguments", Call);
2594 for (
const User *U :
Call.users()) {
2595 const CallInst *UserCall = dyn_cast<const CallInst>(U);
2596 Check(UserCall,
"illegal use of statepoint token", Call, U);
2599 Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
2600 "gc.result or gc.relocate are the only value uses "
2601 "of a gc.statepoint",
2603 if (isa<GCResultInst>(UserCall)) {
2605 "gc.result connected to wrong gc.statepoint", Call, UserCall);
2606 }
else if (isa<GCRelocateInst>(Call)) {
2608 "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
2622void Verifier::verifyFrameRecoverIndices() {
2623 for (
auto &Counts : FrameEscapeInfo) {
2625 unsigned EscapedObjectCount = Counts.second.first;
2626 unsigned MaxRecoveredIndex = Counts.second.second;
2627 Check(MaxRecoveredIndex <= EscapedObjectCount,
2628 "all indices passed to llvm.localrecover must be less than the "
2629 "number of arguments passed to llvm.localescape in the parent "
2637 if (
auto *II = dyn_cast<InvokeInst>(Terminator))
2638 UnwindDest = II->getUnwindDest();
2639 else if (
auto *CSI = dyn_cast<CatchSwitchInst>(Terminator))
2640 UnwindDest = CSI->getUnwindDest();
2642 UnwindDest = cast<CleanupReturnInst>(Terminator)->getUnwindDest();
2646void Verifier::verifySiblingFuncletUnwinds() {
2649 for (
const auto &Pair : SiblingFuncletInfo) {
2651 if (Visited.
count(PredPad))
2657 if (Active.
count(SuccPad)) {
2663 Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
2664 if (CycleTerminator != CyclePad)
2667 }
while (CyclePad != SuccPad);
2668 Check(
false,
"EH pads can't handle each other's exceptions",
2672 if (!Visited.
insert(SuccPad).second)
2676 auto TermI = SiblingFuncletInfo.find(PredPad);
2677 if (TermI == SiblingFuncletInfo.end())
2690void Verifier::visitFunction(
const Function &
F) {
2691 visitGlobalValue(
F);
2695 unsigned NumArgs =
F.arg_size();
2697 Check(&Context == &
F.getContext(),
2698 "Function context does not match Module context!", &
F);
2700 Check(!
F.hasCommonLinkage(),
"Functions may not have common linkage", &
F);
2701 Check(FT->getNumParams() == NumArgs,
2702 "# formal arguments must match # of arguments for function type!", &
F,
2704 Check(
F.getReturnType()->isFirstClassType() ||
2705 F.getReturnType()->isVoidTy() ||
F.getReturnType()->isStructTy(),
2706 "Functions cannot return aggregate values!", &
F);
2708 Check(!
F.hasStructRetAttr() ||
F.getReturnType()->isVoidTy(),
2709 "Invalid struct return type!", &
F);
2713 Check(verifyAttributeCount(Attrs, FT->getNumParams()),
2714 "Attribute after last parameter!", &
F);
2716 CheckDI(
F.IsNewDbgInfoFormat ==
F.getParent()->IsNewDbgInfoFormat,
2717 "Function debug format should match parent module", &
F,
2718 F.IsNewDbgInfoFormat,
F.getParent(),
2719 F.getParent()->IsNewDbgInfoFormat);
2721 bool IsIntrinsic =
F.isIntrinsic();
2724 verifyFunctionAttrs(FT, Attrs, &
F, IsIntrinsic,
false);
2730 "Attribute 'builtin' can only be applied to a callsite.", &
F);
2732 Check(!
Attrs.hasAttrSomewhere(Attribute::ElementType),
2733 "Attribute 'elementtype' can only be applied to a callsite.", &
F);
2738 switch (
F.getCallingConv()) {
2743 Check(
F.arg_empty() ||
Attrs.hasParamAttr(0, Attribute::ByVal),
2744 "Calling convention parameter requires byval", &
F);
2751 Check(
F.getReturnType()->isVoidTy(),
2752 "Calling convention requires void return type", &
F);
2759 Check(!
F.hasStructRetAttr(),
"Calling convention does not allow sret", &
F);
2761 const unsigned StackAS =
DL.getAllocaAddrSpace();
2764 Check(!
Attrs.hasParamAttr(i, Attribute::ByVal),
2765 "Calling convention disallows byval", &
F);
2766 Check(!
Attrs.hasParamAttr(i, Attribute::Preallocated),
2767 "Calling convention disallows preallocated", &
F);
2768 Check(!
Attrs.hasParamAttr(i, Attribute::InAlloca),
2769 "Calling convention disallows inalloca", &
F);
2771 if (
Attrs.hasParamAttr(i, Attribute::ByRef)) {
2774 Check(Arg.getType()->getPointerAddressSpace() != StackAS,
2775 "Calling convention disallows stack byref", &
F);
2789 "Calling convention does not support varargs or "
2790 "perfect forwarding!",
2798 Check(Arg.getType() == FT->getParamType(i),
2799 "Argument value does not match function argument type!", &Arg,
2800 FT->getParamType(i));
2801 Check(Arg.getType()->isFirstClassType(),
2802 "Function arguments must have first-class types!", &Arg);
2804 Check(!Arg.getType()->isMetadataTy(),
2805 "Function takes metadata but isn't an intrinsic", &Arg, &
F);
2806 Check(!Arg.getType()->isTokenTy(),
2807 "Function takes token but isn't an intrinsic", &Arg, &
F);
2808 Check(!Arg.getType()->isX86_AMXTy(),
2809 "Function takes x86_amx but isn't an intrinsic", &Arg, &
F);
2813 if (
Attrs.hasParamAttr(i, Attribute::SwiftError)) {
2814 verifySwiftErrorValue(&Arg);
2820 Check(!
F.getReturnType()->isTokenTy(),
2821 "Function returns a token but isn't an intrinsic", &
F);
2822 Check(!
F.getReturnType()->isX86_AMXTy(),
2823 "Function returns a x86_amx but isn't an intrinsic", &
F);
2828 F.getAllMetadata(MDs);
2829 assert(
F.hasMetadata() != MDs.
empty() &&
"Bit out-of-sync");
2830 verifyFunctionMetadata(MDs);
2833 if (
F.hasPersonalityFn()) {
2834 auto *Per = dyn_cast<Function>(
F.getPersonalityFn()->stripPointerCasts());
2836 Check(Per->getParent() ==
F.getParent(),
2837 "Referencing personality function in another module!", &
F,
2838 F.getParent(), Per, Per->getParent());
2842 BlockEHFuncletColors.
clear();
2844 if (
F.isMaterializable()) {
2846 Check(MDs.
empty(),
"unmaterialized function cannot have metadata", &
F,
2848 }
else if (
F.isDeclaration()) {
2849 for (
const auto &
I : MDs) {
2851 CheckDI(
I.first != LLVMContext::MD_dbg ||
2852 !cast<DISubprogram>(
I.second)->isDistinct(),
2853 "function declaration may only have a unique !dbg attachment",
2855 Check(
I.first != LLVMContext::MD_prof,
2856 "function declaration may not have a !prof attachment", &
F);
2859 visitMDNode(*
I.second, AreDebugLocsAllowed::Yes);
2861 Check(!
F.hasPersonalityFn(),
2862 "Function declaration shouldn't have a personality routine", &
F);
2866 Check(!IsIntrinsic,
"llvm intrinsics cannot be defined!", &
F);
2871 "Entry block to function must not have predecessors!", Entry);
2874 if (Entry->hasAddressTaken()) {
2876 "blockaddress may not be used with the entry block!", Entry);
2879 unsigned NumDebugAttachments = 0, NumProfAttachments = 0,
2880 NumKCFIAttachments = 0;
2882 for (
const auto &
I : MDs) {
2884 auto AllowLocs = AreDebugLocsAllowed::No;
2888 case LLVMContext::MD_dbg: {
2889 ++NumDebugAttachments;
2890 CheckDI(NumDebugAttachments == 1,
2891 "function must have a single !dbg attachment", &
F,
I.second);
2892 CheckDI(isa<DISubprogram>(
I.second),
2893 "function !dbg attachment must be a subprogram", &
F,
I.second);
2894 CheckDI(cast<DISubprogram>(
I.second)->isDistinct(),
2895 "function definition may only have a distinct !dbg attachment",
2898 auto *SP = cast<DISubprogram>(
I.second);
2899 const Function *&AttachedTo = DISubprogramAttachments[SP];
2900 CheckDI(!AttachedTo || AttachedTo == &
F,
2901 "DISubprogram attached to more than one function", SP, &
F);
2903 AllowLocs = AreDebugLocsAllowed::Yes;
2906 case LLVMContext::MD_prof:
2907 ++NumProfAttachments;
2908 Check(NumProfAttachments == 1,
2909 "function must have a single !prof attachment", &
F,
I.second);
2911 case LLVMContext::MD_kcfi_type:
2912 ++NumKCFIAttachments;
2913 Check(NumKCFIAttachments == 1,
2914 "function must have a single !kcfi_type attachment", &
F,
2920 visitMDNode(*
I.second, AllowLocs);
2928 if (
F.isIntrinsic() &&
F.getParent()->isMaterialized()) {
2930 if (
F.hasAddressTaken(&U,
false,
true,
false,
2932 Check(
false,
"Invalid user of intrinsic instruction!", U);
2936 switch (
F.getIntrinsicID()) {
2937 case Intrinsic::experimental_gc_get_pointer_base: {
2939 Check(FT->getNumParams() == 1,
"wrong number of parameters",
F);
2940 Check(isa<PointerType>(
F.getReturnType()),
2941 "gc.get.pointer.base must return a pointer",
F);
2942 Check(FT->getParamType(0) ==
F.getReturnType(),
2943 "gc.get.pointer.base operand and result must be of the same type",
F);
2946 case Intrinsic::experimental_gc_get_pointer_offset: {
2948 Check(FT->getNumParams() == 1,
"wrong number of parameters",
F);
2949 Check(isa<PointerType>(FT->getParamType(0)),
2950 "gc.get.pointer.offset operand must be a pointer",
F);
2951 Check(
F.getReturnType()->isIntegerTy(),
2952 "gc.get.pointer.offset must return integer",
F);
2957 auto *
N =
F.getSubprogram();
2958 HasDebugInfo = (
N !=
nullptr);
2977 CheckDI(Parent && isa<DILocalScope>(Parent),
2978 "DILocation's scope must be a DILocalScope",
N, &
F, &
I,
DL, Parent);
2981 Check(Scope,
"Failed to find DILocalScope",
DL);
2983 if (!Seen.
insert(Scope).second)
2990 if (SP && ((Scope != SP) && !Seen.
insert(SP).second))
2994 "!dbg attachment points at wrong subprogram for function",
N, &
F,
2998 for (
auto &
I : BB) {
2999 VisitDebugLoc(
I,
I.getDebugLoc().getAsMDNode());
3001 if (
auto MD =
I.getMetadata(LLVMContext::MD_loop))
3003 VisitDebugLoc(
I, dyn_cast_or_null<MDNode>(MD->
getOperand(i)));
3004 if (BrokenDebugInfo)
3011void Verifier::visitBasicBlock(
BasicBlock &BB) {
3012 InstsInThisBlock.
clear();
3013 ConvergenceVerifyHelper.
visit(BB);
3020 if (isa<PHINode>(BB.
front())) {
3025 Check(PN.getNumIncomingValues() == Preds.size(),
3026 "PHINode should have one entry for each predecessor of its "
3027 "parent basic block!",
3032 Values.
reserve(PN.getNumIncomingValues());
3033 for (
unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
3035 std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));
3038 for (
unsigned i = 0, e = Values.
size(); i != e; ++i) {
3043 Check(i == 0 || Values[i].first != Values[i - 1].first ||
3044 Values[i].second == Values[i - 1].second,
3045 "PHI node has multiple entries for the same basic block with "
3046 "different incoming values!",
3047 &PN, Values[i].first, Values[i].second, Values[i - 1].second);
3051 Check(Values[i].first == Preds[i],
3052 "PHI node entries do not match predecessors!", &PN,
3053 Values[i].first, Preds[i]);
3061 Check(
I.getParent() == &BB,
"Instruction has bogus parent pointer!");
3064 CheckDI(BB.IsNewDbgInfoFormat == BB.getParent()->IsNewDbgInfoFormat,
3065 "BB debug format should match parent function", &BB,
3066 BB.IsNewDbgInfoFormat, BB.getParent(),
3067 BB.getParent()->IsNewDbgInfoFormat);
3070 if (BB.IsNewDbgInfoFormat)
3071 CheckDI(!BB.getTrailingDbgRecords(),
"Basic Block has trailing DbgRecords!",
3077 Check(&
I ==
I.getParent()->getTerminator(),
3078 "Terminator found in the middle of a basic block!",
I.getParent());
3082void Verifier::visitBranchInst(
BranchInst &BI) {
3085 "Branch condition is not 'i1' type!", &BI, BI.
getCondition());
3090void Verifier::visitReturnInst(
ReturnInst &RI) {
3093 if (
F->getReturnType()->isVoidTy())
3095 "Found return instr that returns non-void in Function of void "
3097 &RI,
F->getReturnType());
3100 "Function return type does not match operand "
3101 "type of return inst!",
3102 &RI,
F->getReturnType());
3109void Verifier::visitSwitchInst(
SwitchInst &SI) {
3110 Check(
SI.getType()->isVoidTy(),
"Switch must have void result type!", &SI);
3113 Type *SwitchTy =
SI.getCondition()->getType();
3115 for (
auto &Case :
SI.cases()) {
3116 Check(isa<ConstantInt>(
SI.getOperand(Case.getCaseIndex() * 2 + 2)),
3117 "Case value is not a constant integer.", &SI);
3118 Check(Case.getCaseValue()->getType() == SwitchTy,
3119 "Switch constants must all be same type as switch value!", &SI);
3121 "Duplicate integer as switch case", &SI, Case.getCaseValue());
3129 "Indirectbr operand must have pointer type!", &BI);
3132 "Indirectbr destinations must all have pointer type!", &BI);
3137void Verifier::visitCallBrInst(
CallBrInst &CBI) {
3138 Check(CBI.
isInlineAsm(),
"Callbr is currently only used for asm-goto!", &CBI);
3140 Check(!
IA->canThrow(),
"Unwinding from Callbr is not allowed");
3142 verifyInlineAsmCall(CBI);
3146void Verifier::visitSelectInst(
SelectInst &SI) {
3149 "Invalid operands for select instruction!", &SI);
3151 Check(
SI.getTrueValue()->getType() ==
SI.getType(),
3152 "Select values must have same type as select instruction!", &SI);
3160 Check(
false,
"User-defined operators should not live outside of a pass!", &
I);
3165 Type *SrcTy =
I.getOperand(0)->getType();
3166 Type *DestTy =
I.getType();
3175 "trunc source and destination must both be a vector or neither", &
I);
3176 Check(SrcBitSize > DestBitSize,
"DestTy too big for Trunc", &
I);
3181void Verifier::visitZExtInst(
ZExtInst &
I) {
3183 Type *SrcTy =
I.getOperand(0)->getType();
3184 Type *DestTy =
I.getType();
3190 "zext source and destination must both be a vector or neither", &
I);
3194 Check(SrcBitSize < DestBitSize,
"Type too small for ZExt", &
I);
3199void Verifier::visitSExtInst(
SExtInst &
I) {
3201 Type *SrcTy =
I.getOperand(0)->getType();
3202 Type *DestTy =
I.getType();
3211 "sext source and destination must both be a vector or neither", &
I);
3212 Check(SrcBitSize < DestBitSize,
"Type too small for SExt", &
I);
3219 Type *SrcTy =
I.getOperand(0)->getType();
3220 Type *DestTy =
I.getType();
3228 "fptrunc source and destination must both be a vector or neither", &
I);
3229 Check(SrcBitSize > DestBitSize,
"DestTy too big for FPTrunc", &
I);
3236 Type *SrcTy =
I.getOperand(0)->getType();
3237 Type *DestTy =
I.getType();
3246 "fpext source and destination must both be a vector or neither", &
I);
3247 Check(SrcBitSize < DestBitSize,
"DestTy too small for FPExt", &
I);
3254 Type *SrcTy =
I.getOperand(0)->getType();
3255 Type *DestTy =
I.getType();
3260 Check(SrcVec == DstVec,
3261 "UIToFP source and dest must both be vector or scalar", &
I);
3263 "UIToFP source must be integer or integer vector", &
I);
3267 if (SrcVec && DstVec)
3268 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3269 cast<VectorType>(DestTy)->getElementCount(),
3270 "UIToFP source and dest vector length mismatch", &
I);
3277 Type *SrcTy =
I.getOperand(0)->getType();
3278 Type *DestTy =
I.getType();
3283 Check(SrcVec == DstVec,
3284 "SIToFP source and dest must both be vector or scalar", &
I);
3286 "SIToFP source must be integer or integer vector", &
I);
3290 if (SrcVec && DstVec)
3291 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3292 cast<VectorType>(DestTy)->getElementCount(),
3293 "SIToFP source and dest vector length mismatch", &
I);
3300 Type *SrcTy =
I.getOperand(0)->getType();
3301 Type *DestTy =
I.getType();
3306 Check(SrcVec == DstVec,
3307 "FPToUI source and dest must both be vector or scalar", &
I);
3310 "FPToUI result must be integer or integer vector", &
I);
3312 if (SrcVec && DstVec)
3313 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3314 cast<VectorType>(DestTy)->getElementCount(),
3315 "FPToUI source and dest vector length mismatch", &
I);
3322 Type *SrcTy =
I.getOperand(0)->getType();
3323 Type *DestTy =
I.getType();
3328 Check(SrcVec == DstVec,
3329 "FPToSI source and dest must both be vector or scalar", &
I);
3332 "FPToSI result must be integer or integer vector", &
I);
3334 if (SrcVec && DstVec)
3335 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3336 cast<VectorType>(DestTy)->getElementCount(),
3337 "FPToSI source and dest vector length mismatch", &
I);
3344 Type *SrcTy =
I.getOperand(0)->getType();
3345 Type *DestTy =
I.getType();
3354 auto *VSrc = cast<VectorType>(SrcTy);
3355 auto *VDest = cast<VectorType>(DestTy);
3356 Check(VSrc->getElementCount() == VDest->getElementCount(),
3357 "PtrToInt Vector width mismatch", &
I);
3365 Type *SrcTy =
I.getOperand(0)->getType();
3366 Type *DestTy =
I.getType();
3374 auto *VSrc = cast<VectorType>(SrcTy);
3375 auto *VDest = cast<VectorType>(DestTy);
3376 Check(VSrc->getElementCount() == VDest->getElementCount(),
3377 "IntToPtr Vector width mismatch", &
I);
3385 "Invalid bitcast", &
I);
3390 Type *SrcTy =
I.getOperand(0)->getType();
3391 Type *DestTy =
I.getType();
3398 "AddrSpaceCast must be between different address spaces", &
I);
3399 if (
auto *SrcVTy = dyn_cast<VectorType>(SrcTy))
3400 Check(SrcVTy->getElementCount() ==
3401 cast<VectorType>(DestTy)->getElementCount(),
3402 "AddrSpaceCast vector pointer number of elements mismatch", &
I);
3408void Verifier::visitPHINode(
PHINode &PN) {
3415 "PHI nodes not grouped at top of basic block!", &PN, PN.
getParent());
3424 "PHI node operands are not the same type as the result!", &PN);
3432void Verifier::visitCallBase(
CallBase &Call) {
3433 Check(
Call.getCalledOperand()->getType()->isPointerTy(),
3434 "Called function must be a pointer!", Call);
3438 if (FTy->isVarArg())
3439 Check(
Call.arg_size() >= FTy->getNumParams(),
3440 "Called function requires more parameters than were provided!", Call);
3442 Check(
Call.arg_size() == FTy->getNumParams(),
3443 "Incorrect number of arguments passed to called function!", Call);
3446 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
3447 Check(
Call.getArgOperand(i)->getType() == FTy->getParamType(i),
3448 "Call parameter type does not match function signature!",
3449 Call.getArgOperand(i), FTy->getParamType(i), Call);
3453 Check(verifyAttributeCount(Attrs,
Call.arg_size()),
3454 "Attribute after last parameter!", Call);
3457 dyn_cast<Function>(
Call.getCalledOperand()->stripPointerCasts());
3461 "Intrinsic called with incompatible signature", Call);
3465 auto CC =
Call.getCallingConv();
3468 "Direct calls to amdgpu_cs_chain/amdgpu_cs_chain_preserve functions "
3469 "not allowed. Please use the @llvm.amdgpu.cs.chain intrinsic instead.",
3472 auto VerifyTypeAlign = [&](
Type *Ty,
const Twine &Message) {
3475 Align ABIAlign =
DL.getABITypeAlign(Ty);
3476 Align MaxAlign(ParamMaxAlignment);
3477 Check(ABIAlign <= MaxAlign,
3478 "Incorrect alignment of " + Message +
" to called function!", Call);
3482 VerifyTypeAlign(FTy->getReturnType(),
"return type");
3483 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3484 Type *Ty = FTy->getParamType(i);
3485 VerifyTypeAlign(Ty,
"argument passed");
3489 if (
Attrs.hasFnAttr(Attribute::Speculatable)) {
3493 "speculatable attribute may not apply to call sites", Call);
3496 if (
Attrs.hasFnAttr(Attribute::Preallocated)) {
3497 Check(
Call.getCalledFunction()->getIntrinsicID() ==
3498 Intrinsic::call_preallocated_arg,
3499 "preallocated as a call site attribute can only be on "
3500 "llvm.call.preallocated.arg");
3504 verifyFunctionAttrs(FTy, Attrs, &Call, IsIntrinsic,
Call.isInlineAsm());
3509 if (
Call.hasInAllocaArgument()) {
3510 Value *InAllocaArg =
Call.getArgOperand(FTy->getNumParams() - 1);
3512 Check(AI->isUsedWithInAlloca(),
3513 "inalloca argument for call has mismatched alloca", AI, Call);
3519 for (
unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3520 if (
Call.paramHasAttr(i, Attribute::SwiftError)) {
3521 Value *SwiftErrorArg =
Call.getArgOperand(i);
3523 Check(AI->isSwiftError(),
3524 "swifterror argument for call has mismatched alloca", AI, Call);
3527 auto ArgI = dyn_cast<Argument>(SwiftErrorArg);
3528 Check(ArgI,
"swifterror argument should come from an alloca or parameter",
3529 SwiftErrorArg, Call);
3530 Check(ArgI->hasSwiftErrorAttr(),
3531 "swifterror argument for call has mismatched parameter", ArgI,
3535 if (
Attrs.hasParamAttr(i, Attribute::ImmArg)) {
3538 Check(Callee &&
Callee->hasParamAttribute(i, Attribute::ImmArg),
3539 "immarg may not apply only to call sites",
Call.getArgOperand(i),
3543 if (
Call.paramHasAttr(i, Attribute::ImmArg)) {
3545 Check(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),
3546 "immarg operand has non-immediate parameter", ArgVal, Call);
3549 if (
Call.paramHasAttr(i, Attribute::Preallocated)) {
3553 bool isMustTail =
Call.isMustTailCall();
3554 Check(hasOB != isMustTail,
3555 "preallocated operand either requires a preallocated bundle or "
3556 "the call to be musttail (but not both)",
3561 if (FTy->isVarArg()) {
3563 bool SawNest =
false;
3564 bool SawReturned =
false;
3566 for (
unsigned Idx = 0;
Idx < FTy->getNumParams(); ++
Idx) {
3567 if (
Attrs.hasParamAttr(
Idx, Attribute::Nest))
3569 if (
Attrs.hasParamAttr(
Idx, Attribute::Returned))
3574 for (
unsigned Idx = FTy->getNumParams();
Idx <
Call.arg_size(); ++
Idx) {
3577 verifyParameterAttrs(ArgAttrs, Ty, &Call);
3580 Check(!SawNest,
"More than one parameter has attribute nest!", Call);
3585 Check(!SawReturned,
"More than one parameter has attribute returned!",
3588 "Incompatible argument and return types for 'returned' "
3596 if (!
Call.getCalledFunction() ||
3597 Call.getCalledFunction()->getIntrinsicID() !=
3598 Intrinsic::experimental_gc_statepoint)
3600 "Attribute 'sret' cannot be used for vararg call arguments!",
3605 "inalloca isn't on the last argument!", Call);
3611 for (
Type *ParamTy : FTy->params()) {
3612 Check(!ParamTy->isMetadataTy(),
3613 "Function has metadata parameter but isn't an intrinsic", Call);
3614 Check(!ParamTy->isTokenTy(),
3615 "Function has token parameter but isn't an intrinsic", Call);
3620 if (!
Call.getCalledFunction()) {
3621 Check(!FTy->getReturnType()->isTokenTy(),
3622 "Return type cannot be token for indirect call!");
3623 Check(!FTy->getReturnType()->isX86_AMXTy(),
3624 "Return type cannot be x86_amx for indirect call!");
3629 visitIntrinsicCall(
ID, Call);
3634 bool FoundDeoptBundle =
false, FoundFuncletBundle =
false,
3635 FoundGCTransitionBundle =
false, FoundCFGuardTargetBundle =
false,
3636 FoundPreallocatedBundle =
false, FoundGCLiveBundle =
false,
3637 FoundPtrauthBundle =
false, FoundKCFIBundle =
false,
3638 FoundAttachedCallBundle =
false;
3639 for (
unsigned i = 0, e =
Call.getNumOperandBundles(); i < e; ++i) {
3643 Check(!FoundDeoptBundle,
"Multiple deopt operand bundles", Call);
3644 FoundDeoptBundle =
true;
3646 Check(!FoundGCTransitionBundle,
"Multiple gc-transition operand bundles",
3648 FoundGCTransitionBundle =
true;
3650 Check(!FoundFuncletBundle,
"Multiple funclet operand bundles", Call);
3651 FoundFuncletBundle =
true;
3653 "Expected exactly one funclet bundle operand", Call);
3655 "Funclet bundle operands should correspond to a FuncletPadInst",
3658 Check(!FoundCFGuardTargetBundle,
"Multiple CFGuardTarget operand bundles",
3660 FoundCFGuardTargetBundle =
true;
3662 "Expected exactly one cfguardtarget bundle operand", Call);
3664 Check(!FoundPtrauthBundle,
"Multiple ptrauth operand bundles", Call);
3665 FoundPtrauthBundle =
true;
3667 "Expected exactly two ptrauth bundle operands", Call);
3669 BU.
Inputs[0]->getType()->isIntegerTy(32),
3670 "Ptrauth bundle key operand must be an i32 constant", Call);
3672 "Ptrauth bundle discriminator operand must be an i64", Call);
3674 Check(!FoundKCFIBundle,
"Multiple kcfi operand bundles", Call);
3675 FoundKCFIBundle =
true;
3676 Check(BU.
Inputs.size() == 1,
"Expected exactly one kcfi bundle operand",
3679 BU.
Inputs[0]->getType()->isIntegerTy(32),
3680 "Kcfi bundle operand must be an i32 constant", Call);
3682 Check(!FoundPreallocatedBundle,
"Multiple preallocated operand bundles",
3684 FoundPreallocatedBundle =
true;
3686 "Expected exactly one preallocated bundle operand", Call);
3687 auto Input = dyn_cast<IntrinsicInst>(BU.
Inputs.front());
3689 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,
3690 "\"preallocated\" argument must be a token from "
3691 "llvm.call.preallocated.setup",
3694 Check(!FoundGCLiveBundle,
"Multiple gc-live operand bundles", Call);
3695 FoundGCLiveBundle =
true;
3697 Check(!FoundAttachedCallBundle,
3698 "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
3699 FoundAttachedCallBundle =
true;
3700 verifyAttachedCallBundle(Call, BU);
3705 Check(!(
Call.getCalledFunction() && FoundPtrauthBundle),
3706 "Direct call cannot have a ptrauth bundle", Call);
3713 if (
Call.getFunction()->getSubprogram() &&
Call.getCalledFunction() &&
3714 !
Call.getCalledFunction()->isInterposable() &&
3715 !
Call.getCalledFunction()->isDeclaration() &&
3716 Call.getCalledFunction()->getSubprogram())
3718 "inlinable function call in a function with "
3719 "debug info must have a !dbg location",
3722 if (
Call.isInlineAsm())
3723 verifyInlineAsmCall(Call);
3725 ConvergenceVerifyHelper.
visit(Call);
3730void Verifier::verifyTailCCMustTailAttrs(
const AttrBuilder &Attrs,
3733 Twine(
"inalloca attribute not allowed in ") + Context);
3735 Twine(
"inreg attribute not allowed in ") + Context);
3736 Check(!
Attrs.contains(Attribute::SwiftError),
3737 Twine(
"swifterror attribute not allowed in ") + Context);
3738 Check(!
Attrs.contains(Attribute::Preallocated),
3739 Twine(
"preallocated attribute not allowed in ") + Context);
3741 Twine(
"byref attribute not allowed in ") + Context);
3753 return PL->getAddressSpace() == PR->getAddressSpace();
3758 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
3759 Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf,
3760 Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated,
3763 for (
auto AK : ABIAttrs) {
3764 Attribute Attr = Attrs.getParamAttrs(
I).getAttribute(AK);
3766 Copy.addAttribute(Attr);
3770 if (Attrs.hasParamAttr(
I, Attribute::Alignment) &&
3771 (Attrs.hasParamAttr(
I, Attribute::ByVal) ||
3772 Attrs.hasParamAttr(
I, Attribute::ByRef)))
3773 Copy.addAlignmentAttr(Attrs.getParamAlignment(
I));
3777void Verifier::verifyMustTailCall(
CallInst &CI) {
3783 Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
3784 "cannot guarantee tail call due to mismatched varargs", &CI);
3786 "cannot guarantee tail call due to mismatched return types", &CI);
3790 "cannot guarantee tail call due to mismatched calling conv", &CI);
3796 Value *RetVal = &CI;
3800 if (
BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
3802 "bitcast following musttail call must use the call", BI);
3809 Check(Ret,
"musttail call must precede a ret with an optional bitcast", &CI);
3810 Check(!
Ret->getReturnValue() ||
Ret->getReturnValue() == RetVal ||
3811 isa<UndefValue>(
Ret->getReturnValue()),
3812 "musttail call result must be returned", Ret);
3823 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3826 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3828 for (
unsigned I = 0, E = CalleeTy->getNumParams();
I != E; ++
I) {
3831 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3834 Check(!CallerTy->isVarArg(),
Twine(
"cannot guarantee ") + CCName +
3835 " tail call for varargs function");
3843 Check(CallerTy->getNumParams() == CalleeTy->getNumParams(),
3844 "cannot guarantee tail call due to mismatched parameter counts", &CI);
3845 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3848 "cannot guarantee tail call due to mismatched parameter types", &CI);
3854 for (
unsigned I = 0, E = CallerTy->getNumParams();
I != E; ++
I) {
3857 Check(CallerABIAttrs == CalleeABIAttrs,
3858 "cannot guarantee tail call due to mismatched ABI impacting "
3859 "function attributes",
3864void Verifier::visitCallInst(
CallInst &CI) {
3868 verifyMustTailCall(CI);
3871void Verifier::visitInvokeInst(
InvokeInst &II) {
3878 "The unwind destination does not have an exception handling instruction!",
3887 Check(
U.getType() ==
U.getOperand(0)->getType(),
3888 "Unary operators must have same type for"
3889 "operands and result!",
3892 switch (
U.getOpcode()) {
3895 case Instruction::FNeg:
3896 Check(
U.getType()->isFPOrFPVectorTy(),
3897 "FNeg operator only works with float types!", &U);
3910 Check(
B.getOperand(0)->getType() ==
B.getOperand(1)->getType(),
3911 "Both operands to a binary operator are not of the same type!", &
B);
3913 switch (
B.getOpcode()) {
3916 case Instruction::Add:
3917 case Instruction::Sub:
3918 case Instruction::Mul:
3919 case Instruction::SDiv:
3920 case Instruction::UDiv:
3921 case Instruction::SRem:
3922 case Instruction::URem:
3923 Check(
B.getType()->isIntOrIntVectorTy(),
3924 "Integer arithmetic operators only work with integral types!", &
B);
3925 Check(
B.getType() ==
B.getOperand(0)->getType(),
3926 "Integer arithmetic operators must have same type "
3927 "for operands and result!",
3932 case Instruction::FAdd:
3933 case Instruction::FSub:
3934 case Instruction::FMul:
3935 case Instruction::FDiv:
3936 case Instruction::FRem:
3937 Check(
B.getType()->isFPOrFPVectorTy(),
3938 "Floating-point arithmetic operators only work with "
3939 "floating-point types!",
3941 Check(
B.getType() ==
B.getOperand(0)->getType(),
3942 "Floating-point arithmetic operators must have same type "
3943 "for operands and result!",
3947 case Instruction::And:
3948 case Instruction::Or:
3949 case Instruction::Xor:
3950 Check(
B.getType()->isIntOrIntVectorTy(),
3951 "Logical operators only work with integral types!", &
B);
3952 Check(
B.getType() ==
B.getOperand(0)->getType(),
3953 "Logical operators must have same type for operands and result!", &
B);
3955 case Instruction::Shl:
3956 case Instruction::LShr:
3957 case Instruction::AShr:
3958 Check(
B.getType()->isIntOrIntVectorTy(),
3959 "Shifts only work with integral types!", &
B);
3960 Check(
B.getType() ==
B.getOperand(0)->getType(),
3961 "Shift return type must be same as operands!", &
B);
3970void Verifier::visitICmpInst(
ICmpInst &IC) {
3974 Check(Op0Ty == Op1Ty,
3975 "Both operands to ICmp instruction are not of the same type!", &IC);
3978 "Invalid operand types for ICmp instruction", &IC);
3985void Verifier::visitFCmpInst(
FCmpInst &FC) {
3987 Type *Op0Ty =
FC.getOperand(0)->getType();
3988 Type *Op1Ty =
FC.getOperand(1)->getType();
3989 Check(Op0Ty == Op1Ty,
3990 "Both operands to FCmp instruction are not of the same type!", &FC);
3995 Check(
FC.isFPPredicate(),
"Invalid predicate in FCmp instruction!", &FC);
4002 "Invalid extractelement operands!", &EI);
4009 "Invalid insertelement operands!", &IE);
4016 "Invalid shufflevector operands!", &SV);
4021 Type *TargetTy =
GEP.getPointerOperandType()->getScalarType();
4023 Check(isa<PointerType>(TargetTy),
4024 "GEP base pointer is not a vector or a vector of pointers", &
GEP);
4025 Check(
GEP.getSourceElementType()->isSized(),
"GEP into unsized type!", &
GEP);
4027 if (
auto *STy = dyn_cast<StructType>(
GEP.getSourceElementType())) {
4030 "getelementptr cannot target structure that contains scalable vector"
4037 all_of(Idxs, [](
Value *V) {
return V->getType()->isIntOrIntVectorTy(); }),
4038 "GEP indexes must be integers", &
GEP);
4041 Check(ElTy,
"Invalid indices for GEP pointer type!", &
GEP);
4043 Check(
GEP.getType()->isPtrOrPtrVectorTy() &&
4044 GEP.getResultElementType() == ElTy,
4045 "GEP is not of right type for indices!", &
GEP, ElTy);
4047 if (
auto *GEPVTy = dyn_cast<VectorType>(
GEP.getType())) {
4050 if (
GEP.getPointerOperandType()->isVectorTy())
4053 cast<VectorType>(
GEP.getPointerOperandType())->getElementCount(),
4054 "Vector GEP result width doesn't match operand's", &
GEP);
4056 Type *IndexTy =
Idx->getType();
4057 if (
auto *IndexVTy = dyn_cast<VectorType>(IndexTy)) {
4059 Check(IndexWidth == GEPWidth,
"Invalid GEP index vector width", &
GEP);
4062 "All GEP indices should be of integer type");
4066 if (
auto *PTy = dyn_cast<PointerType>(
GEP.getType())) {
4067 Check(
GEP.getAddressSpace() == PTy->getAddressSpace(),
4068 "GEP address space doesn't match type", &
GEP);
4075 return A.getUpper() ==
B.getLower() ||
A.getLower() ==
B.getUpper();
4080void Verifier::verifyRangeMetadata(
const Value &
I,
const MDNode *Range,
4081 Type *Ty,
bool IsAbsoluteSymbol) {
4082 unsigned NumOperands =
Range->getNumOperands();
4083 Check(NumOperands % 2 == 0,
"Unfinished range!", Range);
4084 unsigned NumRanges = NumOperands / 2;
4085 Check(NumRanges >= 1,
"It should have at least one range!", Range);
4088 for (
unsigned i = 0; i < NumRanges; ++i) {
4090 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(2 * i));
4091 Check(
Low,
"The lower limit must be an integer!",
Low);
4093 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(2 * i + 1));
4097 "Range types must match instruction type!", &
I);
4105 "The upper and lower limits cannot be the same value", &
I);
4108 Check(!CurRange.isEmptySet() && (IsAbsoluteSymbol || !CurRange.isFullSet()),
4109 "Range must not be empty!", Range);
4111 Check(CurRange.intersectWith(LastRange).isEmptySet(),
4112 "Intervals are overlapping", Range);
4113 Check(LowV.
sgt(LastRange.getLower()),
"Intervals are not in order",
4120 if (NumRanges > 2) {
4122 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(0))->getValue();
4124 mdconst::dyn_extract<ConstantInt>(
Range->getOperand(1))->getValue();
4126 Check(FirstRange.intersectWith(LastRange).isEmptySet(),
4127 "Intervals are overlapping", Range);
4134 assert(Range && Range ==
I.getMetadata(LLVMContext::MD_range) &&
4135 "precondition violation");
4136 verifyRangeMetadata(
I, Range, Ty,
false);
4140 unsigned Size =
DL.getTypeSizeInBits(Ty);
4141 Check(
Size >= 8,
"atomic memory access' size must be byte-sized", Ty,
I);
4143 "atomic memory access' operand must have a power-of-two size", Ty,
I);
4146void Verifier::visitLoadInst(
LoadInst &LI) {
4148 Check(PTy,
"Load operand must be a pointer.", &LI);
4152 "huge alignment values are unsupported", &LI);
4154 Check(ElTy->
isSized(),
"loading unsized types is not allowed", &LI);
4158 "Load cannot have Release ordering", &LI);
4160 "atomic load operand must have integer, pointer, or floating point "
4163 checkAtomicMemAccessSize(ElTy, &LI);
4166 "Non-atomic load cannot have SynchronizationScope specified", &LI);
4172void Verifier::visitStoreInst(
StoreInst &SI) {
4173 PointerType *PTy = dyn_cast<PointerType>(
SI.getOperand(1)->getType());
4174 Check(PTy,
"Store operand must be a pointer.", &SI);
4175 Type *ElTy =
SI.getOperand(0)->getType();
4178 "huge alignment values are unsupported", &SI);
4180 Check(ElTy->
isSized(),
"storing unsized types is not allowed", &SI);
4181 if (
SI.isAtomic()) {
4184 "Store cannot have Acquire ordering", &SI);
4186 "atomic store operand must have integer, pointer, or floating point "
4189 checkAtomicMemAccessSize(ElTy, &SI);
4192 "Non-atomic store cannot have SynchronizationScope specified", &SI);
4198void Verifier::verifySwiftErrorCall(
CallBase &Call,
4199 const Value *SwiftErrorVal) {
4201 if (
I.value() == SwiftErrorVal) {
4202 Check(
Call.paramHasAttr(
I.index(), Attribute::SwiftError),
4203 "swifterror value when used in a callsite should be marked "
4204 "with swifterror attribute",
4205 SwiftErrorVal, Call);
4210void Verifier::verifySwiftErrorValue(
const Value *SwiftErrorVal) {
4213 for (
const User *U : SwiftErrorVal->
users()) {
4214 Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
4216 "swifterror value can only be loaded and stored from, or "
4217 "as a swifterror argument!",
4220 if (
auto StoreI = dyn_cast<StoreInst>(U))
4221 Check(StoreI->getOperand(1) == SwiftErrorVal,
4222 "swifterror value should be the second operand when used "
4225 if (
auto *Call = dyn_cast<CallBase>(U))
4226 verifySwiftErrorCall(*
const_cast<CallBase *
>(Call), SwiftErrorVal);
4230void Verifier::visitAllocaInst(
AllocaInst &AI) {
4233 "Cannot allocate unsized type", &AI);
4235 "Alloca array size must have integer type", &AI);
4238 "huge alignment values are unsupported", &AI);
4243 "swifterror alloca must have pointer type", &AI);
4245 "swifterror alloca must not be array allocation", &AI);
4246 verifySwiftErrorValue(&AI);
4255 "cmpxchg operand must have integer or pointer type", ElTy, &CXI);
4256 checkAtomicMemAccessSize(ElTy, &CXI);
4262 "atomicrmw instructions cannot be unordered.", &RMWI);
4269 " operand must have integer or floating point type!",
4274 " operand must have floating-point or fixed vector of floating-point "
4280 " operand must have integer type!",
4283 checkAtomicMemAccessSize(ElTy, &RMWI);
4285 "Invalid binary operation!", &RMWI);
4289void Verifier::visitFenceInst(
FenceInst &FI) {
4295 "fence instructions may only have acquire, release, acq_rel, or "
4296 "seq_cst ordering.",
4304 "Invalid ExtractValueInst operands!", &EVI);
4313 "Invalid InsertValueInst operands!", &IVI);
4319 if (
auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
4320 return FPI->getParentPad();
4322 return cast<CatchSwitchInst>(EHPad)->getParentPad();
4331 Check(BB != &
F->getEntryBlock(),
"EH pad cannot be in entry block.", &
I);
4333 if (
auto *LPI = dyn_cast<LandingPadInst>(&
I)) {
4338 const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator());
4339 Check(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
4340 "Block containing LandingPadInst must be jumped to "
4341 "only by the unwind edge of an invoke.",
4346 if (
auto *CPI = dyn_cast<CatchPadInst>(&
I)) {
4349 "Block containg CatchPadInst must be jumped to "
4350 "only by its catchswitch.",
4352 Check(BB != CPI->getCatchSwitch()->getUnwindDest(),
4353 "Catchswitch cannot unwind to one of its catchpads",
4354 CPI->getCatchSwitch(), CPI);
4365 if (
auto *II = dyn_cast<InvokeInst>(TI)) {
4366 Check(II->getUnwindDest() == BB && II->getNormalDest() != BB,
4367 "EH pad must be jumped to via an unwind edge", ToPad, II);
4369 dyn_cast<Function>(II->getCalledOperand()->stripPointerCasts());
4370 if (CalledFn && CalledFn->isIntrinsic() && II->doesNotThrow() &&
4374 FromPad = Bundle->Inputs[0];
4377 }
else if (
auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
4378 FromPad = CRI->getOperand(0);
4379 Check(FromPad != ToPadParent,
"A cleanupret must exit its cleanup", CRI);
4380 }
else if (
auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
4383 Check(
false,
"EH pad must be jumped to via an unwind edge", ToPad, TI);
4389 Check(FromPad != ToPad,
4390 "EH pad cannot handle exceptions raised within it", FromPad, TI);
4391 if (FromPad == ToPadParent) {
4395 Check(!isa<ConstantTokenNone>(FromPad),
4396 "A single unwind edge may only enter one EH pad", TI);
4397 Check(Seen.
insert(FromPad).second,
"EH pad jumps through a cycle of pads",
4402 Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
4403 "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
4412 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
4414 visitEHPadPredecessors(LPI);
4416 if (!LandingPadResultTy)
4417 LandingPadResultTy = LPI.
getType();
4420 "The landingpad instruction should have a consistent result type "
4421 "inside a function.",
4425 Check(
F->hasPersonalityFn(),
4426 "LandingPadInst needs to be in a function with a personality.", &LPI);
4431 "LandingPadInst not the first non-PHI instruction in the block.", &LPI);
4437 "Catch operand does not have pointer type!", &LPI);
4439 Check(LPI.
isFilter(i),
"Clause is neither catch nor filter!", &LPI);
4441 "Filter operand is not an array of constants!", &LPI);
4448void Verifier::visitResumeInst(
ResumeInst &RI) {
4450 "ResumeInst needs to be in a function with a personality.", &RI);
4452 if (!LandingPadResultTy)
4456 "The resume instruction should have a consistent result type "
4457 "inside a function.",
4467 Check(
F->hasPersonalityFn(),
4468 "CatchPadInst needs to be in a function with a personality.", &CPI);
4471 "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
4477 "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
4479 visitEHPadPredecessors(CPI);
4485 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
4495 Check(
F->hasPersonalityFn(),
4496 "CleanupPadInst needs to be in a function with a personality.", &CPI);
4501 "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
4504 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
4505 "CleanupPadInst has an invalid parent.", &CPI);
4507 visitEHPadPredecessors(CPI);
4512 User *FirstUser =
nullptr;
4513 Value *FirstUnwindPad =
nullptr;
4517 while (!Worklist.empty()) {
4520 "FuncletPadInst must not be nested within itself", CurrentPad);
4521 Value *UnresolvedAncestorPad =
nullptr;
4524 if (
auto *CRI = dyn_cast<CleanupReturnInst>(U)) {
4525 UnwindDest = CRI->getUnwindDest();
4526 }
else if (
auto *CSI = dyn_cast<CatchSwitchInst>(U)) {
4531 if (CSI->unwindsToCaller())
4533 UnwindDest = CSI->getUnwindDest();
4534 }
else if (
auto *II = dyn_cast<InvokeInst>(U)) {
4535 UnwindDest = II->getUnwindDest();
4536 }
else if (isa<CallInst>(U)) {
4541 }
else if (
auto *CPI = dyn_cast<CleanupPadInst>(U)) {
4545 Worklist.push_back(CPI);
4548 Check(isa<CatchReturnInst>(U),
"Bogus funclet pad use", U);
4556 if (!cast<Instruction>(UnwindPad)->isEHPad())
4560 if (UnwindParent == CurrentPad)
4566 Value *ExitedPad = CurrentPad;
4569 if (ExitedPad == &FPI) {
4574 UnresolvedAncestorPad = &FPI;
4578 if (ExitedParent == UnwindParent) {
4582 UnresolvedAncestorPad = ExitedParent;
4585 ExitedPad = ExitedParent;
4586 }
while (!isa<ConstantTokenNone>(ExitedPad));
4591 UnresolvedAncestorPad = &FPI;
4598 Check(UnwindPad == FirstUnwindPad,
4599 "Unwind edges out of a funclet "
4600 "pad must have the same unwind "
4602 &FPI, U, FirstUser);
4605 FirstUnwindPad = UnwindPad;
4607 if (isa<CleanupPadInst>(&FPI) && !isa<ConstantTokenNone>(UnwindPad) &&
4609 SiblingFuncletInfo[&FPI] = cast<Instruction>(U);
4614 if (CurrentPad != &FPI)
4617 if (UnresolvedAncestorPad) {
4618 if (CurrentPad == UnresolvedAncestorPad) {
4622 assert(CurrentPad == &FPI);
4630 Value *ResolvedPad = CurrentPad;
4631 while (!Worklist.empty()) {
4632 Value *UnclePad = Worklist.back();
4636 while (ResolvedPad != AncestorPad) {
4638 if (ResolvedParent == UnresolvedAncestorPad) {
4641 ResolvedPad = ResolvedParent;
4645 if (ResolvedPad != AncestorPad)
4648 Worklist.pop_back();
4653 if (FirstUnwindPad) {
4654 if (
auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FPI.
getParentPad())) {
4655 BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
4656 Value *SwitchUnwindPad;
4657 if (SwitchUnwindDest)
4661 Check(SwitchUnwindPad == FirstUnwindPad,
4662 "Unwind edges out of a catch must have the same unwind dest as "
4663 "the parent catchswitch",
4664 &FPI, FirstUser, CatchSwitch);
4675 Check(
F->hasPersonalityFn(),
4676 "CatchSwitchInst needs to be in a function with a personality.",
4682 "CatchSwitchInst not the first non-PHI instruction in the block.",
4686 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
4687 "CatchSwitchInst has an invalid parent.", ParentPad);
4691 Check(
I->isEHPad() && !isa<LandingPadInst>(
I),
4692 "CatchSwitchInst must unwind to an EH block which is not a "
4698 SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
4702 "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
4705 Check(isa<CatchPadInst>(Handler->getFirstNonPHI()),
4706 "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
4709 visitEHPadPredecessors(CatchSwitch);
4715 "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
4720 Check(
I->isEHPad() && !isa<LandingPadInst>(
I),
4721 "CleanupReturnInst must unwind to an EH block which is not a "
4729void Verifier::verifyDominatesUse(
Instruction &
I,
unsigned i) {
4735 if (II->getNormalDest() == II->getUnwindDest())
4746 if (!isa<PHINode>(
I) && InstsInThisBlock.
count(
Op))
4749 const Use &
U =
I.getOperandUse(i);
4754 Check(
I.getType()->isPointerTy(),
4755 "dereferenceable, dereferenceable_or_null "
4756 "apply only to pointer types",
4758 Check((isa<LoadInst>(
I) || isa<IntToPtrInst>(
I)),
4759 "dereferenceable, dereferenceable_or_null apply only to load"
4760 " and inttoptr instructions, use attributes for calls or invokes",
4763 "dereferenceable, dereferenceable_or_null "
4764 "take one operand!",
4769 "dereferenceable_or_null metadata value must be an i64!",
4775 "!prof annotations should have no less than 2 operands", MD);
4778 Check(MD->
getOperand(0) !=
nullptr,
"first operand should not be null", MD);
4780 "expected string with name of the !prof annotation", MD);
4785 if (ProfName.
equals(
"branch_weights")) {
4786 if (isa<InvokeInst>(&
I)) {
4788 "Wrong number of InvokeInst branch_weights operands", MD);
4790 unsigned ExpectedNumOperands = 0;
4793 else if (
SwitchInst *SI = dyn_cast<SwitchInst>(&
I))
4794 ExpectedNumOperands =
SI->getNumSuccessors();
4795 else if (isa<CallInst>(&
I))
4796 ExpectedNumOperands = 1;
4798 ExpectedNumOperands = IBI->getNumDestinations();
4799 else if (isa<SelectInst>(&
I))
4800 ExpectedNumOperands = 2;
4801 else if (
CallBrInst *CI = dyn_cast<CallBrInst>(&
I))
4804 CheckFailed(
"!prof branch_weights are not allowed for this instruction",
4808 "Wrong number of operands", MD);
4812 Check(MDO,
"second operand should not be null", MD);
4813 Check(mdconst::dyn_extract<ConstantInt>(MDO),
4814 "!prof brunch_weights operand is not a const int");
4820 assert(
I.hasMetadata(LLVMContext::MD_DIAssignID));
4821 bool ExpectedInstTy =
4822 isa<AllocaInst>(
I) || isa<StoreInst>(
I) || isa<MemIntrinsic>(
I);
4823 CheckDI(ExpectedInstTy,
"!DIAssignID attached to unexpected instruction kind",
4830 "!DIAssignID should only be used by llvm.dbg.assign intrinsics",
4833 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(
User))
4834 CheckDI(DAI->getFunction() ==
I.getFunction(),
4835 "dbg.assign not in same function as inst", DAI, &
I);
4839 cast<DIAssignID>(MD)->getAllDbgVariableRecordUsers()) {
4841 "!DIAssignID should only be used by Assign DVRs.", MD, DVR);
4842 CheckDI(DVR->getFunction() ==
I.getFunction(),
4843 "DVRAssign not in same function as inst", DVR, &
I);
4847void Verifier::visitCallStackMetadata(
MDNode *MD) {
4851 "call stack metadata should have at least 1 operand", MD);
4854 Check(mdconst::dyn_extract_or_null<ConstantInt>(
Op),
4855 "call stack metadata operand should be constant integer",
Op);
4859 Check(isa<CallBase>(
I),
"!memprof metadata should only exist on calls", &
I);
4861 "!memprof annotations should have at least 1 metadata operand "
4866 for (
auto &MIBOp : MD->
operands()) {
4867 MDNode *MIB = dyn_cast<MDNode>(MIBOp);
4872 "Each !memprof MemInfoBlock should have at least 2 operands", MIB);
4876 "!memprof MemInfoBlock first operand should not be null", MIB);
4878 "!memprof MemInfoBlock first operand should be an MDNode", MIB);
4880 visitCallStackMetadata(StackMD);
4884 [](
const MDOperand &
Op) { return isa<MDString>(Op); }),
4885 "Not all !memprof MemInfoBlock operands 1 to N are MDString", MIB);
4890 Check(isa<CallBase>(
I),
"!callsite metadata should only exist on calls", &
I);
4893 visitCallStackMetadata(MD);
4896void Verifier::visitAnnotationMetadata(
MDNode *Annotation) {
4897 Check(isa<MDTuple>(Annotation),
"annotation must be a tuple");
4899 "annotation must have at least one operand");
4901 bool TupleOfStrings =
4902 isa<MDTuple>(
Op.get()) &&
4903 all_of(cast<MDTuple>(
Op)->operands(), [](
auto &Annotation) {
4906 Check(isa<MDString>(
Op.get()) || TupleOfStrings,
4907 "operands must be a string or a tuple of strings");
4911void Verifier::visitAliasScopeMetadata(
const MDNode *MD) {
4913 Check(NumOps >= 2 && NumOps <= 3,
"scope must have two or three operands",
4916 "first scope operand must be self-referential or string", MD);
4919 "third scope operand must be string (if used)", MD);
4922 Check(
Domain !=
nullptr,
"second scope operand must be MDNode", MD);
4924 unsigned NumDomainOps =
Domain->getNumOperands();
4925 Check(NumDomainOps >= 1 && NumDomainOps <= 2,
4926 "domain must have one or two operands",
Domain);
4928 isa<MDString>(
Domain->getOperand(0)),
4929 "first domain operand must be self-referential or string",
Domain);
4930 if (NumDomainOps == 2)
4932 "second domain operand must be string (if used)",
Domain);
4935void Verifier::visitAliasScopeListMetadata(
const MDNode *MD) {
4937 const MDNode *OpMD = dyn_cast<MDNode>(
Op);
4938 Check(OpMD !=
nullptr,
"scope list must consist of MDNodes", MD);
4939 visitAliasScopeMetadata(OpMD);
4943void Verifier::visitAccessGroupMetadata(
const MDNode *MD) {
4944 auto IsValidAccessScope = [](
const MDNode *MD) {
4949 if (IsValidAccessScope(MD))
4954 const MDNode *OpMD = dyn_cast<MDNode>(
Op);
4955 Check(OpMD !=
nullptr,
"Access scope list must consist of MDNodes", MD);
4956 Check(IsValidAccessScope(OpMD),
4957 "Access scope list contains invalid access scope", MD);
4965 Check(BB,
"Instruction not embedded in basic block!", &
I);
4967 if (!isa<PHINode>(
I)) {
4968 for (
User *U :
I.users()) {
4970 "Only PHI nodes may reference their own value!", &
I);
4975 Check(!
I.getType()->isVoidTy() || !
I.hasName(),
4976 "Instruction has a name, but provides a void value!", &
I);
4980 Check(
I.getType()->isVoidTy() ||
I.getType()->isFirstClassType(),
4981 "Instruction returns a non-scalar type!", &
I);
4985 Check(!
I.getType()->isMetadataTy() || isa<CallInst>(
I) || isa<InvokeInst>(
I),
4986 "Invalid use of metadata!", &
I);
4991 for (
Use &U :
I.uses()) {
4992 if (
Instruction *Used = dyn_cast<Instruction>(
U.getUser()))
4994 "Instruction referencing"
4995 " instruction not embedded in a basic block!",
4998 CheckFailed(
"Use of instruction is not an instruction!", U);
5005 const CallBase *CBI = dyn_cast<CallBase>(&
I);
5007 for (
unsigned i = 0, e =
I.getNumOperands(); i != e; ++i) {
5008 Check(
I.getOperand(i) !=
nullptr,
"Instruction has null operand!", &
I);
5012 if (!
I.getOperand(i)->getType()->isFirstClassType()) {
5013 Check(
false,
"Instruction operands must be first-class values!", &
I);
5016 if (
Function *
F = dyn_cast<Function>(
I.getOperand(i))) {
5021 return CBI && CBI->isOperandBundleOfType(
5029 Check((!
F->isIntrinsic() ||
5030 (CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i)) ||
5031 IsAttachedCallOperand(
F, CBI, i)),
5032 "Cannot take the address of an intrinsic!", &
I);
5033 Check(!
F->isIntrinsic() || isa<CallInst>(
I) ||
5034 F->getIntrinsicID() == Intrinsic::donothing ||
5035 F->getIntrinsicID() == Intrinsic::seh_try_begin ||
5036 F->getIntrinsicID() == Intrinsic::seh_try_end ||
5037 F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
5038 F->getIntrinsicID() == Intrinsic::seh_scope_end ||
5039 F->getIntrinsicID() == Intrinsic::coro_resume ||
5040 F->getIntrinsicID() == Intrinsic::coro_destroy ||
5041 F->getIntrinsicID() == Intrinsic::coro_await_suspend_void ||
5042 F->getIntrinsicID() == Intrinsic::coro_await_suspend_bool ||
5043 F->getIntrinsicID() == Intrinsic::coro_await_suspend_handle ||
5044 F->getIntrinsicID() ==
5045 Intrinsic::experimental_patchpoint_void ||
5046 F->getIntrinsicID() == Intrinsic::experimental_patchpoint ||
5047 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
5048 F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
5049 IsAttachedCallOperand(
F, CBI, i),
5050 "Cannot invoke an intrinsic other than donothing, patchpoint, "
5051 "statepoint, coro_resume, coro_destroy or clang.arc.attachedcall",
5053 Check(
F->getParent() == &M,
"Referencing function in another module!", &
I,
5054 &M,
F,
F->getParent());
5055 }
else if (
BasicBlock *OpBB = dyn_cast<BasicBlock>(
I.getOperand(i))) {
5057 "Referring to a basic block in another function!", &
I);
5058 }
else if (
Argument *OpArg = dyn_cast<Argument>(
I.getOperand(i))) {
5060 "Referring to an argument in another function!", &
I);
5061 }
else if (
GlobalValue *GV = dyn_cast<GlobalValue>(
I.getOperand(i))) {
5062 Check(GV->
getParent() == &M,
"Referencing global in another module!", &
I,
5064 }
else if (
Instruction *OpInst = dyn_cast<Instruction>(
I.getOperand(i))) {
5066 "Referring to an instruction in another function!", &
I);
5067 verifyDominatesUse(
I, i);
5068 }
else if (isa<InlineAsm>(
I.getOperand(i))) {
5069 Check(CBI && &CBI->getCalledOperandUse() == &
I.getOperandUse(i),
5070 "Cannot take the address of an inline asm!", &
I);
5071 }
else if (
ConstantExpr *CE = dyn_cast<ConstantExpr>(
I.getOperand(i))) {
5072 if (
CE->getType()->isPtrOrPtrVectorTy()) {
5075 visitConstantExprsRecursively(CE);
5080 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_fpmath)) {
5081 Check(
I.getType()->isFPOrFPVectorTy(),
5082 "fpmath requires a floating point result!", &
I);
5085 mdconst::dyn_extract_or_null<ConstantFP>(MD->
getOperand(0))) {
5086 const APFloat &Accuracy = CFP0->getValueAPF();
5088 "fpmath accuracy must have float type", &
I);
5090 "fpmath accuracy not a positive number!", &
I);
5092 Check(
false,
"invalid fpmath accuracy!", &
I);
5096 if (
MDNode *Range =
I.getMetadata(LLVMContext::MD_range)) {
5097 Check(isa<LoadInst>(
I) || isa<CallInst>(
I) || isa<InvokeInst>(
I),
5098 "Ranges are only for loads, calls and invokes!", &
I);
5099 visitRangeMetadata(
I, Range,
I.getType());
5102 if (
I.hasMetadata(LLVMContext::MD_invariant_group)) {
5103 Check(isa<LoadInst>(
I) || isa<StoreInst>(
I),
5104 "invariant.group metadata is only for loads and stores", &
I);
5107 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_nonnull)) {
5108 Check(
I.getType()->isPointerTy(),
"nonnull applies only to pointer types",
5111 "nonnull applies only to load instructions, use attributes"
5112 " for calls or invokes",
5117 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_dereferenceable))
5118 visitDereferenceableMetadata(
I, MD);
5120 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
5121 visitDereferenceableMetadata(
I, MD);
5123 if (
MDNode *TBAA =
I.getMetadata(LLVMContext::MD_tbaa))
5126 if (
MDNode *TBAA =
I.getMetadata(LLVMContext::MD_tbaa_struct))
5129 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_noalias))
5130 visitAliasScopeListMetadata(MD);
5131 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_alias_scope))
5132 visitAliasScopeListMetadata(MD);
5134 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_access_group))
5135 visitAccessGroupMetadata(MD);
5137 if (
MDNode *AlignMD =
I.getMetadata(LLVMContext::MD_align)) {
5138 Check(
I.getType()->isPointerTy(),
"align applies only to pointer types",
5141 "align applies only to load instructions, "
5142 "use attributes for calls or invokes",
5144 Check(AlignMD->getNumOperands() == 1,
"align takes one operand!", &
I);
5145 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
5147 "align metadata value must be an i64!", &
I);
5152 "alignment is larger that implementation defined limit", &
I);
5155 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_prof))
5156 visitProfMetadata(
I, MD);
5158 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_memprof))
5159 visitMemProfMetadata(
I, MD);
5161 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_callsite))
5162 visitCallsiteMetadata(
I, MD);
5164 if (
MDNode *MD =
I.getMetadata(LLVMContext::MD_DIAssignID))
5165 visitDIAssignIDMetadata(
I, MD);
5167 if (
MDNode *Annotation =
I.getMetadata(LLVMContext::MD_annotation))
5168 visitAnnotationMetadata(Annotation);
5170 if (
MDNode *
N =
I.getDebugLoc().getAsMDNode()) {
5171 CheckDI(isa<DILocation>(
N),
"invalid !dbg metadata attachment", &
I,
N);
5172 visitMDNode(*
N, AreDebugLocsAllowed::Yes);
5175 if (
auto *DII = dyn_cast<DbgVariableIntrinsic>(&
I)) {
5176 verifyFragmentExpression(*DII);
5177 verifyNotEntryValue(*DII);
5181 I.getAllMetadata(MDs);
5182 for (
auto Attachment : MDs) {
5183 unsigned Kind = Attachment.first;
5185 (
Kind == LLVMContext::MD_dbg ||
Kind == LLVMContext::MD_loop)
5186 ? AreDebugLocsAllowed::Yes
5187 : AreDebugLocsAllowed::No;
5188 visitMDNode(*Attachment.second, AllowLocs);
5197 Check(
IF->isDeclaration(),
"Intrinsic functions should never be defined!",
5203 bool IsVarArg = IFTy->isVarArg();
5214 "Intrinsic has incorrect return type!", IF);
5216 "Intrinsic has incorrect argument type!", IF);
5221 "Intrinsic was not defined with variable arguments!", IF);
5224 "Callsite was not defined with variable arguments!", IF);
5233 const std::string ExpectedName =
5235 Check(ExpectedName ==
IF->getName(),
5236 "Intrinsic name not mangled correctly for type arguments! "
5244 if (
auto *MD = dyn_cast<MetadataAsValue>(V))
5245 visitMetadataAsValue(*MD,
Call.getCaller());
5246 if (
auto *Const = dyn_cast<Constant>(V))
5248 "const x86_amx is not allowed in argument!");
5254 case Intrinsic::assume: {
5255 for (
auto &Elem :
Call.bundle_op_infos()) {
5256 unsigned ArgCount = Elem.End - Elem.Begin;
5259 if (Elem.Tag->getKey() ==
"separate_storage") {
5260 Check(ArgCount == 2,
5261 "separate_storage assumptions should have 2 arguments", Call);
5262 Check(
Call.getOperand(Elem.Begin)->getType()->isPointerTy() &&
5263 Call.getOperand(Elem.Begin + 1)->getType()->isPointerTy(),
5264 "arguments to separate_storage assumptions should be pointers",
5268 Check(Elem.Tag->getKey() ==
"ignore" ||
5270 "tags must be valid attribute names", Call);
5273 if (Kind == Attribute::Alignment) {
5274 Check(ArgCount <= 3 && ArgCount >= 2,
5275 "alignment assumptions should have 2 or 3 arguments", Call);
5276 Check(
Call.getOperand(Elem.Begin)->getType()->isPointerTy(),
5277 "first argument should be a pointer", Call);
5278 Check(
Call.getOperand(Elem.Begin + 1)->getType()->isIntegerTy(),
5279 "second argument should be an integer", Call);
5281 Check(
Call.getOperand(Elem.Begin + 2)->getType()->isIntegerTy(),
5282 "third argument should be an integer if present", Call);
5285 Check(ArgCount <= 2,
"too many arguments", Call);
5289 Check(ArgCount == 2,
"this attribute should have 2 arguments", Call);
5290 Check(isa<ConstantInt>(
Call.getOperand(Elem.Begin + 1)),
5291 "the second argument should be a constant integral value", Call);
5293 Check((ArgCount) == 1,
"this attribute should have one argument", Call);
5295 Check((ArgCount) == 0,
"this attribute has no argument", Call);
5300 case Intrinsic::ucmp:
5301 case Intrinsic::scmp: {
5302 Type *SrcTy =
Call.getOperand(0)->getType();
5306 "result type must be at least 2 bits wide", Call);
5308 bool IsDestTypeVector = DestTy->
isVectorTy();
5310 "ucmp/scmp argument and result types must both be either vector or "
5313 if (IsDestTypeVector) {
5314 auto SrcVecLen = cast<VectorType>(SrcTy)->getElementCount();
5315 auto DestVecLen = cast<VectorType>(DestTy)->getElementCount();
5316 Check(SrcVecLen == DestVecLen,
5317 "return type and arguments must have the same number of "
5323 case Intrinsic::coro_id: {
5324 auto *InfoArg =
Call.getArgOperand(3)->stripPointerCasts();
5325 if (isa<ConstantPointerNull>(InfoArg))
5327 auto *GV = dyn_cast<GlobalVariable>(InfoArg);
5329 "info argument of llvm.coro.id must refer to an initialized "
5332 Check(isa<ConstantStruct>(
Init) || isa<ConstantArray>(
Init),
5333 "info argument of llvm.coro.id must refer to either a struct or "
5337 case Intrinsic::is_fpclass: {
5340 "unsupported bits for llvm.is.fpclass test mask");
5343 case Intrinsic::fptrunc_round: {
5346 auto *MAV = dyn_cast<MetadataAsValue>(
Call.getOperand(1));
5348 MD = MAV->getMetadata();
5350 Check(MD !=
nullptr,
"missing rounding mode argument", Call);
5352 Check(isa<MDString>(MD),
5353 (
"invalid value for llvm.fptrunc.round metadata operand"
5354 " (the operand should be a string)"),
5357 std::optional<RoundingMode> RoundMode =
5360 "unsupported rounding mode argument", Call);
5363#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
5364#include "llvm/IR/VPIntrinsics.def"
5365 visitVPIntrinsic(cast<VPIntrinsic>(Call));
5367#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
5368 case Intrinsic::INTRINSIC:
5369#include "llvm/IR/ConstrainedOps.def"
5370 visitConstrainedFPIntrinsic(cast<ConstrainedFPIntrinsic>(Call));
5372 case Intrinsic::dbg_declare:
5373 Check(isa<MetadataAsValue>(
Call.getArgOperand(0)),
5374 "invalid llvm.dbg.declare intrinsic call 1", Call);
5375 visitDbgIntrinsic(
"declare", cast<DbgVariableIntrinsic>(Call));
5377 case Intrinsic::dbg_value:
5378 visitDbgIntrinsic(
"value", cast<DbgVariableIntrinsic>(Call));
5380 case Intrinsic::dbg_assign:
5381 visitDbgIntrinsic(
"assign", cast<DbgVariableIntrinsic>(Call));
5383 case Intrinsic::dbg_label:
5384 visitDbgLabelIntrinsic(
"label", cast<DbgLabelInst>(Call));
5386 case Intrinsic::memcpy:
5387 case Intrinsic::memcpy_inline:
5388 case Intrinsic::memmove:
5389 case Intrinsic::memset:
5390 case Intrinsic::memset_inline: {
5393 case Intrinsic::memcpy_element_unordered_atomic:
5394 case Intrinsic::memmove_element_unordered_atomic:
5395 case Intrinsic::memset_element_unordered_atomic: {
5396 const auto *AMI = cast<AtomicMemIntrinsic>(&Call);
5399 cast<ConstantInt>(AMI->getRawElementSizeInBytes());
5402 "element size of the element-wise atomic memory intrinsic "
5403 "must be a power of 2",
5406 auto IsValidAlignment = [&](
MaybeAlign Alignment) {
5407 return Alignment && ElementSizeVal.
ule(Alignment->value());
5409 Check(IsValidAlignment(AMI->getDestAlign()),
5410 "incorrect alignment of the destination argument", Call);
5411 if (
const auto *AMT = dyn_cast<AtomicMemTransferInst>(AMI)) {
5412 Check(IsValidAlignment(AMT->getSourceAlign()),
5413 "incorrect alignment of the source argument", Call);
5417 case Intrinsic::call_preallocated_setup: {
5418 auto *NumArgs = dyn_cast<ConstantInt>(
Call.getArgOperand(0));
5419 Check(NumArgs !=
nullptr,
5420 "llvm.call.preallocated.setup argument must be a constant");
5421 bool FoundCall =
false;
5423 auto *UseCall = dyn_cast<CallBase>(U);
5424 Check(UseCall !=
nullptr,
5425 "Uses of llvm.call.preallocated.setup must be calls");
5426 const Function *Fn = UseCall->getCalledFunction();
5427 if (Fn && Fn->
getIntrinsicID() == Intrinsic::call_preallocated_arg) {
5428 auto *AllocArgIndex = dyn_cast<ConstantInt>(UseCall->getArgOperand(1));
5429 Check(AllocArgIndex !=
nullptr,
5430 "llvm.call.preallocated.alloc arg index must be a constant");
5431 auto AllocArgIndexInt = AllocArgIndex->getValue();
5432 Check(AllocArgIndexInt.sge(0) &&
5433 AllocArgIndexInt.slt(NumArgs->getValue()),
5434 "llvm.call.preallocated.alloc arg index must be between 0 and "
5436 "llvm.call.preallocated.setup's argument count");
5438 Intrinsic::call_preallocated_teardown) {
5441 Check(!FoundCall,
"Can have at most one call corresponding to a "
5442 "llvm.call.preallocated.setup");
5444 size_t NumPreallocatedArgs = 0;
5445 for (
unsigned i = 0; i < UseCall->arg_size(); i++) {
5446 if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
5447 ++NumPreallocatedArgs;
5450 Check(NumPreallocatedArgs != 0,
5451 "cannot use preallocated intrinsics on a call without "
5452 "preallocated arguments");
5453 Check(NumArgs->equalsInt(NumPreallocatedArgs),
5454 "llvm.call.preallocated.setup arg size must be equal to number "
5455 "of preallocated arguments "
5465 auto PreallocatedBundle =
5467 Check(PreallocatedBundle,
5468 "Use of llvm.call.preallocated.setup outside intrinsics "
5469 "must be in \"preallocated\" operand bundle");
5470 Check(PreallocatedBundle->Inputs.front().get() == &Call,
5471 "preallocated bundle must have token from corresponding "
5472 "llvm.call.preallocated.setup");
5477 case Intrinsic::call_preallocated_arg: {
5478 auto *Token = dyn_cast<CallBase>(
Call.getArgOperand(0));
5479 Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
5480 Intrinsic::call_preallocated_setup,
5481 "llvm.call.preallocated.arg token argument must be a "
5482 "llvm.call.preallocated.setup");
5483 Check(
Call.hasFnAttr(Attribute::Preallocated),
5484 "llvm.call.preallocated.arg must be called with a \"preallocated\" "
5485 "call site attribute");
5488 case Intrinsic::call_preallocated_teardown: {
5489 auto *Token = dyn_cast<CallBase>(
Call.getArgOperand(0));
5490 Check(Token && Token->getCalledFunction()->getIntrinsicID() ==
5491 Intrinsic::call_preallocated_setup,
5492 "llvm.call.preallocated.teardown token argument must be a "
5493 "llvm.call.preallocated.setup");
5496 case Intrinsic::gcroot:
5497 case Intrinsic::gcwrite:
5498 case Intrinsic::gcread:
5499 if (
ID == Intrinsic::gcroot) {
5501 dyn_cast<AllocaInst>(
Call.getArgOperand(0)->stripPointerCasts());
5502 Check(AI,
"llvm.gcroot parameter #1 must be an alloca.", Call);
5503 Check(isa<Constant>(
Call.getArgOperand(1)),
5504 "llvm.gcroot parameter #2 must be a constant.", Call);
5506 Check(!isa<ConstantPointerNull>(
Call.getArgOperand(1)),
5507 "llvm.gcroot parameter #1 must either be a pointer alloca, "
5508 "or argument #2 must be a non-null constant.",
5513 Check(
Call.getParent()->getParent()->hasGC(),
5514 "Enclosing function does not use GC.", Call);
5516 case Intrinsic::init_trampoline:
5517 Check(isa<Function>(
Call.getArgOperand(1)->stripPointerCasts()),
5518 "llvm.init_trampoline parameter #2 must resolve to a function.",
5521 case Intrinsic::prefetch:
5522 Check(cast<ConstantInt>(
Call.getArgOperand(1))->getZExtValue() < 2,
5523 "rw argument to llvm.prefetch must be 0-1", Call);
5524 Check(cast<ConstantInt>(
Call.getArgOperand(2))->getZExtValue() < 4,
5525 "locality argument to llvm.prefetch must be 0-3", Call);
5526 Check(cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue() < 2,
5527 "cache type argument to llvm.prefetch must be 0-1", Call);
5529 case Intrinsic::stackprotector:
5530 Check(isa<AllocaInst>(
Call.getArgOperand(1)->stripPointerCasts()),
5531 "llvm.stackprotector parameter #2 must resolve to an alloca.", Call);
5533 case Intrinsic::localescape: {
5537 Check(!SawFrameEscape,
"multiple calls to llvm.localescape in one function",
5540 if (isa<ConstantPointerNull>(Arg))
5542 auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
5544 "llvm.localescape only accepts static allocas", Call);
5547 SawFrameEscape =
true;
5550 case Intrinsic::localrecover: {
5551 Value *FnArg =
Call.getArgOperand(0)->stripPointerCasts();
5552 Function *Fn = dyn_cast<Function>(FnArg);
5554 "llvm.localrecover first "
5555 "argument must be function defined in this module",
5557 auto *IdxArg = cast<ConstantInt>(
Call.getArgOperand(2));
5558 auto &Entry = FrameEscapeInfo[Fn];
5560 std::max(
uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));
5564 case Intrinsic::experimental_gc_statepoint:
5565 if (
auto *CI = dyn_cast<CallInst>(&Call))
5566 Check(!CI->isInlineAsm(),
5567 "gc.statepoint support for inline assembly unimplemented", CI);
5568 Check(
Call.getParent()->getParent()->hasGC(),
5569 "Enclosing function does not use GC.", Call);
5571 verifyStatepoint(Call);
5573 case Intrinsic::experimental_gc_result: {
5574 Check(
Call.getParent()->getParent()->hasGC(),
5575 "Enclosing function does not use GC.", Call);
5577 auto *Statepoint =
Call.getArgOperand(0);
5578 if (isa<UndefValue>(Statepoint))
5582 const auto *StatepointCall = dyn_cast<CallBase>(Statepoint);
5584 StatepointCall ? StatepointCall->getCalledFunction() :
nullptr;
5587 Intrinsic::experimental_gc_statepoint,
5588 "gc.result operand #1 must be from a statepoint", Call,
5589 Call.getArgOperand(0));
5592 auto *TargetFuncType =
5593 cast<FunctionType>(StatepointCall->getParamElementType(2));
5594 Check(
Call.getType() == TargetFuncType->getReturnType(),
5595 "gc.result result type does not match wrapped callee", Call);
5598 case Intrinsic::experimental_gc_relocate: {
5599 Check(
Call.arg_size() == 3,
"wrong number of arguments", Call);
5601 Check(isa<PointerType>(
Call.getType()->getScalarType()),
5602 "gc.relocate must return a pointer or a vector of pointers", Call);
5608 dyn_cast<LandingPadInst>(
Call.getArgOperand(0))) {
5611 LandingPad->
getParent()->getUniquePredecessor();
5615 Check(InvokeBB,
"safepoints should have unique landingpads",
5616 LandingPad->getParent());
5620 "gc relocate should be linked to a statepoint", InvokeBB);
5625 auto *Token =
Call.getArgOperand(0);
5626 Check(isa<GCStatepointInst>(Token) || isa<UndefValue>(Token),
5627 "gc relocate is incorrectly tied to the statepoint", Call, Token);
5631 const Value &StatepointCall = *cast<GCRelocateInst>(Call).getStatepoint();
5636 "gc.relocate operand #2 must be integer offset", Call);
5639 Check(isa<ConstantInt>(Derived),
5640 "gc.relocate operand #3 must be integer offset", Call);
5642 const uint64_t BaseIndex = cast<ConstantInt>(
Base)->getZExtValue();
5643 const uint64_t DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
5646 if (isa<UndefValue>(StatepointCall))
5648 if (
auto Opt = cast<GCStatepointInst>(StatepointCall)
5650 Check(BaseIndex < Opt->Inputs.size(),
5651 "gc.relocate: statepoint base index out of bounds", Call);
5652 Check(DerivedIndex < Opt->Inputs.size(),
5653 "gc.relocate: statepoint derived index out of bounds", Call);
5661 auto *ResultType =
Call.getType();
5666 "gc.relocate: relocated value must be a pointer", Call);
5667 Check(DerivedType->isPtrOrPtrVectorTy(),
5668 "gc.relocate: relocated value must be a pointer", Call);
5670 Check(ResultType->isVectorTy() == DerivedType->isVectorTy(),
5671 "gc.relocate: vector relocates to vector and pointer to pointer",
5674 ResultType->getPointerAddressSpace() ==
5675 DerivedType->getPointerAddressSpace(),
5676 "gc.relocate: relocating a pointer shouldn't change its address space",
5680 Check(GC,
"gc.relocate: calling function must have GCStrategy",
5681 Call.getFunction());
5683 auto isGCPtr = [&
GC](
Type *PTy) {
5684 return GC->isGCManagedPointer(PTy->getScalarType()).value_or(
true);
5686 Check(isGCPtr(ResultType),
"gc.relocate: must return gc pointer", Call);
5688 "gc.relocate: relocated value must be a gc pointer", Call);
5689 Check(isGCPtr(DerivedType),
5690 "gc.relocate: relocated value must be a gc pointer", Call);
5694 case Intrinsic::experimental_patchpoint: {
5696 Check(
Call.getType()->isSingleValueType(),
5697 "patchpoint: invalid return type used with anyregcc", Call);
5701 case Intrinsic::eh_exceptioncode:
5702 case Intrinsic::eh_exceptionpointer: {
5703 Check(isa<CatchPadInst>(
Call.getArgOperand(0)),
5704 "eh.exceptionpointer argument must be a catchpad", Call);
5707 case Intrinsic::get_active_lane_mask: {
5709 "get_active_lane_mask: must return a "
5712 auto *ElemTy =
Call.getType()->getScalarType();
5713 Check(ElemTy->isIntegerTy(1),
5714 "get_active_lane_mask: element type is not "
5719 case Intrinsic::experimental_get_vector_length: {
5722 "get_vector_length: VF must be positive", Call);
5725 case Intrinsic::masked_load: {
5726 Check(
Call.getType()->isVectorTy(),
"masked_load: must return a vector",
5731 Value *PassThru =
Call.getArgOperand(3);
5732 Check(
Mask->getType()->isVectorTy(),
"masked_load: mask must be vector",
5735 "masked_load: alignment must be a power of 2", Call);
5737 "masked_load: pass through and return type must match", Call);
5738 Check(cast<VectorType>(
Mask->getType())->getElementCount() ==
5739 cast<VectorType>(
Call.getType())->getElementCount(),
5740 "masked_load: vector mask must be same length as return", Call);
5743 case Intrinsic::masked_store: {
5747 Check(
Mask->getType()->isVectorTy(),
"masked_store: mask must be vector",
5750 "masked_store: alignment must be a power of 2", Call);
5751 Check(cast<VectorType>(
Mask->getType())->getElementCount() ==
5752 cast<VectorType>(Val->
getType())->getElementCount(),
5753 "masked_store: vector mask must be same length as value", Call);
5757 case Intrinsic::masked_gather: {
5758 const APInt &Alignment =
5761 "masked_gather: alignment must be 0 or a power of 2", Call);
5764 case Intrinsic::masked_scatter: {
5765 const APInt &Alignment =
5766 cast<ConstantInt>(
Call.getArgOperand(2))->getValue();
5768 "masked_scatter: alignment must be 0 or a power of 2", Call);
5772 case Intrinsic::experimental_guard: {
5773 Check(isa<CallInst>(Call),
"experimental_guard cannot be invoked", Call);
5775 "experimental_guard must have exactly one "
5776 "\"deopt\" operand bundle");
5780 case Intrinsic::experimental_deoptimize: {
5781 Check(isa<CallInst>(Call),
"experimental_deoptimize cannot be invoked",
5784 "experimental_deoptimize must have exactly one "
5785 "\"deopt\" operand bundle");
5786 Check(
Call.getType() ==
Call.getFunction()->getReturnType(),
5787 "experimental_deoptimize return type must match caller return type");
5789 if (isa<CallInst>(Call)) {
5790 auto *RI = dyn_cast<ReturnInst>(
Call.getNextNode());
5792 "calls to experimental_deoptimize must be followed by a return");
5794 if (!
Call.getType()->isVoidTy() && RI)
5795 Check(RI->getReturnValue() == &Call,
5796 "calls to experimental_deoptimize must be followed by a return "
5797 "of the value computed by experimental_deoptimize");
5802 case Intrinsic::vastart: {
5804 "va_start called in a non-varargs function");
5807 case Intrinsic::vector_reduce_and:
5808 case Intrinsic::vector_reduce_or:
5809 case Intrinsic::vector_reduce_xor:
5810 case Intrinsic::vector_reduce_add:
5811 case Intrinsic::vector_reduce_mul:
5812 case Intrinsic::vector_reduce_smax:
5813 case Intrinsic::vector_reduce_smin:
5814 case Intrinsic::vector_reduce_umax:
5815 case Intrinsic::vector_reduce_umin: {
5816 Type *ArgTy =
Call.getArgOperand(0)->getType();
5818 "Intrinsic has incorrect argument type!");
5821 case Intrinsic::vector_reduce_fmax:
5822 case Intrinsic::vector_reduce_fmin: {
5823 Type *ArgTy =
Call.getArgOperand(0)->getType();
5825 "Intrinsic has incorrect argument type!");
5828 case Intrinsic::vector_reduce_fadd:
5829 case Intrinsic::vector_reduce_fmul: {
5832 Type *ArgTy =
Call.getArgOperand(1)->getType();
5834 "Intrinsic has incorrect argument type!");
5837 case Intrinsic::smul_fix:
5838 case Intrinsic::smul_fix_sat:
5839 case Intrinsic::umul_fix:
5840 case Intrinsic::umul_fix_sat:
5841 case Intrinsic::sdiv_fix:
5842 case Intrinsic::sdiv_fix_sat:
5843 case Intrinsic::udiv_fix:
5844 case Intrinsic::udiv_fix_sat: {
5848 "first operand of [us][mul|div]_fix[_sat] must be an int type or "
5851 "second operand of [us][mul|div]_fix[_sat] must be an int type or "
5854 auto *Op3 = cast<ConstantInt>(
Call.getArgOperand(2));
5855 Check(Op3->getType()->isIntegerTy(),
5856 "third operand of [us][mul|div]_fix[_sat] must be an int type");
5857 Check(Op3->getBitWidth() <= 32,
5858 "third operand of [us][mul|div]_fix[_sat] must fit within 32 bits");
5860 if (
ID == Intrinsic::smul_fix ||
ID == Intrinsic::smul_fix_sat ||
5861 ID == Intrinsic::sdiv_fix ||
ID == Intrinsic::sdiv_fix_sat) {
5863 "the scale of s[mul|div]_fix[_sat] must be less than the width of "
5867 "the scale of u[mul|div]_fix[_sat] must be less than or equal "
5868 "to the width of the operands");
5872 case Intrinsic::lrint:
5873 case Intrinsic::llrint: {
5874 Type *ValTy =
Call.getArgOperand(0)->getType();
5878 "llvm.lrint, llvm.llrint: argument must be floating-point or vector "
5879 "of floating-points, and result must be integer or vector of integers",
5882 "llvm.lrint, llvm.llrint: argument and result disagree on vector use",
5885 Check(cast<VectorType>(ValTy)->getElementCount() ==
5886 cast<VectorType>(ResultTy)->getElementCount(),
5887 "llvm.lrint, llvm.llrint: argument must be same length as result",
5892 case Intrinsic::lround:
5893 case Intrinsic::llround: {
5894 Type *ValTy =
Call.getArgOperand(0)->getType();
5897 "Intrinsic does not support vectors", &Call);
5900 case Intrinsic::bswap: {
5903 Check(
Size % 16 == 0,
"bswap must be an even number of bytes", &Call);
5906 case Intrinsic::invariant_start: {
5907 ConstantInt *InvariantSize = dyn_cast<ConstantInt>(
Call.getArgOperand(0));
5908 Check(InvariantSize &&
5910 "invariant_start parameter must be -1, 0 or a positive number",
5914 case Intrinsic::matrix_multiply:
5915 case Intrinsic::matrix_transpose:
5916 case Intrinsic::matrix_column_major_load:
5917 case Intrinsic::matrix_column_major_store: {
5923 Type *Op0ElemTy =
nullptr;
5924 Type *Op1ElemTy =
nullptr;
5926 case Intrinsic::matrix_multiply: {
5927 NumRows = cast<ConstantInt>(
Call.getArgOperand(2));
5929 NumColumns = cast<ConstantInt>(
Call.getArgOperand(4));
5930 Check(cast<FixedVectorType>(
Call.getArgOperand(0)->getType())
5931 ->getNumElements() ==
5933 "First argument of a matrix operation does not match specified "
5935 Check(cast<FixedVectorType>(
Call.getArgOperand(1)->getType())
5936 ->getNumElements() ==
5938 "Second argument of a matrix operation does not match specified "
5941 ResultTy = cast<VectorType>(
Call.getType());
5943 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
5945 cast<VectorType>(
Call.getArgOperand(1)->getType())->getElementType();
5948 case Intrinsic::matrix_transpose:
5949 NumRows = cast<ConstantInt>(
Call.getArgOperand(1));
5950 NumColumns = cast<ConstantInt>(
Call.getArgOperand(2));
5951 ResultTy = cast<VectorType>(
Call.getType());
5953 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
5955 case Intrinsic::matrix_column_major_load: {
5956 Stride = dyn_cast<ConstantInt>(
Call.getArgOperand(1));
5957 NumRows = cast<ConstantInt>(
Call.getArgOperand(3));
5958 NumColumns = cast<ConstantInt>(
Call.getArgOperand(4));
5959 ResultTy = cast<VectorType>(
Call.getType());
5962 case Intrinsic::matrix_column_major_store: {
5963 Stride = dyn_cast<ConstantInt>(
Call.getArgOperand(2));
5964 NumRows = cast<ConstantInt>(
Call.getArgOperand(4));
5965 NumColumns = cast<ConstantInt>(
Call.getArgOperand(5));
5966 ResultTy = cast<VectorType>(
Call.getArgOperand(0)->getType());
5968 cast<VectorType>(
Call.getArgOperand(0)->getType())->getElementType();
5975 Check(ResultTy->getElementType()->isIntegerTy() ||
5976 ResultTy->getElementType()->isFloatingPointTy(),
5977 "Result type must be an integer or floating-point type!", IF);
5980 Check(ResultTy->getElementType() == Op0ElemTy,
5981 "Vector element type mismatch of the result and first operand "
5986 Check(ResultTy->getElementType() == Op1ElemTy,
5987 "Vector element type mismatch of the result and second operand "
5991 Check(cast<FixedVectorType>(ResultTy)->getNumElements() ==
5993 "Result of a matrix operation does not fit in the returned vector!");
5997 "Stride must be greater or equal than the number of rows!", IF);
6001 case Intrinsic::experimental_vector_splice: {
6003 int64_t
Idx = cast<ConstantInt>(
Call.getArgOperand(2))->getSExtValue();
6004 int64_t KnownMinNumElements = VecTy->getElementCount().getKnownMinValue();
6005 if (
Call.getParent() &&
Call.getParent()->getParent()) {
6007 if (
Attrs.hasFnAttr(Attribute::VScaleRange))
6008 KnownMinNumElements *=
Attrs.getFnAttrs().getVScaleRangeMin();
6010 Check((
Idx < 0 && std::abs(
Idx) <= KnownMinNumElements) ||
6011 (
Idx >= 0 &&
Idx < KnownMinNumElements),
6012 "The splice index exceeds the range [-VL, VL-1] where VL is the "
6013 "known minimum number of elements in the vector. For scalable "
6014 "vectors the minimum number of elements is determined from "
6019 case Intrinsic::experimental_stepvector: {
6021 Check(VecTy && VecTy->getScalarType()->isIntegerTy() &&
6022 VecTy->getScalarSizeInBits() >= 8,
6023 "experimental_stepvector only supported for vectors of integers "
6024 "with a bitwidth of at least 8.",
6028 case Intrinsic::vector_insert: {
6032 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6039 Check(VecTy->getElementType() == SubVecTy->getElementType(),
6040 "vector_insert parameters must have the same element "
6044 "vector_insert index must be a constant multiple of "
6045 "the subvector's known minimum vector length.");
6053 "subvector operand of vector_insert would overrun the "
6054 "vector being inserted into.");
6058 case Intrinsic::vector_extract: {
6061 unsigned IdxN = cast<ConstantInt>(
Idx)->getZExtValue();
6069 Check(ResultTy->getElementType() == VecTy->getElementType(),
6070 "vector_extract result must have the same element "
6071 "type as the input vector.",
6074 "vector_extract index must be a constant multiple of "
6075 "the result type's known minimum vector length.");
6083 "vector_extract would overrun.");
6087 case Intrinsic::experimental_noalias_scope_decl: {
6088 NoAliasScopeDecls.
push_back(cast<IntrinsicInst>(&Call));
6091 case Intrinsic::preserve_array_access_index:
6092 case Intrinsic::preserve_struct_access_index:
6093 case Intrinsic::aarch64_ldaxr:
6094 case Intrinsic::aarch64_ldxr:
6095 case Intrinsic::arm_ldaex:
6096 case Intrinsic::arm_ldrex: {
6097 Type *ElemTy =
Call.getParamElementType(0);
6098 Check(ElemTy,
"Intrinsic requires elementtype attribute on first argument.",
6102 case Intrinsic::aarch64_stlxr:
6103 case Intrinsic::aarch64_stxr:
6104 case Intrinsic::arm_stlex:
6105 case Intrinsic::arm_strex: {
6106 Type *ElemTy =
Call.getAttributes().getParamElementType(1);
6108 "Intrinsic requires elementtype attribute on second argument.",
6112 case Intrinsic::aarch64_prefetch: {
6113 Check(cast<ConstantInt>(
Call.getArgOperand(1))->getZExtValue() < 2,
6114 "write argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6115 Check(cast<ConstantInt>(
Call.getArgOperand(2))->getZExtValue() < 4,
6116 "target argument to llvm.aarch64.prefetch must be 0-3", Call);
6117 Check(cast<ConstantInt>(
Call.getArgOperand(3))->getZExtValue() < 2,
6118 "stream argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6119 Check(cast<ConstantInt>(
Call.getArgOperand(4))->getZExtValue() < 2,
6120 "isdata argument to llvm.aarch64.prefetch must be 0 or 1", Call);
6123 case Intrinsic::callbr_landingpad: {
6124 const auto *CBR = dyn_cast<CallBrInst>(
Call.getOperand(0));
6125 Check(CBR,
"intrinstic requires callbr operand", &Call);
6132 CheckFailed(
"Intrinsic in block must have 1 unique predecessor", &Call);
6136 CheckFailed(
"Intrinsic must have corresponding callbr in predecessor",
6142 return IndDest == LandingPadBB;
6144 "Intrinsic's corresponding callbr must have intrinsic's parent basic "
6145 "block in indirect destination list",
6148 Check(&
First == &Call,
"No other instructions may proceed intrinsic",
6152 case Intrinsic::amdgcn_cs_chain: {
6153 auto CallerCC =
Call.getCaller()->getCallingConv();
6160 CheckFailed(
"Intrinsic can only be used from functions with the "
6161 "amdgpu_cs, amdgpu_cs_chain or amdgpu_cs_chain_preserve "
6162 "calling conventions",
6167 Check(
Call.paramHasAttr(2, Attribute::InReg),
6168 "SGPR arguments must have the `inreg` attribute", &Call);
6169 Check(!
Call.paramHasAttr(3, Attribute::InReg),
6170 "VGPR arguments must not have the `inreg` attribute", &Call);
6173 case Intrinsic::amdgcn_set_inactive_chain_arg: {
6174 auto CallerCC =
Call.getCaller()->getCallingConv();
6180 CheckFailed(
"Intrinsic can only be used from functions with the "
6181 "amdgpu_cs_chain or amdgpu_cs_chain_preserve "
6182 "calling conventions",
6187 unsigned InactiveIdx = 1;
6188 Check(!
Call.paramHasAttr(InactiveIdx, Attribute::InReg),
6189 "Value for inactive lanes must not have the `inreg` attribute",
6191 Check(isa<Argument>(
Call.getArgOperand(InactiveIdx)),
6192 "Value for inactive lanes must be a function argument", &Call);
6193 Check(!cast<Argument>(
Call.getArgOperand(InactiveIdx))->hasInRegAttr(),
6194 "Value for inactive lanes must be a VGPR function argument", &Call);
6197 case Intrinsic::nvvm_setmaxnreg_inc_sync_aligned_u32:
6198 case Intrinsic::nvvm_setmaxnreg_dec_sync_aligned_u32: {
6200 unsigned RegCount = cast<ConstantInt>(V)->getZExtValue();
6201 Check(RegCount % 8 == 0,
6202 "reg_count argument to nvvm.setmaxnreg must be in multiples of 8");
6203 Check((RegCount >= 24 && RegCount <= 256),
6204 "reg_count argument to nvvm.setmaxnreg must be within [24, 256]");
6207 case Intrinsic::experimental_convergence_entry:
6209 case Intrinsic::experimental_convergence_anchor:
6211 case Intrinsic::experimental_convergence_loop:
6213 case Intrinsic::ptrmask: {
6214 Type *Ty0 =
Call.getArgOperand(0)->getType();
6215 Type *Ty1 =
Call.getArgOperand(1)->getType();
6217 "llvm.ptrmask intrinsic first argument must be pointer or vector "
6222 "llvm.ptrmask intrinsic arguments must be both scalars or both vectors",
6225 Check(cast<VectorType>(Ty0)->getElementCount() ==
6226 cast<VectorType>(Ty1)->getElementCount(),
6227 "llvm.ptrmask intrinsic arguments must have the same number of "
6231 "llvm.ptrmask intrinsic second argument bitwidth must match "
6232 "pointer index type size of first argument",
6236 case Intrinsic::threadlocal_address: {
6237 const Value &Arg0 = *
Call.getArgOperand(0);
6238 Check(isa<GlobalValue>(Arg0),
6239 "llvm.threadlocal.address first argument must be a GlobalValue");
6240 Check(cast<GlobalValue>(Arg0).isThreadLocal(),
6241 "llvm.threadlocal.address operand isThreadLocal() must be true");
6249 if (
F->hasPersonalityFn() &&
6253 if (BlockEHFuncletColors.
empty())
6257 bool InEHFunclet =
false;
6262 if (dyn_cast_or_null<FuncletPadInst>(ColorFirstBB->getFirstNonPHI()))
6266 bool HasToken =
false;
6267 for (
unsigned I = 0, E =
Call.getNumOperandBundles();
I != E; ++
I)
6273 Check(HasToken,
"Missing funclet token on intrinsic call", &Call);
6286 if (
auto *SP = dyn_cast<DISubprogram>(LocalScope))
6289 if (
auto *LB = dyn_cast<DILexicalBlockBase>(LocalScope))
6293 assert(!isa<DILocalScope>(LocalScope) &&
"Unknown type of local scope");
6299 "invalid #dbg_label intrinsic variable", &DLR, DLR.
getRawLabel());
6303 if (!isa<DILocation>(
N))
6312 CheckDI(Loc,
"#dbg_label record requires a !dbg attachment", &DLR, BB,
F);
6316 if (!LabelSP || !LocSP)
6320 "mismatched subprogram between #dbg_label label and !dbg attachment",
6321 &DLR, BB,
F, Label,
Label->getScope()->getSubprogram(), Loc,
6322 Loc->getScope()->getSubprogram());
6332 "invalid #dbg record type", &DVR, DVR.
getType());
6338 CheckDI(MD && (isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
6339 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands())),
6340 "invalid #dbg record address/value", &DVR, MD);
6341 if (
auto *VAM = dyn_cast<ValueAsMetadata>(MD))
6342 visitValueAsMetadata(*VAM,
F);
6343 else if (
auto *AL = dyn_cast<DIArgList>(MD))
6344 visitDIArgList(*AL,
F);
6358 AreDebugLocsAllowed::No);
6365 isa<ValueAsMetadata>(RawAddr) ||
6366 (isa<MDNode>(RawAddr) && !cast<MDNode>(RawAddr)->getNumOperands()),
6368 if (
auto *VAM = dyn_cast<ValueAsMetadata>(RawAddr))
6369 visitValueAsMetadata(*VAM,
F);
6372 "invalid #dbg_assign address expression", &DVR,
6379 "inst not in same function as #dbg_assign",
I, &DVR);
6388 CheckDI(isa_and_nonnull<DILocation>(DLNode),
"invalid #dbg record DILocation",
6395 if (!VarSP || !LocSP)
6399 "mismatched subprogram between #dbg record variable and DILocation",
6401 Loc->getScope()->getSubprogram());
6406void Verifier::visitVPIntrinsic(
VPIntrinsic &VPI) {
6407 if (
auto *VPCast = dyn_cast<VPCastIntrinsic>(&VPI)) {
6408 auto *
RetTy = cast<VectorType>(VPCast->getType());
6409 auto *ValTy = cast<VectorType>(VPCast->getOperand(0)->getType());
6410 Check(
RetTy->getElementCount() == ValTy->getElementCount(),
6411 "VP cast intrinsic first argument and result vector lengths must be "
6415 switch (VPCast->getIntrinsicID()) {
6418 case Intrinsic::vp_trunc:
6420 "llvm.vp.trunc intrinsic first argument and result element type "
6424 "llvm.vp.trunc intrinsic the bit size of first argument must be "
6425 "larger than the bit size of the return type",
6428 case Intrinsic::vp_zext:
6429 case Intrinsic::vp_sext:
6431 "llvm.vp.zext or llvm.vp.sext intrinsic first argument and result "
6432 "element type must be integer",
6435 "llvm.vp.zext or llvm.vp.sext intrinsic the bit size of first "
6436 "argument must be smaller than the bit size of the return type",
6439 case Intrinsic::vp_fptoui:
6440 case Intrinsic::vp_fptosi:
6441 case Intrinsic::vp_lrint:
6442 case Intrinsic::vp_llrint:
6445 "llvm.vp.fptoui, llvm.vp.fptosi, llvm.vp.lrint or llvm.vp.llrint" "intrinsic first argument element "
6446 "type must be floating-point and result element type must be integer",
6449 case Intrinsic::vp_uitofp:
6450 case Intrinsic::vp_sitofp:
6453 "llvm.vp.uitofp or llvm.vp.sitofp intrinsic first argument element "
6454 "type must be integer and result element type must be floating-point",
6457 case Intrinsic::vp_fptrunc:
6459 "llvm.vp.fptrunc intrinsic first argument and result element type "
6460 "must be floating-point",
6463 "llvm.vp.fptrunc intrinsic the bit size of first argument must be "
6464 "larger than the bit size of the return type",
6467 case Intrinsic::vp_fpext:
6469 "llvm.vp.fpext intrinsic first argument and result element type "
6470 "must be floating-point",
6473 "llvm.vp.fpext intrinsic the bit size of first argument must be "
6474 "smaller than the bit size of the return type",
6477 case Intrinsic::vp_ptrtoint:
6479 "llvm.vp.ptrtoint intrinsic first argument element type must be "
6480 "pointer and result element type must be integer",
6483 case Intrinsic::vp_inttoptr:
6485 "llvm.vp.inttoptr intrinsic first argument element type must be "
6486 "integer and result element type must be pointer",
6492 auto Pred = cast<VPCmpIntrinsic>(&VPI)->getPredicate();
6494 "invalid predicate for VP FP comparison intrinsic", &VPI);
6497 auto Pred = cast<VPCmpIntrinsic>(&VPI)->getPredicate();
6499 "invalid predicate for VP integer comparison intrinsic", &VPI);
6502 auto TestMask = cast<ConstantInt>(VPI.
getOperand(1));
6504 "unsupported bits for llvm.vp.is.fpclass test mask");
6509 unsigned NumOperands;
6512#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
6513 case Intrinsic::INTRINSIC: \
6514 NumOperands = NARG; \
6515 HasRoundingMD = ROUND_MODE; \
6517#include "llvm/IR/ConstrainedOps.def"
6521 NumOperands += (1 + HasRoundingMD);
6523 if (isa<ConstrainedFPCmpIntrinsic>(FPI))
6526 "invalid arguments for constrained FP intrinsic", &FPI);
6529 case Intrinsic::experimental_constrained_lrint:
6530 case Intrinsic::experimental_constrained_llrint: {
6534 "Intrinsic does not support vectors", &FPI);
6538 case Intrinsic::experimental_constrained_lround:
6539 case Intrinsic::experimental_constrained_llround: {
6543 "Intrinsic does not support vectors", &FPI);
6547 case Intrinsic::experimental_constrained_fcmp:
6548 case Intrinsic::experimental_constrained_fcmps: {
6549 auto Pred = cast<ConstrainedFPCmpIntrinsic>(&FPI)->getPredicate();
6551 "invalid predicate for constrained FP comparison intrinsic", &FPI);
6555 case Intrinsic::experimental_constrained_fptosi:
6556 case Intrinsic::experimental_constrained_fptoui: {
6560 "Intrinsic first argument must be floating point", &FPI);
6561 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6562 SrcEC = cast<VectorType>(OperandT)->getElementCount();
6567 "Intrinsic first argument and result disagree on vector use", &FPI);
6569 "Intrinsic result must be an integer", &FPI);
6570 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6571 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
6572 "Intrinsic first argument and result vector lengths must be equal",
6578 case Intrinsic::experimental_constrained_sitofp:
6579 case Intrinsic::experimental_constrained_uitofp: {
6583 "Intrinsic first argument must be integer", &FPI);
6584 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6585 SrcEC = cast<VectorType>(OperandT)->getElementCount();
6590 "Intrinsic first argument and result disagree on vector use", &FPI);
6592 "Intrinsic result must be a floating point", &FPI);
6593 if (
auto *OperandT = dyn_cast<VectorType>(Operand->
getType())) {
6594 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
6595 "Intrinsic first argument and result vector lengths must be equal",
6600 case Intrinsic::experimental_constrained_fptrunc:
6601 case Intrinsic::experimental_constrained_fpext: {
6607 "Intrinsic first argument must be FP or FP vector", &FPI);
6609 "Intrinsic result must be FP or FP vector", &FPI);
6611 "Intrinsic first argument and result disagree on vector use", &FPI);
6613 Check(cast<VectorType>(OperandTy)->getElementCount() ==
6614 cast<VectorType>(ResultTy)->getElementCount(),
6615 "Intrinsic first argument and result vector lengths must be equal",
6618 if (FPI.
getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
6620 "Intrinsic first argument's type must be larger than result type",
6624 "Intrinsic first argument's type must be smaller than result type",
6640 "invalid exception behavior argument", &FPI);
6641 if (HasRoundingMD) {
6649 CheckDI(isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
6650 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
6651 "invalid llvm.dbg." + Kind +
" intrinsic address/value", &DII, MD);
6653 "invalid llvm.dbg." + Kind +
" intrinsic variable", &DII,
6656 "invalid llvm.dbg." + Kind +
" intrinsic expression", &DII,
6659 if (
auto *DAI = dyn_cast<DbgAssignIntrinsic>(&DII)) {
6660 CheckDI(isa<DIAssignID>(DAI->getRawAssignID()),
6661 "invalid llvm.dbg.assign intrinsic DIAssignID", &DII,
6662 DAI->getRawAssignID());
6663 const auto *RawAddr = DAI->getRawAddress();
6665 isa<ValueAsMetadata>(RawAddr) ||
6666 (isa<MDNode>(RawAddr) && !cast<MDNode>(RawAddr)->getNumOperands()),
6667 "invalid llvm.dbg.assign intrinsic address", &DII,
6668 DAI->getRawAddress());
6669 CheckDI(isa<DIExpression>(DAI->getRawAddressExpression()),
6670 "invalid llvm.dbg.assign intrinsic address expression", &DII,
6671 DAI->getRawAddressExpression());
6674 CheckDI(DAI->getFunction() ==
I->getFunction(),
6675 "inst not in same function as dbg.assign",
I, DAI);
6680 if (!isa<DILocation>(
N))
6689 CheckDI(Loc,
"llvm.dbg." + Kind +
" intrinsic requires a !dbg attachment",
6694 if (!VarSP || !LocSP)
6698 "mismatched subprogram between llvm.dbg." + Kind +
6699 " variable and !dbg attachment",
6701 Loc->getScope()->getSubprogram());
6711 "invalid llvm.dbg." + Kind +
" intrinsic variable", &DLI,
6716 if (!isa<DILocation>(
N))
6725 Check(Loc,
"llvm.dbg." + Kind +
" intrinsic requires a !dbg attachment", &DLI,
6730 if (!LabelSP || !LocSP)
6734 "mismatched subprogram between llvm.dbg." + Kind +
6735 " label and !dbg attachment",
6736 &DLI, BB,
F, Label,
Label->getScope()->getSubprogram(), Loc,
6737 Loc->getScope()->getSubprogram());
6742 DIExpression *E = dyn_cast_or_null<DIExpression>(
I.getRawExpression());
6745 if (!V || !E || !E->
isValid())
6759 if (
V->isArtificial())
6762 verifyFragmentExpression(*V, *Fragment, &
I);
6769 if (!V || !E || !E->
isValid())
6783 if (
V->isArtificial())
6786 verifyFragmentExpression(*V, *Fragment, &DVR);
6789template <
typename ValueOrMetadata>
6790void Verifier::verifyFragmentExpression(
const DIVariable &V,
6792 ValueOrMetadata *
Desc) {
6795 auto VarSize =
V.getSizeInBits();
6801 CheckDI(FragSize + FragOffset <= *VarSize,
6802 "fragment is larger than or outside of variable",
Desc, &V);
6803 CheckDI(FragSize != *VarSize,
"fragment covers entire variable",
Desc, &V);
6814 if (
I.getDebugLoc()->getInlinedAt())
6818 CheckDI(Var,
"dbg intrinsic without variable");
6820 unsigned ArgNo = Var->
getArg();
6826 if (DebugFnArgs.
size() < ArgNo)
6827 DebugFnArgs.
resize(ArgNo,
nullptr);
6829 auto *Prev = DebugFnArgs[ArgNo - 1];
6830 DebugFnArgs[ArgNo - 1] = Var;
6831 CheckDI(!Prev || (Prev == Var),
"conflicting debug info for argument", &
I,
6846 CheckDI(Var,
"#dbg record without variable");
6848 unsigned ArgNo = Var->
getArg();
6854 if (DebugFnArgs.
size() < ArgNo)
6855 DebugFnArgs.
resize(ArgNo,
nullptr);
6857 auto *Prev = DebugFnArgs[ArgNo - 1];
6858 DebugFnArgs[ArgNo - 1] = Var;
6859 CheckDI(!Prev || (Prev == Var),
"conflicting debug info for argument", &DVR,
6864 DIExpression *E = dyn_cast_or_null<DIExpression>(
I.getRawExpression());
6870 if (isa<ValueAsMetadata>(
I.getRawLocation())) {
6871 Value *VarValue =
I.getVariableLocationOp(0);
6872 if (isa<UndefValue>(VarValue) || isa<PoisonValue>(VarValue))
6876 if (
auto *ArgLoc = dyn_cast_or_null<Argument>(VarValue);
6877 ArgLoc && ArgLoc->hasAttribute(Attribute::SwiftAsync))
6882 "Entry values are only allowed in MIR unless they target a "
6883 "swiftasync Argument",
6895 if (isa<UndefValue>(VarValue) || isa<PoisonValue>(VarValue))
6899 if (
auto *ArgLoc = dyn_cast_or_null<Argument>(VarValue);
6900 ArgLoc && ArgLoc->hasAttribute(Attribute::SwiftAsync))
6905 "Entry values are only allowed in MIR unless they target a "
6906 "swiftasync Argument",
6910void Verifier::verifyCompileUnits() {
6914 if (
M.getContext().isODRUniquingDebugTypes())
6916 auto *CUs =
M.getNamedMetadata(
"llvm.dbg.cu");
6919 Listed.
insert(CUs->op_begin(), CUs->op_end());
6920 for (
const auto *
CU : CUVisited)
6925void Verifier::verifyDeoptimizeCallingConvs() {
6926 if (DeoptimizeDeclarations.
empty())
6930 for (
const auto *
F :
ArrayRef(DeoptimizeDeclarations).slice(1)) {
6931 Check(
First->getCallingConv() ==
F->getCallingConv(),
6932 "All llvm.experimental.deoptimize declarations must have the same "
6933 "calling convention",
6938void Verifier::verifyAttachedCallBundle(
const CallBase &Call,
6942 Check((FTy->getReturnType()->isPointerTy() ||
6943 (
Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),
6944 "a call with operand bundle \"clang.arc.attachedcall\" must call a "
6945 "function returning a pointer or a non-returning function that has a "
6950 "operand bundle \"clang.arc.attachedcall\" requires one function as "
6954 auto *Fn = cast<Function>(BU.
Inputs.front());
6958 Check((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
6959 IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue),
6960 "invalid function argument", Call);
6963 Check((FnName ==
"objc_retainAutoreleasedReturnValue" ||
6964 FnName ==
"objc_unsafeClaimAutoreleasedReturnValue"),
6965 "invalid function argument", Call);
6969void Verifier::verifyNoAliasScopeDecl() {
6970 if (NoAliasScopeDecls.
empty())
6974 for (
auto *II : NoAliasScopeDecls) {
6975 assert(II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl &&
6976 "Not a llvm.experimental.noalias.scope.decl ?");
6977 const auto *ScopeListMV = dyn_cast<MetadataAsValue>(
6979 Check(ScopeListMV !=
nullptr,
6980 "llvm.experimental.noalias.scope.decl must have a MetadataAsValue "
6984 const auto *ScopeListMD = dyn_cast<MDNode>(ScopeListMV->getMetadata());
6985 Check(ScopeListMD !=
nullptr,
"!id.scope.list must point to an MDNode", II);
6986 Check(ScopeListMD->getNumOperands() == 1,
6987 "!id.scope.list must point to a list with a single scope", II);
6988 visitAliasScopeListMetadata(ScopeListMD);
6999 const auto *ScopeListMV = cast<MetadataAsValue>(
7001 return &cast<MDNode>(ScopeListMV->getMetadata())->getOperand(0);
7007 return GetScope(Lhs) < GetScope(Rhs);
7014 auto ItCurrent = NoAliasScopeDecls.begin();
7015 while (ItCurrent != NoAliasScopeDecls.end()) {
7016 auto CurScope = GetScope(*ItCurrent);
7017 auto ItNext = ItCurrent;
7020 }
while (ItNext != NoAliasScopeDecls.end() &&
7021 GetScope(*ItNext) == CurScope);
7026 if (ItNext - ItCurrent < 32)
7031 "llvm.experimental.noalias.scope.decl dominates another one "
7032 "with the same scope",
7050 return !V.verify(
F);
7054 bool *BrokenDebugInfo) {
7058 bool Broken =
false;
7060 Broken |= !V.verify(
F);
7062 Broken |= !V.verify();
7063 if (BrokenDebugInfo)
7064 *BrokenDebugInfo = V.hasBrokenDebugInfo();
7075 std::unique_ptr<Verifier> V;
7076 bool FatalErrors =
true;
7081 explicit VerifierLegacyPass(
bool FatalErrors)
7083 FatalErrors(FatalErrors) {
7087 bool doInitialization(
Module &M)
override {
7088 V = std::make_unique<Verifier>(
7094 if (!
V->verify(
F) && FatalErrors) {
7095 errs() <<
"in function " <<
F.getName() <<
'\n';
7101 bool doFinalization(
Module &M)
override {
7102 bool HasErrors =
false;
7104 if (
F.isDeclaration())
7105 HasErrors |= !
V->verify(
F);
7107 HasErrors |= !
V->verify();
7108 if (FatalErrors && (HasErrors ||
V->hasBrokenDebugInfo()))
7121template <
typename... Tys>
void TBAAVerifier::CheckFailed(Tys &&... Args) {
7126#define CheckTBAA(C, ...) \
7129 CheckFailed(__VA_ARGS__); \
7137TBAAVerifier::TBAABaseNodeSummary
7141 CheckFailed(
"Base nodes must have at least two operands", &
I, BaseNode);
7145 auto Itr = TBAABaseNodes.find(BaseNode);
7146 if (Itr != TBAABaseNodes.end())
7149 auto Result = verifyTBAABaseNodeImpl(
I, BaseNode, IsNewFormat);
7150 auto InsertResult = TBAABaseNodes.insert({BaseNode, Result});
7152 assert(InsertResult.second &&
"We just checked!");
7156TBAAVerifier::TBAABaseNodeSummary
7159 const TBAAVerifier::TBAABaseNodeSummary InvalidNode = {
true, ~0
u};
7163 return isValidScalarTBAANode(BaseNode)
7164 ? TBAAVerifier::TBAABaseNodeSummary({
false, 0})
7170 CheckFailed(
"Access tag nodes must have the number of operands that is a "
7171 "multiple of 3!", BaseNode);
7176 CheckFailed(
"Struct tag nodes must have an odd number of operands!",
7184 auto *TypeSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7186 if (!TypeSizeNode) {
7187 CheckFailed(
"Type size nodes must be constants!", &
I, BaseNode);
7193 if (!IsNewFormat && !isa<MDString>(BaseNode->
getOperand(0))) {
7194 CheckFailed(
"Struct tag nodes have a string as their first operand",
7201 std::optional<APInt> PrevOffset;
7206 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
7207 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
7209 Idx += NumOpsPerField) {
7212 if (!isa<MDNode>(FieldTy)) {
7213 CheckFailed(
"Incorrect field entry in struct type node!", &
I, BaseNode);
7218 auto *OffsetEntryCI =
7219 mdconst::dyn_extract_or_null<ConstantInt>(FieldOffset);
7220 if (!OffsetEntryCI) {
7221 CheckFailed(
"Offset entries must be constants!", &
I, BaseNode);
7227 BitWidth = OffsetEntryCI->getBitWidth();
7229 if (OffsetEntryCI->getBitWidth() !=
BitWidth) {
7231 "Bitwidth between the offsets and struct type entries must match", &
I,
7243 !PrevOffset || PrevOffset->ule(OffsetEntryCI->getValue());
7246 CheckFailed(
"Offsets must be increasing!", &
I, BaseNode);
7250 PrevOffset = OffsetEntryCI->getValue();
7253 auto *MemberSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7255 if (!MemberSizeNode) {
7256 CheckFailed(
"Member size entries must be constants!", &
I, BaseNode);
7263 return Failed ? InvalidNode
7264 : TBAAVerifier::TBAABaseNodeSummary(
false,
BitWidth);
7285 auto *Parent = dyn_cast_or_null<MDNode>(MD->
getOperand(1));
7286 return Parent && Visited.
insert(Parent).second &&
7290bool TBAAVerifier::isValidScalarTBAANode(
const MDNode *MD) {
7291 auto ResultIt = TBAAScalarNodes.find(MD);
7292 if (ResultIt != TBAAScalarNodes.end())
7293 return ResultIt->second;
7297 auto InsertResult = TBAAScalarNodes.insert({MD,
Result});
7299 assert(InsertResult.second &&
"Just checked!");
7318 return cast<MDNode>(BaseNode->
getOperand(1));
7320 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
7321 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
7323 Idx += NumOpsPerField) {
7324 auto *OffsetEntryCI =
7325 mdconst::extract<ConstantInt>(BaseNode->
getOperand(
Idx + 1));
7326 if (OffsetEntryCI->getValue().ugt(
Offset)) {
7327 if (
Idx == FirstFieldOpNo) {
7328 CheckFailed(
"Could not find TBAA parent in struct type node", &
I,
7333 unsigned PrevIdx =
Idx - NumOpsPerField;
7334 auto *PrevOffsetEntryCI =
7335 mdconst::extract<ConstantInt>(BaseNode->
getOperand(PrevIdx + 1));
7336 Offset -= PrevOffsetEntryCI->getValue();
7337 return cast<MDNode>(BaseNode->
getOperand(PrevIdx));
7342 auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
7344 Offset -= LastOffsetEntryCI->getValue();
7345 return cast<MDNode>(BaseNode->
getOperand(LastIdx));
7349 if (!
Type ||
Type->getNumOperands() < 3)
7354 return isa_and_nonnull<MDNode>(
Type->getOperand(0));
7361 CheckTBAA(isa<LoadInst>(
I) || isa<StoreInst>(
I) || isa<CallInst>(
I) ||
7362 isa<VAArgInst>(
I) || isa<AtomicRMWInst>(
I) ||
7363 isa<AtomicCmpXchgInst>(
I),
7364 "This instruction shall not have a TBAA access tag!", &
I);
7366 bool IsStructPathTBAA =
7370 "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
7380 "Access tag metadata must have either 4 or 5 operands", &
I, MD);
7383 "Struct tag metadata must have either 3 or 4 operands", &
I, MD);
7388 auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
7390 CheckTBAA(AccessSizeNode,
"Access size field must be a constant", &
I, MD);
7394 unsigned ImmutabilityFlagOpNo = IsNewFormat ? 4 : 3;
7396 auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
7399 "Immutability tag on struct tag metadata must be a constant", &
I,
7402 IsImmutableCI->isZero() || IsImmutableCI->isOne(),
7403 "Immutability part of the struct tag metadata must be either 0 or 1",
7408 "Malformed struct tag metadata: base and access-type "
7409 "should be non-null and point to Metadata nodes",
7410 &
I, MD, BaseNode, AccessType);
7413 CheckTBAA(isValidScalarTBAANode(AccessType),
7414 "Access type node must be a valid scalar type", &
I, MD,
7418 auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->
getOperand(2));
7419 CheckTBAA(OffsetCI,
"Offset must be constant integer", &
I, MD);
7422 bool SeenAccessTypeInPath =
false;
7427 BaseNode = getFieldNodeFromTBAABaseNode(
I, BaseNode,
Offset,
7429 if (!StructPath.
insert(BaseNode).second) {
7430 CheckFailed(
"Cycle detected in struct path", &
I, MD);
7435 unsigned BaseNodeBitWidth;
7436 std::tie(
Invalid, BaseNodeBitWidth) = verifyTBAABaseNode(
I, BaseNode,
7444 SeenAccessTypeInPath |= BaseNode == AccessType;
7446 if (isValidScalarTBAANode(BaseNode) || BaseNode == AccessType)
7447 CheckTBAA(
Offset == 0,
"Offset not zero at the point of scalar access",
7451 (BaseNodeBitWidth == 0 &&
Offset == 0) ||
7452 (IsNewFormat && BaseNodeBitWidth == ~0u),
7453 "Access bit-width not the same as description bit-width", &
I, MD,
7454 BaseNodeBitWidth,
Offset.getBitWidth());
7456 if (IsNewFormat && SeenAccessTypeInPath)
7460 CheckTBAA(SeenAccessTypeInPath,
"Did not see access type in access path!", &
I,
7467 "tbaa.struct operands must occur in groups of three", &
I, MD);
7472 std::optional<APInt> NextFree;
7475 mdconst::dyn_extract_or_null<ConstantInt>(MD->
getOperand(
Idx));
7476 CheckTBAA(OffsetCI,
"Offset must be a constant integer", &
I, MD);
7479 mdconst::dyn_extract_or_null<ConstantInt>(MD->
getOperand(
Idx + 1));
7480 CheckTBAA(SizeCI,
"Size must be a constant integer", &
I, MD);
7486 bool NonOverlapping = !NextFree || NextFree->ule(OffsetCI->getValue());
7487 CheckTBAA(NonOverlapping,
"Overlapping tbaa.struct regions", &
I, MD);
7489 NextFree = OffsetCI->getValue() + SizeCI->getValue();
7494char VerifierLegacyPass::ID = 0;
7495INITIALIZE_PASS(VerifierLegacyPass,
"verify",
"Module Verifier",
false,
false)
7498 return new VerifierLegacyPass(FatalErrors);
7516 if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
7524 if (res.IRBroken && FatalErrors)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file defines the StringMap class.
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...
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
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
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...
This file implements a map that provides insertion order iteration.
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
verify safepoint Safepoint IR Verifier
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
This defines the Use 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 LandingPadInst * getLandingPadInst() const
Return the landingpad instruction associated with the landing pad.
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...
bool isEHPad() const
Return true if this basic block is an exception handling block.
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 parameter 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.
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.
This class represents a range of values.
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
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.
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.
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 FunctionType * getResolverFunctionType(Type *IFuncValTy)
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 BasicBlock * getParent() const
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.
BasicBlock * getUnwindDest() const
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.
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
static constexpr size_t npos
Class to represent struct types.
unsigned getNumElements() const
Random access to the elements.
bool containsScalableVectorType(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Returns true if this struct contains a scalable vector.
Type * getTypeAtIndex(const Value *V) const
Given an index value into the type, return the type of the element.
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.
bool visitTBAAStructMetadata(Instruction &I, const MDNode *MD)
@ CanBeGlobal
This type may be used as the value type of a global variable.
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.
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
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.
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 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 isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
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.
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.
AttributeMask typeIncompatible(Type *Ty, 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.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ 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.
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
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)
bool isFortran(SourceLanguage S)
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.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
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,...
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
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.
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)
@ Invalid
Denotes invalid value.
@ Dynamic
Denotes mode unknown at compile time.
@ MaskAll
A bitmask that includes all valid flags.
constexpr unsigned BitWidth
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.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Holds the characteristics of one fragment of a larger variable.
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).