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