1//===-- Verifier.cpp - Implement the Module Verifier -----------------------==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the function verifier interface, that can be used for some
10// basic correctness checking of input to the system.
11//
12// Note that this does not provide full `Java style' security and verifications,
13// instead it just tries to ensure that code is well-formed.
14//
15// * Both of a binary operator's parameters are of the same type
16// * Verify that the indices of mem access instructions match other operands
17// * Verify that arithmetic and other things are only performed on first-class
18// types. Verify that shifts & logicals only happen on integrals f.e.
19// * All of the constants in a switch statement are of the correct type
20// * The code is in valid SSA form
21// * It should be illegal to put a label into any other type (like a structure)
22// or to return one. [except constant arrays!]
23// * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad
24// * PHI nodes must have an entry for each predecessor, with no extras.
25// * PHI nodes must be the first thing in a basic block, all grouped together
26// * All basic blocks should only end with terminator insts, not contain them
27// * The entry node to a function must not have predecessors
28// * All Instructions must be embedded into a basic block
29// * Functions cannot take a void-typed parameter
30// * Verify that a function's argument list agrees with it's declared type.
31// * It is illegal to specify a name for a void value.
32// * It is illegal to have a internal global value with no initializer
33// * It is illegal to have a ret instruction that returns a value that does not
34// agree with the function return value type.
35// * Function call argument types match the function prototype
36// * A landing pad is defined by a landingpad instruction, and can be jumped to
37// only by the unwind edge of an invoke instruction.
38// * A landingpad instruction must be the first non-PHI instruction in the
39// block.
40// * Landingpad instructions must be in a function with a personality function.
41// * Convergence control intrinsics are introduced in ConvergentOperations.rst.
42// The applied restrictions are too numerous to list here.
43// * The convergence entry intrinsic and the loop heart must be the first
44// non-PHI instruction in their respective block. This does not conflict with
45// the landing pads, since these two kinds cannot occur in the same block.
46// * All other things that are tested by asserts spread about the code...
47//
48//===----------------------------------------------------------------------===//
49
50#include "llvm/IR/Verifier.h"
51#include "VerifierInternal.h"
52#include "llvm/ADT/APFloat.h"
53#include "llvm/ADT/APInt.h"
54#include "llvm/ADT/ArrayRef.h"
55#include "llvm/ADT/DenseMap.h"
56#include "llvm/ADT/MapVector.h"
57#include "llvm/ADT/STLExtras.h"
58#include "llvm/ADT/SmallPtrSet.h"
59#include "llvm/ADT/SmallVector.h"
60#include "llvm/ADT/StringExtras.h"
61#include "llvm/ADT/StringRef.h"
62#include "llvm/ADT/Twine.h"
63#include "llvm/BinaryFormat/Dwarf.h"
64#include "llvm/IR/Argument.h"
65#include "llvm/IR/AttributeMask.h"
66#include "llvm/IR/Attributes.h"
67#include "llvm/IR/AutoUpgrade.h"
68#include "llvm/IR/BasicBlock.h"
69#include "llvm/IR/BundleAttributes.h"
70#include "llvm/IR/CFG.h"
71#include "llvm/IR/CallingConv.h"
72#include "llvm/IR/Comdat.h"
73#include "llvm/IR/Constant.h"
74#include "llvm/IR/ConstantRange.h"
75#include "llvm/IR/ConstantRangeList.h"
76#include "llvm/IR/Constants.h"
77#include "llvm/IR/ConvergenceVerifier.h"
78#include "llvm/IR/DataLayout.h"
79#include "llvm/IR/DebugInfo.h"
80#include "llvm/IR/DebugInfoMetadata.h"
81#include "llvm/IR/DebugLoc.h"
82#include "llvm/IR/DerivedTypes.h"
83#include "llvm/IR/Dominators.h"
84#include "llvm/IR/EHPersonalities.h"
85#include "llvm/IR/FPEnv.h"
86#include "llvm/IR/Function.h"
87#include "llvm/IR/GCStrategy.h"
88#include "llvm/IR/GetElementPtrTypeIterator.h"
89#include "llvm/IR/GlobalAlias.h"
90#include "llvm/IR/GlobalValue.h"
91#include "llvm/IR/GlobalVariable.h"
92#include "llvm/IR/InlineAsm.h"
93#include "llvm/IR/InstVisitor.h"
94#include "llvm/IR/InstrTypes.h"
95#include "llvm/IR/Instruction.h"
96#include "llvm/IR/Instructions.h"
97#include "llvm/IR/IntrinsicInst.h"
98#include "llvm/IR/Intrinsics.h"
99#include "llvm/IR/IntrinsicsAArch64.h"
100#include "llvm/IR/IntrinsicsARM.h"
101#include "llvm/IR/IntrinsicsNVPTX.h"
102#include "llvm/IR/IntrinsicsRISCV.h"
103#include "llvm/IR/IntrinsicsWebAssembly.h"
104#include "llvm/IR/LLVMContext.h"
105#include "llvm/IR/MemoryModelRelaxationAnnotations.h"
106#include "llvm/IR/Metadata.h"
107#include "llvm/IR/Module.h"
108#include "llvm/IR/ModuleSlotTracker.h"
109#include "llvm/IR/PassManager.h"
110#include "llvm/IR/ProfDataUtils.h"
111#include "llvm/IR/Statepoint.h"
112#include "llvm/IR/Type.h"
113#include "llvm/IR/Use.h"
114#include "llvm/IR/User.h"
115#include "llvm/IR/VFABIDemangler.h"
116#include "llvm/IR/Value.h"
117#include "llvm/InitializePasses.h"
118#include "llvm/Pass.h"
119#include "llvm/ProfileData/InstrProf.h"
120#include "llvm/Support/AtomicOrdering.h"
121#include "llvm/Support/Casting.h"
122#include "llvm/Support/CodeGen.h"
123#include "llvm/Support/CommandLine.h"
124#include "llvm/Support/ErrorHandling.h"
125#include "llvm/Support/FormatVariadic.h"
126#include "llvm/Support/MathExtras.h"
127#include "llvm/Support/ModRef.h"
128#include "llvm/Support/TimeProfiler.h"
129#include "llvm/Support/raw_ostream.h"
130#include "llvm/TargetParser/RISCVTargetParser.h"
131#include "llvm/TargetParser/Triple.h"
132#include "llvm/Transforms/Coroutines/CoroInstr.h"
133#include <algorithm>
134#include <cassert>
135#include <cstdint>
136#include <limits>
137#include <memory>
138#include <optional>
139#include <queue>
140#include <string>
141#include <utility>
142
143using namespace llvm;
144
145static cl::opt<bool> VerifyNoAliasScopeDomination(
146 "verify-noalias-scope-decl-dom", cl::Hidden, cl::init(Val: false),
147 cl::desc("Ensure that llvm.experimental.noalias.scope.decl for identical "
148 "scopes are not dominating"));
149
150namespace {
151
152class Verifier : public InstVisitor<Verifier>, VerifierSupport {
153 friend class InstVisitor<Verifier>;
154 DominatorTree DT;
155
156 /// When verifying a basic block, keep track of all of the
157 /// instructions we have seen so far.
158 ///
159 /// This allows us to do efficient dominance checks for the case when an
160 /// instruction has an operand that is an instruction in the same block.
161 SmallPtrSet<Instruction *, 16> InstsInThisBlock;
162
163 /// Keep track of the metadata nodes that have been checked already.
164 SmallPtrSet<const Metadata *, 32> MDNodes;
165
166 /// Keep track which DISubprogram is attached to which function.
167 DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
168
169 /// For each visited DIScope, whether walking its scope chain reaches a
170 /// repeated node.
171 DenseMap<const Metadata *, bool> DIScopeChainReachesCycle;
172
173 /// Track all DICompileUnits visited.
174 SmallPtrSet<const Metadata *, 2> CUVisited;
175
176 /// The result type for a landingpad.
177 Type *LandingPadResultTy;
178
179 /// Whether we've seen a call to @llvm.localescape in this function
180 /// already.
181 bool SawFrameEscape;
182
183 /// Whether the current function has a DISubprogram attached to it.
184 bool HasDebugInfo = false;
185
186 /// Stores the count of how many objects were passed to llvm.localescape for a
187 /// given function and the largest index passed to llvm.localrecover.
188 DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
189
190 // Maps catchswitches and cleanuppads that unwind to siblings to the
191 // terminators that indicate the unwind, used to detect cycles therein.
192 MapVector<Instruction *, Instruction *> SiblingFuncletInfo;
193
194 /// Cache which blocks are in which funclet, if an EH funclet personality is
195 /// in use. Otherwise empty.
196 DenseMap<BasicBlock *, ColorVector> BlockEHFuncletColors;
197
198 /// Cache of constants visited in search of ConstantExprs.
199 SmallPtrSet<const Constant *, 32> ConstantExprVisited;
200
201 /// Cache of declarations of the llvm.experimental.deoptimize.<ty> intrinsic.
202 SmallVector<const Function *, 4> DeoptimizeDeclarations;
203
204 /// Cache of attribute lists verified.
205 SmallPtrSet<const void *, 32> AttributeListsVisited;
206
207 // Verify that this GlobalValue is only used in this module.
208 // This map is used to avoid visiting uses twice. We can arrive at a user
209 // twice, if they have multiple operands. In particular for very large
210 // constant expressions, we can arrive at a particular user many times.
211 SmallPtrSet<const Value *, 32> GlobalValueVisited;
212
213 // Keeps track of duplicate function argument debug info.
214 SmallVector<const DILocalVariable *, 16> DebugFnArgs;
215
216 TBAAVerifier TBAAVerifyHelper;
217 ConvergenceVerifier ConvergenceVerifyHelper;
218
219 SmallVector<IntrinsicInst *, 4> NoAliasScopeDecls;
220
221 void checkAtomicMemAccessSize(Type *Ty, const Instruction *I);
222
223public:
224 explicit Verifier(raw_ostream *OS, bool ShouldTreatBrokenDebugInfoAsError,
225 const Module &M)
226 : VerifierSupport(OS, M), LandingPadResultTy(nullptr),
227 SawFrameEscape(false), TBAAVerifyHelper(this) {
228 TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
229 }
230
231 bool hasBrokenDebugInfo() const { return BrokenDebugInfo; }
232
233 bool verify(const Function &F) {
234 llvm::TimeTraceScope timeScope("Verifier");
235 assert(F.getParent() == &M &&
236 "An instance of this class only works with a specific module!");
237
238 // First ensure the function is well-enough formed to compute dominance
239 // information, and directly compute a dominance tree. We don't rely on the
240 // pass manager to provide this as it isolates us from a potentially
241 // out-of-date dominator tree and makes it significantly more complex to run
242 // this code outside of a pass manager.
243
244 // First check that every basic block has a terminator, otherwise we can't
245 // even inspect the CFG.
246 for (const BasicBlock &BB : F) {
247 if (!BB.empty() && BB.back().isTerminator())
248 continue;
249
250 if (OS) {
251 *OS << "Basic Block in function '" << F.getName()
252 << "' does not have terminator!\n";
253 BB.printAsOperand(O&: *OS, PrintType: true, MST);
254 *OS << "\n";
255 }
256 return false;
257 }
258
259 // FIXME: It's really gross that we have to cast away constness here.
260 if (!F.empty())
261 DT.recalculate(Func&: const_cast<Function &>(F));
262
263 auto FailureCB = [this](const Twine &Message) {
264 this->CheckFailed(Message);
265 };
266 ConvergenceVerifyHelper.initialize(OS, FailureCB, F);
267
268 Broken = false;
269 // FIXME: We strip const here because the inst visitor strips const.
270 visit(F&: const_cast<Function &>(F));
271 verifySiblingFuncletUnwinds();
272
273 if (ConvergenceVerifyHelper.sawTokens())
274 ConvergenceVerifyHelper.verify(DT);
275
276 InstsInThisBlock.clear();
277 DebugFnArgs.clear();
278 DIScopeChainReachesCycle.clear();
279 LandingPadResultTy = nullptr;
280 SawFrameEscape = false;
281 SiblingFuncletInfo.clear();
282 verifyNoAliasScopeDecl();
283 NoAliasScopeDecls.clear();
284
285 return !Broken;
286 }
287
288 /// Verify the module that this instance of \c Verifier was initialized with.
289 bool verify() {
290 Broken = false;
291
292 // Collect all declarations of the llvm.experimental.deoptimize intrinsic.
293 for (const Function &F : M)
294 if (F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
295 DeoptimizeDeclarations.push_back(Elt: &F);
296
297 // Now that we've visited every function, verify that we never asked to
298 // recover a frame index that wasn't escaped.
299 verifyFrameRecoverIndices();
300 for (const GlobalVariable &GV : M.globals())
301 visitGlobalVariable(GV);
302
303 for (const GlobalAlias &GA : M.aliases())
304 visitGlobalAlias(GA);
305
306 for (const GlobalIFunc &GI : M.ifuncs())
307 visitGlobalIFunc(GI);
308
309 for (const NamedMDNode &NMD : M.named_metadata())
310 visitNamedMDNode(NMD);
311
312 for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable())
313 visitComdat(C: SMEC.getValue());
314
315 visitModuleFlags();
316 visitModuleIdents();
317 visitModuleCommandLines();
318 visitModuleErrnoTBAA();
319
320 verifyCompileUnits();
321
322 verifyDeoptimizeCallingConvs();
323 DISubprogramAttachments.clear();
324 DIScopeChainReachesCycle.clear();
325 return !Broken;
326 }
327
328private:
329 /// Whether a metadata node is allowed to be, or contain, a DILocation.
330 enum class AreDebugLocsAllowed { No, Yes };
331
332 /// Metadata that should be treated as a range, with slightly different
333 /// requirements.
334 enum class RangeLikeMetadataKind {
335 Range, // MD_range
336 AbsoluteSymbol, // MD_absolute_symbol
337 NoaliasAddrspace // MD_noalias_addrspace
338 };
339
340 // Verification methods...
341 void visitGlobalValue(const GlobalValue &GV);
342 void visitGlobalVariable(const GlobalVariable &GV);
343 void visitGlobalAlias(const GlobalAlias &GA);
344 void visitGlobalIFunc(const GlobalIFunc &GI);
345 void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C);
346 void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited,
347 const GlobalAlias &A, const Constant &C);
348 void visitNamedMDNode(const NamedMDNode &NMD);
349 void visitMDNode(const MDNode &MD, AreDebugLocsAllowed AllowLocs);
350 void visitMetadataAsValue(const MetadataAsValue &MD, Function *F);
351 void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F);
352 void visitDIArgList(const DIArgList &AL, Function *F);
353 void visitComdat(const Comdat &C);
354 void visitModuleIdents();
355 void visitModuleCommandLines();
356 void visitModuleErrnoTBAA();
357 void visitModuleFlags();
358 void visitModuleFlag(const MDNode *Op,
359 DenseMap<const MDString *, const MDNode *> &SeenIDs,
360 SmallVectorImpl<const MDNode *> &Requirements);
361 void visitModuleFlagCGProfileEntry(const MDOperand &MDO);
362 void visitFunction(const Function &F);
363 void visitBasicBlock(BasicBlock &BB);
364 void verifyRangeLikeMetadata(const Value &V, const MDNode *Range, Type *Ty,
365 RangeLikeMetadataKind Kind);
366 void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
367 void visitNoFPClassMetadata(Instruction &I, MDNode *Range, Type *Ty);
368 void visitNoaliasAddrspaceMetadata(Instruction &I, MDNode *Range, Type *Ty);
369 void visitDereferenceableMetadata(Instruction &I, MDNode *MD);
370 void visitNoFreeObjMetadata(Instruction &I, MDNode *MD);
371 void visitProfMetadata(Instruction &I, MDNode *MD);
372 void visitCallStackMetadata(MDNode *MD);
373 void visitMemProfMetadata(Instruction &I, MDNode *MD);
374 void visitCallsiteMetadata(Instruction &I, MDNode *MD);
375 void visitCalleeTypeMetadata(Instruction &I, MDNode *MD);
376 void visitDIAssignIDMetadata(Instruction &I, MDNode *MD);
377 void visitMMRAMetadata(Instruction &I, MDNode *MD);
378 void visitAnnotationMetadata(MDNode *Annotation);
379 void visitAliasScopeMetadata(const MDNode *MD);
380 void visitAliasScopeListMetadata(const MDNode *MD);
381 void visitAccessGroupMetadata(const MDNode *MD);
382 void visitCapturesMetadata(Instruction &I, const MDNode *Captures);
383 void visitAllocTokenMetadata(Instruction &I, MDNode *MD);
384 void visitInlineHistoryMetadata(Instruction &I, MDNode *MD);
385 void visitMemCacheHintMetadata(Instruction &I, MDNode *MD);
386
387#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
388#include "llvm/IR/Metadata.def"
389 void visitDIType(const DIType &N);
390 void visitDIScope(const DIScope &N);
391 void visitDIScopeChain(const DIScope &N);
392 bool hasDIScopeCycle(const Metadata *S);
393 DISubprogram *getSubprogram(Metadata *LocalScope);
394 void visitDIVariable(const DIVariable &N);
395 void visitDILexicalBlockBase(const DILexicalBlockBase &N);
396 void visitDITemplateParameter(const DITemplateParameter &N);
397
398 void visitTemplateParams(const MDNode &N, const Metadata &RawParams);
399
400 void visit(DbgLabelRecord &DLR);
401 void visit(DbgVariableRecord &DVR);
402 // InstVisitor overrides...
403 using InstVisitor<Verifier>::visit;
404 void visitDbgRecords(Instruction &I);
405 void visit(Instruction &I);
406
407 void visitTruncInst(TruncInst &I);
408 void visitZExtInst(ZExtInst &I);
409 void visitSExtInst(SExtInst &I);
410 void visitFPTruncInst(FPTruncInst &I);
411 void visitFPExtInst(FPExtInst &I);
412 void visitFPToUIInst(FPToUIInst &I);
413 void visitFPToSIInst(FPToSIInst &I);
414 void visitUIToFPInst(UIToFPInst &I);
415 void visitSIToFPInst(SIToFPInst &I);
416 void visitIntToPtrInst(IntToPtrInst &I);
417 void checkPtrToAddr(Type *SrcTy, Type *DestTy, const Value &V);
418 void visitPtrToAddrInst(PtrToAddrInst &I);
419 void visitPtrToIntInst(PtrToIntInst &I);
420 void visitBitCastInst(BitCastInst &I);
421 void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
422 void visitPHINode(PHINode &PN);
423 void visitCallBase(CallBase &Call);
424 void visitUnaryOperator(UnaryOperator &U);
425 void visitBinaryOperator(BinaryOperator &B);
426 void visitICmpInst(ICmpInst &IC);
427 void visitFCmpInst(FCmpInst &FC);
428 void visitExtractElementInst(ExtractElementInst &EI);
429 void visitInsertElementInst(InsertElementInst &EI);
430 void visitShuffleVectorInst(ShuffleVectorInst &EI);
431 void visitVAArgInst(VAArgInst &VAA) { visitInstruction(I&: VAA); }
432 void visitCallInst(CallInst &CI);
433 void visitInvokeInst(InvokeInst &II);
434 void visitGetElementPtrInst(GetElementPtrInst &GEP);
435 void visitLoadInst(LoadInst &LI);
436 void visitStoreInst(StoreInst &SI);
437 void verifyDominatesUse(Instruction &I, unsigned i);
438 void visitInstruction(Instruction &I);
439 void visitTerminator(Instruction &I);
440 void visitCondBrInst(CondBrInst &BI);
441 void visitReturnInst(ReturnInst &RI);
442 void visitSwitchInst(SwitchInst &SI);
443 void visitIndirectBrInst(IndirectBrInst &BI);
444 void visitCallBrInst(CallBrInst &CBI);
445 void visitSelectInst(SelectInst &SI);
446 void visitUserOp1(Instruction &I);
447 void visitUserOp2(Instruction &I) { visitUserOp1(I); }
448 void visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call);
449 void visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI);
450 void visitVPIntrinsic(VPIntrinsic &VPI);
451 void visitDbgLabelIntrinsic(StringRef Kind, DbgLabelInst &DLI);
452 void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
453 void visitAtomicRMWInst(AtomicRMWInst &RMWI);
454 void visitFenceInst(FenceInst &FI);
455 void visitAllocaInst(AllocaInst &AI);
456 void visitExtractValueInst(ExtractValueInst &EVI);
457 void visitInsertValueInst(InsertValueInst &IVI);
458 void visitEHPadPredecessors(Instruction &I);
459 void visitLandingPadInst(LandingPadInst &LPI);
460 void visitResumeInst(ResumeInst &RI);
461 void visitCatchPadInst(CatchPadInst &CPI);
462 void visitCatchReturnInst(CatchReturnInst &CatchReturn);
463 void visitCleanupPadInst(CleanupPadInst &CPI);
464 void visitFuncletPadInst(FuncletPadInst &FPI);
465 void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch);
466 void visitCleanupReturnInst(CleanupReturnInst &CRI);
467
468 void verifySwiftErrorCall(CallBase &Call, const Value *SwiftErrorVal);
469 void verifySwiftErrorValue(const Value *SwiftErrorVal);
470 void verifyTailCCMustTailAttrs(const AttrBuilder &Attrs, StringRef Context);
471 void verifyMustTailCall(CallInst &CI);
472 bool verifyAttributeCount(AttributeList Attrs, unsigned Params);
473 void verifyAttributeTypes(AttributeSet Attrs, const Value *V);
474 void verifyParameterAttrs(AttributeSet Attrs, Type *Ty, const Value *V);
475 void checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
476 const Value *V);
477 void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
478 const Value *V, bool IsIntrinsic, bool IsInlineAsm);
479 void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
480 void verifyUnknownProfileMetadata(MDNode *MD);
481 void visitConstantExprsRecursively(const Constant *EntryC);
482 void visitConstantExpr(const ConstantExpr *CE);
483 void visitConstantPtrAuth(const ConstantPtrAuth *CPA);
484 void verifyInlineAsmCall(const CallBase &Call);
485 void verifyStatepoint(const CallBase &Call);
486 void verifyFrameRecoverIndices();
487 void verifySiblingFuncletUnwinds();
488
489 void verifyFragmentExpression(const DbgVariableRecord &I);
490 template <typename ValueOrMetadata>
491 void verifyFragmentExpression(const DIVariable &V,
492 DIExpression::FragmentInfo Fragment,
493 ValueOrMetadata *Desc);
494 void verifyFnArgs(const DbgVariableRecord &DVR);
495 void verifyNotEntryValue(const DbgVariableRecord &I);
496
497 /// Module-level debug info verification...
498 void verifyCompileUnits();
499
500 /// Module-level verification that all @llvm.experimental.deoptimize
501 /// declarations share the same calling convention.
502 void verifyDeoptimizeCallingConvs();
503
504 void verifyAttachedCallBundle(const CallBase &Call,
505 const OperandBundleUse &BU);
506
507 /// Verify the llvm.experimental.noalias.scope.decl declarations
508 void verifyNoAliasScopeDecl();
509};
510
511} // end anonymous namespace
512
513/// We know that cond should be true, if not print an error message.
514#define Check(C, ...) \
515 do { \
516 if (!(C)) { \
517 CheckFailed(__VA_ARGS__); \
518 return; \
519 } \
520 } while (false)
521
522/// We know that a debug info condition should be true, if not print
523/// an error message.
524#define CheckDI(C, ...) \
525 do { \
526 if (!(C)) { \
527 DebugInfoCheckFailed(__VA_ARGS__); \
528 return; \
529 } \
530 } while (false)
531
532void Verifier::visitDbgRecords(Instruction &I) {
533 if (!I.getDbgMarker())
534 return;
535 CheckDI(I.getDbgMarker()->MarkedInstr == &I,
536 "Instruction has invalid DebugMarker", &I);
537 CheckDI(!isa<PHINode>(&I) || !I.hasDbgRecords(),
538 "PHI Node must not have any attached DbgRecords", &I);
539 for (DbgRecord &DR : I.getDbgRecordRange()) {
540 CheckDI(DR.getMarker() == I.getDbgMarker(),
541 "DbgRecord had invalid DebugMarker", &I, &DR);
542 if (auto *Loc =
543 dyn_cast_or_null<DILocation>(Val: DR.getDebugLoc().getAsMDNode()))
544 visitMDNode(MD: *Loc, AllowLocs: AreDebugLocsAllowed::Yes);
545 if (auto *DVR = dyn_cast<DbgVariableRecord>(Val: &DR)) {
546 visit(DVR&: *DVR);
547 // These have to appear after `visit` for consistency with existing
548 // intrinsic behaviour.
549 verifyFragmentExpression(I: *DVR);
550 verifyNotEntryValue(I: *DVR);
551 } else if (auto *DLR = dyn_cast<DbgLabelRecord>(Val: &DR)) {
552 visit(DLR&: *DLR);
553 }
554 }
555}
556
557void Verifier::visit(Instruction &I) {
558 visitDbgRecords(I);
559 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
560 Check(I.getOperand(i) != nullptr, "Operand is null", &I);
561 InstVisitor<Verifier>::visit(I);
562}
563
564// Helper to iterate over indirect users. By returning false, the callback can ask to stop traversing further.
565static void forEachUser(const Value *User,
566 SmallPtrSet<const Value *, 32> &Visited,
567 llvm::function_ref<bool(const Value *)> Callback) {
568 if (!Visited.insert(Ptr: User).second)
569 return;
570
571 SmallVector<const Value *> WorkList(User->materialized_users());
572 while (!WorkList.empty()) {
573 const Value *Cur = WorkList.pop_back_val();
574 if (!Visited.insert(Ptr: Cur).second)
575 continue;
576 if (Callback(Cur))
577 append_range(C&: WorkList, R: Cur->materialized_users());
578 }
579}
580
581void Verifier::visitGlobalValue(const GlobalValue &GV) {
582 Check(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),
583 "Global is external, but doesn't have external or weak linkage!", &GV);
584
585 if (const auto *GO = dyn_cast<GlobalObject>(Val: &GV)) {
586 if (const MDNode *Associated =
587 GO->getMetadata(KindID: LLVMContext::MD_associated)) {
588 Check(Associated->getNumOperands() == 1,
589 "associated metadata must have one operand", &GV, Associated);
590 const Metadata *Op = Associated->getOperand(I: 0).get();
591 Check(Op, "associated metadata must have a global value", GO, Associated);
592
593 const auto *VM = dyn_cast_or_null<ValueAsMetadata>(Val: Op);
594 Check(VM, "associated metadata must be ValueAsMetadata", GO, Associated);
595 if (VM) {
596 Check(isa<PointerType>(VM->getValue()->getType()),
597 "associated value must be pointer typed", GV, Associated);
598
599 const Value *Stripped = VM->getValue()->stripPointerCastsAndAliases();
600 Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
601 "associated metadata must point to a GlobalObject", GO, Stripped);
602 Check(Stripped != GO,
603 "global values should not associate to themselves", GO,
604 Associated);
605 }
606 }
607
608 // FIXME: Why is getMetadata on GlobalValue protected?
609 if (const MDNode *AbsoluteSymbol =
610 GO->getMetadata(KindID: LLVMContext::MD_absolute_symbol)) {
611 verifyRangeLikeMetadata(V: *GO, Range: AbsoluteSymbol,
612 Ty: DL.getIntPtrType(GO->getType()),
613 Kind: RangeLikeMetadataKind::AbsoluteSymbol);
614 }
615
616 if (GO->hasMetadata(KindID: LLVMContext::MD_implicit_ref)) {
617 Check(!GO->isDeclaration(),
618 "ref metadata must not be placed on a declaration", GO);
619
620 SmallVector<MDNode *> MDs;
621 GO->getMetadata(KindID: LLVMContext::MD_implicit_ref, MDs);
622 for (const MDNode *MD : MDs) {
623 Check(MD->getNumOperands() == 1, "ref metadata must have one operand",
624 &GV, MD);
625 const Metadata *Op = MD->getOperand(I: 0).get();
626 const auto *VM = dyn_cast_or_null<ValueAsMetadata>(Val: Op);
627 Check(VM, "ref metadata must be ValueAsMetadata", GO, MD);
628 if (VM) {
629 Check(isa<PointerType>(VM->getValue()->getType()),
630 "ref value must be pointer typed", GV, MD);
631
632 const Value *Stripped = VM->getValue()->stripPointerCastsAndAliases();
633 Check(isa<GlobalObject>(Stripped) || isa<Constant>(Stripped),
634 "ref metadata must point to a GlobalObject", GO, Stripped);
635 Check(Stripped != GO, "values should not reference themselves", GO,
636 MD);
637 }
638 }
639 }
640
641 if (auto *Props = GO->getMetadata(KindID: LLVMContext::MD_elf_section_properties)) {
642 Check(Props->getNumOperands() == 2,
643 "elf_section_properties metadata must have two operands", GO,
644 Props);
645 if (Props->getNumOperands() == 2) {
646 auto *Type = dyn_cast<ConstantAsMetadata>(Val: Props->getOperand(I: 0));
647 Check(Type, "type field must be ConstantAsMetadata", GO, Props);
648 auto *TypeInt = dyn_cast<ConstantInt>(Val: Type->getValue());
649 Check(TypeInt, "type field must be ConstantInt", GO, Props);
650
651 auto *Entsize = dyn_cast<ConstantAsMetadata>(Val: Props->getOperand(I: 1));
652 Check(Entsize, "entsize field must be ConstantAsMetadata", GO, Props);
653 auto *EntsizeInt = dyn_cast<ConstantInt>(Val: Entsize->getValue());
654 Check(EntsizeInt, "entsize field must be ConstantInt", GO, Props);
655 }
656 }
657 }
658
659 Check(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
660 "Only global variables can have appending linkage!", &GV);
661
662 if (GV.hasAppendingLinkage()) {
663 const auto *GVar = dyn_cast<GlobalVariable>(Val: &GV);
664 Check(GVar && GVar->getValueType()->isArrayTy(),
665 "Only global arrays can have appending linkage!", GVar);
666 }
667
668 if (GV.isDeclarationForLinker())
669 Check(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
670
671 if (GV.hasDLLExportStorageClass()) {
672 Check(!GV.hasHiddenVisibility(),
673 "dllexport GlobalValue must have default or protected visibility",
674 &GV);
675 }
676 if (GV.hasDLLImportStorageClass()) {
677 Check(GV.hasDefaultVisibility(),
678 "dllimport GlobalValue must have default visibility", &GV);
679 Check(!GV.isDSOLocal(), "GlobalValue with DLLImport Storage is dso_local!",
680 &GV);
681
682 Check((GV.isDeclaration() &&
683 (GV.hasExternalLinkage() || GV.hasExternalWeakLinkage())) ||
684 GV.hasAvailableExternallyLinkage(),
685 "Global is marked as dllimport, but not external", &GV);
686 }
687
688 if (GV.isImplicitDSOLocal())
689 Check(GV.isDSOLocal(),
690 "GlobalValue with local linkage or non-default "
691 "visibility must be dso_local!",
692 &GV);
693
694 forEachUser(User: &GV, Visited&: GlobalValueVisited, Callback: [&](const Value *V) -> bool {
695 if (const auto *I = dyn_cast<Instruction>(Val: V)) {
696 if (!I->getParent() || !I->getParent()->getParent())
697 CheckFailed(Message: "Global is referenced by parentless instruction!", V1: &GV, Vs: &M,
698 Vs: I);
699 else if (I->getParent()->getParent()->getParent() != &M)
700 CheckFailed(Message: "Global is referenced in a different module!", V1: &GV, Vs: &M, Vs: I,
701 Vs: I->getParent()->getParent(),
702 Vs: I->getParent()->getParent()->getParent());
703 return false;
704 } else if (const auto *F = dyn_cast<Function>(Val: V)) {
705 if (F->getParent() != &M)
706 CheckFailed(Message: "Global is used by function in a different module", V1: &GV, Vs: &M,
707 Vs: F, Vs: F->getParent());
708 return false;
709 }
710 return true;
711 });
712}
713
714void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
715 // Target-specific global variable checks. Done first because this function
716 // returns early for a global without an initializer.
717 verifyAMDGPUGlobalVariable(VS&: *this, GV);
718
719 Type *GVType = GV.getValueType();
720
721 if (MaybeAlign A = GV.getAlign()) {
722 Check(A->value() <= Value::MaximumAlignment,
723 "huge alignment values are unsupported", &GV);
724 }
725
726 if (GV.hasInitializer()) {
727 Check(GV.getInitializer()->getType() == GVType,
728 "Global variable initializer type does not match global "
729 "variable type!",
730 &GV);
731 Check(GV.getInitializer()->getType()->isSized(),
732 "Global variable initializer must be sized", &GV);
733 visitConstantExprsRecursively(EntryC: GV.getInitializer());
734 // If the global has common linkage, it must have a zero initializer and
735 // cannot be constant.
736 if (GV.hasCommonLinkage()) {
737 Check(GV.getInitializer()->isNullValue(),
738 "'common' global must have a zero initializer!", &GV);
739 Check(!GV.isConstant(), "'common' global may not be marked constant!",
740 &GV);
741 Check(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
742 }
743 }
744
745 if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
746 GV.getName() == "llvm.global_dtors")) {
747 Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
748 "invalid linkage for intrinsic global variable", &GV);
749 Check(GV.materialized_use_empty(),
750 "invalid uses of intrinsic global variable", &GV);
751
752 // Don't worry about emitting an error for it not being an array,
753 // visitGlobalValue will complain on appending non-array.
754 if (const auto *ATy = dyn_cast<ArrayType>(Val: GVType)) {
755 const auto *STy = dyn_cast<StructType>(Val: ATy->getElementType());
756 PointerType *FuncPtrTy =
757 PointerType::get(C&: Context, AddressSpace: DL.getProgramAddressSpace());
758 Check(STy && (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
759 STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
760 STy->getTypeAtIndex(1) == FuncPtrTy,
761 "wrong type for intrinsic global variable", &GV);
762 Check(STy->getNumElements() == 3,
763 "the third field of the element type is mandatory, "
764 "specify ptr null to migrate from the obsoleted 2-field form");
765 Type *ETy = STy->getTypeAtIndex(N: 2);
766 Check(ETy->isPointerTy(), "wrong type for intrinsic global variable",
767 &GV);
768 }
769
770 auto *Init = GV.hasInitializer()
771 ? dyn_cast<ConstantArray>(Val: GV.getInitializer())
772 : nullptr;
773 if (Init) {
774 for (const Use &U : Init->operands()) {
775 auto *Structor = dyn_cast<ConstantStruct>(Val: U);
776 if (!Structor || Structor->getNumOperands() != 3)
777 continue;
778 Check(!isa<ConstantPtrAuth>(Structor->getOperand(1)),
779 "signing of ctors/dtors should be requested via module flags");
780 }
781 }
782 }
783
784 if (GV.hasName() && (GV.getName() == "llvm.used" ||
785 GV.getName() == "llvm.compiler.used")) {
786 Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
787 "invalid linkage for intrinsic global variable", &GV);
788 Check(GV.materialized_use_empty(),
789 "invalid uses of intrinsic global variable", &GV);
790
791 if (const auto *ATy = dyn_cast<ArrayType>(Val: GVType)) {
792 const auto *PTy = dyn_cast<PointerType>(Val: ATy->getElementType());
793 Check(PTy, "wrong type for intrinsic global variable", &GV);
794 if (GV.hasInitializer()) {
795 const Constant *Init = GV.getInitializer();
796 const auto *InitArray = dyn_cast<ConstantArray>(Val: Init);
797 Check(InitArray, "wrong initializer for intrinsic global variable",
798 Init);
799 for (Value *Op : InitArray->operands()) {
800 Value *V = Op->stripPointerCasts();
801 Check(isa<GlobalVariable>(V) || isa<Function>(V) ||
802 isa<GlobalAlias>(V),
803 Twine("invalid ") + GV.getName() + " member", V);
804 Check(V->hasName(),
805 Twine("members of ") + GV.getName() + " must be named", V);
806 }
807 }
808 }
809 }
810
811 // Visit any debug info attachments.
812 SmallVector<MDNode *, 1> MDs;
813 GV.getMetadata(KindID: LLVMContext::MD_dbg, MDs);
814 for (MDNode *MD : MDs) {
815 if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(Val: MD))
816 visitDIGlobalVariableExpression(N: *GVE);
817 else
818 CheckDI(false, "!dbg attachment of global variable must be a "
819 "DIGlobalVariableExpression");
820 }
821
822 // Scalable vectors cannot be global variables, since we don't know
823 // the runtime size.
824 Check(!GVType->isScalableTy(), "Globals cannot contain scalable types", &GV);
825
826 // Check if it is or contains a target extension type that disallows being
827 // used as a global.
828 Check(!GVType->containsNonGlobalTargetExtType(),
829 "Global @" + GV.getName() + " has illegal target extension type",
830 GVType);
831
832 // Check that the the address space can hold all bits of the type, recognized
833 // by an access in the address space being able to reach all bytes of the
834 // type.
835 Check(!GVType->isSized() ||
836 isUIntN(DL.getAddressSizeInBits(GV.getAddressSpace()),
837 GV.getGlobalSize(DL)),
838 "Global variable is too large to fit into the address space", &GV,
839 GVType);
840
841 if (!GV.hasInitializer()) {
842 visitGlobalValue(GV);
843 return;
844 }
845
846 // Walk any aggregate initializers looking for bitcasts between address spaces
847 visitConstantExprsRecursively(EntryC: GV.getInitializer());
848
849 visitGlobalValue(GV);
850}
851
852void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
853 SmallPtrSet<const GlobalAlias*, 4> Visited;
854 Visited.insert(Ptr: &GA);
855 visitAliaseeSubExpr(Visited, A: GA, C);
856}
857
858void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
859 const GlobalAlias &GA, const Constant &C) {
860 if (GA.hasAvailableExternallyLinkage()) {
861 Check(isa<GlobalValue>(C) &&
862 cast<GlobalValue>(C).hasAvailableExternallyLinkage(),
863 "available_externally alias must point to available_externally "
864 "global value",
865 &GA);
866 }
867 if (const auto *GV = dyn_cast<GlobalValue>(Val: &C)) {
868 if (!GA.hasAvailableExternallyLinkage()) {
869 Check(!GV->isDeclarationForLinker(), "Alias must point to a definition",
870 &GA);
871 }
872
873 if (const auto *GA2 = dyn_cast<GlobalAlias>(Val: GV)) {
874 Check(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
875
876 Check(!GA2->isInterposable(),
877 "Alias cannot point to an interposable alias", &GA);
878 } else {
879 // Only continue verifying subexpressions of GlobalAliases.
880 // Do not recurse into global initializers.
881 return;
882 }
883 }
884
885 if (const auto *CE = dyn_cast<ConstantExpr>(Val: &C))
886 visitConstantExprsRecursively(EntryC: CE);
887
888 for (const Use &U : C.operands()) {
889 Value *V = &*U;
890 if (const auto *GA2 = dyn_cast<GlobalAlias>(Val: V))
891 visitAliaseeSubExpr(Visited, GA, C: *GA2->getAliasee());
892 else if (const auto *C2 = dyn_cast<Constant>(Val: V))
893 visitAliaseeSubExpr(Visited, GA, C: *C2);
894 }
895}
896
897void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
898 Check(GlobalAlias::isValidLinkage(GA.getLinkage()),
899 "Alias should have private, internal, linkonce, weak, linkonce_odr, "
900 "weak_odr, external, or available_externally linkage!",
901 &GA);
902 const Constant *Aliasee = GA.getAliasee();
903 Check(Aliasee, "Aliasee cannot be NULL!", &GA);
904 Check(GA.getType() == Aliasee->getType(),
905 "Alias and aliasee types should match!", &GA);
906
907 Check(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
908 "Aliasee should be either GlobalValue or ConstantExpr", &GA);
909
910 visitAliaseeSubExpr(GA, C: *Aliasee);
911
912 visitGlobalValue(GV: GA);
913}
914
915void Verifier::visitGlobalIFunc(const GlobalIFunc &GI) {
916 visitGlobalValue(GV: GI);
917
918 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
919 GI.getAllMetadata(MDs);
920 for (const auto &I : MDs) {
921 CheckDI(I.first != LLVMContext::MD_dbg,
922 "an ifunc may not have a !dbg attachment", &GI);
923 Check(I.first != LLVMContext::MD_prof,
924 "an ifunc may not have a !prof attachment", &GI);
925 visitMDNode(MD: *I.second, AllowLocs: AreDebugLocsAllowed::No);
926 }
927
928 Check(GlobalIFunc::isValidLinkage(GI.getLinkage()),
929 "IFunc should have private, internal, linkonce, weak, linkonce_odr, "
930 "weak_odr, or external linkage!",
931 &GI);
932 // Pierce through ConstantExprs and GlobalAliases and check that the resolver
933 // is a Function definition.
934 const Function *Resolver = GI.getResolverFunction();
935 Check(Resolver, "IFunc must have a Function resolver", &GI);
936 Check(!Resolver->isDeclarationForLinker(),
937 "IFunc resolver must be a definition", &GI);
938
939 // Check that the immediate resolver operand (prior to any bitcasts) has the
940 // correct type.
941 const Type *ResolverTy = GI.getResolver()->getType();
942
943 Check(isa<PointerType>(Resolver->getFunctionType()->getReturnType()),
944 "IFunc resolver must return a pointer", &GI);
945
946 Check(ResolverTy == PointerType::get(Context, GI.getAddressSpace()),
947 "IFunc resolver has incorrect type", &GI);
948}
949
950void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
951 // There used to be various other llvm.dbg.* nodes, but we don't support
952 // upgrading them and we want to reserve the namespace for future uses.
953 if (NMD.getName().starts_with(Prefix: "llvm.dbg."))
954 CheckDI(NMD.getName() == "llvm.dbg.cu",
955 "unrecognized named metadata node in the llvm.dbg namespace", &NMD);
956 for (const MDNode *MD : NMD.operands()) {
957 if (NMD.getName() == "llvm.dbg.cu")
958 CheckDI(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD);
959
960 if (!MD)
961 continue;
962
963 visitMDNode(MD: *MD, AllowLocs: AreDebugLocsAllowed::Yes);
964 }
965}
966
967/// Parent scope operand of \p S, or null if \p S has no parent (a \c DIFile,
968/// \c DICompileUnit, or non-scope). Mirrors \c DIScope::getScope() without
969/// asserting on unexpected metadata kinds.
970static const Metadata *getRawDIScopeParent(const Metadata *S) {
971 if (!S)
972 return nullptr;
973 if (auto *T = dyn_cast<DIType>(Val: S))
974 return T->getRawScope();
975 if (auto *SP = dyn_cast<DISubprogram>(Val: S))
976 return SP->getRawScope();
977 if (auto *LB = dyn_cast<DILexicalBlockBase>(Val: S))
978 return LB->getRawScope();
979 if (auto *NS = dyn_cast<DINamespace>(Val: S))
980 return NS->getRawScope();
981 if (auto *CB = dyn_cast<DICommonBlock>(Val: S))
982 return CB->getRawScope();
983 if (auto *M = dyn_cast<DIModule>(Val: S))
984 return M->getRawScope();
985 return nullptr;
986}
987
988/// True if following the scope operand from \p S repeats a node.
989bool Verifier::hasDIScopeCycle(const Metadata *S) {
990 SmallPtrSet<const Metadata *, 8> Seen;
991 auto CacheSeen = [&](bool HasCycle) {
992 for (const Metadata *M : Seen)
993 DIScopeChainReachesCycle[M] = HasCycle;
994 return HasCycle;
995 };
996
997 while (auto *Scope = dyn_cast_or_null<DIScope>(Val: S)) {
998 auto It = DIScopeChainReachesCycle.find(Val: Scope);
999 bool IsInCache = It != DIScopeChainReachesCycle.end();
1000 if (IsInCache)
1001 return CacheSeen(It->second);
1002 bool AlreadySeen = !Seen.insert(Ptr: Scope).second;
1003 if (AlreadySeen) // New cycle detected
1004 return CacheSeen(true);
1005 // No new cycle detected
1006 S = getRawDIScopeParent(S: Scope);
1007 }
1008
1009 // Finished walking node chain without detecting any cycles
1010 return CacheSeen(false);
1011}
1012
1013void Verifier::visitDIScopeChain(const DIScope &N) {
1014 CheckDI(!hasDIScopeCycle(&N), "DIScope scope chain must not contain a cycle",
1015 &N);
1016}
1017
1018void Verifier::visitMDNode(const MDNode &BaseMD,
1019 AreDebugLocsAllowed AllowLocs) {
1020 // Only visit each node once. Metadata can be mutually recursive, so this
1021 // avoids infinite recursion here, as well as being an optimization.
1022 if (!MDNodes.insert(Ptr: &BaseMD).second)
1023 return;
1024
1025 std::queue<const MDNode *> Worklist;
1026 Worklist.push(x: &BaseMD);
1027
1028 while (!Worklist.empty()) {
1029 const MDNode *CurrentMD = Worklist.front();
1030 Worklist.pop();
1031 Check(&CurrentMD->getContext() == &Context,
1032 "MDNode context does not match Module context!", CurrentMD);
1033
1034 switch (CurrentMD->getMetadataID()) {
1035 default:
1036 llvm_unreachable("Invalid MDNode subclass");
1037 case Metadata::MDTupleKind:
1038 break;
1039#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
1040 case Metadata::CLASS##Kind: \
1041 visit##CLASS(cast<CLASS>(*CurrentMD)); \
1042 break;
1043#include "llvm/IR/Metadata.def"
1044 }
1045
1046 // A scope chain must terminate.
1047 if (const auto *S = dyn_cast<DIScope>(Val: CurrentMD))
1048 visitDIScopeChain(N: *S);
1049
1050 for (const Metadata *Op : CurrentMD->operands()) {
1051 if (!Op)
1052 continue;
1053 Check(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
1054 CurrentMD, Op);
1055 CheckDI(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed::Yes,
1056 "DILocation not allowed within this metadata node", CurrentMD,
1057 Op);
1058 if (auto *N = dyn_cast<MDNode>(Val: Op)) {
1059 if (MDNodes.insert(Ptr: N).second)
1060 Worklist.push(x: N);
1061 continue;
1062 }
1063 if (auto *V = dyn_cast<ValueAsMetadata>(Val: Op)) {
1064 visitValueAsMetadata(MD: *V, F: nullptr);
1065 continue;
1066 }
1067 }
1068
1069 // FIXME: The nested llvm.loop.* property tags (llvm.loop.align,
1070 // llvm.loop.estimated_trip_count, the boolean enable/disable tags below)
1071 // are only meaningful as operands of an llvm.loop node. Neither llvm.loop's
1072 // structure nor the requirement that these tags appear only within it is
1073 // validated here; the checks below fire on any matching tuple regardless of
1074 // where it appears.
1075
1076 // Check llvm.loop.estimated_trip_count.
1077 if (CurrentMD->getNumOperands() > 0 &&
1078 CurrentMD->getOperand(I: 0).equalsStr(Str: LLVMLoopEstimatedTripCount)) {
1079 Check(CurrentMD->getNumOperands() == 2, "Expected two operands",
1080 CurrentMD);
1081 auto *Count =
1082 dyn_cast_or_null<ConstantAsMetadata>(Val: CurrentMD->getOperand(I: 1));
1083 Check(Count && Count->getType()->isIntegerTy() &&
1084 cast<IntegerType>(Count->getType())->getBitWidth() <= 32,
1085 "Expected second operand to be an integer constant of type i32 or "
1086 "smaller",
1087 CurrentMD);
1088 }
1089
1090 // Check llvm.loop.align.
1091 if (CurrentMD->getNumOperands() > 0 &&
1092 CurrentMD->getOperand(I: 0).equalsStr(Str: "llvm.loop.align")) {
1093 Check(CurrentMD->getNumOperands() == 2, "Expected two operands",
1094 CurrentMD);
1095 auto *AlignMD =
1096 mdconst::dyn_extract_or_null<ConstantInt>(MD: CurrentMD->getOperand(I: 1));
1097 Check(AlignMD && AlignMD->getType()->isIntegerTy(32),
1098 "Expected the alignment to be an integer constant of type i32",
1099 CurrentMD);
1100 if (AlignMD) {
1101 uint64_t Align = AlignMD->getValue().getZExtValue();
1102 Check(isPowerOf2_64(Align),
1103 "Expected the alignment to be a power of two", CurrentMD);
1104 Check(Align <= Value::MaximumAlignment,
1105 "Alignment is larger than the implementation defined limit",
1106 CurrentMD);
1107 }
1108 }
1109
1110 // Enforce the single-operand form of the loop enable/disable pairs.
1111 if (CurrentMD->getNumOperands() > 0 &&
1112 any_of(Range: OldBooleanLoopTags, P: [CurrentMD](const BooleanLoopTags &Tags) {
1113 return CurrentMD->getOperand(I: 0).equalsStr(Str: Tags.Enable) ||
1114 CurrentMD->getOperand(I: 0).equalsStr(Str: Tags.Disable);
1115 }))
1116 Check(CurrentMD->getNumOperands() == 1,
1117 "Expecting only the metadata name", CurrentMD);
1118
1119 // Check these last, so we diagnose problems in operands first.
1120 Check(!CurrentMD->isTemporary(), "Expected no forward declarations!",
1121 CurrentMD);
1122 Check(CurrentMD->isResolved(), "All nodes should be resolved!", CurrentMD);
1123 }
1124}
1125
1126void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
1127 Check(MD.getValue(), "Expected valid value", &MD);
1128 Check(!MD.getValue()->getType()->isMetadataTy(),
1129 "Unexpected metadata round-trip through values", &MD, MD.getValue());
1130
1131 auto *L = dyn_cast<LocalAsMetadata>(Val: &MD);
1132 if (!L)
1133 return;
1134
1135 Check(F, "function-local metadata used outside a function", L);
1136
1137 // If this was an instruction, bb, or argument, verify that it is in the
1138 // function that we expect.
1139 Function *ActualF = nullptr;
1140 if (auto *I = dyn_cast<Instruction>(Val: L->getValue())) {
1141 Check(I->getParent(), "function-local metadata not in basic block", L, I);
1142 ActualF = I->getParent()->getParent();
1143 } else if (auto *BB = dyn_cast<BasicBlock>(Val: L->getValue())) {
1144 ActualF = BB->getParent();
1145 } else if (auto *A = dyn_cast<Argument>(Val: L->getValue())) {
1146 ActualF = A->getParent();
1147 }
1148 assert(ActualF && "Unimplemented function local metadata case!");
1149
1150 Check(ActualF == F, "function-local metadata used in wrong function", L);
1151}
1152
1153void Verifier::visitDIArgList(const DIArgList &AL, Function *F) {
1154 for (const ValueAsMetadata *VAM : AL.getArgs())
1155 visitValueAsMetadata(MD: *VAM, F);
1156}
1157
1158void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
1159 Metadata *MD = MDV.getMetadata();
1160 if (auto *N = dyn_cast<MDNode>(Val: MD)) {
1161 visitMDNode(BaseMD: *N, AllowLocs: AreDebugLocsAllowed::No);
1162 return;
1163 }
1164
1165 // Only visit each node once. Metadata can be mutually recursive, so this
1166 // avoids infinite recursion here, as well as being an optimization.
1167 if (!MDNodes.insert(Ptr: MD).second)
1168 return;
1169
1170 if (auto *V = dyn_cast<ValueAsMetadata>(Val: MD))
1171 visitValueAsMetadata(MD: *V, F);
1172
1173 if (auto *AL = dyn_cast<DIArgList>(Val: MD))
1174 visitDIArgList(AL: *AL, F);
1175}
1176
1177static bool isType(const Metadata *MD) { return !MD || isa<DIType>(Val: MD); }
1178static bool isScope(const Metadata *MD) { return !MD || isa<DIScope>(Val: MD); }
1179static bool isDINode(const Metadata *MD) { return !MD || isa<DINode>(Val: MD); }
1180static bool isMDTuple(const Metadata *MD) { return !MD || isa<MDTuple>(Val: MD); }
1181
1182void Verifier::visitDILocation(const DILocation &N) {
1183 CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1184 "location requires a valid scope", &N, N.getRawScope());
1185 if (auto *IA = N.getRawInlinedAt())
1186 CheckDI(isa<DILocation>(IA), "inlined-at should be a location", &N, IA);
1187 if (auto *SP = dyn_cast<DISubprogram>(Val: N.getRawScope()))
1188 CheckDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
1189}
1190
1191void Verifier::visitGenericDINode(const GenericDINode &N) {
1192 CheckDI(N.getTag(), "invalid tag", &N);
1193}
1194
1195void Verifier::visitDIScope(const DIScope &N) {
1196 if (auto *F = N.getRawFile())
1197 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1198}
1199
1200void Verifier::visitDIType(const DIType &N) {
1201 CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
1202 visitDIScope(N);
1203 CheckDI(N.getRawFile() || N.getLine() == 0, "line specified with no file", &N,
1204 N.getLine());
1205}
1206
1207void Verifier::visitDISubrangeType(const DISubrangeType &N) {
1208 visitDIType(N);
1209
1210 CheckDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
1211 auto *BaseType = N.getRawBaseType();
1212 CheckDI(!BaseType || isType(BaseType), "BaseType must be a type");
1213 auto *LBound = N.getRawLowerBound();
1214 CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
1215 isa<DIVariable>(LBound) || isa<DIExpression>(LBound) ||
1216 isa<DIDerivedType>(LBound),
1217 "LowerBound must be signed constant or DIVariable or DIExpression or "
1218 "DIDerivedType",
1219 &N);
1220 auto *UBound = N.getRawUpperBound();
1221 CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
1222 isa<DIVariable>(UBound) || isa<DIExpression>(UBound) ||
1223 isa<DIDerivedType>(UBound),
1224 "UpperBound must be signed constant or DIVariable or DIExpression or "
1225 "DIDerivedType",
1226 &N);
1227 auto *Stride = N.getRawStride();
1228 CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
1229 isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1230 "Stride must be signed constant or DIVariable or DIExpression", &N);
1231 auto *Bias = N.getRawBias();
1232 CheckDI(!Bias || isa<ConstantAsMetadata>(Bias) || isa<DIVariable>(Bias) ||
1233 isa<DIExpression>(Bias),
1234 "Bias must be signed constant or DIVariable or DIExpression", &N);
1235 // Subrange types currently only support constant size.
1236 auto *Size = N.getRawSizeInBits();
1237 CheckDI(!Size || isa<ConstantAsMetadata>(Size),
1238 "SizeInBits must be a constant");
1239}
1240
1241void Verifier::visitDISubrange(const DISubrange &N) {
1242 CheckDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
1243 CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
1244 "Subrange can have any one of count or upperBound", &N);
1245 auto *CBound = N.getRawCountNode();
1246 CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
1247 isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
1248 "Count must be signed constant or DIVariable or DIExpression", &N);
1249 auto Count = N.getCount();
1250 CheckDI(!Count || !isa<ConstantInt *>(Count) ||
1251 cast<ConstantInt *>(Count)->getSExtValue() >= -1,
1252 "invalid subrange count", &N);
1253 auto *LBound = N.getRawLowerBound();
1254 CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
1255 isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
1256 "LowerBound must be signed constant or DIVariable or DIExpression",
1257 &N);
1258 auto *UBound = N.getRawUpperBound();
1259 CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||
1260 isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
1261 "UpperBound must be signed constant or DIVariable or DIExpression",
1262 &N);
1263 auto *Stride = N.getRawStride();
1264 CheckDI(!Stride || isa<ConstantAsMetadata>(Stride) ||
1265 isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1266 "Stride must be signed constant or DIVariable or DIExpression", &N);
1267}
1268
1269void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) {
1270 CheckDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N);
1271 CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
1272 "GenericSubrange can have any one of count or upperBound", &N);
1273 auto *CBound = N.getRawCountNode();
1274 CheckDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
1275 "Count must be signed constant or DIVariable or DIExpression", &N);
1276 auto *LBound = N.getRawLowerBound();
1277 CheckDI(LBound, "GenericSubrange must contain lowerBound", &N);
1278 CheckDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
1279 "LowerBound must be signed constant or DIVariable or DIExpression",
1280 &N);
1281 auto *UBound = N.getRawUpperBound();
1282 CheckDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),
1283 "UpperBound must be signed constant or DIVariable or DIExpression",
1284 &N);
1285 auto *Stride = N.getRawStride();
1286 CheckDI(Stride, "GenericSubrange must contain stride", &N);
1287 CheckDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),
1288 "Stride must be signed constant or DIVariable or DIExpression", &N);
1289}
1290
1291void Verifier::visitDIEnumerator(const DIEnumerator &N) {
1292 CheckDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
1293}
1294
1295void Verifier::visitDIBasicType(const DIBasicType &N) {
1296 visitDIType(N);
1297
1298 CheckDI(N.getTag() == dwarf::DW_TAG_base_type ||
1299 N.getTag() == dwarf::DW_TAG_unspecified_type ||
1300 N.getTag() == dwarf::DW_TAG_string_type,
1301 "invalid tag", &N);
1302 // Basic types currently only support constant size.
1303 auto *Size = N.getRawSizeInBits();
1304 CheckDI(!Size || isa<ConstantAsMetadata>(Size),
1305 "SizeInBits must be a constant");
1306}
1307
1308void Verifier::visitDIFixedPointType(const DIFixedPointType &N) {
1309 visitDIBasicType(N);
1310
1311 CheckDI(N.getTag() == dwarf::DW_TAG_base_type, "invalid tag", &N);
1312 CheckDI(N.getEncoding() == dwarf::DW_ATE_signed_fixed ||
1313 N.getEncoding() == dwarf::DW_ATE_unsigned_fixed,
1314 "invalid encoding", &N);
1315 CheckDI(N.getKind() == DIFixedPointType::FixedPointBinary ||
1316 N.getKind() == DIFixedPointType::FixedPointDecimal ||
1317 N.getKind() == DIFixedPointType::FixedPointRational,
1318 "invalid kind", &N);
1319 CheckDI(N.getKind() != DIFixedPointType::FixedPointRational ||
1320 N.getFactorRaw() == 0,
1321 "factor should be 0 for rationals", &N);
1322 CheckDI(N.getKind() == DIFixedPointType::FixedPointRational ||
1323 (N.getNumeratorRaw() == 0 && N.getDenominatorRaw() == 0),
1324 "numerator and denominator should be 0 for non-rationals", &N);
1325}
1326
1327void Verifier::visitDIStringType(const DIStringType &N) {
1328 visitDIType(N);
1329
1330 CheckDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N);
1331 CheckDI(!(N.isBigEndian() && N.isLittleEndian()), "has conflicting flags",
1332 &N);
1333}
1334
1335void Verifier::visitDIDerivedType(const DIDerivedType &N) {
1336 // Common type checks.
1337 visitDIType(N);
1338
1339 CheckDI(N.getTag() == dwarf::DW_TAG_typedef ||
1340 N.getTag() == dwarf::DW_TAG_pointer_type ||
1341 N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
1342 N.getTag() == dwarf::DW_TAG_reference_type ||
1343 N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
1344 N.getTag() == dwarf::DW_TAG_const_type ||
1345 N.getTag() == dwarf::DW_TAG_immutable_type ||
1346 N.getTag() == dwarf::DW_TAG_volatile_type ||
1347 N.getTag() == dwarf::DW_TAG_restrict_type ||
1348 N.getTag() == dwarf::DW_TAG_atomic_type ||
1349 N.getTag() == dwarf::DW_TAG_LLVM_ptrauth_type ||
1350 N.getTag() == dwarf::DW_TAG_member ||
1351 (N.getTag() == dwarf::DW_TAG_variable && N.isStaticMember()) ||
1352 N.getTag() == dwarf::DW_TAG_inheritance ||
1353 N.getTag() == dwarf::DW_TAG_friend ||
1354 N.getTag() == dwarf::DW_TAG_set_type ||
1355 N.getTag() == dwarf::DW_TAG_template_alias,
1356 "invalid tag", &N);
1357 if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
1358 CheckDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
1359 N.getRawExtraData());
1360 } else if (N.getTag() == dwarf::DW_TAG_template_alias) {
1361 CheckDI(isMDTuple(N.getRawExtraData()), "invalid template parameters", &N,
1362 N.getRawExtraData());
1363 } else if (N.getTag() == dwarf::DW_TAG_inheritance ||
1364 N.getTag() == dwarf::DW_TAG_member ||
1365 N.getTag() == dwarf::DW_TAG_variable) {
1366 auto *ExtraData = N.getRawExtraData();
1367 auto IsValidExtraData = [&]() {
1368 if (ExtraData == nullptr)
1369 return true;
1370 if (isa<ConstantAsMetadata>(Val: ExtraData) || isa<MDString>(Val: ExtraData) ||
1371 isa<DIObjCProperty>(Val: ExtraData))
1372 return true;
1373 if (auto *Tuple = dyn_cast<MDTuple>(Val: ExtraData)) {
1374 if (Tuple->getNumOperands() != 1)
1375 return false;
1376 return isa_and_nonnull<ConstantAsMetadata>(Val: Tuple->getOperand(I: 0).get());
1377 }
1378 return false;
1379 };
1380 CheckDI(IsValidExtraData(),
1381 "extraData must be ConstantAsMetadata, MDString, DIObjCProperty, "
1382 "or MDTuple with single ConstantAsMetadata operand",
1383 &N, ExtraData);
1384 }
1385
1386 if (N.getTag() == dwarf::DW_TAG_set_type) {
1387 if (auto *T = N.getRawBaseType()) {
1388 auto *Enum = dyn_cast_or_null<DICompositeType>(Val: T);
1389 auto *Subrange = dyn_cast_or_null<DISubrangeType>(Val: T);
1390 auto *Basic = dyn_cast_or_null<DIBasicType>(Val: T);
1391 CheckDI(
1392 (Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||
1393 (Subrange && Subrange->getTag() == dwarf::DW_TAG_subrange_type) ||
1394 (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned ||
1395 Basic->getEncoding() == dwarf::DW_ATE_signed ||
1396 Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||
1397 Basic->getEncoding() == dwarf::DW_ATE_signed_char ||
1398 Basic->getEncoding() == dwarf::DW_ATE_boolean)),
1399 "invalid set base type", &N, T);
1400 }
1401 }
1402
1403 CheckDI(isType(N.getRawBaseType()), "invalid base type", &N,
1404 N.getRawBaseType());
1405
1406 if (N.getDWARFAddressSpace()) {
1407 CheckDI(N.getTag() == dwarf::DW_TAG_pointer_type ||
1408 N.getTag() == dwarf::DW_TAG_reference_type ||
1409 N.getTag() == dwarf::DW_TAG_rvalue_reference_type,
1410 "DWARF address space only applies to pointer or reference types",
1411 &N);
1412 }
1413
1414 auto *Size = N.getRawSizeInBits();
1415 CheckDI(!Size || isa<ConstantAsMetadata>(Size) || isa<DIVariable>(Size) ||
1416 isa<DIExpression>(Size),
1417 "SizeInBits must be a constant or DIVariable or DIExpression");
1418}
1419
1420/// Detect mutually exclusive flags.
1421static bool hasConflictingReferenceFlags(unsigned Flags) {
1422 return ((Flags & DINode::FlagLValueReference) &&
1423 (Flags & DINode::FlagRValueReference)) ||
1424 ((Flags & DINode::FlagTypePassByValue) &&
1425 (Flags & DINode::FlagTypePassByReference));
1426}
1427
1428void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
1429 auto *Params = dyn_cast<MDTuple>(Val: &RawParams);
1430 CheckDI(Params, "invalid template params", &N, &RawParams);
1431 for (Metadata *Op : Params->operands()) {
1432 CheckDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
1433 &N, Params, Op);
1434 }
1435}
1436
1437void Verifier::visitDICompositeType(const DICompositeType &N) {
1438 // Common type checks.
1439 visitDIType(N);
1440
1441 CheckDI(N.getTag() == dwarf::DW_TAG_array_type ||
1442 N.getTag() == dwarf::DW_TAG_structure_type ||
1443 N.getTag() == dwarf::DW_TAG_union_type ||
1444 N.getTag() == dwarf::DW_TAG_enumeration_type ||
1445 N.getTag() == dwarf::DW_TAG_class_type ||
1446 N.getTag() == dwarf::DW_TAG_variant_part ||
1447 N.getTag() == dwarf::DW_TAG_variant ||
1448 N.getTag() == dwarf::DW_TAG_namelist,
1449 "invalid tag", &N);
1450
1451 CheckDI(isType(N.getRawBaseType()), "invalid base type", &N,
1452 N.getRawBaseType());
1453
1454 CheckDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
1455 "invalid composite elements", &N, N.getRawElements());
1456 CheckDI(isType(N.getRawVTableHolder()), "invalid vtable holder", &N,
1457 N.getRawVTableHolder());
1458 CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
1459 "invalid reference flags", &N);
1460 unsigned DIBlockByRefStruct = 1 << 4;
1461 CheckDI((N.getFlags() & DIBlockByRefStruct) == 0,
1462 "DIBlockByRefStruct on DICompositeType is no longer supported", &N);
1463 CheckDI(llvm::all_of(N.getElements(), [](const DINode *N) { return N; }),
1464 "DISubprogram contains null entry in `elements` field", &N);
1465
1466 if (N.isVector()) {
1467 const DINodeArray Elements = N.getElements();
1468 CheckDI(Elements.size() == 1 &&
1469 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,
1470 "invalid vector, expected one element of type subrange", &N);
1471 }
1472
1473 if (auto *Params = N.getRawTemplateParams())
1474 visitTemplateParams(N, RawParams: *Params);
1475
1476 if (auto *D = N.getRawDiscriminator()) {
1477 CheckDI(isa<DIDerivedType>(D) && N.getTag() == dwarf::DW_TAG_variant_part,
1478 "discriminator can only appear on variant part");
1479 }
1480
1481 if (N.getRawDataLocation()) {
1482 CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
1483 "dataLocation can only appear in array type");
1484 }
1485
1486 if (N.getRawAssociated()) {
1487 CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
1488 "associated can only appear in array type");
1489 }
1490
1491 if (N.getRawAllocated()) {
1492 CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
1493 "allocated can only appear in array type");
1494 }
1495
1496 if (N.getRawRank()) {
1497 CheckDI(N.getTag() == dwarf::DW_TAG_array_type,
1498 "rank can only appear in array type");
1499 }
1500
1501 if (N.getTag() == dwarf::DW_TAG_array_type) {
1502 CheckDI(N.getRawBaseType(), "array types must have a base type", &N);
1503 }
1504
1505 auto *Size = N.getRawSizeInBits();
1506 CheckDI(!Size || isa<ConstantAsMetadata>(Size) || isa<DIVariable>(Size) ||
1507 isa<DIExpression>(Size),
1508 "SizeInBits must be a constant or DIVariable or DIExpression");
1509}
1510
1511void Verifier::visitDISubroutineType(const DISubroutineType &N) {
1512 visitDIType(N);
1513 CheckDI(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
1514 if (auto *Types = N.getRawTypeArray()) {
1515 CheckDI(isa<MDTuple>(Types), "invalid composite elements", &N, Types);
1516 for (Metadata *Ty : N.getTypeArray()->operands()) {
1517 CheckDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty);
1518 }
1519 }
1520 CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
1521 "invalid reference flags", &N);
1522}
1523
1524void Verifier::visitDIFile(const DIFile &N) {
1525 CheckDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
1526 std::optional<DIFile::ChecksumInfo<StringRef>> Checksum = N.getChecksum();
1527 if (Checksum) {
1528 CheckDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,
1529 "invalid checksum kind", &N);
1530 size_t Size;
1531 switch (Checksum->Kind) {
1532 case DIFile::CSK_MD5:
1533 Size = 32;
1534 break;
1535 case DIFile::CSK_SHA1:
1536 Size = 40;
1537 break;
1538 case DIFile::CSK_SHA256:
1539 Size = 64;
1540 break;
1541 }
1542 CheckDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
1543 CheckDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,
1544 "invalid checksum", &N);
1545 }
1546}
1547
1548void Verifier::visitDICompileUnit(const DICompileUnit &N) {
1549 CheckDI(N.isDistinct(), "compile units must be distinct", &N);
1550 CheckDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
1551
1552 // Don't bother verifying the compilation directory or producer string
1553 // as those could be empty.
1554 CheckDI(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N,
1555 N.getRawFile());
1556 CheckDI(!N.getFile()->getFilename().empty(), "invalid filename", &N,
1557 N.getFile());
1558
1559 CheckDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),
1560 "invalid emission kind", &N);
1561
1562 CheckDI(N.getSourceLanguage().getDialect() <= dwarf::DW_LLVM_LANG_DIALECT_max,
1563 "invalid language dialect", &N);
1564
1565 if (auto *Array = N.getRawEnumTypes()) {
1566 CheckDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
1567 for (Metadata *Op : N.getEnumTypes()->operands()) {
1568 auto *Enum = dyn_cast_or_null<DICompositeType>(Val: Op);
1569 CheckDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
1570 "invalid enum type", &N, N.getEnumTypes(), Op);
1571 CheckDI(!Enum->getScope() || !isa<DILocalScope>(Enum->getScope()),
1572 "function-local enum in a DICompileUnit's enum list", &N,
1573 N.getEnumTypes(), Op);
1574 }
1575 }
1576 if (auto *Array = N.getRawRetainedTypes()) {
1577 CheckDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
1578 for (Metadata *Op : N.getRetainedTypes()->operands()) {
1579 CheckDI(
1580 Op && (isa<DIType>(Op) || (isa<DISubprogram>(Op) &&
1581 !cast<DISubprogram>(Op)->isDefinition())),
1582 "invalid retained type", &N, Op);
1583 }
1584 }
1585 if (auto *Array = N.getRawGlobalVariables()) {
1586 CheckDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
1587 for (Metadata *Op : N.getGlobalVariables()->operands()) {
1588 auto *GVE = dyn_cast_or_null<DIGlobalVariableExpression>(Val: Op);
1589 CheckDI(GVE, "invalid global variable ref", &N, Op);
1590 CheckDI(!isa_and_nonnull<DILocalScope>(GVE->getVariable()->getScope()),
1591 "function-local variables are not allowed in a DICompileUnit's "
1592 "global variables list",
1593 &N, Op);
1594 }
1595 }
1596 if (auto *Array = N.getRawImportedEntities()) {
1597 CheckDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
1598 for (Metadata *Op : N.getImportedEntities()->operands()) {
1599 auto *IE = dyn_cast_or_null<DIImportedEntity>(Val: Op);
1600 CheckDI(IE, "invalid imported entity ref", &N, Op);
1601 CheckDI(!isa_and_nonnull<DILocalScope>(IE->getScope()),
1602 "function-local imports are not allowed in a DICompileUnit's "
1603 "imported entities list",
1604 &N, Op);
1605 }
1606 }
1607 if (auto *Array = N.getRawMacros()) {
1608 CheckDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
1609 for (Metadata *Op : N.getMacros()->operands()) {
1610 CheckDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
1611 }
1612 }
1613 CUVisited.insert(Ptr: &N);
1614}
1615
1616void Verifier::visitDISubprogram(const DISubprogram &N) {
1617 CheckDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
1618 CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
1619 if (auto *F = N.getRawFile())
1620 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1621 else
1622 CheckDI(N.getLine() == 0, "line specified with no file", &N, N.getLine());
1623 auto *T = N.getRawType();
1624 CheckDI(T, "DISubprogram requires a non-null type", &N);
1625 CheckDI(isa<DISubroutineType>(T), "invalid subroutine type", &N, T);
1626 CheckDI(isType(N.getRawContainingType()), "invalid containing type", &N,
1627 N.getRawContainingType());
1628 if (auto *Params = N.getRawTemplateParams())
1629 visitTemplateParams(N, RawParams: *Params);
1630 if (auto *S = N.getRawDeclaration())
1631 CheckDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
1632 "invalid subprogram declaration", &N, S);
1633 if (auto *RawNode = N.getRawRetainedNodes()) {
1634 auto *Node = dyn_cast<MDTuple>(Val: RawNode);
1635 CheckDI(Node, "invalid retained nodes list", &N, RawNode);
1636
1637 DenseMap<unsigned, DILocalVariable *> Args;
1638 for (Metadata *Op : Node->operands()) {
1639 CheckDI(Op, "nullptr in retained nodes", &N, Node);
1640
1641 auto True = [](const Metadata *) { return true; };
1642 auto False = [](const Metadata *) { return false; };
1643 bool IsTypeCorrect = DISubprogram::visitRetainedNode<bool>(
1644 N: Op, FuncLV&: True, FuncLabel&: True, FuncIE&: True, FuncType&: True, FuncGVE&: True, FuncUnknown&: False);
1645 CheckDI(IsTypeCorrect,
1646 "invalid retained nodes, expected DILocalVariable, DILabel, "
1647 "DIImportedEntity, DIType or DIGlobalVariableExpression",
1648 &N, Node, Op);
1649
1650 auto *RetainedNode = cast<MDNode>(Val: Op);
1651 auto *RetainedNodeScope = dyn_cast_or_null<DILocalScope>(
1652 Val: DISubprogram::getRawRetainedNodeScope(N: RetainedNode));
1653 CheckDI(RetainedNodeScope,
1654 "invalid retained nodes, retained node is not local", &N, Node,
1655 RetainedNode);
1656
1657 DISubprogram *RetainedNodeSP = getSubprogram(LocalScope: RetainedNodeScope);
1658 DICompileUnit *RetainedNodeUnit =
1659 RetainedNodeSP ? RetainedNodeSP->getUnit() : nullptr;
1660 CheckDI(
1661 RetainedNodeSP == &N,
1662 "invalid retained nodes, retained node does not belong to subprogram",
1663 &N, Node, RetainedNode, RetainedNodeScope, RetainedNodeSP,
1664 RetainedNodeUnit);
1665
1666 auto *DV = dyn_cast<DILocalVariable>(Val: RetainedNode);
1667 if (!DV)
1668 continue;
1669 if (unsigned ArgNum = DV->getArg()) {
1670 auto [ArgI, Inserted] = Args.insert(KV: {ArgNum, DV});
1671 CheckDI(Inserted || DV == ArgI->second,
1672 "invalid retained nodes, more than one local variable with the "
1673 "same argument index",
1674 &N, N.getUnit(), Node, RetainedNode, Args[ArgNum]);
1675 }
1676 }
1677 }
1678 CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
1679 "invalid reference flags", &N);
1680
1681 auto *Unit = N.getRawUnit();
1682 if (N.isDefinition()) {
1683 // Subprogram definitions (not part of the type hierarchy).
1684 CheckDI(N.isDistinct(), "subprogram definitions must be distinct", &N);
1685 CheckDI(Unit, "subprogram definitions must have a compile unit", &N);
1686 CheckDI(isa<DICompileUnit>(Unit), "invalid unit type", &N, Unit);
1687 // There's no good way to cross the CU boundary to insert a nested
1688 // DISubprogram definition in one CU into a type defined in another CU.
1689 auto *CT = dyn_cast_or_null<DICompositeType>(Val: N.getRawScope());
1690 if (CT && CT->getRawIdentifier() &&
1691 M.getContext().isODRUniquingDebugTypes())
1692 CheckDI(N.getDeclaration(),
1693 "definition subprograms cannot be nested within DICompositeType "
1694 "when enabling ODR",
1695 &N);
1696 } else {
1697 // Subprogram declarations (part of the type hierarchy).
1698 CheckDI(!Unit, "subprogram declarations must not have a compile unit", &N);
1699 CheckDI(!N.getRawDeclaration(),
1700 "subprogram declaration must not have a declaration field");
1701 }
1702
1703 if (auto *RawThrownTypes = N.getRawThrownTypes()) {
1704 auto *ThrownTypes = dyn_cast<MDTuple>(Val: RawThrownTypes);
1705 CheckDI(ThrownTypes, "invalid thrown types list", &N, RawThrownTypes);
1706 for (Metadata *Op : ThrownTypes->operands())
1707 CheckDI(Op && isa<DIType>(Op), "invalid thrown type", &N, ThrownTypes,
1708 Op);
1709 }
1710
1711 if (N.areAllCallsDescribed())
1712 CheckDI(N.isDefinition(),
1713 "DIFlagAllCallsDescribed must be attached to a definition");
1714}
1715
1716void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
1717 CheckDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
1718 CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1719 "invalid local scope", &N, N.getRawScope());
1720 if (auto *SP = dyn_cast<DISubprogram>(Val: N.getRawScope()))
1721 CheckDI(SP->isDefinition(), "scope points into the type hierarchy", &N);
1722}
1723
1724void Verifier::visitDILexicalBlock(const DILexicalBlock &N) {
1725 visitDILexicalBlockBase(N);
1726
1727 CheckDI(N.getLine() || !N.getColumn(),
1728 "cannot have column info without line info", &N);
1729}
1730
1731void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) {
1732 visitDILexicalBlockBase(N);
1733}
1734
1735void Verifier::visitDICommonBlock(const DICommonBlock &N) {
1736 CheckDI(N.getTag() == dwarf::DW_TAG_common_block, "invalid tag", &N);
1737 if (auto *S = N.getRawScope())
1738 CheckDI(isa<DIScope>(S), "invalid scope ref", &N, S);
1739 if (auto *S = N.getRawDecl())
1740 CheckDI(isa<DIGlobalVariable>(S), "invalid declaration", &N, S);
1741}
1742
1743void Verifier::visitDINamespace(const DINamespace &N) {
1744 CheckDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
1745 if (auto *S = N.getRawScope())
1746 CheckDI(isa<DIScope>(S), "invalid scope ref", &N, S);
1747}
1748
1749void Verifier::visitDIMacro(const DIMacro &N) {
1750 CheckDI(N.getMacinfoType() == dwarf::DW_MACINFO_define ||
1751 N.getMacinfoType() == dwarf::DW_MACINFO_undef,
1752 "invalid macinfo type", &N);
1753 CheckDI(!N.getName().empty(), "anonymous macro", &N);
1754 if (!N.getValue().empty()) {
1755 assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix");
1756 }
1757}
1758
1759void Verifier::visitDIMacroFile(const DIMacroFile &N) {
1760 CheckDI(N.getMacinfoType() == dwarf::DW_MACINFO_start_file,
1761 "invalid macinfo type", &N);
1762 if (auto *F = N.getRawFile())
1763 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1764
1765 if (auto *Array = N.getRawElements()) {
1766 CheckDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
1767 for (Metadata *Op : N.getElements()->operands()) {
1768 CheckDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
1769 }
1770 }
1771}
1772
1773void Verifier::visitDIModule(const DIModule &N) {
1774 CheckDI(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N);
1775 CheckDI(!N.getName().empty(), "anonymous module", &N);
1776}
1777
1778void Verifier::visitDITemplateParameter(const DITemplateParameter &N) {
1779 CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
1780}
1781
1782void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) {
1783 visitDITemplateParameter(N);
1784
1785 CheckDI(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
1786 &N);
1787}
1788
1789void Verifier::visitDITemplateValueParameter(
1790 const DITemplateValueParameter &N) {
1791 visitDITemplateParameter(N);
1792
1793 CheckDI(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
1794 N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
1795 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
1796 "invalid tag", &N);
1797}
1798
1799void Verifier::visitDIVariable(const DIVariable &N) {
1800 if (auto *S = N.getRawScope())
1801 CheckDI(isa<DIScope>(S), "invalid scope", &N, S);
1802 if (auto *F = N.getRawFile())
1803 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1804}
1805
1806void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) {
1807 // Checks common to all variables.
1808 visitDIVariable(N);
1809
1810 CheckDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
1811 CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
1812 // Check only if the global variable is not an extern
1813 if (N.isDefinition())
1814 CheckDI(N.getType(), "missing global variable type", &N);
1815 if (auto *Member = N.getRawStaticDataMemberDeclaration()) {
1816 CheckDI(isa<DIDerivedType>(Member),
1817 "invalid static data member declaration", &N, Member);
1818 }
1819}
1820
1821void Verifier::visitDILocalVariable(const DILocalVariable &N) {
1822 // Checks common to all variables.
1823 visitDIVariable(N);
1824
1825 CheckDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
1826 CheckDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
1827 CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1828 "local variable requires a valid scope", &N, N.getRawScope());
1829 if (auto Ty = N.getType())
1830 CheckDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType());
1831}
1832
1833void Verifier::visitDIAssignID(const DIAssignID &N) {
1834 CheckDI(!N.getNumOperands(), "DIAssignID has no arguments", &N);
1835 CheckDI(N.isDistinct(), "DIAssignID must be distinct", &N);
1836}
1837
1838void Verifier::visitDILabel(const DILabel &N) {
1839 if (auto *S = N.getRawScope())
1840 CheckDI(isa<DIScope>(S), "invalid scope", &N, S);
1841 if (auto *F = N.getRawFile())
1842 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1843
1844 CheckDI(N.getTag() == dwarf::DW_TAG_label, "invalid tag", &N);
1845 CheckDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1846 "label requires a valid scope", &N, N.getRawScope());
1847}
1848
1849void Verifier::visitDIExpression(const DIExpression &N) {
1850 CheckDI(N.isValid(), "invalid expression", &N);
1851}
1852
1853void Verifier::visitDIGlobalVariableExpression(
1854 const DIGlobalVariableExpression &GVE) {
1855 CheckDI(GVE.getVariable(), "missing variable");
1856 if (auto *Var = GVE.getVariable())
1857 visitDIGlobalVariable(N: *Var);
1858 if (auto *Expr = GVE.getExpression()) {
1859 visitDIExpression(N: *Expr);
1860 if (auto Fragment = Expr->getFragmentInfo())
1861 verifyFragmentExpression(V: *GVE.getVariable(), Fragment: *Fragment, Desc: &GVE);
1862 }
1863}
1864
1865void Verifier::visitDIObjCProperty(const DIObjCProperty &N) {
1866 CheckDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
1867 if (auto *T = N.getRawType())
1868 CheckDI(isType(T), "invalid type ref", &N, T);
1869 if (auto *F = N.getRawFile())
1870 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1871}
1872
1873void Verifier::visitDIProperty(const DIProperty &N) {
1874 CheckDI(N.getTag() == dwarf::DW_TAG_property, "invalid tag", &N);
1875 if (auto *T = N.getRawType())
1876 CheckDI(isType(T), "invalid type ref", &N, T);
1877 if (auto *F = N.getRawFile())
1878 CheckDI(isa<DIFile>(F), "invalid file", &N, F);
1879 // DWARF allows a property getter to forward to a subprogram, variable, or
1880 // constant too, but the backend only knows how to forward to a member.
1881 if (DINode *BackingStorage = N.getBackingStorage()) {
1882 auto *DT = dyn_cast<DIDerivedType>(Val: BackingStorage);
1883 CheckDI(DT && DT->getTag() == dwarf::DW_TAG_member,
1884 "property backing storage must be a member", &N, BackingStorage);
1885 }
1886}
1887
1888void Verifier::visitDIImportedEntity(const DIImportedEntity &N) {
1889 CheckDI(N.getTag() == dwarf::DW_TAG_imported_module ||
1890 N.getTag() == dwarf::DW_TAG_imported_declaration,
1891 "invalid tag", &N);
1892 if (auto *S = N.getRawScope())
1893 CheckDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S);
1894 CheckDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,
1895 N.getRawEntity());
1896}
1897
1898void Verifier::visitComdat(const Comdat &C) {
1899 // In COFF the Module is invalid if the GlobalValue has private linkage.
1900 // Entities with private linkage don't have entries in the symbol table.
1901 if (TT.isOSBinFormatCOFF())
1902 if (const GlobalValue *GV = M.getNamedValue(Name: C.getName()))
1903 Check(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
1904 GV);
1905}
1906
1907void Verifier::visitModuleIdents() {
1908 const NamedMDNode *Idents = M.getNamedMetadata(Name: "llvm.ident");
1909 if (!Idents)
1910 return;
1911
1912 // llvm.ident takes a list of metadata entry. Each entry has only one string.
1913 // Scan each llvm.ident entry and make sure that this requirement is met.
1914 for (const MDNode *N : Idents->operands()) {
1915 Check(N->getNumOperands() == 1,
1916 "incorrect number of operands in llvm.ident metadata", N);
1917 Check(dyn_cast_or_null<MDString>(N->getOperand(0)),
1918 ("invalid value for llvm.ident metadata entry operand"
1919 "(the operand should be a string)"),
1920 N->getOperand(0));
1921 }
1922}
1923
1924void Verifier::visitModuleCommandLines() {
1925 const NamedMDNode *CommandLines = M.getNamedMetadata(Name: "llvm.commandline");
1926 if (!CommandLines)
1927 return;
1928
1929 // llvm.commandline takes a list of metadata entry. Each entry has only one
1930 // string. Scan each llvm.commandline entry and make sure that this
1931 // requirement is met.
1932 for (const MDNode *N : CommandLines->operands()) {
1933 Check(N->getNumOperands() == 1,
1934 "incorrect number of operands in llvm.commandline metadata", N);
1935 Check(dyn_cast_or_null<MDString>(N->getOperand(0)),
1936 ("invalid value for llvm.commandline metadata entry operand"
1937 "(the operand should be a string)"),
1938 N->getOperand(0));
1939 }
1940}
1941
1942void Verifier::visitModuleErrnoTBAA() {
1943 const NamedMDNode *ErrnoTBAA = M.getNamedMetadata(Name: "llvm.errno.tbaa");
1944 if (!ErrnoTBAA)
1945 return;
1946
1947 Check(ErrnoTBAA->getNumOperands() >= 1,
1948 "llvm.errno.tbaa must have at least one operand", ErrnoTBAA);
1949
1950 for (const MDNode *N : ErrnoTBAA->operands())
1951 TBAAVerifyHelper.visitTBAAMetadata(I: nullptr, MD: N);
1952}
1953
1954void Verifier::visitModuleFlags() {
1955 const NamedMDNode *Flags = M.getModuleFlagsMetadata();
1956 if (!Flags) return;
1957
1958 // Scan each flag, and track the flags and requirements.
1959 DenseMap<const MDString*, const MDNode*> SeenIDs;
1960 SmallVector<const MDNode*, 16> Requirements;
1961
1962 // Either both aarch64-elf-pauthabi-* flags should be set or none at all.
1963 std::optional<uint64_t> PAuthABIPlatform;
1964 std::optional<uint64_t> PAuthABIVersion;
1965 // Signing of init/fini pointers: address diversity implies basic signing.
1966 uint64_t HasPtrauthInitFini = 0;
1967 uint64_t HasPtrauthInitFiniAddr = 0;
1968
1969 for (const MDNode *MDN : Flags->operands()) {
1970 visitModuleFlag(Op: MDN, SeenIDs, Requirements);
1971 if (MDN->getNumOperands() != 3)
1972 continue;
1973
1974 if (const auto *FlagName = dyn_cast_or_null<MDString>(Val: MDN->getOperand(I: 1))) {
1975 auto GetFlagNamed = [&](StringRef Name) -> std::optional<uint64_t> {
1976 if (FlagName->getString() != Name)
1977 return std::nullopt;
1978 if (const auto *FlagValue =
1979 mdconst::dyn_extract_or_null<ConstantInt>(MD: MDN->getOperand(I: 2)))
1980 return FlagValue->getZExtValue();
1981
1982 CheckFailed(Message: Name + ": module flag expects integer value");
1983 return std::nullopt;
1984 };
1985
1986 if (auto Value = GetFlagNamed("aarch64-elf-pauthabi-platform"))
1987 PAuthABIPlatform = *Value;
1988 else if (auto Value = GetFlagNamed("aarch64-elf-pauthabi-version"))
1989 PAuthABIVersion = *Value;
1990 else if (auto Value = GetFlagNamed("ptrauth-init-fini"))
1991 HasPtrauthInitFini = *Value;
1992 else if (auto Value =
1993 GetFlagNamed("ptrauth-init-fini-address-discrimination"))
1994 HasPtrauthInitFiniAddr = *Value;
1995 }
1996 }
1997
1998 Check(llvm::is_contained({0u, 1u}, HasPtrauthInitFini),
1999 "ptrauth-init-fini must be 0 or 1");
2000 Check(llvm::is_contained({0u, 1u}, HasPtrauthInitFiniAddr),
2001 "ptrauth-init-fini-address-discrimination must be 0 or 1, if set");
2002 if (HasPtrauthInitFiniAddr)
2003 Check(HasPtrauthInitFini, "ptrauth-init-fini-address-discrimination module "
2004 "flag requires ptrauth-init-fini");
2005
2006 if (PAuthABIPlatform.has_value() != PAuthABIVersion.has_value())
2007 CheckFailed(Message: "either both or no 'aarch64-elf-pauthabi-platform' and "
2008 "'aarch64-elf-pauthabi-version' module flags must be present");
2009
2010 // Validate that the requirements in the module are valid.
2011 for (const MDNode *Requirement : Requirements) {
2012 const MDString *Flag = cast<MDString>(Val: Requirement->getOperand(I: 0));
2013 const Metadata *ReqValue = Requirement->getOperand(I: 1);
2014
2015 const MDNode *Op = SeenIDs.lookup(Val: Flag);
2016 if (!Op) {
2017 CheckFailed(Message: "invalid requirement on flag, flag is not present in module",
2018 V1: Flag);
2019 continue;
2020 }
2021
2022 if (Op->getOperand(I: 2) != ReqValue) {
2023 CheckFailed(Message: ("invalid requirement on flag, "
2024 "flag does not have the required value"),
2025 V1: Flag);
2026 continue;
2027 }
2028 }
2029}
2030
2031void
2032Verifier::visitModuleFlag(const MDNode *Op,
2033 DenseMap<const MDString *, const MDNode *> &SeenIDs,
2034 SmallVectorImpl<const MDNode *> &Requirements) {
2035 // Each module flag should have three arguments, the merge behavior (a
2036 // constant int), the flag ID (an MDString), and the value.
2037 Check(Op->getNumOperands() == 3,
2038 "incorrect number of operands in module flag", Op);
2039 Module::ModFlagBehavior MFB;
2040 if (!Module::isValidModFlagBehavior(MD: Op->getOperand(I: 0), MFB)) {
2041 Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
2042 "invalid behavior operand in module flag (expected constant integer)",
2043 Op->getOperand(0));
2044 Check(false,
2045 "invalid behavior operand in module flag (unexpected constant)",
2046 Op->getOperand(0));
2047 }
2048 MDString *ID = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 1));
2049 Check(ID, "invalid ID operand in module flag (expected metadata string)",
2050 Op->getOperand(1));
2051
2052 // Check the values for behaviors with additional requirements.
2053 switch (MFB) {
2054 case Module::Error:
2055 case Module::Warning:
2056 case Module::Override:
2057 // These behavior types accept any value.
2058 break;
2059
2060 case Module::Min: {
2061 auto *V = mdconst::dyn_extract_or_null<ConstantInt>(MD: Op->getOperand(I: 2));
2062 Check(V && V->getValue().isNonNegative(),
2063 "invalid value for 'min' module flag (expected constant non-negative "
2064 "integer)",
2065 Op->getOperand(2));
2066 break;
2067 }
2068
2069 case Module::Max: {
2070 Check(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),
2071 "invalid value for 'max' module flag (expected constant integer)",
2072 Op->getOperand(2));
2073 break;
2074 }
2075
2076 case Module::Require: {
2077 // The value should itself be an MDNode with two operands, a flag ID (an
2078 // MDString), and a value.
2079 auto *Value = dyn_cast<MDNode>(Val: Op->getOperand(I: 2));
2080 Check(Value && Value->getNumOperands() == 2,
2081 "invalid value for 'require' module flag (expected metadata pair)",
2082 Op->getOperand(2));
2083 Check(isa<MDString>(Value->getOperand(0)),
2084 ("invalid value for 'require' module flag "
2085 "(first value operand should be a string)"),
2086 Value->getOperand(0));
2087
2088 // Append it to the list of requirements, to check once all module flags are
2089 // scanned.
2090 Requirements.push_back(Elt: Value);
2091 break;
2092 }
2093
2094 case Module::Append:
2095 case Module::AppendUnique: {
2096 // These behavior types require the operand be an MDNode.
2097 Check(isa<MDNode>(Op->getOperand(2)),
2098 "invalid value for 'append'-type module flag "
2099 "(expected a metadata node)",
2100 Op->getOperand(2));
2101 break;
2102 }
2103 }
2104
2105 // Unless this is a "requires" flag, check the ID is unique.
2106 if (MFB != Module::Require) {
2107 bool Inserted = SeenIDs.insert(KV: std::make_pair(x&: ID, y&: Op)).second;
2108 Check(Inserted,
2109 "module flag identifiers must be unique (or of 'require' type)", ID);
2110 }
2111
2112 StringRef Name = ID->getString();
2113 if (Name == "wchar_size") {
2114 ConstantInt *Value
2115 = mdconst::dyn_extract_or_null<ConstantInt>(MD: Op->getOperand(I: 2));
2116 Check(Value, "wchar_size metadata requires constant integer argument");
2117 return;
2118 }
2119
2120 if (Name == "long-double-type") {
2121 Check(MFB == Module::Error,
2122 "long-double-type module flag must use 'error' merge behavior", Op);
2123 const MDString *Value = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 2));
2124 Check(Value, "long-double-type metadata requires a string argument");
2125 if (Value)
2126 Check(parseLongDoubleFormat(Value->getString()).has_value(),
2127 "invalid long-double-type metadata value", Op);
2128 return;
2129 }
2130
2131 if (Name == "float-abi") {
2132 Check(MFB == Module::Error,
2133 "float-abi module flag must use 'error' merge behavior", Op);
2134 const MDString *Value = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 2));
2135 Check(Value, "float-abi metadata requires a string argument");
2136 if (Value)
2137 Check(FloatABI::parseABIType(Value->getString()).has_value(),
2138 "invalid float-abi metadata value", Op);
2139 return;
2140 }
2141
2142 if (Name == "thread-model") {
2143 Check(MFB == Module::Error,
2144 "thread-model module flag must use 'error' merge behavior", Op);
2145 const MDString *Value = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 2));
2146 Check(Value, "thread-model metadata requires a string argument");
2147 if (Value)
2148 Check(parseThreadModel(Value->getString()).has_value(),
2149 "invalid thread-model metadata value", Op);
2150 return;
2151 }
2152
2153 if (Name == "target-abi") {
2154 const MDString *Value = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 2));
2155 Check(Value && !Value->getString().empty(),
2156 "target-abi metadata requires a non-empty string argument", Op);
2157 return;
2158 }
2159
2160 if (ID->getString() == "exception-model") {
2161 Check(MFB == Module::Error,
2162 "exception-model module flag must use 'error' merge behavior", Op);
2163 const MDString *Value = dyn_cast_or_null<MDString>(Val: Op->getOperand(I: 2));
2164 Check(Value, "exception-model metadata requires a string argument");
2165 if (Value)
2166 Check(parseExceptionModel(Value->getString()).has_value(),
2167 "invalid exception-model metadata value", Op);
2168 return;
2169 }
2170
2171 if (Name == "Linker Options") {
2172 // If the llvm.linker.options named metadata exists, we assume that the
2173 // bitcode reader has upgraded the module flag. Otherwise the flag might
2174 // have been created by a client directly.
2175 Check(M.getNamedMetadata("llvm.linker.options"),
2176 "'Linker Options' named metadata no longer supported");
2177 return;
2178 }
2179
2180 if (Name == "SemanticInterposition") {
2181 ConstantInt *Value =
2182 mdconst::dyn_extract_or_null<ConstantInt>(MD: Op->getOperand(I: 2));
2183 Check(Value,
2184 "SemanticInterposition metadata requires constant integer argument");
2185 return;
2186 }
2187
2188 if (Name == "CG Profile") {
2189 for (const MDOperand &MDO : cast<MDNode>(Val: Op->getOperand(I: 2))->operands())
2190 visitModuleFlagCGProfileEntry(MDO);
2191 return;
2192 }
2193
2194 // Target-specific module flag checks.
2195 verifyAMDGPUModuleFlag(VS&: *this, ID, MFB, Op);
2196}
2197
2198void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) {
2199 auto CheckFunction = [&](const MDOperand &FuncMDO) {
2200 if (!FuncMDO)
2201 return;
2202 auto F = dyn_cast<ValueAsMetadata>(Val: FuncMDO);
2203 Check(F && isa<Function>(F->getValue()->stripPointerCasts()),
2204 "expected a Function or null", FuncMDO);
2205 };
2206 auto Node = dyn_cast_or_null<MDNode>(Val: MDO);
2207 Check(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO);
2208 CheckFunction(Node->getOperand(I: 0));
2209 CheckFunction(Node->getOperand(I: 1));
2210 auto Count = dyn_cast_or_null<ConstantAsMetadata>(Val: Node->getOperand(I: 2));
2211 Check(Count && Count->getType()->isIntegerTy(),
2212 "expected an integer constant", Node->getOperand(2));
2213}
2214
2215void Verifier::verifyAttributeTypes(AttributeSet Attrs, const Value *V) {
2216 for (Attribute A : Attrs) {
2217
2218 if (A.isStringAttribute()) {
2219#define GET_ATTR_NAMES
2220#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)
2221#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
2222 if (A.getKindAsString() == #DISPLAY_NAME) { \
2223 auto V = A.getValueAsString(); \
2224 if (!(V.empty() || V == "true" || V == "false")) \
2225 CheckFailed("invalid value for '" #DISPLAY_NAME "' attribute: " + V + \
2226 ""); \
2227 }
2228
2229#include "llvm/IR/Attributes.inc"
2230 continue;
2231 }
2232
2233 if (A.isIntAttribute() != Attribute::isIntAttrKind(Kind: A.getKindAsEnum())) {
2234 CheckFailed(Message: "Attribute '" + A.getAsString() + "' should have an Argument",
2235 V1: V);
2236 return;
2237 }
2238 }
2239}
2240
2241// VerifyParameterAttrs - Check the given attributes for an argument or return
2242// value of the specified type. The value V is printed in error messages.
2243void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
2244 const Value *V) {
2245 if (!Attrs.hasAttributes())
2246 return;
2247
2248 verifyAttributeTypes(Attrs, V);
2249
2250 for (Attribute Attr : Attrs)
2251 Check(Attr.isStringAttribute() ||
2252 Attribute::canUseAsParamAttr(Attr.getKindAsEnum()),
2253 "Attribute '" + Attr.getAsString() + "' does not apply to parameters",
2254 V);
2255
2256 if (Attrs.hasAttribute(Kind: Attribute::ImmArg)) {
2257 unsigned AttrCount =
2258 Attrs.getNumAttributes() - Attrs.hasAttribute(Kind: Attribute::Range);
2259 Check(AttrCount == 1,
2260 "Attribute 'immarg' is incompatible with other attributes except the "
2261 "'range' attribute",
2262 V);
2263 }
2264
2265 // Check for mutually incompatible attributes. Only inreg is compatible with
2266 // sret.
2267 unsigned AttrCount = 0;
2268 AttrCount += Attrs.hasAttribute(Kind: Attribute::ByVal);
2269 AttrCount += Attrs.hasAttribute(Kind: Attribute::InAlloca);
2270 AttrCount += Attrs.hasAttribute(Kind: Attribute::Preallocated);
2271 AttrCount += Attrs.hasAttribute(Kind: Attribute::StructRet) ||
2272 Attrs.hasAttribute(Kind: Attribute::InReg);
2273 AttrCount += Attrs.hasAttribute(Kind: Attribute::Nest);
2274 AttrCount += Attrs.hasAttribute(Kind: Attribute::ByRef);
2275 Check(AttrCount <= 1,
2276 "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
2277 "'byref', and 'sret' are incompatible!",
2278 V);
2279
2280 Check(!(Attrs.hasAttribute(Attribute::InAlloca) &&
2281 Attrs.hasAttribute(Attribute::ReadOnly)),
2282 "Attributes "
2283 "'inalloca and readonly' are incompatible!",
2284 V);
2285
2286 Check(!(Attrs.hasAttribute(Attribute::StructRet) &&
2287 Attrs.hasAttribute(Attribute::Returned)),
2288 "Attributes "
2289 "'sret and returned' are incompatible!",
2290 V);
2291
2292 Check(!(Attrs.hasAttribute(Attribute::ZExt) &&
2293 Attrs.hasAttribute(Attribute::SExt)),
2294 "Attributes "
2295 "'zeroext and signext' are incompatible!",
2296 V);
2297
2298 Check(!(Attrs.hasAttribute(Attribute::ReadNone) &&
2299 Attrs.hasAttribute(Attribute::ReadOnly)),
2300 "Attributes "
2301 "'readnone and readonly' are incompatible!",
2302 V);
2303
2304 Check(!(Attrs.hasAttribute(Attribute::ReadNone) &&
2305 Attrs.hasAttribute(Attribute::WriteOnly)),
2306 "Attributes "
2307 "'readnone and writeonly' are incompatible!",
2308 V);
2309
2310 Check(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
2311 Attrs.hasAttribute(Attribute::WriteOnly)),
2312 "Attributes "
2313 "'readonly and writeonly' are incompatible!",
2314 V);
2315
2316 Check(!(Attrs.hasAttribute(Attribute::NoInline) &&
2317 Attrs.hasAttribute(Attribute::AlwaysInline)),
2318 "Attributes "
2319 "'noinline and alwaysinline' are incompatible!",
2320 V);
2321
2322 Check(!(Attrs.hasAttribute(Attribute::Writable) &&
2323 Attrs.hasAttribute(Attribute::ReadNone)),
2324 "Attributes writable and readnone are incompatible!", V);
2325
2326 Check(!(Attrs.hasAttribute(Attribute::Writable) &&
2327 Attrs.hasAttribute(Attribute::ReadOnly)),
2328 "Attributes writable and readonly are incompatible!", V);
2329
2330 AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(Ty, AS: Attrs);
2331 for (Attribute Attr : Attrs) {
2332 if (!Attr.isStringAttribute() &&
2333 IncompatibleAttrs.contains(A: Attr.getKindAsEnum())) {
2334 CheckFailed(Message: "Attribute '" + Attr.getAsString() +
2335 "' applied to incompatible type!", V1: V);
2336 return;
2337 }
2338 }
2339
2340 if (isa<PointerType>(Val: Ty)) {
2341 if (Attrs.hasAttribute(Kind: Attribute::Alignment)) {
2342 Align AttrAlign = Attrs.getAlignment().valueOrOne();
2343 Check(AttrAlign.value() <= Value::MaximumAlignment,
2344 "huge alignment values are unsupported", V);
2345 }
2346 if (Attrs.hasAttribute(Kind: Attribute::ByVal)) {
2347 Type *ByValTy = Attrs.getByValType();
2348 Check(ByValTy->isSized(),
2349 "Attribute 'byval' does not support unsized types!", V);
2350 // Check if it is or contains a target extension type that disallows being
2351 // used on the stack.
2352 Check(!ByValTy->containsNonLocalTargetExtType(),
2353 "'byval' argument has illegal target extension type", V);
2354 Check(DL.getTypeAllocSize(ByValTy).getKnownMinValue() < (1ULL << 32),
2355 "huge 'byval' arguments are unsupported", V);
2356 }
2357 if (Attrs.hasAttribute(Kind: Attribute::ByRef)) {
2358 Check(Attrs.getByRefType()->isSized(),
2359 "Attribute 'byref' does not support unsized types!", V);
2360 Check(DL.getTypeAllocSize(Attrs.getByRefType()).getKnownMinValue() <
2361 (1ULL << 32),
2362 "huge 'byref' arguments are unsupported", V);
2363 }
2364 if (Attrs.hasAttribute(Kind: Attribute::InAlloca)) {
2365 Check(Attrs.getInAllocaType()->isSized(),
2366 "Attribute 'inalloca' does not support unsized types!", V);
2367 Check(DL.getTypeAllocSize(Attrs.getInAllocaType()).getKnownMinValue() <
2368 (1ULL << 32),
2369 "huge 'inalloca' arguments are unsupported", V);
2370 }
2371 if (Attrs.hasAttribute(Kind: Attribute::Preallocated)) {
2372 Check(Attrs.getPreallocatedType()->isSized(),
2373 "Attribute 'preallocated' does not support unsized types!", V);
2374 Check(
2375 DL.getTypeAllocSize(Attrs.getPreallocatedType()).getKnownMinValue() <
2376 (1ULL << 32),
2377 "huge 'preallocated' arguments are unsupported", V);
2378 }
2379 }
2380
2381 if (Attrs.hasAttribute(Kind: Attribute::Initializes)) {
2382 auto Inits = Attrs.getAttribute(Kind: Attribute::Initializes).getInitializes();
2383 Check(!Inits.empty(), "Attribute 'initializes' does not support empty list",
2384 V);
2385 Check(ConstantRangeList::isOrderedRanges(Inits),
2386 "Attribute 'initializes' does not support unordered ranges", V);
2387 }
2388
2389 if (Attrs.hasAttribute(Kind: Attribute::NoFPClass)) {
2390 uint64_t Val = Attrs.getAttribute(Kind: Attribute::NoFPClass).getValueAsInt();
2391 Check(Val != 0, "Attribute 'nofpclass' must have at least one test bit set",
2392 V);
2393 Check((Val & ~static_cast<unsigned>(fcAllFlags)) == 0,
2394 "Invalid value for 'nofpclass' test mask", V);
2395 }
2396 if (Attrs.hasAttribute(Kind: Attribute::Range)) {
2397 const ConstantRange &CR =
2398 Attrs.getAttribute(Kind: Attribute::Range).getValueAsConstantRange();
2399 Check(Ty->isIntOrIntVectorTy(CR.getBitWidth()),
2400 "Range bit width must match type bit width!", V);
2401 }
2402}
2403
2404void Verifier::checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
2405 const Value *V) {
2406 if (Attrs.hasFnAttr(Kind: Attr)) {
2407 StringRef S = Attrs.getFnAttr(Kind: Attr).getValueAsString();
2408 unsigned N;
2409 if (S.getAsInteger(Radix: 10, Result&: N))
2410 CheckFailed(Message: "\"" + Attr + "\" takes an unsigned integer: " + S, V1: V);
2411 }
2412}
2413
2414// Check parameter attributes against a function type.
2415// The value V is printed in error messages.
2416void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
2417 const Value *V, bool IsIntrinsic,
2418 bool IsInlineAsm) {
2419 if (Attrs.isEmpty())
2420 return;
2421
2422 if (AttributeListsVisited.insert(Ptr: Attrs.getRawPointer()).second) {
2423 Check(Attrs.hasParentContext(Context),
2424 "Attribute list does not match Module context!", &Attrs, V);
2425 for (const auto &AttrSet : Attrs) {
2426 Check(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),
2427 "Attribute set does not match Module context!", &AttrSet, V);
2428 for (const auto &A : AttrSet) {
2429 Check(A.hasParentContext(Context),
2430 "Attribute does not match Module context!", &A, V);
2431 }
2432 }
2433 }
2434
2435 bool SawNest = false;
2436 bool SawReturned = false;
2437 bool SawSRet = false;
2438 bool SawSwiftSelf = false;
2439 bool SawSwiftAsync = false;
2440 bool SawSwiftError = false;
2441
2442 // Verify return value attributes.
2443 AttributeSet RetAttrs = Attrs.getRetAttrs();
2444 for (Attribute RetAttr : RetAttrs)
2445 Check(RetAttr.isStringAttribute() ||
2446 Attribute::canUseAsRetAttr(RetAttr.getKindAsEnum()),
2447 "Attribute '" + RetAttr.getAsString() +
2448 "' does not apply to function return values",
2449 V);
2450
2451 unsigned MaxParameterWidth = 0;
2452 auto GetMaxParameterWidth = [&MaxParameterWidth](Type *Ty) {
2453 if (Ty->isVectorTy()) {
2454 if (auto *VT = dyn_cast<FixedVectorType>(Val: Ty)) {
2455 unsigned Size = VT->getPrimitiveSizeInBits().getFixedValue();
2456 if (Size > MaxParameterWidth)
2457 MaxParameterWidth = Size;
2458 }
2459 }
2460 };
2461 GetMaxParameterWidth(FT->getReturnType());
2462 verifyParameterAttrs(Attrs: RetAttrs, Ty: FT->getReturnType(), V);
2463
2464 // Verify parameter attributes.
2465 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2466 Type *Ty = FT->getParamType(i);
2467 AttributeSet ArgAttrs = Attrs.getParamAttrs(ArgNo: i);
2468
2469 if (!IsIntrinsic) {
2470 Check(!ArgAttrs.hasAttribute(Attribute::ImmArg),
2471 "immarg attribute only applies to intrinsics", V);
2472 if (!IsInlineAsm)
2473 Check(!ArgAttrs.hasAttribute(Attribute::ElementType),
2474 "Attribute 'elementtype' can only be applied to intrinsics"
2475 " and inline asm.",
2476 V);
2477 }
2478
2479 verifyParameterAttrs(Attrs: ArgAttrs, Ty, V);
2480 GetMaxParameterWidth(Ty);
2481
2482 if (ArgAttrs.hasAttribute(Kind: Attribute::Nest)) {
2483 Check(!SawNest, "More than one parameter has attribute nest!", V);
2484 SawNest = true;
2485 }
2486
2487 if (ArgAttrs.hasAttribute(Kind: Attribute::Returned)) {
2488 Check(!SawReturned, "More than one parameter has attribute returned!", V);
2489 Check(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
2490 "Incompatible argument and return types for 'returned' attribute",
2491 V);
2492 SawReturned = true;
2493 }
2494
2495 if (ArgAttrs.hasAttribute(Kind: Attribute::StructRet)) {
2496 Check(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
2497 Check(i == 0 || i == 1,
2498 "Attribute 'sret' is not on first or second parameter!", V);
2499 SawSRet = true;
2500 }
2501
2502 if (ArgAttrs.hasAttribute(Kind: Attribute::SwiftSelf)) {
2503 Check(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V);
2504 SawSwiftSelf = true;
2505 }
2506
2507 if (ArgAttrs.hasAttribute(Kind: Attribute::SwiftAsync)) {
2508 Check(!SawSwiftAsync, "Cannot have multiple 'swiftasync' parameters!", V);
2509 SawSwiftAsync = true;
2510 }
2511
2512 if (ArgAttrs.hasAttribute(Kind: Attribute::SwiftError)) {
2513 Check(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!", V);
2514 SawSwiftError = true;
2515 }
2516
2517 if (ArgAttrs.hasAttribute(Kind: Attribute::InAlloca)) {
2518 Check(i == FT->getNumParams() - 1,
2519 "inalloca isn't on the last parameter!", V);
2520 }
2521 }
2522
2523 if (!Attrs.hasFnAttrs())
2524 return;
2525
2526 verifyAttributeTypes(Attrs: Attrs.getFnAttrs(), V);
2527 for (Attribute FnAttr : Attrs.getFnAttrs())
2528 Check(FnAttr.isStringAttribute() ||
2529 Attribute::canUseAsFnAttr(FnAttr.getKindAsEnum()),
2530 "Attribute '" + FnAttr.getAsString() +
2531 "' does not apply to functions!",
2532 V);
2533
2534 Check(!(Attrs.hasFnAttr(Attribute::NoInline) &&
2535 Attrs.hasFnAttr(Attribute::AlwaysInline)),
2536 "Attributes 'noinline and alwaysinline' are incompatible!", V);
2537
2538 if (Attrs.hasFnAttr(Kind: Attribute::OptimizeNone)) {
2539 Check(Attrs.hasFnAttr(Attribute::NoInline),
2540 "Attribute 'optnone' requires 'noinline'!", V);
2541
2542 Check(!Attrs.hasFnAttr(Attribute::OptimizeForSize),
2543 "Attributes 'optsize and optnone' are incompatible!", V);
2544
2545 Check(!Attrs.hasFnAttr(Attribute::MinSize),
2546 "Attributes 'minsize and optnone' are incompatible!", V);
2547
2548 Check(!Attrs.hasFnAttr(Attribute::OptimizeForDebugging),
2549 "Attributes 'optdebug and optnone' are incompatible!", V);
2550 }
2551
2552 Check(!(Attrs.hasFnAttr(Attribute::SanitizeRealtime) &&
2553 Attrs.hasFnAttr(Attribute::SanitizeRealtimeBlocking)),
2554 "Attributes "
2555 "'sanitize_realtime and sanitize_realtime_blocking' are incompatible!",
2556 V);
2557
2558 if (Attrs.hasFnAttr(Kind: Attribute::OptimizeForDebugging)) {
2559 Check(!Attrs.hasFnAttr(Attribute::OptimizeForSize),
2560 "Attributes 'optsize and optdebug' are incompatible!", V);
2561
2562 Check(!Attrs.hasFnAttr(Attribute::MinSize),
2563 "Attributes 'minsize and optdebug' are incompatible!", V);
2564 }
2565
2566 Check(!Attrs.hasAttrSomewhere(Attribute::Writable) ||
2567 isModSet(Attrs.getMemoryEffects().getModRef(IRMemLocation::ArgMem)),
2568 "Attribute writable and memory without argmem: write are incompatible!",
2569 V);
2570
2571 if (Attrs.hasFnAttr(Kind: "aarch64_pstate_sm_enabled")) {
2572 Check(!Attrs.hasFnAttr("aarch64_pstate_sm_compatible"),
2573 "Attributes 'aarch64_pstate_sm_enabled and "
2574 "aarch64_pstate_sm_compatible' are incompatible!",
2575 V);
2576 }
2577
2578 Check((Attrs.hasFnAttr("aarch64_new_za") + Attrs.hasFnAttr("aarch64_in_za") +
2579 Attrs.hasFnAttr("aarch64_inout_za") +
2580 Attrs.hasFnAttr("aarch64_out_za") +
2581 Attrs.hasFnAttr("aarch64_preserves_za") +
2582 Attrs.hasFnAttr("aarch64_za_state_agnostic")) <= 1,
2583 "Attributes 'aarch64_new_za', 'aarch64_in_za', 'aarch64_out_za', "
2584 "'aarch64_inout_za', 'aarch64_preserves_za' and "
2585 "'aarch64_za_state_agnostic' are mutually exclusive",
2586 V);
2587
2588 Check((Attrs.hasFnAttr("aarch64_new_zt0") +
2589 Attrs.hasFnAttr("aarch64_in_zt0") +
2590 Attrs.hasFnAttr("aarch64_inout_zt0") +
2591 Attrs.hasFnAttr("aarch64_out_zt0") +
2592 Attrs.hasFnAttr("aarch64_preserves_zt0") +
2593 Attrs.hasFnAttr("aarch64_za_state_agnostic")) <= 1,
2594 "Attributes 'aarch64_new_zt0', 'aarch64_in_zt0', 'aarch64_out_zt0', "
2595 "'aarch64_inout_zt0', 'aarch64_preserves_zt0' and "
2596 "'aarch64_za_state_agnostic' are mutually exclusive",
2597 V);
2598
2599 if (Attrs.hasFnAttr(Kind: Attribute::JumpTable)) {
2600 const GlobalValue *GV = cast<GlobalValue>(Val: V);
2601 Check(GV->hasGlobalUnnamedAddr(),
2602 "Attribute 'jumptable' requires 'unnamed_addr'", V);
2603 }
2604
2605 if (auto Args = Attrs.getFnAttrs().getAllocSizeArgs()) {
2606 auto CheckParam = [&](StringRef Name, unsigned ParamNo) {
2607 if (ParamNo >= FT->getNumParams()) {
2608 CheckFailed(Message: "'allocsize' " + Name + " argument is out of bounds", V1: V);
2609 return false;
2610 }
2611
2612 if (!FT->getParamType(i: ParamNo)->isIntegerTy()) {
2613 CheckFailed(Message: "'allocsize' " + Name +
2614 " argument must refer to an integer parameter",
2615 V1: V);
2616 return false;
2617 }
2618
2619 return true;
2620 };
2621
2622 if (!CheckParam("element size", Args->first))
2623 return;
2624
2625 if (Args->second && !CheckParam("number of elements", *Args->second))
2626 return;
2627 }
2628
2629 if (Attrs.hasFnAttr(Kind: Attribute::AllocKind)) {
2630 AllocFnKind K = Attrs.getAllocKind();
2631 AllocFnKind Type =
2632 K & (AllocFnKind::Alloc | AllocFnKind::Realloc | AllocFnKind::Free);
2633 if (!is_contained(
2634 Set: {AllocFnKind::Alloc, AllocFnKind::Realloc, AllocFnKind::Free},
2635 Element: Type))
2636 CheckFailed(
2637 Message: "'allockind()' requires exactly one of alloc, realloc, and free");
2638 if ((Type == AllocFnKind::Free) &&
2639 ((K & (AllocFnKind::Uninitialized | AllocFnKind::Zeroed |
2640 AllocFnKind::Aligned)) != AllocFnKind::Unknown))
2641 CheckFailed(Message: "'allockind(\"free\")' doesn't allow uninitialized, zeroed, "
2642 "or aligned modifiers.");
2643 AllocFnKind ZeroedUninit = AllocFnKind::Uninitialized | AllocFnKind::Zeroed;
2644 if ((K & ZeroedUninit) == ZeroedUninit)
2645 CheckFailed(Message: "'allockind()' can't be both zeroed and uninitialized");
2646 }
2647
2648 if (Attribute A = Attrs.getFnAttr(Kind: "alloc-variant-zeroed"); A.isValid()) {
2649 StringRef S = A.getValueAsString();
2650 Check(!S.empty(), "'alloc-variant-zeroed' must not be empty");
2651 Function *Variant = M.getFunction(Name: S);
2652 if (Variant) {
2653 Attribute Family = Attrs.getFnAttr(Kind: "alloc-family");
2654 Attribute VariantFamily = Variant->getFnAttribute(Kind: "alloc-family");
2655 if (Family.isValid())
2656 Check(VariantFamily.isValid() &&
2657 VariantFamily.getValueAsString() == Family.getValueAsString(),
2658 "'alloc-variant-zeroed' must name a function belonging to the "
2659 "same 'alloc-family'");
2660
2661 Check(Variant->hasFnAttribute(Attribute::AllocKind) &&
2662 (Variant->getFnAttribute(Attribute::AllocKind).getAllocKind() &
2663 AllocFnKind::Zeroed) != AllocFnKind::Unknown,
2664 "'alloc-variant-zeroed' must name a function with "
2665 "'allockind(\"zeroed\")'");
2666
2667 Check(FT == Variant->getFunctionType(),
2668 "'alloc-variant-zeroed' must name a function with the same "
2669 "signature");
2670
2671 if (const auto *F = dyn_cast<Function>(Val: V))
2672 Check(F->getCallingConv() == Variant->getCallingConv(),
2673 "'alloc-variant-zeroed' must name a function with the same "
2674 "calling convention");
2675 }
2676 }
2677
2678 if (Attrs.hasFnAttr(Kind: Attribute::VScaleRange)) {
2679 unsigned VScaleMin = Attrs.getFnAttrs().getVScaleRangeMin();
2680 if (VScaleMin == 0)
2681 CheckFailed(Message: "'vscale_range' minimum must be greater than 0", V1: V);
2682 else if (!isPowerOf2_32(Value: VScaleMin))
2683 CheckFailed(Message: "'vscale_range' minimum must be power-of-two value", V1: V);
2684 std::optional<unsigned> VScaleMax = Attrs.getFnAttrs().getVScaleRangeMax();
2685 if (VScaleMax && VScaleMin > VScaleMax)
2686 CheckFailed(Message: "'vscale_range' minimum cannot be greater than maximum", V1: V);
2687 else if (VScaleMax && !isPowerOf2_32(Value: *VScaleMax))
2688 CheckFailed(Message: "'vscale_range' maximum must be power-of-two value", V1: V);
2689 }
2690
2691 if (Attribute FPAttr = Attrs.getFnAttr(Kind: "frame-pointer"); FPAttr.isValid()) {
2692 StringRef FP = FPAttr.getValueAsString();
2693 if (FP != "all" && FP != "non-leaf" && FP != "none" && FP != "reserved" &&
2694 FP != "non-leaf-no-reserve")
2695 CheckFailed(Message: "invalid value for 'frame-pointer' attribute: " + FP, V1: V);
2696 }
2697
2698 checkUnsignedBaseTenFuncAttr(Attrs, Attr: "tail-pad-to-size", V);
2699 checkUnsignedBaseTenFuncAttr(Attrs, Attr: "tail-pad-value", V);
2700 checkUnsignedBaseTenFuncAttr(Attrs, Attr: "patchable-function-prefix", V);
2701 checkUnsignedBaseTenFuncAttr(Attrs, Attr: "patchable-function-entry", V);
2702 if (Attrs.hasFnAttr(Kind: "patchable-function-entry-section"))
2703 Check(!Attrs.getFnAttr("patchable-function-entry-section")
2704 .getValueAsString()
2705 .empty(),
2706 "\"patchable-function-entry-section\" must not be empty");
2707 checkUnsignedBaseTenFuncAttr(Attrs, Attr: "warn-stack-size", V);
2708
2709 if (auto A = Attrs.getFnAttr(Kind: "sign-return-address"); A.isValid()) {
2710 StringRef S = A.getValueAsString();
2711 if (S != "none" && S != "all" && S != "non-leaf")
2712 CheckFailed(Message: "invalid value for 'sign-return-address' attribute: " + S, V1: V);
2713 }
2714
2715 if (auto A = Attrs.getFnAttr(Kind: "sign-return-address-key"); A.isValid()) {
2716 StringRef S = A.getValueAsString();
2717 if (S != "a_key" && S != "b_key")
2718 CheckFailed(Message: "invalid value for 'sign-return-address-key' attribute: " + S,
2719 V1: V);
2720 if (auto AA = Attrs.getFnAttr(Kind: "sign-return-address"); !AA.isValid()) {
2721 CheckFailed(
2722 Message: "'sign-return-address-key' present without `sign-return-address`");
2723 }
2724 }
2725
2726 if (auto A = Attrs.getFnAttr(Kind: "branch-target-enforcement"); A.isValid()) {
2727 StringRef S = A.getValueAsString();
2728 if (S != "" && S != "true" && S != "false")
2729 CheckFailed(
2730 Message: "invalid value for 'branch-target-enforcement' attribute: " + S, V1: V);
2731 }
2732
2733 if (auto A = Attrs.getFnAttr(Kind: "branch-protection-pauth-lr"); A.isValid()) {
2734 StringRef S = A.getValueAsString();
2735 if (S != "" && S != "true" && S != "false")
2736 CheckFailed(
2737 Message: "invalid value for 'branch-protection-pauth-lr' attribute: " + S, V1: V);
2738 }
2739
2740 if (auto A = Attrs.getFnAttr(Kind: "guarded-control-stack"); A.isValid()) {
2741 StringRef S = A.getValueAsString();
2742 if (S != "" && S != "true" && S != "false")
2743 CheckFailed(Message: "invalid value for 'guarded-control-stack' attribute: " + S,
2744 V1: V);
2745 }
2746
2747 if (auto A = Attrs.getFnAttr(Kind: "vector-function-abi-variant"); A.isValid()) {
2748 StringRef S = A.getValueAsString();
2749 const std::optional<VFInfo> Info = VFABI::tryDemangleForVFABI(MangledName: S, FTy: FT);
2750 if (!Info)
2751 CheckFailed(Message: "invalid name for a VFABI variant: " + S, V1: V);
2752 }
2753
2754 if (auto A = Attrs.getFnAttr(Kind: "modular-format"); A.isValid()) {
2755 StringRef S = A.getValueAsString();
2756 SmallVector<StringRef> Args;
2757 S.split(A&: Args, Separator: ',');
2758 Check(Args.size() >= 5,
2759 "modular-format attribute requires at least 5 arguments", V);
2760 unsigned UpperBound = FT->getNumParams() + (FT->isVarArg() ? 1 : 0);
2761 unsigned FormatIdx;
2762 Check(!Args[1].getAsInteger(10, FormatIdx),
2763 "modular-format attribute format string index is not an integer", V);
2764 Check(FormatIdx > 0,
2765 "modular-format attribute format string index must be greater than 0",
2766 V);
2767 Check(FormatIdx <= UpperBound,
2768 "modular-format attribute format string index is out of bounds", V);
2769 unsigned FirstArgIdx;
2770 Check(!Args[2].getAsInteger(10, FirstArgIdx),
2771 "modular-format attribute first arg index is not an integer", V);
2772 Check(FirstArgIdx <= UpperBound,
2773 "modular-format attribute first arg index is out of bounds", V);
2774 Check(!Args[3].empty(),
2775 "modular-format attribute modular implementation function name "
2776 "cannot be empty",
2777 V);
2778 Check(!Args[4].empty(),
2779 "modular-format attribute implementation name cannot be empty", V);
2780 }
2781
2782 if (auto A = Attrs.getFnAttr(Kind: "target-features"); A.isValid()) {
2783 StringRef S = A.getValueAsString();
2784 if (!S.empty()) {
2785 for (auto FeatureFlag : split(Str: S, Separator: ',')) {
2786 if (FeatureFlag.empty())
2787 CheckFailed(
2788 Message: "target-features attribute should not contain an empty string");
2789 else
2790 Check(FeatureFlag[0] == '+' || FeatureFlag[0] == '-',
2791 "target feature '" + FeatureFlag +
2792 "' must start with a '+' or '-'",
2793 V);
2794 }
2795 }
2796 }
2797}
2798void Verifier::verifyUnknownProfileMetadata(MDNode *MD) {
2799 Check(MD->getNumOperands() == 2,
2800 "'unknown' !prof should have a single additional operand", MD);
2801 auto *PassName = dyn_cast<MDString>(Val: MD->getOperand(I: 1));
2802 Check(PassName != nullptr,
2803 "'unknown' !prof should have an additional operand of type "
2804 "string");
2805 Check(!PassName->getString().empty(),
2806 "the 'unknown' !prof operand should not be an empty string");
2807}
2808
2809void Verifier::verifyFunctionMetadata(
2810 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
2811 for (const auto &Pair : MDs) {
2812 if (Pair.first == LLVMContext::MD_prof) {
2813 MDNode *MD = Pair.second;
2814 Check(MD->getNumOperands() >= 2,
2815 "!prof annotations should have no less than 2 operands", MD);
2816 // We may have functions that are synthesized by the compiler, e.g. in
2817 // WPD, that we can't currently determine the entry count.
2818 if (MD->getOperand(I: 0).equalsStr(
2819 Str: MDProfLabels::UnknownBranchWeightsMarker)) {
2820 verifyUnknownProfileMetadata(MD);
2821 continue;
2822 }
2823
2824 // Check first operand.
2825 Check(MD->getOperand(0) != nullptr, "first operand should not be null",
2826 MD);
2827 Check(isa<MDString>(MD->getOperand(0)),
2828 "expected string with name of the !prof annotation", MD);
2829 MDString *MDS = cast<MDString>(Val: MD->getOperand(I: 0));
2830 StringRef ProfName = MDS->getString();
2831 Check(ProfName == MDProfLabels::FunctionEntryCount ||
2832 ProfName == MDProfLabels::SyntheticFunctionEntryCount,
2833 "first operand should be 'function_entry_count'"
2834 " or 'synthetic_function_entry_count'",
2835 MD);
2836
2837 // Check second operand.
2838 Check(MD->getOperand(1) != nullptr, "second operand should not be null",
2839 MD);
2840 Check(isa<ConstantAsMetadata>(MD->getOperand(1)),
2841 "expected integer argument to function_entry_count", MD);
2842 } else if (Pair.first == LLVMContext::MD_kcfi_type) {
2843 MDNode *MD = Pair.second;
2844 Check(MD->getNumOperands() == 1,
2845 "!kcfi_type must have exactly one operand", MD);
2846 Check(MD->getOperand(0) != nullptr, "!kcfi_type operand must not be null",
2847 MD);
2848 Check(isa<ConstantAsMetadata>(MD->getOperand(0)),
2849 "expected a constant operand for !kcfi_type", MD);
2850 Constant *C = cast<ConstantAsMetadata>(Val: MD->getOperand(I: 0))->getValue();
2851 Check(isa<ConstantInt>(C) && isa<IntegerType>(C->getType()),
2852 "expected a constant integer operand for !kcfi_type", MD);
2853 Check(cast<ConstantInt>(C)->getBitWidth() == 32,
2854 "expected a 32-bit integer constant operand for !kcfi_type", MD);
2855 } else if (Pair.first == Context.getMDKindID(Name: "reqd_work_group_size")) {
2856 MDNode *MD = Pair.second;
2857 Check(MD->getNumOperands() == 3,
2858 "reqd_work_group_size must have exactly three operands", MD);
2859 if (MD->getNumOperands() != 3)
2860 continue;
2861
2862 uint64_t Product = 1;
2863 for (unsigned I = 0; I != 3; ++I) {
2864 ConstantInt *C = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I));
2865 Check(C, "reqd_work_group_size operands must be integer constants", MD);
2866 if (!C)
2867 break;
2868
2869 const APInt &Value = C->getValue();
2870 Check(Value.getActiveBits() <= 64,
2871 "reqd_work_group_size operands must fit in 64 bits", MD);
2872 if (Value.getActiveBits() > 64)
2873 break;
2874
2875 uint64_t Dim = Value.getZExtValue();
2876 Check(Dim == 0 || Product <= std::numeric_limits<uint64_t>::max() / Dim,
2877 "reqd_work_group_size product must fit in 64 bits", MD);
2878 if (Dim != 0 && Product > std::numeric_limits<uint64_t>::max() / Dim)
2879 break;
2880 Product *= Dim;
2881 }
2882 }
2883 }
2884}
2885
2886void Verifier::visitConstantExprsRecursively(const Constant *EntryC) {
2887 if (EntryC->getNumOperands() == 0)
2888 return;
2889
2890 if (!ConstantExprVisited.insert(Ptr: EntryC).second)
2891 return;
2892
2893 SmallVector<const Constant *, 16> Stack;
2894 Stack.push_back(Elt: EntryC);
2895
2896 while (!Stack.empty()) {
2897 const Constant *C = Stack.pop_back_val();
2898
2899 // Check this constant expression.
2900 if (const auto *CE = dyn_cast<ConstantExpr>(Val: C))
2901 visitConstantExpr(CE);
2902
2903 if (const auto *CPA = dyn_cast<ConstantPtrAuth>(Val: C))
2904 visitConstantPtrAuth(CPA);
2905
2906 if (const auto *GV = dyn_cast<GlobalValue>(Val: C)) {
2907 // Global Values get visited separately, but we do need to make sure
2908 // that the global value is in the correct module
2909 Check(GV->getParent() == &M, "Referencing global in another module!",
2910 EntryC, &M, GV, GV->getParent());
2911 continue;
2912 }
2913
2914 // Visit all sub-expressions.
2915 for (const Use &U : C->operands()) {
2916 const auto *OpC = dyn_cast<Constant>(Val: U);
2917 if (!OpC)
2918 continue;
2919 if (!ConstantExprVisited.insert(Ptr: OpC).second)
2920 continue;
2921 Stack.push_back(Elt: OpC);
2922 }
2923 }
2924}
2925
2926void Verifier::visitConstantExpr(const ConstantExpr *CE) {
2927 if (CE->getOpcode() == Instruction::BitCast)
2928 Check(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
2929 CE->getType()),
2930 "Invalid bitcast", CE);
2931 else if (CE->getOpcode() == Instruction::PtrToAddr)
2932 checkPtrToAddr(SrcTy: CE->getOperand(i_nocapture: 0)->getType(), DestTy: CE->getType(), V: *CE);
2933}
2934
2935void Verifier::visitConstantPtrAuth(const ConstantPtrAuth *CPA) {
2936 Check(CPA->getPointer()->getType()->isPointerTy(),
2937 "signed ptrauth constant base pointer must have pointer type");
2938
2939 Check(CPA->getType() == CPA->getPointer()->getType(),
2940 "signed ptrauth constant must have same type as its base pointer");
2941
2942 Check(CPA->getKey()->getBitWidth() == 32,
2943 "signed ptrauth constant key must be i32 constant integer");
2944
2945 Check(CPA->getAddrDiscriminator()->getType()->isPointerTy(),
2946 "signed ptrauth constant address discriminator must be a pointer");
2947
2948 Check(CPA->getDiscriminator()->getBitWidth() == 64,
2949 "signed ptrauth constant discriminator must be i64 constant integer");
2950
2951 Check(CPA->getDeactivationSymbol()->getType()->isPointerTy(),
2952 "signed ptrauth constant deactivation symbol must be a pointer");
2953
2954 Check(isa<GlobalValue>(CPA->getDeactivationSymbol()) ||
2955 isa<ConstantPointerNull>(CPA->getDeactivationSymbol()),
2956 "signed ptrauth constant deactivation symbol must be a global value "
2957 "or null");
2958}
2959
2960bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
2961 // There shouldn't be more attribute sets than there are parameters plus the
2962 // function and return value.
2963 return Attrs.getNumAttrSets() <= Params + 2;
2964}
2965
2966void Verifier::verifyInlineAsmCall(const CallBase &Call) {
2967 const InlineAsm *IA = cast<InlineAsm>(Val: Call.getCalledOperand());
2968 unsigned ArgNo = 0;
2969 unsigned LabelNo = 0;
2970 for (const InlineAsm::ConstraintInfo &CI : IA->ParseConstraints()) {
2971 if (CI.Type == InlineAsm::isLabel) {
2972 ++LabelNo;
2973 continue;
2974 }
2975
2976 // Only deal with constraints that correspond to call arguments.
2977 if (!CI.hasArg())
2978 continue;
2979
2980 if (CI.isIndirect) {
2981 const Value *Arg = Call.getArgOperand(i: ArgNo);
2982 Check(Arg->getType()->isPointerTy(),
2983 "Operand for indirect constraint must have pointer type", &Call);
2984
2985 Check(Call.getParamElementType(ArgNo),
2986 "Operand for indirect constraint must have elementtype attribute",
2987 &Call);
2988 } else {
2989 Check(!Call.paramHasAttr(ArgNo, Attribute::ElementType),
2990 "Elementtype attribute can only be applied for indirect "
2991 "constraints",
2992 &Call);
2993 }
2994
2995 ArgNo++;
2996 }
2997
2998 if (auto *CallBr = dyn_cast<CallBrInst>(Val: &Call)) {
2999 Check(LabelNo == CallBr->getNumIndirectDests(),
3000 "Number of label constraints does not match number of callbr dests",
3001 &Call);
3002 } else {
3003 Check(LabelNo == 0, "Label constraints can only be used with callbr",
3004 &Call);
3005 }
3006}
3007
3008/// Verify that statepoint intrinsic is well formed.
3009void Verifier::verifyStatepoint(const CallBase &Call) {
3010 assert(Call.getIntrinsicID() == Intrinsic::experimental_gc_statepoint);
3011
3012 Check(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory() &&
3013 !Call.onlyAccessesArgMemory(),
3014 "gc.statepoint must read and write all memory to preserve "
3015 "reordering restrictions required by safepoint semantics",
3016 Call);
3017
3018 const int64_t NumPatchBytes =
3019 cast<ConstantInt>(Val: Call.getArgOperand(i: 1))->getSExtValue();
3020 assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!");
3021 Check(NumPatchBytes >= 0,
3022 "gc.statepoint number of patchable bytes must be "
3023 "positive",
3024 Call);
3025
3026 Type *TargetElemType = Call.getParamElementType(ArgNo: 2);
3027 Check(TargetElemType,
3028 "gc.statepoint callee argument must have elementtype attribute", Call);
3029 auto *TargetFuncType = dyn_cast<FunctionType>(Val: TargetElemType);
3030 Check(TargetFuncType,
3031 "gc.statepoint callee elementtype must be function type", Call);
3032
3033 const int NumCallArgs = cast<ConstantInt>(Val: Call.getArgOperand(i: 3))->getZExtValue();
3034 Check(NumCallArgs >= 0,
3035 "gc.statepoint number of arguments to underlying call "
3036 "must be positive",
3037 Call);
3038 const int NumParams = (int)TargetFuncType->getNumParams();
3039 if (TargetFuncType->isVarArg()) {
3040 Check(NumCallArgs >= NumParams,
3041 "gc.statepoint mismatch in number of vararg call args", Call);
3042
3043 // TODO: Remove this limitation
3044 Check(TargetFuncType->getReturnType()->isVoidTy(),
3045 "gc.statepoint doesn't support wrapping non-void "
3046 "vararg functions yet",
3047 Call);
3048 } else
3049 Check(NumCallArgs == NumParams,
3050 "gc.statepoint mismatch in number of call args", Call);
3051
3052 const uint64_t Flags
3053 = cast<ConstantInt>(Val: Call.getArgOperand(i: 4))->getZExtValue();
3054 Check((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
3055 "unknown flag used in gc.statepoint flags argument", Call);
3056
3057 // Verify that the types of the call parameter arguments match
3058 // the type of the wrapped callee.
3059 AttributeList Attrs = Call.getAttributes();
3060 for (int i = 0; i < NumParams; i++) {
3061 Type *ParamType = TargetFuncType->getParamType(i);
3062 Type *ArgType = Call.getArgOperand(i: 5 + i)->getType();
3063 Check(ArgType == ParamType,
3064 "gc.statepoint call argument does not match wrapped "
3065 "function type",
3066 Call);
3067
3068 if (TargetFuncType->isVarArg()) {
3069 AttributeSet ArgAttrs = Attrs.getParamAttrs(ArgNo: 5 + i);
3070 Check(!ArgAttrs.hasAttribute(Attribute::StructRet),
3071 "Attribute 'sret' cannot be used for vararg call arguments!", Call);
3072 }
3073 }
3074
3075 const int EndCallArgsInx = 4 + NumCallArgs;
3076
3077 const Value *NumTransitionArgsV = Call.getArgOperand(i: EndCallArgsInx + 1);
3078 Check(isa<ConstantInt>(NumTransitionArgsV),
3079 "gc.statepoint number of transition arguments "
3080 "must be constant integer",
3081 Call);
3082 const int NumTransitionArgs =
3083 cast<ConstantInt>(Val: NumTransitionArgsV)->getZExtValue();
3084 Check(NumTransitionArgs == 0,
3085 "gc.statepoint w/inline transition bundle is deprecated", Call);
3086 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
3087
3088 const Value *NumDeoptArgsV = Call.getArgOperand(i: EndTransitionArgsInx + 1);
3089 Check(isa<ConstantInt>(NumDeoptArgsV),
3090 "gc.statepoint number of deoptimization arguments "
3091 "must be constant integer",
3092 Call);
3093 const int NumDeoptArgs = cast<ConstantInt>(Val: NumDeoptArgsV)->getZExtValue();
3094 Check(NumDeoptArgs == 0,
3095 "gc.statepoint w/inline deopt operands is deprecated", Call);
3096
3097 const int ExpectedNumArgs = 7 + NumCallArgs;
3098 Check(ExpectedNumArgs == (int)Call.arg_size(),
3099 "gc.statepoint too many arguments", Call);
3100
3101 // Check that the only uses of this gc.statepoint are gc.result or
3102 // gc.relocate calls which are tied to this statepoint and thus part
3103 // of the same statepoint sequence
3104 for (const User *U : Call.users()) {
3105 const auto *UserCall = dyn_cast<const CallInst>(Val: U);
3106 Check(UserCall, "illegal use of statepoint token", Call, U);
3107 if (!UserCall)
3108 continue;
3109 Check(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),
3110 "gc.result or gc.relocate are the only value uses "
3111 "of a gc.statepoint",
3112 Call, U);
3113 if (isa<GCResultInst>(Val: UserCall)) {
3114 Check(UserCall->getArgOperand(0) == &Call,
3115 "gc.result connected to wrong gc.statepoint", Call, UserCall);
3116 } else if (isa<GCRelocateInst>(Val: Call)) {
3117 Check(UserCall->getArgOperand(0) == &Call,
3118 "gc.relocate connected to wrong gc.statepoint", Call, UserCall);
3119 }
3120 }
3121
3122 // Note: It is legal for a single derived pointer to be listed multiple
3123 // times. It's non-optimal, but it is legal. It can also happen after
3124 // insertion if we strip a bitcast away.
3125 // Note: It is really tempting to check that each base is relocated and
3126 // that a derived pointer is never reused as a base pointer. This turns
3127 // out to be problematic since optimizations run after safepoint insertion
3128 // can recognize equality properties that the insertion logic doesn't know
3129 // about. See example statepoint.ll in the verifier subdirectory
3130}
3131
3132void Verifier::verifyFrameRecoverIndices() {
3133 for (auto &Counts : FrameEscapeInfo) {
3134 Function *F = Counts.first;
3135 unsigned EscapedObjectCount = Counts.second.first;
3136 unsigned MaxRecoveredIndex = Counts.second.second;
3137 Check(MaxRecoveredIndex <= EscapedObjectCount,
3138 "all indices passed to llvm.localrecover must be less than the "
3139 "number of arguments passed to llvm.localescape in the parent "
3140 "function",
3141 F);
3142 }
3143}
3144
3145static Instruction *getSuccPad(Instruction *Terminator) {
3146 BasicBlock *UnwindDest;
3147 if (auto *II = dyn_cast<InvokeInst>(Val: Terminator))
3148 UnwindDest = II->getUnwindDest();
3149 else if (auto *CSI = dyn_cast<CatchSwitchInst>(Val: Terminator))
3150 UnwindDest = CSI->getUnwindDest();
3151 else
3152 UnwindDest = cast<CleanupReturnInst>(Val: Terminator)->getUnwindDest();
3153 return &*UnwindDest->getFirstNonPHIIt();
3154}
3155
3156void Verifier::verifySiblingFuncletUnwinds() {
3157 llvm::TimeTraceScope timeScope("Verifier verify sibling funclet unwinds");
3158 SmallPtrSet<Instruction *, 8> Visited;
3159 SmallPtrSet<Instruction *, 8> Active;
3160 for (const auto &Pair : SiblingFuncletInfo) {
3161 Instruction *PredPad = Pair.first;
3162 if (Visited.count(Ptr: PredPad))
3163 continue;
3164 Active.insert(Ptr: PredPad);
3165 Instruction *Terminator = Pair.second;
3166 do {
3167 Instruction *SuccPad = getSuccPad(Terminator);
3168 if (Active.count(Ptr: SuccPad)) {
3169 // Found a cycle; report error
3170 Instruction *CyclePad = SuccPad;
3171 SmallVector<Instruction *, 8> CycleNodes;
3172 do {
3173 CycleNodes.push_back(Elt: CyclePad);
3174 Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
3175 if (CycleTerminator != CyclePad)
3176 CycleNodes.push_back(Elt: CycleTerminator);
3177 CyclePad = getSuccPad(Terminator: CycleTerminator);
3178 } while (CyclePad != SuccPad);
3179 Check(false, "EH pads can't handle each other's exceptions",
3180 ArrayRef<Instruction *>(CycleNodes));
3181 }
3182 // Don't re-walk a node we've already checked
3183 if (!Visited.insert(Ptr: SuccPad).second)
3184 break;
3185 // Walk to this successor if it has a map entry.
3186 PredPad = SuccPad;
3187 auto TermI = SiblingFuncletInfo.find(Key: PredPad);
3188 if (TermI == SiblingFuncletInfo.end())
3189 break;
3190 Terminator = TermI->second;
3191 Active.insert(Ptr: PredPad);
3192 } while (true);
3193 // Each node only has one successor, so we've walked all the active
3194 // nodes' successors.
3195 Active.clear();
3196 }
3197}
3198
3199// visitFunction - Verify that a function is ok.
3200//
3201void Verifier::visitFunction(const Function &F) {
3202 visitGlobalValue(GV: F);
3203
3204 // Check function arguments.
3205 FunctionType *FT = F.getFunctionType();
3206 unsigned NumArgs = F.arg_size();
3207
3208 Check(&Context == &F.getContext(),
3209 "Function context does not match Module context!", &F);
3210
3211 Check(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
3212 Check(FT->getNumParams() == NumArgs,
3213 "# formal arguments must match # of arguments for function type!", &F,
3214 FT);
3215 Check(F.getReturnType()->isFirstClassType() ||
3216 F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
3217 "Functions cannot return aggregate values!", &F);
3218
3219 Check(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
3220 "Invalid struct return type!", &F);
3221
3222 if (MaybeAlign A = F.getAlign()) {
3223 Check(A->value() <= Value::MaximumAlignment,
3224 "huge alignment values are unsupported", &F);
3225 }
3226
3227 AttributeList Attrs = F.getAttributes();
3228
3229 Check(verifyAttributeCount(Attrs, FT->getNumParams()),
3230 "Attribute after last parameter!", &F);
3231
3232 bool IsIntrinsic = F.isIntrinsic();
3233
3234 // Check function attributes.
3235 verifyFunctionAttrs(FT, Attrs, V: &F, IsIntrinsic, /* IsInlineAsm */ false);
3236
3237 // On function declarations/definitions, we do not support the builtin
3238 // attribute. We do not check this in VerifyFunctionAttrs since that is
3239 // checking for Attributes that can/can not ever be on functions.
3240 Check(!Attrs.hasFnAttr(Attribute::Builtin),
3241 "Attribute 'builtin' can only be applied to a callsite.", &F);
3242
3243 Check(!Attrs.hasAttrSomewhere(Attribute::ElementType),
3244 "Attribute 'elementtype' can only be applied to a callsite.", &F);
3245
3246 if (Attrs.hasFnAttr(Kind: Attribute::Naked))
3247 for (const Argument &Arg : F.args())
3248 Check(Arg.use_empty(), "cannot use argument of naked function", &Arg);
3249
3250 // Check that this function meets the restrictions on this calling convention.
3251 // Sometimes varargs is used for perfectly forwarding thunks, so some of these
3252 // restrictions can be lifted.
3253 switch (F.getCallingConv()) {
3254 default:
3255 case CallingConv::C:
3256 break;
3257 case CallingConv::X86_INTR: {
3258 Check(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::ByVal),
3259 "Calling convention parameter requires byval", &F);
3260 break;
3261 }
3262 case CallingConv::AMDGPU_KERNEL:
3263 case CallingConv::SPIR_KERNEL:
3264 case CallingConv::AMDGPU_CS_Chain:
3265 case CallingConv::AMDGPU_CS_ChainPreserve:
3266 Check(F.getReturnType()->isVoidTy(),
3267 "Calling convention requires void return type", &F);
3268 [[fallthrough]];
3269 case CallingConv::AMDGPU_VS:
3270 case CallingConv::AMDGPU_HS:
3271 case CallingConv::AMDGPU_GS:
3272 case CallingConv::AMDGPU_PS:
3273 case CallingConv::AMDGPU_CS:
3274 Check(!F.hasStructRetAttr(), "Calling convention does not allow sret", &F);
3275 if (F.getCallingConv() != CallingConv::SPIR_KERNEL) {
3276 const unsigned StackAS = DL.getAllocaAddrSpace();
3277 unsigned i = 0;
3278 for (const Argument &Arg : F.args()) {
3279 Check(!Attrs.hasParamAttr(i, Attribute::ByVal),
3280 "Calling convention disallows byval", &F);
3281 Check(!Attrs.hasParamAttr(i, Attribute::Preallocated),
3282 "Calling convention disallows preallocated", &F);
3283 Check(!Attrs.hasParamAttr(i, Attribute::InAlloca),
3284 "Calling convention disallows inalloca", &F);
3285
3286 if (Attrs.hasParamAttr(ArgNo: i, Kind: Attribute::ByRef)) {
3287 // FIXME: Should also disallow LDS and GDS, but we don't have the enum
3288 // value here.
3289 Check(Arg.getType()->getPointerAddressSpace() != StackAS,
3290 "Calling convention disallows stack byref", &F);
3291 }
3292
3293 ++i;
3294 }
3295 }
3296
3297 [[fallthrough]];
3298 case CallingConv::Fast:
3299 case CallingConv::Cold:
3300 case CallingConv::Intel_OCL_BI:
3301 case CallingConv::PTX_Kernel:
3302 case CallingConv::PTX_Device:
3303 Check(!F.isVarArg(),
3304 "Calling convention does not support varargs or "
3305 "perfect forwarding!",
3306 &F);
3307 break;
3308 case CallingConv::AMDGPU_Gfx_WholeWave:
3309 Check(!F.arg_empty() && F.arg_begin()->getType()->isIntegerTy(1),
3310 "Calling convention requires first argument to be i1", &F);
3311 Check(!F.arg_begin()->hasInRegAttr(),
3312 "Calling convention requires first argument to not be inreg", &F);
3313 Check(!F.isVarArg(),
3314 "Calling convention does not support varargs or "
3315 "perfect forwarding!",
3316 &F);
3317 break;
3318 }
3319
3320 // Check that the argument values match the function type for this function...
3321 unsigned i = 0;
3322 for (const Argument &Arg : F.args()) {
3323 Check(Arg.getType() == FT->getParamType(i),
3324 "Argument value does not match function argument type!", &Arg,
3325 FT->getParamType(i));
3326 Check(Arg.getType()->isFirstClassType(),
3327 "Function arguments must have first-class types!", &Arg);
3328 if (!IsIntrinsic) {
3329 Check(!Arg.getType()->isMetadataTy(),
3330 "Function takes metadata but isn't an intrinsic", &Arg, &F);
3331 Check(!Arg.getType()->isTokenLikeTy(),
3332 "Function takes token but isn't an intrinsic", &Arg, &F);
3333 Check(!Arg.getType()->isX86_AMXTy(),
3334 "Function takes x86_amx but isn't an intrinsic", &Arg, &F);
3335 }
3336
3337 // Check that swifterror argument is only used by loads and stores.
3338 if (Attrs.hasParamAttr(ArgNo: i, Kind: Attribute::SwiftError)) {
3339 verifySwiftErrorValue(SwiftErrorVal: &Arg);
3340 }
3341 ++i;
3342 }
3343
3344 if (!IsIntrinsic) {
3345 Check(!F.getReturnType()->isTokenLikeTy(),
3346 "Function returns a token but isn't an intrinsic", &F);
3347 Check(!F.getReturnType()->isX86_AMXTy(),
3348 "Function returns a x86_amx but isn't an intrinsic", &F);
3349 }
3350
3351 // Get the function metadata attachments.
3352 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
3353 F.getAllMetadata(MDs);
3354 assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync");
3355 verifyFunctionMetadata(MDs);
3356
3357 // Target-specific function metadata checks.
3358 verifyAMDGPUFunctionMetadata(VS&: *this, F);
3359
3360 // Check validity of the personality function
3361 if (F.hasPersonalityFn()) {
3362 auto *Per = dyn_cast<Function>(Val: F.getPersonalityFn()->stripPointerCasts());
3363 if (Per)
3364 Check(Per->getParent() == F.getParent(),
3365 "Referencing personality function in another module!", &F,
3366 F.getParent(), Per, Per->getParent());
3367 }
3368
3369 // EH funclet coloring can be expensive, recompute on-demand
3370 BlockEHFuncletColors.clear();
3371
3372 if (F.isMaterializable()) {
3373 // Function has a body somewhere we can't see.
3374 Check(MDs.empty(), "unmaterialized function cannot have metadata", &F,
3375 MDs.empty() ? nullptr : MDs.front().second);
3376 } else if (F.isDeclaration()) {
3377 for (const auto &I : MDs) {
3378 // This is used for call site debug information.
3379 CheckDI(I.first != LLVMContext::MD_dbg ||
3380 !cast<DISubprogram>(I.second)->isDistinct(),
3381 "function declaration may only have a unique !dbg attachment",
3382 &F);
3383 Check(I.first != LLVMContext::MD_prof,
3384 "function declaration may not have a !prof attachment", &F);
3385
3386 // Verify the metadata itself.
3387 visitMDNode(BaseMD: *I.second, AllowLocs: AreDebugLocsAllowed::Yes);
3388 }
3389 Check(!F.hasPersonalityFn(),
3390 "Function declaration shouldn't have a personality routine", &F);
3391 } else {
3392 // Verify that this function (which has a body) is not named "llvm.*". It
3393 // is not legal to define intrinsics.
3394 Check(!IsIntrinsic, "llvm intrinsics cannot be defined!", &F);
3395
3396 // Check the entry node
3397 const BasicBlock *Entry = &F.getEntryBlock();
3398 Check(pred_empty(Entry),
3399 "Entry block to function must not have predecessors!", Entry);
3400
3401 // The address of the entry block cannot be taken, unless it is dead.
3402 if (Entry->hasAddressTaken()) {
3403 Check(!BlockAddress::lookup(Entry)->isConstantUsed(),
3404 "blockaddress may not be used with the entry block!", Entry);
3405 }
3406
3407 unsigned NumDebugAttachments = 0, NumProfAttachments = 0,
3408 NumKCFIAttachments = 0;
3409 // Visit metadata attachments.
3410 for (const auto &I : MDs) {
3411 // Verify that the attachment is legal.
3412 auto AllowLocs = AreDebugLocsAllowed::No;
3413 switch (I.first) {
3414 default:
3415 break;
3416 case LLVMContext::MD_dbg: {
3417 ++NumDebugAttachments;
3418 CheckDI(NumDebugAttachments == 1,
3419 "function must have a single !dbg attachment", &F, I.second);
3420 CheckDI(isa<DISubprogram>(I.second),
3421 "function !dbg attachment must be a subprogram", &F, I.second);
3422 CheckDI(cast<DISubprogram>(I.second)->isDistinct(),
3423 "function definition may only have a distinct !dbg attachment",
3424 &F);
3425
3426 auto *SP = cast<DISubprogram>(Val: I.second);
3427 const Function *&AttachedTo = DISubprogramAttachments[SP];
3428 CheckDI(!AttachedTo || AttachedTo == &F,
3429 "DISubprogram attached to more than one function", SP, &F);
3430 AttachedTo = &F;
3431 AllowLocs = AreDebugLocsAllowed::Yes;
3432 break;
3433 }
3434 case LLVMContext::MD_prof:
3435 ++NumProfAttachments;
3436 Check(NumProfAttachments == 1,
3437 "function must have a single !prof attachment", &F, I.second);
3438 break;
3439 case LLVMContext::MD_kcfi_type:
3440 ++NumKCFIAttachments;
3441 Check(NumKCFIAttachments == 1,
3442 "function must have a single !kcfi_type attachment", &F,
3443 I.second);
3444 break;
3445 }
3446
3447 // Verify the metadata itself.
3448 visitMDNode(BaseMD: *I.second, AllowLocs);
3449 }
3450 }
3451
3452 // If this function is actually an intrinsic, verify that it is only used in
3453 // direct call/invokes, never having its "address taken".
3454 // Only do this if the module is materialized, otherwise we don't have all the
3455 // uses.
3456 bool isMaterialized = F.getParent()->isMaterialized();
3457 if (F.isIntrinsic() && isMaterialized) {
3458 const User *U;
3459 if (F.hasAddressTaken(&U, IgnoreCallbackUses: false, IgnoreAssumeLikeCalls: true, IngoreLLVMUsed: false,
3460 /*IgnoreARCAttachedCall=*/true))
3461 Check(false, "Invalid user of intrinsic instruction!", U);
3462 }
3463
3464 // Verify if the intrinsic's signature and name are valid. We do this if
3465 // the intrinsic has at least one materialized use, or if the module is fully
3466 // materialized.
3467 Intrinsic::ID IID = F.getIntrinsicID();
3468 if (IID && (isMaterialized || !F.materialized_use_empty())) {
3469 // Verify that the intrinsic prototype lines up with what the .td files
3470 // describe.
3471 std::string ErrMsg;
3472 raw_string_ostream ErrOS(ErrMsg);
3473 SmallVector<Type *, 4> OverloadTys;
3474 bool IsValid = Intrinsic::isSignatureValid(ID: IID, FT, OverloadTys, OS&: ErrOS);
3475 Printable PrintDecl([&F](raw_ostream &OS) { F.print(OS); });
3476 Check(IsValid, ErrMsg, PrintDecl);
3477
3478 // Now that we have the intrinsic ID and the actual argument types (and we
3479 // know they are legal for the intrinsic!) get the intrinsic name through
3480 // the usual means. This allows us to verify the mangling of argument types
3481 // into the name.
3482 const std::string ExpectedName = Intrinsic::getName(
3483 Id: IID, OverloadTys, M: const_cast<Module *>(F.getParent()), FT);
3484 Check(ExpectedName == F.getName(),
3485 "Intrinsic name not mangled correctly for type arguments! "
3486 "Should be: " +
3487 ExpectedName,
3488 PrintDecl);
3489 }
3490
3491 auto *N = F.getSubprogram();
3492 HasDebugInfo = (N != nullptr);
3493 if (!HasDebugInfo)
3494 return;
3495
3496 // Check that all !dbg attachments lead to back to N.
3497 //
3498 // FIXME: Check this incrementally while visiting !dbg attachments.
3499 // FIXME: Only check when N is the canonical subprogram for F.
3500 SmallPtrSet<const MDNode *, 32> Seen;
3501 auto VisitDebugLoc = [&](const Instruction &I, const MDNode *Node) {
3502 // Be careful about using DILocation here since we might be dealing with
3503 // broken code (this is the Verifier after all).
3504 const DILocation *DL = dyn_cast_or_null<DILocation>(Val: Node);
3505 if (!DL)
3506 return;
3507 if (!Seen.insert(Ptr: DL).second)
3508 return;
3509
3510 Metadata *Parent = DL->getRawScope();
3511 CheckDI(Parent && isa<DILocalScope>(Parent),
3512 "DILocation's scope must be a DILocalScope", N, &F, &I, DL, Parent);
3513
3514 DILocalScope *Scope = DL->getInlinedAtScope();
3515 Check(Scope, "Failed to find DILocalScope", DL);
3516
3517 if (!Seen.insert(Ptr: Scope).second)
3518 return;
3519
3520 // Cycles are diagnosed when the DIScope nodes themselves are visited.
3521 if (hasDIScopeCycle(S: Scope))
3522 return;
3523
3524 DISubprogram *SP = Scope->getSubprogram();
3525
3526 // Scope and SP could be the same MDNode and we don't want to skip
3527 // validation in that case
3528 if ((Scope != SP) && !Seen.insert(Ptr: SP).second)
3529 return;
3530
3531 CheckDI(SP->describes(&F),
3532 "!dbg attachment points at wrong subprogram for function", N, &F,
3533 &I, DL, Scope, SP);
3534 };
3535 for (auto &BB : F)
3536 for (auto &I : BB) {
3537 VisitDebugLoc(I, I.getDebugLoc().getAsMDNode());
3538 // The llvm.loop annotations also contain two DILocations.
3539 if (auto MD = I.getMetadata(KindID: LLVMContext::MD_loop))
3540 for (unsigned i = 1; i < MD->getNumOperands(); ++i)
3541 VisitDebugLoc(I, dyn_cast_or_null<MDNode>(Val: MD->getOperand(I: i)));
3542 if (BrokenDebugInfo)
3543 return;
3544 }
3545}
3546
3547// verifyBasicBlock - Verify that a basic block is well formed...
3548//
3549void Verifier::visitBasicBlock(BasicBlock &BB) {
3550 InstsInThisBlock.clear();
3551 ConvergenceVerifyHelper.visit(BB);
3552
3553 // Ensure that basic blocks have terminators!
3554 Check(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
3555
3556 // Check constraints that this basic block imposes on all of the PHI nodes in
3557 // it.
3558 if (isa<PHINode>(Val: BB.front())) {
3559 SmallVector<BasicBlock *, 8> Preds(predecessors(BB: &BB));
3560 SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
3561 llvm::sort(C&: Preds);
3562 for (const PHINode &PN : BB.phis()) {
3563 Check(PN.getNumIncomingValues() == Preds.size(),
3564 "PHINode should have one entry for each predecessor of its "
3565 "parent basic block!",
3566 &PN);
3567
3568 // Get and sort all incoming values in the PHI node...
3569 Values.clear();
3570 Values.reserve(N: PN.getNumIncomingValues());
3571 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
3572 Values.push_back(
3573 Elt: std::make_pair(x: PN.getIncomingBlock(i), y: PN.getIncomingValue(i)));
3574 llvm::sort(C&: Values);
3575
3576 for (unsigned i = 0, e = Values.size(); i != e; ++i) {
3577 // Check to make sure that if there is more than one entry for a
3578 // particular basic block in this PHI node, that the incoming values are
3579 // all identical.
3580 //
3581 Check(i == 0 || Values[i].first != Values[i - 1].first ||
3582 Values[i].second == Values[i - 1].second,
3583 "PHI node has multiple entries for the same basic block with "
3584 "different incoming values!",
3585 &PN, Values[i].first, Values[i].second, Values[i - 1].second);
3586
3587 // Check to make sure that the predecessors and PHI node entries are
3588 // matched up.
3589 Check(Values[i].first == Preds[i],
3590 "PHI node entries do not match predecessors!", &PN,
3591 Values[i].first, Preds[i]);
3592 }
3593 }
3594 }
3595
3596 // Check that all instructions have their parent pointers set up correctly.
3597 for (auto &I : BB)
3598 {
3599 Check(I.getParent() == &BB, "Instruction has bogus parent pointer!");
3600 }
3601
3602 // Confirm that no issues arise from the debug program.
3603 CheckDI(!BB.getTrailingDbgRecords(), "Basic Block has trailing DbgRecords!",
3604 &BB);
3605}
3606
3607void Verifier::visitTerminator(Instruction &I) {
3608 // Ensure that terminators only exist at the end of the basic block.
3609 Check(&I == I.getParent()->getTerminator(),
3610 "Terminator found in the middle of a basic block!", I.getParent());
3611 visitInstruction(I);
3612}
3613
3614void Verifier::visitCondBrInst(CondBrInst &BI) {
3615 Check(BI.getCondition()->getType()->isIntegerTy(1),
3616 "Branch condition is not 'i1' type!", &BI, BI.getCondition());
3617 visitTerminator(I&: BI);
3618}
3619
3620void Verifier::visitReturnInst(ReturnInst &RI) {
3621 Function *F = RI.getParent()->getParent();
3622 unsigned N = RI.getNumOperands();
3623 if (F->getReturnType()->isVoidTy())
3624 Check(N == 0,
3625 "Found return instr that returns non-void in Function of void "
3626 "return type!",
3627 &RI, F->getReturnType());
3628 else
3629 Check(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
3630 "Function return type does not match operand "
3631 "type of return inst!",
3632 &RI, F->getReturnType());
3633
3634 // Check to make sure that the return value has necessary properties for
3635 // terminators...
3636 visitTerminator(I&: RI);
3637}
3638
3639void Verifier::visitSwitchInst(SwitchInst &SI) {
3640 Check(SI.getType()->isVoidTy(), "Switch must have void result type!", &SI);
3641 // Check to make sure that all of the constants in the switch instruction
3642 // have the same type as the switched-on value.
3643 Type *SwitchTy = SI.getCondition()->getType();
3644 SmallPtrSet<ConstantInt*, 32> Constants;
3645 for (auto &Case : SI.cases()) {
3646 Check(isa<ConstantInt>(Case.getCaseValue()),
3647 "Case value is not a constant integer.", &SI);
3648 Check(Case.getCaseValue()->getType() == SwitchTy,
3649 "Switch constants must all be same type as switch value!", &SI);
3650 Check(Constants.insert(Case.getCaseValue()).second,
3651 "Duplicate integer as switch case", &SI, Case.getCaseValue());
3652 }
3653
3654 visitTerminator(I&: SI);
3655}
3656
3657void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
3658 Check(BI.getAddress()->getType()->isPointerTy(),
3659 "Indirectbr operand must have pointer type!", &BI);
3660 for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
3661 Check(BI.getDestination(i)->getType()->isLabelTy(),
3662 "Indirectbr destinations must all have pointer type!", &BI);
3663
3664 visitTerminator(I&: BI);
3665}
3666
3667static bool isSupportedCallBrIntrinsic(Intrinsic::ID ID) {
3668 // Currently we only support callbr for amdgcn.kill. Add more checks here as
3669 // needed.
3670 return isAMDGPUCallBrIntrinsic(ID);
3671}
3672
3673void Verifier::visitCallBrInst(CallBrInst &CBI) {
3674 if (!CBI.isInlineAsm()) {
3675 Check(CBI.getCalledFunction(),
3676 "callbr: indirect function / invalid signature");
3677 Check(!CBI.hasOperandBundles(),
3678 "callbr for intrinsics currently doesn't support operand bundles");
3679
3680 if (!isSupportedCallBrIntrinsic(ID: CBI.getIntrinsicID())) {
3681 CheckFailed(
3682 Message: "callbr currently only supports asm-goto and selected intrinsics");
3683 }
3684 visitIntrinsicCall(ID: CBI.getIntrinsicID(), Call&: CBI);
3685 } else {
3686 const InlineAsm *IA = cast<InlineAsm>(Val: CBI.getCalledOperand());
3687 Check(!IA->canThrow(), "Unwinding from Callbr is not allowed");
3688
3689 verifyInlineAsmCall(Call: CBI);
3690 }
3691 visitTerminator(I&: CBI);
3692}
3693
3694void Verifier::visitSelectInst(SelectInst &SI) {
3695 Check(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
3696 SI.getOperand(2)),
3697 "Invalid operands for select instruction!", &SI);
3698
3699 Check(SI.getTrueValue()->getType() == SI.getType(),
3700 "Select values must have same type as select instruction!", &SI);
3701 visitInstruction(I&: SI);
3702}
3703
3704/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
3705/// a pass, if any exist, it's an error.
3706///
3707void Verifier::visitUserOp1(Instruction &I) {
3708 Check(false, "User-defined operators should not live outside of a pass!", &I);
3709}
3710
3711void Verifier::visitTruncInst(TruncInst &I) {
3712 // Get the source and destination types
3713 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3714 Type *DestTy = I.getType();
3715
3716 // Get the size of the types in bits, we'll need this later
3717 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
3718 unsigned DestBitSize = DestTy->getScalarSizeInBits();
3719
3720 Check(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
3721 Check(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
3722 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
3723 "trunc source and destination must both be a vector or neither", &I);
3724 Check(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
3725
3726 visitInstruction(I);
3727}
3728
3729void Verifier::visitZExtInst(ZExtInst &I) {
3730 // Get the source and destination types
3731 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3732 Type *DestTy = I.getType();
3733
3734 // Get the size of the types in bits, we'll need this later
3735 Check(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
3736 Check(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
3737 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
3738 "zext source and destination must both be a vector or neither", &I);
3739 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
3740 unsigned DestBitSize = DestTy->getScalarSizeInBits();
3741
3742 Check(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
3743
3744 visitInstruction(I);
3745}
3746
3747void Verifier::visitSExtInst(SExtInst &I) {
3748 // Get the source and destination types
3749 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3750 Type *DestTy = I.getType();
3751
3752 // Get the size of the types in bits, we'll need this later
3753 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
3754 unsigned DestBitSize = DestTy->getScalarSizeInBits();
3755
3756 Check(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
3757 Check(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
3758 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
3759 "sext source and destination must both be a vector or neither", &I);
3760 Check(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
3761
3762 visitInstruction(I);
3763}
3764
3765void Verifier::visitFPTruncInst(FPTruncInst &I) {
3766 // Get the source and destination types
3767 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3768 Type *DestTy = I.getType();
3769 // Get the size of the types in bits, we'll need this later
3770 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
3771 unsigned DestBitSize = DestTy->getScalarSizeInBits();
3772
3773 Check(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
3774 Check(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
3775 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
3776 "fptrunc source and destination must both be a vector or neither", &I);
3777 Check(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
3778
3779 visitInstruction(I);
3780}
3781
3782void Verifier::visitFPExtInst(FPExtInst &I) {
3783 // Get the source and destination types
3784 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3785 Type *DestTy = I.getType();
3786
3787 // Get the size of the types in bits, we'll need this later
3788 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
3789 unsigned DestBitSize = DestTy->getScalarSizeInBits();
3790
3791 Check(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
3792 Check(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
3793 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(),
3794 "fpext source and destination must both be a vector or neither", &I);
3795 Check(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
3796
3797 visitInstruction(I);
3798}
3799
3800void Verifier::visitUIToFPInst(UIToFPInst &I) {
3801 // Get the source and destination types
3802 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3803 Type *DestTy = I.getType();
3804
3805 bool SrcVec = SrcTy->isVectorTy();
3806 bool DstVec = DestTy->isVectorTy();
3807
3808 Check(SrcVec == DstVec,
3809 "UIToFP source and dest must both be vector or scalar", &I);
3810 Check(SrcTy->isIntOrIntVectorTy(),
3811 "UIToFP source must be integer or integer vector", &I);
3812 Check(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
3813 &I);
3814
3815 if (SrcVec && DstVec)
3816 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3817 cast<VectorType>(DestTy)->getElementCount(),
3818 "UIToFP source and dest vector length mismatch", &I);
3819
3820 visitInstruction(I);
3821}
3822
3823void Verifier::visitSIToFPInst(SIToFPInst &I) {
3824 // Get the source and destination types
3825 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3826 Type *DestTy = I.getType();
3827
3828 bool SrcVec = SrcTy->isVectorTy();
3829 bool DstVec = DestTy->isVectorTy();
3830
3831 Check(SrcVec == DstVec,
3832 "SIToFP source and dest must both be vector or scalar", &I);
3833 Check(SrcTy->isIntOrIntVectorTy(),
3834 "SIToFP source must be integer or integer vector", &I);
3835 Check(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
3836 &I);
3837
3838 if (SrcVec && DstVec)
3839 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3840 cast<VectorType>(DestTy)->getElementCount(),
3841 "SIToFP source and dest vector length mismatch", &I);
3842
3843 visitInstruction(I);
3844}
3845
3846void Verifier::visitFPToUIInst(FPToUIInst &I) {
3847 // Get the source and destination types
3848 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3849 Type *DestTy = I.getType();
3850
3851 bool SrcVec = SrcTy->isVectorTy();
3852 bool DstVec = DestTy->isVectorTy();
3853
3854 Check(SrcVec == DstVec,
3855 "FPToUI source and dest must both be vector or scalar", &I);
3856 Check(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector", &I);
3857 Check(DestTy->isIntOrIntVectorTy(),
3858 "FPToUI result must be integer or integer vector", &I);
3859
3860 if (SrcVec && DstVec)
3861 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3862 cast<VectorType>(DestTy)->getElementCount(),
3863 "FPToUI source and dest vector length mismatch", &I);
3864
3865 visitInstruction(I);
3866}
3867
3868void Verifier::visitFPToSIInst(FPToSIInst &I) {
3869 // Get the source and destination types
3870 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3871 Type *DestTy = I.getType();
3872
3873 bool SrcVec = SrcTy->isVectorTy();
3874 bool DstVec = DestTy->isVectorTy();
3875
3876 Check(SrcVec == DstVec,
3877 "FPToSI source and dest must both be vector or scalar", &I);
3878 Check(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector", &I);
3879 Check(DestTy->isIntOrIntVectorTy(),
3880 "FPToSI result must be integer or integer vector", &I);
3881
3882 if (SrcVec && DstVec)
3883 Check(cast<VectorType>(SrcTy)->getElementCount() ==
3884 cast<VectorType>(DestTy)->getElementCount(),
3885 "FPToSI source and dest vector length mismatch", &I);
3886
3887 visitInstruction(I);
3888}
3889
3890void Verifier::checkPtrToAddr(Type *SrcTy, Type *DestTy, const Value &V) {
3891 Check(SrcTy->isPtrOrPtrVectorTy(), "PtrToAddr source must be pointer", V);
3892 Check(DestTy->isIntOrIntVectorTy(), "PtrToAddr result must be integral", V);
3893 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToAddr type mismatch",
3894 V);
3895
3896 if (SrcTy->isVectorTy()) {
3897 auto *VSrc = cast<VectorType>(Val: SrcTy);
3898 auto *VDest = cast<VectorType>(Val: DestTy);
3899 Check(VSrc->getElementCount() == VDest->getElementCount(),
3900 "PtrToAddr vector length mismatch", V);
3901 }
3902
3903 Type *AddrTy = DL.getAddressType(PtrTy: SrcTy);
3904 Check(AddrTy == DestTy, "PtrToAddr result must be address width", V);
3905}
3906
3907void Verifier::visitPtrToAddrInst(PtrToAddrInst &I) {
3908 checkPtrToAddr(SrcTy: I.getOperand(i_nocapture: 0)->getType(), DestTy: I.getType(), V: I);
3909 visitInstruction(I);
3910}
3911
3912void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
3913 // Get the source and destination types
3914 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3915 Type *DestTy = I.getType();
3916
3917 Check(SrcTy->isPtrOrPtrVectorTy(), "PtrToInt source must be pointer", &I);
3918
3919 Check(DestTy->isIntOrIntVectorTy(), "PtrToInt result must be integral", &I);
3920 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
3921 &I);
3922
3923 if (SrcTy->isVectorTy()) {
3924 auto *VSrc = cast<VectorType>(Val: SrcTy);
3925 auto *VDest = cast<VectorType>(Val: DestTy);
3926 Check(VSrc->getElementCount() == VDest->getElementCount(),
3927 "PtrToInt Vector length mismatch", &I);
3928 }
3929
3930 visitInstruction(I);
3931}
3932
3933void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
3934 // Get the source and destination types
3935 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3936 Type *DestTy = I.getType();
3937
3938 Check(SrcTy->isIntOrIntVectorTy(), "IntToPtr source must be an integral", &I);
3939 Check(DestTy->isPtrOrPtrVectorTy(), "IntToPtr result must be a pointer", &I);
3940
3941 Check(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
3942 &I);
3943 if (SrcTy->isVectorTy()) {
3944 auto *VSrc = cast<VectorType>(Val: SrcTy);
3945 auto *VDest = cast<VectorType>(Val: DestTy);
3946 Check(VSrc->getElementCount() == VDest->getElementCount(),
3947 "IntToPtr Vector length mismatch", &I);
3948 }
3949 visitInstruction(I);
3950}
3951
3952void Verifier::visitBitCastInst(BitCastInst &I) {
3953 Check(
3954 CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
3955 "Invalid bitcast", &I);
3956 visitInstruction(I);
3957}
3958
3959void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
3960 Type *SrcTy = I.getOperand(i_nocapture: 0)->getType();
3961 Type *DestTy = I.getType();
3962
3963 Check(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
3964 &I);
3965 Check(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
3966 &I);
3967 Check(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
3968 "AddrSpaceCast must be between different address spaces", &I);
3969 if (auto *SrcVTy = dyn_cast<VectorType>(Val: SrcTy))
3970 Check(SrcVTy->getElementCount() ==
3971 cast<VectorType>(DestTy)->getElementCount(),
3972 "AddrSpaceCast vector pointer number of elements mismatch", &I);
3973 visitInstruction(I);
3974}
3975
3976/// visitPHINode - Ensure that a PHI node is well formed.
3977///
3978void Verifier::visitPHINode(PHINode &PN) {
3979 // Ensure that the PHI nodes are all grouped together at the top of the block.
3980 // This can be tested by checking whether the instruction before this is
3981 // either nonexistent (because this is begin()) or is a PHI node. If not,
3982 // then there is some other instruction before a PHI.
3983 Check(&PN == &PN.getParent()->front() ||
3984 isa<PHINode>(--BasicBlock::iterator(&PN)),
3985 "PHI nodes not grouped at top of basic block!", &PN, PN.getParent());
3986
3987 // Check that a PHI doesn't yield a Token.
3988 Check(!PN.getType()->isTokenLikeTy(), "PHI nodes cannot have token type!");
3989
3990 // Check that all of the values of the PHI node have the same type as the
3991 // result.
3992 for (Value *IncValue : PN.incoming_values()) {
3993 Check(PN.getType() == IncValue->getType(),
3994 "PHI node operands are not the same type as the result!", &PN);
3995 }
3996
3997 // All other PHI node constraints are checked in the visitBasicBlock method.
3998
3999 visitInstruction(I&: PN);
4000}
4001
4002void Verifier::visitCallBase(CallBase &Call) {
4003 Check(Call.getCalledOperand()->getType()->isPointerTy(),
4004 "Called function must be a pointer!", Call);
4005 FunctionType *FTy = Call.getFunctionType();
4006
4007 // Verify that the correct number of arguments are being passed
4008 if (FTy->isVarArg())
4009 Check(Call.arg_size() >= FTy->getNumParams(),
4010 "Called function requires more parameters than were provided!", Call);
4011 else
4012 Check(Call.arg_size() == FTy->getNumParams(),
4013 "Incorrect number of arguments passed to called function!", Call);
4014
4015 // Verify that all arguments to the call match the function type.
4016 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
4017 Check(Call.getArgOperand(i)->getType() == FTy->getParamType(i),
4018 "Call parameter type does not match function signature!",
4019 Call.getArgOperand(i), FTy->getParamType(i), Call);
4020
4021 AttributeList Attrs = Call.getAttributes();
4022
4023 Check(verifyAttributeCount(Attrs, Call.arg_size()),
4024 "Attribute after last parameter!", Call);
4025
4026 auto *Callee =
4027 dyn_cast<Function>(Val: Call.getCalledOperand()->stripPointerCasts());
4028 bool IsIntrinsic = Callee && Callee->isIntrinsic();
4029 if (IsIntrinsic)
4030 Check(Callee->getFunctionType() == FTy,
4031 "Intrinsic called with incompatible signature", Call);
4032
4033 // Verify if the calling convention of the callee is callable.
4034 Check(isCallableCC(Call.getCallingConv()),
4035 "calling convention does not permit calls", Call);
4036
4037 // Disallow passing/returning values with alignment higher than we can
4038 // represent.
4039 // FIXME: Consider making DataLayout cap the alignment, so this isn't
4040 // necessary.
4041 auto VerifyTypeAlign = [&](Type *Ty, const Twine &Message) {
4042 if (!Ty->isSized())
4043 return;
4044 Align ABIAlign = DL.getABITypeAlign(Ty);
4045 Check(ABIAlign.value() <= Value::MaximumAlignment,
4046 "Incorrect alignment of " + Message + " to called function!", Call);
4047 };
4048
4049 if (!IsIntrinsic) {
4050 VerifyTypeAlign(FTy->getReturnType(), "return type");
4051 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
4052 Type *Ty = FTy->getParamType(i);
4053 VerifyTypeAlign(Ty, "argument passed");
4054 }
4055 }
4056
4057 if (Attrs.hasFnAttr(Kind: Attribute::Speculatable)) {
4058 // Don't allow speculatable on call sites, unless the underlying function
4059 // declaration is also speculatable.
4060 Check(Callee && Callee->isSpeculatable(),
4061 "speculatable attribute may not apply to call sites", Call);
4062 }
4063
4064 if (Attrs.hasFnAttr(Kind: Attribute::Preallocated)) {
4065 Check(Call.getIntrinsicID() == Intrinsic::call_preallocated_arg,
4066 "preallocated as a call site attribute can only be on "
4067 "llvm.call.preallocated.arg");
4068 }
4069
4070 Check(!Attrs.hasFnAttr(Attribute::DenormalFPEnv),
4071 "denormal_fpenv attribute may not apply to call sites", Call);
4072
4073 // Verify call attributes.
4074 verifyFunctionAttrs(FT: FTy, Attrs, V: &Call, IsIntrinsic, IsInlineAsm: Call.isInlineAsm());
4075
4076 // Conservatively check the inalloca argument.
4077 // We have a bug if we can find that there is an underlying alloca without
4078 // inalloca.
4079 if (Call.hasInAllocaArgument()) {
4080 Value *InAllocaArg = Call.getArgOperand(i: FTy->getNumParams() - 1);
4081 if (auto AI = dyn_cast<AllocaInst>(Val: InAllocaArg->stripInBoundsOffsets()))
4082 Check(AI->isUsedWithInAlloca(),
4083 "inalloca argument for call has mismatched alloca", AI, Call);
4084 }
4085
4086 // For each argument of the callsite, if it has the swifterror argument,
4087 // make sure the underlying alloca/parameter it comes from has a swifterror as
4088 // well.
4089 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
4090 if (Call.paramHasAttr(ArgNo: i, Kind: Attribute::SwiftError)) {
4091 Value *SwiftErrorArg = Call.getArgOperand(i);
4092 if (auto AI = dyn_cast<AllocaInst>(Val: SwiftErrorArg->stripInBoundsOffsets())) {
4093 Check(AI->isSwiftError(),
4094 "swifterror argument for call has mismatched alloca", AI, Call);
4095 continue;
4096 }
4097 auto ArgI = dyn_cast<Argument>(Val: SwiftErrorArg);
4098 Check(ArgI, "swifterror argument should come from an alloca or parameter",
4099 SwiftErrorArg, Call);
4100 Check(ArgI->hasSwiftErrorAttr(),
4101 "swifterror argument for call has mismatched parameter", ArgI,
4102 Call);
4103 }
4104
4105 if (Attrs.hasParamAttr(ArgNo: i, Kind: Attribute::ImmArg)) {
4106 // Don't allow immarg on call sites, unless the underlying declaration
4107 // also has the matching immarg.
4108 Check(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),
4109 "immarg may not apply only to call sites", Call.getArgOperand(i),
4110 Call);
4111 }
4112
4113 if (Call.paramHasAttr(ArgNo: i, Kind: Attribute::ImmArg)) {
4114 Value *ArgVal = Call.getArgOperand(i);
4115 Check((isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal)) &&
4116 !isa<VectorType>(ArgVal->getType()),
4117 "immarg operand has non-immediate parameter", ArgVal, Call);
4118
4119 // If the imm-arg is an integer and also has a range attached,
4120 // check if the given value is within the range.
4121 if (Call.paramHasAttr(ArgNo: i, Kind: Attribute::Range)) {
4122 if (auto *CI = dyn_cast<ConstantInt>(Val: ArgVal)) {
4123 const ConstantRange &CR =
4124 Call.getParamAttr(ArgNo: i, Kind: Attribute::Range).getValueAsConstantRange();
4125 Check(CR.contains(CI->getValue()),
4126 formatv("immarg value {} for arg {} out of range {}",
4127 CI->getValue(), i, CR),
4128 Call);
4129 }
4130 }
4131 if (auto *CI = dyn_cast<ConstantInt>(Val: ArgVal))
4132 Check(Intrinsic::isImmArgValueInRangeSet(Call.getIntrinsicID(), i,
4133 CI->getValue()),
4134 formatv("immarg value {} for arg {} out of range set",
4135 CI->getValue(), i),
4136 Call);
4137 }
4138
4139 if (Call.paramHasAttr(ArgNo: i, Kind: Attribute::Preallocated)) {
4140 Value *ArgVal = Call.getArgOperand(i);
4141 bool hasOB =
4142 Call.countOperandBundlesOfType(ID: LLVMContext::OB_preallocated) != 0;
4143 bool isMustTail = Call.isMustTailCall();
4144 Check(hasOB != isMustTail,
4145 "preallocated operand either requires a preallocated bundle or "
4146 "the call to be musttail (but not both)",
4147 ArgVal, Call);
4148 }
4149 }
4150
4151 if (FTy->isVarArg()) {
4152 // FIXME? is 'nest' even legal here?
4153 bool SawNest = false;
4154 bool SawReturned = false;
4155
4156 for (unsigned Idx = 0; Idx < FTy->getNumParams(); ++Idx) {
4157 if (Attrs.hasParamAttr(ArgNo: Idx, Kind: Attribute::Nest))
4158 SawNest = true;
4159 if (Attrs.hasParamAttr(ArgNo: Idx, Kind: Attribute::Returned))
4160 SawReturned = true;
4161 }
4162
4163 // Check attributes on the varargs part.
4164 for (unsigned Idx = FTy->getNumParams(); Idx < Call.arg_size(); ++Idx) {
4165 Type *Ty = Call.getArgOperand(i: Idx)->getType();
4166 AttributeSet ArgAttrs = Attrs.getParamAttrs(ArgNo: Idx);
4167 verifyParameterAttrs(Attrs: ArgAttrs, Ty, V: &Call);
4168
4169 if (ArgAttrs.hasAttribute(Kind: Attribute::Nest)) {
4170 Check(!SawNest, "More than one parameter has attribute nest!", Call);
4171 SawNest = true;
4172 }
4173
4174 if (ArgAttrs.hasAttribute(Kind: Attribute::Returned)) {
4175 Check(!SawReturned, "More than one parameter has attribute returned!",
4176 Call);
4177 Check(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
4178 "Incompatible argument and return types for 'returned' "
4179 "attribute",
4180 Call);
4181 SawReturned = true;
4182 }
4183
4184 // Statepoint intrinsic is vararg but the wrapped function may be not.
4185 // Allow sret here and check the wrapped function in verifyStatepoint.
4186 if (Call.getIntrinsicID() != Intrinsic::experimental_gc_statepoint)
4187 Check(!ArgAttrs.hasAttribute(Attribute::StructRet),
4188 "Attribute 'sret' cannot be used for vararg call arguments!",
4189 Call);
4190
4191 if (ArgAttrs.hasAttribute(Kind: Attribute::InAlloca))
4192 Check(Idx == Call.arg_size() - 1,
4193 "inalloca isn't on the last argument!", Call);
4194 }
4195 }
4196
4197 // Verify that there's no metadata unless it's a direct call to an intrinsic.
4198 if (!IsIntrinsic) {
4199 for (Type *ParamTy : FTy->params()) {
4200 Check(!ParamTy->isMetadataTy(),
4201 "Function has metadata parameter but isn't an intrinsic", Call);
4202 Check(!ParamTy->isTokenLikeTy(),
4203 "Function has token parameter but isn't an intrinsic", Call);
4204 }
4205 }
4206
4207 // Verify that indirect calls don't return tokens.
4208 if (!Call.getCalledFunction()) {
4209 Check(!FTy->getReturnType()->isTokenLikeTy(),
4210 "Return type cannot be token for indirect call!");
4211 Check(!FTy->getReturnType()->isX86_AMXTy(),
4212 "Return type cannot be x86_amx for indirect call!");
4213 }
4214
4215 if (Intrinsic::ID ID = Call.getIntrinsicID())
4216 visitIntrinsicCall(ID, Call);
4217
4218 // Verify that a callsite has at most one "deopt", at most one "funclet", at
4219 // most one "gc-transition", at most one "cfguardtarget", at most one
4220 // "preallocated" operand bundle, and at most one "ptrauth" operand bundle.
4221 bool FoundDeoptBundle = false, FoundFuncletBundle = false,
4222 FoundGCTransitionBundle = false, FoundCFGuardTargetBundle = false,
4223 FoundPreallocatedBundle = false, FoundGCLiveBundle = false,
4224 FoundPtrauthBundle = false, FoundKCFIBundle = false,
4225 FoundAttachedCallBundle = false;
4226 for (unsigned i = 0, e = Call.getNumOperandBundles(); i < e; ++i) {
4227 OperandBundleUse BU = Call.getOperandBundleAt(Index: i);
4228 for (const Value *Input : BU.Inputs)
4229 Check(!Input->getType()->isLabelTy(),
4230 "Operand bundle operands cannot be labels", Call);
4231 uint32_t Tag = BU.getTagID();
4232 if (Tag == LLVMContext::OB_deopt) {
4233 Check(!FoundDeoptBundle, "Multiple deopt operand bundles", Call);
4234 FoundDeoptBundle = true;
4235 } else if (Tag == LLVMContext::OB_gc_transition) {
4236 Check(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",
4237 Call);
4238 FoundGCTransitionBundle = true;
4239 } else if (Tag == LLVMContext::OB_funclet) {
4240 Check(!FoundFuncletBundle, "Multiple funclet operand bundles", Call);
4241 FoundFuncletBundle = true;
4242 Check(BU.Inputs.size() == 1,
4243 "Expected exactly one funclet bundle operand", Call);
4244 Check(isa<FuncletPadInst>(BU.Inputs.front()),
4245 "Funclet bundle operands should correspond to a FuncletPadInst",
4246 Call);
4247 } else if (Tag == LLVMContext::OB_cfguardtarget) {
4248 Check(!FoundCFGuardTargetBundle, "Multiple CFGuardTarget operand bundles",
4249 Call);
4250 FoundCFGuardTargetBundle = true;
4251 Check(BU.Inputs.size() == 1,
4252 "Expected exactly one cfguardtarget bundle operand", Call);
4253 } else if (Tag == LLVMContext::OB_ptrauth) {
4254 Check(!FoundPtrauthBundle, "Multiple ptrauth operand bundles", Call);
4255 FoundPtrauthBundle = true;
4256 Check(BU.Inputs.size() == 2,
4257 "Expected exactly two ptrauth bundle operands", Call);
4258 Check(isa<ConstantInt>(BU.Inputs[0]) &&
4259 BU.Inputs[0]->getType()->isIntegerTy(32),
4260 "Ptrauth bundle key operand must be an i32 constant", Call);
4261 Check(BU.Inputs[1]->getType()->isIntegerTy(64),
4262 "Ptrauth bundle discriminator operand must be an i64", Call);
4263 } else if (Tag == LLVMContext::OB_kcfi) {
4264 Check(!FoundKCFIBundle, "Multiple kcfi operand bundles", Call);
4265 FoundKCFIBundle = true;
4266 Check(BU.Inputs.size() == 1, "Expected exactly one kcfi bundle operand",
4267 Call);
4268 Check(isa<ConstantInt>(BU.Inputs[0]) &&
4269 BU.Inputs[0]->getType()->isIntegerTy(32),
4270 "Kcfi bundle operand must be an i32 constant", Call);
4271 } else if (Tag == LLVMContext::OB_preallocated) {
4272 Check(!FoundPreallocatedBundle, "Multiple preallocated operand bundles",
4273 Call);
4274 FoundPreallocatedBundle = true;
4275 Check(BU.Inputs.size() == 1,
4276 "Expected exactly one preallocated bundle operand", Call);
4277 auto Input = dyn_cast<IntrinsicInst>(Val: BU.Inputs.front());
4278 Check(Input &&
4279 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,
4280 "\"preallocated\" argument must be a token from "
4281 "llvm.call.preallocated.setup",
4282 Call);
4283 } else if (Tag == LLVMContext::OB_gc_live) {
4284 Check(!FoundGCLiveBundle, "Multiple gc-live operand bundles", Call);
4285 FoundGCLiveBundle = true;
4286 } else if (Tag == LLVMContext::OB_clang_arc_attachedcall) {
4287 Check(!FoundAttachedCallBundle,
4288 "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
4289 FoundAttachedCallBundle = true;
4290 verifyAttachedCallBundle(Call, BU);
4291 }
4292 }
4293
4294 // Verify that callee and callsite agree on whether to use pointer auth.
4295 Check(!(Call.getCalledFunction() && FoundPtrauthBundle),
4296 "Direct call cannot have a ptrauth bundle", Call);
4297
4298 // Verify that each inlinable callsite of a debug-info-bearing function in a
4299 // debug-info-bearing function has a debug location attached to it. Failure to
4300 // do so causes assertion failures when the inliner sets up inline scope info
4301 // (Interposable functions are not inlinable, neither are functions without
4302 // definitions.)
4303 if (Call.getFunction()->getSubprogram() && Call.getCalledFunction() &&
4304 !Call.getCalledFunction()->isInterposable() &&
4305 !Call.getCalledFunction()->isDeclaration() &&
4306 Call.getCalledFunction()->getSubprogram())
4307 CheckDI(Call.getDebugLoc(),
4308 "inlinable function call in a function with "
4309 "debug info must have a !dbg location",
4310 Call);
4311
4312 if (Call.isInlineAsm())
4313 verifyInlineAsmCall(Call);
4314
4315 ConvergenceVerifyHelper.visit(I: Call);
4316
4317 visitInstruction(I&: Call);
4318}
4319
4320void Verifier::verifyTailCCMustTailAttrs(const AttrBuilder &Attrs,
4321 StringRef Context) {
4322 Check(!Attrs.contains(Attribute::InAlloca),
4323 Twine("inalloca attribute not allowed in ") + Context);
4324 Check(!Attrs.contains(Attribute::InReg),
4325 Twine("inreg attribute not allowed in ") + Context);
4326 Check(!Attrs.contains(Attribute::SwiftError),
4327 Twine("swifterror attribute not allowed in ") + Context);
4328 Check(!Attrs.contains(Attribute::Preallocated),
4329 Twine("preallocated attribute not allowed in ") + Context);
4330 Check(!Attrs.contains(Attribute::ByRef),
4331 Twine("byref attribute not allowed in ") + Context);
4332}
4333
4334static AttrBuilder getParameterABIAttributes(LLVMContext& C, unsigned I, AttributeList Attrs) {
4335 static const Attribute::AttrKind ABIAttrs[] = {
4336 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
4337 Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf,
4338 Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated,
4339 Attribute::ByRef};
4340 AttrBuilder Copy(C);
4341 for (auto AK : ABIAttrs) {
4342 Attribute Attr = Attrs.getParamAttrs(ArgNo: I).getAttribute(Kind: AK);
4343 if (Attr.isValid())
4344 Copy.addAttribute(A: Attr);
4345 }
4346
4347 // `align` is ABI-affecting only in combination with `byval` or `byref`.
4348 if (Attrs.hasParamAttr(ArgNo: I, Kind: Attribute::Alignment) &&
4349 (Attrs.hasParamAttr(ArgNo: I, Kind: Attribute::ByVal) ||
4350 Attrs.hasParamAttr(ArgNo: I, Kind: Attribute::ByRef)))
4351 Copy.addAlignmentAttr(Align: Attrs.getParamAlignment(ArgNo: I));
4352 return Copy;
4353}
4354
4355void Verifier::verifyMustTailCall(CallInst &CI) {
4356 Check(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
4357
4358 Function *F = CI.getParent()->getParent();
4359 FunctionType *CallerTy = F->getFunctionType();
4360 FunctionType *CalleeTy = CI.getFunctionType();
4361 Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
4362 "cannot guarantee tail call due to mismatched varargs", &CI);
4363 Check(CallerTy->getReturnType() == CalleeTy->getReturnType(),
4364 "cannot guarantee tail call due to mismatched return types", &CI);
4365
4366 // - The calling conventions of the caller and callee must match.
4367 Check(F->getCallingConv() == CI.getCallingConv(),
4368 "cannot guarantee tail call due to mismatched calling conv", &CI);
4369
4370 // - The call must immediately precede a :ref:`ret <i_ret>` instruction.
4371 // - The ret instruction must return the value produced by the call or void.
4372 Instruction *Next = CI.getNextNode();
4373
4374 // Check the return.
4375 ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Val: Next);
4376 Check(Ret, "musttail call must precede a ret", &CI);
4377 Check(!Ret->getReturnValue() || Ret->getReturnValue() == &CI ||
4378 isa<UndefValue>(Ret->getReturnValue()),
4379 "musttail call result must be returned", Ret);
4380
4381 AttributeList CallerAttrs = F->getAttributes();
4382 AttributeList CalleeAttrs = CI.getAttributes();
4383 if (CI.getCallingConv() == CallingConv::SwiftTail ||
4384 CI.getCallingConv() == CallingConv::Tail) {
4385 StringRef CCName =
4386 CI.getCallingConv() == CallingConv::Tail ? "tailcc" : "swifttailcc";
4387
4388 // - Only sret, byval, swiftself, and swiftasync ABI-impacting attributes
4389 // are allowed in swifttailcc call
4390 for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
4391 AttrBuilder ABIAttrs = getParameterABIAttributes(C&: F->getContext(), I, Attrs: CallerAttrs);
4392 SmallString<32> Context{CCName, StringRef(" musttail caller")};
4393 verifyTailCCMustTailAttrs(Attrs: ABIAttrs, Context);
4394 }
4395 for (unsigned I = 0, E = CalleeTy->getNumParams(); I != E; ++I) {
4396 AttrBuilder ABIAttrs = getParameterABIAttributes(C&: F->getContext(), I, Attrs: CalleeAttrs);
4397 SmallString<32> Context{CCName, StringRef(" musttail callee")};
4398 verifyTailCCMustTailAttrs(Attrs: ABIAttrs, Context);
4399 }
4400 // - Varargs functions are not allowed
4401 Check(!CallerTy->isVarArg(), Twine("cannot guarantee ") + CCName +
4402 " tail call for varargs function");
4403 return;
4404 }
4405
4406 // - The caller and callee prototypes must match.
4407 if (!CI.getIntrinsicID()) {
4408 Check(CallerTy->getNumParams() == CalleeTy->getNumParams(),
4409 "cannot guarantee tail call due to mismatched parameter counts", &CI);
4410 for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
4411 Check(CallerTy->getParamType(I) == CalleeTy->getParamType(I),
4412 "cannot guarantee tail call due to mismatched parameter types",
4413 &CI);
4414 }
4415 }
4416
4417 // - All ABI-impacting function attributes, such as sret, byval, inreg,
4418 // returned, preallocated, and inalloca, must match.
4419 for (unsigned I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
4420 AttrBuilder CallerABIAttrs = getParameterABIAttributes(C&: F->getContext(), I, Attrs: CallerAttrs);
4421 AttrBuilder CalleeABIAttrs = getParameterABIAttributes(C&: F->getContext(), I, Attrs: CalleeAttrs);
4422 Check(CallerABIAttrs == CalleeABIAttrs,
4423 "cannot guarantee tail call due to mismatched ABI impacting "
4424 "function attributes",
4425 &CI, CI.getOperand(I));
4426 }
4427}
4428
4429void Verifier::visitCallInst(CallInst &CI) {
4430 visitCallBase(Call&: CI);
4431
4432 if (CI.isMustTailCall())
4433 verifyMustTailCall(CI);
4434}
4435
4436void Verifier::visitInvokeInst(InvokeInst &II) {
4437 visitCallBase(Call&: II);
4438
4439 // Verify that the first non-PHI instruction of the unwind destination is an
4440 // exception handling instruction.
4441 Check(
4442 II.getUnwindDest()->isEHPad(),
4443 "The unwind destination does not have an exception handling instruction!",
4444 &II);
4445
4446 visitTerminator(I&: II);
4447}
4448
4449/// visitUnaryOperator - Check the argument to the unary operator.
4450///
4451void Verifier::visitUnaryOperator(UnaryOperator &U) {
4452 Check(U.getType() == U.getOperand(0)->getType(),
4453 "Unary operators must have same type for"
4454 "operands and result!",
4455 &U);
4456
4457 switch (U.getOpcode()) {
4458 // Check that floating-point arithmetic operators are only used with
4459 // floating-point operands.
4460 case Instruction::FNeg:
4461 Check(U.getType()->isFPOrFPVectorTy(),
4462 "FNeg operator only works with float types!", &U);
4463 break;
4464 default:
4465 llvm_unreachable("Unknown UnaryOperator opcode!");
4466 }
4467
4468 visitInstruction(I&: U);
4469}
4470
4471/// visitBinaryOperator - Check that both arguments to the binary operator are
4472/// of the same type!
4473///
4474void Verifier::visitBinaryOperator(BinaryOperator &B) {
4475 Check(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
4476 "Both operands to a binary operator are not of the same type!", &B);
4477
4478 switch (B.getOpcode()) {
4479 // Check that integer arithmetic operators are only used with
4480 // integral operands.
4481 case Instruction::Add:
4482 case Instruction::Sub:
4483 case Instruction::Mul:
4484 case Instruction::SDiv:
4485 case Instruction::UDiv:
4486 case Instruction::SRem:
4487 case Instruction::URem:
4488 Check(B.getType()->isIntOrIntVectorTy(),
4489 "Integer arithmetic operators only work with integral types!", &B);
4490 Check(B.getType() == B.getOperand(0)->getType(),
4491 "Integer arithmetic operators must have same type "
4492 "for operands and result!",
4493 &B);
4494 break;
4495 // Check that floating-point arithmetic operators are only used with
4496 // floating-point operands.
4497 case Instruction::FAdd:
4498 case Instruction::FSub:
4499 case Instruction::FMul:
4500 case Instruction::FDiv:
4501 case Instruction::FRem:
4502 Check(B.getType()->isFPOrFPVectorTy(),
4503 "Floating-point arithmetic operators only work with "
4504 "floating-point types!",
4505 &B);
4506 Check(B.getType() == B.getOperand(0)->getType(),
4507 "Floating-point arithmetic operators must have same type "
4508 "for operands and result!",
4509 &B);
4510 break;
4511 // Check that logical operators are only used with integral operands.
4512 case Instruction::And:
4513 case Instruction::Or:
4514 case Instruction::Xor:
4515 Check(B.getType()->isIntOrIntVectorTy(),
4516 "Logical operators only work with integral types!", &B);
4517 Check(B.getType() == B.getOperand(0)->getType(),
4518 "Logical operators must have same type for operands and result!", &B);
4519 break;
4520 case Instruction::Shl:
4521 case Instruction::LShr:
4522 case Instruction::AShr:
4523 Check(B.getType()->isIntOrIntVectorTy(),
4524 "Shifts only work with integral types!", &B);
4525 Check(B.getType() == B.getOperand(0)->getType(),
4526 "Shift return type must be same as operands!", &B);
4527 break;
4528 default:
4529 llvm_unreachable("Unknown BinaryOperator opcode!");
4530 }
4531
4532 visitInstruction(I&: B);
4533}
4534
4535void Verifier::visitICmpInst(ICmpInst &IC) {
4536 // Check that the operands are the same type
4537 Type *Op0Ty = IC.getOperand(i_nocapture: 0)->getType();
4538 Type *Op1Ty = IC.getOperand(i_nocapture: 1)->getType();
4539 Check(Op0Ty == Op1Ty,
4540 "Both operands to ICmp instruction are not of the same type!", &IC);
4541 // Check that the operands are the right type
4542 Check(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy(),
4543 "Invalid operand types for ICmp instruction", &IC);
4544 // Check that the predicate is valid.
4545 Check(IC.isIntPredicate(), "Invalid predicate in ICmp instruction!", &IC);
4546
4547 visitInstruction(I&: IC);
4548}
4549
4550void Verifier::visitFCmpInst(FCmpInst &FC) {
4551 // Check that the operands are the same type
4552 Type *Op0Ty = FC.getOperand(i_nocapture: 0)->getType();
4553 Type *Op1Ty = FC.getOperand(i_nocapture: 1)->getType();
4554 Check(Op0Ty == Op1Ty,
4555 "Both operands to FCmp instruction are not of the same type!", &FC);
4556 // Check that the operands are the right type
4557 Check(Op0Ty->isFPOrFPVectorTy(), "Invalid operand types for FCmp instruction",
4558 &FC);
4559 // Check that the predicate is valid.
4560 Check(FC.isFPPredicate(), "Invalid predicate in FCmp instruction!", &FC);
4561
4562 visitInstruction(I&: FC);
4563}
4564
4565void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
4566 Check(ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
4567 "Invalid extractelement operands!", &EI);
4568 visitInstruction(I&: EI);
4569}
4570
4571void Verifier::visitInsertElementInst(InsertElementInst &IE) {
4572 Check(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
4573 IE.getOperand(2)),
4574 "Invalid insertelement operands!", &IE);
4575 visitInstruction(I&: IE);
4576}
4577
4578void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
4579 Check(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
4580 SV.getShuffleMask()),
4581 "Invalid shufflevector operands!", &SV);
4582 visitInstruction(I&: SV);
4583}
4584
4585void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
4586 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
4587 MD: GEP.getModule()->getModuleFlag(Key: "require-logical-pointer")))
4588 Check(!MD->getZExtValue(),
4589 "Non-logical getelementptr disallowed for this module.");
4590
4591 Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
4592
4593 Check(isa<PointerType>(TargetTy),
4594 "GEP base pointer is not a vector or a vector of pointers", &GEP);
4595 Check(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
4596
4597 if (auto *STy = dyn_cast<StructType>(Val: GEP.getSourceElementType())) {
4598 Check(!STy->isScalableTy(),
4599 "getelementptr cannot target structure that contains scalable vector"
4600 "type",
4601 &GEP);
4602 }
4603
4604 SmallVector<Value *, 16> Idxs(GEP.indices());
4605 Check(
4606 all_of(Idxs, [](Value *V) { return V->getType()->isIntOrIntVectorTy(); }),
4607 "GEP indexes must be integers", &GEP);
4608 Type *ElTy =
4609 GetElementPtrInst::getIndexedType(Ty: GEP.getSourceElementType(), IdxList: Idxs);
4610 Check(ElTy, "Invalid indices for GEP pointer type!", &GEP);
4611
4612 auto *PtrTy = dyn_cast<PointerType>(Val: GEP.getType()->getScalarType());
4613
4614 Check(PtrTy && GEP.getResultElementType() == ElTy,
4615 "GEP is not of right type for indices!", &GEP, ElTy);
4616
4617 if (auto *GEPVTy = dyn_cast<VectorType>(Val: GEP.getType())) {
4618 // Additional checks for vector GEPs.
4619 ElementCount GEPWidth = GEPVTy->getElementCount();
4620 if (GEP.getPointerOperandType()->isVectorTy())
4621 Check(
4622 GEPWidth ==
4623 cast<VectorType>(GEP.getPointerOperandType())->getElementCount(),
4624 "Vector GEP result width doesn't match operand's", &GEP);
4625 for (Value *Idx : Idxs) {
4626 Type *IndexTy = Idx->getType();
4627 if (auto *IndexVTy = dyn_cast<VectorType>(Val: IndexTy)) {
4628 ElementCount IndexWidth = IndexVTy->getElementCount();
4629 Check(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP);
4630 }
4631 Check(IndexTy->isIntOrIntVectorTy(),
4632 "All GEP indices should be of integer type");
4633 }
4634 }
4635
4636 // Check that GEP does not index into a vector with non-byte-addressable
4637 // elements.
4638 for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
4639 GTI != GTE; ++GTI) {
4640 if (GTI.isVector()) {
4641 Type *ElemTy = GTI.getIndexedType();
4642 Check(DL.typeSizeEqualsStoreSize(ElemTy),
4643 "GEP into vector with non-byte-addressable element type", &GEP);
4644 }
4645 }
4646
4647 Check(GEP.getAddressSpace() == PtrTy->getAddressSpace(),
4648 "GEP address space doesn't match type", &GEP);
4649
4650 visitInstruction(I&: GEP);
4651}
4652
4653static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
4654 return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
4655}
4656
4657/// Verify !range and !absolute_symbol metadata. These have the same
4658/// restrictions, except !absolute_symbol allows the full set.
4659void Verifier::verifyRangeLikeMetadata(const Value &I, const MDNode *Range,
4660 Type *Ty, RangeLikeMetadataKind Kind) {
4661 unsigned NumOperands = Range->getNumOperands();
4662 Check(NumOperands % 2 == 0, "Unfinished range!", Range);
4663 unsigned NumRanges = NumOperands / 2;
4664 Check(NumRanges >= 1, "It should have at least one range!", Range);
4665
4666 ConstantRange LastRange(1, true); // Dummy initial value
4667 for (unsigned i = 0; i < NumRanges; ++i) {
4668 ConstantInt *Low =
4669 mdconst::dyn_extract<ConstantInt>(MD: Range->getOperand(I: 2 * i));
4670 Check(Low, "The lower limit must be an integer!", Low);
4671 ConstantInt *High =
4672 mdconst::dyn_extract<ConstantInt>(MD: Range->getOperand(I: 2 * i + 1));
4673 Check(High, "The upper limit must be an integer!", High);
4674
4675 Check(High->getType() == Low->getType(), "Range pair types must match!",
4676 &I);
4677
4678 if (Kind == RangeLikeMetadataKind::NoaliasAddrspace) {
4679 Check(High->getType()->isIntegerTy(32),
4680 "noalias.addrspace type must be i32!", &I);
4681 } else {
4682 Check(High->getType() == Ty->getScalarType(),
4683 "Range types must match instruction type!", &I);
4684 }
4685
4686 APInt HighV = High->getValue();
4687 APInt LowV = Low->getValue();
4688
4689 // ConstantRange asserts if the ranges are the same except for the min/max
4690 // value. Leave the cases it tolerates for the empty range error below.
4691 Check(LowV != HighV || LowV.isMaxValue() || LowV.isMinValue(),
4692 "The upper and lower limits cannot be the same value", &I);
4693
4694 ConstantRange CurRange(LowV, HighV);
4695 Check(!CurRange.isEmptySet() &&
4696 (Kind == RangeLikeMetadataKind::AbsoluteSymbol ||
4697 !CurRange.isFullSet()),
4698 "Range must not be empty!", Range);
4699 if (i != 0) {
4700 Check(CurRange.intersectWith(LastRange).isEmptySet(),
4701 "Intervals are overlapping", Range);
4702 Check(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
4703 Range);
4704 Check(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
4705 Range);
4706 }
4707 LastRange = ConstantRange(LowV, HighV);
4708 }
4709 if (NumRanges > 2) {
4710 APInt FirstLow =
4711 mdconst::dyn_extract<ConstantInt>(MD: Range->getOperand(I: 0))->getValue();
4712 APInt FirstHigh =
4713 mdconst::dyn_extract<ConstantInt>(MD: Range->getOperand(I: 1))->getValue();
4714 ConstantRange FirstRange(FirstLow, FirstHigh);
4715 Check(FirstRange.intersectWith(LastRange).isEmptySet(),
4716 "Intervals are overlapping", Range);
4717 Check(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
4718 Range);
4719 }
4720}
4721
4722void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
4723 assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&
4724 "precondition violation");
4725 verifyRangeLikeMetadata(I, Range, Ty, Kind: RangeLikeMetadataKind::Range);
4726}
4727
4728void Verifier::visitNoFPClassMetadata(Instruction &I, MDNode *NoFPClass,
4729 Type *Ty) {
4730 Check(AttributeFuncs::isNoFPClassCompatibleType(Ty),
4731 "nofpclass only applies to floating-point typed loads", I);
4732
4733 Check(NoFPClass->getNumOperands() == 1,
4734 "nofpclass must have exactly one entry", NoFPClass);
4735 ConstantInt *MaskVal =
4736 mdconst::dyn_extract<ConstantInt>(MD: NoFPClass->getOperand(I: 0));
4737 Check(MaskVal && MaskVal->getType()->isIntegerTy(32),
4738 "nofpclass entry must be a constant i32", NoFPClass);
4739 uint32_t Val = MaskVal->getZExtValue();
4740 Check(Val != 0, "'nofpclass' must have at least one test bit set", NoFPClass,
4741 I);
4742
4743 Check((Val & ~static_cast<unsigned>(fcAllFlags)) == 0,
4744 "Invalid value for 'nofpclass' test mask", NoFPClass, I);
4745}
4746
4747void Verifier::visitNoaliasAddrspaceMetadata(Instruction &I, MDNode *Range,
4748 Type *Ty) {
4749 assert(Range && Range == I.getMetadata(LLVMContext::MD_noalias_addrspace) &&
4750 "precondition violation");
4751 verifyRangeLikeMetadata(I, Range, Ty,
4752 Kind: RangeLikeMetadataKind::NoaliasAddrspace);
4753}
4754
4755void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
4756 unsigned Size = DL.getTypeSizeInBits(Ty).getFixedValue();
4757 Check(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
4758 Check(!(Size & (Size - 1)),
4759 "atomic memory access' operand must have a power-of-two size", Ty, I);
4760}
4761
4762void Verifier::visitLoadInst(LoadInst &LI) {
4763 auto *PTy = dyn_cast<PointerType>(Val: LI.getOperand(i_nocapture: 0)->getType());
4764 Check(PTy, "Load operand must be a pointer.", &LI);
4765 Type *ElTy = LI.getType();
4766 if (MaybeAlign A = LI.getAlign()) {
4767 Check(A->value() <= Value::MaximumAlignment,
4768 "huge alignment values are unsupported", &LI);
4769 }
4770 Check(ElTy->isSized(), "loading unsized types is not allowed", &LI);
4771 if (LI.isAtomic()) {
4772 Check(LI.getOrdering() != AtomicOrdering::Release &&
4773 LI.getOrdering() != AtomicOrdering::AcquireRelease,
4774 "Load cannot have Release ordering", &LI);
4775
4776 if (LI.isElementwise()) {
4777 Check(LI.getOrdering() != AtomicOrdering::SequentiallyConsistent,
4778 "atomic elementwise load cannot be sequentially consistent.", &LI);
4779 auto *VecTy = dyn_cast<FixedVectorType>(Val: ElTy);
4780 Check(VecTy,
4781 "atomic elementwise load operand must have fixed vector type!", &LI,
4782 ElTy);
4783 if (VecTy)
4784 checkAtomicMemAccessSize(Ty: VecTy->getElementType(), I: &LI);
4785 }
4786
4787 Check(ElTy->getScalarType()->isIntOrPtrTy() ||
4788 ElTy->getScalarType()->isByteTy() ||
4789 ElTy->getScalarType()->isFloatingPointTy(),
4790 "atomic load operand must have integer, byte, pointer, floating "
4791 "point, or vector type!",
4792 ElTy, &LI);
4793
4794 checkAtomicMemAccessSize(Ty: ElTy, I: &LI);
4795 } else {
4796 Check(!LI.isElementwise(), "non-atomic load cannot be elementwise", &LI);
4797 Check(LI.getSyncScopeID() == SyncScope::System,
4798 "Non-atomic load cannot have SynchronizationScope specified", &LI);
4799 }
4800
4801 visitInstruction(I&: LI);
4802}
4803
4804void Verifier::visitStoreInst(StoreInst &SI) {
4805 auto *PTy = dyn_cast<PointerType>(Val: SI.getOperand(i_nocapture: 1)->getType());
4806 Check(PTy, "Store operand must be a pointer.", &SI);
4807 Type *ElTy = SI.getOperand(i_nocapture: 0)->getType();
4808 if (MaybeAlign A = SI.getAlign()) {
4809 Check(A->value() <= Value::MaximumAlignment,
4810 "huge alignment values are unsupported", &SI);
4811 }
4812 Check(ElTy->isSized(), "storing unsized types is not allowed", &SI);
4813 if (SI.isAtomic()) {
4814 Check(SI.getOrdering() != AtomicOrdering::Acquire &&
4815 SI.getOrdering() != AtomicOrdering::AcquireRelease,
4816 "Store cannot have Acquire ordering", &SI);
4817
4818 if (SI.isElementwise()) {
4819 Check(SI.getOrdering() != AtomicOrdering::SequentiallyConsistent,
4820 "atomic elementwise store cannot be sequentially consistent.", &SI);
4821
4822 auto *VecTy = dyn_cast<FixedVectorType>(Val: ElTy);
4823 Check(VecTy,
4824 "atomic elementwise store operand must have fixed vector type!",
4825 &SI, ElTy);
4826 if (VecTy)
4827 checkAtomicMemAccessSize(Ty: VecTy->getElementType(), I: &SI);
4828 }
4829
4830 Check(ElTy->getScalarType()->isIntOrPtrTy() ||
4831 ElTy->getScalarType()->isByteTy() ||
4832 ElTy->getScalarType()->isFloatingPointTy(),
4833 "atomic store operand must have integer, byte, pointer, floating "
4834 "point, or vector type!",
4835 ElTy, &SI);
4836 checkAtomicMemAccessSize(Ty: ElTy, I: &SI);
4837 } else {
4838 Check(!SI.isElementwise(), "non-atomic store cannot be elementwise", &SI);
4839 Check(SI.getSyncScopeID() == SyncScope::System,
4840 "Non-atomic store cannot have SynchronizationScope specified", &SI);
4841 }
4842 visitInstruction(I&: SI);
4843}
4844
4845/// Check that SwiftErrorVal is used as a swifterror argument in CS.
4846void Verifier::verifySwiftErrorCall(CallBase &Call,
4847 const Value *SwiftErrorVal) {
4848 for (const auto &I : llvm::enumerate(First: Call.args())) {
4849 if (I.value() == SwiftErrorVal) {
4850 Check(Call.paramHasAttr(I.index(), Attribute::SwiftError),
4851 "swifterror value when used in a callsite should be marked "
4852 "with swifterror attribute",
4853 SwiftErrorVal, Call);
4854 }
4855 }
4856}
4857
4858void Verifier::verifySwiftErrorValue(const Value *SwiftErrorVal) {
4859 // Check that swifterror value is only used by loads, stores, or as
4860 // a swifterror argument.
4861 for (const User *U : SwiftErrorVal->users()) {
4862 Check(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
4863 isa<InvokeInst>(U),
4864 "swifterror value can only be loaded and stored from, or "
4865 "as a swifterror argument!",
4866 SwiftErrorVal, U);
4867 // If it is used by a store, check it is the second operand.
4868 if (auto StoreI = dyn_cast<StoreInst>(Val: U))
4869 Check(StoreI->getOperand(1) == SwiftErrorVal,
4870 "swifterror value should be the second operand when used "
4871 "by stores",
4872 SwiftErrorVal, U);
4873 if (auto *Call = dyn_cast<CallBase>(Val: U))
4874 verifySwiftErrorCall(Call&: *const_cast<CallBase *>(Call), SwiftErrorVal);
4875 }
4876}
4877
4878void Verifier::visitAllocaInst(AllocaInst &AI) {
4879 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
4880 MD: AI.getModule()->getModuleFlag(Key: "require-logical-pointer")))
4881 Check(!MD->getZExtValue(),
4882 "Non-logical alloca disallowed for this module.");
4883
4884 Type *Ty = AI.getAllocatedType();
4885 Check(Ty->isSized(), "Cannot allocate unsized type", &AI);
4886 // Check if it's a target extension type that disallows being used on the
4887 // stack.
4888 Check(!Ty->containsNonLocalTargetExtType(),
4889 "Alloca has illegal target extension type", &AI);
4890 Check(AI.getArraySize()->getType()->isIntegerTy(),
4891 "Alloca array size must have integer type", &AI);
4892 if (MaybeAlign A = AI.getAlign()) {
4893 Check(A->value() <= Value::MaximumAlignment,
4894 "huge alignment values are unsupported", &AI);
4895 }
4896
4897 if (AI.isSwiftError()) {
4898 Check(Ty->isPointerTy(), "swifterror alloca must have pointer type", &AI);
4899 Check(!AI.isArrayAllocation(),
4900 "swifterror alloca must not be array allocation", &AI);
4901 verifySwiftErrorValue(SwiftErrorVal: &AI);
4902 }
4903
4904 visitInstruction(I&: AI);
4905
4906 // Target-specific alloca checks.
4907 verifyAMDGPUAlloca(VS&: *this, AI);
4908}
4909
4910void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
4911 Type *ElTy = CXI.getOperand(i_nocapture: 1)->getType();
4912 Check(ElTy->isIntOrPtrTy(),
4913 "cmpxchg operand must have integer or pointer type", ElTy, &CXI);
4914 checkAtomicMemAccessSize(Ty: ElTy, I: &CXI);
4915 visitInstruction(I&: CXI);
4916}
4917
4918void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
4919 Check(RMWI.getOrdering() != AtomicOrdering::Unordered,
4920 "atomicrmw instructions cannot be unordered.", &RMWI);
4921 auto Op = RMWI.getOperation();
4922 Type *ElTy = RMWI.getOperand(i_nocapture: 1)->getType();
4923 Check(!ElTy->isScalableTy(), "atomicrmw operand may not be scalable", &RMWI);
4924 if (RMWI.isElementwise()) {
4925 Check(RMWI.getOrdering() != AtomicOrdering::SequentiallyConsistent,
4926 "atomicrmw elementwise cannot be sequentially consistent.", &RMWI);
4927 auto *VecTy = dyn_cast<FixedVectorType>(Val: ElTy);
4928 Check(VecTy, "atomicrmw elementwise operand must have fixed vector type!",
4929 &RMWI, ElTy);
4930 if (VecTy)
4931 checkAtomicMemAccessSize(Ty: VecTy->getElementType(), I: &RMWI);
4932 }
4933
4934 if (Op == AtomicRMWInst::Xchg) {
4935 Check((ElTy->isIntOrIntVectorTy() || ElTy->isFPOrFPVectorTy() ||
4936 ElTy->isPtrOrPtrVectorTy()),
4937 "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
4938 " operand must be an integer type, a floating-point type, a "
4939 "pointer type, or a fixed vector of any of these types!",
4940 &RMWI, ElTy);
4941 } else if (AtomicRMWInst::isFPOperation(Op)) {
4942 Check(ElTy->isFPOrFPVectorTy(),
4943 "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
4944 " operand must have floating-point or fixed vector of "
4945 "floating-point "
4946 "type!",
4947 &RMWI, ElTy);
4948 } else {
4949 Check(ElTy->isIntOrIntVectorTy(),
4950 "atomicrmw " + AtomicRMWInst::getOperationName(Op) +
4951 " operand must have integer or fixed vector of integer type!",
4952 &RMWI, ElTy);
4953 }
4954 checkAtomicMemAccessSize(Ty: ElTy, I: &RMWI);
4955 Check(AtomicRMWInst::FIRST_BINOP <= Op && Op <= AtomicRMWInst::LAST_BINOP,
4956 "Invalid binary operation!", &RMWI);
4957 visitInstruction(I&: RMWI);
4958}
4959
4960void Verifier::visitFenceInst(FenceInst &FI) {
4961 const AtomicOrdering Ordering = FI.getOrdering();
4962 Check(Ordering == AtomicOrdering::Acquire ||
4963 Ordering == AtomicOrdering::Release ||
4964 Ordering == AtomicOrdering::AcquireRelease ||
4965 Ordering == AtomicOrdering::SequentiallyConsistent,
4966 "fence instructions may only have acquire, release, acq_rel, or "
4967 "seq_cst ordering.",
4968 &FI);
4969 visitInstruction(I&: FI);
4970}
4971
4972void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
4973 Check(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
4974 EVI.getIndices()) == EVI.getType(),
4975 "Invalid ExtractValueInst operands!", &EVI);
4976
4977 visitInstruction(I&: EVI);
4978}
4979
4980void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
4981 Check(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
4982 IVI.getIndices()) ==
4983 IVI.getOperand(1)->getType(),
4984 "Invalid InsertValueInst operands!", &IVI);
4985
4986 visitInstruction(I&: IVI);
4987}
4988
4989static Value *getParentPad(Value *EHPad) {
4990 if (auto *FPI = dyn_cast<FuncletPadInst>(Val: EHPad))
4991 return FPI->getParentPad();
4992
4993 return cast<CatchSwitchInst>(Val: EHPad)->getParentPad();
4994}
4995
4996void Verifier::visitEHPadPredecessors(Instruction &I) {
4997 assert(I.isEHPad());
4998
4999 BasicBlock *BB = I.getParent();
5000 Function *F = BB->getParent();
5001
5002 Check(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
5003
5004 if (auto *LPI = dyn_cast<LandingPadInst>(Val: &I)) {
5005 // The landingpad instruction defines its parent as a landing pad block. The
5006 // landing pad block may be branched to only by the unwind edge of an
5007 // invoke.
5008 for (BasicBlock *PredBB : predecessors(BB)) {
5009 const auto *II = dyn_cast<InvokeInst>(Val: PredBB->getTerminator());
5010 Check(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
5011 "Block containing LandingPadInst must be jumped to "
5012 "only by the unwind edge of an invoke.",
5013 LPI);
5014 }
5015 return;
5016 }
5017 if (auto *CPI = dyn_cast<CatchPadInst>(Val: &I)) {
5018 if (!pred_empty(BB))
5019 Check(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
5020 "Block containg CatchPadInst must be jumped to "
5021 "only by its catchswitch.",
5022 CPI);
5023 Check(BB != CPI->getCatchSwitch()->getUnwindDest(),
5024 "Catchswitch cannot unwind to one of its catchpads",
5025 CPI->getCatchSwitch(), CPI);
5026 return;
5027 }
5028
5029 // Verify that each pred has a legal terminator with a legal to/from EH
5030 // pad relationship.
5031 Instruction *ToPad = &I;
5032 Value *ToPadParent = getParentPad(EHPad: ToPad);
5033 for (BasicBlock *PredBB : predecessors(BB)) {
5034 Instruction *TI = PredBB->getTerminator();
5035 Value *FromPad;
5036 if (auto *II = dyn_cast<InvokeInst>(Val: TI)) {
5037 Check(II->getUnwindDest() == BB && II->getNormalDest() != BB,
5038 "EH pad must be jumped to via an unwind edge", ToPad, II);
5039 auto *CalledFn =
5040 dyn_cast<Function>(Val: II->getCalledOperand()->stripPointerCasts());
5041 if (CalledFn && CalledFn->isIntrinsic() && II->doesNotThrow() &&
5042 !IntrinsicInst::mayLowerToFunctionCall(IID: CalledFn->getIntrinsicID()))
5043 continue;
5044 if (auto Bundle = II->getOperandBundle(ID: LLVMContext::OB_funclet))
5045 FromPad = Bundle->Inputs[0];
5046 else
5047 FromPad = ConstantTokenNone::get(Context&: II->getContext());
5048 } else if (auto *CRI = dyn_cast<CleanupReturnInst>(Val: TI)) {
5049 FromPad = CRI->getOperand(i_nocapture: 0);
5050 Check(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI);
5051 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(Val: TI)) {
5052 FromPad = CSI;
5053 } else {
5054 Check(false, "EH pad must be jumped to via an unwind edge", ToPad, TI);
5055 }
5056
5057 // The edge may exit from zero or more nested pads.
5058 SmallPtrSet<Value *, 8> Seen;
5059 for (;; FromPad = getParentPad(EHPad: FromPad)) {
5060 Check(FromPad != ToPad,
5061 "EH pad cannot handle exceptions raised within it", FromPad, TI);
5062 if (FromPad == ToPadParent) {
5063 // This is a legal unwind edge.
5064 break;
5065 }
5066 Check(!isa<ConstantTokenNone>(FromPad),
5067 "A single unwind edge may only enter one EH pad", TI);
5068 Check(Seen.insert(FromPad).second, "EH pad jumps through a cycle of pads",
5069 FromPad);
5070
5071 // This will be diagnosed on the corresponding instruction already. We
5072 // need the extra check here to make sure getParentPad() works.
5073 Check(isa<FuncletPadInst>(FromPad) || isa<CatchSwitchInst>(FromPad),
5074 "Parent pad must be catchpad/cleanuppad/catchswitch", TI);
5075 }
5076 }
5077}
5078
5079void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
5080 // The landingpad instruction is ill-formed if it doesn't have any clauses and
5081 // isn't a cleanup.
5082 Check(LPI.getNumClauses() > 0 || LPI.isCleanup(),
5083 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
5084
5085 visitEHPadPredecessors(I&: LPI);
5086
5087 if (!LandingPadResultTy)
5088 LandingPadResultTy = LPI.getType();
5089 else
5090 Check(LandingPadResultTy == LPI.getType(),
5091 "The landingpad instruction should have a consistent result type "
5092 "inside a function.",
5093 &LPI);
5094
5095 Function *F = LPI.getParent()->getParent();
5096 Check(F->hasPersonalityFn(),
5097 "LandingPadInst needs to be in a function with a personality.", &LPI);
5098
5099 // The landingpad instruction must be the first non-PHI instruction in the
5100 // block.
5101 Check(LPI.getParent()->getLandingPadInst() == &LPI,
5102 "LandingPadInst not the first non-PHI instruction in the block.", &LPI);
5103
5104 for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
5105 Constant *Clause = LPI.getClause(Idx: i);
5106 if (LPI.isCatch(Idx: i)) {
5107 Check(isa<PointerType>(Clause->getType()),
5108 "Catch operand does not have pointer type!", &LPI);
5109 } else {
5110 Check(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
5111 Check(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
5112 "Filter operand is not an array of constants!", &LPI);
5113 }
5114 }
5115
5116 visitInstruction(I&: LPI);
5117}
5118
5119void Verifier::visitResumeInst(ResumeInst &RI) {
5120 Check(RI.getFunction()->hasPersonalityFn(),
5121 "ResumeInst needs to be in a function with a personality.", &RI);
5122
5123 if (!LandingPadResultTy)
5124 LandingPadResultTy = RI.getValue()->getType();
5125 else
5126 Check(LandingPadResultTy == RI.getValue()->getType(),
5127 "The resume instruction should have a consistent result type "
5128 "inside a function.",
5129 &RI);
5130
5131 visitTerminator(I&: RI);
5132}
5133
5134void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
5135 BasicBlock *BB = CPI.getParent();
5136
5137 Function *F = BB->getParent();
5138 Check(F->hasPersonalityFn(),
5139 "CatchPadInst needs to be in a function with a personality.", &CPI);
5140
5141 Check(isa<CatchSwitchInst>(CPI.getParentPad()),
5142 "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
5143 CPI.getParentPad());
5144
5145 // The catchpad instruction must be the first non-PHI instruction in the
5146 // block.
5147 Check(&*BB->getFirstNonPHIIt() == &CPI,
5148 "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
5149
5150 Check(llvm::all_of(CPI.arg_operands(),
5151 [](Use &U) {
5152 auto *V = U.get();
5153 return isa<Constant>(V) || isa<AllocaInst>(V);
5154 }),
5155 "Argument operand must be alloca or constant.", &CPI);
5156
5157 visitEHPadPredecessors(I&: CPI);
5158 visitFuncletPadInst(FPI&: CPI);
5159}
5160
5161void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
5162 Check(isa<CatchPadInst>(CatchReturn.getOperand(0)),
5163 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
5164 CatchReturn.getOperand(0));
5165
5166 visitTerminator(I&: CatchReturn);
5167}
5168
5169void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
5170 BasicBlock *BB = CPI.getParent();
5171
5172 Function *F = BB->getParent();
5173 Check(F->hasPersonalityFn(),
5174 "CleanupPadInst needs to be in a function with a personality.", &CPI);
5175
5176 // The cleanuppad instruction must be the first non-PHI instruction in the
5177 // block.
5178 Check(&*BB->getFirstNonPHIIt() == &CPI,
5179 "CleanupPadInst not the first non-PHI instruction in the block.", &CPI);
5180
5181 auto *ParentPad = CPI.getParentPad();
5182 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
5183 "CleanupPadInst has an invalid parent.", &CPI);
5184
5185 visitEHPadPredecessors(I&: CPI);
5186 visitFuncletPadInst(FPI&: CPI);
5187}
5188
5189void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
5190 User *FirstUser = nullptr;
5191 Value *FirstUnwindPad = nullptr;
5192 SmallVector<FuncletPadInst *, 8> Worklist({&FPI});
5193 SmallPtrSet<FuncletPadInst *, 8> Seen;
5194
5195 while (!Worklist.empty()) {
5196 FuncletPadInst *CurrentPad = Worklist.pop_back_val();
5197 Check(Seen.insert(CurrentPad).second,
5198 "FuncletPadInst must not be nested within itself", CurrentPad);
5199 Value *UnresolvedAncestorPad = nullptr;
5200 for (User *U : CurrentPad->users()) {
5201 BasicBlock *UnwindDest;
5202 if (auto *CRI = dyn_cast<CleanupReturnInst>(Val: U)) {
5203 UnwindDest = CRI->getUnwindDest();
5204 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(Val: U)) {
5205 // We allow catchswitch unwind to caller to nest
5206 // within an outer pad that unwinds somewhere else,
5207 // because catchswitch doesn't have a nounwind variant.
5208 // See e.g. SimplifyCFGOpt::SimplifyUnreachable.
5209 if (CSI->unwindsToCaller())
5210 continue;
5211 UnwindDest = CSI->getUnwindDest();
5212 } else if (auto *II = dyn_cast<InvokeInst>(Val: U)) {
5213 UnwindDest = II->getUnwindDest();
5214 } else if (isa<CallInst>(Val: U)) {
5215 // Calls which don't unwind may be found inside funclet
5216 // pads that unwind somewhere else. We don't *require*
5217 // such calls to be annotated nounwind.
5218 continue;
5219 } else if (auto *CPI = dyn_cast<CleanupPadInst>(Val: U)) {
5220 // The unwind dest for a cleanup can only be found by
5221 // recursive search. Add it to the worklist, and we'll
5222 // search for its first use that determines where it unwinds.
5223 Worklist.push_back(Elt: CPI);
5224 continue;
5225 } else {
5226 Check(isa<CatchReturnInst>(U), "Bogus funclet pad use", U);
5227 continue;
5228 }
5229
5230 Value *UnwindPad;
5231 bool ExitsFPI;
5232 if (UnwindDest) {
5233 UnwindPad = &*UnwindDest->getFirstNonPHIIt();
5234 if (!cast<Instruction>(Val: UnwindPad)->isEHPad())
5235 continue;
5236 Value *UnwindParent = getParentPad(EHPad: UnwindPad);
5237 // Ignore unwind edges that don't exit CurrentPad.
5238 if (UnwindParent == CurrentPad)
5239 continue;
5240 // Determine whether the original funclet pad is exited,
5241 // and if we are scanning nested pads determine how many
5242 // of them are exited so we can stop searching their
5243 // children.
5244 Value *ExitedPad = CurrentPad;
5245 ExitsFPI = false;
5246 do {
5247 if (ExitedPad == &FPI) {
5248 ExitsFPI = true;
5249 // Now we can resolve any ancestors of CurrentPad up to
5250 // FPI, but not including FPI since we need to make sure
5251 // to check all direct users of FPI for consistency.
5252 UnresolvedAncestorPad = &FPI;
5253 break;
5254 }
5255 Value *ExitedParent = getParentPad(EHPad: ExitedPad);
5256 if (ExitedParent == UnwindParent) {
5257 // ExitedPad is the ancestor-most pad which this unwind
5258 // edge exits, so we can resolve up to it, meaning that
5259 // ExitedParent is the first ancestor still unresolved.
5260 UnresolvedAncestorPad = ExitedParent;
5261 break;
5262 }
5263 ExitedPad = ExitedParent;
5264 } while (!isa<ConstantTokenNone>(Val: ExitedPad));
5265 } else {
5266 // Unwinding to caller exits all pads.
5267 UnwindPad = ConstantTokenNone::get(Context&: FPI.getContext());
5268 ExitsFPI = true;
5269 UnresolvedAncestorPad = &FPI;
5270 }
5271
5272 if (ExitsFPI) {
5273 // This unwind edge exits FPI. Make sure it agrees with other
5274 // such edges.
5275 if (FirstUser) {
5276 Check(UnwindPad == FirstUnwindPad,
5277 "Unwind edges out of a funclet "
5278 "pad must have the same unwind "
5279 "dest",
5280 &FPI, U, FirstUser);
5281 } else {
5282 FirstUser = U;
5283 FirstUnwindPad = UnwindPad;
5284 // Record cleanup sibling unwinds for verifySiblingFuncletUnwinds
5285 if (isa<CleanupPadInst>(Val: &FPI) && !isa<ConstantTokenNone>(Val: UnwindPad) &&
5286 getParentPad(EHPad: UnwindPad) == getParentPad(EHPad: &FPI))
5287 SiblingFuncletInfo[&FPI] = cast<Instruction>(Val: U);
5288 }
5289 }
5290 // Make sure we visit all uses of FPI, but for nested pads stop as
5291 // soon as we know where they unwind to.
5292 if (CurrentPad != &FPI)
5293 break;
5294 }
5295 if (UnresolvedAncestorPad) {
5296 if (CurrentPad == UnresolvedAncestorPad) {
5297 // When CurrentPad is FPI itself, we don't mark it as resolved even if
5298 // we've found an unwind edge that exits it, because we need to verify
5299 // all direct uses of FPI.
5300 assert(CurrentPad == &FPI);
5301 continue;
5302 }
5303 // Pop off the worklist any nested pads that we've found an unwind
5304 // destination for. The pads on the worklist are the uncles,
5305 // great-uncles, etc. of CurrentPad. We've found an unwind destination
5306 // for all ancestors of CurrentPad up to but not including
5307 // UnresolvedAncestorPad.
5308 Value *ResolvedPad = CurrentPad;
5309 while (!Worklist.empty()) {
5310 Value *UnclePad = Worklist.back();
5311 Value *AncestorPad = getParentPad(EHPad: UnclePad);
5312 // Walk ResolvedPad up the ancestor list until we either find the
5313 // uncle's parent or the last resolved ancestor.
5314 while (ResolvedPad != AncestorPad) {
5315 Value *ResolvedParent = getParentPad(EHPad: ResolvedPad);
5316 if (ResolvedParent == UnresolvedAncestorPad) {
5317 break;
5318 }
5319 ResolvedPad = ResolvedParent;
5320 }
5321 // If the resolved ancestor search didn't find the uncle's parent,
5322 // then the uncle is not yet resolved.
5323 if (ResolvedPad != AncestorPad)
5324 break;
5325 // This uncle is resolved, so pop it from the worklist.
5326 Worklist.pop_back();
5327 }
5328 }
5329 }
5330
5331 if (FirstUnwindPad) {
5332 if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Val: FPI.getParentPad())) {
5333 BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
5334 Value *SwitchUnwindPad;
5335 if (SwitchUnwindDest)
5336 SwitchUnwindPad = &*SwitchUnwindDest->getFirstNonPHIIt();
5337 else
5338 SwitchUnwindPad = ConstantTokenNone::get(Context&: FPI.getContext());
5339 Check(SwitchUnwindPad == FirstUnwindPad,
5340 "Unwind edges out of a catch must have the same unwind dest as "
5341 "the parent catchswitch",
5342 &FPI, FirstUser, CatchSwitch);
5343 }
5344 }
5345
5346 visitInstruction(I&: FPI);
5347}
5348
5349void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
5350 BasicBlock *BB = CatchSwitch.getParent();
5351
5352 Function *F = BB->getParent();
5353 Check(F->hasPersonalityFn(),
5354 "CatchSwitchInst needs to be in a function with a personality.",
5355 &CatchSwitch);
5356
5357 // The catchswitch instruction must be the first non-PHI instruction in the
5358 // block.
5359 Check(&*BB->getFirstNonPHIIt() == &CatchSwitch,
5360 "CatchSwitchInst not the first non-PHI instruction in the block.",
5361 &CatchSwitch);
5362
5363 auto *ParentPad = CatchSwitch.getParentPad();
5364 Check(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
5365 "CatchSwitchInst has an invalid parent.", ParentPad);
5366
5367 if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
5368 BasicBlock::iterator I = UnwindDest->getFirstNonPHIIt();
5369 Check(I->isEHPad() && !isa<LandingPadInst>(I),
5370 "CatchSwitchInst must unwind to an EH block which is not a "
5371 "landingpad.",
5372 &CatchSwitch);
5373
5374 // Record catchswitch sibling unwinds for verifySiblingFuncletUnwinds
5375 if (getParentPad(EHPad: &*I) == ParentPad)
5376 SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
5377 }
5378
5379 Check(CatchSwitch.getNumHandlers() != 0,
5380 "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
5381
5382 for (BasicBlock *Handler : CatchSwitch.handlers()) {
5383 Check(isa<CatchPadInst>(Handler->getFirstNonPHIIt()),
5384 "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
5385 }
5386
5387 visitEHPadPredecessors(I&: CatchSwitch);
5388 visitTerminator(I&: CatchSwitch);
5389}
5390
5391void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) {
5392 Check(isa<CleanupPadInst>(CRI.getOperand(0)),
5393 "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
5394 CRI.getOperand(0));
5395
5396 if (BasicBlock *UnwindDest = CRI.getUnwindDest()) {
5397 BasicBlock::iterator I = UnwindDest->getFirstNonPHIIt();
5398 Check(I->isEHPad() && !isa<LandingPadInst>(I),
5399 "CleanupReturnInst must unwind to an EH block which is not a "
5400 "landingpad.",
5401 &CRI);
5402 }
5403
5404 visitTerminator(I&: CRI);
5405}
5406
5407void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
5408 Instruction *Op = cast<Instruction>(Val: I.getOperand(i));
5409 // If the we have an invalid invoke, don't try to compute the dominance.
5410 // We already reject it in the invoke specific checks and the dominance
5411 // computation doesn't handle multiple edges.
5412 if (auto *II = dyn_cast<InvokeInst>(Val: Op)) {
5413 if (II->getNormalDest() == II->getUnwindDest())
5414 return;
5415 }
5416
5417 // Quick check whether the def has already been encountered in the same block.
5418 // PHI nodes are not checked to prevent accepting preceding PHIs, because PHI
5419 // uses are defined to happen on the incoming edge, not at the instruction.
5420 //
5421 // FIXME: If this operand is a MetadataAsValue (wrapping a LocalAsMetadata)
5422 // wrapping an SSA value, assert that we've already encountered it. See
5423 // related FIXME in Mapper::mapLocalAsMetadata in ValueMapper.cpp.
5424 if (!isa<PHINode>(Val: I) && InstsInThisBlock.count(Ptr: Op))
5425 return;
5426
5427 const Use &U = I.getOperandUse(i);
5428 Check(DT.dominates(Op, U), "Instruction does not dominate all uses!", Op, &I);
5429}
5430
5431void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
5432 Check(I.getType()->isPointerTy(),
5433 "dereferenceable, dereferenceable_or_null "
5434 "apply only to pointer types",
5435 &I);
5436 Check((isa<LoadInst>(I) || isa<IntToPtrInst>(I)),
5437 "dereferenceable, dereferenceable_or_null apply only to load"
5438 " and inttoptr instructions, use attributes for calls or invokes",
5439 &I);
5440 Check(MD->getNumOperands() == 1,
5441 "dereferenceable, dereferenceable_or_null "
5442 "take one operand!",
5443 &I);
5444 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: 0));
5445 Check(CI && CI->getType()->isIntegerTy(64),
5446 "dereferenceable, "
5447 "dereferenceable_or_null metadata value must be an i64!",
5448 &I);
5449}
5450
5451void Verifier::visitNoFreeObjMetadata(Instruction &I, MDNode *MD) {
5452 Check(I.getType()->isPointerTy(), "nofreeobj applies only to pointer types",
5453 &I);
5454 Check((isa<IntToPtrInst>(I)),
5455 "nofreeobj applies only to inttoptr instruction", &I);
5456 Check(MD->getNumOperands() == 0, "nofreeobj metadata must be empty", &I);
5457}
5458
5459void Verifier::visitProfMetadata(Instruction &I, MDNode *MD) {
5460 auto GetBranchingTerminatorNumOperands = [&]() {
5461 unsigned ExpectedNumOperands = 0;
5462 if (auto *BI = dyn_cast<CondBrInst>(Val: &I))
5463 ExpectedNumOperands = BI->getNumSuccessors();
5464 else if (auto *SI = dyn_cast<SwitchInst>(Val: &I))
5465 ExpectedNumOperands = SI->getNumSuccessors();
5466 else if (isa<CallInst>(Val: &I))
5467 ExpectedNumOperands = 1;
5468 else if (auto *IBI = dyn_cast<IndirectBrInst>(Val: &I))
5469 ExpectedNumOperands = IBI->getNumDestinations();
5470 else if (isa<SelectInst>(Val: &I))
5471 ExpectedNumOperands = 2;
5472 else if (auto *CI = dyn_cast<CallBrInst>(Val: &I))
5473 ExpectedNumOperands = CI->getNumSuccessors();
5474 return ExpectedNumOperands;
5475 };
5476 Check(MD->getNumOperands() >= 1,
5477 "!prof annotations should have at least 1 operand", MD);
5478 // Check first operand.
5479 Check(MD->getOperand(0) != nullptr, "first operand should not be null", MD);
5480 Check(isa<MDString>(MD->getOperand(0)),
5481 "expected string with name of the !prof annotation", MD);
5482 MDString *MDS = cast<MDString>(Val: MD->getOperand(I: 0));
5483 StringRef ProfName = MDS->getString();
5484
5485 if (ProfName == MDProfLabels::UnknownBranchWeightsMarker) {
5486 Check(GetBranchingTerminatorNumOperands() != 0 || isa<InvokeInst>(I),
5487 "'unknown' !prof should only appear on instructions on which "
5488 "'branch_weights' would",
5489 MD);
5490 verifyUnknownProfileMetadata(MD);
5491 return;
5492 }
5493
5494 Check(MD->getNumOperands() >= 2,
5495 "!prof annotations should have no less than 2 operands", MD);
5496
5497 // Check consistency of !prof branch_weights metadata.
5498 if (ProfName == MDProfLabels::BranchWeights) {
5499 unsigned NumBranchWeights = getNumBranchWeights(ProfileData: *MD);
5500 if (isa<InvokeInst>(Val: &I)) {
5501 Check(NumBranchWeights == 1 || NumBranchWeights == 2,
5502 "Wrong number of InvokeInst branch_weights operands", MD);
5503 } else {
5504 const unsigned ExpectedNumOperands = GetBranchingTerminatorNumOperands();
5505 if (ExpectedNumOperands == 0)
5506 CheckFailed(Message: "!prof branch_weights are not allowed for this instruction",
5507 V1: MD);
5508
5509 Check(NumBranchWeights == ExpectedNumOperands, "Wrong number of operands",
5510 MD);
5511 }
5512 for (unsigned i = getBranchWeightOffset(ProfileData: MD); i < MD->getNumOperands();
5513 ++i) {
5514 auto &MDO = MD->getOperand(I: i);
5515 Check(MDO, "second operand should not be null", MD);
5516 Check(mdconst::dyn_extract<ConstantInt>(MDO),
5517 "!prof brunch_weights operand is not a const int");
5518 }
5519 } else if (ProfName == MDProfLabels::ValueProfile) {
5520 Check(isValueProfileMD(MD), "invalid value profiling metadata", MD);
5521 ConstantInt *KindInt = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: 1));
5522 Check(KindInt, "VP !prof missing kind argument", MD);
5523
5524 auto Kind = KindInt->getZExtValue();
5525 Check(Kind >= InstrProfValueKind::IPVK_First &&
5526 Kind <= InstrProfValueKind::IPVK_Last,
5527 "Invalid VP !prof kind", MD);
5528 Check(MD->getNumOperands() % 2 == 1,
5529 "VP !prof should have an even number "
5530 "of arguments after 'VP'",
5531 MD);
5532 if (Kind == InstrProfValueKind::IPVK_IndirectCallTarget ||
5533 Kind == InstrProfValueKind::IPVK_MemOPSize)
5534 Check(isa<CallBase>(I),
5535 "VP !prof indirect call or memop size expected to be applied to "
5536 "CallBase instructions only",
5537 MD);
5538
5539 DenseSet<uint64_t> ProfileValues;
5540 for (unsigned I = 3; I < MD->getNumOperands(); I += 2) {
5541 ConstantInt *ProfileValue =
5542 mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I));
5543 Check(ProfileValue, "VP !prof value operand is not a const int", MD);
5544 uint64_t ProfileValueInt = ProfileValue->getZExtValue();
5545 auto [ValueIt, Inserted] = ProfileValues.insert(V: ProfileValueInt);
5546 Check(Inserted, "VP !prof should not have duplicate profile values", MD);
5547 }
5548 } else {
5549 CheckFailed(Message: "expected either branch_weights or VP profile name", V1: MD);
5550 }
5551}
5552
5553void Verifier::visitDIAssignIDMetadata(Instruction &I, MDNode *MD) {
5554 assert(I.hasMetadata(LLVMContext::MD_DIAssignID));
5555 // DIAssignID metadata must be attached to either an alloca or some form of
5556 // store/memory-writing instruction.
5557 // FIXME: We allow all intrinsic insts here to avoid trying to enumerate all
5558 // possible store intrinsics.
5559 bool ExpectedInstTy =
5560 isa<AllocaInst>(Val: I) || isa<StoreInst>(Val: I) || isa<IntrinsicInst>(Val: I);
5561 CheckDI(ExpectedInstTy, "!DIAssignID attached to unexpected instruction kind",
5562 I, MD);
5563 // Iterate over the MetadataAsValue uses of the DIAssignID - these should
5564 // only be found as DbgAssignIntrinsic operands.
5565 if (auto *AsValue = MetadataAsValue::getIfExists(Context, MD)) {
5566 for (auto *User : AsValue->users()) {
5567 CheckDI(isa<DbgAssignIntrinsic>(User),
5568 "!DIAssignID should only be used by llvm.dbg.assign intrinsics",
5569 MD, User);
5570 // All of the dbg.assign intrinsics should be in the same function as I.
5571 if (auto *DAI = dyn_cast<DbgAssignIntrinsic>(Val: User))
5572 CheckDI(DAI->getFunction() == I.getFunction(),
5573 "dbg.assign not in same function as inst", DAI, &I);
5574 }
5575 }
5576 for (DbgVariableRecord *DVR : at::getAssignmentMarkers(ID: cast<DIAssignID>(Val: MD)))
5577 CheckDI(DVR->getFunction() == I.getFunction(),
5578 "DVRAssign not in same function as inst", DVR, &I);
5579}
5580
5581void Verifier::visitMMRAMetadata(Instruction &I, MDNode *MD) {
5582 Check(canInstructionHaveMMRAs(I),
5583 "!mmra metadata attached to unexpected instruction kind", I, MD);
5584
5585 // MMRA Metadata should either be a tag, e.g. !{!"foo", !"bar"}, or a
5586 // list of tags such as !2 in the following example:
5587 // !0 = !{!"a", !"b"}
5588 // !1 = !{!"c", !"d"}
5589 // !2 = !{!0, !1}
5590 if (MMRAMetadata::isTagMD(MD))
5591 return;
5592
5593 Check(isa<MDTuple>(MD), "!mmra expected to be a metadata tuple", I, MD);
5594 for (const MDOperand &MDOp : MD->operands())
5595 Check(MMRAMetadata::isTagMD(MDOp.get()),
5596 "!mmra metadata tuple operand is not an MMRA tag", I, MDOp.get());
5597}
5598
5599void Verifier::visitCallStackMetadata(MDNode *MD) {
5600 // Call stack metadata should consist of a list of at least 1 constant int
5601 // (representing a hash of the location).
5602 Check(MD->getNumOperands() >= 1,
5603 "call stack metadata should have at least 1 operand", MD);
5604
5605 for (const auto &Op : MD->operands())
5606 Check(mdconst::dyn_extract_or_null<ConstantInt>(Op),
5607 "call stack metadata operand should be constant integer", Op);
5608}
5609
5610void Verifier::visitMemProfMetadata(Instruction &I, MDNode *MD) {
5611 Check(isa<CallBase>(I), "!memprof metadata should only exist on calls", &I);
5612 if (isa<CallBase>(Val: I))
5613 Check(I.hasMetadata(LLVMContext::MD_callsite),
5614 "!memprof metadata requires !callsite metadata", &I, MD);
5615 Check(MD->getNumOperands() >= 1,
5616 "!memprof annotations should have at least 1 metadata operand "
5617 "(MemInfoBlock)",
5618 MD);
5619
5620 // Check each MIB
5621 for (auto &MIBOp : MD->operands()) {
5622 auto *MIB = dyn_cast<MDNode>(Val: MIBOp);
5623 // The first operand of an MIB should be the call stack metadata.
5624 // There rest of the operands should be MDString tags, and there should be
5625 // at least one.
5626 Check(MIB->getNumOperands() >= 2,
5627 "Each !memprof MemInfoBlock should have at least 2 operands", MIB);
5628
5629 // Check call stack metadata (first operand).
5630 Check(MIB->getOperand(0) != nullptr,
5631 "!memprof MemInfoBlock first operand should not be null", MIB);
5632 Check(isa<MDNode>(MIB->getOperand(0)),
5633 "!memprof MemInfoBlock first operand should be an MDNode", MIB);
5634 auto *StackMD = dyn_cast<MDNode>(Val: MIB->getOperand(I: 0));
5635 visitCallStackMetadata(MD: StackMD);
5636
5637 // The second MIB operand should be MDString.
5638 Check(isa<MDString>(MIB->getOperand(1)),
5639 "!memprof MemInfoBlock second operand should be an MDString", MIB);
5640
5641 // Any remaining should be MDNode that are pairs of integers
5642 for (unsigned I = 2; I < MIB->getNumOperands(); ++I) {
5643 auto *OpNode = dyn_cast<MDNode>(Val: MIB->getOperand(I));
5644 Check(OpNode, "Not all !memprof MemInfoBlock operands 2 to N are MDNode",
5645 MIB);
5646 Check(OpNode->getNumOperands() == 2,
5647 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with 2 "
5648 "operands",
5649 MIB);
5650 // Check that all of Op's operands are ConstantInt.
5651 Check(llvm::all_of(OpNode->operands(),
5652 [](const MDOperand &Op) {
5653 return mdconst::hasa<ConstantInt>(Op);
5654 }),
5655 "Not all !memprof MemInfoBlock operands 2 to N are MDNode with "
5656 "ConstantInt operands",
5657 MIB);
5658 }
5659 }
5660}
5661
5662void Verifier::visitCallsiteMetadata(Instruction &I, MDNode *MD) {
5663 Check(isa<CallBase>(I), "!callsite metadata should only exist on calls", &I);
5664 // Verify the partial callstack annotated from memprof profiles. This callsite
5665 // is a part of a profiled allocation callstack.
5666 visitCallStackMetadata(MD);
5667}
5668
5669void Verifier::visitCalleeTypeMetadata(Instruction &I, MDNode *MD) {
5670 Check(isa<CallBase>(I), "!callee_type metadata should only exist on calls",
5671 &I);
5672 for (Metadata *Op : MD->operands()) {
5673 Check(isa<MDNode>(Op),
5674 "The callee_type metadata must be a list of callgraph metadata nodes",
5675 Op);
5676 auto *CallgraphMD = cast<MDNode>(Val: Op);
5677 Check(CallgraphMD->getNumOperands() == 1,
5678 "Well-formed callgraph metadata must contain exactly one "
5679 "operand",
5680 Op);
5681 Check(isa<MDString>(CallgraphMD->getOperand(0)),
5682 "The operand of callgraph metadata for functions must be an MDString",
5683 Op);
5684 }
5685}
5686
5687void Verifier::visitAnnotationMetadata(MDNode *Annotation) {
5688 Check(isa<MDTuple>(Annotation), "annotation must be a tuple");
5689 Check(Annotation->getNumOperands() >= 1,
5690 "annotation must have at least one operand");
5691 for (const MDOperand &Op : Annotation->operands()) {
5692 bool TupleOfStrings =
5693 isa<MDTuple>(Val: Op.get()) &&
5694 all_of(Range: cast<MDTuple>(Val: Op)->operands(), P: [](auto &Annotation) {
5695 return isa<MDString>(Annotation.get());
5696 });
5697 Check(isa<MDString>(Op.get()) || TupleOfStrings,
5698 "operands must be a string or a tuple of strings");
5699 }
5700}
5701
5702void Verifier::visitAliasScopeMetadata(const MDNode *MD) {
5703 unsigned NumOps = MD->getNumOperands();
5704 Check(NumOps >= 2 && NumOps <= 3, "scope must have two or three operands",
5705 MD);
5706 Check(MD->getOperand(0).get() == MD || isa<MDString>(MD->getOperand(0)),
5707 "first scope operand must be self-referential or string", MD);
5708 if (NumOps == 3)
5709 Check(isa<MDString>(MD->getOperand(2)),
5710 "third scope operand must be string (if used)", MD);
5711
5712 auto *Domain = dyn_cast<MDNode>(Val: MD->getOperand(I: 1));
5713 Check(Domain != nullptr, "second scope operand must be MDNode", MD);
5714
5715 unsigned NumDomainOps = Domain->getNumOperands();
5716 Check(NumDomainOps >= 1 && NumDomainOps <= 2,
5717 "domain must have one or two operands", Domain);
5718 Check(Domain->getOperand(0).get() == Domain ||
5719 isa<MDString>(Domain->getOperand(0)),
5720 "first domain operand must be self-referential or string", Domain);
5721 if (NumDomainOps == 2)
5722 Check(isa<MDString>(Domain->getOperand(1)),
5723 "second domain operand must be string (if used)", Domain);
5724}
5725
5726void Verifier::visitAliasScopeListMetadata(const MDNode *MD) {
5727 for (const MDOperand &Op : MD->operands()) {
5728 const auto *OpMD = dyn_cast<MDNode>(Val: Op);
5729 Check(OpMD != nullptr, "scope list must consist of MDNodes", MD);
5730 visitAliasScopeMetadata(MD: OpMD);
5731 }
5732}
5733
5734void Verifier::visitAccessGroupMetadata(const MDNode *MD) {
5735 auto IsValidAccessScope = [](const MDNode *MD) {
5736 return MD->getNumOperands() == 0 && MD->isDistinct();
5737 };
5738
5739 // An empty node is an access scope, and it must be 'distinct'. It is never a
5740 // list, because an empty list is not allowed: it would look the same as an
5741 // access scope.
5742 if (MD->getNumOperands() == 0) {
5743 Check(MD->isDistinct(), "Access scope must be 'distinct'", MD);
5744 return;
5745 }
5746
5747 // A non-empty node is a list of access scopes.
5748 for (const MDOperand &Op : MD->operands()) {
5749 const auto *OpMD = dyn_cast<MDNode>(Val: Op);
5750 Check(OpMD != nullptr, "Access scope list must consist of MDNodes", MD);
5751 Check(IsValidAccessScope(OpMD),
5752 "Access scope list contains invalid access scope", MD);
5753 }
5754}
5755
5756void Verifier::visitCapturesMetadata(Instruction &I, const MDNode *Captures) {
5757 static const char *ValidArgs[] = {"address_is_null", "address",
5758 "read_provenance", "provenance"};
5759
5760 auto *SI = dyn_cast<StoreInst>(Val: &I);
5761 Check(SI, "!captures metadata can only be applied to store instructions", &I);
5762 Check(SI->getValueOperand()->getType()->isPointerTy(),
5763 "!captures metadata can only be applied to store with value operand of "
5764 "pointer type",
5765 &I);
5766 Check(Captures->getNumOperands() != 0, "!captures metadata cannot be empty",
5767 &I);
5768
5769 for (Metadata *Op : Captures->operands()) {
5770 auto *Str = dyn_cast<MDString>(Val: Op);
5771 Check(Str, "!captures metadata must be a list of strings", &I);
5772 Check(is_contained(ValidArgs, Str->getString()),
5773 "invalid entry in !captures metadata", &I, Str);
5774 }
5775}
5776
5777void Verifier::visitAllocTokenMetadata(Instruction &I, MDNode *MD) {
5778 Check(isa<CallBase>(I), "!alloc_token should only exist on calls", &I);
5779 Check(MD->getNumOperands() == 2, "!alloc_token must have 2 operands", MD);
5780 Check(isa<MDString>(MD->getOperand(0)), "expected string", MD);
5781 Check(mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(1)),
5782 "expected integer constant", MD);
5783}
5784
5785void Verifier::visitInlineHistoryMetadata(Instruction &I, MDNode *MD) {
5786 Check(isa<CallBase>(I), "!inline_history should only exist on calls", &I);
5787 for (Metadata *Op : MD->operands()) {
5788 // Can be null when a function is erased.
5789 if (!Op)
5790 continue;
5791 Check(isa<ValueAsMetadata>(Op) &&
5792 isa<Function>(cast<ValueAsMetadata>(Op)
5793 ->getValue()
5794 ->stripPointerCastsAndAliases()),
5795 "!inline_history operands must be functions or null", MD);
5796 }
5797}
5798
5799void Verifier::visitMemCacheHintMetadata(Instruction &I, MDNode *MD) {
5800 Check(I.mayReadOrWriteMemory(),
5801 "!mem.cache_hint is only valid on memory operations", &I);
5802
5803 Check(MD->getNumOperands() % 2 == 0,
5804 "!mem.cache_hint must have even number of operands "
5805 "(operand_no, hint_node pairs)",
5806 MD);
5807
5808 const auto *CB = dyn_cast<CallBase>(Val: &I);
5809 if (CB)
5810 Check(CB->getIntrinsicID() != Intrinsic::not_intrinsic,
5811 "!mem.cache_hint is not supported on non-intrinsic calls", &I);
5812
5813 unsigned NumOperands = CB ? CB->arg_size() : I.getNumOperands();
5814
5815 SmallDenseSet<unsigned, 4> SeenOperandNos;
5816 std::optional<uint64_t> LastOperandNo;
5817
5818 // Top-level metadata alternates: i32 operand_no, MDNode hint_node.
5819 for (unsigned J = 0; J + 1 < MD->getNumOperands(); J += 2) {
5820 auto *OpNoCI = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: J));
5821 Check(OpNoCI,
5822 "!mem.cache_hint must alternate between i32 operand numbers and "
5823 "metadata hint nodes",
5824 MD);
5825
5826 Check(OpNoCI->getValue().isNonNegative(),
5827 "!mem.cache_hint operand number must be non-negative", MD);
5828
5829 uint64_t OperandNo = OpNoCI->getZExtValue();
5830 Check(OperandNo < NumOperands,
5831 "!mem.cache_hint operand number is out of range", &I);
5832
5833 Value *Operand =
5834 CB ? CB->getArgOperand(i: OperandNo) : I.getOperand(i: OperandNo);
5835 Check(Operand->getType()->isPtrOrPtrVectorTy(),
5836 "!mem.cache_hint operand number must refer to a pointer operand", &I);
5837
5838 bool Inserted = SeenOperandNos.insert(V: OperandNo).second;
5839 Check(Inserted, "!mem.cache_hint contains duplicate operand number", MD);
5840
5841 Check(!Inserted || !LastOperandNo || OperandNo > *LastOperandNo,
5842 "!mem.cache_hint operand numbers must be in increasing order", MD);
5843 LastOperandNo = OperandNo;
5844
5845 const auto *Node = dyn_cast<MDNode>(Val: MD->getOperand(I: J + 1));
5846 Check(Node,
5847 "!mem.cache_hint must alternate between i32 operand numbers and "
5848 "metadata hint nodes",
5849 MD);
5850
5851 Check(Node->getNumOperands() % 2 == 0,
5852 "!mem.cache_hint hint node must have even number of operands "
5853 "(key-value pairs)",
5854 Node);
5855
5856 StringSet<> SeenKeys;
5857 for (unsigned K = 0; K + 1 < Node->getNumOperands(); K += 2) {
5858 const auto *Key = dyn_cast<MDString>(Val: Node->getOperand(I: K));
5859 Check(Key, "!mem.cache_hint key must be a string", Node);
5860
5861 StringRef KeyStr = Key->getString();
5862 Check(SeenKeys.insert(KeyStr).second,
5863 "!mem.cache_hint hint node contains duplicate key", Node);
5864
5865 const Metadata *Value = Node->getOperand(I: K + 1).get();
5866 Check(isa_and_nonnull<MDString>(Value) ||
5867 mdconst::dyn_extract<ConstantInt>(Value),
5868 "!mem.cache_hint value must be a string or integer", Node);
5869 }
5870 }
5871}
5872
5873/// verifyInstruction - Verify that an instruction is well formed.
5874///
5875void Verifier::visitInstruction(Instruction &I) {
5876 BasicBlock *BB = I.getParent();
5877 Check(BB, "Instruction not embedded in basic block!", &I);
5878
5879 if (!isa<PHINode>(Val: I)) { // Check that non-phi nodes are not self referential
5880 for (User *U : I.users()) {
5881 Check(U != (User *)&I || !DT.isReachableFromEntry(BB),
5882 "Only PHI nodes may reference their own value!", &I);
5883 }
5884 }
5885
5886 // Check that void typed values don't have names
5887 Check(!I.getType()->isVoidTy() || !I.hasName(),
5888 "Instruction has a name, but provides a void value!", &I);
5889
5890 // Check that the return value of the instruction is either void or a legal
5891 // value type.
5892 Check(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
5893 "Instruction returns a non-scalar type!", &I);
5894
5895 // Check that the instruction doesn't produce metadata. Calls are already
5896 // checked against the callee type.
5897 Check(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
5898 "Invalid use of metadata!", &I);
5899
5900 // Check that all uses of the instruction, if they are instructions
5901 // themselves, actually have parent basic blocks. If the use is not an
5902 // instruction, it is an error!
5903 for (Use &U : I.uses()) {
5904 if (auto *Used = dyn_cast<Instruction>(Val: U.getUser()))
5905 Check(Used->getParent() != nullptr,
5906 "Instruction referencing"
5907 " instruction not embedded in a basic block!",
5908 &I, Used);
5909 else {
5910 CheckFailed(Message: "Use of instruction is not an instruction!", V1: U);
5911 return;
5912 }
5913 }
5914
5915 // Get a pointer to the call base of the instruction if it is some form of
5916 // call.
5917 const auto *CBI = dyn_cast<CallBase>(Val: &I);
5918
5919 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
5920 Check(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
5921
5922 // Check to make sure that only first-class-values are operands to
5923 // instructions.
5924 if (!I.getOperand(i)->getType()->isFirstClassType()) {
5925 Check(false, "Instruction operands must be first-class values!", &I);
5926 }
5927
5928 if (auto *F = dyn_cast<Function>(Val: I.getOperand(i))) {
5929 // This code checks whether the function is used as the operand of a
5930 // clang_arc_attachedcall operand bundle.
5931 auto IsAttachedCallOperand = [](Function *F, const CallBase *CBI,
5932 int Idx) {
5933 return CBI && CBI->isOperandBundleOfType(
5934 ID: LLVMContext::OB_clang_arc_attachedcall, Idx);
5935 };
5936
5937 // Check to make sure that the "address of" an intrinsic function is never
5938 // taken. Ignore cases where the address of the intrinsic function is used
5939 // as the argument of operand bundle "clang.arc.attachedcall" as those
5940 // cases are handled in verifyAttachedCallBundle.
5941 Check((!F->isIntrinsic() ||
5942 (CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i)) ||
5943 IsAttachedCallOperand(F, CBI, i)),
5944 "Cannot take the address of an intrinsic!", &I);
5945 Check(!F->isIntrinsic() || isa<CallInst>(I) || isa<CallBrInst>(I) ||
5946 F->getIntrinsicID() == Intrinsic::donothing ||
5947 F->getIntrinsicID() == Intrinsic::seh_try_begin ||
5948 F->getIntrinsicID() == Intrinsic::seh_try_end ||
5949 F->getIntrinsicID() == Intrinsic::seh_scope_begin ||
5950 F->getIntrinsicID() == Intrinsic::seh_scope_end ||
5951 F->getIntrinsicID() == Intrinsic::coro_resume ||
5952 F->getIntrinsicID() == Intrinsic::coro_destroy ||
5953 F->getIntrinsicID() == Intrinsic::coro_await_suspend_void ||
5954 F->getIntrinsicID() == Intrinsic::coro_await_suspend_bool ||
5955 F->getIntrinsicID() == Intrinsic::coro_await_suspend_handle ||
5956 F->getIntrinsicID() ==
5957 Intrinsic::experimental_patchpoint_void ||
5958 F->getIntrinsicID() == Intrinsic::experimental_patchpoint ||
5959 F->getIntrinsicID() == Intrinsic::fake_use ||
5960 F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint ||
5961 F->getIntrinsicID() == Intrinsic::wasm_throw ||
5962 F->getIntrinsicID() == Intrinsic::wasm_rethrow ||
5963 IsAttachedCallOperand(F, CBI, i),
5964 "Cannot invoke an intrinsic other than donothing, patchpoint, "
5965 "statepoint, coro_resume, coro_destroy, clang.arc.attachedcall or "
5966 "wasm.(re)throw",
5967 &I);
5968 Check(F->getParent() == &M, "Referencing function in another module!", &I,
5969 &M, F, F->getParent());
5970 } else if (auto *OpBB = dyn_cast<BasicBlock>(Val: I.getOperand(i))) {
5971 Check(OpBB->getParent() == BB->getParent(),
5972 "Referring to a basic block in another function!", &I);
5973 } else if (auto *OpArg = dyn_cast<Argument>(Val: I.getOperand(i))) {
5974 Check(OpArg->getParent() == BB->getParent(),
5975 "Referring to an argument in another function!", &I);
5976 } else if (auto *GV = dyn_cast<GlobalValue>(Val: I.getOperand(i))) {
5977 Check(GV->getParent() == &M, "Referencing global in another module!", &I,
5978 &M, GV, GV->getParent());
5979 } else if (auto *OpInst = dyn_cast<Instruction>(Val: I.getOperand(i))) {
5980 Check(OpInst->getFunction() == BB->getParent(),
5981 "Referring to an instruction in another function!", &I);
5982 verifyDominatesUse(I, i);
5983 } else if (isa<InlineAsm>(Val: I.getOperand(i))) {
5984 Check(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
5985 "Cannot take the address of an inline asm!", &I);
5986 } else if (auto *C = dyn_cast<Constant>(Val: I.getOperand(i))) {
5987 visitConstantExprsRecursively(EntryC: C);
5988 }
5989 }
5990
5991 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_fpmath)) {
5992 Check(FPMathOperator::isSupportedFloatingPointType(I.getType()),
5993 "fpmath requires a floating point result!", &I);
5994 Check(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
5995 if (ConstantFP *CFP0 =
5996 mdconst::dyn_extract_or_null<ConstantFP>(MD: MD->getOperand(I: 0))) {
5997 const APFloat &Accuracy = CFP0->getValueAPF();
5998 Check(&Accuracy.getSemantics() == &APFloat::IEEEsingle(),
5999 "fpmath accuracy must have float type", &I);
6000 Check(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
6001 "fpmath accuracy not a positive number!", &I);
6002 } else {
6003 Check(false, "invalid fpmath accuracy!", &I);
6004 }
6005 }
6006
6007 if (MDNode *Range = I.getMetadata(KindID: LLVMContext::MD_range)) {
6008 Check(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
6009 "Ranges are only for loads, calls and invokes!", &I);
6010 visitRangeMetadata(I, Range, Ty: I.getType());
6011 }
6012
6013 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_nofpclass)) {
6014 Check(isa<LoadInst>(I), "nofpclass is only for loads", &I);
6015 visitNoFPClassMetadata(I, NoFPClass: MD, Ty: I.getType());
6016 }
6017
6018 if (MDNode *Range = I.getMetadata(KindID: LLVMContext::MD_noalias_addrspace)) {
6019 Check(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<AtomicRMWInst>(I) ||
6020 isa<AtomicCmpXchgInst>(I) || isa<CallInst>(I),
6021 "noalias.addrspace are only for memory operations!", &I);
6022 visitNoaliasAddrspaceMetadata(I, Range, Ty: I.getType());
6023 }
6024
6025 if (I.hasMetadata(KindID: LLVMContext::MD_invariant_group)) {
6026 Check(isa<LoadInst>(I) || isa<StoreInst>(I),
6027 "invariant.group metadata is only for loads and stores", &I);
6028 }
6029
6030 if (I.hasMetadata(KindID: LLVMContext::MD_invariant_load)) {
6031 auto *II = dyn_cast<IntrinsicInst>(Val: &I);
6032 Check(isa<LoadInst>(I) || (II && II->onlyReadsMemory()),
6033 "invariant.load metadata is only for loads and readonly "
6034 "intrinsic calls",
6035 &I);
6036 }
6037
6038 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_nonnull)) {
6039 Check(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
6040 &I);
6041 Check(isa<LoadInst>(I),
6042 "nonnull applies only to load instructions, use attributes"
6043 " for calls or invokes",
6044 &I);
6045 Check(MD->getNumOperands() == 0, "nonnull metadata must be empty", &I);
6046 }
6047
6048 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_noundef)) {
6049 Check(isa<LoadInst>(I), "noundef applies only to load instructions", &I);
6050 Check(MD->getNumOperands() == 0, "noundef metadata must be empty", &I);
6051 }
6052
6053 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_dereferenceable))
6054 visitDereferenceableMetadata(I, MD);
6055
6056 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_dereferenceable_or_null))
6057 visitDereferenceableMetadata(I, MD);
6058
6059 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_nofreeobj))
6060 visitNoFreeObjMetadata(I, MD);
6061
6062 if (MDNode *TBAA = I.getMetadata(KindID: LLVMContext::MD_tbaa))
6063 TBAAVerifyHelper.visitTBAAMetadata(I: &I, MD: TBAA);
6064
6065 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_noalias))
6066 visitAliasScopeListMetadata(MD);
6067 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_alias_scope))
6068 visitAliasScopeListMetadata(MD);
6069
6070 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_access_group))
6071 visitAccessGroupMetadata(MD);
6072
6073 if (MDNode *AlignMD = I.getMetadata(KindID: LLVMContext::MD_align)) {
6074 Check(I.getType()->isPointerTy(), "align applies only to pointer types",
6075 &I);
6076 Check(isa<LoadInst>(I),
6077 "align applies only to load instructions, "
6078 "use attributes for calls or invokes",
6079 &I);
6080 Check(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
6081 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD: AlignMD->getOperand(I: 0));
6082 Check(CI && CI->getType()->isIntegerTy(64),
6083 "align metadata value must be an i64!", &I);
6084 uint64_t Align = CI->getZExtValue();
6085 Check(isPowerOf2_64(Align), "align metadata value must be a power of 2!",
6086 &I);
6087 Check(Align <= Value::MaximumAlignment,
6088 "alignment is larger that implementation defined limit", &I);
6089 }
6090
6091 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_prof))
6092 visitProfMetadata(I, MD);
6093
6094 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_memprof))
6095 visitMemProfMetadata(I, MD);
6096
6097 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_callsite))
6098 visitCallsiteMetadata(I, MD);
6099
6100 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_callee_type))
6101 visitCalleeTypeMetadata(I, MD);
6102
6103 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_DIAssignID))
6104 visitDIAssignIDMetadata(I, MD);
6105
6106 if (MDNode *MMRA = I.getMetadata(KindID: LLVMContext::MD_mmra))
6107 visitMMRAMetadata(I, MD: MMRA);
6108
6109 if (MDNode *Annotation = I.getMetadata(KindID: LLVMContext::MD_annotation))
6110 visitAnnotationMetadata(Annotation);
6111
6112 if (MDNode *Captures = I.getMetadata(KindID: LLVMContext::MD_captures))
6113 visitCapturesMetadata(I, Captures);
6114
6115 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_alloc_token))
6116 visitAllocTokenMetadata(I, MD);
6117
6118 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_inline_history))
6119 visitInlineHistoryMetadata(I, MD);
6120
6121 if (MDNode *MD = I.getMetadata(KindID: LLVMContext::MD_mem_cache_hint))
6122 visitMemCacheHintMetadata(I, MD);
6123
6124 if (MDNode *MD = I.getMetadata(Kind: "amdgpu.expected.active.lanes")) {
6125 Check(MD->getNumOperands() == 1,
6126 "!amdgpu.expected.active.lanes must have exactly one operand", &I,
6127 MD);
6128 ConstantInt *CI =
6129 mdconst::dyn_extract_or_null<ConstantInt>(MD: MD->getOperand(I: 0));
6130 Check(CI && CI->getType()->isIntegerTy(32),
6131 "!amdgpu.expected.active.lanes operand must be an i32 constant", &I,
6132 MD);
6133 }
6134
6135 if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
6136 CheckDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
6137 visitMDNode(BaseMD: *N, AllowLocs: AreDebugLocsAllowed::Yes);
6138
6139 if (auto *DL = dyn_cast<DILocation>(Val: N)) {
6140 if (DL->getAtomGroup()) {
6141 DISubprogram *SP = getSubprogram(LocalScope: DL->getRawScope());
6142 CheckDI(SP && SP->getKeyInstructionsEnabled(),
6143 "DbgLoc uses atomGroup but DISubprogram doesn't have Key "
6144 "Instructions enabled",
6145 DL, SP);
6146 }
6147 }
6148 }
6149
6150 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
6151 I.getAllMetadata(MDs);
6152 for (auto Attachment : MDs) {
6153 unsigned Kind = Attachment.first;
6154 auto AllowLocs =
6155 (Kind == LLVMContext::MD_dbg || Kind == LLVMContext::MD_loop)
6156 ? AreDebugLocsAllowed::Yes
6157 : AreDebugLocsAllowed::No;
6158 visitMDNode(BaseMD: *Attachment.second, AllowLocs);
6159 }
6160
6161 InstsInThisBlock.insert(Ptr: &I);
6162}
6163
6164/// Allow intrinsics to be verified in different ways.
6165void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
6166 Function *IF = Call.getCalledFunction();
6167
6168 // If the intrinsic takes MDNode arguments, verify that they are either global
6169 // or are local to *this* function.
6170 for (Value *V : Call.args()) {
6171 if (auto *MD = dyn_cast<MetadataAsValue>(Val: V))
6172 visitMetadataAsValue(MDV: *MD, F: Call.getCaller());
6173 if (auto *Const = dyn_cast<Constant>(Val: V))
6174 Check(!Const->getType()->isX86_AMXTy(),
6175 "const x86_amx is not allowed in argument!");
6176 }
6177
6178 switch (ID) {
6179 default:
6180 break;
6181 case Intrinsic::assume: {
6182 if (Call.hasOperandBundles()) {
6183 auto *Cond = dyn_cast<ConstantInt>(Val: Call.getArgOperand(i: 0));
6184 Check(Cond && Cond->isOne(),
6185 "assume with operand bundles must have i1 true condition", Call);
6186 }
6187 for (auto OBU : Call.operand_bundles()) {
6188 // Separate storage assumptions are special insofar as they're the only
6189 // operand bundles allowed on assumes that aren't parameter attributes.
6190
6191 auto GetTypeAt = [&](unsigned Index) {
6192 return OBU.Inputs[Index]->getType();
6193 };
6194
6195 switch (getBundleAttrFromOBU(OBU)) {
6196 case BundleAttr::None:
6197 CheckFailed(Message: "tags must be valid attribute names", V1: Call);
6198 break;
6199 case BundleAttr::Align:
6200 Check(OBU.Inputs.size() >= 2 && OBU.Inputs.size() <= 3,
6201 "alignment assumptions should have 2 or 3 arguments", Call);
6202 Check(GetTypeAt(0)->isPointerTy(), "first argument should be a pointer",
6203 Call);
6204 Check(GetTypeAt(1)->isIntegerTy() &&
6205 GetTypeAt(1)->getIntegerBitWidth() <= 64,
6206 "second argument should be an integer with a maximum width of 64 "
6207 "bits",
6208 Call);
6209 Check(OBU.Inputs.size() < 3 ||
6210 (GetTypeAt(2)->isIntegerTy() &&
6211 GetTypeAt(2)->getIntegerBitWidth() <= 64),
6212 "third argument should be an integer with a maximum width of 64 "
6213 "bits if present",
6214 Call);
6215 break;
6216 case BundleAttr::Cold:
6217 Check(OBU.Inputs.size() == 0,
6218 "cold assumptions should have no arguments", Call);
6219 break;
6220 case BundleAttr::Dereferenceable:
6221 case BundleAttr::DereferenceableOrNull:
6222 Check(OBU.Inputs.size() == 2,
6223 "dereferenceable assumptions should have 2 arguments", Call);
6224 Check(GetTypeAt(0)->isPointerTy(), "first argument should be a pointer",
6225 Call);
6226 Check(GetTypeAt(1)->isIntegerTy() &&
6227 GetTypeAt(1)->getIntegerBitWidth() <= 64,
6228 "second argument should be an integer with a maximum width of 64 "
6229 "bits",
6230 Call);
6231 break;
6232 case BundleAttr::Ignore:
6233 break;
6234 case BundleAttr::NonNull:
6235 Check(OBU.Inputs.size() == 1,
6236 "nonnull assumptions should have 1 argument", Call);
6237 Check(GetTypeAt(0)->isPointerTy(), "first argument should be a pointer",
6238 Call);
6239 break;
6240 case BundleAttr::NoUndef:
6241 Check(OBU.Inputs.size() == 1,
6242 "noundef assumptions should have 1 argument", Call);
6243 break;
6244 case BundleAttr::SeparateStorage:
6245 Check(OBU.Inputs.size() == 2,
6246 "separate_storage assumptions should have 2 arguments", Call);
6247 Check(GetTypeAt(0)->isPointerTy() && GetTypeAt(1)->isPointerTy(),
6248 "arguments to separate_storage assumptions should be pointers",
6249 Call);
6250 break;
6251 }
6252 }
6253 break;
6254 }
6255 case Intrinsic::ucmp:
6256 case Intrinsic::scmp: {
6257 Type *SrcTy = Call.getOperand(i_nocapture: 0)->getType();
6258 Type *DestTy = Call.getType();
6259
6260 Check(DestTy->getScalarSizeInBits() >= 2,
6261 "result type must be at least 2 bits wide", Call);
6262
6263 bool IsDestTypeVector = DestTy->isVectorTy();
6264 Check(SrcTy->isVectorTy() == IsDestTypeVector,
6265 "ucmp/scmp argument and result types must both be either vector or "
6266 "scalar types",
6267 Call);
6268 if (IsDestTypeVector) {
6269 auto SrcVecLen = cast<VectorType>(Val: SrcTy)->getElementCount();
6270 auto DestVecLen = cast<VectorType>(Val: DestTy)->getElementCount();
6271 Check(SrcVecLen == DestVecLen,
6272 "return type and arguments must have the same number of "
6273 "elements",
6274 Call);
6275 }
6276 break;
6277 }
6278 case Intrinsic::coro_begin:
6279 case Intrinsic::coro_begin_custom_abi:
6280 Check(isa<AnyCoroIdInst>(Call.getArgOperand(0)),
6281 "id argument of llvm.coro.begin must refer to coro.id");
6282 break;
6283 case Intrinsic::coro_id: {
6284 Check(isa<ConstantInt>(Call.getArgOperand(0)),
6285 "align argument only accepts constants");
6286 auto *Promise = Call.getArgOperand(i: 1);
6287 Check(isa<ConstantPointerNull>(Promise) || isa<AllocaInst>(Promise),
6288 "promise argument must refer to an alloca");
6289
6290 auto *CoroAddr = Call.getArgOperand(i: 2)->stripPointerCastsAndAliases();
6291 bool BeforeCoroEarly = isa<ConstantPointerNull>(Val: CoroAddr);
6292 Check(BeforeCoroEarly || isa<Function>(CoroAddr),
6293 "coro argument must refer to a function");
6294
6295 auto *InfoArg = Call.getArgOperand(i: 3);
6296 bool BeforeCoroSplit = isa<ConstantPointerNull>(Val: InfoArg);
6297 if (BeforeCoroSplit)
6298 break;
6299
6300 Check(!BeforeCoroEarly, "cannot run CoroSplit before CoroEarly");
6301 auto *GV = dyn_cast<GlobalVariable>(Val: InfoArg);
6302 Check(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
6303 "info argument of llvm.coro.id must refer to an initialized "
6304 "constant");
6305 Constant *Init = GV->getInitializer();
6306 Check(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
6307 "info argument of llvm.coro.id must refer to either a struct or "
6308 "an array");
6309 break;
6310 }
6311 case Intrinsic::is_fpclass: {
6312 const ConstantInt *TestMask = cast<ConstantInt>(Val: Call.getOperand(i_nocapture: 1));
6313 Check((TestMask->getZExtValue() & ~static_cast<unsigned>(fcAllFlags)) == 0,
6314 "unsupported bits for llvm.is.fpclass test mask");
6315 break;
6316 }
6317 case Intrinsic::fptrunc_round: {
6318 // Check the rounding mode
6319 Metadata *MD = nullptr;
6320 auto *MAV = dyn_cast<MetadataAsValue>(Val: Call.getOperand(i_nocapture: 1));
6321 if (MAV)
6322 MD = MAV->getMetadata();
6323
6324 Check(MD != nullptr, "missing rounding mode argument", Call);
6325
6326 Check(isa<MDString>(MD),
6327 ("invalid value for llvm.fptrunc.round metadata operand"
6328 " (the operand should be a string)"),
6329 MD);
6330
6331 std::optional<RoundingMode> RoundMode =
6332 convertStrToRoundingMode(cast<MDString>(Val: MD)->getString());
6333 Check(RoundMode && *RoundMode != RoundingMode::Dynamic,
6334 "unsupported rounding mode argument", Call);
6335 break;
6336 }
6337 case Intrinsic::convert_to_arbitrary_fp: {
6338 // Check that vector element counts are consistent.
6339 Type *ValueTy = Call.getArgOperand(i: 0)->getType();
6340 Type *IntTy = Call.getType();
6341
6342 if (auto *ValueVecTy = dyn_cast<VectorType>(Val: ValueTy)) {
6343 auto *IntVecTy = dyn_cast<VectorType>(Val: IntTy);
6344 Check(IntVecTy,
6345 "if floating-point operand is a vector, integer operand must also "
6346 "be a vector",
6347 Call);
6348 Check(ValueVecTy->getElementCount() == IntVecTy->getElementCount(),
6349 "floating-point and integer vector operands must have the same "
6350 "element count",
6351 Call);
6352 }
6353
6354 // Check interpretation metadata (argoperand 1).
6355 auto *InterpMAV = dyn_cast<MetadataAsValue>(Val: Call.getArgOperand(i: 1));
6356 Check(InterpMAV, "missing interpretation metadata operand", Call);
6357 auto *InterpStr = dyn_cast<MDString>(Val: InterpMAV->getMetadata());
6358 Check(InterpStr, "interpretation metadata operand must be a string", Call);
6359 StringRef Interp = InterpStr->getString();
6360
6361 Check(!Interp.empty(), "interpretation metadata string must not be empty",
6362 Call);
6363
6364 // Valid interpretation strings: mini-float format names.
6365 Check(APFloatBase::isValidArbitraryFPFormat(Interp),
6366 "unsupported interpretation metadata string", Call);
6367
6368 // The integer type width must equal the arbitrary FP format width.
6369 if (unsigned FormatBits =
6370 APFloatBase::getArbitraryFPFormatSizeInBits(Format: Interp))
6371 Check(IntTy->getScalarSizeInBits() == FormatBits,
6372 "integer type bit width must equal the arbitrary FP format width",
6373 Call);
6374
6375 // Check rounding mode metadata (argoperand 2).
6376 auto *RoundingMAV = dyn_cast<MetadataAsValue>(Val: Call.getArgOperand(i: 2));
6377 Check(RoundingMAV, "missing rounding mode metadata operand", Call);
6378 auto *RoundingStr = dyn_cast<MDString>(Val: RoundingMAV->getMetadata());
6379 Check(RoundingStr, "rounding mode metadata operand must be a string", Call);
6380
6381 std::optional<RoundingMode> RM =
6382 convertStrToRoundingMode(RoundingStr->getString());
6383 Check(RM && *RM != RoundingMode::Dynamic,
6384 "unsupported rounding mode argument", Call);
6385 break;
6386 }
6387 case Intrinsic::convert_from_arbitrary_fp: {
6388 // Check that vector element counts are consistent.
6389 Type *IntTy = Call.getArgOperand(i: 0)->getType();
6390 Type *ValueTy = Call.getType();
6391
6392 if (auto *ValueVecTy = dyn_cast<VectorType>(Val: ValueTy)) {
6393 auto *IntVecTy = dyn_cast<VectorType>(Val: IntTy);
6394 Check(IntVecTy,
6395 "if floating-point operand is a vector, integer operand must also "
6396 "be a vector",
6397 Call);
6398 Check(ValueVecTy->getElementCount() == IntVecTy->getElementCount(),
6399 "floating-point and integer vector operands must have the same "
6400 "element count",
6401 Call);
6402 }
6403
6404 // Check interpretation metadata (argoperand 1).
6405 auto *InterpMAV = dyn_cast<MetadataAsValue>(Val: Call.getArgOperand(i: 1));
6406 Check(InterpMAV, "missing interpretation metadata operand", Call);
6407 auto *InterpStr = dyn_cast<MDString>(Val: InterpMAV->getMetadata());
6408 Check(InterpStr, "interpretation metadata operand must be a string", Call);
6409 StringRef Interp = InterpStr->getString();
6410
6411 Check(!Interp.empty(), "interpretation metadata string must not be empty",
6412 Call);
6413
6414 // Valid interpretation strings: mini-float format names.
6415 Check(APFloatBase::isValidArbitraryFPFormat(Interp),
6416 "unsupported interpretation metadata string", Call);
6417
6418 // The integer type width must equal the arbitrary FP format width.
6419 if (unsigned FormatBits =
6420 APFloatBase::getArbitraryFPFormatSizeInBits(Format: Interp))
6421 Check(IntTy->getScalarSizeInBits() == FormatBits,
6422 "integer type bit width must equal the arbitrary FP format width",
6423 Call);
6424 break;
6425 }
6426#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
6427#include "llvm/IR/VPIntrinsics.def"
6428#undef BEGIN_REGISTER_VP_INTRINSIC
6429 visitVPIntrinsic(VPI&: cast<VPIntrinsic>(Val&: Call));
6430 break;
6431#define INSTRUCTION(NAME, NARGS, ROUND_MODE, INTRINSIC) \
6432 case Intrinsic::INTRINSIC:
6433#include "llvm/IR/ConstrainedOps.def"
6434#undef INSTRUCTION
6435 visitConstrainedFPIntrinsic(FPI&: cast<ConstrainedFPIntrinsic>(Val&: Call));
6436 break;
6437 case Intrinsic::dbg_declare: // llvm.dbg.declare
6438 case Intrinsic::dbg_value: // llvm.dbg.value
6439 case Intrinsic::dbg_assign: // llvm.dbg.assign
6440 case Intrinsic::dbg_label: // llvm.dbg.label
6441 // We no longer interpret debug intrinsics (the old variable-location
6442 // design). They're meaningless as far as LLVM is concerned we could make
6443 // it an error for them to appear, but it's possible we'll have users
6444 // converting back to intrinsics for the forseeable future (such as DXIL),
6445 // so tolerate their existance.
6446 break;
6447 case Intrinsic::memcpy:
6448 case Intrinsic::memcpy_inline:
6449 case Intrinsic::memmove:
6450 case Intrinsic::memset:
6451 case Intrinsic::memset_inline:
6452 break;
6453 case Intrinsic::experimental_memset_pattern: {
6454 const auto Memset = cast<MemSetPatternInst>(Val: &Call);
6455 Check(Memset->getValue()->getType()->isSized(),
6456 "unsized types cannot be used as memset patterns", Call);
6457 break;
6458 }
6459 case Intrinsic::memcpy_element_unordered_atomic:
6460 case Intrinsic::memmove_element_unordered_atomic:
6461 case Intrinsic::memset_element_unordered_atomic: {
6462 const auto *AMI = cast<AnyMemIntrinsic>(Val: &Call);
6463
6464 ConstantInt *ElementSizeCI =
6465 cast<ConstantInt>(Val: AMI->getRawElementSizeInBytes());
6466 const APInt &ElementSizeVal = ElementSizeCI->getValue();
6467 Check(ElementSizeVal.isPowerOf2(),
6468 "element size of the element-wise atomic memory intrinsic "
6469 "must be a power of 2",
6470 Call);
6471
6472 auto IsValidAlignment = [&](MaybeAlign Alignment) {
6473 return Alignment && ElementSizeVal.ule(RHS: Alignment->value());
6474 };
6475 Check(IsValidAlignment(AMI->getDestAlign()),
6476 "incorrect alignment of the destination argument", Call);
6477 if (const auto *AMT = dyn_cast<AnyMemTransferInst>(Val: AMI)) {
6478 Check(IsValidAlignment(AMT->getSourceAlign()),
6479 "incorrect alignment of the source argument", Call);
6480 }
6481 break;
6482 }
6483 case Intrinsic::call_preallocated_setup: {
6484 auto *NumArgs = cast<ConstantInt>(Val: Call.getArgOperand(i: 0));
6485 bool FoundCall = false;
6486 for (User *U : Call.users()) {
6487 auto *UseCall = dyn_cast<CallBase>(Val: U);
6488 Check(UseCall != nullptr,
6489 "Uses of llvm.call.preallocated.setup must be calls");
6490 Intrinsic::ID IID = UseCall->getIntrinsicID();
6491 if (IID == Intrinsic::call_preallocated_arg) {
6492 auto *AllocArgIndex = dyn_cast<ConstantInt>(Val: UseCall->getArgOperand(i: 1));
6493 Check(AllocArgIndex != nullptr,
6494 "llvm.call.preallocated.alloc arg index must be a constant");
6495 auto AllocArgIndexInt = AllocArgIndex->getValue();
6496 Check(AllocArgIndexInt.sge(0) &&
6497 AllocArgIndexInt.slt(NumArgs->getValue()),
6498 "llvm.call.preallocated.alloc arg index must be between 0 and "
6499 "corresponding "
6500 "llvm.call.preallocated.setup's argument count");
6501 } else if (IID == Intrinsic::call_preallocated_teardown) {
6502 // nothing to do
6503 } else {
6504 Check(!FoundCall, "Can have at most one call corresponding to a "
6505 "llvm.call.preallocated.setup");
6506 FoundCall = true;
6507 size_t NumPreallocatedArgs = 0;
6508 for (unsigned i = 0; i < UseCall->arg_size(); i++) {
6509 if (UseCall->paramHasAttr(ArgNo: i, Kind: Attribute::Preallocated)) {
6510 ++NumPreallocatedArgs;
6511 }
6512 }
6513 Check(NumPreallocatedArgs != 0,
6514 "cannot use preallocated intrinsics on a call without "
6515 "preallocated arguments");
6516 Check(NumArgs->equalsInt(NumPreallocatedArgs),
6517 "llvm.call.preallocated.setup arg size must be equal to number "
6518 "of preallocated arguments "
6519 "at call site",
6520 Call, *UseCall);
6521 // getOperandBundle() cannot be called if more than one of the operand
6522 // bundle exists. There is already a check elsewhere for this, so skip
6523 // here if we see more than one.
6524 if (UseCall->countOperandBundlesOfType(ID: LLVMContext::OB_preallocated) >
6525 1) {
6526 return;
6527 }
6528 auto PreallocatedBundle =
6529 UseCall->getOperandBundle(ID: LLVMContext::OB_preallocated);
6530 Check(PreallocatedBundle,
6531 "Use of llvm.call.preallocated.setup outside intrinsics "
6532 "must be in \"preallocated\" operand bundle");
6533 Check(PreallocatedBundle->Inputs.front().get() == &Call,
6534 "preallocated bundle must have token from corresponding "
6535 "llvm.call.preallocated.setup");
6536 }
6537 }
6538 break;
6539 }
6540 case Intrinsic::call_preallocated_arg: {
6541 auto *Token = dyn_cast<CallBase>(Val: Call.getArgOperand(i: 0));
6542 Check(Token &&
6543 Token->getIntrinsicID() == Intrinsic::call_preallocated_setup,
6544 "llvm.call.preallocated.arg token argument must be a "
6545 "llvm.call.preallocated.setup");
6546 Check(Call.hasFnAttr(Attribute::Preallocated),
6547 "llvm.call.preallocated.arg must be called with a \"preallocated\" "
6548 "call site attribute");
6549 break;
6550 }
6551 case Intrinsic::call_preallocated_teardown: {
6552 auto *Token = dyn_cast<CallBase>(Val: Call.getArgOperand(i: 0));
6553 Check(Token &&
6554 Token->getIntrinsicID() == Intrinsic::call_preallocated_setup,
6555 "llvm.call.preallocated.teardown token argument must be a "
6556 "llvm.call.preallocated.setup");
6557 break;
6558 }
6559 case Intrinsic::gcroot:
6560 case Intrinsic::gcwrite:
6561 case Intrinsic::gcread:
6562 if (ID == Intrinsic::gcroot) {
6563 auto *AI =
6564 dyn_cast<AllocaInst>(Val: Call.getArgOperand(i: 0)->stripPointerCasts());
6565 Check(AI, "llvm.gcroot parameter #1 must be an alloca.", Call);
6566 Check(isa<Constant>(Call.getArgOperand(1)),
6567 "llvm.gcroot parameter #2 must be a constant.", Call);
6568 if (!AI->getAllocatedType()->isPointerTy()) {
6569 Check(!isa<ConstantPointerNull>(Call.getArgOperand(1)),
6570 "llvm.gcroot parameter #1 must either be a pointer alloca, "
6571 "or argument #2 must be a non-null constant.",
6572 Call);
6573 }
6574 }
6575
6576 Check(Call.getParent()->getParent()->hasGC(),
6577 "Enclosing function does not use GC.", Call);
6578 break;
6579 case Intrinsic::init_trampoline:
6580 Check(isa<Function>(Call.getArgOperand(1)->stripPointerCasts()),
6581 "llvm.init_trampoline parameter #2 must resolve to a function.",
6582 Call);
6583 break;
6584 case Intrinsic::reloc_none: {
6585 Check(isa<MDString>(
6586 cast<MetadataAsValue>(Call.getArgOperand(0))->getMetadata()),
6587 "llvm.reloc.none argument must be a metadata string", &Call);
6588 break;
6589 }
6590 case Intrinsic::stackprotector:
6591 Check(isa<AllocaInst>(Call.getArgOperand(1)->stripPointerCasts()),
6592 "llvm.stackprotector parameter #2 must resolve to an alloca.", Call);
6593 break;
6594 case Intrinsic::localescape: {
6595 BasicBlock *BB = Call.getParent();
6596 Check(BB->isEntryBlock(), "llvm.localescape used outside of entry block",
6597 Call);
6598 Check(!SawFrameEscape, "multiple calls to llvm.localescape in one function",
6599 Call);
6600 for (Value *Arg : Call.args()) {
6601 if (isa<ConstantPointerNull>(Val: Arg))
6602 continue; // Null values are allowed as placeholders.
6603 auto *AI = dyn_cast<AllocaInst>(Val: Arg->stripPointerCasts());
6604 Check(AI && AI->isStaticAlloca(),
6605 "llvm.localescape only accepts static allocas", Call);
6606 }
6607 FrameEscapeInfo[BB->getParent()].first = Call.arg_size();
6608 SawFrameEscape = true;
6609 break;
6610 }
6611 case Intrinsic::localrecover: {
6612 Value *FnArg = Call.getArgOperand(i: 0)->stripPointerCasts();
6613 auto *Fn = dyn_cast<Function>(Val: FnArg);
6614 Check(Fn && !Fn->isDeclaration(),
6615 "llvm.localrecover first "
6616 "argument must be function defined in this module",
6617 Call);
6618 auto *IdxArg = cast<ConstantInt>(Val: Call.getArgOperand(i: 2));
6619 auto &Entry = FrameEscapeInfo[Fn];
6620 Entry.second = unsigned(
6621 std::max(a: uint64_t(Entry.second), b: IdxArg->getLimitedValue(Limit: ~0U) + 1));
6622 break;
6623 }
6624
6625 case Intrinsic::experimental_gc_statepoint:
6626 if (auto *CI = dyn_cast<CallInst>(Val: &Call))
6627 Check(!CI->isInlineAsm(),
6628 "gc.statepoint support for inline assembly unimplemented", CI);
6629 Check(Call.getParent()->getParent()->hasGC(),
6630 "Enclosing function does not use GC.", Call);
6631
6632 verifyStatepoint(Call);
6633 break;
6634 case Intrinsic::experimental_gc_result: {
6635 Check(Call.getParent()->getParent()->hasGC(),
6636 "Enclosing function does not use GC.", Call);
6637
6638 auto *Statepoint = Call.getArgOperand(i: 0);
6639 if (isa<UndefValue>(Val: Statepoint))
6640 break;
6641
6642 // Are we tied to a statepoint properly?
6643 const auto *StatepointCall = dyn_cast<CallBase>(Val: Statepoint);
6644 Check(StatepointCall && StatepointCall->getIntrinsicID() ==
6645 Intrinsic::experimental_gc_statepoint,
6646 "gc.result operand #1 must be from a statepoint", Call,
6647 Call.getArgOperand(0));
6648
6649 // Check that result type matches wrapped callee.
6650 auto *TargetFuncType =
6651 cast<FunctionType>(Val: StatepointCall->getParamElementType(ArgNo: 2));
6652 Check(Call.getType() == TargetFuncType->getReturnType(),
6653 "gc.result result type does not match wrapped callee", Call);
6654 break;
6655 }
6656 case Intrinsic::experimental_gc_relocate: {
6657 Check(Call.arg_size() == 3, "wrong number of arguments", Call);
6658
6659 Check(isa<PointerType>(Call.getType()->getScalarType()),
6660 "gc.relocate must return a pointer or a vector of pointers", Call);
6661
6662 // Check that this relocate is correctly tied to the statepoint
6663
6664 // This is case for relocate on the unwinding path of an invoke statepoint
6665 if (auto *LandingPad = dyn_cast<LandingPadInst>(Val: Call.getArgOperand(i: 0))) {
6666
6667 const BasicBlock *InvokeBB =
6668 LandingPad->getParent()->getUniquePredecessor();
6669
6670 // Landingpad relocates should have only one predecessor with invoke
6671 // statepoint terminator
6672 Check(InvokeBB, "safepoints should have unique landingpads",
6673 LandingPad->getParent());
6674 Check(InvokeBB->getTerminator(), "safepoint block should be well formed",
6675 InvokeBB);
6676 Check(isa<GCStatepointInst>(InvokeBB->getTerminator()),
6677 "gc relocate should be linked to a statepoint", InvokeBB);
6678 } else {
6679 // In all other cases relocate should be tied to the statepoint directly.
6680 // This covers relocates on a normal return path of invoke statepoint and
6681 // relocates of a call statepoint.
6682 auto *Token = Call.getArgOperand(i: 0);
6683 Check(isa<GCStatepointInst>(Token) || isa<UndefValue>(Token),
6684 "gc relocate is incorrectly tied to the statepoint", Call, Token);
6685 }
6686
6687 // Verify rest of the relocate arguments.
6688 const Value &StatepointCall = *cast<GCRelocateInst>(Val&: Call).getStatepoint();
6689
6690 // Both the base and derived must be piped through the safepoint.
6691 Value *Base = Call.getArgOperand(i: 1);
6692 Check(isa<ConstantInt>(Base),
6693 "gc.relocate operand #2 must be integer offset", Call);
6694
6695 Value *Derived = Call.getArgOperand(i: 2);
6696 Check(isa<ConstantInt>(Derived),
6697 "gc.relocate operand #3 must be integer offset", Call);
6698
6699 const uint64_t BaseIndex = cast<ConstantInt>(Val: Base)->getZExtValue();
6700 const uint64_t DerivedIndex = cast<ConstantInt>(Val: Derived)->getZExtValue();
6701
6702 // Check the bounds
6703 if (isa<UndefValue>(Val: StatepointCall))
6704 break;
6705 if (auto Opt = cast<GCStatepointInst>(Val: StatepointCall)
6706 .getOperandBundle(ID: LLVMContext::OB_gc_live)) {
6707 Check(BaseIndex < Opt->Inputs.size(),
6708 "gc.relocate: statepoint base index out of bounds", Call);
6709 Check(DerivedIndex < Opt->Inputs.size(),
6710 "gc.relocate: statepoint derived index out of bounds", Call);
6711 }
6712
6713 // Relocated value must be either a pointer type or vector-of-pointer type,
6714 // but gc_relocate does not need to return the same pointer type as the
6715 // relocated pointer. It can be casted to the correct type later if it's
6716 // desired. However, they must have the same address space and 'vectorness'
6717 GCRelocateInst &Relocate = cast<GCRelocateInst>(Val&: Call);
6718 auto *ResultType = Call.getType();
6719 auto *DerivedType = Relocate.getDerivedPtr()->getType();
6720 auto *BaseType = Relocate.getBasePtr()->getType();
6721
6722 Check(BaseType->isPtrOrPtrVectorTy(),
6723 "gc.relocate: relocated value must be a pointer", Call);
6724 Check(DerivedType->isPtrOrPtrVectorTy(),
6725 "gc.relocate: relocated value must be a pointer", Call);
6726
6727 Check(ResultType->isVectorTy() == DerivedType->isVectorTy(),
6728 "gc.relocate: vector relocates to vector and pointer to pointer",
6729 Call);
6730 Check(
6731 ResultType->getPointerAddressSpace() ==
6732 DerivedType->getPointerAddressSpace(),
6733 "gc.relocate: relocating a pointer shouldn't change its address space",
6734 Call);
6735
6736 auto GC = llvm::getGCStrategy(Name: Relocate.getFunction()->getGC());
6737 Check(GC, "gc.relocate: calling function must have GCStrategy",
6738 Call.getFunction());
6739 if (GC) {
6740 auto isGCPtr = [&GC](Type *PTy) {
6741 return GC->isGCManagedPointer(Ty: PTy->getScalarType()).value_or(u: true);
6742 };
6743 Check(isGCPtr(ResultType), "gc.relocate: must return gc pointer", Call);
6744 Check(isGCPtr(BaseType),
6745 "gc.relocate: relocated value must be a gc pointer", Call);
6746 Check(isGCPtr(DerivedType),
6747 "gc.relocate: relocated value must be a gc pointer", Call);
6748 }
6749 break;
6750 }
6751 case Intrinsic::experimental_patchpoint: {
6752 if (Call.getCallingConv() == CallingConv::AnyReg) {
6753 Check(Call.getType()->isSingleValueType(),
6754 "patchpoint: invalid return type used with anyregcc", Call);
6755 }
6756 break;
6757 }
6758 case Intrinsic::eh_exceptioncode:
6759 case Intrinsic::eh_exceptionpointer: {
6760 Check(isa<CatchPadInst>(Call.getArgOperand(0)),
6761 "eh.exceptionpointer argument must be a catchpad", Call);
6762 break;
6763 }
6764 case Intrinsic::get_active_lane_mask: {
6765 Type *ElemTy = Call.getType()->getScalarType();
6766 Check(ElemTy->isIntegerTy(1),
6767 "get_active_lane_mask: element type is not i1", Call);
6768 break;
6769 }
6770 case Intrinsic::experimental_get_vector_length: {
6771 auto *VF = cast<ConstantInt>(Val: Call.getArgOperand(i: 1));
6772 Check(!VF->isNegative() && !VF->isZero(),
6773 "get_vector_length: VF must be positive", Call);
6774 break;
6775 }
6776 case Intrinsic::experimental_guard: {
6777 Check(isa<CallInst>(Call), "experimental_guard cannot be invoked", Call);
6778 Check(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
6779 "experimental_guard must have exactly one "
6780 "\"deopt\" operand bundle");
6781 break;
6782 }
6783
6784 case Intrinsic::experimental_deoptimize: {
6785 Check(isa<CallInst>(Call), "experimental_deoptimize cannot be invoked",
6786 Call);
6787 Check(Call.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
6788 "experimental_deoptimize must have exactly one "
6789 "\"deopt\" operand bundle");
6790 Check(Call.getType() == Call.getFunction()->getReturnType(),
6791 "experimental_deoptimize return type must match caller return type");
6792
6793 if (isa<CallInst>(Val: Call)) {
6794 auto *RI = dyn_cast<ReturnInst>(Val: Call.getNextNode());
6795 Check(RI,
6796 "calls to experimental_deoptimize must be followed by a return");
6797
6798 if (!Call.getType()->isVoidTy() && RI)
6799 Check(RI->getReturnValue() == &Call,
6800 "calls to experimental_deoptimize must be followed by a return "
6801 "of the value computed by experimental_deoptimize");
6802 }
6803
6804 break;
6805 }
6806 case Intrinsic::vastart: {
6807 Check(Call.getFunction()->isVarArg(),
6808 "va_start called in a non-varargs function");
6809 break;
6810 }
6811 case Intrinsic::get_dynamic_area_offset: {
6812 auto *IntTy = dyn_cast<IntegerType>(Val: Call.getType());
6813 Check(IntTy && DL.getPointerSizeInBits(DL.getAllocaAddrSpace()) ==
6814 IntTy->getBitWidth(),
6815 "get_dynamic_area_offset result type must be scalar integer matching "
6816 "alloca address space width",
6817 Call);
6818 break;
6819 }
6820 case Intrinsic::smul_fix:
6821 case Intrinsic::smul_fix_sat:
6822 case Intrinsic::umul_fix:
6823 case Intrinsic::umul_fix_sat:
6824 case Intrinsic::sdiv_fix:
6825 case Intrinsic::sdiv_fix_sat:
6826 case Intrinsic::udiv_fix:
6827 case Intrinsic::udiv_fix_sat: {
6828 Value *Op1 = Call.getArgOperand(i: 0);
6829 auto *Op3 = cast<ConstantInt>(Val: Call.getArgOperand(i: 2));
6830
6831 if (ID == Intrinsic::smul_fix || ID == Intrinsic::smul_fix_sat ||
6832 ID == Intrinsic::sdiv_fix || ID == Intrinsic::sdiv_fix_sat) {
6833 Check(Op3->getZExtValue() < Op1->getType()->getScalarSizeInBits(),
6834 "the scale of s[mul|div]_fix[_sat] must be less than the width of "
6835 "the operands");
6836 } else {
6837 Check(Op3->getZExtValue() <= Op1->getType()->getScalarSizeInBits(),
6838 "the scale of u[mul|div]_fix[_sat] must be less than or equal "
6839 "to the width of the operands");
6840 }
6841 break;
6842 }
6843 case Intrinsic::lrint:
6844 case Intrinsic::llrint:
6845 case Intrinsic::lround:
6846 case Intrinsic::llround: {
6847 Type *ValTy = Call.getArgOperand(i: 0)->getType();
6848 Type *ResultTy = Call.getType();
6849 Check(ValTy->isVectorTy() == ResultTy->isVectorTy(),
6850 IF->getName() + ": argument and result disagree on vector use",
6851 &Call);
6852 if (auto *VTy = dyn_cast<VectorType>(Val: ValTy)) {
6853 auto *RTy = dyn_cast<VectorType>(Val: ResultTy);
6854 Check(VTy->getElementCount() == RTy->getElementCount(),
6855 IF->getName() + ": argument must be same length as result", &Call);
6856 }
6857 break;
6858 }
6859 case Intrinsic::bswap: {
6860 Type *Ty = Call.getType();
6861 unsigned Size = Ty->getScalarSizeInBits();
6862 Check(Size % 16 == 0, "bswap must be an even number of bytes", &Call);
6863 break;
6864 }
6865 case Intrinsic::invariant_start: {
6866 auto *InvariantSize = dyn_cast<ConstantInt>(Val: Call.getArgOperand(i: 0));
6867 Check(InvariantSize &&
6868 (!InvariantSize->isNegative() || InvariantSize->isMinusOne()),
6869 "invariant_start parameter must be -1, 0 or a positive number",
6870 &Call);
6871 break;
6872 }
6873 case Intrinsic::matrix_multiply:
6874 case Intrinsic::matrix_transpose:
6875 case Intrinsic::matrix_column_major_load:
6876 case Intrinsic::matrix_column_major_store: {
6877 Function *IF = Call.getCalledFunction();
6878 Value *Stride = nullptr;
6879 ConstantInt *NumRows;
6880 ConstantInt *NumColumns;
6881 VectorType *ResultTy;
6882 Type *Op0ElemTy = nullptr;
6883 Type *Op1ElemTy = nullptr;
6884 switch (ID) {
6885 case Intrinsic::matrix_multiply: {
6886 NumRows = cast<ConstantInt>(Val: Call.getArgOperand(i: 2));
6887 ConstantInt *N = cast<ConstantInt>(Val: Call.getArgOperand(i: 3));
6888 NumColumns = cast<ConstantInt>(Val: Call.getArgOperand(i: 4));
6889 Check(cast<FixedVectorType>(Call.getArgOperand(0)->getType())
6890 ->getNumElements() ==
6891 NumRows->getZExtValue() * N->getZExtValue(),
6892 "First argument of a matrix operation does not match specified "
6893 "shape!");
6894 Check(cast<FixedVectorType>(Call.getArgOperand(1)->getType())
6895 ->getNumElements() ==
6896 N->getZExtValue() * NumColumns->getZExtValue(),
6897 "Second argument of a matrix operation does not match specified "
6898 "shape!");
6899
6900 ResultTy = cast<VectorType>(Val: Call.getType());
6901 Op0ElemTy =
6902 cast<VectorType>(Val: Call.getArgOperand(i: 0)->getType())->getElementType();
6903 Op1ElemTy =
6904 cast<VectorType>(Val: Call.getArgOperand(i: 1)->getType())->getElementType();
6905 break;
6906 }
6907 case Intrinsic::matrix_transpose:
6908 NumRows = cast<ConstantInt>(Val: Call.getArgOperand(i: 1));
6909 NumColumns = cast<ConstantInt>(Val: Call.getArgOperand(i: 2));
6910 ResultTy = cast<VectorType>(Val: Call.getType());
6911 Op0ElemTy =
6912 cast<VectorType>(Val: Call.getArgOperand(i: 0)->getType())->getElementType();
6913 break;
6914 case Intrinsic::matrix_column_major_load: {
6915 Stride = Call.getArgOperand(i: 1);
6916 NumRows = cast<ConstantInt>(Val: Call.getArgOperand(i: 3));
6917 NumColumns = cast<ConstantInt>(Val: Call.getArgOperand(i: 4));
6918 ResultTy = cast<VectorType>(Val: Call.getType());
6919 break;
6920 }
6921 case Intrinsic::matrix_column_major_store: {
6922 Stride = Call.getArgOperand(i: 2);
6923 NumRows = cast<ConstantInt>(Val: Call.getArgOperand(i: 4));
6924 NumColumns = cast<ConstantInt>(Val: Call.getArgOperand(i: 5));
6925 ResultTy = cast<VectorType>(Val: Call.getArgOperand(i: 0)->getType());
6926 Op0ElemTy =
6927 cast<VectorType>(Val: Call.getArgOperand(i: 0)->getType())->getElementType();
6928 break;
6929 }
6930 default:
6931 llvm_unreachable("unexpected intrinsic");
6932 }
6933
6934 Check(ResultTy->getElementType()->isIntegerTy() ||
6935 ResultTy->getElementType()->isFloatingPointTy(),
6936 "Result type must be an integer or floating-point type!", IF);
6937
6938 if (Op0ElemTy)
6939 Check(ResultTy->getElementType() == Op0ElemTy,
6940 "Vector element type mismatch of the result and first operand "
6941 "vector!",
6942 IF);
6943
6944 if (Op1ElemTy)
6945 Check(ResultTy->getElementType() == Op1ElemTy,
6946 "Vector element type mismatch of the result and second operand "
6947 "vector!",
6948 IF);
6949
6950 Check(cast<FixedVectorType>(ResultTy)->getNumElements() ==
6951 NumRows->getZExtValue() * NumColumns->getZExtValue(),
6952 "Result of a matrix operation does not fit in the returned vector!");
6953
6954 if (Stride)
6955 Check(Stride->getType()->getIntegerBitWidth() <= 64,
6956 "Stride bitwidth cannot exceed 64!", IF);
6957
6958 break;
6959 }
6960 case Intrinsic::stepvector: {
6961 auto *VecTy = dyn_cast<VectorType>(Val: Call.getType());
6962 Check(VecTy && VecTy->getScalarType()->isIntegerTy() &&
6963 VecTy->getScalarSizeInBits() >= 8,
6964 "stepvector only supported for vectors of integers "
6965 "with a bitwidth of at least 8.",
6966 &Call);
6967 break;
6968 }
6969 case Intrinsic::experimental_vector_match: {
6970 Value *Op1 = Call.getArgOperand(i: 0);
6971 Value *Op2 = Call.getArgOperand(i: 1);
6972 Value *Mask = Call.getArgOperand(i: 2);
6973
6974 auto *Op1Ty = dyn_cast<VectorType>(Val: Op1->getType());
6975 auto *Op2Ty = dyn_cast<VectorType>(Val: Op2->getType());
6976 auto *MaskTy = dyn_cast<VectorType>(Val: Mask->getType());
6977
6978 Check(Op1Ty && Op2Ty && MaskTy, "Operands must be vectors.", &Call);
6979 Check(isa<FixedVectorType>(Op2Ty),
6980 "Second operand must be a fixed length vector.", &Call);
6981 Check(Op1Ty->getElementType()->isIntegerTy(),
6982 "First operand must be a vector of integers.", &Call);
6983 Check(Op1Ty->getElementType() == Op2Ty->getElementType(),
6984 "First two operands must have the same element type.", &Call);
6985 Check(Op1Ty->getElementCount() == MaskTy->getElementCount(),
6986 "First operand and mask must have the same number of elements.",
6987 &Call);
6988 Check(MaskTy->getElementType()->isIntegerTy(1),
6989 "Mask must be a vector of i1's.", &Call);
6990 Check(Call.getType() == MaskTy, "Return type must match the mask type.",
6991 &Call);
6992 break;
6993 }
6994 case Intrinsic::speculative_load: {
6995 Type *LoadTy = Call.getType();
6996 Check(LoadTy->isByteTy() || LoadTy->isVectorTy(),
6997 "llvm.speculative.load return type must be a byte type or a "
6998 "vector type",
6999 &Call);
7000 if (LoadTy->isByteOrByteVectorTy()) {
7001 unsigned BitWidth = LoadTy->getScalarType()->getByteBitWidth();
7002 Check((BitWidth % 8) == 0,
7003 "llvm.speculative.load byte type must have a bit width that is "
7004 "a multiple of 8",
7005 &Call);
7006 }
7007
7008 uint64_t MinSizeInBits = DL.getTypeSizeInBits(Ty: LoadTy).getKnownMinValue();
7009 Check((MinSizeInBits % 8) == 0 && isPowerOf2_64(MinSizeInBits / 8),
7010 "llvm.speculative.load return type size in bytes must be a "
7011 "positive power of 2",
7012 &Call);
7013
7014 constexpr unsigned NumFixedArgs = 3;
7015 unsigned NumArgs = Call.arg_size();
7016 Check(NumArgs >= NumFixedArgs,
7017 "llvm.speculative.load requires at least 3 arguments", &Call);
7018
7019 Value *PayloadArg = Call.getArgOperand(i: NumFixedArgs - 1);
7020 if (PayloadArg->getType()->isIntegerTy(BitWidth: 64)) {
7021 // Direct form: (ptr, i1 from_end, i64 num_accessible_bytes)
7022 Check(NumArgs == NumFixedArgs,
7023 "llvm.speculative.load direct form has too many arguments", &Call);
7024 } else {
7025 // Oracle form: (ptr, i1 from_end, oracle_fn_ptr, args...)
7026 auto *OracleFn = dyn_cast<Function>(Val: PayloadArg);
7027 Check(OracleFn,
7028 "llvm.speculative.load third argument must be i64 or a direct "
7029 "reference to an oracle function",
7030 &Call);
7031
7032 // Make sure the called oracle matches the attributes of the intrinsic.
7033 Check(OracleFn->onlyReadsMemory() && OracleFn->onlyAccessesArgMemory() &&
7034 OracleFn->doesNotThrow() && OracleFn->hasNoSync() &&
7035 OracleFn->willReturn(),
7036 "llvm.speculative.load oracle function must be nounwind, nosync "
7037 "and willreturn, must not have side effects and may only read "
7038 "memory through its arguments",
7039 &Call);
7040
7041 FunctionType *FTy = OracleFn->getFunctionType();
7042 Check(FTy->getReturnType()->isIntegerTy(64),
7043 "llvm.speculative.load oracle function must return i64", &Call);
7044
7045 Check(!FTy->isVarArg(),
7046 "llvm.speculative.load oracle function must have a fixed argument "
7047 "list",
7048 &Call);
7049 Check(NumArgs - NumFixedArgs == FTy->getNumParams(),
7050 "llvm.speculative.load oracle function argument count mismatch",
7051 &Call);
7052 for (auto [ParamTy, Arg] :
7053 zip_equal(t: FTy->params(), u: drop_begin(RangeOrContainer: Call.args(), N: NumFixedArgs)))
7054 Check(ParamTy == Arg->getType(),
7055 "llvm.speculative.load oracle function argument type mismatch",
7056 &Call);
7057 }
7058 break;
7059 }
7060 case Intrinsic::vector_insert: {
7061 Value *Vec = Call.getArgOperand(i: 0);
7062 Value *SubVec = Call.getArgOperand(i: 1);
7063 Value *Idx = Call.getArgOperand(i: 2);
7064 unsigned IdxN = cast<ConstantInt>(Val: Idx)->getZExtValue();
7065
7066 VectorType *VecTy = cast<VectorType>(Val: Vec->getType());
7067 VectorType *SubVecTy = cast<VectorType>(Val: SubVec->getType());
7068
7069 ElementCount VecEC = VecTy->getElementCount();
7070 ElementCount SubVecEC = SubVecTy->getElementCount();
7071 Check(VecTy->getElementType() == SubVecTy->getElementType(),
7072 "vector_insert parameters must have the same element "
7073 "type.",
7074 &Call);
7075 Check(IdxN % SubVecEC.getKnownMinValue() == 0,
7076 "vector_insert index must be a constant multiple of "
7077 "the subvector's known minimum vector length.");
7078
7079 // The only allowed 'mixed' case is inserting a fixed vector into a
7080 // scalable vector.
7081 if (SubVecEC.isScalable()) {
7082 Check(VecEC.isScalable(), "cannot vector_insert a scalable vector into "
7083 "a fixed vector.");
7084 }
7085
7086 // If this insertion is not the 'mixed' case where a fixed vector is
7087 // inserted into a scalable vector, ensure that the insertion of the
7088 // subvector does not overrun the parent vector.
7089 if (VecEC.isScalable() == SubVecEC.isScalable()) {
7090 Check(IdxN < VecEC.getKnownMinValue() &&
7091 IdxN + SubVecEC.getKnownMinValue() <= VecEC.getKnownMinValue(),
7092 "subvector operand of vector_insert would overrun the "
7093 "vector being inserted into.");
7094 }
7095 break;
7096 }
7097 case Intrinsic::vector_extract: {
7098 Value *Vec = Call.getArgOperand(i: 0);
7099 Value *Idx = Call.getArgOperand(i: 1);
7100 unsigned IdxN = cast<ConstantInt>(Val: Idx)->getZExtValue();
7101
7102 VectorType *ResultTy = cast<VectorType>(Val: Call.getType());
7103 VectorType *VecTy = cast<VectorType>(Val: Vec->getType());
7104
7105 ElementCount VecEC = VecTy->getElementCount();
7106 ElementCount ResultEC = ResultTy->getElementCount();
7107
7108 Check(ResultTy->getElementType() == VecTy->getElementType(),
7109 "vector_extract result must have the same element "
7110 "type as the input vector.",
7111 &Call);
7112 Check(IdxN % ResultEC.getKnownMinValue() == 0,
7113 "vector_extract index must be a constant multiple of "
7114 "the result type's known minimum vector length.");
7115
7116 // The only allowed 'mixed' case is extracting a fixed vector from a
7117 // scalable vector.
7118 if (ResultEC.isScalable()) {
7119 Check(VecEC.isScalable(), "cannot vector_extract a scalable vector from "
7120 "a fixed vector.");
7121 }
7122
7123 // If this extraction is not the 'mixed' case where a fixed vector is
7124 // extracted from a scalable vector, ensure that the extraction does not
7125 // overrun the parent vector.
7126 if (VecEC.isScalable() == ResultEC.isScalable()) {
7127 Check(IdxN < VecEC.getKnownMinValue() &&
7128 IdxN + ResultEC.getKnownMinValue() <= VecEC.getKnownMinValue(),
7129 "vector_extract would overrun.");
7130 }
7131 break;
7132 }
7133 case Intrinsic::vector_partial_reduce_fadd:
7134 case Intrinsic::vector_partial_reduce_add: {
7135 VectorType *AccTy = cast<VectorType>(Val: Call.getArgOperand(i: 0)->getType());
7136 VectorType *VecTy = cast<VectorType>(Val: Call.getArgOperand(i: 1)->getType());
7137
7138 unsigned VecWidth = VecTy->getElementCount().getKnownMinValue();
7139 unsigned AccWidth = AccTy->getElementCount().getKnownMinValue();
7140
7141 Check((VecWidth % AccWidth) == 0,
7142 "Invalid vector widths for partial "
7143 "reduction. The width of the input vector "
7144 "must be a positive integer multiple of "
7145 "the width of the accumulator vector.");
7146 break;
7147 }
7148 case Intrinsic::experimental_noalias_scope_decl: {
7149 NoAliasScopeDecls.push_back(Elt: cast<IntrinsicInst>(Val: &Call));
7150 break;
7151 }
7152 case Intrinsic::preserve_array_access_index:
7153 case Intrinsic::preserve_struct_access_index:
7154 case Intrinsic::aarch64_ldaxr:
7155 case Intrinsic::aarch64_ldxr:
7156 case Intrinsic::arm_ldaex:
7157 case Intrinsic::arm_ldrex: {
7158 Type *ElemTy = Call.getParamElementType(ArgNo: 0);
7159 Check(ElemTy, "Intrinsic requires elementtype attribute on first argument.",
7160 &Call);
7161 break;
7162 }
7163 case Intrinsic::aarch64_stlxr:
7164 case Intrinsic::aarch64_stxr:
7165 case Intrinsic::arm_stlex:
7166 case Intrinsic::arm_strex: {
7167 Type *ElemTy = Call.getAttributes().getParamElementType(ArgNo: 1);
7168 Check(ElemTy,
7169 "Intrinsic requires elementtype attribute on second argument.",
7170 &Call);
7171 break;
7172 }
7173 case Intrinsic::aarch64_prefetch: {
7174 Check(cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue() < 2,
7175 "write argument to llvm.aarch64.prefetch must be 0 or 1", Call);
7176 Check(cast<ConstantInt>(Call.getArgOperand(2))->getZExtValue() < 4,
7177 "target argument to llvm.aarch64.prefetch must be 0-3", Call);
7178 Check(cast<ConstantInt>(Call.getArgOperand(3))->getZExtValue() < 2,
7179 "stream argument to llvm.aarch64.prefetch must be 0 or 1", Call);
7180 Check(cast<ConstantInt>(Call.getArgOperand(4))->getZExtValue() < 2,
7181 "isdata argument to llvm.aarch64.prefetch must be 0 or 1", Call);
7182 break;
7183 }
7184 case Intrinsic::aarch64_range_prefetch: {
7185 Check(cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue() < 2,
7186 "write argument to llvm.aarch64.range.prefetch must be 0 or 1", Call);
7187 Check(cast<ConstantInt>(Call.getArgOperand(2))->getZExtValue() < 2,
7188 "stream argument to llvm.aarch64.range.prefetch must be 0 or 1",
7189 Call);
7190 break;
7191 }
7192 case Intrinsic::riscv_vsetvli:
7193 case Intrinsic::riscv_vsetvlimax: {
7194 // The result models VLMAX (or a VL bounded by it) and is only defined for
7195 // XLen (i32/i64). Narrower types cannot represent the architectural VLMAX
7196 // range of [1, 65536], which value analyses rely on.
7197 Check(Call.getType()->isIntegerTy(32) || Call.getType()->isIntegerTy(64),
7198 "llvm.riscv.vsetvli/vsetvlimax result must be i32 or i64", &Call);
7199
7200 // VSEW and VLMUL select the vtype and must encode a valid SEW/LMUL pair.
7201 bool HasAVL = ID == Intrinsic::riscv_vsetvli;
7202 unsigned Offset = HasAVL ? 1 : 0;
7203 uint64_t VSEW =
7204 cast<ConstantInt>(Val: Call.getArgOperand(i: Offset))->getZExtValue();
7205 uint64_t VLMUL =
7206 cast<ConstantInt>(Val: Call.getArgOperand(i: Offset + 1))->getZExtValue();
7207 Check(VSEW <= 3, "llvm.riscv.vsetvli/vsetvlimax VSEW must be 0-3", &Call);
7208 Check(VLMUL <= 7 && VLMUL != RISCVVType::LMUL_RESERVED,
7209 "llvm.riscv.vsetvli/vsetvlimax VLMUL is reserved", &Call);
7210 break;
7211 }
7212 case Intrinsic::callbr_landingpad: {
7213 const auto *CBR = dyn_cast<CallBrInst>(Val: Call.getOperand(i_nocapture: 0));
7214 Check(CBR, "intrinstic requires callbr operand", &Call);
7215 if (!CBR)
7216 break;
7217
7218 const BasicBlock *LandingPadBB = Call.getParent();
7219 const BasicBlock *PredBB = LandingPadBB->getUniquePredecessor();
7220 if (!PredBB) {
7221 CheckFailed(Message: "Intrinsic in block must have 1 unique predecessor", V1: &Call);
7222 break;
7223 }
7224 if (!isa<CallBrInst>(Val: PredBB->getTerminator())) {
7225 CheckFailed(Message: "Intrinsic must have corresponding callbr in predecessor",
7226 V1: &Call);
7227 break;
7228 }
7229 Check(llvm::is_contained(CBR->getIndirectDests(), LandingPadBB),
7230 "Intrinsic's corresponding callbr must have intrinsic's parent basic "
7231 "block in indirect destination list",
7232 &Call);
7233 const Instruction &First = *LandingPadBB->begin();
7234 Check(&First == &Call, "No other instructions may proceed intrinsic",
7235 &Call);
7236 break;
7237 }
7238 case Intrinsic::structured_gep: {
7239 // Parser should refuse those 2 cases.
7240 assert(Call.arg_size() >= 1);
7241 assert(Call.getOperand(0)->getType()->isPointerTy());
7242
7243 Check(Call.paramHasAttr(0, Attribute::ElementType),
7244 "Intrinsic first parameter is missing an ElementType attribute",
7245 &Call);
7246
7247 Type *T = Call.getParamAttr(ArgNo: 0, Kind: Attribute::ElementType).getValueAsType();
7248 for (unsigned I = 1; I < Call.arg_size(); ++I) {
7249 Value *Index = Call.getOperand(i_nocapture: I);
7250 auto *CI = dyn_cast<ConstantInt>(Val: Index);
7251 Check(Index->getType()->isIntegerTy(),
7252 "Index operand type must be an integer", &Call);
7253
7254 if (auto *AT = dyn_cast<ArrayType>(Val: T)) {
7255 T = AT->getElementType();
7256 } else if (auto *ST = dyn_cast<StructType>(Val: T)) {
7257 Check(CI, "Indexing into a struct requires a constant int", &Call);
7258 Check(CI->getZExtValue() < ST->getNumElements(),
7259 "Indexing in a struct should be inbounds", &Call);
7260 T = ST->getElementType(N: CI->getZExtValue());
7261 } else if (auto *VT = dyn_cast<VectorType>(Val: T)) {
7262 T = VT->getElementType();
7263 } else {
7264 CheckFailed(Message: "Reached a non-composite type with more indices to process",
7265 V1: &Call);
7266 }
7267 }
7268 break;
7269 }
7270 case Intrinsic::structured_alloca:
7271 Check(Call.hasRetAttr(Attribute::ElementType),
7272 "@llvm.structured.alloca calls require elementtype attribute.",
7273 &Call);
7274 break;
7275 case Intrinsic::nvvm_setmaxnreg_inc_sync_aligned_u32:
7276 case Intrinsic::nvvm_setmaxnreg_dec_sync_aligned_u32: {
7277 Value *V = Call.getArgOperand(i: 0);
7278 unsigned RegCount = cast<ConstantInt>(Val: V)->getZExtValue();
7279 Check(RegCount % 8 == 0,
7280 "reg_count argument to nvvm.setmaxnreg must be in multiples of 8");
7281 break;
7282 }
7283 case Intrinsic::nvvm_cp_async_bulk_global_to_shared_cta:
7284 case Intrinsic::nvvm_cp_async_bulk_global_to_shared_cta_relaxed: {
7285 const unsigned ArgSize = Call.arg_size();
7286 const unsigned FlagValidPatternIndex = ArgSize - 1;
7287 const unsigned IgnoreOOBFlagIndex = 8;
7288 bool IgnoreOOB =
7289 cast<ConstantInt>(Val: Call.getArgOperand(i: IgnoreOOBFlagIndex))->isOne();
7290 const auto *FlagValidPattern =
7291 cast<ConstantInt>(Val: Call.getArgOperand(i: FlagValidPatternIndex));
7292 Check(!IgnoreOOB || FlagValidPattern->isZero(),
7293 "flag_valid_pattern must be 0 (disabled) when ignore_oob is enabled",
7294 &Call);
7295 break;
7296 }
7297 case Intrinsic::experimental_convergence_entry:
7298 case Intrinsic::experimental_convergence_anchor:
7299 break;
7300 case Intrinsic::experimental_convergence_loop:
7301 break;
7302 case Intrinsic::ptrmask: {
7303 Type *Ty0 = Call.getArgOperand(i: 0)->getType();
7304 Type *Ty1 = Call.getArgOperand(i: 1)->getType();
7305 Check(Ty0->isPtrOrPtrVectorTy(),
7306 "llvm.ptrmask intrinsic first argument must be pointer or vector "
7307 "of pointers",
7308 &Call);
7309 Check(
7310 Ty0->isVectorTy() == Ty1->isVectorTy(),
7311 "llvm.ptrmask intrinsic arguments must be both scalars or both vectors",
7312 &Call);
7313 if (Ty0->isVectorTy())
7314 Check(cast<VectorType>(Ty0)->getElementCount() ==
7315 cast<VectorType>(Ty1)->getElementCount(),
7316 "llvm.ptrmask intrinsic arguments must have the same number of "
7317 "elements",
7318 &Call);
7319 Check(DL.getIndexTypeSizeInBits(Ty0) == Ty1->getScalarSizeInBits(),
7320 "llvm.ptrmask intrinsic second argument bitwidth must match "
7321 "pointer index type size of first argument",
7322 &Call);
7323 break;
7324 }
7325 case Intrinsic::thread_pointer: {
7326 Check(Call.getType()->getPointerAddressSpace() ==
7327 DL.getDefaultGlobalsAddressSpace(),
7328 "llvm.thread.pointer intrinsic return type must be for the globals "
7329 "address space",
7330 &Call);
7331 break;
7332 }
7333 case Intrinsic::threadlocal_address: {
7334 const Value &Arg0 = *Call.getArgOperand(i: 0);
7335 Check(isa<GlobalValue>(Arg0),
7336 "llvm.threadlocal.address first argument must be a GlobalValue");
7337 Check(cast<GlobalValue>(Arg0).isThreadLocal(),
7338 "llvm.threadlocal.address operand isThreadLocal() must be true");
7339 break;
7340 }
7341 case Intrinsic::lifetime_start:
7342 case Intrinsic::lifetime_end: {
7343 Value *Ptr = Call.getArgOperand(i: 0);
7344 auto *II = dyn_cast<IntrinsicInst>(Val: Ptr);
7345 Check(isa<AllocaInst>(Ptr) || isa<PoisonValue>(Ptr) ||
7346 (II && II->getIntrinsicID() == Intrinsic::structured_alloca),
7347 "llvm.lifetime.start/end can only be used on alloca or poison",
7348 &Call);
7349 break;
7350 }
7351 case Intrinsic::sponentry: {
7352 const unsigned StackAS = DL.getAllocaAddrSpace();
7353 const Type *RetTy = Call.getFunctionType()->getReturnType();
7354 Check(RetTy->getPointerAddressSpace() == StackAS,
7355 "llvm.sponentry must return a pointer to the stack", &Call);
7356 break;
7357 }
7358 case Intrinsic::write_volatile_register: {
7359 auto *MD = cast<MDNode>(
7360 Val: cast<MetadataAsValue>(Val: Call.getArgOperand(i: 0))->getMetadata());
7361 Check(MD->getNumOperands() == 1 && isa<MDString>(MD->getOperand(0)),
7362 "llvm.write_volatile_register metadata must be a single MDString",
7363 &Call);
7364 break;
7365 }
7366 case Intrinsic::ptrauth_auth_with_pc_and_resign: {
7367 // Verify that the auth key is IA (0) or IB (1), not DA (2) or DB (3)
7368 auto *AuthKey = cast<ConstantInt>(Val: Call.getArgOperand(i: 1));
7369 uint64_t Key = AuthKey->getZExtValue();
7370 Check(Key == 0 || Key == 1,
7371 "ptrauth.auth.with.pc.and.resign key must be IA (0) or IB (1)",
7372 &Call);
7373 break;
7374 }
7375 };
7376
7377 // Verify that there aren't any unmediated control transfers between funclets.
7378 if (IntrinsicInst::mayLowerToFunctionCall(IID: ID)) {
7379 Function *F = Call.getParent()->getParent();
7380 if (F->hasPersonalityFn() &&
7381 isScopedEHPersonality(Pers: classifyEHPersonality(Pers: F->getPersonalityFn()))) {
7382 // Run EH funclet coloring on-demand and cache results for other intrinsic
7383 // calls in this function
7384 if (BlockEHFuncletColors.empty())
7385 BlockEHFuncletColors = colorEHFunclets(F&: *F);
7386
7387 // colorEHFunclets() leaves unreachable blocks colorless. Such a call
7388 // is in no funclet and WinEHPrepare will not see it, so there is
7389 // nothing to check.
7390 BasicBlock *CallBB = Call.getParent();
7391 auto ColorsIt = BlockEHFuncletColors.find(Val: CallBB);
7392 if (ColorsIt != BlockEHFuncletColors.end()) {
7393 // Check for catch-/cleanup-pad in first funclet block
7394 bool InEHFunclet = false;
7395 const ColorVector &CV = ColorsIt->second;
7396 assert(CV.size() > 0 && "Uncolored block");
7397 for (BasicBlock *ColorFirstBB : CV)
7398 if (auto It = ColorFirstBB->getFirstNonPHIIt();
7399 It != ColorFirstBB->end())
7400 if (isa_and_nonnull<FuncletPadInst>(Val: &*It))
7401 InEHFunclet = true;
7402
7403 // Check for funclet operand bundle
7404 bool HasToken = false;
7405 for (unsigned I = 0, E = Call.getNumOperandBundles(); I != E; ++I)
7406 if (Call.getOperandBundleAt(Index: I).getTagID() == LLVMContext::OB_funclet)
7407 HasToken = true;
7408
7409 // This would cause silent code truncation in WinEHPrepare
7410 if (InEHFunclet)
7411 Check(HasToken, "Missing funclet token on intrinsic call", &Call);
7412 }
7413 }
7414 }
7415
7416 // Target-specific intrinsic call checks.
7417 verifyAMDGPUIntrinsicCall(VS&: *this, ID, Call);
7418}
7419
7420/// Carefully grab the subprogram from a local scope.
7421///
7422/// This carefully grabs the subprogram from a local scope, avoiding the
7423/// built-in assertions that would typically fire.
7424DISubprogram *Verifier::getSubprogram(Metadata *LocalScope) {
7425 if (hasDIScopeCycle(S: LocalScope))
7426 return nullptr;
7427
7428 if (!LocalScope)
7429 return nullptr;
7430
7431 if (auto *SP = dyn_cast<DISubprogram>(Val: LocalScope))
7432 return SP;
7433
7434 if (auto *LB = dyn_cast<DILexicalBlockBase>(Val: LocalScope))
7435 return getSubprogram(LocalScope: LB->getRawScope());
7436
7437 // Just return null; broken scope chains are checked elsewhere.
7438 assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope");
7439 return nullptr;
7440}
7441
7442void Verifier::visit(DbgLabelRecord &DLR) {
7443 CheckDI(isa<DILabel>(DLR.getRawLabel()),
7444 "invalid #dbg_label intrinsic variable", &DLR, DLR.getRawLabel());
7445
7446 // Ignore broken !dbg attachments; they're checked elsewhere.
7447 if (MDNode *N = DLR.getDebugLoc().getAsMDNode())
7448 if (!isa<DILocation>(Val: N))
7449 return;
7450
7451 BasicBlock *BB = DLR.getParent();
7452 Function *F = BB ? BB->getParent() : nullptr;
7453
7454 // The scopes for variables and !dbg attachments must agree.
7455 DILabel *Label = DLR.getLabel();
7456 DILocation *Loc = DLR.getDebugLoc();
7457 CheckDI(Loc, "#dbg_label record requires a !dbg attachment", &DLR, BB, F);
7458
7459 DISubprogram *LabelSP = getSubprogram(LocalScope: Label->getRawScope());
7460 DISubprogram *LocSP = getSubprogram(LocalScope: Loc->getRawScope());
7461 if (!LabelSP || !LocSP)
7462 return;
7463
7464 CheckDI(LabelSP == LocSP,
7465 "mismatched subprogram between #dbg_label label and !dbg attachment",
7466 &DLR, BB, F, Label, Label->getScope()->getSubprogram(), Loc,
7467 Loc->getScope()->getSubprogram());
7468}
7469
7470void Verifier::visit(DbgVariableRecord &DVR) {
7471 BasicBlock *BB = DVR.getParent();
7472 Function *F = BB->getParent();
7473
7474 CheckDI(DVR.getType() == DbgVariableRecord::LocationType::Value ||
7475 DVR.getType() == DbgVariableRecord::LocationType::Declare ||
7476 DVR.getType() == DbgVariableRecord::LocationType::DeclareValue ||
7477 DVR.getType() == DbgVariableRecord::LocationType::Assign,
7478 "invalid #dbg record type", &DVR, DVR.getType(), BB, F);
7479
7480 // The location for a DbgVariableRecord must be either a ValueAsMetadata,
7481 // DIArgList, or an empty MDNode (which is a legacy representation for an
7482 // "undef" location).
7483 auto *MD = DVR.getRawLocation();
7484 CheckDI(MD && (isa<ValueAsMetadata>(MD) || isa<DIArgList>(MD) ||
7485 (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands())),
7486 "invalid #dbg record address/value", &DVR, MD, BB, F);
7487 CheckDI(DVR.isDbgAssign() || !isa<DIAssignID>(MD),
7488 "!DIAssignID should only be used by Assign DVRs.", MD, &DVR);
7489 if (auto *VAM = dyn_cast<ValueAsMetadata>(Val: MD)) {
7490 visitValueAsMetadata(MD: *VAM, F);
7491 if (DVR.isDbgDeclare()) {
7492 // Allow integers here to support inttoptr salvage.
7493 Type *Ty = VAM->getValue()->getType();
7494 CheckDI(Ty->isPointerTy() || Ty->isIntegerTy(),
7495 "location of #dbg_declare must be a pointer or int", &DVR, MD, BB,
7496 F);
7497 }
7498 } else if (auto *AL = dyn_cast<DIArgList>(Val: MD)) {
7499 visitDIArgList(AL: *AL, F);
7500 }
7501
7502 CheckDI(isa_and_nonnull<DILocalVariable>(DVR.getRawVariable()),
7503 "invalid #dbg record variable", &DVR, DVR.getRawVariable(), BB, F);
7504 visitMDNode(BaseMD: *DVR.getRawVariable(), AllowLocs: AreDebugLocsAllowed::No);
7505
7506 CheckDI(isa_and_nonnull<DIExpression>(DVR.getRawExpression()),
7507 "invalid #dbg record expression", &DVR, DVR.getRawExpression(), BB,
7508 F);
7509 visitMDNode(BaseMD: *DVR.getExpression(), AllowLocs: AreDebugLocsAllowed::No);
7510
7511 if (DVR.isDbgAssign()) {
7512 CheckDI(isa_and_nonnull<DIAssignID>(DVR.getRawAssignID()),
7513 "invalid #dbg_assign DIAssignID", &DVR, DVR.getRawAssignID(), BB,
7514 F);
7515 visitMDNode(BaseMD: *cast<DIAssignID>(Val: DVR.getRawAssignID()),
7516 AllowLocs: AreDebugLocsAllowed::No);
7517
7518 const auto *RawAddr = DVR.getRawAddress();
7519 // Similarly to the location above, the address for an assign
7520 // DbgVariableRecord must be a ValueAsMetadata or an empty MDNode, which
7521 // represents an undef address.
7522 CheckDI(
7523 isa<ValueAsMetadata>(RawAddr) ||
7524 (isa<MDNode>(RawAddr) && !cast<MDNode>(RawAddr)->getNumOperands()),
7525 "invalid #dbg_assign address", &DVR, DVR.getRawAddress(), BB, F);
7526 if (auto *VAM = dyn_cast<ValueAsMetadata>(Val: RawAddr))
7527 visitValueAsMetadata(MD: *VAM, F);
7528
7529 CheckDI(isa_and_nonnull<DIExpression>(DVR.getRawAddressExpression()),
7530 "invalid #dbg_assign address expression", &DVR,
7531 DVR.getRawAddressExpression(), BB, F);
7532 visitMDNode(BaseMD: *DVR.getAddressExpression(), AllowLocs: AreDebugLocsAllowed::No);
7533
7534 // All of the linked instructions should be in the same function as DVR.
7535 for (Instruction *I : at::getAssignmentInsts(DVR: &DVR))
7536 CheckDI(DVR.getFunction() == I->getFunction(),
7537 "inst not in same function as #dbg_assign", I, &DVR, BB, F);
7538 }
7539
7540 // This check is redundant with one in visitLocalVariable().
7541 DILocalVariable *Var = DVR.getVariable();
7542 CheckDI(isType(Var->getRawType()), "invalid type ref", Var, Var->getRawType(),
7543 BB, F);
7544
7545 auto *DLNode = DVR.getDebugLoc().getAsMDNode();
7546 CheckDI(isa_and_nonnull<DILocation>(DLNode), "invalid #dbg record DILocation",
7547 &DVR, DLNode, BB, F);
7548 DILocation *Loc = DVR.getDebugLoc();
7549
7550 // The scopes for variables and !dbg attachments must agree.
7551 DISubprogram *VarSP = getSubprogram(LocalScope: Var->getRawScope());
7552 DISubprogram *LocSP = getSubprogram(LocalScope: Loc->getRawScope());
7553 if (!VarSP || !LocSP)
7554 return; // Broken scope chains are checked elsewhere.
7555
7556 CheckDI(VarSP == LocSP,
7557 "mismatched subprogram between #dbg record variable and DILocation",
7558 &DVR, BB, F, Var, Var->getScope()->getSubprogram(), Loc,
7559 Loc->getScope()->getSubprogram(), BB, F);
7560
7561 verifyFnArgs(DVR);
7562}
7563
7564void Verifier::visitVPIntrinsic(VPIntrinsic &VPI) {
7565 switch (VPI.getIntrinsicID()) {
7566 case Intrinsic::experimental_vp_splice: {
7567 VectorType *VecTy = cast<VectorType>(Val: VPI.getType());
7568 int64_t Idx = cast<ConstantInt>(Val: VPI.getArgOperand(i: 2))->getSExtValue();
7569 int64_t KnownMinNumElements = VecTy->getElementCount().getKnownMinValue();
7570 if (VPI.getParent() && VPI.getParent()->getParent()) {
7571 AttributeList Attrs = VPI.getParent()->getParent()->getAttributes();
7572 if (Attrs.hasFnAttr(Kind: Attribute::VScaleRange))
7573 KnownMinNumElements *= Attrs.getFnAttrs().getVScaleRangeMin();
7574 }
7575 Check((Idx < 0 && std::abs(Idx) <= KnownMinNumElements) ||
7576 (Idx >= 0 && Idx < KnownMinNumElements),
7577 "The splice index exceeds the range [-VL, VL-1] where VL is the "
7578 "known minimum number of elements in the vector. For scalable "
7579 "vectors the minimum number of elements is determined from "
7580 "vscale_range.",
7581 &VPI);
7582 break;
7583 }
7584 }
7585}
7586
7587void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) {
7588 unsigned NumOperands = FPI.getNonMetadataArgCount();
7589 bool HasRoundingMD =
7590 Intrinsic::hasConstrainedFPRoundingModeOperand(QID: FPI.getIntrinsicID());
7591
7592 // Add the expected number of metadata operands.
7593 NumOperands += (1 + HasRoundingMD);
7594
7595 // Compare intrinsics carry an extra predicate metadata operand.
7596 if (isa<ConstrainedFPCmpIntrinsic>(Val: FPI))
7597 NumOperands += 1;
7598 Check((FPI.arg_size() == NumOperands),
7599 "invalid arguments for constrained FP intrinsic", &FPI);
7600
7601 switch (FPI.getIntrinsicID()) {
7602 case Intrinsic::experimental_constrained_fcmp:
7603 case Intrinsic::experimental_constrained_fcmps: {
7604 auto Pred = cast<ConstrainedFPCmpIntrinsic>(Val: &FPI)->getPredicate();
7605 Check(CmpInst::isFPPredicate(Pred),
7606 "invalid predicate for constrained FP comparison intrinsic", &FPI);
7607 break;
7608 }
7609
7610 case Intrinsic::experimental_constrained_fptosi:
7611 case Intrinsic::experimental_constrained_fptoui: {
7612 Value *Operand = FPI.getArgOperand(i: 0);
7613 ElementCount SrcEC;
7614 Check(Operand->getType()->isFPOrFPVectorTy(),
7615 "Intrinsic first argument must be floating point", &FPI);
7616 if (auto *OperandT = dyn_cast<VectorType>(Val: Operand->getType())) {
7617 SrcEC = cast<VectorType>(Val: OperandT)->getElementCount();
7618 }
7619
7620 Operand = &FPI;
7621 Check(SrcEC.isNonZero() == Operand->getType()->isVectorTy(),
7622 "Intrinsic first argument and result disagree on vector use", &FPI);
7623 Check(Operand->getType()->isIntOrIntVectorTy(),
7624 "Intrinsic result must be an integer", &FPI);
7625 if (auto *OperandT = dyn_cast<VectorType>(Val: Operand->getType())) {
7626 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
7627 "Intrinsic first argument and result vector lengths must be equal",
7628 &FPI);
7629 }
7630 break;
7631 }
7632
7633 case Intrinsic::experimental_constrained_sitofp:
7634 case Intrinsic::experimental_constrained_uitofp: {
7635 Value *Operand = FPI.getArgOperand(i: 0);
7636 ElementCount SrcEC;
7637 Check(Operand->getType()->isIntOrIntVectorTy(),
7638 "Intrinsic first argument must be integer", &FPI);
7639 if (auto *OperandT = dyn_cast<VectorType>(Val: Operand->getType())) {
7640 SrcEC = cast<VectorType>(Val: OperandT)->getElementCount();
7641 }
7642
7643 Operand = &FPI;
7644 Check(SrcEC.isNonZero() == Operand->getType()->isVectorTy(),
7645 "Intrinsic first argument and result disagree on vector use", &FPI);
7646 Check(Operand->getType()->isFPOrFPVectorTy(),
7647 "Intrinsic result must be a floating point", &FPI);
7648 if (auto *OperandT = dyn_cast<VectorType>(Val: Operand->getType())) {
7649 Check(SrcEC == cast<VectorType>(OperandT)->getElementCount(),
7650 "Intrinsic first argument and result vector lengths must be equal",
7651 &FPI);
7652 }
7653 break;
7654 }
7655
7656 case Intrinsic::experimental_constrained_fptrunc:
7657 case Intrinsic::experimental_constrained_fpext: {
7658 Value *Operand = FPI.getArgOperand(i: 0);
7659 Type *OperandTy = Operand->getType();
7660 Value *Result = &FPI;
7661 Type *ResultTy = Result->getType();
7662 Check(OperandTy->isFPOrFPVectorTy(),
7663 "Intrinsic first argument must be FP or FP vector", &FPI);
7664 Check(ResultTy->isFPOrFPVectorTy(),
7665 "Intrinsic result must be FP or FP vector", &FPI);
7666 Check(OperandTy->isVectorTy() == ResultTy->isVectorTy(),
7667 "Intrinsic first argument and result disagree on vector use", &FPI);
7668 if (OperandTy->isVectorTy()) {
7669 Check(cast<VectorType>(OperandTy)->getElementCount() ==
7670 cast<VectorType>(ResultTy)->getElementCount(),
7671 "Intrinsic first argument and result vector lengths must be equal",
7672 &FPI);
7673 }
7674 if (FPI.getIntrinsicID() == Intrinsic::experimental_constrained_fptrunc) {
7675 Check(OperandTy->getScalarSizeInBits() > ResultTy->getScalarSizeInBits(),
7676 "Intrinsic first argument's type must be larger than result type",
7677 &FPI);
7678 } else {
7679 Check(OperandTy->getScalarSizeInBits() < ResultTy->getScalarSizeInBits(),
7680 "Intrinsic first argument's type must be smaller than result type",
7681 &FPI);
7682 }
7683 break;
7684 }
7685
7686 default:
7687 break;
7688 }
7689
7690 // If a non-metadata argument is passed in a metadata slot then the
7691 // error will be caught earlier when the incorrect argument doesn't
7692 // match the specification in the intrinsic call table. Thus, no
7693 // argument type check is needed here.
7694
7695 Check(FPI.getExceptionBehavior().has_value(),
7696 "invalid exception behavior argument", &FPI);
7697 if (HasRoundingMD) {
7698 Check(FPI.getRoundingMode().has_value(), "invalid rounding mode argument",
7699 &FPI);
7700 }
7701}
7702
7703void Verifier::verifyFragmentExpression(const DbgVariableRecord &DVR) {
7704 DILocalVariable *V = dyn_cast_or_null<DILocalVariable>(Val: DVR.getRawVariable());
7705 DIExpression *E = dyn_cast_or_null<DIExpression>(Val: DVR.getRawExpression());
7706
7707 // We don't know whether this intrinsic verified correctly.
7708 if (!V || !E || !E->isValid())
7709 return;
7710
7711 // Nothing to do if this isn't a DW_OP_LLVM_fragment expression.
7712 auto Fragment = E->getFragmentInfo();
7713 if (!Fragment)
7714 return;
7715
7716 // The frontend helps out GDB by emitting the members of local anonymous
7717 // unions as artificial local variables with shared storage. When SROA splits
7718 // the storage for artificial local variables that are smaller than the entire
7719 // union, the overhang piece will be outside of the allotted space for the
7720 // variable and this check fails.
7721 // FIXME: Remove this check as soon as clang stops doing this; it hides bugs.
7722 if (V->isArtificial())
7723 return;
7724
7725 verifyFragmentExpression(V: *V, Fragment: *Fragment, Desc: &DVR);
7726}
7727
7728template <typename ValueOrMetadata>
7729void Verifier::verifyFragmentExpression(const DIVariable &V,
7730 DIExpression::FragmentInfo Fragment,
7731 ValueOrMetadata *Desc) {
7732 // If there's no size, the type is broken, but that should be checked
7733 // elsewhere.
7734 auto VarSize = V.getSizeInBits();
7735 if (!VarSize)
7736 return;
7737
7738 unsigned FragSize = Fragment.SizeInBits;
7739 unsigned FragOffset = Fragment.OffsetInBits;
7740 CheckDI(FragSize + FragOffset <= *VarSize,
7741 "fragment is larger than or outside of variable", Desc, &V);
7742 CheckDI(FragSize != *VarSize, "fragment covers entire variable", Desc, &V);
7743}
7744
7745void Verifier::verifyFnArgs(const DbgVariableRecord &DVR) {
7746 // This function does not take the scope of noninlined function arguments into
7747 // account. Don't run it if current function is nodebug, because it may
7748 // contain inlined debug intrinsics.
7749 if (!HasDebugInfo)
7750 return;
7751
7752 // For performance reasons only check non-inlined ones.
7753 if (DVR.getDebugLoc()->getInlinedAt())
7754 return;
7755
7756 DILocalVariable *Var = DVR.getVariable();
7757 CheckDI(Var, "#dbg record without variable");
7758
7759 unsigned ArgNo = Var->getArg();
7760 if (!ArgNo)
7761 return;
7762
7763 // Verify there are no duplicate function argument debug info entries.
7764 // These will cause hard-to-debug assertions in the DWARF backend.
7765 if (DebugFnArgs.size() < ArgNo)
7766 DebugFnArgs.resize(N: ArgNo, NV: nullptr);
7767
7768 auto *Prev = DebugFnArgs[ArgNo - 1];
7769 DebugFnArgs[ArgNo - 1] = Var;
7770 CheckDI(!Prev || (Prev == Var), "conflicting debug info for argument", &DVR,
7771 Prev, Var);
7772}
7773
7774void Verifier::verifyNotEntryValue(const DbgVariableRecord &DVR) {
7775 DIExpression *E = dyn_cast_or_null<DIExpression>(Val: DVR.getRawExpression());
7776
7777 // We don't know whether this intrinsic verified correctly.
7778 if (!E || !E->isValid())
7779 return;
7780
7781 if (isa<ValueAsMetadata>(Val: DVR.getRawLocation())) {
7782 Value *VarValue = DVR.getVariableLocationOp(OpIdx: 0);
7783 if (isa<UndefValue>(Val: VarValue) || isa<PoisonValue>(Val: VarValue))
7784 return;
7785 // We allow EntryValues for swift async arguments, as they have an
7786 // ABI-guarantee to be turned into a specific register.
7787 if (auto *ArgLoc = dyn_cast_or_null<Argument>(Val: VarValue);
7788 ArgLoc && ArgLoc->hasAttribute(Kind: Attribute::SwiftAsync))
7789 return;
7790 }
7791
7792 CheckDI(!E->isEntryValue(),
7793 "Entry values are only allowed in MIR unless they target a "
7794 "swiftasync Argument",
7795 &DVR);
7796}
7797
7798void Verifier::verifyCompileUnits() {
7799 // When more than one Module is imported into the same context, such as during
7800 // an LTO build before linking the modules, ODR type uniquing may cause types
7801 // to point to a different CU. This check does not make sense in this case.
7802 if (M.getContext().isODRUniquingDebugTypes())
7803 return;
7804 auto *CUs = M.getNamedMetadata(Name: "llvm.dbg.cu");
7805 SmallPtrSet<const Metadata *, 2> Listed;
7806 if (CUs)
7807 Listed.insert_range(R: CUs->operands());
7808 for (const auto *CU : CUVisited)
7809 CheckDI(Listed.count(CU), "DICompileUnit not listed in llvm.dbg.cu", CU);
7810 CUVisited.clear();
7811}
7812
7813void Verifier::verifyDeoptimizeCallingConvs() {
7814 if (DeoptimizeDeclarations.empty())
7815 return;
7816
7817 const Function *First = DeoptimizeDeclarations[0];
7818 for (const auto *F : ArrayRef(DeoptimizeDeclarations).slice(N: 1)) {
7819 Check(First->getCallingConv() == F->getCallingConv(),
7820 "All llvm.experimental.deoptimize declarations must have the same "
7821 "calling convention",
7822 First, F);
7823 }
7824}
7825
7826void Verifier::verifyAttachedCallBundle(const CallBase &Call,
7827 const OperandBundleUse &BU) {
7828 FunctionType *FTy = Call.getFunctionType();
7829
7830 Check((FTy->getReturnType()->isPointerTy() ||
7831 (Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),
7832 "a call with operand bundle \"clang.arc.attachedcall\" must call a "
7833 "function returning a pointer or a non-returning function that has a "
7834 "void return type",
7835 Call);
7836
7837 Check(BU.Inputs.size() == 1 && isa<Function>(BU.Inputs.front()),
7838 "operand bundle \"clang.arc.attachedcall\" requires one function as "
7839 "an argument",
7840 Call);
7841
7842 auto *Fn = cast<Function>(Val: BU.Inputs.front());
7843 Intrinsic::ID IID = Fn->getIntrinsicID();
7844
7845 if (IID) {
7846 Check((IID == Intrinsic::objc_retainAutoreleasedReturnValue ||
7847 IID == Intrinsic::objc_claimAutoreleasedReturnValue ||
7848 IID == Intrinsic::objc_unsafeClaimAutoreleasedReturnValue),
7849 "invalid function argument", Call);
7850 } else {
7851 StringRef FnName = Fn->getName();
7852 Check((FnName == "objc_retainAutoreleasedReturnValue" ||
7853 FnName == "objc_claimAutoreleasedReturnValue" ||
7854 FnName == "objc_unsafeClaimAutoreleasedReturnValue"),
7855 "invalid function argument", Call);
7856 }
7857}
7858
7859void Verifier::verifyNoAliasScopeDecl() {
7860 if (NoAliasScopeDecls.empty())
7861 return;
7862
7863 // only a single scope must be declared at a time.
7864 for (auto *II : NoAliasScopeDecls) {
7865 assert(II->getIntrinsicID() == Intrinsic::experimental_noalias_scope_decl &&
7866 "Not a llvm.experimental.noalias.scope.decl ?");
7867 const auto *ScopeListMV = dyn_cast<MetadataAsValue>(
7868 Val: II->getOperand(i_nocapture: Intrinsic::NoAliasScopeDeclScopeArg));
7869 Check(ScopeListMV != nullptr,
7870 "llvm.experimental.noalias.scope.decl must have a MetadataAsValue "
7871 "argument",
7872 II);
7873
7874 const auto *ScopeListMD = dyn_cast<MDNode>(Val: ScopeListMV->getMetadata());
7875 Check(ScopeListMD != nullptr, "!id.scope.list must point to an MDNode", II);
7876 Check(ScopeListMD->getNumOperands() == 1,
7877 "!id.scope.list must point to a list with a single scope", II);
7878 visitAliasScopeListMetadata(MD: ScopeListMD);
7879 }
7880
7881 // Only check the domination rule when requested. Once all passes have been
7882 // adapted this option can go away.
7883 if (!VerifyNoAliasScopeDomination)
7884 return;
7885
7886 // Now sort the intrinsics based on the scope MDNode so that declarations of
7887 // the same scopes are next to each other.
7888 auto GetScope = [](IntrinsicInst *II) {
7889 const auto *ScopeListMV = cast<MetadataAsValue>(
7890 Val: II->getOperand(i_nocapture: Intrinsic::NoAliasScopeDeclScopeArg));
7891 return &cast<MDNode>(Val: ScopeListMV->getMetadata())->getOperand(I: 0);
7892 };
7893
7894 // We are sorting on MDNode pointers here. For valid input IR this is ok.
7895 // TODO: Sort on Metadata ID to avoid non-deterministic error messages.
7896 auto Compare = [GetScope](IntrinsicInst *Lhs, IntrinsicInst *Rhs) {
7897 return GetScope(Lhs) < GetScope(Rhs);
7898 };
7899
7900 llvm::sort(C&: NoAliasScopeDecls, Comp: Compare);
7901
7902 // Go over the intrinsics and check that for the same scope, they are not
7903 // dominating each other.
7904 auto ItCurrent = NoAliasScopeDecls.begin();
7905 while (ItCurrent != NoAliasScopeDecls.end()) {
7906 auto CurScope = GetScope(*ItCurrent);
7907 auto ItNext = ItCurrent;
7908 do {
7909 ++ItNext;
7910 } while (ItNext != NoAliasScopeDecls.end() &&
7911 GetScope(*ItNext) == CurScope);
7912
7913 // [ItCurrent, ItNext) represents the declarations for the same scope.
7914 // Ensure they are not dominating each other.. but only if it is not too
7915 // expensive.
7916 if (ItNext - ItCurrent < 32)
7917 for (auto *I : llvm::make_range(x: ItCurrent, y: ItNext))
7918 for (auto *J : llvm::make_range(x: ItCurrent, y: ItNext))
7919 if (I != J)
7920 Check(!DT.dominates(I, J),
7921 "llvm.experimental.noalias.scope.decl dominates another one "
7922 "with the same scope",
7923 I);
7924 ItCurrent = ItNext;
7925 }
7926}
7927
7928//===----------------------------------------------------------------------===//
7929// Implement the public interfaces to this file...
7930//===----------------------------------------------------------------------===//
7931
7932bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
7933 Function &F = const_cast<Function &>(f);
7934
7935 // Don't use a raw_null_ostream. Printing IR is expensive.
7936 Verifier V(OS, /*ShouldTreatBrokenDebugInfoAsError=*/true, *f.getParent());
7937
7938 // Note that this function's return value is inverted from what you would
7939 // expect of a function called "verify".
7940 return !V.verify(F);
7941}
7942
7943bool llvm::verifyModule(const Module &M, raw_ostream *OS,
7944 bool *BrokenDebugInfo) {
7945 // Don't use a raw_null_ostream. Printing IR is expensive.
7946 Verifier V(OS, /*ShouldTreatBrokenDebugInfoAsError=*/!BrokenDebugInfo, M);
7947
7948 bool Broken = false;
7949 for (const Function &F : M)
7950 Broken |= !V.verify(F);
7951
7952 Broken |= !V.verify();
7953 if (BrokenDebugInfo)
7954 *BrokenDebugInfo = V.hasBrokenDebugInfo();
7955 // Note that this function's return value is inverted from what you would
7956 // expect of a function called "verify".
7957 return Broken;
7958}
7959
7960namespace {
7961
7962struct VerifierLegacyPass : public FunctionPass {
7963 static char ID;
7964
7965 std::unique_ptr<Verifier> V;
7966 bool FatalErrors = true;
7967
7968 VerifierLegacyPass() : FunctionPass(ID) {}
7969 explicit VerifierLegacyPass(bool FatalErrors)
7970 : FunctionPass(ID), FatalErrors(FatalErrors) {}
7971
7972 bool doInitialization(Module &M) override {
7973 V = std::make_unique<Verifier>(
7974 args: &dbgs(), /*ShouldTreatBrokenDebugInfoAsError=*/args: false, args&: M);
7975 return false;
7976 }
7977
7978 bool runOnFunction(Function &F) override {
7979 if (!V->verify(F) && FatalErrors) {
7980 errs() << "in function " << F.getName() << '\n';
7981 report_fatal_error(reason: "Broken function found, compilation aborted!");
7982 }
7983 return false;
7984 }
7985
7986 bool doFinalization(Module &M) override {
7987 bool HasErrors = false;
7988 for (Function &F : M)
7989 if (F.isDeclaration())
7990 HasErrors |= !V->verify(F);
7991
7992 HasErrors |= !V->verify();
7993 if (FatalErrors && (HasErrors || V->hasBrokenDebugInfo()))
7994 report_fatal_error(reason: "Broken module found, compilation aborted!");
7995 return false;
7996 }
7997
7998 void getAnalysisUsage(AnalysisUsage &AU) const override {
7999 AU.setPreservesAll();
8000 }
8001};
8002
8003} // end anonymous namespace
8004
8005/// Helper to issue failure from the TBAA verification
8006template <typename... Tys> void TBAAVerifier::CheckFailed(Tys &&... Args) {
8007 if (Diagnostic)
8008 return Diagnostic->CheckFailed(Args...);
8009}
8010
8011#define CheckTBAA(C, ...) \
8012 do { \
8013 if (!(C)) { \
8014 CheckFailed(__VA_ARGS__); \
8015 return false; \
8016 } \
8017 } while (false)
8018
8019/// Verify that \p BaseNode can be used as the "base type" in the struct-path
8020/// TBAA scheme. This means \p BaseNode is either a scalar node, or a
8021/// struct-type node describing an aggregate data structure (like a struct).
8022TBAAVerifier::TBAABaseNodeSummary
8023TBAAVerifier::verifyTBAABaseNode(const Instruction *I, const MDNode *BaseNode,
8024 bool IsNewFormat) {
8025 if (BaseNode->getNumOperands() < 2) {
8026 CheckFailed(Args: "Base nodes must have at least two operands", Args&: I, Args&: BaseNode);
8027 return {true, ~0u};
8028 }
8029
8030 auto Itr = TBAABaseNodes.find(Val: BaseNode);
8031 if (Itr != TBAABaseNodes.end())
8032 return Itr->second;
8033
8034 auto Result = verifyTBAABaseNodeImpl(I, BaseNode, IsNewFormat);
8035 auto InsertResult = TBAABaseNodes.insert(KV: {BaseNode, Result});
8036 (void)InsertResult;
8037 assert(InsertResult.second && "We just checked!");
8038 return Result;
8039}
8040
8041TBAAVerifier::TBAABaseNodeSummary
8042TBAAVerifier::verifyTBAABaseNodeImpl(const Instruction *I,
8043 const MDNode *BaseNode, bool IsNewFormat) {
8044 const TBAAVerifier::TBAABaseNodeSummary InvalidNode = {true, ~0u};
8045
8046 if (BaseNode->getNumOperands() == 2) {
8047 // Scalar nodes can only be accessed at offset 0.
8048 return isValidScalarTBAANode(MD: BaseNode)
8049 ? TBAAVerifier::TBAABaseNodeSummary({false, 0})
8050 : InvalidNode;
8051 }
8052
8053 if (IsNewFormat) {
8054 if (BaseNode->getNumOperands() % 3 != 0) {
8055 CheckFailed(Args: "Access tag nodes must have the number of operands that is a "
8056 "multiple of 3!", Args&: BaseNode);
8057 return InvalidNode;
8058 }
8059 } else {
8060 if (BaseNode->getNumOperands() % 2 != 1) {
8061 CheckFailed(Args: "Struct tag nodes must have an odd number of operands!",
8062 Args&: BaseNode);
8063 return InvalidNode;
8064 }
8065 }
8066
8067 // Check the type size field.
8068 if (IsNewFormat) {
8069 auto *TypeSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
8070 MD: BaseNode->getOperand(I: 1));
8071 if (!TypeSizeNode) {
8072 CheckFailed(Args: "Type size nodes must be constants!", Args&: I, Args&: BaseNode);
8073 return InvalidNode;
8074 }
8075 }
8076
8077 // Check the type name field. In the new format it can be anything.
8078 if (!IsNewFormat && !isa<MDString>(Val: BaseNode->getOperand(I: 0))) {
8079 CheckFailed(Args: "Struct tag nodes have a string as their first operand",
8080 Args&: BaseNode);
8081 return InvalidNode;
8082 }
8083
8084 bool Failed = false;
8085
8086 std::optional<APInt> PrevOffset;
8087 unsigned BitWidth = ~0u;
8088
8089 // We've already checked that BaseNode is not a degenerate root node with one
8090 // operand in \c verifyTBAABaseNode, so this loop should run at least once.
8091 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
8092 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
8093 for (unsigned Idx = FirstFieldOpNo; Idx < BaseNode->getNumOperands();
8094 Idx += NumOpsPerField) {
8095 const MDOperand &FieldTy = BaseNode->getOperand(I: Idx);
8096 const MDOperand &FieldOffset = BaseNode->getOperand(I: Idx + 1);
8097 if (!isa<MDNode>(Val: FieldTy)) {
8098 CheckFailed(Args: "Incorrect field entry in struct type node!", Args&: I, Args&: BaseNode);
8099 Failed = true;
8100 continue;
8101 }
8102
8103 auto *OffsetEntryCI =
8104 mdconst::dyn_extract_or_null<ConstantInt>(MD: FieldOffset);
8105 if (!OffsetEntryCI) {
8106 CheckFailed(Args: "Offset entries must be constants!", Args&: I, Args&: BaseNode);
8107 Failed = true;
8108 continue;
8109 }
8110
8111 if (BitWidth == ~0u)
8112 BitWidth = OffsetEntryCI->getBitWidth();
8113
8114 if (OffsetEntryCI->getBitWidth() != BitWidth) {
8115 CheckFailed(
8116 Args: "Bitwidth between the offsets and struct type entries must match", Args&: I,
8117 Args&: BaseNode);
8118 Failed = true;
8119 continue;
8120 }
8121
8122 // NB! As far as I can tell, we generate a non-strictly increasing offset
8123 // sequence only from structs that have zero size bit fields. When
8124 // recursing into a contained struct in \c getFieldNodeFromTBAABaseNode we
8125 // pick the field lexically the latest in struct type metadata node. This
8126 // mirrors the actual behavior of the alias analysis implementation.
8127 bool IsAscending =
8128 !PrevOffset || PrevOffset->ule(RHS: OffsetEntryCI->getValue());
8129
8130 if (!IsAscending) {
8131 CheckFailed(Args: "Offsets must be increasing!", Args&: I, Args&: BaseNode);
8132 Failed = true;
8133 }
8134
8135 PrevOffset = OffsetEntryCI->getValue();
8136
8137 if (IsNewFormat) {
8138 auto *MemberSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
8139 MD: BaseNode->getOperand(I: Idx + 2));
8140 if (!MemberSizeNode) {
8141 CheckFailed(Args: "Member size entries must be constants!", Args&: I, Args&: BaseNode);
8142 Failed = true;
8143 continue;
8144 }
8145 }
8146 }
8147
8148 return Failed ? InvalidNode
8149 : TBAAVerifier::TBAABaseNodeSummary(false, BitWidth);
8150}
8151
8152static bool IsRootTBAANode(const MDNode *MD) {
8153 return MD->getNumOperands() < 2;
8154}
8155
8156static bool IsScalarTBAANodeImpl(const MDNode *MD,
8157 SmallPtrSetImpl<const MDNode *> &Visited) {
8158 if (MD->getNumOperands() != 2 && MD->getNumOperands() != 3)
8159 return false;
8160
8161 if (!isa<MDString>(Val: MD->getOperand(I: 0)))
8162 return false;
8163
8164 if (MD->getNumOperands() == 3) {
8165 auto *Offset = mdconst::dyn_extract<ConstantInt>(MD: MD->getOperand(I: 2));
8166 if (!(Offset && Offset->isZero() && isa<MDString>(Val: MD->getOperand(I: 0))))
8167 return false;
8168 }
8169
8170 auto *Parent = dyn_cast_or_null<MDNode>(Val: MD->getOperand(I: 1));
8171 return Parent && Visited.insert(Ptr: Parent).second &&
8172 (IsRootTBAANode(MD: Parent) || IsScalarTBAANodeImpl(MD: Parent, Visited));
8173}
8174
8175bool TBAAVerifier::isValidScalarTBAANode(const MDNode *MD) {
8176 auto ResultIt = TBAAScalarNodes.find(Val: MD);
8177 if (ResultIt != TBAAScalarNodes.end())
8178 return ResultIt->second;
8179
8180 SmallPtrSet<const MDNode *, 4> Visited;
8181 bool Result = IsScalarTBAANodeImpl(MD, Visited);
8182 auto InsertResult = TBAAScalarNodes.insert(KV: {MD, Result});
8183 (void)InsertResult;
8184 assert(InsertResult.second && "Just checked!");
8185
8186 return Result;
8187}
8188
8189/// Returns the field node at the offset \p Offset in \p BaseNode. Update \p
8190/// Offset in place to be the offset within the field node returned.
8191///
8192/// We assume we've okayed \p BaseNode via \c verifyTBAABaseNode.
8193MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(const Instruction *I,
8194 const MDNode *BaseNode,
8195 APInt &Offset,
8196 bool IsNewFormat) {
8197 assert(BaseNode->getNumOperands() >= 2 && "Invalid base node!");
8198
8199 // Scalar nodes have only one possible "field" -- their parent in the access
8200 // hierarchy. Offset must be zero at this point, but our caller is supposed
8201 // to check that.
8202 if (BaseNode->getNumOperands() == 2)
8203 return cast<MDNode>(Val: BaseNode->getOperand(I: 1));
8204
8205 unsigned FirstFieldOpNo = IsNewFormat ? 3 : 1;
8206 unsigned NumOpsPerField = IsNewFormat ? 3 : 2;
8207 for (unsigned Idx = FirstFieldOpNo; Idx < BaseNode->getNumOperands();
8208 Idx += NumOpsPerField) {
8209 auto *OffsetEntryCI =
8210 mdconst::extract<ConstantInt>(MD: BaseNode->getOperand(I: Idx + 1));
8211 if (OffsetEntryCI->getValue().ugt(RHS: Offset)) {
8212 if (Idx == FirstFieldOpNo) {
8213 CheckFailed(Args: "Could not find TBAA parent in struct type node", Args&: I,
8214 Args&: BaseNode, Args: &Offset);
8215 return nullptr;
8216 }
8217
8218 unsigned PrevIdx = Idx - NumOpsPerField;
8219 auto *PrevOffsetEntryCI =
8220 mdconst::extract<ConstantInt>(MD: BaseNode->getOperand(I: PrevIdx + 1));
8221 Offset -= PrevOffsetEntryCI->getValue();
8222 return cast<MDNode>(Val: BaseNode->getOperand(I: PrevIdx));
8223 }
8224 }
8225
8226 unsigned LastIdx = BaseNode->getNumOperands() - NumOpsPerField;
8227 auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
8228 MD: BaseNode->getOperand(I: LastIdx + 1));
8229 Offset -= LastOffsetEntryCI->getValue();
8230 return cast<MDNode>(Val: BaseNode->getOperand(I: LastIdx));
8231}
8232
8233static bool isNewFormatTBAATypeNode(llvm::MDNode *Type) {
8234 if (!Type || Type->getNumOperands() < 3)
8235 return false;
8236
8237 // In the new format type nodes shall have a reference to the parent type as
8238 // its first operand.
8239 return isa_and_nonnull<MDNode>(Val: Type->getOperand(I: 0));
8240}
8241
8242bool TBAAVerifier::visitTBAAMetadata(const Instruction *I, const MDNode *MD) {
8243 CheckTBAA(MD->getNumOperands() > 0, "TBAA metadata cannot have 0 operands", I,
8244 MD);
8245
8246 if (I)
8247 CheckTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
8248 isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
8249 isa<AtomicCmpXchgInst>(I),
8250 "This instruction shall not have a TBAA access tag!", I);
8251
8252 bool IsStructPathTBAA =
8253 isa<MDNode>(Val: MD->getOperand(I: 0)) && MD->getNumOperands() >= 3;
8254
8255 CheckTBAA(IsStructPathTBAA,
8256 "Old-style TBAA is no longer allowed, use struct-path TBAA instead",
8257 I);
8258
8259 auto *BaseNode = dyn_cast_or_null<MDNode>(Val: MD->getOperand(I: 0));
8260 auto *AccessType = dyn_cast_or_null<MDNode>(Val: MD->getOperand(I: 1));
8261
8262 bool IsNewFormat = isNewFormatTBAATypeNode(Type: AccessType);
8263
8264 if (IsNewFormat) {
8265 CheckTBAA(MD->getNumOperands() == 4 || MD->getNumOperands() == 5,
8266 "Access tag metadata must have either 4 or 5 operands", I, MD);
8267 } else {
8268 CheckTBAA(MD->getNumOperands() < 5,
8269 "Struct tag metadata must have either 3 or 4 operands", I, MD);
8270 }
8271
8272 // Check the access size field.
8273 if (IsNewFormat) {
8274 auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
8275 MD: MD->getOperand(I: 3));
8276 CheckTBAA(AccessSizeNode, "Access size field must be a constant", I, MD);
8277 }
8278
8279 // Check the immutability flag.
8280 unsigned ImmutabilityFlagOpNo = IsNewFormat ? 4 : 3;
8281 if (MD->getNumOperands() == ImmutabilityFlagOpNo + 1) {
8282 auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
8283 MD: MD->getOperand(I: ImmutabilityFlagOpNo));
8284 CheckTBAA(IsImmutableCI,
8285 "Immutability tag on struct tag metadata must be a constant", I,
8286 MD);
8287 CheckTBAA(
8288 IsImmutableCI->isZero() || IsImmutableCI->isOne(),
8289 "Immutability part of the struct tag metadata must be either 0 or 1", I,
8290 MD);
8291 }
8292
8293 CheckTBAA(BaseNode && AccessType,
8294 "Malformed struct tag metadata: base and access-type "
8295 "should be non-null and point to Metadata nodes",
8296 I, MD, BaseNode, AccessType);
8297
8298 if (!IsNewFormat) {
8299 CheckTBAA(isValidScalarTBAANode(AccessType),
8300 "Access type node must be a valid scalar type", I, MD,
8301 AccessType);
8302 }
8303
8304 auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD: MD->getOperand(I: 2));
8305 CheckTBAA(OffsetCI, "Offset must be constant integer", I, MD);
8306
8307 APInt Offset = OffsetCI->getValue();
8308 bool SeenAccessTypeInPath = false;
8309
8310 SmallPtrSet<MDNode *, 4> StructPath;
8311
8312 for (/* empty */; BaseNode && !IsRootTBAANode(MD: BaseNode);
8313 BaseNode =
8314 getFieldNodeFromTBAABaseNode(I, BaseNode, Offset, IsNewFormat)) {
8315 if (!StructPath.insert(Ptr: BaseNode).second) {
8316 CheckFailed(Args: "Cycle detected in struct path", Args&: I, Args&: MD);
8317 return false;
8318 }
8319
8320 bool Invalid;
8321 unsigned BaseNodeBitWidth;
8322 std::tie(args&: Invalid, args&: BaseNodeBitWidth) =
8323 verifyTBAABaseNode(I, BaseNode, IsNewFormat);
8324
8325 // If the base node is invalid in itself, then we've already printed all the
8326 // errors we wanted to print.
8327 if (Invalid)
8328 return false;
8329
8330 SeenAccessTypeInPath |= BaseNode == AccessType;
8331
8332 if (isValidScalarTBAANode(MD: BaseNode) || BaseNode == AccessType)
8333 CheckTBAA(Offset == 0, "Offset not zero at the point of scalar access", I,
8334 MD, &Offset);
8335
8336 CheckTBAA(BaseNodeBitWidth == Offset.getBitWidth() ||
8337 (BaseNodeBitWidth == 0 && Offset == 0) ||
8338 (IsNewFormat && BaseNodeBitWidth == ~0u),
8339 "Access bit-width not the same as description bit-width", I, MD,
8340 BaseNodeBitWidth, Offset.getBitWidth());
8341
8342 if (IsNewFormat && SeenAccessTypeInPath)
8343 break;
8344 }
8345
8346 CheckTBAA(SeenAccessTypeInPath, "Did not see access type in access path!", I,
8347 MD);
8348 return true;
8349}
8350
8351char VerifierLegacyPass::ID = 0;
8352INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
8353
8354FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
8355 return new VerifierLegacyPass(FatalErrors);
8356}
8357
8358AnalysisKey VerifierAnalysis::Key;
8359VerifierAnalysis::Result VerifierAnalysis::run(Module &M,
8360 ModuleAnalysisManager &) {
8361 Result Res;
8362 Res.IRBroken = llvm::verifyModule(M, OS: &dbgs(), BrokenDebugInfo: &Res.DebugInfoBroken);
8363 return Res;
8364}
8365
8366VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
8367 FunctionAnalysisManager &) {
8368 return { .IRBroken: llvm::verifyFunction(f: F, OS: &dbgs()), .DebugInfoBroken: false };
8369}
8370
8371PreservedAnalyses VerifierPass::run(Module &M, ModuleAnalysisManager &AM) {
8372 auto Res = AM.getResult<VerifierAnalysis>(IR&: M);
8373 if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
8374 report_fatal_error(reason: "Broken module found, compilation aborted!");
8375
8376 return PreservedAnalyses::all();
8377}
8378
8379PreservedAnalyses VerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
8380 auto res = AM.getResult<VerifierAnalysis>(IR&: F);
8381 if (res.IRBroken && FatalErrors)
8382 report_fatal_error(reason: "Broken function found, compilation aborted!");
8383
8384 return PreservedAnalyses::all();
8385}
8386