Bug Summary

File:llvm/lib/IR/Verifier.cpp
Warning:line 2588, column 5
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Verifier.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/Verifier.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/Verifier.cpp

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// sanity 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// * PHI nodes must have at least one entry
27// * All basic blocks should only end with terminator insts, not contain them
28// * The entry node to a function must not have predecessors
29// * All Instructions must be embedded into a basic block
30// * Functions cannot take a void-typed parameter
31// * Verify that a function's argument list agrees with it's declared type.
32// * It is illegal to specify a name for a void value.
33// * It is illegal to have a internal global value with no initializer
34// * It is illegal to have a ret instruction that returns a value that does not
35// agree with the function return value type.
36// * Function call argument types match the function prototype
37// * A landing pad is defined by a landingpad instruction, and can be jumped to
38// only by the unwind edge of an invoke instruction.
39// * A landingpad instruction must be the first non-PHI instruction in the
40// block.
41// * Landingpad instructions must be in a function with a personality function.
42// * All other things that are tested by asserts spread about the code...
43//
44//===----------------------------------------------------------------------===//
45
46#include "llvm/IR/Verifier.h"
47#include "llvm/ADT/APFloat.h"
48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/DenseMap.h"
51#include "llvm/ADT/MapVector.h"
52#include "llvm/ADT/Optional.h"
53#include "llvm/ADT/STLExtras.h"
54#include "llvm/ADT/SmallPtrSet.h"
55#include "llvm/ADT/SmallSet.h"
56#include "llvm/ADT/SmallVector.h"
57#include "llvm/ADT/StringExtras.h"
58#include "llvm/ADT/StringMap.h"
59#include "llvm/ADT/StringRef.h"
60#include "llvm/ADT/Twine.h"
61#include "llvm/ADT/ilist.h"
62#include "llvm/BinaryFormat/Dwarf.h"
63#include "llvm/IR/Argument.h"
64#include "llvm/IR/Attributes.h"
65#include "llvm/IR/BasicBlock.h"
66#include "llvm/IR/CFG.h"
67#include "llvm/IR/CallingConv.h"
68#include "llvm/IR/Comdat.h"
69#include "llvm/IR/Constant.h"
70#include "llvm/IR/ConstantRange.h"
71#include "llvm/IR/Constants.h"
72#include "llvm/IR/DataLayout.h"
73#include "llvm/IR/DebugInfo.h"
74#include "llvm/IR/DebugInfoMetadata.h"
75#include "llvm/IR/DebugLoc.h"
76#include "llvm/IR/DerivedTypes.h"
77#include "llvm/IR/Dominators.h"
78#include "llvm/IR/Function.h"
79#include "llvm/IR/GlobalAlias.h"
80#include "llvm/IR/GlobalValue.h"
81#include "llvm/IR/GlobalVariable.h"
82#include "llvm/IR/InlineAsm.h"
83#include "llvm/IR/InstVisitor.h"
84#include "llvm/IR/InstrTypes.h"
85#include "llvm/IR/Instruction.h"
86#include "llvm/IR/Instructions.h"
87#include "llvm/IR/IntrinsicInst.h"
88#include "llvm/IR/Intrinsics.h"
89#include "llvm/IR/IntrinsicsWebAssembly.h"
90#include "llvm/IR/LLVMContext.h"
91#include "llvm/IR/Metadata.h"
92#include "llvm/IR/Module.h"
93#include "llvm/IR/ModuleSlotTracker.h"
94#include "llvm/IR/PassManager.h"
95#include "llvm/IR/Statepoint.h"
96#include "llvm/IR/Type.h"
97#include "llvm/IR/Use.h"
98#include "llvm/IR/User.h"
99#include "llvm/IR/Value.h"
100#include "llvm/InitializePasses.h"
101#include "llvm/Pass.h"
102#include "llvm/Support/AtomicOrdering.h"
103#include "llvm/Support/Casting.h"
104#include "llvm/Support/CommandLine.h"
105#include "llvm/Support/Debug.h"
106#include "llvm/Support/ErrorHandling.h"
107#include "llvm/Support/MathExtras.h"
108#include "llvm/Support/raw_ostream.h"
109#include <algorithm>
110#include <cassert>
111#include <cstdint>
112#include <memory>
113#include <string>
114#include <utility>
115
116using namespace llvm;
117
118static cl::opt<bool> VerifyNoAliasScopeDomination(
119 "verify-noalias-scope-decl-dom", cl::Hidden, cl::init(false),
120 cl::desc("Ensure that llvm.experimental.noalias.scope.decl for identical "
121 "scopes are not dominating"));
122
123namespace llvm {
124
125struct VerifierSupport {
126 raw_ostream *OS;
127 const Module &M;
128 ModuleSlotTracker MST;
129 Triple TT;
130 const DataLayout &DL;
131 LLVMContext &Context;
132
133 /// Track the brokenness of the module while recursively visiting.
134 bool Broken = false;
135 /// Broken debug info can be "recovered" from by stripping the debug info.
136 bool BrokenDebugInfo = false;
137 /// Whether to treat broken debug info as an error.
138 bool TreatBrokenDebugInfoAsError = true;
139
140 explicit VerifierSupport(raw_ostream *OS, const Module &M)
141 : OS(OS), M(M), MST(&M), TT(M.getTargetTriple()), DL(M.getDataLayout()),
142 Context(M.getContext()) {}
143
144private:
145 void Write(const Module *M) {
146 *OS << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
147 }
148
149 void Write(const Value *V) {
150 if (V)
151 Write(*V);
152 }
153
154 void Write(const Value &V) {
155 if (isa<Instruction>(V)) {
156 V.print(*OS, MST);
157 *OS << '\n';
158 } else {
159 V.printAsOperand(*OS, true, MST);
160 *OS << '\n';
161 }
162 }
163
164 void Write(const Metadata *MD) {
165 if (!MD)
166 return;
167 MD->print(*OS, MST, &M);
168 *OS << '\n';
169 }
170
171 template <class T> void Write(const MDTupleTypedArrayWrapper<T> &MD) {
172 Write(MD.get());
173 }
174
175 void Write(const NamedMDNode *NMD) {
176 if (!NMD)
177 return;
178 NMD->print(*OS, MST);
179 *OS << '\n';
180 }
181
182 void Write(Type *T) {
183 if (!T)
184 return;
185 *OS << ' ' << *T;
186 }
187
188 void Write(const Comdat *C) {
189 if (!C)
190 return;
191 *OS << *C;
192 }
193
194 void Write(const APInt *AI) {
195 if (!AI)
196 return;
197 *OS << *AI << '\n';
198 }
199
200 void Write(const unsigned i) { *OS << i << '\n'; }
201
202 // NOLINTNEXTLINE(readability-identifier-naming)
203 void Write(const Attribute *A) {
204 if (!A)
205 return;
206 *OS << A->getAsString() << '\n';
207 }
208
209 // NOLINTNEXTLINE(readability-identifier-naming)
210 void Write(const AttributeSet *AS) {
211 if (!AS)
212 return;
213 *OS << AS->getAsString() << '\n';
214 }
215
216 // NOLINTNEXTLINE(readability-identifier-naming)
217 void Write(const AttributeList *AL) {
218 if (!AL)
219 return;
220 AL->print(*OS);
221 }
222
223 template <typename T> void Write(ArrayRef<T> Vs) {
224 for (const T &V : Vs)
225 Write(V);
226 }
227
228 template <typename T1, typename... Ts>
229 void WriteTs(const T1 &V1, const Ts &... Vs) {
230 Write(V1);
231 WriteTs(Vs...);
232 }
233
234 template <typename... Ts> void WriteTs() {}
235
236public:
237 /// A check failed, so printout out the condition and the message.
238 ///
239 /// This provides a nice place to put a breakpoint if you want to see why
240 /// something is not correct.
241 void CheckFailed(const Twine &Message) {
242 if (OS)
243 *OS << Message << '\n';
244 Broken = true;
245 }
246
247 /// A check failed (with values to print).
248 ///
249 /// This calls the Message-only version so that the above is easier to set a
250 /// breakpoint on.
251 template <typename T1, typename... Ts>
252 void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) {
253 CheckFailed(Message);
254 if (OS)
255 WriteTs(V1, Vs...);
256 }
257
258 /// A debug info check failed.
259 void DebugInfoCheckFailed(const Twine &Message) {
260 if (OS)
261 *OS << Message << '\n';
262 Broken |= TreatBrokenDebugInfoAsError;
263 BrokenDebugInfo = true;
264 }
265
266 /// A debug info check failed (with values to print).
267 template <typename T1, typename... Ts>
268 void DebugInfoCheckFailed(const Twine &Message, const T1 &V1,
269 const Ts &... Vs) {
270 DebugInfoCheckFailed(Message);
271 if (OS)
272 WriteTs(V1, Vs...);
273 }
274};
275
276} // namespace llvm
277
278namespace {
279
280class Verifier : public InstVisitor<Verifier>, VerifierSupport {
281 friend class InstVisitor<Verifier>;
282
283 DominatorTree DT;
284
285 /// When verifying a basic block, keep track of all of the
286 /// instructions we have seen so far.
287 ///
288 /// This allows us to do efficient dominance checks for the case when an
289 /// instruction has an operand that is an instruction in the same block.
290 SmallPtrSet<Instruction *, 16> InstsInThisBlock;
291
292 /// Keep track of the metadata nodes that have been checked already.
293 SmallPtrSet<const Metadata *, 32> MDNodes;
294
295 /// Keep track which DISubprogram is attached to which function.
296 DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
297
298 /// Track all DICompileUnits visited.
299 SmallPtrSet<const Metadata *, 2> CUVisited;
300
301 /// The result type for a landingpad.
302 Type *LandingPadResultTy;
303
304 /// Whether we've seen a call to @llvm.localescape in this function
305 /// already.
306 bool SawFrameEscape;
307
308 /// Whether the current function has a DISubprogram attached to it.
309 bool HasDebugInfo = false;
310
311 /// The current source language.
312 dwarf::SourceLanguage CurrentSourceLang = dwarf::DW_LANG_lo_user;
313
314 /// Whether source was present on the first DIFile encountered in each CU.
315 DenseMap<const DICompileUnit *, bool> HasSourceDebugInfo;
316
317 /// Stores the count of how many objects were passed to llvm.localescape for a
318 /// given function and the largest index passed to llvm.localrecover.
319 DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
320
321 // Maps catchswitches and cleanuppads that unwind to siblings to the
322 // terminators that indicate the unwind, used to detect cycles therein.
323 MapVector<Instruction *, Instruction *> SiblingFuncletInfo;
324
325 /// Cache of constants visited in search of ConstantExprs.
326 SmallPtrSet<const Constant *, 32> ConstantExprVisited;
327
328 /// Cache of declarations of the llvm.experimental.deoptimize.<ty> intrinsic.
329 SmallVector<const Function *, 4> DeoptimizeDeclarations;
330
331 /// Cache of attribute lists verified.
332 SmallPtrSet<const void *, 32> AttributeListsVisited;
333
334 // Verify that this GlobalValue is only used in this module.
335 // This map is used to avoid visiting uses twice. We can arrive at a user
336 // twice, if they have multiple operands. In particular for very large
337 // constant expressions, we can arrive at a particular user many times.
338 SmallPtrSet<const Value *, 32> GlobalValueVisited;
339
340 // Keeps track of duplicate function argument debug info.
341 SmallVector<const DILocalVariable *, 16> DebugFnArgs;
342
343 TBAAVerifier TBAAVerifyHelper;
344
345 SmallVector<IntrinsicInst *, 4> NoAliasScopeDecls;
346
347 void checkAtomicMemAccessSize(Type *Ty, const Instruction *I);
348
349public:
350 explicit Verifier(raw_ostream *OS, bool ShouldTreatBrokenDebugInfoAsError,
351 const Module &M)
352 : VerifierSupport(OS, M), LandingPadResultTy(nullptr),
353 SawFrameEscape(false), TBAAVerifyHelper(this) {
354 TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
355 }
356
357 bool hasBrokenDebugInfo() const { return BrokenDebugInfo; }
358
359 bool verify(const Function &F) {
360 assert(F.getParent() == &M &&(static_cast<void> (0))
361 "An instance of this class only works with a specific module!")(static_cast<void> (0));
362
363 // First ensure the function is well-enough formed to compute dominance
364 // information, and directly compute a dominance tree. We don't rely on the
365 // pass manager to provide this as it isolates us from a potentially
366 // out-of-date dominator tree and makes it significantly more complex to run
367 // this code outside of a pass manager.
368 // FIXME: It's really gross that we have to cast away constness here.
369 if (!F.empty())
370 DT.recalculate(const_cast<Function &>(F));
371
372 for (const BasicBlock &BB : F) {
373 if (!BB.empty() && BB.back().isTerminator())
374 continue;
375
376 if (OS) {
377 *OS << "Basic Block in function '" << F.getName()
378 << "' does not have terminator!\n";
379 BB.printAsOperand(*OS, true, MST);
380 *OS << "\n";
381 }
382 return false;
383 }
384
385 Broken = false;
386 // FIXME: We strip const here because the inst visitor strips const.
387 visit(const_cast<Function &>(F));
388 verifySiblingFuncletUnwinds();
389 InstsInThisBlock.clear();
390 DebugFnArgs.clear();
391 LandingPadResultTy = nullptr;
392 SawFrameEscape = false;
393 SiblingFuncletInfo.clear();
394 verifyNoAliasScopeDecl();
395 NoAliasScopeDecls.clear();
396
397 return !Broken;
398 }
399
400 /// Verify the module that this instance of \c Verifier was initialized with.
401 bool verify() {
402 Broken = false;
403
404 // Collect all declarations of the llvm.experimental.deoptimize intrinsic.
405 for (const Function &F : M)
406 if (F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
407 DeoptimizeDeclarations.push_back(&F);
408
409 // Now that we've visited every function, verify that we never asked to
410 // recover a frame index that wasn't escaped.
411 verifyFrameRecoverIndices();
412 for (const GlobalVariable &GV : M.globals())
413 visitGlobalVariable(GV);
414
415 for (const GlobalAlias &GA : M.aliases())
416 visitGlobalAlias(GA);
417
418 for (const NamedMDNode &NMD : M.named_metadata())
419 visitNamedMDNode(NMD);
420
421 for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable())
422 visitComdat(SMEC.getValue());
423
424 visitModuleFlags(M);
425 visitModuleIdents(M);
426 visitModuleCommandLines(M);
427
428 verifyCompileUnits();
429
430 verifyDeoptimizeCallingConvs();
431 DISubprogramAttachments.clear();
432 return !Broken;
433 }
434
435private:
436 /// Whether a metadata node is allowed to be, or contain, a DILocation.
437 enum class AreDebugLocsAllowed { No, Yes };
438
439 // Verification methods...
440 void visitGlobalValue(const GlobalValue &GV);
441 void visitGlobalVariable(const GlobalVariable &GV);
442 void visitGlobalAlias(const GlobalAlias &GA);
443 void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C);
444 void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited,
445 const GlobalAlias &A, const Constant &C);
446 void visitNamedMDNode(const NamedMDNode &NMD);
447 void visitMDNode(const MDNode &MD, AreDebugLocsAllowed AllowLocs);
448 void visitMetadataAsValue(const MetadataAsValue &MD, Function *F);
449 void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F);
450 void visitComdat(const Comdat &C);
451 void visitModuleIdents(const Module &M);
452 void visitModuleCommandLines(const Module &M);
453 void visitModuleFlags(const Module &M);
454 void visitModuleFlag(const MDNode *Op,
455 DenseMap<const MDString *, const MDNode *> &SeenIDs,
456 SmallVectorImpl<const MDNode *> &Requirements);
457 void visitModuleFlagCGProfileEntry(const MDOperand &MDO);
458 void visitFunction(const Function &F);
459 void visitBasicBlock(BasicBlock &BB);
460 void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
461 void visitDereferenceableMetadata(Instruction &I, MDNode *MD);
462 void visitProfMetadata(Instruction &I, MDNode *MD);
463 void visitAnnotationMetadata(MDNode *Annotation);
464
465 template <class Ty> bool isValidMetadataArray(const MDTuple &N);
466#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
467#include "llvm/IR/Metadata.def"
468 void visitDIScope(const DIScope &N);
469 void visitDIVariable(const DIVariable &N);
470 void visitDILexicalBlockBase(const DILexicalBlockBase &N);
471 void visitDITemplateParameter(const DITemplateParameter &N);
472
473 void visitTemplateParams(const MDNode &N, const Metadata &RawParams);
474
475 // InstVisitor overrides...
476 using InstVisitor<Verifier>::visit;
477 void visit(Instruction &I);
478
479 void visitTruncInst(TruncInst &I);
480 void visitZExtInst(ZExtInst &I);
481 void visitSExtInst(SExtInst &I);
482 void visitFPTruncInst(FPTruncInst &I);
483 void visitFPExtInst(FPExtInst &I);
484 void visitFPToUIInst(FPToUIInst &I);
485 void visitFPToSIInst(FPToSIInst &I);
486 void visitUIToFPInst(UIToFPInst &I);
487 void visitSIToFPInst(SIToFPInst &I);
488 void visitIntToPtrInst(IntToPtrInst &I);
489 void visitPtrToIntInst(PtrToIntInst &I);
490 void visitBitCastInst(BitCastInst &I);
491 void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
492 void visitPHINode(PHINode &PN);
493 void visitCallBase(CallBase &Call);
494 void visitUnaryOperator(UnaryOperator &U);
495 void visitBinaryOperator(BinaryOperator &B);
496 void visitICmpInst(ICmpInst &IC);
497 void visitFCmpInst(FCmpInst &FC);
498 void visitExtractElementInst(ExtractElementInst &EI);
499 void visitInsertElementInst(InsertElementInst &EI);
500 void visitShuffleVectorInst(ShuffleVectorInst &EI);
501 void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); }
502 void visitCallInst(CallInst &CI);
503 void visitInvokeInst(InvokeInst &II);
504 void visitGetElementPtrInst(GetElementPtrInst &GEP);
505 void visitLoadInst(LoadInst &LI);
506 void visitStoreInst(StoreInst &SI);
507 void verifyDominatesUse(Instruction &I, unsigned i);
508 void visitInstruction(Instruction &I);
509 void visitTerminator(Instruction &I);
510 void visitBranchInst(BranchInst &BI);
511 void visitReturnInst(ReturnInst &RI);
512 void visitSwitchInst(SwitchInst &SI);
513 void visitIndirectBrInst(IndirectBrInst &BI);
514 void visitCallBrInst(CallBrInst &CBI);
515 void visitSelectInst(SelectInst &SI);
516 void visitUserOp1(Instruction &I);
517 void visitUserOp2(Instruction &I) { visitUserOp1(I); }
518 void visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call);
519 void visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI);
520 void visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII);
521 void visitDbgLabelIntrinsic(StringRef Kind, DbgLabelInst &DLI);
522 void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
523 void visitAtomicRMWInst(AtomicRMWInst &RMWI);
524 void visitFenceInst(FenceInst &FI);
525 void visitAllocaInst(AllocaInst &AI);
526 void visitExtractValueInst(ExtractValueInst &EVI);
527 void visitInsertValueInst(InsertValueInst &IVI);
528 void visitEHPadPredecessors(Instruction &I);
529 void visitLandingPadInst(LandingPadInst &LPI);
530 void visitResumeInst(ResumeInst &RI);
531 void visitCatchPadInst(CatchPadInst &CPI);
532 void visitCatchReturnInst(CatchReturnInst &CatchReturn);
533 void visitCleanupPadInst(CleanupPadInst &CPI);
534 void visitFuncletPadInst(FuncletPadInst &FPI);
535 void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch);
536 void visitCleanupReturnInst(CleanupReturnInst &CRI);
537
538 void verifySwiftErrorCall(CallBase &Call, const Value *SwiftErrorVal);
539 void verifySwiftErrorValue(const Value *SwiftErrorVal);
540 void verifyTailCCMustTailAttrs(AttrBuilder Attrs, StringRef Context);
541 void verifyMustTailCall(CallInst &CI);
542 bool verifyAttributeCount(AttributeList Attrs, unsigned Params);
543 void verifyAttributeTypes(AttributeSet Attrs, const Value *V);
544 void verifyParameterAttrs(AttributeSet Attrs, Type *Ty, const Value *V);
545 void checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
546 const Value *V);
547 void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
548 const Value *V, bool IsIntrinsic);
549 void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
550
551 void visitConstantExprsRecursively(const Constant *EntryC);
552 void visitConstantExpr(const ConstantExpr *CE);
553 void verifyStatepoint(const CallBase &Call);
554 void verifyFrameRecoverIndices();
555 void verifySiblingFuncletUnwinds();
556
557 void verifyFragmentExpression(const DbgVariableIntrinsic &I);
558 template <typename ValueOrMetadata>
559 void verifyFragmentExpression(const DIVariable &V,
560 DIExpression::FragmentInfo Fragment,
561 ValueOrMetadata *Desc);
562 void verifyFnArgs(const DbgVariableIntrinsic &I);
563 void verifyNotEntryValue(const DbgVariableIntrinsic &I);
564
565 /// Module-level debug info verification...
566 void verifyCompileUnits();
567
568 /// Module-level verification that all @llvm.experimental.deoptimize
569 /// declarations share the same calling convention.
570 void verifyDeoptimizeCallingConvs();
571
572 /// Verify all-or-nothing property of DIFile source attribute within a CU.
573 void verifySourceDebugInfo(const DICompileUnit &U, const DIFile &F);
574
575 /// Verify the llvm.experimental.noalias.scope.decl declarations
576 void verifyNoAliasScopeDecl();
577};
578
579} // end anonymous namespace
580
581/// We know that cond should be true, if not print an error message.
582#define Assert(C, ...)do { if (!(C)) { CheckFailed(...); return; } } while (false) \
583 do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (false)
584
585/// We know that a debug info condition should be true, if not print
586/// an error message.
587#define AssertDI(C, ...)do { if (!(C)) { DebugInfoCheckFailed(...); return; } } while
(false)
\
588 do { if (!(C)) { DebugInfoCheckFailed(__VA_ARGS__); return; } } while (false)
589
590void Verifier::visit(Instruction &I) {
591 for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
592 Assert(I.getOperand(i) != nullptr, "Operand is null", &I)do { if (!(I.getOperand(i) != nullptr)) { CheckFailed("Operand is null"
, &I); return; } } while (false)
;
593 InstVisitor<Verifier>::visit(I);
594}
595
596// Helper to recursively iterate over indirect users. By
597// returning false, the callback can ask to stop recursing
598// further.
599static void forEachUser(const Value *User,
600 SmallPtrSet<const Value *, 32> &Visited,
601 llvm::function_ref<bool(const Value *)> Callback) {
602 if (!Visited.insert(User).second)
603 return;
604 for (const Value *TheNextUser : User->materialized_users())
605 if (Callback(TheNextUser))
606 forEachUser(TheNextUser, Visited, Callback);
607}
608
609void Verifier::visitGlobalValue(const GlobalValue &GV) {
610 Assert(!GV.isDeclaration() || GV.hasValidDeclarationLinkage(),do { if (!(!GV.isDeclaration() || GV.hasValidDeclarationLinkage
())) { CheckFailed("Global is external, but doesn't have external or weak linkage!"
, &GV); return; } } while (false)
611 "Global is external, but doesn't have external or weak linkage!", &GV)do { if (!(!GV.isDeclaration() || GV.hasValidDeclarationLinkage
())) { CheckFailed("Global is external, but doesn't have external or weak linkage!"
, &GV); return; } } while (false)
;
612
613 if (const GlobalObject *GO = dyn_cast<GlobalObject>(&GV))
614 Assert(GO->getAlignment() <= Value::MaximumAlignment,do { if (!(GO->getAlignment() <= Value::MaximumAlignment
)) { CheckFailed("huge alignment values are unsupported", GO)
; return; } } while (false)
615 "huge alignment values are unsupported", GO)do { if (!(GO->getAlignment() <= Value::MaximumAlignment
)) { CheckFailed("huge alignment values are unsupported", GO)
; return; } } while (false)
;
616 Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),do { if (!(!GV.hasAppendingLinkage() || isa<GlobalVariable
>(GV))) { CheckFailed("Only global variables can have appending linkage!"
, &GV); return; } } while (false)
617 "Only global variables can have appending linkage!", &GV)do { if (!(!GV.hasAppendingLinkage() || isa<GlobalVariable
>(GV))) { CheckFailed("Only global variables can have appending linkage!"
, &GV); return; } } while (false)
;
618
619 if (GV.hasAppendingLinkage()) {
620 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
621 Assert(GVar && GVar->getValueType()->isArrayTy(),do { if (!(GVar && GVar->getValueType()->isArrayTy
())) { CheckFailed("Only global arrays can have appending linkage!"
, GVar); return; } } while (false)
622 "Only global arrays can have appending linkage!", GVar)do { if (!(GVar && GVar->getValueType()->isArrayTy
())) { CheckFailed("Only global arrays can have appending linkage!"
, GVar); return; } } while (false)
;
623 }
624
625 if (GV.isDeclarationForLinker())
626 Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV)do { if (!(!GV.hasComdat())) { CheckFailed("Declaration may not be in a Comdat!"
, &GV); return; } } while (false)
;
627
628 if (GV.hasDLLImportStorageClass()) {
629 Assert(!GV.isDSOLocal(),do { if (!(!GV.isDSOLocal())) { CheckFailed("GlobalValue with DLLImport Storage is dso_local!"
, &GV); return; } } while (false)
630 "GlobalValue with DLLImport Storage is dso_local!", &GV)do { if (!(!GV.isDSOLocal())) { CheckFailed("GlobalValue with DLLImport Storage is dso_local!"
, &GV); return; } } while (false)
;
631
632 Assert((GV.isDeclaration() &&do { if (!((GV.isDeclaration() && (GV.hasExternalLinkage
() || GV.hasExternalWeakLinkage())) || GV.hasAvailableExternallyLinkage
())) { CheckFailed("Global is marked as dllimport, but not external"
, &GV); return; } } while (false)
633 (GV.hasExternalLinkage() || GV.hasExternalWeakLinkage())) ||do { if (!((GV.isDeclaration() && (GV.hasExternalLinkage
() || GV.hasExternalWeakLinkage())) || GV.hasAvailableExternallyLinkage
())) { CheckFailed("Global is marked as dllimport, but not external"
, &GV); return; } } while (false)
634 GV.hasAvailableExternallyLinkage(),do { if (!((GV.isDeclaration() && (GV.hasExternalLinkage
() || GV.hasExternalWeakLinkage())) || GV.hasAvailableExternallyLinkage
())) { CheckFailed("Global is marked as dllimport, but not external"
, &GV); return; } } while (false)
635 "Global is marked as dllimport, but not external", &GV)do { if (!((GV.isDeclaration() && (GV.hasExternalLinkage
() || GV.hasExternalWeakLinkage())) || GV.hasAvailableExternallyLinkage
())) { CheckFailed("Global is marked as dllimport, but not external"
, &GV); return; } } while (false)
;
636 }
637
638 if (GV.isImplicitDSOLocal())
639 Assert(GV.isDSOLocal(),do { if (!(GV.isDSOLocal())) { CheckFailed("GlobalValue with local linkage or non-default "
"visibility must be dso_local!", &GV); return; } } while
(false)
640 "GlobalValue with local linkage or non-default "do { if (!(GV.isDSOLocal())) { CheckFailed("GlobalValue with local linkage or non-default "
"visibility must be dso_local!", &GV); return; } } while
(false)
641 "visibility must be dso_local!",do { if (!(GV.isDSOLocal())) { CheckFailed("GlobalValue with local linkage or non-default "
"visibility must be dso_local!", &GV); return; } } while
(false)
642 &GV)do { if (!(GV.isDSOLocal())) { CheckFailed("GlobalValue with local linkage or non-default "
"visibility must be dso_local!", &GV); return; } } while
(false)
;
643
644 forEachUser(&GV, GlobalValueVisited, [&](const Value *V) -> bool {
645 if (const Instruction *I = dyn_cast<Instruction>(V)) {
646 if (!I->getParent() || !I->getParent()->getParent())
647 CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
648 I);
649 else if (I->getParent()->getParent()->getParent() != &M)
650 CheckFailed("Global is referenced in a different module!", &GV, &M, I,
651 I->getParent()->getParent(),
652 I->getParent()->getParent()->getParent());
653 return false;
654 } else if (const Function *F = dyn_cast<Function>(V)) {
655 if (F->getParent() != &M)
656 CheckFailed("Global is used by function in a different module", &GV, &M,
657 F, F->getParent());
658 return false;
659 }
660 return true;
661 });
662}
663
664void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
665 if (GV.hasInitializer()) {
666 Assert(GV.getInitializer()->getType() == GV.getValueType(),do { if (!(GV.getInitializer()->getType() == GV.getValueType
())) { CheckFailed("Global variable initializer type does not match global "
"variable type!", &GV); return; } } while (false)
667 "Global variable initializer type does not match global "do { if (!(GV.getInitializer()->getType() == GV.getValueType
())) { CheckFailed("Global variable initializer type does not match global "
"variable type!", &GV); return; } } while (false)
668 "variable type!",do { if (!(GV.getInitializer()->getType() == GV.getValueType
())) { CheckFailed("Global variable initializer type does not match global "
"variable type!", &GV); return; } } while (false)
669 &GV)do { if (!(GV.getInitializer()->getType() == GV.getValueType
())) { CheckFailed("Global variable initializer type does not match global "
"variable type!", &GV); return; } } while (false)
;
670 // If the global has common linkage, it must have a zero initializer and
671 // cannot be constant.
672 if (GV.hasCommonLinkage()) {
673 Assert(GV.getInitializer()->isNullValue(),do { if (!(GV.getInitializer()->isNullValue())) { CheckFailed
("'common' global must have a zero initializer!", &GV); return
; } } while (false)
674 "'common' global must have a zero initializer!", &GV)do { if (!(GV.getInitializer()->isNullValue())) { CheckFailed
("'common' global must have a zero initializer!", &GV); return
; } } while (false)
;
675 Assert(!GV.isConstant(), "'common' global may not be marked constant!",do { if (!(!GV.isConstant())) { CheckFailed("'common' global may not be marked constant!"
, &GV); return; } } while (false)
676 &GV)do { if (!(!GV.isConstant())) { CheckFailed("'common' global may not be marked constant!"
, &GV); return; } } while (false)
;
677 Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV)do { if (!(!GV.hasComdat())) { CheckFailed("'common' global may not be in a Comdat!"
, &GV); return; } } while (false)
;
678 }
679 }
680
681 if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
682 GV.getName() == "llvm.global_dtors")) {
683 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),do { if (!(!GV.hasInitializer() || GV.hasAppendingLinkage()))
{ CheckFailed("invalid linkage for intrinsic global variable"
, &GV); return; } } while (false)
684 "invalid linkage for intrinsic global variable", &GV)do { if (!(!GV.hasInitializer() || GV.hasAppendingLinkage()))
{ CheckFailed("invalid linkage for intrinsic global variable"
, &GV); return; } } while (false)
;
685 // Don't worry about emitting an error for it not being an array,
686 // visitGlobalValue will complain on appending non-array.
687 if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
688 StructType *STy = dyn_cast<StructType>(ATy->getElementType());
689 PointerType *FuncPtrTy =
690 FunctionType::get(Type::getVoidTy(Context), false)->
691 getPointerTo(DL.getProgramAddressSpace());
692 Assert(STy &&do { if (!(STy && (STy->getNumElements() == 2 || STy
->getNumElements() == 3) && STy->getTypeAtIndex
(0u)->isIntegerTy(32) && STy->getTypeAtIndex(1)
== FuncPtrTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
693 (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&do { if (!(STy && (STy->getNumElements() == 2 || STy
->getNumElements() == 3) && STy->getTypeAtIndex
(0u)->isIntegerTy(32) && STy->getTypeAtIndex(1)
== FuncPtrTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
694 STy->getTypeAtIndex(0u)->isIntegerTy(32) &&do { if (!(STy && (STy->getNumElements() == 2 || STy
->getNumElements() == 3) && STy->getTypeAtIndex
(0u)->isIntegerTy(32) && STy->getTypeAtIndex(1)
== FuncPtrTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
695 STy->getTypeAtIndex(1) == FuncPtrTy,do { if (!(STy && (STy->getNumElements() == 2 || STy
->getNumElements() == 3) && STy->getTypeAtIndex
(0u)->isIntegerTy(32) && STy->getTypeAtIndex(1)
== FuncPtrTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
696 "wrong type for intrinsic global variable", &GV)do { if (!(STy && (STy->getNumElements() == 2 || STy
->getNumElements() == 3) && STy->getTypeAtIndex
(0u)->isIntegerTy(32) && STy->getTypeAtIndex(1)
== FuncPtrTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
;
697 Assert(STy->getNumElements() == 3,do { if (!(STy->getNumElements() == 3)) { CheckFailed("the third field of the element type is mandatory, "
"specify i8* null to migrate from the obsoleted 2-field form"
); return; } } while (false)
698 "the third field of the element type is mandatory, "do { if (!(STy->getNumElements() == 3)) { CheckFailed("the third field of the element type is mandatory, "
"specify i8* null to migrate from the obsoleted 2-field form"
); return; } } while (false)
699 "specify i8* null to migrate from the obsoleted 2-field form")do { if (!(STy->getNumElements() == 3)) { CheckFailed("the third field of the element type is mandatory, "
"specify i8* null to migrate from the obsoleted 2-field form"
); return; } } while (false)
;
700 Type *ETy = STy->getTypeAtIndex(2);
701 Type *Int8Ty = Type::getInt8Ty(ETy->getContext());
702 Assert(ETy->isPointerTy() &&do { if (!(ETy->isPointerTy() && cast<PointerType
>(ETy)->isOpaqueOrPointeeTypeMatches(Int8Ty))) { CheckFailed
("wrong type for intrinsic global variable", &GV); return
; } } while (false)
703 cast<PointerType>(ETy)->isOpaqueOrPointeeTypeMatches(Int8Ty),do { if (!(ETy->isPointerTy() && cast<PointerType
>(ETy)->isOpaqueOrPointeeTypeMatches(Int8Ty))) { CheckFailed
("wrong type for intrinsic global variable", &GV); return
; } } while (false)
704 "wrong type for intrinsic global variable", &GV)do { if (!(ETy->isPointerTy() && cast<PointerType
>(ETy)->isOpaqueOrPointeeTypeMatches(Int8Ty))) { CheckFailed
("wrong type for intrinsic global variable", &GV); return
; } } while (false)
;
705 }
706 }
707
708 if (GV.hasName() && (GV.getName() == "llvm.used" ||
709 GV.getName() == "llvm.compiler.used")) {
710 Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),do { if (!(!GV.hasInitializer() || GV.hasAppendingLinkage()))
{ CheckFailed("invalid linkage for intrinsic global variable"
, &GV); return; } } while (false)
711 "invalid linkage for intrinsic global variable", &GV)do { if (!(!GV.hasInitializer() || GV.hasAppendingLinkage()))
{ CheckFailed("invalid linkage for intrinsic global variable"
, &GV); return; } } while (false)
;
712 Type *GVType = GV.getValueType();
713 if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
714 PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
715 Assert(PTy, "wrong type for intrinsic global variable", &GV)do { if (!(PTy)) { CheckFailed("wrong type for intrinsic global variable"
, &GV); return; } } while (false)
;
716 if (GV.hasInitializer()) {
717 const Constant *Init = GV.getInitializer();
718 const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
719 Assert(InitArray, "wrong initalizer for intrinsic global variable",do { if (!(InitArray)) { CheckFailed("wrong initalizer for intrinsic global variable"
, Init); return; } } while (false)
720 Init)do { if (!(InitArray)) { CheckFailed("wrong initalizer for intrinsic global variable"
, Init); return; } } while (false)
;
721 for (Value *Op : InitArray->operands()) {
722 Value *V = Op->stripPointerCasts();
723 Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||do { if (!(isa<GlobalVariable>(V) || isa<Function>
(V) || isa<GlobalAlias>(V))) { CheckFailed("invalid llvm.used member"
, V); return; } } while (false)
724 isa<GlobalAlias>(V),do { if (!(isa<GlobalVariable>(V) || isa<Function>
(V) || isa<GlobalAlias>(V))) { CheckFailed("invalid llvm.used member"
, V); return; } } while (false)
725 "invalid llvm.used member", V)do { if (!(isa<GlobalVariable>(V) || isa<Function>
(V) || isa<GlobalAlias>(V))) { CheckFailed("invalid llvm.used member"
, V); return; } } while (false)
;
726 Assert(V->hasName(), "members of llvm.used must be named", V)do { if (!(V->hasName())) { CheckFailed("members of llvm.used must be named"
, V); return; } } while (false)
;
727 }
728 }
729 }
730 }
731
732 // Visit any debug info attachments.
733 SmallVector<MDNode *, 1> MDs;
734 GV.getMetadata(LLVMContext::MD_dbg, MDs);
735 for (auto *MD : MDs) {
736 if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
737 visitDIGlobalVariableExpression(*GVE);
738 else
739 AssertDI(false, "!dbg attachment of global variable must be a "do { if (!(false)) { DebugInfoCheckFailed("!dbg attachment of global variable must be a "
"DIGlobalVariableExpression"); return; } } while (false)
740 "DIGlobalVariableExpression")do { if (!(false)) { DebugInfoCheckFailed("!dbg attachment of global variable must be a "
"DIGlobalVariableExpression"); return; } } while (false)
;
741 }
742
743 // Scalable vectors cannot be global variables, since we don't know
744 // the runtime size. If the global is an array containing scalable vectors,
745 // that will be caught by the isValidElementType methods in StructType or
746 // ArrayType instead.
747 Assert(!isa<ScalableVectorType>(GV.getValueType()),do { if (!(!isa<ScalableVectorType>(GV.getValueType()))
) { CheckFailed("Globals cannot contain scalable vectors", &
GV); return; } } while (false)
748 "Globals cannot contain scalable vectors", &GV)do { if (!(!isa<ScalableVectorType>(GV.getValueType()))
) { CheckFailed("Globals cannot contain scalable vectors", &
GV); return; } } while (false)
;
749
750 if (auto *STy = dyn_cast<StructType>(GV.getValueType()))
751 Assert(!STy->containsScalableVectorType(),do { if (!(!STy->containsScalableVectorType())) { CheckFailed
("Globals cannot contain scalable vectors", &GV); return;
} } while (false)
752 "Globals cannot contain scalable vectors", &GV)do { if (!(!STy->containsScalableVectorType())) { CheckFailed
("Globals cannot contain scalable vectors", &GV); return;
} } while (false)
;
753
754 if (!GV.hasInitializer()) {
755 visitGlobalValue(GV);
756 return;
757 }
758
759 // Walk any aggregate initializers looking for bitcasts between address spaces
760 visitConstantExprsRecursively(GV.getInitializer());
761
762 visitGlobalValue(GV);
763}
764
765void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
766 SmallPtrSet<const GlobalAlias*, 4> Visited;
767 Visited.insert(&GA);
768 visitAliaseeSubExpr(Visited, GA, C);
769}
770
771void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
772 const GlobalAlias &GA, const Constant &C) {
773 if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
774 Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition",do { if (!(!GV->isDeclarationForLinker())) { CheckFailed("Alias must point to a definition"
, &GA); return; } } while (false)
775 &GA)do { if (!(!GV->isDeclarationForLinker())) { CheckFailed("Alias must point to a definition"
, &GA); return; } } while (false)
;
776
777 if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
778 Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA)do { if (!(Visited.insert(GA2).second)) { CheckFailed("Aliases cannot form a cycle"
, &GA); return; } } while (false)
;
779
780 Assert(!GA2->isInterposable(), "Alias cannot point to an interposable alias",do { if (!(!GA2->isInterposable())) { CheckFailed("Alias cannot point to an interposable alias"
, &GA); return; } } while (false)
781 &GA)do { if (!(!GA2->isInterposable())) { CheckFailed("Alias cannot point to an interposable alias"
, &GA); return; } } while (false)
;
782 } else {
783 // Only continue verifying subexpressions of GlobalAliases.
784 // Do not recurse into global initializers.
785 return;
786 }
787 }
788
789 if (const auto *CE = dyn_cast<ConstantExpr>(&C))
790 visitConstantExprsRecursively(CE);
791
792 for (const Use &U : C.operands()) {
793 Value *V = &*U;
794 if (const auto *GA2 = dyn_cast<GlobalAlias>(V))
795 visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
796 else if (const auto *C2 = dyn_cast<Constant>(V))
797 visitAliaseeSubExpr(Visited, GA, *C2);
798 }
799}
800
801void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
802 Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),do { if (!(GlobalAlias::isValidLinkage(GA.getLinkage()))) { CheckFailed
("Alias should have private, internal, linkonce, weak, linkonce_odr, "
"weak_odr, or external linkage!", &GA); return; } } while
(false)
803 "Alias should have private, internal, linkonce, weak, linkonce_odr, "do { if (!(GlobalAlias::isValidLinkage(GA.getLinkage()))) { CheckFailed
("Alias should have private, internal, linkonce, weak, linkonce_odr, "
"weak_odr, or external linkage!", &GA); return; } } while
(false)
804 "weak_odr, or external linkage!",do { if (!(GlobalAlias::isValidLinkage(GA.getLinkage()))) { CheckFailed
("Alias should have private, internal, linkonce, weak, linkonce_odr, "
"weak_odr, or external linkage!", &GA); return; } } while
(false)
805 &GA)do { if (!(GlobalAlias::isValidLinkage(GA.getLinkage()))) { CheckFailed
("Alias should have private, internal, linkonce, weak, linkonce_odr, "
"weak_odr, or external linkage!", &GA); return; } } while
(false)
;
806 const Constant *Aliasee = GA.getAliasee();
807 Assert(Aliasee, "Aliasee cannot be NULL!", &GA)do { if (!(Aliasee)) { CheckFailed("Aliasee cannot be NULL!",
&GA); return; } } while (false)
;
808 Assert(GA.getType() == Aliasee->getType(),do { if (!(GA.getType() == Aliasee->getType())) { CheckFailed
("Alias and aliasee types should match!", &GA); return; }
} while (false)
809 "Alias and aliasee types should match!", &GA)do { if (!(GA.getType() == Aliasee->getType())) { CheckFailed
("Alias and aliasee types should match!", &GA); return; }
} while (false)
;
810
811 Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),do { if (!(isa<GlobalValue>(Aliasee) || isa<ConstantExpr
>(Aliasee))) { CheckFailed("Aliasee should be either GlobalValue or ConstantExpr"
, &GA); return; } } while (false)
812 "Aliasee should be either GlobalValue or ConstantExpr", &GA)do { if (!(isa<GlobalValue>(Aliasee) || isa<ConstantExpr
>(Aliasee))) { CheckFailed("Aliasee should be either GlobalValue or ConstantExpr"
, &GA); return; } } while (false)
;
813
814 visitAliaseeSubExpr(GA, *Aliasee);
815
816 visitGlobalValue(GA);
817}
818
819void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
820 // There used to be various other llvm.dbg.* nodes, but we don't support
821 // upgrading them and we want to reserve the namespace for future uses.
822 if (NMD.getName().startswith("llvm.dbg."))
823 AssertDI(NMD.getName() == "llvm.dbg.cu",do { if (!(NMD.getName() == "llvm.dbg.cu")) { DebugInfoCheckFailed
("unrecognized named metadata node in the llvm.dbg namespace"
, &NMD); return; } } while (false)
824 "unrecognized named metadata node in the llvm.dbg namespace",do { if (!(NMD.getName() == "llvm.dbg.cu")) { DebugInfoCheckFailed
("unrecognized named metadata node in the llvm.dbg namespace"
, &NMD); return; } } while (false)
825 &NMD)do { if (!(NMD.getName() == "llvm.dbg.cu")) { DebugInfoCheckFailed
("unrecognized named metadata node in the llvm.dbg namespace"
, &NMD); return; } } while (false)
;
826 for (const MDNode *MD : NMD.operands()) {
827 if (NMD.getName() == "llvm.dbg.cu")
828 AssertDI(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD)do { if (!(MD && isa<DICompileUnit>(MD))) { DebugInfoCheckFailed
("invalid compile unit", &NMD, MD); return; } } while (false
)
;
829
830 if (!MD)
831 continue;
832
833 visitMDNode(*MD, AreDebugLocsAllowed::Yes);
834 }
835}
836
837void Verifier::visitMDNode(const MDNode &MD, AreDebugLocsAllowed AllowLocs) {
838 // Only visit each node once. Metadata can be mutually recursive, so this
839 // avoids infinite recursion here, as well as being an optimization.
840 if (!MDNodes.insert(&MD).second)
841 return;
842
843 Assert(&MD.getContext() == &Context,do { if (!(&MD.getContext() == &Context)) { CheckFailed
("MDNode context does not match Module context!", &MD); return
; } } while (false)
844 "MDNode context does not match Module context!", &MD)do { if (!(&MD.getContext() == &Context)) { CheckFailed
("MDNode context does not match Module context!", &MD); return
; } } while (false)
;
845
846 switch (MD.getMetadataID()) {
847 default:
848 llvm_unreachable("Invalid MDNode subclass")__builtin_unreachable();
849 case Metadata::MDTupleKind:
850 break;
851#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
852 case Metadata::CLASS##Kind: \
853 visit##CLASS(cast<CLASS>(MD)); \
854 break;
855#include "llvm/IR/Metadata.def"
856 }
857
858 for (const Metadata *Op : MD.operands()) {
859 if (!Op)
860 continue;
861 Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",do { if (!(!isa<LocalAsMetadata>(Op))) { CheckFailed("Invalid operand for global metadata!"
, &MD, Op); return; } } while (false)
862 &MD, Op)do { if (!(!isa<LocalAsMetadata>(Op))) { CheckFailed("Invalid operand for global metadata!"
, &MD, Op); return; } } while (false)
;
863 AssertDI(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed::Yes,do { if (!(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed
::Yes)) { DebugInfoCheckFailed("DILocation not allowed within this metadata node"
, &MD, Op); return; } } while (false)
864 "DILocation not allowed within this metadata node", &MD, Op)do { if (!(!isa<DILocation>(Op) || AllowLocs == AreDebugLocsAllowed
::Yes)) { DebugInfoCheckFailed("DILocation not allowed within this metadata node"
, &MD, Op); return; } } while (false)
;
865 if (auto *N = dyn_cast<MDNode>(Op)) {
866 visitMDNode(*N, AllowLocs);
867 continue;
868 }
869 if (auto *V = dyn_cast<ValueAsMetadata>(Op)) {
870 visitValueAsMetadata(*V, nullptr);
871 continue;
872 }
873 }
874
875 // Check these last, so we diagnose problems in operands first.
876 Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD)do { if (!(!MD.isTemporary())) { CheckFailed("Expected no forward declarations!"
, &MD); return; } } while (false)
;
877 Assert(MD.isResolved(), "All nodes should be resolved!", &MD)do { if (!(MD.isResolved())) { CheckFailed("All nodes should be resolved!"
, &MD); return; } } while (false)
;
878}
879
880void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
881 Assert(MD.getValue(), "Expected valid value", &MD)do { if (!(MD.getValue())) { CheckFailed("Expected valid value"
, &MD); return; } } while (false)
;
882 Assert(!MD.getValue()->getType()->isMetadataTy(),do { if (!(!MD.getValue()->getType()->isMetadataTy())) {
CheckFailed("Unexpected metadata round-trip through values",
&MD, MD.getValue()); return; } } while (false)
883 "Unexpected metadata round-trip through values", &MD, MD.getValue())do { if (!(!MD.getValue()->getType()->isMetadataTy())) {
CheckFailed("Unexpected metadata round-trip through values",
&MD, MD.getValue()); return; } } while (false)
;
884
885 auto *L = dyn_cast<LocalAsMetadata>(&MD);
886 if (!L)
887 return;
888
889 Assert(F, "function-local metadata used outside a function", L)do { if (!(F)) { CheckFailed("function-local metadata used outside a function"
, L); return; } } while (false)
;
890
891 // If this was an instruction, bb, or argument, verify that it is in the
892 // function that we expect.
893 Function *ActualF = nullptr;
894 if (Instruction *I = dyn_cast<Instruction>(L->getValue())) {
895 Assert(I->getParent(), "function-local metadata not in basic block", L, I)do { if (!(I->getParent())) { CheckFailed("function-local metadata not in basic block"
, L, I); return; } } while (false)
;
896 ActualF = I->getParent()->getParent();
897 } else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue()))
898 ActualF = BB->getParent();
899 else if (Argument *A = dyn_cast<Argument>(L->getValue()))
900 ActualF = A->getParent();
901 assert(ActualF && "Unimplemented function local metadata case!")(static_cast<void> (0));
902
903 Assert(ActualF == F, "function-local metadata used in wrong function", L)do { if (!(ActualF == F)) { CheckFailed("function-local metadata used in wrong function"
, L); return; } } while (false)
;
904}
905
906void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
907 Metadata *MD = MDV.getMetadata();
908 if (auto *N = dyn_cast<MDNode>(MD)) {
909 visitMDNode(*N, AreDebugLocsAllowed::No);
910 return;
911 }
912
913 // Only visit each node once. Metadata can be mutually recursive, so this
914 // avoids infinite recursion here, as well as being an optimization.
915 if (!MDNodes.insert(MD).second)
916 return;
917
918 if (auto *V = dyn_cast<ValueAsMetadata>(MD))
919 visitValueAsMetadata(*V, F);
920}
921
922static bool isType(const Metadata *MD) { return !MD || isa<DIType>(MD); }
923static bool isScope(const Metadata *MD) { return !MD || isa<DIScope>(MD); }
924static bool isDINode(const Metadata *MD) { return !MD || isa<DINode>(MD); }
925
926void Verifier::visitDILocation(const DILocation &N) {
927 AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("location requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
928 "location requires a valid scope", &N, N.getRawScope())do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("location requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
;
929 if (auto *IA = N.getRawInlinedAt())
930 AssertDI(isa<DILocation>(IA), "inlined-at should be a location", &N, IA)do { if (!(isa<DILocation>(IA))) { DebugInfoCheckFailed
("inlined-at should be a location", &N, IA); return; } } while
(false)
;
931 if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
932 AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N)do { if (!(SP->isDefinition())) { DebugInfoCheckFailed("scope points into the type hierarchy"
, &N); return; } } while (false)
;
933}
934
935void Verifier::visitGenericDINode(const GenericDINode &N) {
936 AssertDI(N.getTag(), "invalid tag", &N)do { if (!(N.getTag())) { DebugInfoCheckFailed("invalid tag",
&N); return; } } while (false)
;
937}
938
939void Verifier::visitDIScope(const DIScope &N) {
940 if (auto *F = N.getRawFile())
941 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
942}
943
944void Verifier::visitDISubrange(const DISubrange &N) {
945 AssertDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_subrange_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
946 bool HasAssumedSizedArraySupport = dwarf::isFortran(CurrentSourceLang);
947 AssertDI(HasAssumedSizedArraySupport || N.getRawCountNode() ||do { if (!(HasAssumedSizedArraySupport || N.getRawCountNode()
|| N.getRawUpperBound())) { DebugInfoCheckFailed("Subrange must contain count or upperBound"
, &N); return; } } while (false)
948 N.getRawUpperBound(),do { if (!(HasAssumedSizedArraySupport || N.getRawCountNode()
|| N.getRawUpperBound())) { DebugInfoCheckFailed("Subrange must contain count or upperBound"
, &N); return; } } while (false)
949 "Subrange must contain count or upperBound", &N)do { if (!(HasAssumedSizedArraySupport || N.getRawCountNode()
|| N.getRawUpperBound())) { DebugInfoCheckFailed("Subrange must contain count or upperBound"
, &N); return; } } while (false)
;
950 AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(),do { if (!(!N.getRawCountNode() || !N.getRawUpperBound())) { DebugInfoCheckFailed
("Subrange can have any one of count or upperBound", &N);
return; } } while (false)
951 "Subrange can have any one of count or upperBound", &N)do { if (!(!N.getRawCountNode() || !N.getRawUpperBound())) { DebugInfoCheckFailed
("Subrange can have any one of count or upperBound", &N);
return; } } while (false)
;
952 auto *CBound = N.getRawCountNode();
953 AssertDI(!CBound || isa<ConstantAsMetadata>(CBound) ||do { if (!(!CBound || isa<ConstantAsMetadata>(CBound) ||
isa<DIVariable>(CBound) || isa<DIExpression>(CBound
))) { DebugInfoCheckFailed("Count must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
954 isa<DIVariable>(CBound) || isa<DIExpression>(CBound),do { if (!(!CBound || isa<ConstantAsMetadata>(CBound) ||
isa<DIVariable>(CBound) || isa<DIExpression>(CBound
))) { DebugInfoCheckFailed("Count must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
955 "Count must be signed constant or DIVariable or DIExpression", &N)do { if (!(!CBound || isa<ConstantAsMetadata>(CBound) ||
isa<DIVariable>(CBound) || isa<DIExpression>(CBound
))) { DebugInfoCheckFailed("Count must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
956 auto Count = N.getCount();
957 AssertDI(!Count || !Count.is<ConstantInt *>() ||do { if (!(!Count || !Count.is<ConstantInt *>() || Count
.get<ConstantInt *>()->getSExtValue() >= -1)) { DebugInfoCheckFailed
("invalid subrange count", &N); return; } } while (false)
958 Count.get<ConstantInt *>()->getSExtValue() >= -1,do { if (!(!Count || !Count.is<ConstantInt *>() || Count
.get<ConstantInt *>()->getSExtValue() >= -1)) { DebugInfoCheckFailed
("invalid subrange count", &N); return; } } while (false)
959 "invalid subrange count", &N)do { if (!(!Count || !Count.is<ConstantInt *>() || Count
.get<ConstantInt *>()->getSExtValue() >= -1)) { DebugInfoCheckFailed
("invalid subrange count", &N); return; } } while (false)
;
960 auto *LBound = N.getRawLowerBound();
961 AssertDI(!LBound || isa<ConstantAsMetadata>(LBound) ||do { if (!(!LBound || isa<ConstantAsMetadata>(LBound) ||
isa<DIVariable>(LBound) || isa<DIExpression>(LBound
))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
962 isa<DIVariable>(LBound) || isa<DIExpression>(LBound),do { if (!(!LBound || isa<ConstantAsMetadata>(LBound) ||
isa<DIVariable>(LBound) || isa<DIExpression>(LBound
))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
963 "LowerBound must be signed constant or DIVariable or DIExpression",do { if (!(!LBound || isa<ConstantAsMetadata>(LBound) ||
isa<DIVariable>(LBound) || isa<DIExpression>(LBound
))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
964 &N)do { if (!(!LBound || isa<ConstantAsMetadata>(LBound) ||
isa<DIVariable>(LBound) || isa<DIExpression>(LBound
))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
965 auto *UBound = N.getRawUpperBound();
966 AssertDI(!UBound || isa<ConstantAsMetadata>(UBound) ||do { if (!(!UBound || isa<ConstantAsMetadata>(UBound) ||
isa<DIVariable>(UBound) || isa<DIExpression>(UBound
))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
967 isa<DIVariable>(UBound) || isa<DIExpression>(UBound),do { if (!(!UBound || isa<ConstantAsMetadata>(UBound) ||
isa<DIVariable>(UBound) || isa<DIExpression>(UBound
))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
968 "UpperBound must be signed constant or DIVariable or DIExpression",do { if (!(!UBound || isa<ConstantAsMetadata>(UBound) ||
isa<DIVariable>(UBound) || isa<DIExpression>(UBound
))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
969 &N)do { if (!(!UBound || isa<ConstantAsMetadata>(UBound) ||
isa<DIVariable>(UBound) || isa<DIExpression>(UBound
))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
970 auto *Stride = N.getRawStride();
971 AssertDI(!Stride || isa<ConstantAsMetadata>(Stride) ||do { if (!(!Stride || isa<ConstantAsMetadata>(Stride) ||
isa<DIVariable>(Stride) || isa<DIExpression>(Stride
))) { DebugInfoCheckFailed("Stride must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
972 isa<DIVariable>(Stride) || isa<DIExpression>(Stride),do { if (!(!Stride || isa<ConstantAsMetadata>(Stride) ||
isa<DIVariable>(Stride) || isa<DIExpression>(Stride
))) { DebugInfoCheckFailed("Stride must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
973 "Stride must be signed constant or DIVariable or DIExpression", &N)do { if (!(!Stride || isa<ConstantAsMetadata>(Stride) ||
isa<DIVariable>(Stride) || isa<DIExpression>(Stride
))) { DebugInfoCheckFailed("Stride must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
974}
975
976void Verifier::visitDIGenericSubrange(const DIGenericSubrange &N) {
977 AssertDI(N.getTag() == dwarf::DW_TAG_generic_subrange, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_generic_subrange)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
978 AssertDI(N.getRawCountNode() || N.getRawUpperBound(),do { if (!(N.getRawCountNode() || N.getRawUpperBound())) { DebugInfoCheckFailed
("GenericSubrange must contain count or upperBound", &N);
return; } } while (false)
979 "GenericSubrange must contain count or upperBound", &N)do { if (!(N.getRawCountNode() || N.getRawUpperBound())) { DebugInfoCheckFailed
("GenericSubrange must contain count or upperBound", &N);
return; } } while (false)
;
980 AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(),do { if (!(!N.getRawCountNode() || !N.getRawUpperBound())) { DebugInfoCheckFailed
("GenericSubrange can have any one of count or upperBound", &
N); return; } } while (false)
981 "GenericSubrange can have any one of count or upperBound", &N)do { if (!(!N.getRawCountNode() || !N.getRawUpperBound())) { DebugInfoCheckFailed
("GenericSubrange can have any one of count or upperBound", &
N); return; } } while (false)
;
982 auto *CBound = N.getRawCountNode();
983 AssertDI(!CBound || isa<DIVariable>(CBound) || isa<DIExpression>(CBound),do { if (!(!CBound || isa<DIVariable>(CBound) || isa<
DIExpression>(CBound))) { DebugInfoCheckFailed("Count must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
984 "Count must be signed constant or DIVariable or DIExpression", &N)do { if (!(!CBound || isa<DIVariable>(CBound) || isa<
DIExpression>(CBound))) { DebugInfoCheckFailed("Count must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
985 auto *LBound = N.getRawLowerBound();
986 AssertDI(LBound, "GenericSubrange must contain lowerBound", &N)do { if (!(LBound)) { DebugInfoCheckFailed("GenericSubrange must contain lowerBound"
, &N); return; } } while (false)
;
987 AssertDI(isa<DIVariable>(LBound) || isa<DIExpression>(LBound),do { if (!(isa<DIVariable>(LBound) || isa<DIExpression
>(LBound))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
988 "LowerBound must be signed constant or DIVariable or DIExpression",do { if (!(isa<DIVariable>(LBound) || isa<DIExpression
>(LBound))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
989 &N)do { if (!(isa<DIVariable>(LBound) || isa<DIExpression
>(LBound))) { DebugInfoCheckFailed("LowerBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
990 auto *UBound = N.getRawUpperBound();
991 AssertDI(!UBound || isa<DIVariable>(UBound) || isa<DIExpression>(UBound),do { if (!(!UBound || isa<DIVariable>(UBound) || isa<
DIExpression>(UBound))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
992 "UpperBound must be signed constant or DIVariable or DIExpression",do { if (!(!UBound || isa<DIVariable>(UBound) || isa<
DIExpression>(UBound))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
993 &N)do { if (!(!UBound || isa<DIVariable>(UBound) || isa<
DIExpression>(UBound))) { DebugInfoCheckFailed("UpperBound must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
994 auto *Stride = N.getRawStride();
995 AssertDI(Stride, "GenericSubrange must contain stride", &N)do { if (!(Stride)) { DebugInfoCheckFailed("GenericSubrange must contain stride"
, &N); return; } } while (false)
;
996 AssertDI(isa<DIVariable>(Stride) || isa<DIExpression>(Stride),do { if (!(isa<DIVariable>(Stride) || isa<DIExpression
>(Stride))) { DebugInfoCheckFailed("Stride must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
997 "Stride must be signed constant or DIVariable or DIExpression", &N)do { if (!(isa<DIVariable>(Stride) || isa<DIExpression
>(Stride))) { DebugInfoCheckFailed("Stride must be signed constant or DIVariable or DIExpression"
, &N); return; } } while (false)
;
998}
999
1000void Verifier::visitDIEnumerator(const DIEnumerator &N) {
1001 AssertDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_enumerator)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1002}
1003
1004void Verifier::visitDIBasicType(const DIBasicType &N) {
1005 AssertDI(N.getTag() == dwarf::DW_TAG_base_type ||do { if (!(N.getTag() == dwarf::DW_TAG_base_type || N.getTag(
) == dwarf::DW_TAG_unspecified_type || N.getTag() == dwarf::DW_TAG_string_type
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1006 N.getTag() == dwarf::DW_TAG_unspecified_type ||do { if (!(N.getTag() == dwarf::DW_TAG_base_type || N.getTag(
) == dwarf::DW_TAG_unspecified_type || N.getTag() == dwarf::DW_TAG_string_type
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1007 N.getTag() == dwarf::DW_TAG_string_type,do { if (!(N.getTag() == dwarf::DW_TAG_base_type || N.getTag(
) == dwarf::DW_TAG_unspecified_type || N.getTag() == dwarf::DW_TAG_string_type
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1008 "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_base_type || N.getTag(
) == dwarf::DW_TAG_unspecified_type || N.getTag() == dwarf::DW_TAG_string_type
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
;
1009}
1010
1011void Verifier::visitDIStringType(const DIStringType &N) {
1012 AssertDI(N.getTag() == dwarf::DW_TAG_string_type, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_string_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1013 AssertDI(!(N.isBigEndian() && N.isLittleEndian()) ,do { if (!(!(N.isBigEndian() && N.isLittleEndian())))
{ DebugInfoCheckFailed("has conflicting flags", &N); return
; } } while (false)
1014 "has conflicting flags", &N)do { if (!(!(N.isBigEndian() && N.isLittleEndian())))
{ DebugInfoCheckFailed("has conflicting flags", &N); return
; } } while (false)
;
1015}
1016
1017void Verifier::visitDIDerivedType(const DIDerivedType &N) {
1018 // Common scope checks.
1019 visitDIScope(N);
1020
1021 AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1022 N.getTag() == dwarf::DW_TAG_pointer_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1023 N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1024 N.getTag() == dwarf::DW_TAG_reference_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1025 N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1026 N.getTag() == dwarf::DW_TAG_const_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1027 N.getTag() == dwarf::DW_TAG_volatile_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1028 N.getTag() == dwarf::DW_TAG_restrict_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1029 N.getTag() == dwarf::DW_TAG_atomic_type ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1030 N.getTag() == dwarf::DW_TAG_member ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1031 N.getTag() == dwarf::DW_TAG_inheritance ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1032 N.getTag() == dwarf::DW_TAG_friend ||do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1033 N.getTag() == dwarf::DW_TAG_set_type,do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1034 "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() ==
dwarf::DW_TAG_pointer_type || N.getTag() == dwarf::DW_TAG_ptr_to_member_type
|| N.getTag() == dwarf::DW_TAG_reference_type || N.getTag() ==
dwarf::DW_TAG_rvalue_reference_type || N.getTag() == dwarf::
DW_TAG_const_type || N.getTag() == dwarf::DW_TAG_volatile_type
|| N.getTag() == dwarf::DW_TAG_restrict_type || N.getTag() ==
dwarf::DW_TAG_atomic_type || N.getTag() == dwarf::DW_TAG_member
|| N.getTag() == dwarf::DW_TAG_inheritance || N.getTag() == dwarf
::DW_TAG_friend || N.getTag() == dwarf::DW_TAG_set_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1035 if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
1036 AssertDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,do { if (!(isType(N.getRawExtraData()))) { DebugInfoCheckFailed
("invalid pointer to member type", &N, N.getRawExtraData(
)); return; } } while (false)
1037 N.getRawExtraData())do { if (!(isType(N.getRawExtraData()))) { DebugInfoCheckFailed
("invalid pointer to member type", &N, N.getRawExtraData(
)); return; } } while (false)
;
1038 }
1039
1040 if (N.getTag() == dwarf::DW_TAG_set_type) {
1041 if (auto *T = N.getRawBaseType()) {
1042 auto *Enum = dyn_cast_or_null<DICompositeType>(T);
1043 auto *Basic = dyn_cast_or_null<DIBasicType>(T);
1044 AssertDI(do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1045 (Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type) ||do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1046 (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned ||do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1047 Basic->getEncoding() == dwarf::DW_ATE_signed ||do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1048 Basic->getEncoding() == dwarf::DW_ATE_unsigned_char ||do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1049 Basic->getEncoding() == dwarf::DW_ATE_signed_char ||do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1050 Basic->getEncoding() == dwarf::DW_ATE_boolean)),do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
1051 "invalid set base type", &N, T)do { if (!((Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
) || (Basic && (Basic->getEncoding() == dwarf::DW_ATE_unsigned
|| Basic->getEncoding() == dwarf::DW_ATE_signed || Basic->
getEncoding() == dwarf::DW_ATE_unsigned_char || Basic->getEncoding
() == dwarf::DW_ATE_signed_char || Basic->getEncoding() ==
dwarf::DW_ATE_boolean)))) { DebugInfoCheckFailed("invalid set base type"
, &N, T); return; } } while (false)
;
1052 }
1053 }
1054
1055 AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope())do { if (!(isScope(N.getRawScope()))) { DebugInfoCheckFailed(
"invalid scope", &N, N.getRawScope()); return; } } while (
false)
;
1056 AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,do { if (!(isType(N.getRawBaseType()))) { DebugInfoCheckFailed
("invalid base type", &N, N.getRawBaseType()); return; } }
while (false)
1057 N.getRawBaseType())do { if (!(isType(N.getRawBaseType()))) { DebugInfoCheckFailed
("invalid base type", &N, N.getRawBaseType()); return; } }
while (false)
;
1058
1059 if (N.getDWARFAddressSpace()) {
1060 AssertDI(N.getTag() == dwarf::DW_TAG_pointer_type ||do { if (!(N.getTag() == dwarf::DW_TAG_pointer_type || N.getTag
() == dwarf::DW_TAG_reference_type || N.getTag() == dwarf::DW_TAG_rvalue_reference_type
)) { DebugInfoCheckFailed("DWARF address space only applies to pointer or reference types"
, &N); return; } } while (false)
1061 N.getTag() == dwarf::DW_TAG_reference_type ||do { if (!(N.getTag() == dwarf::DW_TAG_pointer_type || N.getTag
() == dwarf::DW_TAG_reference_type || N.getTag() == dwarf::DW_TAG_rvalue_reference_type
)) { DebugInfoCheckFailed("DWARF address space only applies to pointer or reference types"
, &N); return; } } while (false)
1062 N.getTag() == dwarf::DW_TAG_rvalue_reference_type,do { if (!(N.getTag() == dwarf::DW_TAG_pointer_type || N.getTag
() == dwarf::DW_TAG_reference_type || N.getTag() == dwarf::DW_TAG_rvalue_reference_type
)) { DebugInfoCheckFailed("DWARF address space only applies to pointer or reference types"
, &N); return; } } while (false)
1063 "DWARF address space only applies to pointer or reference types",do { if (!(N.getTag() == dwarf::DW_TAG_pointer_type || N.getTag
() == dwarf::DW_TAG_reference_type || N.getTag() == dwarf::DW_TAG_rvalue_reference_type
)) { DebugInfoCheckFailed("DWARF address space only applies to pointer or reference types"
, &N); return; } } while (false)
1064 &N)do { if (!(N.getTag() == dwarf::DW_TAG_pointer_type || N.getTag
() == dwarf::DW_TAG_reference_type || N.getTag() == dwarf::DW_TAG_rvalue_reference_type
)) { DebugInfoCheckFailed("DWARF address space only applies to pointer or reference types"
, &N); return; } } while (false)
;
1065 }
1066}
1067
1068/// Detect mutually exclusive flags.
1069static bool hasConflictingReferenceFlags(unsigned Flags) {
1070 return ((Flags & DINode::FlagLValueReference) &&
1071 (Flags & DINode::FlagRValueReference)) ||
1072 ((Flags & DINode::FlagTypePassByValue) &&
1073 (Flags & DINode::FlagTypePassByReference));
1074}
1075
1076void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
1077 auto *Params = dyn_cast<MDTuple>(&RawParams);
1078 AssertDI(Params, "invalid template params", &N, &RawParams)do { if (!(Params)) { DebugInfoCheckFailed("invalid template params"
, &N, &RawParams); return; } } while (false)
;
1079 for (Metadata *Op : Params->operands()) {
1080 AssertDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",do { if (!(Op && isa<DITemplateParameter>(Op)))
{ DebugInfoCheckFailed("invalid template parameter", &N,
Params, Op); return; } } while (false)
1081 &N, Params, Op)do { if (!(Op && isa<DITemplateParameter>(Op)))
{ DebugInfoCheckFailed("invalid template parameter", &N,
Params, Op); return; } } while (false)
;
1082 }
1083}
1084
1085void Verifier::visitDICompositeType(const DICompositeType &N) {
1086 // Common scope checks.
1087 visitDIScope(N);
1088
1089 AssertDI(N.getTag() == dwarf::DW_TAG_array_type ||do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1090 N.getTag() == dwarf::DW_TAG_structure_type ||do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1091 N.getTag() == dwarf::DW_TAG_union_type ||do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1092 N.getTag() == dwarf::DW_TAG_enumeration_type ||do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1093 N.getTag() == dwarf::DW_TAG_class_type ||do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1094 N.getTag() == dwarf::DW_TAG_variant_part,do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1095 "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_array_type || N.getTag
() == dwarf::DW_TAG_structure_type || N.getTag() == dwarf::DW_TAG_union_type
|| N.getTag() == dwarf::DW_TAG_enumeration_type || N.getTag(
) == dwarf::DW_TAG_class_type || N.getTag() == dwarf::DW_TAG_variant_part
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
;
1096
1097 AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope())do { if (!(isScope(N.getRawScope()))) { DebugInfoCheckFailed(
"invalid scope", &N, N.getRawScope()); return; } } while (
false)
;
1098 AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,do { if (!(isType(N.getRawBaseType()))) { DebugInfoCheckFailed
("invalid base type", &N, N.getRawBaseType()); return; } }
while (false)
1099 N.getRawBaseType())do { if (!(isType(N.getRawBaseType()))) { DebugInfoCheckFailed
("invalid base type", &N, N.getRawBaseType()); return; } }
while (false)
;
1100
1101 AssertDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),do { if (!(!N.getRawElements() || isa<MDTuple>(N.getRawElements
()))) { DebugInfoCheckFailed("invalid composite elements", &
N, N.getRawElements()); return; } } while (false)
1102 "invalid composite elements", &N, N.getRawElements())do { if (!(!N.getRawElements() || isa<MDTuple>(N.getRawElements
()))) { DebugInfoCheckFailed("invalid composite elements", &
N, N.getRawElements()); return; } } while (false)
;
1103 AssertDI(isType(N.getRawVTableHolder()), "invalid vtable holder", &N,do { if (!(isType(N.getRawVTableHolder()))) { DebugInfoCheckFailed
("invalid vtable holder", &N, N.getRawVTableHolder()); return
; } } while (false)
1104 N.getRawVTableHolder())do { if (!(isType(N.getRawVTableHolder()))) { DebugInfoCheckFailed
("invalid vtable holder", &N, N.getRawVTableHolder()); return
; } } while (false)
;
1105 AssertDI(!hasConflictingReferenceFlags(N.getFlags()),do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
1106 "invalid reference flags", &N)do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
;
1107 unsigned DIBlockByRefStruct = 1 << 4;
1108 AssertDI((N.getFlags() & DIBlockByRefStruct) == 0,do { if (!((N.getFlags() & DIBlockByRefStruct) == 0)) { DebugInfoCheckFailed
("DIBlockByRefStruct on DICompositeType is no longer supported"
, &N); return; } } while (false)
1109 "DIBlockByRefStruct on DICompositeType is no longer supported", &N)do { if (!((N.getFlags() & DIBlockByRefStruct) == 0)) { DebugInfoCheckFailed
("DIBlockByRefStruct on DICompositeType is no longer supported"
, &N); return; } } while (false)
;
1110
1111 if (N.isVector()) {
1112 const DINodeArray Elements = N.getElements();
1113 AssertDI(Elements.size() == 1 &&do { if (!(Elements.size() == 1 && Elements[0]->getTag
() == dwarf::DW_TAG_subrange_type)) { DebugInfoCheckFailed("invalid vector, expected one element of type subrange"
, &N); return; } } while (false)
1114 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type,do { if (!(Elements.size() == 1 && Elements[0]->getTag
() == dwarf::DW_TAG_subrange_type)) { DebugInfoCheckFailed("invalid vector, expected one element of type subrange"
, &N); return; } } while (false)
1115 "invalid vector, expected one element of type subrange", &N)do { if (!(Elements.size() == 1 && Elements[0]->getTag
() == dwarf::DW_TAG_subrange_type)) { DebugInfoCheckFailed("invalid vector, expected one element of type subrange"
, &N); return; } } while (false)
;
1116 }
1117
1118 if (auto *Params = N.getRawTemplateParams())
1119 visitTemplateParams(N, *Params);
1120
1121 if (auto *D = N.getRawDiscriminator()) {
1122 AssertDI(isa<DIDerivedType>(D) && N.getTag() == dwarf::DW_TAG_variant_part,do { if (!(isa<DIDerivedType>(D) && N.getTag() ==
dwarf::DW_TAG_variant_part)) { DebugInfoCheckFailed("discriminator can only appear on variant part"
); return; } } while (false)
1123 "discriminator can only appear on variant part")do { if (!(isa<DIDerivedType>(D) && N.getTag() ==
dwarf::DW_TAG_variant_part)) { DebugInfoCheckFailed("discriminator can only appear on variant part"
); return; } } while (false)
;
1124 }
1125
1126 if (N.getRawDataLocation()) {
1127 AssertDI(N.getTag() == dwarf::DW_TAG_array_type,do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("dataLocation can only appear in array type"); return; } } while
(false)
1128 "dataLocation can only appear in array type")do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("dataLocation can only appear in array type"); return; } } while
(false)
;
1129 }
1130
1131 if (N.getRawAssociated()) {
1132 AssertDI(N.getTag() == dwarf::DW_TAG_array_type,do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("associated can only appear in array type"); return; } } while
(false)
1133 "associated can only appear in array type")do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("associated can only appear in array type"); return; } } while
(false)
;
1134 }
1135
1136 if (N.getRawAllocated()) {
1137 AssertDI(N.getTag() == dwarf::DW_TAG_array_type,do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("allocated can only appear in array type"); return; } } while
(false)
1138 "allocated can only appear in array type")do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("allocated can only appear in array type"); return; } } while
(false)
;
1139 }
1140
1141 if (N.getRawRank()) {
1142 AssertDI(N.getTag() == dwarf::DW_TAG_array_type,do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("rank can only appear in array type"); return; } } while (false
)
1143 "rank can only appear in array type")do { if (!(N.getTag() == dwarf::DW_TAG_array_type)) { DebugInfoCheckFailed
("rank can only appear in array type"); return; } } while (false
)
;
1144 }
1145}
1146
1147void Verifier::visitDISubroutineType(const DISubroutineType &N) {
1148 AssertDI(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_subroutine_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1149 if (auto *Types = N.getRawTypeArray()) {
1150 AssertDI(isa<MDTuple>(Types), "invalid composite elements", &N, Types)do { if (!(isa<MDTuple>(Types))) { DebugInfoCheckFailed
("invalid composite elements", &N, Types); return; } } while
(false)
;
1151 for (Metadata *Ty : N.getTypeArray()->operands()) {
1152 AssertDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty)do { if (!(isType(Ty))) { DebugInfoCheckFailed("invalid subroutine type ref"
, &N, Types, Ty); return; } } while (false)
;
1153 }
1154 }
1155 AssertDI(!hasConflictingReferenceFlags(N.getFlags()),do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
1156 "invalid reference flags", &N)do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
;
1157}
1158
1159void Verifier::visitDIFile(const DIFile &N) {
1160 AssertDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_file_type)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1161 Optional<DIFile::ChecksumInfo<StringRef>> Checksum = N.getChecksum();
1162 if (Checksum) {
1163 AssertDI(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last,do { if (!(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last
)) { DebugInfoCheckFailed("invalid checksum kind", &N); return
; } } while (false)
1164 "invalid checksum kind", &N)do { if (!(Checksum->Kind <= DIFile::ChecksumKind::CSK_Last
)) { DebugInfoCheckFailed("invalid checksum kind", &N); return
; } } while (false)
;
1165 size_t Size;
1166 switch (Checksum->Kind) {
1167 case DIFile::CSK_MD5:
1168 Size = 32;
1169 break;
1170 case DIFile::CSK_SHA1:
1171 Size = 40;
1172 break;
1173 case DIFile::CSK_SHA256:
1174 Size = 64;
1175 break;
1176 }
1177 AssertDI(Checksum->Value.size() == Size, "invalid checksum length", &N)do { if (!(Checksum->Value.size() == Size)) { DebugInfoCheckFailed
("invalid checksum length", &N); return; } } while (false
)
;
1178 AssertDI(Checksum->Value.find_if_not(llvm::isHexDigit) == StringRef::npos,do { if (!(Checksum->Value.find_if_not(llvm::isHexDigit) ==
StringRef::npos)) { DebugInfoCheckFailed("invalid checksum",
&N); return; } } while (false)
1179 "invalid checksum", &N)do { if (!(Checksum->Value.find_if_not(llvm::isHexDigit) ==
StringRef::npos)) { DebugInfoCheckFailed("invalid checksum",
&N); return; } } while (false)
;
1180 }
1181}
1182
1183void Verifier::visitDICompileUnit(const DICompileUnit &N) {
1184 AssertDI(N.isDistinct(), "compile units must be distinct", &N)do { if (!(N.isDistinct())) { DebugInfoCheckFailed("compile units must be distinct"
, &N); return; } } while (false)
;
1185 AssertDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_compile_unit)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1186
1187 // Don't bother verifying the compilation directory or producer string
1188 // as those could be empty.
1189 AssertDI(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N,do { if (!(N.getRawFile() && isa<DIFile>(N.getRawFile
()))) { DebugInfoCheckFailed("invalid file", &N, N.getRawFile
()); return; } } while (false)
1190 N.getRawFile())do { if (!(N.getRawFile() && isa<DIFile>(N.getRawFile
()))) { DebugInfoCheckFailed("invalid file", &N, N.getRawFile
()); return; } } while (false)
;
1191 AssertDI(!N.getFile()->getFilename().empty(), "invalid filename", &N,do { if (!(!N.getFile()->getFilename().empty())) { DebugInfoCheckFailed
("invalid filename", &N, N.getFile()); return; } } while (
false)
1192 N.getFile())do { if (!(!N.getFile()->getFilename().empty())) { DebugInfoCheckFailed
("invalid filename", &N, N.getFile()); return; } } while (
false)
;
1193
1194 CurrentSourceLang = (dwarf::SourceLanguage)N.getSourceLanguage();
1195
1196 verifySourceDebugInfo(N, *N.getFile());
1197
1198 AssertDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),do { if (!((N.getEmissionKind() <= DICompileUnit::LastEmissionKind
))) { DebugInfoCheckFailed("invalid emission kind", &N); return
; } } while (false)
1199 "invalid emission kind", &N)do { if (!((N.getEmissionKind() <= DICompileUnit::LastEmissionKind
))) { DebugInfoCheckFailed("invalid emission kind", &N); return
; } } while (false)
;
1200
1201 if (auto *Array = N.getRawEnumTypes()) {
1202 AssertDI(isa<MDTuple>(Array), "invalid enum list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid enum list", &N, Array); return; } } while (false
)
;
1203 for (Metadata *Op : N.getEnumTypes()->operands()) {
1204 auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
1205 AssertDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,do { if (!(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
)) { DebugInfoCheckFailed("invalid enum type", &N, N.getEnumTypes
(), Op); return; } } while (false)
1206 "invalid enum type", &N, N.getEnumTypes(), Op)do { if (!(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type
)) { DebugInfoCheckFailed("invalid enum type", &N, N.getEnumTypes
(), Op); return; } } while (false)
;
1207 }
1208 }
1209 if (auto *Array = N.getRawRetainedTypes()) {
1210 AssertDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid retained type list", &N, Array); return; } } while
(false)
;
1211 for (Metadata *Op : N.getRetainedTypes()->operands()) {
1212 AssertDI(Op && (isa<DIType>(Op) ||do { if (!(Op && (isa<DIType>(Op) || (isa<DISubprogram
>(Op) && !cast<DISubprogram>(Op)->isDefinition
())))) { DebugInfoCheckFailed("invalid retained type", &N
, Op); return; } } while (false)
1213 (isa<DISubprogram>(Op) &&do { if (!(Op && (isa<DIType>(Op) || (isa<DISubprogram
>(Op) && !cast<DISubprogram>(Op)->isDefinition
())))) { DebugInfoCheckFailed("invalid retained type", &N
, Op); return; } } while (false)
1214 !cast<DISubprogram>(Op)->isDefinition())),do { if (!(Op && (isa<DIType>(Op) || (isa<DISubprogram
>(Op) && !cast<DISubprogram>(Op)->isDefinition
())))) { DebugInfoCheckFailed("invalid retained type", &N
, Op); return; } } while (false)
1215 "invalid retained type", &N, Op)do { if (!(Op && (isa<DIType>(Op) || (isa<DISubprogram
>(Op) && !cast<DISubprogram>(Op)->isDefinition
())))) { DebugInfoCheckFailed("invalid retained type", &N
, Op); return; } } while (false)
;
1216 }
1217 }
1218 if (auto *Array = N.getRawGlobalVariables()) {
1219 AssertDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid global variable list", &N, Array); return; } } while
(false)
;
1220 for (Metadata *Op : N.getGlobalVariables()->operands()) {
1221 AssertDI(Op && (isa<DIGlobalVariableExpression>(Op)),do { if (!(Op && (isa<DIGlobalVariableExpression>
(Op)))) { DebugInfoCheckFailed("invalid global variable ref",
&N, Op); return; } } while (false)
1222 "invalid global variable ref", &N, Op)do { if (!(Op && (isa<DIGlobalVariableExpression>
(Op)))) { DebugInfoCheckFailed("invalid global variable ref",
&N, Op); return; } } while (false)
;
1223 }
1224 }
1225 if (auto *Array = N.getRawImportedEntities()) {
1226 AssertDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid imported entity list", &N, Array); return; } } while
(false)
;
1227 for (Metadata *Op : N.getImportedEntities()->operands()) {
1228 AssertDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",do { if (!(Op && isa<DIImportedEntity>(Op))) { DebugInfoCheckFailed
("invalid imported entity ref", &N, Op); return; } } while
(false)
1229 &N, Op)do { if (!(Op && isa<DIImportedEntity>(Op))) { DebugInfoCheckFailed
("invalid imported entity ref", &N, Op); return; } } while
(false)
;
1230 }
1231 }
1232 if (auto *Array = N.getRawMacros()) {
1233 AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid macro list", &N, Array); return; } } while (false
)
;
1234 for (Metadata *Op : N.getMacros()->operands()) {
1235 AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op)do { if (!(Op && isa<DIMacroNode>(Op))) { DebugInfoCheckFailed
("invalid macro ref", &N, Op); return; } } while (false)
;
1236 }
1237 }
1238 CUVisited.insert(&N);
1239}
1240
1241void Verifier::visitDISubprogram(const DISubprogram &N) {
1242 AssertDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_subprogram)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1243 AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope())do { if (!(isScope(N.getRawScope()))) { DebugInfoCheckFailed(
"invalid scope", &N, N.getRawScope()); return; } } while (
false)
;
1244 if (auto *F = N.getRawFile())
1245 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
1246 else
1247 AssertDI(N.getLine() == 0, "line specified with no file", &N, N.getLine())do { if (!(N.getLine() == 0)) { DebugInfoCheckFailed("line specified with no file"
, &N, N.getLine()); return; } } while (false)
;
1248 if (auto *T = N.getRawType())
1249 AssertDI(isa<DISubroutineType>(T), "invalid subroutine type", &N, T)do { if (!(isa<DISubroutineType>(T))) { DebugInfoCheckFailed
("invalid subroutine type", &N, T); return; } } while (false
)
;
1250 AssertDI(isType(N.getRawContainingType()), "invalid containing type", &N,do { if (!(isType(N.getRawContainingType()))) { DebugInfoCheckFailed
("invalid containing type", &N, N.getRawContainingType())
; return; } } while (false)
1251 N.getRawContainingType())do { if (!(isType(N.getRawContainingType()))) { DebugInfoCheckFailed
("invalid containing type", &N, N.getRawContainingType())
; return; } } while (false)
;
1252 if (auto *Params = N.getRawTemplateParams())
1253 visitTemplateParams(N, *Params);
1254 if (auto *S = N.getRawDeclaration())
1255 AssertDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),do { if (!(isa<DISubprogram>(S) && !cast<DISubprogram
>(S)->isDefinition())) { DebugInfoCheckFailed("invalid subprogram declaration"
, &N, S); return; } } while (false)
1256 "invalid subprogram declaration", &N, S)do { if (!(isa<DISubprogram>(S) && !cast<DISubprogram
>(S)->isDefinition())) { DebugInfoCheckFailed("invalid subprogram declaration"
, &N, S); return; } } while (false)
;
1257 if (auto *RawNode = N.getRawRetainedNodes()) {
1258 auto *Node = dyn_cast<MDTuple>(RawNode);
1259 AssertDI(Node, "invalid retained nodes list", &N, RawNode)do { if (!(Node)) { DebugInfoCheckFailed("invalid retained nodes list"
, &N, RawNode); return; } } while (false)
;
1260 for (Metadata *Op : Node->operands()) {
1261 AssertDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op)),do { if (!(Op && (isa<DILocalVariable>(Op) || isa
<DILabel>(Op)))) { DebugInfoCheckFailed("invalid retained nodes, expected DILocalVariable or DILabel"
, &N, Node, Op); return; } } while (false)
1262 "invalid retained nodes, expected DILocalVariable or DILabel",do { if (!(Op && (isa<DILocalVariable>(Op) || isa
<DILabel>(Op)))) { DebugInfoCheckFailed("invalid retained nodes, expected DILocalVariable or DILabel"
, &N, Node, Op); return; } } while (false)
1263 &N, Node, Op)do { if (!(Op && (isa<DILocalVariable>(Op) || isa
<DILabel>(Op)))) { DebugInfoCheckFailed("invalid retained nodes, expected DILocalVariable or DILabel"
, &N, Node, Op); return; } } while (false)
;
1264 }
1265 }
1266 AssertDI(!hasConflictingReferenceFlags(N.getFlags()),do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
1267 "invalid reference flags", &N)do { if (!(!hasConflictingReferenceFlags(N.getFlags()))) { DebugInfoCheckFailed
("invalid reference flags", &N); return; } } while (false
)
;
1268
1269 auto *Unit = N.getRawUnit();
1270 if (N.isDefinition()) {
1271 // Subprogram definitions (not part of the type hierarchy).
1272 AssertDI(N.isDistinct(), "subprogram definitions must be distinct", &N)do { if (!(N.isDistinct())) { DebugInfoCheckFailed("subprogram definitions must be distinct"
, &N); return; } } while (false)
;
1273 AssertDI(Unit, "subprogram definitions must have a compile unit", &N)do { if (!(Unit)) { DebugInfoCheckFailed("subprogram definitions must have a compile unit"
, &N); return; } } while (false)
;
1274 AssertDI(isa<DICompileUnit>(Unit), "invalid unit type", &N, Unit)do { if (!(isa<DICompileUnit>(Unit))) { DebugInfoCheckFailed
("invalid unit type", &N, Unit); return; } } while (false
)
;
1275 if (N.getFile())
1276 verifySourceDebugInfo(*N.getUnit(), *N.getFile());
1277 } else {
1278 // Subprogram declarations (part of the type hierarchy).
1279 AssertDI(!Unit, "subprogram declarations must not have a compile unit", &N)do { if (!(!Unit)) { DebugInfoCheckFailed("subprogram declarations must not have a compile unit"
, &N); return; } } while (false)
;
1280 }
1281
1282 if (auto *RawThrownTypes = N.getRawThrownTypes()) {
1283 auto *ThrownTypes = dyn_cast<MDTuple>(RawThrownTypes);
1284 AssertDI(ThrownTypes, "invalid thrown types list", &N, RawThrownTypes)do { if (!(ThrownTypes)) { DebugInfoCheckFailed("invalid thrown types list"
, &N, RawThrownTypes); return; } } while (false)
;
1285 for (Metadata *Op : ThrownTypes->operands())
1286 AssertDI(Op && isa<DIType>(Op), "invalid thrown type", &N, ThrownTypes,do { if (!(Op && isa<DIType>(Op))) { DebugInfoCheckFailed
("invalid thrown type", &N, ThrownTypes, Op); return; } }
while (false)
1287 Op)do { if (!(Op && isa<DIType>(Op))) { DebugInfoCheckFailed
("invalid thrown type", &N, ThrownTypes, Op); return; } }
while (false)
;
1288 }
1289
1290 if (N.areAllCallsDescribed())
1291 AssertDI(N.isDefinition(),do { if (!(N.isDefinition())) { DebugInfoCheckFailed("DIFlagAllCallsDescribed must be attached to a definition"
); return; } } while (false)
1292 "DIFlagAllCallsDescribed must be attached to a definition")do { if (!(N.isDefinition())) { DebugInfoCheckFailed("DIFlagAllCallsDescribed must be attached to a definition"
); return; } } while (false)
;
1293}
1294
1295void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
1296 AssertDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_lexical_block)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1297 AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("invalid local scope"
, &N, N.getRawScope()); return; } } while (false)
1298 "invalid local scope", &N, N.getRawScope())do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("invalid local scope"
, &N, N.getRawScope()); return; } } while (false)
;
1299 if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
1300 AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N)do { if (!(SP->isDefinition())) { DebugInfoCheckFailed("scope points into the type hierarchy"
, &N); return; } } while (false)
;
1301}
1302
1303void Verifier::visitDILexicalBlock(const DILexicalBlock &N) {
1304 visitDILexicalBlockBase(N);
1305
1306 AssertDI(N.getLine() || !N.getColumn(),do { if (!(N.getLine() || !N.getColumn())) { DebugInfoCheckFailed
("cannot have column info without line info", &N); return
; } } while (false)
1307 "cannot have column info without line info", &N)do { if (!(N.getLine() || !N.getColumn())) { DebugInfoCheckFailed
("cannot have column info without line info", &N); return
; } } while (false)
;
1308}
1309
1310void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) {
1311 visitDILexicalBlockBase(N);
1312}
1313
1314void Verifier::visitDICommonBlock(const DICommonBlock &N) {
1315 AssertDI(N.getTag() == dwarf::DW_TAG_common_block, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_common_block)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1316 if (auto *S = N.getRawScope())
1317 AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S)do { if (!(isa<DIScope>(S))) { DebugInfoCheckFailed("invalid scope ref"
, &N, S); return; } } while (false)
;
1318 if (auto *S = N.getRawDecl())
1319 AssertDI(isa<DIGlobalVariable>(S), "invalid declaration", &N, S)do { if (!(isa<DIGlobalVariable>(S))) { DebugInfoCheckFailed
("invalid declaration", &N, S); return; } } while (false)
;
1320}
1321
1322void Verifier::visitDINamespace(const DINamespace &N) {
1323 AssertDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_namespace)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1324 if (auto *S = N.getRawScope())
1325 AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S)do { if (!(isa<DIScope>(S))) { DebugInfoCheckFailed("invalid scope ref"
, &N, S); return; } } while (false)
;
1326}
1327
1328void Verifier::visitDIMacro(const DIMacro &N) {
1329 AssertDI(N.getMacinfoType() == dwarf::DW_MACINFO_define ||do { if (!(N.getMacinfoType() == dwarf::DW_MACINFO_define || N
.getMacinfoType() == dwarf::DW_MACINFO_undef)) { DebugInfoCheckFailed
("invalid macinfo type", &N); return; } } while (false)
1330 N.getMacinfoType() == dwarf::DW_MACINFO_undef,do { if (!(N.getMacinfoType() == dwarf::DW_MACINFO_define || N
.getMacinfoType() == dwarf::DW_MACINFO_undef)) { DebugInfoCheckFailed
("invalid macinfo type", &N); return; } } while (false)
1331 "invalid macinfo type", &N)do { if (!(N.getMacinfoType() == dwarf::DW_MACINFO_define || N
.getMacinfoType() == dwarf::DW_MACINFO_undef)) { DebugInfoCheckFailed
("invalid macinfo type", &N); return; } } while (false)
;
1332 AssertDI(!N.getName().empty(), "anonymous macro", &N)do { if (!(!N.getName().empty())) { DebugInfoCheckFailed("anonymous macro"
, &N); return; } } while (false)
;
1333 if (!N.getValue().empty()) {
1334 assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix")(static_cast<void> (0));
1335 }
1336}
1337
1338void Verifier::visitDIMacroFile(const DIMacroFile &N) {
1339 AssertDI(N.getMacinfoType() == dwarf::DW_MACINFO_start_file,do { if (!(N.getMacinfoType() == dwarf::DW_MACINFO_start_file
)) { DebugInfoCheckFailed("invalid macinfo type", &N); return
; } } while (false)
1340 "invalid macinfo type", &N)do { if (!(N.getMacinfoType() == dwarf::DW_MACINFO_start_file
)) { DebugInfoCheckFailed("invalid macinfo type", &N); return
; } } while (false)
;
1341 if (auto *F = N.getRawFile())
1342 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
1343
1344 if (auto *Array = N.getRawElements()) {
1345 AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array)do { if (!(isa<MDTuple>(Array))) { DebugInfoCheckFailed
("invalid macro list", &N, Array); return; } } while (false
)
;
1346 for (Metadata *Op : N.getElements()->operands()) {
1347 AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op)do { if (!(Op && isa<DIMacroNode>(Op))) { DebugInfoCheckFailed
("invalid macro ref", &N, Op); return; } } while (false)
;
1348 }
1349 }
1350}
1351
1352void Verifier::visitDIArgList(const DIArgList &N) {
1353 AssertDI(!N.getNumOperands(),do { if (!(!N.getNumOperands())) { DebugInfoCheckFailed("DIArgList should have no operands other than a list of "
"ValueAsMetadata", &N); return; } } while (false)
1354 "DIArgList should have no operands other than a list of "do { if (!(!N.getNumOperands())) { DebugInfoCheckFailed("DIArgList should have no operands other than a list of "
"ValueAsMetadata", &N); return; } } while (false)
1355 "ValueAsMetadata",do { if (!(!N.getNumOperands())) { DebugInfoCheckFailed("DIArgList should have no operands other than a list of "
"ValueAsMetadata", &N); return; } } while (false)
1356 &N)do { if (!(!N.getNumOperands())) { DebugInfoCheckFailed("DIArgList should have no operands other than a list of "
"ValueAsMetadata", &N); return; } } while (false)
;
1357}
1358
1359void Verifier::visitDIModule(const DIModule &N) {
1360 AssertDI(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_module)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1361 AssertDI(!N.getName().empty(), "anonymous module", &N)do { if (!(!N.getName().empty())) { DebugInfoCheckFailed("anonymous module"
, &N); return; } } while (false)
;
1362}
1363
1364void Verifier::visitDITemplateParameter(const DITemplateParameter &N) {
1365 AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType())do { if (!(isType(N.getRawType()))) { DebugInfoCheckFailed("invalid type ref"
, &N, N.getRawType()); return; } } while (false)
;
1366}
1367
1368void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) {
1369 visitDITemplateParameter(N);
1370
1371 AssertDI(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",do { if (!(N.getTag() == dwarf::DW_TAG_template_type_parameter
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
1372 &N)do { if (!(N.getTag() == dwarf::DW_TAG_template_type_parameter
)) { DebugInfoCheckFailed("invalid tag", &N); return; } }
while (false)
;
1373}
1374
1375void Verifier::visitDITemplateValueParameter(
1376 const DITemplateValueParameter &N) {
1377 visitDITemplateParameter(N);
1378
1379 AssertDI(N.getTag() == dwarf::DW_TAG_template_value_parameter ||do { if (!(N.getTag() == dwarf::DW_TAG_template_value_parameter
|| N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1380 N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||do { if (!(N.getTag() == dwarf::DW_TAG_template_value_parameter
|| N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1381 N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,do { if (!(N.getTag() == dwarf::DW_TAG_template_value_parameter
|| N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1382 "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_template_value_parameter
|| N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1383}
1384
1385void Verifier::visitDIVariable(const DIVariable &N) {
1386 if (auto *S = N.getRawScope())
1387 AssertDI(isa<DIScope>(S), "invalid scope", &N, S)do { if (!(isa<DIScope>(S))) { DebugInfoCheckFailed("invalid scope"
, &N, S); return; } } while (false)
;
1388 if (auto *F = N.getRawFile())
1389 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
1390}
1391
1392void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) {
1393 // Checks common to all variables.
1394 visitDIVariable(N);
1395
1396 AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_variable)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1397 AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType())do { if (!(isType(N.getRawType()))) { DebugInfoCheckFailed("invalid type ref"
, &N, N.getRawType()); return; } } while (false)
;
1398 // Assert only if the global variable is not an extern
1399 if (N.isDefinition())
1400 AssertDI(N.getType(), "missing global variable type", &N)do { if (!(N.getType())) { DebugInfoCheckFailed("missing global variable type"
, &N); return; } } while (false)
;
1401 if (auto *Member = N.getRawStaticDataMemberDeclaration()) {
1402 AssertDI(isa<DIDerivedType>(Member),do { if (!(isa<DIDerivedType>(Member))) { DebugInfoCheckFailed
("invalid static data member declaration", &N, Member); return
; } } while (false)
1403 "invalid static data member declaration", &N, Member)do { if (!(isa<DIDerivedType>(Member))) { DebugInfoCheckFailed
("invalid static data member declaration", &N, Member); return
; } } while (false)
;
1404 }
1405}
1406
1407void Verifier::visitDILocalVariable(const DILocalVariable &N) {
1408 // Checks common to all variables.
1409 visitDIVariable(N);
1410
1411 AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType())do { if (!(isType(N.getRawType()))) { DebugInfoCheckFailed("invalid type ref"
, &N, N.getRawType()); return; } } while (false)
;
1412 AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_variable)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1413 AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("local variable requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
1414 "local variable requires a valid scope", &N, N.getRawScope())do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("local variable requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
;
1415 if (auto Ty = N.getType())
1416 AssertDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType())do { if (!(!isa<DISubroutineType>(Ty))) { DebugInfoCheckFailed
("invalid type", &N, N.getType()); return; } } while (false
)
;
1417}
1418
1419void Verifier::visitDILabel(const DILabel &N) {
1420 if (auto *S = N.getRawScope())
1421 AssertDI(isa<DIScope>(S), "invalid scope", &N, S)do { if (!(isa<DIScope>(S))) { DebugInfoCheckFailed("invalid scope"
, &N, S); return; } } while (false)
;
1422 if (auto *F = N.getRawFile())
1423 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
1424
1425 AssertDI(N.getTag() == dwarf::DW_TAG_label, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_label)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1426 AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("label requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
1427 "label requires a valid scope", &N, N.getRawScope())do { if (!(N.getRawScope() && isa<DILocalScope>
(N.getRawScope()))) { DebugInfoCheckFailed("label requires a valid scope"
, &N, N.getRawScope()); return; } } while (false)
;
1428}
1429
1430void Verifier::visitDIExpression(const DIExpression &N) {
1431 AssertDI(N.isValid(), "invalid expression", &N)do { if (!(N.isValid())) { DebugInfoCheckFailed("invalid expression"
, &N); return; } } while (false)
;
1432}
1433
1434void Verifier::visitDIGlobalVariableExpression(
1435 const DIGlobalVariableExpression &GVE) {
1436 AssertDI(GVE.getVariable(), "missing variable")do { if (!(GVE.getVariable())) { DebugInfoCheckFailed("missing variable"
); return; } } while (false)
;
1437 if (auto *Var = GVE.getVariable())
1438 visitDIGlobalVariable(*Var);
1439 if (auto *Expr = GVE.getExpression()) {
1440 visitDIExpression(*Expr);
1441 if (auto Fragment = Expr->getFragmentInfo())
1442 verifyFragmentExpression(*GVE.getVariable(), *Fragment, &GVE);
1443 }
1444}
1445
1446void Verifier::visitDIObjCProperty(const DIObjCProperty &N) {
1447 AssertDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_APPLE_property)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1448 if (auto *T = N.getRawType())
1449 AssertDI(isType(T), "invalid type ref", &N, T)do { if (!(isType(T))) { DebugInfoCheckFailed("invalid type ref"
, &N, T); return; } } while (false)
;
1450 if (auto *F = N.getRawFile())
1451 AssertDI(isa<DIFile>(F), "invalid file", &N, F)do { if (!(isa<DIFile>(F))) { DebugInfoCheckFailed("invalid file"
, &N, F); return; } } while (false)
;
1452}
1453
1454void Verifier::visitDIImportedEntity(const DIImportedEntity &N) {
1455 AssertDI(N.getTag() == dwarf::DW_TAG_imported_module ||do { if (!(N.getTag() == dwarf::DW_TAG_imported_module || N.getTag
() == dwarf::DW_TAG_imported_declaration)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1456 N.getTag() == dwarf::DW_TAG_imported_declaration,do { if (!(N.getTag() == dwarf::DW_TAG_imported_module || N.getTag
() == dwarf::DW_TAG_imported_declaration)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
1457 "invalid tag", &N)do { if (!(N.getTag() == dwarf::DW_TAG_imported_module || N.getTag
() == dwarf::DW_TAG_imported_declaration)) { DebugInfoCheckFailed
("invalid tag", &N); return; } } while (false)
;
1458 if (auto *S = N.getRawScope())
1459 AssertDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S)do { if (!(isa<DIScope>(S))) { DebugInfoCheckFailed("invalid scope for imported entity"
, &N, S); return; } } while (false)
;
1460 AssertDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,do { if (!(isDINode(N.getRawEntity()))) { DebugInfoCheckFailed
("invalid imported entity", &N, N.getRawEntity()); return
; } } while (false)
1461 N.getRawEntity())do { if (!(isDINode(N.getRawEntity()))) { DebugInfoCheckFailed
("invalid imported entity", &N, N.getRawEntity()); return
; } } while (false)
;
1462}
1463
1464void Verifier::visitComdat(const Comdat &C) {
1465 // In COFF the Module is invalid if the GlobalValue has private linkage.
1466 // Entities with private linkage don't have entries in the symbol table.
1467 if (TT.isOSBinFormatCOFF())
1468 if (const GlobalValue *GV = M.getNamedValue(C.getName()))
1469 Assert(!GV->hasPrivateLinkage(),do { if (!(!GV->hasPrivateLinkage())) { CheckFailed("comdat global value has private linkage"
, GV); return; } } while (false)
1470 "comdat global value has private linkage", GV)do { if (!(!GV->hasPrivateLinkage())) { CheckFailed("comdat global value has private linkage"
, GV); return; } } while (false)
;
1471}
1472
1473void Verifier::visitModuleIdents(const Module &M) {
1474 const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident");
1475 if (!Idents)
1476 return;
1477
1478 // llvm.ident takes a list of metadata entry. Each entry has only one string.
1479 // Scan each llvm.ident entry and make sure that this requirement is met.
1480 for (const MDNode *N : Idents->operands()) {
1481 Assert(N->getNumOperands() == 1,do { if (!(N->getNumOperands() == 1)) { CheckFailed("incorrect number of operands in llvm.ident metadata"
, N); return; } } while (false)
1482 "incorrect number of operands in llvm.ident metadata", N)do { if (!(N->getNumOperands() == 1)) { CheckFailed("incorrect number of operands in llvm.ident metadata"
, N); return; } } while (false)
;
1483 Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.ident metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1484 ("invalid value for llvm.ident metadata entry operand"do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.ident metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1485 "(the operand should be a string)"),do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.ident metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1486 N->getOperand(0))do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.ident metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
;
1487 }
1488}
1489
1490void Verifier::visitModuleCommandLines(const Module &M) {
1491 const NamedMDNode *CommandLines = M.getNamedMetadata("llvm.commandline");
1492 if (!CommandLines)
1493 return;
1494
1495 // llvm.commandline takes a list of metadata entry. Each entry has only one
1496 // string. Scan each llvm.commandline entry and make sure that this
1497 // requirement is met.
1498 for (const MDNode *N : CommandLines->operands()) {
1499 Assert(N->getNumOperands() == 1,do { if (!(N->getNumOperands() == 1)) { CheckFailed("incorrect number of operands in llvm.commandline metadata"
, N); return; } } while (false)
1500 "incorrect number of operands in llvm.commandline metadata", N)do { if (!(N->getNumOperands() == 1)) { CheckFailed("incorrect number of operands in llvm.commandline metadata"
, N); return; } } while (false)
;
1501 Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.commandline metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1502 ("invalid value for llvm.commandline metadata entry operand"do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.commandline metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1503 "(the operand should be a string)"),do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.commandline metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
1504 N->getOperand(0))do { if (!(dyn_cast_or_null<MDString>(N->getOperand(
0)))) { CheckFailed(("invalid value for llvm.commandline metadata entry operand"
"(the operand should be a string)"), N->getOperand(0)); return
; } } while (false)
;
1505 }
1506}
1507
1508void Verifier::visitModuleFlags(const Module &M) {
1509 const NamedMDNode *Flags = M.getModuleFlagsMetadata();
1510 if (!Flags) return;
1511
1512 // Scan each flag, and track the flags and requirements.
1513 DenseMap<const MDString*, const MDNode*> SeenIDs;
1514 SmallVector<const MDNode*, 16> Requirements;
1515 for (const MDNode *MDN : Flags->operands())
1516 visitModuleFlag(MDN, SeenIDs, Requirements);
1517
1518 // Validate that the requirements in the module are valid.
1519 for (const MDNode *Requirement : Requirements) {
1520 const MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1521 const Metadata *ReqValue = Requirement->getOperand(1);
1522
1523 const MDNode *Op = SeenIDs.lookup(Flag);
1524 if (!Op) {
1525 CheckFailed("invalid requirement on flag, flag is not present in module",
1526 Flag);
1527 continue;
1528 }
1529
1530 if (Op->getOperand(2) != ReqValue) {
1531 CheckFailed(("invalid requirement on flag, "
1532 "flag does not have the required value"),
1533 Flag);
1534 continue;
1535 }
1536 }
1537}
1538
1539void
1540Verifier::visitModuleFlag(const MDNode *Op,
1541 DenseMap<const MDString *, const MDNode *> &SeenIDs,
1542 SmallVectorImpl<const MDNode *> &Requirements) {
1543 // Each module flag should have three arguments, the merge behavior (a
1544 // constant int), the flag ID (an MDString), and the value.
1545 Assert(Op->getNumOperands() == 3,do { if (!(Op->getNumOperands() == 3)) { CheckFailed("incorrect number of operands in module flag"
, Op); return; } } while (false)
1546 "incorrect number of operands in module flag", Op)do { if (!(Op->getNumOperands() == 3)) { CheckFailed("incorrect number of operands in module flag"
, Op); return; } } while (false)
;
1547 Module::ModFlagBehavior MFB;
1548 if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
1549 Assert(do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(0)))) { CheckFailed("invalid behavior operand in module flag (expected constant integer)"
, Op->getOperand(0)); return; } } while (false)
1550 mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(0)))) { CheckFailed("invalid behavior operand in module flag (expected constant integer)"
, Op->getOperand(0)); return; } } while (false)
1551 "invalid behavior operand in module flag (expected constant integer)",do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(0)))) { CheckFailed("invalid behavior operand in module flag (expected constant integer)"
, Op->getOperand(0)); return; } } while (false)
1552 Op->getOperand(0))do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(0)))) { CheckFailed("invalid behavior operand in module flag (expected constant integer)"
, Op->getOperand(0)); return; } } while (false)
;
1553 Assert(false,do { if (!(false)) { CheckFailed("invalid behavior operand in module flag (unexpected constant)"
, Op->getOperand(0)); return; } } while (false)
1554 "invalid behavior operand in module flag (unexpected constant)",do { if (!(false)) { CheckFailed("invalid behavior operand in module flag (unexpected constant)"
, Op->getOperand(0)); return; } } while (false)
1555 Op->getOperand(0))do { if (!(false)) { CheckFailed("invalid behavior operand in module flag (unexpected constant)"
, Op->getOperand(0)); return; } } while (false)
;
1556 }
1557 MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
1558 Assert(ID, "invalid ID operand in module flag (expected metadata string)",do { if (!(ID)) { CheckFailed("invalid ID operand in module flag (expected metadata string)"
, Op->getOperand(1)); return; } } while (false)
1559 Op->getOperand(1))do { if (!(ID)) { CheckFailed("invalid ID operand in module flag (expected metadata string)"
, Op->getOperand(1)); return; } } while (false)
;
1560
1561 // Sanity check the values for behaviors with additional requirements.
1562 switch (MFB) {
1563 case Module::Error:
1564 case Module::Warning:
1565 case Module::Override:
1566 // These behavior types accept any value.
1567 break;
1568
1569 case Module::Max: {
1570 Assert(mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2)),do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(2)))) { CheckFailed("invalid value for 'max' module flag (expected constant integer)"
, Op->getOperand(2)); return; } } while (false)
1571 "invalid value for 'max' module flag (expected constant integer)",do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(2)))) { CheckFailed("invalid value for 'max' module flag (expected constant integer)"
, Op->getOperand(2)); return; } } while (false)
1572 Op->getOperand(2))do { if (!(mdconst::dyn_extract_or_null<ConstantInt>(Op
->getOperand(2)))) { CheckFailed("invalid value for 'max' module flag (expected constant integer)"
, Op->getOperand(2)); return; } } while (false)
;
1573 break;
1574 }
1575
1576 case Module::Require: {
1577 // The value should itself be an MDNode with two operands, a flag ID (an
1578 // MDString), and a value.
1579 MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
1580 Assert(Value && Value->getNumOperands() == 2,do { if (!(Value && Value->getNumOperands() == 2))
{ CheckFailed("invalid value for 'require' module flag (expected metadata pair)"
, Op->getOperand(2)); return; } } while (false)
1581 "invalid value for 'require' module flag (expected metadata pair)",do { if (!(Value && Value->getNumOperands() == 2))
{ CheckFailed("invalid value for 'require' module flag (expected metadata pair)"
, Op->getOperand(2)); return; } } while (false)
1582 Op->getOperand(2))do { if (!(Value && Value->getNumOperands() == 2))
{ CheckFailed("invalid value for 'require' module flag (expected metadata pair)"
, Op->getOperand(2)); return; } } while (false)
;
1583 Assert(isa<MDString>(Value->getOperand(0)),do { if (!(isa<MDString>(Value->getOperand(0)))) { CheckFailed
(("invalid value for 'require' module flag " "(first value operand should be a string)"
), Value->getOperand(0)); return; } } while (false)
1584 ("invalid value for 'require' module flag "do { if (!(isa<MDString>(Value->getOperand(0)))) { CheckFailed
(("invalid value for 'require' module flag " "(first value operand should be a string)"
), Value->getOperand(0)); return; } } while (false)
1585 "(first value operand should be a string)"),do { if (!(isa<MDString>(Value->getOperand(0)))) { CheckFailed
(("invalid value for 'require' module flag " "(first value operand should be a string)"
), Value->getOperand(0)); return; } } while (false)
1586 Value->getOperand(0))do { if (!(isa<MDString>(Value->getOperand(0)))) { CheckFailed
(("invalid value for 'require' module flag " "(first value operand should be a string)"
), Value->getOperand(0)); return; } } while (false)
;
1587
1588 // Append it to the list of requirements, to check once all module flags are
1589 // scanned.
1590 Requirements.push_back(Value);
1591 break;
1592 }
1593
1594 case Module::Append:
1595 case Module::AppendUnique: {
1596 // These behavior types require the operand be an MDNode.
1597 Assert(isa<MDNode>(Op->getOperand(2)),do { if (!(isa<MDNode>(Op->getOperand(2)))) { CheckFailed
("invalid value for 'append'-type module flag " "(expected a metadata node)"
, Op->getOperand(2)); return; } } while (false)
1598 "invalid value for 'append'-type module flag "do { if (!(isa<MDNode>(Op->getOperand(2)))) { CheckFailed
("invalid value for 'append'-type module flag " "(expected a metadata node)"
, Op->getOperand(2)); return; } } while (false)
1599 "(expected a metadata node)",do { if (!(isa<MDNode>(Op->getOperand(2)))) { CheckFailed
("invalid value for 'append'-type module flag " "(expected a metadata node)"
, Op->getOperand(2)); return; } } while (false)
1600 Op->getOperand(2))do { if (!(isa<MDNode>(Op->getOperand(2)))) { CheckFailed
("invalid value for 'append'-type module flag " "(expected a metadata node)"
, Op->getOperand(2)); return; } } while (false)
;
1601 break;
1602 }
1603 }
1604
1605 // Unless this is a "requires" flag, check the ID is unique.
1606 if (MFB != Module::Require) {
1607 bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
1608 Assert(Inserted,do { if (!(Inserted)) { CheckFailed("module flag identifiers must be unique (or of 'require' type)"
, ID); return; } } while (false)
1609 "module flag identifiers must be unique (or of 'require' type)", ID)do { if (!(Inserted)) { CheckFailed("module flag identifiers must be unique (or of 'require' type)"
, ID); return; } } while (false)
;
1610 }
1611
1612 if (ID->getString() == "wchar_size") {
1613 ConstantInt *Value
1614 = mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2));
1615 Assert(Value, "wchar_size metadata requires constant integer argument")do { if (!(Value)) { CheckFailed("wchar_size metadata requires constant integer argument"
); return; } } while (false)
;
1616 }
1617
1618 if (ID->getString() == "Linker Options") {
1619 // If the llvm.linker.options named metadata exists, we assume that the
1620 // bitcode reader has upgraded the module flag. Otherwise the flag might
1621 // have been created by a client directly.
1622 Assert(M.getNamedMetadata("llvm.linker.options"),do { if (!(M.getNamedMetadata("llvm.linker.options"))) { CheckFailed
("'Linker Options' named metadata no longer supported"); return
; } } while (false)
1623 "'Linker Options' named metadata no longer supported")do { if (!(M.getNamedMetadata("llvm.linker.options"))) { CheckFailed
("'Linker Options' named metadata no longer supported"); return
; } } while (false)
;
1624 }
1625
1626 if (ID->getString() == "SemanticInterposition") {
1627 ConstantInt *Value =
1628 mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2));
1629 Assert(Value,do { if (!(Value)) { CheckFailed("SemanticInterposition metadata requires constant integer argument"
); return; } } while (false)
1630 "SemanticInterposition metadata requires constant integer argument")do { if (!(Value)) { CheckFailed("SemanticInterposition metadata requires constant integer argument"
); return; } } while (false)
;
1631 }
1632
1633 if (ID->getString() == "CG Profile") {
1634 for (const MDOperand &MDO : cast<MDNode>(Op->getOperand(2))->operands())
1635 visitModuleFlagCGProfileEntry(MDO);
1636 }
1637}
1638
1639void Verifier::visitModuleFlagCGProfileEntry(const MDOperand &MDO) {
1640 auto CheckFunction = [&](const MDOperand &FuncMDO) {
1641 if (!FuncMDO)
1642 return;
1643 auto F = dyn_cast<ValueAsMetadata>(FuncMDO);
1644 Assert(F && isa<Function>(F->getValue()->stripPointerCasts()),do { if (!(F && isa<Function>(F->getValue()->
stripPointerCasts()))) { CheckFailed("expected a Function or null"
, FuncMDO); return; } } while (false)
1645 "expected a Function or null", FuncMDO)do { if (!(F && isa<Function>(F->getValue()->
stripPointerCasts()))) { CheckFailed("expected a Function or null"
, FuncMDO); return; } } while (false)
;
1646 };
1647 auto Node = dyn_cast_or_null<MDNode>(MDO);
1648 Assert(Node && Node->getNumOperands() == 3, "expected a MDNode triple", MDO)do { if (!(Node && Node->getNumOperands() == 3)) {
CheckFailed("expected a MDNode triple", MDO); return; } } while
(false)
;
1649 CheckFunction(Node->getOperand(0));
1650 CheckFunction(Node->getOperand(1));
1651 auto Count = dyn_cast_or_null<ConstantAsMetadata>(Node->getOperand(2));
1652 Assert(Count && Count->getType()->isIntegerTy(),do { if (!(Count && Count->getType()->isIntegerTy
())) { CheckFailed("expected an integer constant", Node->getOperand
(2)); return; } } while (false)
1653 "expected an integer constant", Node->getOperand(2))do { if (!(Count && Count->getType()->isIntegerTy
())) { CheckFailed("expected an integer constant", Node->getOperand
(2)); return; } } while (false)
;
1654}
1655
1656void Verifier::verifyAttributeTypes(AttributeSet Attrs, const Value *V) {
1657 for (Attribute A : Attrs) {
1658
1659 if (A.isStringAttribute()) {
1660#define GET_ATTR_NAMES
1661#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)
1662#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
1663 if (A.getKindAsString() == #DISPLAY_NAME) { \
1664 auto V = A.getValueAsString(); \
1665 if (!(V.empty() || V == "true" || V == "false")) \
1666 CheckFailed("invalid value for '" #DISPLAY_NAME "' attribute: " + V + \
1667 ""); \
1668 }
1669
1670#include "llvm/IR/Attributes.inc"
1671 continue;
1672 }
1673
1674 if (A.isIntAttribute() != Attribute::isIntAttrKind(A.getKindAsEnum())) {
1675 CheckFailed("Attribute '" + A.getAsString() + "' should have an Argument",
1676 V);
1677 return;
1678 }
1679 }
1680}
1681
1682// VerifyParameterAttrs - Check the given attributes for an argument or return
1683// value of the specified type. The value V is printed in error messages.
1684void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
1685 const Value *V) {
1686 if (!Attrs.hasAttributes())
1687 return;
1688
1689 verifyAttributeTypes(Attrs, V);
1690
1691 for (Attribute Attr : Attrs)
1692 Assert(Attr.isStringAttribute() ||do { if (!(Attr.isStringAttribute() || Attribute::canUseAsParamAttr
(Attr.getKindAsEnum()))) { CheckFailed("Attribute '" + Attr.getAsString
() + "' does not apply to parameters", V); return; } } while (
false)
1693 Attribute::canUseAsParamAttr(Attr.getKindAsEnum()),do { if (!(Attr.isStringAttribute() || Attribute::canUseAsParamAttr
(Attr.getKindAsEnum()))) { CheckFailed("Attribute '" + Attr.getAsString
() + "' does not apply to parameters", V); return; } } while (
false)
1694 "Attribute '" + Attr.getAsString() +do { if (!(Attr.isStringAttribute() || Attribute::canUseAsParamAttr
(Attr.getKindAsEnum()))) { CheckFailed("Attribute '" + Attr.getAsString
() + "' does not apply to parameters", V); return; } } while (
false)
1695 "' does not apply to parameters",do { if (!(Attr.isStringAttribute() || Attribute::canUseAsParamAttr
(Attr.getKindAsEnum()))) { CheckFailed("Attribute '" + Attr.getAsString
() + "' does not apply to parameters", V); return; } } while (
false)
1696 V)do { if (!(Attr.isStringAttribute() || Attribute::canUseAsParamAttr
(Attr.getKindAsEnum()))) { CheckFailed("Attribute '" + Attr.getAsString
() + "' does not apply to parameters", V); return; } } while (
false)
;
1697
1698 if (Attrs.hasAttribute(Attribute::ImmArg)) {
1699 Assert(Attrs.getNumAttributes() == 1,do { if (!(Attrs.getNumAttributes() == 1)) { CheckFailed("Attribute 'immarg' is incompatible with other attributes"
, V); return; } } while (false)
1700 "Attribute 'immarg' is incompatible with other attributes", V)do { if (!(Attrs.getNumAttributes() == 1)) { CheckFailed("Attribute 'immarg' is incompatible with other attributes"
, V); return; } } while (false)
;
1701 }
1702
1703 // Check for mutually incompatible attributes. Only inreg is compatible with
1704 // sret.
1705 unsigned AttrCount = 0;
1706 AttrCount += Attrs.hasAttribute(Attribute::ByVal);
1707 AttrCount += Attrs.hasAttribute(Attribute::InAlloca);
1708 AttrCount += Attrs.hasAttribute(Attribute::Preallocated);
1709 AttrCount += Attrs.hasAttribute(Attribute::StructRet) ||
1710 Attrs.hasAttribute(Attribute::InReg);
1711 AttrCount += Attrs.hasAttribute(Attribute::Nest);
1712 AttrCount += Attrs.hasAttribute(Attribute::ByRef);
1713 Assert(AttrCount <= 1,do { if (!(AttrCount <= 1)) { CheckFailed("Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
"'byref', and 'sret' are incompatible!", V); return; } } while
(false)
1714 "Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "do { if (!(AttrCount <= 1)) { CheckFailed("Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
"'byref', and 'sret' are incompatible!", V); return; } } while
(false)
1715 "'byref', and 'sret' are incompatible!",do { if (!(AttrCount <= 1)) { CheckFailed("Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
"'byref', and 'sret' are incompatible!", V); return; } } while
(false)
1716 V)do { if (!(AttrCount <= 1)) { CheckFailed("Attributes 'byval', 'inalloca', 'preallocated', 'inreg', 'nest', "
"'byref', and 'sret' are incompatible!", V); return; } } while
(false)
;
1717
1718 Assert(!(Attrs.hasAttribute(Attribute::InAlloca) &&do { if (!(!(Attrs.hasAttribute(Attribute::InAlloca) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'inalloca and readonly' are incompatible!", V); return; } }
while (false)
1719 Attrs.hasAttribute(Attribute::ReadOnly)),do { if (!(!(Attrs.hasAttribute(Attribute::InAlloca) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'inalloca and readonly' are incompatible!", V); return; } }
while (false)
1720 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::InAlloca) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'inalloca and readonly' are incompatible!", V); return; } }
while (false)
1721 "'inalloca and readonly' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::InAlloca) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'inalloca and readonly' are incompatible!", V); return; } }
while (false)
1722 V)do { if (!(!(Attrs.hasAttribute(Attribute::InAlloca) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'inalloca and readonly' are incompatible!", V); return; } }
while (false)
;
1723
1724 Assert(!(Attrs.hasAttribute(Attribute::StructRet) &&do { if (!(!(Attrs.hasAttribute(Attribute::StructRet) &&
Attrs.hasAttribute(Attribute::Returned)))) { CheckFailed("Attributes "
"'sret and returned' are incompatible!", V); return; } } while
(false)
1725 Attrs.hasAttribute(Attribute::Returned)),do { if (!(!(Attrs.hasAttribute(Attribute::StructRet) &&
Attrs.hasAttribute(Attribute::Returned)))) { CheckFailed("Attributes "
"'sret and returned' are incompatible!", V); return; } } while
(false)
1726 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::StructRet) &&
Attrs.hasAttribute(Attribute::Returned)))) { CheckFailed("Attributes "
"'sret and returned' are incompatible!", V); return; } } while
(false)
1727 "'sret and returned' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::StructRet) &&
Attrs.hasAttribute(Attribute::Returned)))) { CheckFailed("Attributes "
"'sret and returned' are incompatible!", V); return; } } while
(false)
1728 V)do { if (!(!(Attrs.hasAttribute(Attribute::StructRet) &&
Attrs.hasAttribute(Attribute::Returned)))) { CheckFailed("Attributes "
"'sret and returned' are incompatible!", V); return; } } while
(false)
;
1729
1730 Assert(!(Attrs.hasAttribute(Attribute::ZExt) &&do { if (!(!(Attrs.hasAttribute(Attribute::ZExt) && Attrs
.hasAttribute(Attribute::SExt)))) { CheckFailed("Attributes "
"'zeroext and signext' are incompatible!", V); return; } } while
(false)
1731 Attrs.hasAttribute(Attribute::SExt)),do { if (!(!(Attrs.hasAttribute(Attribute::ZExt) && Attrs
.hasAttribute(Attribute::SExt)))) { CheckFailed("Attributes "
"'zeroext and signext' are incompatible!", V); return; } } while
(false)
1732 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::ZExt) && Attrs
.hasAttribute(Attribute::SExt)))) { CheckFailed("Attributes "
"'zeroext and signext' are incompatible!", V); return; } } while
(false)
1733 "'zeroext and signext' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::ZExt) && Attrs
.hasAttribute(Attribute::SExt)))) { CheckFailed("Attributes "
"'zeroext and signext' are incompatible!", V); return; } } while
(false)
1734 V)do { if (!(!(Attrs.hasAttribute(Attribute::ZExt) && Attrs
.hasAttribute(Attribute::SExt)))) { CheckFailed("Attributes "
"'zeroext and signext' are incompatible!", V); return; } } while
(false)
;
1735
1736 Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'readnone and readonly' are incompatible!", V); return; } }
while (false)
1737 Attrs.hasAttribute(Attribute::ReadOnly)),do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'readnone and readonly' are incompatible!", V); return; } }
while (false)
1738 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'readnone and readonly' are incompatible!", V); return; } }
while (false)
1739 "'readnone and readonly' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'readnone and readonly' are incompatible!", V); return; } }
while (false)
1740 V)do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::ReadOnly)))) { CheckFailed("Attributes "
"'readnone and readonly' are incompatible!", V); return; } }
while (false)
;
1741
1742 Assert(!(Attrs.hasAttribute(Attribute::ReadNone) &&do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readnone and writeonly' are incompatible!", V); return; } }
while (false)
1743 Attrs.hasAttribute(Attribute::WriteOnly)),do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readnone and writeonly' are incompatible!", V); return; } }
while (false)
1744 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readnone and writeonly' are incompatible!", V); return; } }
while (false)
1745 "'readnone and writeonly' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readnone and writeonly' are incompatible!", V); return; } }
while (false)
1746 V)do { if (!(!(Attrs.hasAttribute(Attribute::ReadNone) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readnone and writeonly' are incompatible!", V); return; } }
while (false)
;
1747
1748 Assert(!(Attrs.hasAttribute(Attribute::ReadOnly) &&do { if (!(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readonly and writeonly' are incompatible!", V); return; } }
while (false)
1749 Attrs.hasAttribute(Attribute::WriteOnly)),do { if (!(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readonly and writeonly' are incompatible!", V); return; } }
while (false)
1750 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readonly and writeonly' are incompatible!", V); return; } }
while (false)
1751 "'readonly and writeonly' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readonly and writeonly' are incompatible!", V); return; } }
while (false)
1752 V)do { if (!(!(Attrs.hasAttribute(Attribute::ReadOnly) &&
Attrs.hasAttribute(Attribute::WriteOnly)))) { CheckFailed("Attributes "
"'readonly and writeonly' are incompatible!", V); return; } }
while (false)
;
1753
1754 Assert(!(Attrs.hasAttribute(Attribute::NoInline) &&do { if (!(!(Attrs.hasAttribute(Attribute::NoInline) &&
Attrs.hasAttribute(Attribute::AlwaysInline)))) { CheckFailed
("Attributes " "'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1755 Attrs.hasAttribute(Attribute::AlwaysInline)),do { if (!(!(Attrs.hasAttribute(Attribute::NoInline) &&
Attrs.hasAttribute(Attribute::AlwaysInline)))) { CheckFailed
("Attributes " "'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1756 "Attributes "do { if (!(!(Attrs.hasAttribute(Attribute::NoInline) &&
Attrs.hasAttribute(Attribute::AlwaysInline)))) { CheckFailed
("Attributes " "'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1757 "'noinline and alwaysinline' are incompatible!",do { if (!(!(Attrs.hasAttribute(Attribute::NoInline) &&
Attrs.hasAttribute(Attribute::AlwaysInline)))) { CheckFailed
("Attributes " "'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1758 V)do { if (!(!(Attrs.hasAttribute(Attribute::NoInline) &&
Attrs.hasAttribute(Attribute::AlwaysInline)))) { CheckFailed
("Attributes " "'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
;
1759
1760 AttrBuilder IncompatibleAttrs = AttributeFuncs::typeIncompatible(Ty);
1761 for (Attribute Attr : Attrs) {
1762 if (!Attr.isStringAttribute() &&
1763 IncompatibleAttrs.contains(Attr.getKindAsEnum())) {
1764 CheckFailed("Attribute '" + Attr.getAsString() +
1765 "' applied to incompatible type!", V);
1766 return;
1767 }
1768 }
1769
1770 if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
1771 if (Attrs.hasAttribute(Attribute::ByVal)) {
1772 SmallPtrSet<Type *, 4> Visited;
1773 Assert(Attrs.getByValType()->isSized(&Visited),do { if (!(Attrs.getByValType()->isSized(&Visited))) {
CheckFailed("Attribute 'byval' does not support unsized types!"
, V); return; } } while (false)
1774 "Attribute 'byval' does not support unsized types!", V)do { if (!(Attrs.getByValType()->isSized(&Visited))) {
CheckFailed("Attribute 'byval' does not support unsized types!"
, V); return; } } while (false)
;
1775 }
1776 if (Attrs.hasAttribute(Attribute::ByRef)) {
1777 SmallPtrSet<Type *, 4> Visited;
1778 Assert(Attrs.getByRefType()->isSized(&Visited),do { if (!(Attrs.getByRefType()->isSized(&Visited))) {
CheckFailed("Attribute 'byref' does not support unsized types!"
, V); return; } } while (false)
1779 "Attribute 'byref' does not support unsized types!", V)do { if (!(Attrs.getByRefType()->isSized(&Visited))) {
CheckFailed("Attribute 'byref' does not support unsized types!"
, V); return; } } while (false)
;
1780 }
1781 if (Attrs.hasAttribute(Attribute::InAlloca)) {
1782 SmallPtrSet<Type *, 4> Visited;
1783 Assert(Attrs.getInAllocaType()->isSized(&Visited),do { if (!(Attrs.getInAllocaType()->isSized(&Visited))
) { CheckFailed("Attribute 'inalloca' does not support unsized types!"
, V); return; } } while (false)
1784 "Attribute 'inalloca' does not support unsized types!", V)do { if (!(Attrs.getInAllocaType()->isSized(&Visited))
) { CheckFailed("Attribute 'inalloca' does not support unsized types!"
, V); return; } } while (false)
;
1785 }
1786 if (Attrs.hasAttribute(Attribute::Preallocated)) {
1787 SmallPtrSet<Type *, 4> Visited;
1788 Assert(Attrs.getPreallocatedType()->isSized(&Visited),do { if (!(Attrs.getPreallocatedType()->isSized(&Visited
))) { CheckFailed("Attribute 'preallocated' does not support unsized types!"
, V); return; } } while (false)
1789 "Attribute 'preallocated' does not support unsized types!", V)do { if (!(Attrs.getPreallocatedType()->isSized(&Visited
))) { CheckFailed("Attribute 'preallocated' does not support unsized types!"
, V); return; } } while (false)
;
1790 }
1791 if (!PTy->isOpaque()) {
1792 if (!isa<PointerType>(PTy->getElementType()))
1793 Assert(!Attrs.hasAttribute(Attribute::SwiftError),do { if (!(!Attrs.hasAttribute(Attribute::SwiftError))) { CheckFailed
("Attribute 'swifterror' only applies to parameters " "with pointer to pointer type!"
, V); return; } } while (false)
1794 "Attribute 'swifterror' only applies to parameters "do { if (!(!Attrs.hasAttribute(Attribute::SwiftError))) { CheckFailed
("Attribute 'swifterror' only applies to parameters " "with pointer to pointer type!"
, V); return; } } while (false)
1795 "with pointer to pointer type!",do { if (!(!Attrs.hasAttribute(Attribute::SwiftError))) { CheckFailed
("Attribute 'swifterror' only applies to parameters " "with pointer to pointer type!"
, V); return; } } while (false)
1796 V)do { if (!(!Attrs.hasAttribute(Attribute::SwiftError))) { CheckFailed
("Attribute 'swifterror' only applies to parameters " "with pointer to pointer type!"
, V); return; } } while (false)
;
1797 if (Attrs.hasAttribute(Attribute::ByRef)) {
1798 Assert(Attrs.getByRefType() == PTy->getElementType(),do { if (!(Attrs.getByRefType() == PTy->getElementType()))
{ CheckFailed("Attribute 'byref' type does not match parameter!"
, V); return; } } while (false)
1799 "Attribute 'byref' type does not match parameter!", V)do { if (!(Attrs.getByRefType() == PTy->getElementType()))
{ CheckFailed("Attribute 'byref' type does not match parameter!"
, V); return; } } while (false)
;
1800 }
1801
1802 if (Attrs.hasAttribute(Attribute::ByVal) && Attrs.getByValType()) {
1803 Assert(Attrs.getByValType() == PTy->getElementType(),do { if (!(Attrs.getByValType() == PTy->getElementType()))
{ CheckFailed("Attribute 'byval' type does not match parameter!"
, V); return; } } while (false)
1804 "Attribute 'byval' type does not match parameter!", V)do { if (!(Attrs.getByValType() == PTy->getElementType()))
{ CheckFailed("Attribute 'byval' type does not match parameter!"
, V); return; } } while (false)
;
1805 }
1806
1807 if (Attrs.hasAttribute(Attribute::Preallocated)) {
1808 Assert(Attrs.getPreallocatedType() == PTy->getElementType(),do { if (!(Attrs.getPreallocatedType() == PTy->getElementType
())) { CheckFailed("Attribute 'preallocated' type does not match parameter!"
, V); return; } } while (false)
1809 "Attribute 'preallocated' type does not match parameter!", V)do { if (!(Attrs.getPreallocatedType() == PTy->getElementType
())) { CheckFailed("Attribute 'preallocated' type does not match parameter!"
, V); return; } } while (false)
;
1810 }
1811
1812 if (Attrs.hasAttribute(Attribute::InAlloca)) {
1813 Assert(Attrs.getInAllocaType() == PTy->getElementType(),do { if (!(Attrs.getInAllocaType() == PTy->getElementType(
))) { CheckFailed("Attribute 'inalloca' type does not match parameter!"
, V); return; } } while (false)
1814 "Attribute 'inalloca' type does not match parameter!", V)do { if (!(Attrs.getInAllocaType() == PTy->getElementType(
))) { CheckFailed("Attribute 'inalloca' type does not match parameter!"
, V); return; } } while (false)
;
1815 }
1816
1817 if (Attrs.hasAttribute(Attribute::ElementType)) {
1818 Assert(Attrs.getElementType() == PTy->getElementType(),do { if (!(Attrs.getElementType() == PTy->getElementType()
)) { CheckFailed("Attribute 'elementtype' type does not match parameter!"
, V); return; } } while (false)
1819 "Attribute 'elementtype' type does not match parameter!", V)do { if (!(Attrs.getElementType() == PTy->getElementType()
)) { CheckFailed("Attribute 'elementtype' type does not match parameter!"
, V); return; } } while (false)
;
1820 }
1821 }
1822 }
1823}
1824
1825void Verifier::checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
1826 const Value *V) {
1827 if (Attrs.hasFnAttr(Attr)) {
1828 StringRef S = Attrs.getFnAttr(Attr).getValueAsString();
1829 unsigned N;
1830 if (S.getAsInteger(10, N))
1831 CheckFailed("\"" + Attr + "\" takes an unsigned integer: " + S, V);
1832 }
1833}
1834
1835// Check parameter attributes against a function type.
1836// The value V is printed in error messages.
1837void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
1838 const Value *V, bool IsIntrinsic) {
1839 if (Attrs.isEmpty())
1840 return;
1841
1842 if (AttributeListsVisited.insert(Attrs.getRawPointer()).second) {
1843 Assert(Attrs.hasParentContext(Context),do { if (!(Attrs.hasParentContext(Context))) { CheckFailed("Attribute list does not match Module context!"
, &Attrs, V); return; } } while (false)
1844 "Attribute list does not match Module context!", &Attrs, V)do { if (!(Attrs.hasParentContext(Context))) { CheckFailed("Attribute list does not match Module context!"
, &Attrs, V); return; } } while (false)
;
1845 for (const auto &AttrSet : Attrs) {
1846 Assert(!AttrSet.hasAttributes() || AttrSet.hasParentContext(Context),do { if (!(!AttrSet.hasAttributes() || AttrSet.hasParentContext
(Context))) { CheckFailed("Attribute set does not match Module context!"
, &AttrSet, V); return; } } while (false)
1847 "Attribute set does not match Module context!", &AttrSet, V)do { if (!(!AttrSet.hasAttributes() || AttrSet.hasParentContext
(Context))) { CheckFailed("Attribute set does not match Module context!"
, &AttrSet, V); return; } } while (false)
;
1848 for (const auto &A : AttrSet) {
1849 Assert(A.hasParentContext(Context),do { if (!(A.hasParentContext(Context))) { CheckFailed("Attribute does not match Module context!"
, &A, V); return; } } while (false)
1850 "Attribute does not match Module context!", &A, V)do { if (!(A.hasParentContext(Context))) { CheckFailed("Attribute does not match Module context!"
, &A, V); return; } } while (false)
;
1851 }
1852 }
1853 }
1854
1855 bool SawNest = false;
1856 bool SawReturned = false;
1857 bool SawSRet = false;
1858 bool SawSwiftSelf = false;
1859 bool SawSwiftAsync = false;
1860 bool SawSwiftError = false;
1861
1862 // Verify return value attributes.
1863 AttributeSet RetAttrs = Attrs.getRetAttrs();
1864 for (Attribute RetAttr : RetAttrs)
1865 Assert(RetAttr.isStringAttribute() ||do { if (!(RetAttr.isStringAttribute() || Attribute::canUseAsRetAttr
(RetAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + RetAttr
.getAsString() + "' does not apply to function return values"
, V); return; } } while (false)
1866 Attribute::canUseAsRetAttr(RetAttr.getKindAsEnum()),do { if (!(RetAttr.isStringAttribute() || Attribute::canUseAsRetAttr
(RetAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + RetAttr
.getAsString() + "' does not apply to function return values"
, V); return; } } while (false)
1867 "Attribute '" + RetAttr.getAsString() +do { if (!(RetAttr.isStringAttribute() || Attribute::canUseAsRetAttr
(RetAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + RetAttr
.getAsString() + "' does not apply to function return values"
, V); return; } } while (false)
1868 "' does not apply to function return values",do { if (!(RetAttr.isStringAttribute() || Attribute::canUseAsRetAttr
(RetAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + RetAttr
.getAsString() + "' does not apply to function return values"
, V); return; } } while (false)
1869 V)do { if (!(RetAttr.isStringAttribute() || Attribute::canUseAsRetAttr
(RetAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + RetAttr
.getAsString() + "' does not apply to function return values"
, V); return; } } while (false)
;
1870
1871 verifyParameterAttrs(RetAttrs, FT->getReturnType(), V);
1872
1873 // Verify parameter attributes.
1874 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1875 Type *Ty = FT->getParamType(i);
1876 AttributeSet ArgAttrs = Attrs.getParamAttrs(i);
1877
1878 if (!IsIntrinsic) {
1879 Assert(!ArgAttrs.hasAttribute(Attribute::ImmArg),do { if (!(!ArgAttrs.hasAttribute(Attribute::ImmArg))) { CheckFailed
("immarg attribute only applies to intrinsics",V); return; } }
while (false)
1880 "immarg attribute only applies to intrinsics",V)do { if (!(!ArgAttrs.hasAttribute(Attribute::ImmArg))) { CheckFailed
("immarg attribute only applies to intrinsics",V); return; } }
while (false)
;
1881 Assert(!ArgAttrs.hasAttribute(Attribute::ElementType),do { if (!(!ArgAttrs.hasAttribute(Attribute::ElementType))) {
CheckFailed("Attribute 'elementtype' can only be applied to intrinsics."
, V); return; } } while (false)
1882 "Attribute 'elementtype' can only be applied to intrinsics.", V)do { if (!(!ArgAttrs.hasAttribute(Attribute::ElementType))) {
CheckFailed("Attribute 'elementtype' can only be applied to intrinsics."
, V); return; } } while (false)
;
1883 }
1884
1885 verifyParameterAttrs(ArgAttrs, Ty, V);
1886
1887 if (ArgAttrs.hasAttribute(Attribute::Nest)) {
1888 Assert(!SawNest, "More than one parameter has attribute nest!", V)do { if (!(!SawNest)) { CheckFailed("More than one parameter has attribute nest!"
, V); return; } } while (false)
;
1889 SawNest = true;
1890 }
1891
1892 if (ArgAttrs.hasAttribute(Attribute::Returned)) {
1893 Assert(!SawReturned, "More than one parameter has attribute returned!",do { if (!(!SawReturned)) { CheckFailed("More than one parameter has attribute returned!"
, V); return; } } while (false)
1894 V)do { if (!(!SawReturned)) { CheckFailed("More than one parameter has attribute returned!"
, V); return; } } while (false)
;
1895 Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()),do { if (!(Ty->canLosslesslyBitCastTo(FT->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' attribute"
, V); return; } } while (false)
1896 "Incompatible argument and return types for 'returned' attribute",do { if (!(Ty->canLosslesslyBitCastTo(FT->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' attribute"
, V); return; } } while (false)
1897 V)do { if (!(Ty->canLosslesslyBitCastTo(FT->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' attribute"
, V); return; } } while (false)
;
1898 SawReturned = true;
1899 }
1900
1901 if (ArgAttrs.hasAttribute(Attribute::StructRet)) {
1902 Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V)do { if (!(!SawSRet)) { CheckFailed("Cannot have multiple 'sret' parameters!"
, V); return; } } while (false)
;
1903 Assert(i == 0 || i == 1,do { if (!(i == 0 || i == 1)) { CheckFailed("Attribute 'sret' is not on first or second parameter!"
, V); return; } } while (false)
1904 "Attribute 'sret' is not on first or second parameter!", V)do { if (!(i == 0 || i == 1)) { CheckFailed("Attribute 'sret' is not on first or second parameter!"
, V); return; } } while (false)
;
1905 SawSRet = true;
1906 }
1907
1908 if (ArgAttrs.hasAttribute(Attribute::SwiftSelf)) {
1909 Assert(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V)do { if (!(!SawSwiftSelf)) { CheckFailed("Cannot have multiple 'swiftself' parameters!"
, V); return; } } while (false)
;
1910 SawSwiftSelf = true;
1911 }
1912
1913 if (ArgAttrs.hasAttribute(Attribute::SwiftAsync)) {
1914 Assert(!SawSwiftAsync, "Cannot have multiple 'swiftasync' parameters!", V)do { if (!(!SawSwiftAsync)) { CheckFailed("Cannot have multiple 'swiftasync' parameters!"
, V); return; } } while (false)
;
1915 SawSwiftAsync = true;
1916 }
1917
1918 if (ArgAttrs.hasAttribute(Attribute::SwiftError)) {
1919 Assert(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!",do { if (!(!SawSwiftError)) { CheckFailed("Cannot have multiple 'swifterror' parameters!"
, V); return; } } while (false)
1920 V)do { if (!(!SawSwiftError)) { CheckFailed("Cannot have multiple 'swifterror' parameters!"
, V); return; } } while (false)
;
1921 SawSwiftError = true;
1922 }
1923
1924 if (ArgAttrs.hasAttribute(Attribute::InAlloca)) {
1925 Assert(i == FT->getNumParams() - 1,do { if (!(i == FT->getNumParams() - 1)) { CheckFailed("inalloca isn't on the last parameter!"
, V); return; } } while (false)
1926 "inalloca isn't on the last parameter!", V)do { if (!(i == FT->getNumParams() - 1)) { CheckFailed("inalloca isn't on the last parameter!"
, V); return; } } while (false)
;
1927 }
1928 }
1929
1930 if (!Attrs.hasFnAttrs())
1931 return;
1932
1933 verifyAttributeTypes(Attrs.getFnAttrs(), V);
1934 for (Attribute FnAttr : Attrs.getFnAttrs())
1935 Assert(FnAttr.isStringAttribute() ||do { if (!(FnAttr.isStringAttribute() || Attribute::canUseAsFnAttr
(FnAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + FnAttr
.getAsString() + "' does not apply to functions!", V); return
; } } while (false)
1936 Attribute::canUseAsFnAttr(FnAttr.getKindAsEnum()),do { if (!(FnAttr.isStringAttribute() || Attribute::canUseAsFnAttr
(FnAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + FnAttr
.getAsString() + "' does not apply to functions!", V); return
; } } while (false)
1937 "Attribute '" + FnAttr.getAsString() +do { if (!(FnAttr.isStringAttribute() || Attribute::canUseAsFnAttr
(FnAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + FnAttr
.getAsString() + "' does not apply to functions!", V); return
; } } while (false)
1938 "' does not apply to functions!",do { if (!(FnAttr.isStringAttribute() || Attribute::canUseAsFnAttr
(FnAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + FnAttr
.getAsString() + "' does not apply to functions!", V); return
; } } while (false)
1939 V)do { if (!(FnAttr.isStringAttribute() || Attribute::canUseAsFnAttr
(FnAttr.getKindAsEnum()))) { CheckFailed("Attribute '" + FnAttr
.getAsString() + "' does not apply to functions!", V); return
; } } while (false)
;
1940
1941 Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::ReadOnly)))) { CheckFailed("Attributes 'readnone and readonly' are incompatible!"
, V); return; } } while (false)
1942 Attrs.hasFnAttr(Attribute::ReadOnly)),do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::ReadOnly)))) { CheckFailed("Attributes 'readnone and readonly' are incompatible!"
, V); return; } } while (false)
1943 "Attributes 'readnone and readonly' are incompatible!", V)do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::ReadOnly)))) { CheckFailed("Attributes 'readnone and readonly' are incompatible!"
, V); return; } } while (false)
;
1944
1945 Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readnone and writeonly' are incompatible!"
, V); return; } } while (false)
1946 Attrs.hasFnAttr(Attribute::WriteOnly)),do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readnone and writeonly' are incompatible!"
, V); return; } } while (false)
1947 "Attributes 'readnone and writeonly' are incompatible!", V)do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readnone and writeonly' are incompatible!"
, V); return; } } while (false)
;
1948
1949 Assert(!(Attrs.hasFnAttr(Attribute::ReadOnly) &&do { if (!(!(Attrs.hasFnAttr(Attribute::ReadOnly) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readonly and writeonly' are incompatible!"
, V); return; } } while (false)
1950 Attrs.hasFnAttr(Attribute::WriteOnly)),do { if (!(!(Attrs.hasFnAttr(Attribute::ReadOnly) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readonly and writeonly' are incompatible!"
, V); return; } } while (false)
1951 "Attributes 'readonly and writeonly' are incompatible!", V)do { if (!(!(Attrs.hasFnAttr(Attribute::ReadOnly) && Attrs
.hasFnAttr(Attribute::WriteOnly)))) { CheckFailed("Attributes 'readonly and writeonly' are incompatible!"
, V); return; } } while (false)
;
1952
1953 Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)))) { CheckFailed
("Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!", V); return; } } while (false)
1954 Attrs.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)),do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)))) { CheckFailed
("Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!", V); return; } } while (false)
1955 "Attributes 'readnone and inaccessiblemem_or_argmemonly' are "do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)))) { CheckFailed
("Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!", V); return; } } while (false)
1956 "incompatible!",do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)))) { CheckFailed
("Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!", V); return; } } while (false)
1957 V)do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly)))) { CheckFailed
("Attributes 'readnone and inaccessiblemem_or_argmemonly' are "
"incompatible!", V); return; } } while (false)
;
1958
1959 Assert(!(Attrs.hasFnAttr(Attribute::ReadNone) &&do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOnly)))) { CheckFailed("Attributes 'readnone and inaccessiblememonly' are incompatible!"
, V); return; } } while (false)
1960 Attrs.hasFnAttr(Attribute::InaccessibleMemOnly)),do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOnly)))) { CheckFailed("Attributes 'readnone and inaccessiblememonly' are incompatible!"
, V); return; } } while (false)
1961 "Attributes 'readnone and inaccessiblememonly' are incompatible!", V)do { if (!(!(Attrs.hasFnAttr(Attribute::ReadNone) && Attrs
.hasFnAttr(Attribute::InaccessibleMemOnly)))) { CheckFailed("Attributes 'readnone and inaccessiblememonly' are incompatible!"
, V); return; } } while (false)
;
1962
1963 Assert(!(Attrs.hasFnAttr(Attribute::NoInline) &&do { if (!(!(Attrs.hasFnAttr(Attribute::NoInline) && Attrs
.hasFnAttr(Attribute::AlwaysInline)))) { CheckFailed("Attributes 'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1964 Attrs.hasFnAttr(Attribute::AlwaysInline)),do { if (!(!(Attrs.hasFnAttr(Attribute::NoInline) && Attrs
.hasFnAttr(Attribute::AlwaysInline)))) { CheckFailed("Attributes 'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
1965 "Attributes 'noinline and alwaysinline' are incompatible!", V)do { if (!(!(Attrs.hasFnAttr(Attribute::NoInline) && Attrs
.hasFnAttr(Attribute::AlwaysInline)))) { CheckFailed("Attributes 'noinline and alwaysinline' are incompatible!"
, V); return; } } while (false)
;
1966
1967 if (Attrs.hasFnAttr(Attribute::OptimizeNone)) {
1968 Assert(Attrs.hasFnAttr(Attribute::NoInline),do { if (!(Attrs.hasFnAttr(Attribute::NoInline))) { CheckFailed
("Attribute 'optnone' requires 'noinline'!", V); return; } } while
(false)
1969 "Attribute 'optnone' requires 'noinline'!", V)do { if (!(Attrs.hasFnAttr(Attribute::NoInline))) { CheckFailed
("Attribute 'optnone' requires 'noinline'!", V); return; } } while
(false)
;
1970
1971 Assert(!Attrs.hasFnAttr(Attribute::OptimizeForSize),do { if (!(!Attrs.hasFnAttr(Attribute::OptimizeForSize))) { CheckFailed
("Attributes 'optsize and optnone' are incompatible!", V); return
; } } while (false)
1972 "Attributes 'optsize and optnone' are incompatible!", V)do { if (!(!Attrs.hasFnAttr(Attribute::OptimizeForSize))) { CheckFailed
("Attributes 'optsize and optnone' are incompatible!", V); return
; } } while (false)
;
1973
1974 Assert(!Attrs.hasFnAttr(Attribute::MinSize),do { if (!(!Attrs.hasFnAttr(Attribute::MinSize))) { CheckFailed
("Attributes 'minsize and optnone' are incompatible!", V); return
; } } while (false)
1975 "Attributes 'minsize and optnone' are incompatible!", V)do { if (!(!Attrs.hasFnAttr(Attribute::MinSize))) { CheckFailed
("Attributes 'minsize and optnone' are incompatible!", V); return
; } } while (false)
;
1976 }
1977
1978 if (Attrs.hasFnAttr(Attribute::JumpTable)) {
1979 const GlobalValue *GV = cast<GlobalValue>(V);
1980 Assert(GV->hasGlobalUnnamedAddr(),do { if (!(GV->hasGlobalUnnamedAddr())) { CheckFailed("Attribute 'jumptable' requires 'unnamed_addr'"
, V); return; } } while (false)
1981 "Attribute 'jumptable' requires 'unnamed_addr'", V)do { if (!(GV->hasGlobalUnnamedAddr())) { CheckFailed("Attribute 'jumptable' requires 'unnamed_addr'"
, V); return; } } while (false)
;
1982 }
1983
1984 if (Attrs.hasFnAttr(Attribute::AllocSize)) {
1985 std::pair<unsigned, Optional<unsigned>> Args =
1986 Attrs.getFnAttrs().getAllocSizeArgs();
1987
1988 auto CheckParam = [&](StringRef Name, unsigned ParamNo) {
1989 if (ParamNo >= FT->getNumParams()) {
1990 CheckFailed("'allocsize' " + Name + " argument is out of bounds", V);
1991 return false;
1992 }
1993
1994 if (!FT->getParamType(ParamNo)->isIntegerTy()) {
1995 CheckFailed("'allocsize' " + Name +
1996 " argument must refer to an integer parameter",
1997 V);
1998 return false;
1999 }
2000
2001 return true;
2002 };
2003
2004 if (!CheckParam("element size", Args.first))
2005 return;
2006
2007 if (Args.second && !CheckParam("number of elements", *Args.second))
2008 return;
2009 }
2010
2011 if (Attrs.hasFnAttr(Attribute::VScaleRange)) {
2012 std::pair<unsigned, unsigned> Args =
2013 Attrs.getFnAttrs().getVScaleRangeArgs();
2014
2015 if (Args.first > Args.second && Args.second != 0)
2016 CheckFailed("'vscale_range' minimum cannot be greater than maximum", V);
2017 }
2018
2019 if (Attrs.hasFnAttr("frame-pointer")) {
2020 StringRef FP = Attrs.getFnAttr("frame-pointer").getValueAsString();
2021 if (FP != "all" && FP != "non-leaf" && FP != "none")
2022 CheckFailed("invalid value for 'frame-pointer' attribute: " + FP, V);
2023 }
2024
2025 checkUnsignedBaseTenFuncAttr(Attrs, "patchable-function-prefix", V);
2026 checkUnsignedBaseTenFuncAttr(Attrs, "patchable-function-entry", V);
2027 checkUnsignedBaseTenFuncAttr(Attrs, "warn-stack-size", V);
2028}
2029
2030void Verifier::verifyFunctionMetadata(
2031 ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
2032 for (const auto &Pair : MDs) {
2033 if (Pair.first == LLVMContext::MD_prof) {
2034 MDNode *MD = Pair.second;
2035 Assert(MD->getNumOperands() >= 2,do { if (!(MD->getNumOperands() >= 2)) { CheckFailed("!prof annotations should have no less than 2 operands"
, MD); return; } } while (false)
2036 "!prof annotations should have no less than 2 operands", MD)do { if (!(MD->getNumOperands() >= 2)) { CheckFailed("!prof annotations should have no less than 2 operands"
, MD); return; } } while (false)
;
2037
2038 // Check first operand.
2039 Assert(MD->getOperand(0) != nullptr, "first operand should not be null",do { if (!(MD->getOperand(0) != nullptr)) { CheckFailed("first operand should not be null"
, MD); return; } } while (false)
2040 MD)do { if (!(MD->getOperand(0) != nullptr)) { CheckFailed("first operand should not be null"
, MD); return; } } while (false)
;
2041 Assert(isa<MDString>(MD->getOperand(0)),do { if (!(isa<MDString>(MD->getOperand(0)))) { CheckFailed
("expected string with name of the !prof annotation", MD); return
; } } while (false)
2042 "expected string with name of the !prof annotation", MD)do { if (!(isa<MDString>(MD->getOperand(0)))) { CheckFailed
("expected string with name of the !prof annotation", MD); return
; } } while (false)
;
2043 MDString *MDS = cast<MDString>(MD->getOperand(0));
2044 StringRef ProfName = MDS->getString();
2045 Assert(ProfName.equals("function_entry_count") ||do { if (!(ProfName.equals("function_entry_count") || ProfName
.equals("synthetic_function_entry_count"))) { CheckFailed("first operand should be 'function_entry_count'"
" or 'synthetic_function_entry_count'", MD); return; } } while
(false)
2046 ProfName.equals("synthetic_function_entry_count"),do { if (!(ProfName.equals("function_entry_count") || ProfName
.equals("synthetic_function_entry_count"))) { CheckFailed("first operand should be 'function_entry_count'"
" or 'synthetic_function_entry_count'", MD); return; } } while
(false)
2047 "first operand should be 'function_entry_count'"do { if (!(ProfName.equals("function_entry_count") || ProfName
.equals("synthetic_function_entry_count"))) { CheckFailed("first operand should be 'function_entry_count'"
" or 'synthetic_function_entry_count'", MD); return; } } while
(false)
2048 " or 'synthetic_function_entry_count'",do { if (!(ProfName.equals("function_entry_count") || ProfName
.equals("synthetic_function_entry_count"))) { CheckFailed("first operand should be 'function_entry_count'"
" or 'synthetic_function_entry_count'", MD); return; } } while
(false)
2049 MD)do { if (!(ProfName.equals("function_entry_count") || ProfName
.equals("synthetic_function_entry_count"))) { CheckFailed("first operand should be 'function_entry_count'"
" or 'synthetic_function_entry_count'", MD); return; } } while
(false)
;
2050
2051 // Check second operand.
2052 Assert(MD->getOperand(1) != nullptr, "second operand should not be null",do { if (!(MD->getOperand(1) != nullptr)) { CheckFailed("second operand should not be null"
, MD); return; } } while (false)
2053 MD)do { if (!(MD->getOperand(1) != nullptr)) { CheckFailed("second operand should not be null"
, MD); return; } } while (false)
;
2054 Assert(isa<ConstantAsMetadata>(MD->getOperand(1)),do { if (!(isa<ConstantAsMetadata>(MD->getOperand(1)
))) { CheckFailed("expected integer argument to function_entry_count"
, MD); return; } } while (false)
2055 "expected integer argument to function_entry_count", MD)do { if (!(isa<ConstantAsMetadata>(MD->getOperand(1)
))) { CheckFailed("expected integer argument to function_entry_count"
, MD); return; } } while (false)
;
2056 }
2057 }
2058}
2059
2060void Verifier::visitConstantExprsRecursively(const Constant *EntryC) {
2061 if (!ConstantExprVisited.insert(EntryC).second)
2062 return;
2063
2064 SmallVector<const Constant *, 16> Stack;
2065 Stack.push_back(EntryC);
2066
2067 while (!Stack.empty()) {
2068 const Constant *C = Stack.pop_back_val();
2069
2070 // Check this constant expression.
2071 if (const auto *CE = dyn_cast<ConstantExpr>(C))
2072 visitConstantExpr(CE);
2073
2074 if (const auto *GV = dyn_cast<GlobalValue>(C)) {
2075 // Global Values get visited separately, but we do need to make sure
2076 // that the global value is in the correct module
2077 Assert(GV->getParent() == &M, "Referencing global in another module!",do { if (!(GV->getParent() == &M)) { CheckFailed("Referencing global in another module!"
, EntryC, &M, GV, GV->getParent()); return; } } while (
false)
2078 EntryC, &M, GV, GV->getParent())do { if (!(GV->getParent() == &M)) { CheckFailed("Referencing global in another module!"
, EntryC, &M, GV, GV->getParent()); return; } } while (
false)
;
2079 continue;
2080 }
2081
2082 // Visit all sub-expressions.
2083 for (const Use &U : C->operands()) {
2084 const auto *OpC = dyn_cast<Constant>(U);
2085 if (!OpC)
2086 continue;
2087 if (!ConstantExprVisited.insert(OpC).second)
2088 continue;
2089 Stack.push_back(OpC);
2090 }
2091 }
2092}
2093
2094void Verifier::visitConstantExpr(const ConstantExpr *CE) {
2095 if (CE->getOpcode() == Instruction::BitCast)
2096 Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),do { if (!(CastInst::castIsValid(Instruction::BitCast, CE->
getOperand(0), CE->getType()))) { CheckFailed("Invalid bitcast"
, CE); return; } } while (false)
2097 CE->getType()),do { if (!(CastInst::castIsValid(Instruction::BitCast, CE->
getOperand(0), CE->getType()))) { CheckFailed("Invalid bitcast"
, CE); return; } } while (false)
2098 "Invalid bitcast", CE)do { if (!(CastInst::castIsValid(Instruction::BitCast, CE->
getOperand(0), CE->getType()))) { CheckFailed("Invalid bitcast"
, CE); return; } } while (false)
;
2099}
2100
2101bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
2102 // There shouldn't be more attribute sets than there are parameters plus the
2103 // function and return value.
2104 return Attrs.getNumAttrSets() <= Params + 2;
2105}
2106
2107/// Verify that statepoint intrinsic is well formed.
2108void Verifier::verifyStatepoint(const CallBase &Call) {
2109 assert(Call.getCalledFunction() &&(static_cast<void> (0))
2110 Call.getCalledFunction()->getIntrinsicID() ==(static_cast<void> (0))
2111 Intrinsic::experimental_gc_statepoint)(static_cast<void> (0));
2112
2113 Assert(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory() &&do { if (!(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory
() && !Call.onlyAccessesArgMemory())) { CheckFailed("gc.statepoint must read and write all memory to preserve "
"reordering restrictions required by safepoint semantics", Call
); return; } } while (false)
2114 !Call.onlyAccessesArgMemory(),do { if (!(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory
() && !Call.onlyAccessesArgMemory())) { CheckFailed("gc.statepoint must read and write all memory to preserve "
"reordering restrictions required by safepoint semantics", Call
); return; } } while (false)
2115 "gc.statepoint must read and write all memory to preserve "do { if (!(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory
() && !Call.onlyAccessesArgMemory())) { CheckFailed("gc.statepoint must read and write all memory to preserve "
"reordering restrictions required by safepoint semantics", Call
); return; } } while (false)
2116 "reordering restrictions required by safepoint semantics",do { if (!(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory
() && !Call.onlyAccessesArgMemory())) { CheckFailed("gc.statepoint must read and write all memory to preserve "
"reordering restrictions required by safepoint semantics", Call
); return; } } while (false)
2117 Call)do { if (!(!Call.doesNotAccessMemory() && !Call.onlyReadsMemory
() && !Call.onlyAccessesArgMemory())) { CheckFailed("gc.statepoint must read and write all memory to preserve "
"reordering restrictions required by safepoint semantics", Call
); return; } } while (false)
;
2118
2119 const int64_t NumPatchBytes =
2120 cast<ConstantInt>(Call.getArgOperand(1))->getSExtValue();
2121 assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!")(static_cast<void> (0));
2122 Assert(NumPatchBytes >= 0,do { if (!(NumPatchBytes >= 0)) { CheckFailed("gc.statepoint number of patchable bytes must be "
"positive", Call); return; } } while (false)
2123 "gc.statepoint number of patchable bytes must be "do { if (!(NumPatchBytes >= 0)) { CheckFailed("gc.statepoint number of patchable bytes must be "
"positive", Call); return; } } while (false)
2124 "positive",do { if (!(NumPatchBytes >= 0)) { CheckFailed("gc.statepoint number of patchable bytes must be "
"positive", Call); return; } } while (false)
2125 Call)do { if (!(NumPatchBytes >= 0)) { CheckFailed("gc.statepoint number of patchable bytes must be "
"positive", Call); return; } } while (false)
;
2126
2127 const Value *Target = Call.getArgOperand(2);
2128 auto *PT = dyn_cast<PointerType>(Target->getType());
2129 Assert(PT && PT->getElementType()->isFunctionTy(),do { if (!(PT && PT->getElementType()->isFunctionTy
())) { CheckFailed("gc.statepoint callee must be of function pointer type"
, Call, Target); return; } } while (false)
2130 "gc.statepoint callee must be of function pointer type", Call, Target)do { if (!(PT && PT->getElementType()->isFunctionTy
())) { CheckFailed("gc.statepoint callee must be of function pointer type"
, Call, Target); return; } } while (false)
;
2131 FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
2132
2133 const int NumCallArgs = cast<ConstantInt>(Call.getArgOperand(3))->getZExtValue();
2134 Assert(NumCallArgs >= 0,do { if (!(NumCallArgs >= 0)) { CheckFailed("gc.statepoint number of arguments to underlying call "
"must be positive", Call); return; } } while (false)
2135 "gc.statepoint number of arguments to underlying call "do { if (!(NumCallArgs >= 0)) { CheckFailed("gc.statepoint number of arguments to underlying call "
"must be positive", Call); return; } } while (false)
2136 "must be positive",do { if (!(NumCallArgs >= 0)) { CheckFailed("gc.statepoint number of arguments to underlying call "
"must be positive", Call); return; } } while (false)
2137 Call)do { if (!(NumCallArgs >= 0)) { CheckFailed("gc.statepoint number of arguments to underlying call "
"must be positive", Call); return; } } while (false)
;
2138 const int NumParams = (int)TargetFuncType->getNumParams();
2139 if (TargetFuncType->isVarArg()) {
2140 Assert(NumCallArgs >= NumParams,do { if (!(NumCallArgs >= NumParams)) { CheckFailed("gc.statepoint mismatch in number of vararg call args"
, Call); return; } } while (false)
2141 "gc.statepoint mismatch in number of vararg call args", Call)do { if (!(NumCallArgs >= NumParams)) { CheckFailed("gc.statepoint mismatch in number of vararg call args"
, Call); return; } } while (false)
;
2142
2143 // TODO: Remove this limitation
2144 Assert(TargetFuncType->getReturnType()->isVoidTy(),do { if (!(TargetFuncType->getReturnType()->isVoidTy())
) { CheckFailed("gc.statepoint doesn't support wrapping non-void "
"vararg functions yet", Call); return; } } while (false)
2145 "gc.statepoint doesn't support wrapping non-void "do { if (!(TargetFuncType->getReturnType()->isVoidTy())
) { CheckFailed("gc.statepoint doesn't support wrapping non-void "
"vararg functions yet", Call); return; } } while (false)
2146 "vararg functions yet",do { if (!(TargetFuncType->getReturnType()->isVoidTy())
) { CheckFailed("gc.statepoint doesn't support wrapping non-void "
"vararg functions yet", Call); return; } } while (false)
2147 Call)do { if (!(TargetFuncType->getReturnType()->isVoidTy())
) { CheckFailed("gc.statepoint doesn't support wrapping non-void "
"vararg functions yet", Call); return; } } while (false)
;
2148 } else
2149 Assert(NumCallArgs == NumParams,do { if (!(NumCallArgs == NumParams)) { CheckFailed("gc.statepoint mismatch in number of call args"
, Call); return; } } while (false)
2150 "gc.statepoint mismatch in number of call args", Call)do { if (!(NumCallArgs == NumParams)) { CheckFailed("gc.statepoint mismatch in number of call args"
, Call); return; } } while (false)
;
2151
2152 const uint64_t Flags
2153 = cast<ConstantInt>(Call.getArgOperand(4))->getZExtValue();
2154 Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,do { if (!((Flags & ~(uint64_t)StatepointFlags::MaskAll) ==
0)) { CheckFailed("unknown flag used in gc.statepoint flags argument"
, Call); return; } } while (false)
2155 "unknown flag used in gc.statepoint flags argument", Call)do { if (!((Flags & ~(uint64_t)StatepointFlags::MaskAll) ==
0)) { CheckFailed("unknown flag used in gc.statepoint flags argument"
, Call); return; } } while (false)
;
2156
2157 // Verify that the types of the call parameter arguments match
2158 // the type of the wrapped callee.
2159 AttributeList Attrs = Call.getAttributes();
2160 for (int i = 0; i < NumParams; i++) {
2161 Type *ParamType = TargetFuncType->getParamType(i);
2162 Type *ArgType = Call.getArgOperand(5 + i)->getType();
2163 Assert(ArgType == ParamType,do { if (!(ArgType == ParamType)) { CheckFailed("gc.statepoint call argument does not match wrapped "
"function type", Call); return; } } while (false)
2164 "gc.statepoint call argument does not match wrapped "do { if (!(ArgType == ParamType)) { CheckFailed("gc.statepoint call argument does not match wrapped "
"function type", Call); return; } } while (false)
2165 "function type",do { if (!(ArgType == ParamType)) { CheckFailed("gc.statepoint call argument does not match wrapped "
"function type", Call); return; } } while (false)
2166 Call)do { if (!(ArgType == ParamType)) { CheckFailed("gc.statepoint call argument does not match wrapped "
"function type", Call); return; } } while (false)
;
2167
2168 if (TargetFuncType->isVarArg()) {
2169 AttributeSet ArgAttrs = Attrs.getParamAttrs(5 + i);
2170 Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
2171 "Attribute 'sret' cannot be used for vararg call arguments!",do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
2172 Call)do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
;
2173 }
2174 }
2175
2176 const int EndCallArgsInx = 4 + NumCallArgs;
2177
2178 const Value *NumTransitionArgsV = Call.getArgOperand(EndCallArgsInx + 1);
2179 Assert(isa<ConstantInt>(NumTransitionArgsV),do { if (!(isa<ConstantInt>(NumTransitionArgsV))) { CheckFailed
("gc.statepoint number of transition arguments " "must be constant integer"
, Call); return; } } while (false)
2180 "gc.statepoint number of transition arguments "do { if (!(isa<ConstantInt>(NumTransitionArgsV))) { CheckFailed
("gc.statepoint number of transition arguments " "must be constant integer"
, Call); return; } } while (false)
2181 "must be constant integer",do { if (!(isa<ConstantInt>(NumTransitionArgsV))) { CheckFailed
("gc.statepoint number of transition arguments " "must be constant integer"
, Call); return; } } while (false)
2182 Call)do { if (!(isa<ConstantInt>(NumTransitionArgsV))) { CheckFailed
("gc.statepoint number of transition arguments " "must be constant integer"
, Call); return; } } while (false)
;
2183 const int NumTransitionArgs =
2184 cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
2185 Assert(NumTransitionArgs == 0,do { if (!(NumTransitionArgs == 0)) { CheckFailed("gc.statepoint w/inline transition bundle is deprecated"
, Call); return; } } while (false)
2186 "gc.statepoint w/inline transition bundle is deprecated", Call)do { if (!(NumTransitionArgs == 0)) { CheckFailed("gc.statepoint w/inline transition bundle is deprecated"
, Call); return; } } while (false)
;
2187 const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
2188
2189 const Value *NumDeoptArgsV = Call.getArgOperand(EndTransitionArgsInx + 1);
2190 Assert(isa<ConstantInt>(NumDeoptArgsV),do { if (!(isa<ConstantInt>(NumDeoptArgsV))) { CheckFailed
("gc.statepoint number of deoptimization arguments " "must be constant integer"
, Call); return; } } while (false)
2191 "gc.statepoint number of deoptimization arguments "do { if (!(isa<ConstantInt>(NumDeoptArgsV))) { CheckFailed
("gc.statepoint number of deoptimization arguments " "must be constant integer"
, Call); return; } } while (false)
2192 "must be constant integer",do { if (!(isa<ConstantInt>(NumDeoptArgsV))) { CheckFailed
("gc.statepoint number of deoptimization arguments " "must be constant integer"
, Call); return; } } while (false)
2193 Call)do { if (!(isa<ConstantInt>(NumDeoptArgsV))) { CheckFailed
("gc.statepoint number of deoptimization arguments " "must be constant integer"
, Call); return; } } while (false)
;
2194 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
2195 Assert(NumDeoptArgs == 0,do { if (!(NumDeoptArgs == 0)) { CheckFailed("gc.statepoint w/inline deopt operands is deprecated"
, Call); return; } } while (false)
2196 "gc.statepoint w/inline deopt operands is deprecated", Call)do { if (!(NumDeoptArgs == 0)) { CheckFailed("gc.statepoint w/inline deopt operands is deprecated"
, Call); return; } } while (false)
;
2197
2198 const int ExpectedNumArgs = 7 + NumCallArgs;
2199 Assert(ExpectedNumArgs == (int)Call.arg_size(),do { if (!(ExpectedNumArgs == (int)Call.arg_size())) { CheckFailed
("gc.statepoint too many arguments", Call); return; } } while
(false)
2200 "gc.statepoint too many arguments", Call)do { if (!(ExpectedNumArgs == (int)Call.arg_size())) { CheckFailed
("gc.statepoint too many arguments", Call); return; } } while
(false)
;
2201
2202 // Check that the only uses of this gc.statepoint are gc.result or
2203 // gc.relocate calls which are tied to this statepoint and thus part
2204 // of the same statepoint sequence
2205 for (const User *U : Call.users()) {
2206 const CallInst *UserCall = dyn_cast<const CallInst>(U);
2207 Assert(UserCall, "illegal use of statepoint token", Call, U)do { if (!(UserCall)) { CheckFailed("illegal use of statepoint token"
, Call, U); return; } } while (false)
;
2208 if (!UserCall)
2209 continue;
2210 Assert(isa<GCRelocateInst>(UserCall) || isa<GCResultInst>(UserCall),do { if (!(isa<GCRelocateInst>(UserCall) || isa<GCResultInst
>(UserCall))) { CheckFailed("gc.result or gc.relocate are the only value uses "
"of a gc.statepoint", Call, U); return; } } while (false)
2211 "gc.result or gc.relocate are the only value uses "do { if (!(isa<GCRelocateInst>(UserCall) || isa<GCResultInst
>(UserCall))) { CheckFailed("gc.result or gc.relocate are the only value uses "
"of a gc.statepoint", Call, U); return; } } while (false)
2212 "of a gc.statepoint",do { if (!(isa<GCRelocateInst>(UserCall) || isa<GCResultInst
>(UserCall))) { CheckFailed("gc.result or gc.relocate are the only value uses "
"of a gc.statepoint", Call, U); return; } } while (false)
2213 Call, U)do { if (!(isa<GCRelocateInst>(UserCall) || isa<GCResultInst
>(UserCall))) { CheckFailed("gc.result or gc.relocate are the only value uses "
"of a gc.statepoint", Call, U); return; } } while (false)
;
2214 if (isa<GCResultInst>(UserCall)) {
2215 Assert(UserCall->getArgOperand(0) == &Call,do { if (!(UserCall->getArgOperand(0) == &Call)) { CheckFailed
("gc.result connected to wrong gc.statepoint", Call, UserCall
); return; } } while (false)
2216 "gc.result connected to wrong gc.statepoint", Call, UserCall)do { if (!(UserCall->getArgOperand(0) == &Call)) { CheckFailed
("gc.result connected to wrong gc.statepoint", Call, UserCall
); return; } } while (false)
;
2217 } else if (isa<GCRelocateInst>(Call)) {
2218 Assert(UserCall->getArgOperand(0) == &Call,do { if (!(UserCall->getArgOperand(0) == &Call)) { CheckFailed
("gc.relocate connected to wrong gc.statepoint", Call, UserCall
); return; } } while (false)
2219 "gc.relocate connected to wrong gc.statepoint", Call, UserCall)do { if (!(UserCall->getArgOperand(0) == &Call)) { CheckFailed
("gc.relocate connected to wrong gc.statepoint", Call, UserCall
); return; } } while (false)
;
2220 }
2221 }
2222
2223 // Note: It is legal for a single derived pointer to be listed multiple
2224 // times. It's non-optimal, but it is legal. It can also happen after
2225 // insertion if we strip a bitcast away.
2226 // Note: It is really tempting to check that each base is relocated and
2227 // that a derived pointer is never reused as a base pointer. This turns
2228 // out to be problematic since optimizations run after safepoint insertion
2229 // can recognize equality properties that the insertion logic doesn't know
2230 // about. See example statepoint.ll in the verifier subdirectory
2231}
2232
2233void Verifier::verifyFrameRecoverIndices() {
2234 for (auto &Counts : FrameEscapeInfo) {
2235 Function *F = Counts.first;
2236 unsigned EscapedObjectCount = Counts.second.first;
2237 unsigned MaxRecoveredIndex = Counts.second.second;
2238 Assert(MaxRecoveredIndex <= EscapedObjectCount,do { if (!(MaxRecoveredIndex <= EscapedObjectCount)) { CheckFailed
("all indices passed to llvm.localrecover must be less than the "
"number of arguments passed to llvm.localescape in the parent "
"function", F); return; } } while (false)
2239 "all indices passed to llvm.localrecover must be less than the "do { if (!(MaxRecoveredIndex <= EscapedObjectCount)) { CheckFailed
("all indices passed to llvm.localrecover must be less than the "
"number of arguments passed to llvm.localescape in the parent "
"function", F); return; } } while (false)
2240 "number of arguments passed to llvm.localescape in the parent "do { if (!(MaxRecoveredIndex <= EscapedObjectCount)) { CheckFailed
("all indices passed to llvm.localrecover must be less than the "
"number of arguments passed to llvm.localescape in the parent "
"function", F); return; } } while (false)
2241 "function",do { if (!(MaxRecoveredIndex <= EscapedObjectCount)) { CheckFailed
("all indices passed to llvm.localrecover must be less than the "
"number of arguments passed to llvm.localescape in the parent "
"function", F); return; } } while (false)
2242 F)do { if (!(MaxRecoveredIndex <= EscapedObjectCount)) { CheckFailed
("all indices passed to llvm.localrecover must be less than the "
"number of arguments passed to llvm.localescape in the parent "
"function", F); return; } } while (false)
;
2243 }
2244}
2245
2246static Instruction *getSuccPad(Instruction *Terminator) {
2247 BasicBlock *UnwindDest;
2248 if (auto *II = dyn_cast<InvokeInst>(Terminator))
2249 UnwindDest = II->getUnwindDest();
2250 else if (auto *CSI = dyn_cast<CatchSwitchInst>(Terminator))
2251 UnwindDest = CSI->getUnwindDest();
2252 else
2253 UnwindDest = cast<CleanupReturnInst>(Terminator)->getUnwindDest();
2254 return UnwindDest->getFirstNonPHI();
2255}
2256
2257void Verifier::verifySiblingFuncletUnwinds() {
2258 SmallPtrSet<Instruction *, 8> Visited;
2259 SmallPtrSet<Instruction *, 8> Active;
2260 for (const auto &Pair : SiblingFuncletInfo) {
2261 Instruction *PredPad = Pair.first;
2262 if (Visited.count(PredPad))
2263 continue;
2264 Active.insert(PredPad);
2265 Instruction *Terminator = Pair.second;
2266 do {
2267 Instruction *SuccPad = getSuccPad(Terminator);
2268 if (Active.count(SuccPad)) {
2269 // Found a cycle; report error
2270 Instruction *CyclePad = SuccPad;
2271 SmallVector<Instruction *, 8> CycleNodes;
2272 do {
2273 CycleNodes.push_back(CyclePad);
2274 Instruction *CycleTerminator = SiblingFuncletInfo[CyclePad];
2275 if (CycleTerminator != CyclePad)
2276 CycleNodes.push_back(CycleTerminator);
2277 CyclePad = getSuccPad(CycleTerminator);
2278 } while (CyclePad != SuccPad);
2279 Assert(false, "EH pads can't handle each other's exceptions",do { if (!(false)) { CheckFailed("EH pads can't handle each other's exceptions"
, ArrayRef<Instruction *>(CycleNodes)); return; } } while
(false)
2280 ArrayRef<Instruction *>(CycleNodes))do { if (!(false)) { CheckFailed("EH pads can't handle each other's exceptions"
, ArrayRef<Instruction *>(CycleNodes)); return; } } while
(false)
;
2281 }
2282 // Don't re-walk a node we've already checked
2283 if (!Visited.insert(SuccPad).second)
2284 break;
2285 // Walk to this successor if it has a map entry.
2286 PredPad = SuccPad;
2287 auto TermI = SiblingFuncletInfo.find(PredPad);
2288 if (TermI == SiblingFuncletInfo.end())
2289 break;
2290 Terminator = TermI->second;
2291 Active.insert(PredPad);
2292 } while (true);
2293 // Each node only has one successor, so we've walked all the active
2294 // nodes' successors.
2295 Active.clear();
2296 }
2297}
2298
2299// visitFunction - Verify that a function is ok.
2300//
2301void Verifier::visitFunction(const Function &F) {
2302 visitGlobalValue(F);
2303
2304 // Check function arguments.
2305 FunctionType *FT = F.getFunctionType();
2306 unsigned NumArgs = F.arg_size();
2307
2308 Assert(&Context == &F.getContext(),do { if (!(&Context == &F.getContext())) { CheckFailed
("Function context does not match Module context!", &F); return
; } } while (false)
1
Assuming the condition is true
2
Taking false branch
3
Loop condition is false. Exiting loop
2309 "Function context does not match Module context!", &F)do { if (!(&Context == &F.getContext())) { CheckFailed
("Function context does not match Module context!", &F); return
; } } while (false)
;
2310
2311 Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F)do { if (!(!F.hasCommonLinkage())) { CheckFailed("Functions may not have common linkage"
, &F); return; } } while (false)
;
4
Taking false branch
5
Loop condition is false. Exiting loop
2312 Assert(FT->getNumParams() == NumArgs,do { if (!(FT->getNumParams() == NumArgs)) { CheckFailed("# formal arguments must match # of arguments for function type!"
, &F, FT); return; } } while (false)
6
Assuming the condition is true
7
Taking false branch
2313 "# formal arguments must match # of arguments for function type!", &F,do { if (!(FT->getNumParams() == NumArgs)) { CheckFailed("# formal arguments must match # of arguments for function type!"
, &F, FT); return; } } while (false)
2314 FT)do { if (!(FT->getNumParams() == NumArgs)) { CheckFailed("# formal arguments must match # of arguments for function type!"
, &F, FT); return; } } while (false)
;
2315 Assert(F.getReturnType()->isFirstClassType() ||do { if (!(F.getReturnType()->isFirstClassType() || F.getReturnType
()->isVoidTy() || F.getReturnType()->isStructTy())) { CheckFailed
("Functions cannot return aggregate values!", &F); return
; } } while (false)
8
Loop condition is false. Exiting loop
9
Taking false branch
2316 F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),do { if (!(F.getReturnType()->isFirstClassType() || F.getReturnType
()->isVoidTy() || F.getReturnType()->isStructTy())) { CheckFailed
("Functions cannot return aggregate values!", &F); return
; } } while (false)
2317 "Functions cannot return aggregate values!", &F)do { if (!(F.getReturnType()->isFirstClassType() || F.getReturnType
()->isVoidTy() || F.getReturnType()->isStructTy())) { CheckFailed
("Functions cannot return aggregate values!", &F); return
; } } while (false)
;
2318
2319 Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),do { if (!(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy
())) { CheckFailed("Invalid struct return type!", &F); return
; } } while (false)
10
Loop condition is false. Exiting loop
11
Assuming the condition is true
12
Taking false branch
13
Loop condition is false. Exiting loop
2320 "Invalid struct return type!", &F)do { if (!(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy
())) { CheckFailed("Invalid struct return type!", &F); return
; } } while (false)
;
2321
2322 AttributeList Attrs = F.getAttributes();
2323
2324 Assert(verifyAttributeCount(Attrs, FT->getNumParams()),do { if (!(verifyAttributeCount(Attrs, FT->getNumParams())
)) { CheckFailed("Attribute after last parameter!", &F); return
; } } while (false)
14
Taking false branch
15
Loop condition is false. Exiting loop
2325 "Attribute after last parameter!", &F)do { if (!(verifyAttributeCount(Attrs, FT->getNumParams())
)) { CheckFailed("Attribute after last parameter!", &F); return
; } } while (false)
;
2326
2327 bool IsIntrinsic = F.isIntrinsic();
2328
2329 // Check function attributes.
2330 verifyFunctionAttrs(FT, Attrs, &F, IsIntrinsic);
2331
2332 // On function declarations/definitions, we do not support the builtin
2333 // attribute. We do not check this in VerifyFunctionAttrs since that is
2334 // checking for Attributes that can/can not ever be on functions.
2335 Assert(!Attrs.hasFnAttr(Attribute::Builtin),do { if (!(!Attrs.hasFnAttr(Attribute::Builtin))) { CheckFailed
("Attribute 'builtin' can only be applied to a callsite.", &
F); return; } } while (false)
16
Assuming the condition is true
17
Taking false branch
18
Loop condition is false. Exiting loop
2336 "Attribute 'builtin' can only be applied to a callsite.", &F)do { if (!(!Attrs.hasFnAttr(Attribute::Builtin))) { CheckFailed
("Attribute 'builtin' can only be applied to a callsite.", &
F); return; } } while (false)
;
2337
2338 Assert(!Attrs.hasAttrSomewhere(Attribute::ElementType),do { if (!(!Attrs.hasAttrSomewhere(Attribute::ElementType))) {
CheckFailed("Attribute 'elementtype' can only be applied to a callsite."
, &F); return; } } while (false)
19
Assuming the condition is true
20
Taking false branch
21
Loop condition is false. Exiting loop
2339 "Attribute 'elementtype' can only be applied to a callsite.", &F)do { if (!(!Attrs.hasAttrSomewhere(Attribute::ElementType))) {
CheckFailed("Attribute 'elementtype' can only be applied to a callsite."
, &F); return; } } while (false)
;
2340
2341 // Check that this function meets the restrictions on this calling convention.
2342 // Sometimes varargs is used for perfectly forwarding thunks, so some of these
2343 // restrictions can be lifted.
2344 switch (F.getCallingConv()) {
22
Control jumps to 'case C:' at line 2346
2345 default:
2346 case CallingConv::C:
2347 break;
2348 case CallingConv::X86_INTR: {
2349 Assert(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::ByVal),do { if (!(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::
ByVal))) { CheckFailed("Calling convention parameter requires byval"
, &F); return; } } while (false)
2350 "Calling convention parameter requires byval", &F)do { if (!(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::
ByVal))) { CheckFailed("Calling convention parameter requires byval"
, &F); return; } } while (false)
;
2351 break;
2352 }
2353 case CallingConv::AMDGPU_KERNEL:
2354 case CallingConv::SPIR_KERNEL:
2355 Assert(F.getReturnType()->isVoidTy(),do { if (!(F.getReturnType()->isVoidTy())) { CheckFailed("Calling convention requires void return type"
, &F); return; } } while (false)
2356 "Calling convention requires void return type", &F)do { if (!(F.getReturnType()->isVoidTy())) { CheckFailed("Calling convention requires void return type"
, &F); return; } } while (false)
;
2357 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2358 case CallingConv::AMDGPU_VS:
2359 case CallingConv::AMDGPU_HS:
2360 case CallingConv::AMDGPU_GS:
2361 case CallingConv::AMDGPU_PS:
2362 case CallingConv::AMDGPU_CS:
2363 Assert(!F.hasStructRetAttr(),do { if (!(!F.hasStructRetAttr())) { CheckFailed("Calling convention does not allow sret"
, &F); return; } } while (false)
2364 "Calling convention does not allow sret", &F)do { if (!(!F.hasStructRetAttr())) { CheckFailed("Calling convention does not allow sret"
, &F); return; } } while (false)
;
2365 if (F.getCallingConv() != CallingConv::SPIR_KERNEL) {
2366 const unsigned StackAS = DL.getAllocaAddrSpace();
2367 unsigned i = 0;
2368 for (const Argument &Arg : F.args()) {
2369 Assert(!Attrs.hasParamAttr(i, Attribute::ByVal),do { if (!(!Attrs.hasParamAttr(i, Attribute::ByVal))) { CheckFailed
("Calling convention disallows byval", &F); return; } } while
(false)
2370 "Calling convention disallows byval", &F)do { if (!(!Attrs.hasParamAttr(i, Attribute::ByVal))) { CheckFailed
("Calling convention disallows byval", &F); return; } } while
(false)
;
2371 Assert(!Attrs.hasParamAttr(i, Attribute::Preallocated),do { if (!(!Attrs.hasParamAttr(i, Attribute::Preallocated))) {
CheckFailed("Calling convention disallows preallocated", &
F); return; } } while (false)
2372 "Calling convention disallows preallocated", &F)do { if (!(!Attrs.hasParamAttr(i, Attribute::Preallocated))) {
CheckFailed("Calling convention disallows preallocated", &
F); return; } } while (false)
;
2373 Assert(!Attrs.hasParamAttr(i, Attribute::InAlloca),do { if (!(!Attrs.hasParamAttr(i, Attribute::InAlloca))) { CheckFailed
("Calling convention disallows inalloca", &F); return; } }
while (false)
2374 "Calling convention disallows inalloca", &F)do { if (!(!Attrs.hasParamAttr(i, Attribute::InAlloca))) { CheckFailed
("Calling convention disallows inalloca", &F); return; } }
while (false)
;
2375
2376 if (Attrs.hasParamAttr(i, Attribute::ByRef)) {
2377 // FIXME: Should also disallow LDS and GDS, but we don't have the enum
2378 // value here.
2379 Assert(Arg.getType()->getPointerAddressSpace() != StackAS,do { if (!(Arg.getType()->getPointerAddressSpace() != StackAS
)) { CheckFailed("Calling convention disallows stack byref", &
F); return; } } while (false)
2380 "Calling convention disallows stack byref", &F)do { if (!(Arg.getType()->getPointerAddressSpace() != StackAS
)) { CheckFailed("Calling convention disallows stack byref", &
F); return; } } while (false)
;
2381 }
2382
2383 ++i;
2384 }
2385 }
2386
2387 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2388 case CallingConv::Fast:
2389 case CallingConv::Cold:
2390 case CallingConv::Intel_OCL_BI:
2391 case CallingConv::PTX_Kernel:
2392 case CallingConv::PTX_Device:
2393 Assert(!F.isVarArg(), "Calling convention does not support varargs or "do { if (!(!F.isVarArg())) { CheckFailed("Calling convention does not support varargs or "
"perfect forwarding!", &F); return; } } while (false)
2394 "perfect forwarding!",do { if (!(!F.isVarArg())) { CheckFailed("Calling convention does not support varargs or "
"perfect forwarding!", &F); return; } } while (false)
2395 &F)do { if (!(!F.isVarArg())) { CheckFailed("Calling convention does not support varargs or "
"perfect forwarding!", &F); return; } } while (false)
;
2396 break;
2397 }
2398
2399 // Check that the argument values match the function type for this function...
2400 unsigned i = 0;
23
Execution continues on line 2400
2401 for (const Argument &Arg : F.args()) {
24
Assuming '__begin1' is equal to '__end1'
2402 Assert(Arg.getType() == FT->getParamType(i),do { if (!(Arg.getType() == FT->getParamType(i))) { CheckFailed
("Argument value does not match function argument type!", &
Arg, FT->getParamType(i)); return; } } while (false)
2403 "Argument value does not match function argument type!", &Arg,do { if (!(Arg.getType() == FT->getParamType(i))) { CheckFailed
("Argument value does not match function argument type!", &
Arg, FT->getParamType(i)); return; } } while (false)
2404 FT->getParamType(i))do { if (!(Arg.getType() == FT->getParamType(i))) { CheckFailed
("Argument value does not match function argument type!", &
Arg, FT->getParamType(i)); return; } } while (false)
;
2405 Assert(Arg.getType()->isFirstClassType(),do { if (!(Arg.getType()->isFirstClassType())) { CheckFailed
("Function arguments must have first-class types!", &Arg)
; return; } } while (false)
2406 "Function arguments must have first-class types!", &Arg)do { if (!(Arg.getType()->isFirstClassType())) { CheckFailed
("Function arguments must have first-class types!", &Arg)
; return; } } while (false)
;
2407 if (!IsIntrinsic) {
2408 Assert(!Arg.getType()->isMetadataTy(),do { if (!(!Arg.getType()->isMetadataTy())) { CheckFailed(
"Function takes metadata but isn't an intrinsic", &Arg, &
F); return; } } while (false)
2409 "Function takes metadata but isn't an intrinsic", &Arg, &F)do { if (!(!Arg.getType()->isMetadataTy())) { CheckFailed(
"Function takes metadata but isn't an intrinsic", &Arg, &
F); return; } } while (false)
;
2410 Assert(!Arg.getType()->isTokenTy(),do { if (!(!Arg.getType()->isTokenTy())) { CheckFailed("Function takes token but isn't an intrinsic"
, &Arg, &F); return; } } while (false)
2411 "Function takes token but isn't an intrinsic", &Arg, &F)do { if (!(!Arg.getType()->isTokenTy())) { CheckFailed("Function takes token but isn't an intrinsic"
, &Arg, &F); return; } } while (false)
;
2412 Assert(!Arg.getType()->isX86_AMXTy(),do { if (!(!Arg.getType()->isX86_AMXTy())) { CheckFailed("Function takes x86_amx but isn't an intrinsic"
, &Arg, &F); return; } } while (false)
2413 "Function takes x86_amx but isn't an intrinsic", &Arg, &F)do { if (!(!Arg.getType()->isX86_AMXTy())) { CheckFailed("Function takes x86_amx but isn't an intrinsic"
, &Arg, &F); return; } } while (false)
;
2414 }
2415
2416 // Check that swifterror argument is only used by loads and stores.
2417 if (Attrs.hasParamAttr(i, Attribute::SwiftError)) {
2418 verifySwiftErrorValue(&Arg);
2419 }
2420 ++i;
2421 }
2422
2423 if (!IsIntrinsic) {
25
Assuming 'IsIntrinsic' is true
26
Taking false branch
2424 Assert(!F.getReturnType()->isTokenTy(),do { if (!(!F.getReturnType()->isTokenTy())) { CheckFailed
("Function returns a token but isn't an intrinsic", &F); return
; } } while (false)
2425 "Function returns a token but isn't an intrinsic", &F)do { if (!(!F.getReturnType()->isTokenTy())) { CheckFailed
("Function returns a token but isn't an intrinsic", &F); return
; } } while (false)
;
2426 Assert(!F.getReturnType()->isX86_AMXTy(),do { if (!(!F.getReturnType()->isX86_AMXTy())) { CheckFailed
("Function returns a x86_amx but isn't an intrinsic", &F)
; return; } } while (false)
2427 "Function returns a x86_amx but isn't an intrinsic", &F)do { if (!(!F.getReturnType()->isX86_AMXTy())) { CheckFailed
("Function returns a x86_amx but isn't an intrinsic", &F)
; return; } } while (false)
;
2428 }
2429
2430 // Get the function metadata attachments.
2431 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
2432 F.getAllMetadata(MDs);
2433 assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync")(static_cast<void> (0));
2434 verifyFunctionMetadata(MDs);
2435
2436 // Check validity of the personality function
2437 if (F.hasPersonalityFn()) {
27
Assuming the condition is false
28
Taking false branch
2438 auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
2439 if (Per)
2440 Assert(Per->getParent() == F.getParent(),do { if (!(Per->getParent() == F.getParent())) { CheckFailed
("Referencing personality function in another module!", &
F, F.getParent(), Per, Per->getParent()); return; } } while
(false)
2441 "Referencing personality function in another module!",do { if (!(Per->getParent() == F.getParent())) { CheckFailed
("Referencing personality function in another module!", &
F, F.getParent(), Per, Per->getParent()); return; } } while
(false)
2442 &F, F.getParent(), Per, Per->getParent())do { if (!(Per->getParent() == F.getParent())) { CheckFailed
("Referencing personality function in another module!", &
F, F.getParent(), Per, Per->getParent()); return; } } while
(false)
;
2443 }
2444
2445 if (F.isMaterializable()) {
29
Assuming the condition is false
30
Taking false branch
2446 // Function has a body somewhere we can't see.
2447 Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,do { if (!(MDs.empty())) { CheckFailed("unmaterialized function cannot have metadata"
, &F, MDs.empty() ? nullptr : MDs.front().second); return
; } } while (false)
2448 MDs.empty() ? nullptr : MDs.front().second)do { if (!(MDs.empty())) { CheckFailed("unmaterialized function cannot have metadata"
, &F, MDs.empty() ? nullptr : MDs.front().second); return
; } } while (false)
;
2449 } else if (F.isDeclaration()) {
31
Assuming the condition is true
32
Taking true branch
2450 for (const auto &I : MDs) {
33
Assuming '__begin3' is equal to '__end3'
2451 // This is used for call site debug information.
2452 AssertDI(I.first != LLVMContext::MD_dbg ||do { if (!(I.first != LLVMContext::MD_dbg || !cast<DISubprogram
>(I.second)->isDistinct())) { DebugInfoCheckFailed("function declaration may only have a unique !dbg attachment"
, &F); return; } } while (false)
2453 !cast<DISubprogram>(I.second)->isDistinct(),do { if (!(I.first != LLVMContext::MD_dbg || !cast<DISubprogram
>(I.second)->isDistinct())) { DebugInfoCheckFailed("function declaration may only have a unique !dbg attachment"
, &F); return; } } while (false)
2454 "function declaration may only have a unique !dbg attachment",do { if (!(I.first != LLVMContext::MD_dbg || !cast<DISubprogram
>(I.second)->isDistinct())) { DebugInfoCheckFailed("function declaration may only have a unique !dbg attachment"
, &F); return; } } while (false)
2455 &F)do { if (!(I.first != LLVMContext::MD_dbg || !cast<DISubprogram
>(I.second)->isDistinct())) { DebugInfoCheckFailed("function declaration may only have a unique !dbg attachment"
, &F); return; } } while (false)
;
2456 Assert(I.first != LLVMContext::MD_prof,do { if (!(I.first != LLVMContext::MD_prof)) { CheckFailed("function declaration may not have a !prof attachment"
, &F); return; } } while (false)
2457 "function declaration may not have a !prof attachment", &F)do { if (!(I.first != LLVMContext::MD_prof)) { CheckFailed("function declaration may not have a !prof attachment"
, &F); return; } } while (false)
;
2458
2459 // Verify the metadata itself.
2460 visitMDNode(*I.second, AreDebugLocsAllowed::Yes);
2461 }
2462 Assert(!F.hasPersonalityFn(),do { if (!(!F.hasPersonalityFn())) { CheckFailed("Function declaration shouldn't have a personality routine"
, &F); return; } } while (false)
34
Assuming the condition is true
35
Taking false branch
2463 "Function declaration shouldn't have a personality routine", &F)do { if (!(!F.hasPersonalityFn())) { CheckFailed("Function declaration shouldn't have a personality routine"
, &F); return; } } while (false)
;
2464 } else {
2465 // Verify that this function (which has a body) is not named "llvm.*". It
2466 // is not legal to define intrinsics.
2467 Assert(!IsIntrinsic, "llvm intrinsics cannot be defined!", &F)do { if (!(!IsIntrinsic)) { CheckFailed("llvm intrinsics cannot be defined!"
, &F); return; } } while (false)
;
2468
2469 // Check the entry node
2470 const BasicBlock *Entry = &F.getEntryBlock();
2471 Assert(pred_empty(Entry),do { if (!(pred_empty(Entry))) { CheckFailed("Entry block to function must not have predecessors!"
, Entry); return; } } while (false)
2472 "Entry block to function must not have predecessors!", Entry)do { if (!(pred_empty(Entry))) { CheckFailed("Entry block to function must not have predecessors!"
, Entry); return; } } while (false)
;
2473
2474 // The address of the entry block cannot be taken, unless it is dead.
2475 if (Entry->hasAddressTaken()) {
2476 Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),do { if (!(!BlockAddress::lookup(Entry)->isConstantUsed())
) { CheckFailed("blockaddress may not be used with the entry block!"
, Entry); return; } } while (false)
2477 "blockaddress may not be used with the entry block!", Entry)do { if (!(!BlockAddress::lookup(Entry)->isConstantUsed())
) { CheckFailed("blockaddress may not be used with the entry block!"
, Entry); return; } } while (false)
;
2478 }
2479
2480 unsigned NumDebugAttachments = 0, NumProfAttachments = 0;
2481 // Visit metadata attachments.
2482 for (const auto &I : MDs) {
2483 // Verify that the attachment is legal.
2484 auto AllowLocs = AreDebugLocsAllowed::No;
2485 switch (I.first) {
2486 default:
2487 break;
2488 case LLVMContext::MD_dbg: {
2489 ++NumDebugAttachments;
2490 AssertDI(NumDebugAttachments == 1,do { if (!(NumDebugAttachments == 1)) { DebugInfoCheckFailed(
"function must have a single !dbg attachment", &F, I.second
); return; } } while (false)
2491 "function must have a single !dbg attachment", &F, I.second)do { if (!(NumDebugAttachments == 1)) { DebugInfoCheckFailed(
"function must have a single !dbg attachment", &F, I.second
); return; } } while (false)
;
2492 AssertDI(isa<DISubprogram>(I.second),do { if (!(isa<DISubprogram>(I.second))) { DebugInfoCheckFailed
("function !dbg attachment must be a subprogram", &F, I.second
); return; } } while (false)
2493 "function !dbg attachment must be a subprogram", &F, I.second)do { if (!(isa<DISubprogram>(I.second))) { DebugInfoCheckFailed
("function !dbg attachment must be a subprogram", &F, I.second
); return; } } while (false)
;
2494 AssertDI(cast<DISubprogram>(I.second)->isDistinct(),do { if (!(cast<DISubprogram>(I.second)->isDistinct(
))) { DebugInfoCheckFailed("function definition may only have a distinct !dbg attachment"
, &F); return; } } while (false)
2495 "function definition may only have a distinct !dbg attachment",do { if (!(cast<DISubprogram>(I.second)->isDistinct(
))) { DebugInfoCheckFailed("function definition may only have a distinct !dbg attachment"
, &F); return; } } while (false)
2496 &F)do { if (!(cast<DISubprogram>(I.second)->isDistinct(
))) { DebugInfoCheckFailed("function definition may only have a distinct !dbg attachment"
, &F); return; } } while (false)
;
2497
2498 auto *SP = cast<DISubprogram>(I.second);
2499 const Function *&AttachedTo = DISubprogramAttachments[SP];
2500 AssertDI(!AttachedTo || AttachedTo == &F,do { if (!(!AttachedTo || AttachedTo == &F)) { DebugInfoCheckFailed
("DISubprogram attached to more than one function", SP, &
F); return; } } while (false)
2501 "DISubprogram attached to more than one function", SP, &F)do { if (!(!AttachedTo || AttachedTo == &F)) { DebugInfoCheckFailed
("DISubprogram attached to more than one function", SP, &
F); return; } } while (false)
;
2502 AttachedTo = &F;
2503 AllowLocs = AreDebugLocsAllowed::Yes;
2504 break;
2505 }
2506 case LLVMContext::MD_prof:
2507 ++NumProfAttachments;
2508 Assert(NumProfAttachments == 1,do { if (!(NumProfAttachments == 1)) { CheckFailed("function must have a single !prof attachment"
, &F, I.second); return; } } while (false)
2509 "function must have a single !prof attachment", &F, I.second)do { if (!(NumProfAttachments == 1)) { CheckFailed("function must have a single !prof attachment"
, &F, I.second); return; } } while (false)
;
2510 break;
2511 }
2512
2513 // Verify the metadata itself.
2514 visitMDNode(*I.second, AllowLocs);
2515 }
2516 }
2517
2518 // If this function is actually an intrinsic, verify that it is only used in
2519 // direct call/invokes, never having its "address taken".
2520 // Only do this if the module is materialized, otherwise we don't have all the
2521 // uses.
2522 if (F.isIntrinsic() && F.getParent()->isMaterialized()) {
36
Loop condition is false. Exiting loop
37
Assuming the condition is false
2523 const User *U;
2524 if (F.hasAddressTaken(&U))
2525 Assert(false, "Invalid user of intrinsic instruction!", U)do { if (!(false)) { CheckFailed("Invalid user of intrinsic instruction!"
, U); return; } } while (false)
;
2526 }
2527
2528 // Check intrinsics' signatures.
2529 switch (F.getIntrinsicID()) {
38
'Default' branch taken. Execution continues on line 2551
2530 case Intrinsic::experimental_gc_get_pointer_base: {
2531 FunctionType *FT = F.getFunctionType();
2532 Assert(FT->getNumParams() == 1, "wrong number of parameters", F)do { if (!(FT->getNumParams() == 1)) { CheckFailed("wrong number of parameters"
, F); return; } } while (false)
;
2533 Assert(isa<PointerType>(F.getReturnType()),do { if (!(isa<PointerType>(F.getReturnType()))) { CheckFailed
("gc.get.pointer.base must return a pointer", F); return; } }
while (false)
2534 "gc.get.pointer.base must return a pointer", F)do { if (!(isa<PointerType>(F.getReturnType()))) { CheckFailed
("gc.get.pointer.base must return a pointer", F); return; } }
while (false)
;
2535 Assert(FT->getParamType(0) == F.getReturnType(),do { if (!(FT->getParamType(0) == F.getReturnType())) { CheckFailed
("gc.get.pointer.base operand and result must be of the same type"
, F); return; } } while (false)
2536 "gc.get.pointer.base operand and result must be of the same type",do { if (!(FT->getParamType(0) == F.getReturnType())) { CheckFailed
("gc.get.pointer.base operand and result must be of the same type"
, F); return; } } while (false)
2537 F)do { if (!(FT->getParamType(0) == F.getReturnType())) { CheckFailed
("gc.get.pointer.base operand and result must be of the same type"
, F); return; } } while (false)
;
2538 break;
2539 }
2540 case Intrinsic::experimental_gc_get_pointer_offset: {
2541 FunctionType *FT = F.getFunctionType();
2542 Assert(FT->getNumParams() == 1, "wrong number of parameters", F)do { if (!(FT->getNumParams() == 1)) { CheckFailed("wrong number of parameters"
, F); return; } } while (false)
;
2543 Assert(isa<PointerType>(FT->getParamType(0)),do { if (!(isa<PointerType>(FT->getParamType(0)))) {
CheckFailed("gc.get.pointer.offset operand must be a pointer"
, F); return; } } while (false)
2544 "gc.get.pointer.offset operand must be a pointer", F)do { if (!(isa<PointerType>(FT->getParamType(0)))) {
CheckFailed("gc.get.pointer.offset operand must be a pointer"
, F); return; } } while (false)
;
2545 Assert(F.getReturnType()->isIntegerTy(),do { if (!(F.getReturnType()->isIntegerTy())) { CheckFailed
("gc.get.pointer.offset must return integer", F); return; } }
while (false)
2546 "gc.get.pointer.offset must return integer", F)do { if (!(F.getReturnType()->isIntegerTy())) { CheckFailed
("gc.get.pointer.offset must return integer", F); return; } }
while (false)
;
2547 break;
2548 }
2549 }
2550
2551 auto *N = F.getSubprogram();
2552 HasDebugInfo = (N != nullptr);
39
Assuming the condition is true
2553 if (!HasDebugInfo
39.1
Field 'HasDebugInfo' is true
39.1
Field 'HasDebugInfo' is true
)
40
Taking false branch
2554 return;
2555
2556 // Check that all !dbg attachments lead to back to N.
2557 //
2558 // FIXME: Check this incrementally while visiting !dbg attachments.
2559 // FIXME: Only check when N is the canonical subprogram for F.
2560 SmallPtrSet<const MDNode *, 32> Seen;
2561 auto VisitDebugLoc = [&](const Instruction &I, const MDNode *Node) {
2562 // Be careful about using DILocation here since we might be dealing with
2563 // broken code (this is the Verifier after all).
2564 const DILocation *DL = dyn_cast_or_null<DILocation>(Node);
42
Assuming 'Node' is a 'DILocation'
2565 if (!DL
42.1
'DL' is non-null
42.1
'DL' is non-null
)
43
Taking false branch
2566 return;
2567 if (!Seen.insert(DL).second)
44
Assuming field 'second' is true
45
Taking false branch
2568 return;
2569
2570 Metadata *Parent = DL->getRawScope();
2571 AssertDI(Parent && isa<DILocalScope>(Parent),do { if (!(Parent && isa<DILocalScope>(Parent))
) { DebugInfoCheckFailed("DILocation's scope must be a DILocalScope"
, N, &F, &I, DL, Parent); return; } } while (false)
46
Assuming 'Parent' is non-null
47
Assuming 'Parent' is a 'DILocalScope'
48
Taking false branch
49
Loop condition is false. Exiting loop
2572 "DILocation's scope must be a DILocalScope", N, &F, &I, DL,do { if (!(Parent && isa<DILocalScope>(Parent))
) { DebugInfoCheckFailed("DILocation's scope must be a DILocalScope"
, N, &F, &I, DL, Parent); return; } } while (false)
2573 Parent)do { if (!(Parent && isa<DILocalScope>(Parent))
) { DebugInfoCheckFailed("DILocation's scope must be a DILocalScope"
, N, &F, &I, DL, Parent); return; } } while (false)
;
2574
2575 DILocalScope *Scope = DL->getInlinedAtScope();
50
Calling 'DILocation::getInlinedAtScope'
57
Returning from 'DILocation::getInlinedAtScope'
2576 Assert(Scope, "Failed to find DILocalScope", DL)do { if (!(Scope)) { CheckFailed("Failed to find DILocalScope"
, DL); return; } } while (false)
;
58
Taking false branch
59
Loop condition is false. Exiting loop
2577
2578 if (!Seen.insert(Scope).second)
60
Assuming field 'second' is true
61
Taking false branch
2579 return;
2580
2581 DISubprogram *SP = Scope->getSubprogram();
62
'SP' initialized here
2582
2583 // Scope and SP could be the same MDNode and we don't want to skip
2584 // validation in that case
2585 if (SP && ((Scope != SP) && !Seen.insert(SP).second))
63
Assuming 'SP' is null
64
Taking false branch
2586 return;
2587
2588 AssertDI(SP->describes(&F),do { if (!(SP->describes(&F))) { DebugInfoCheckFailed(
"!dbg attachment points at wrong subprogram for function", N,
&F, &I, DL, Scope, SP); return; } } while (false)
65
Called C++ object pointer is null
2589 "!dbg attachment points at wrong subprogram for function", N, &F,do { if (!(SP->describes(&F))) { DebugInfoCheckFailed(
"!dbg attachment points at wrong subprogram for function", N,
&F, &I, DL, Scope, SP); return; } } while (false)
2590 &I, DL, Scope, SP)do { if (!(SP->describes(&F))) { DebugInfoCheckFailed(
"!dbg attachment points at wrong subprogram for function", N,
&F, &I, DL, Scope, SP); return; } } while (false)
;
2591 };
2592 for (auto &BB : F)
2593 for (auto &I : BB) {
2594 VisitDebugLoc(I, I.getDebugLoc().getAsMDNode());
41
Calling 'operator()'
2595 // The llvm.loop annotations also contain two DILocations.
2596 if (auto MD = I.getMetadata(LLVMContext::MD_loop))
2597 for (unsigned i = 1; i < MD->getNumOperands(); ++i)
2598 VisitDebugLoc(I, dyn_cast_or_null<MDNode>(MD->getOperand(i)));
2599 if (BrokenDebugInfo)
2600 return;
2601 }
2602}
2603
2604// verifyBasicBlock - Verify that a basic block is well formed...
2605//
2606void Verifier::visitBasicBlock(BasicBlock &BB) {
2607 InstsInThisBlock.clear();
2608
2609 // Ensure that basic blocks have terminators!
2610 Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB)do { if (!(BB.getTerminator())) { CheckFailed("Basic Block does not have terminator!"
, &BB); return; } } while (false)
;
2611
2612 // Check constraints that this basic block imposes on all of the PHI nodes in
2613 // it.
2614 if (isa<PHINode>(BB.front())) {
2615 SmallVector<BasicBlock *, 8> Preds(predecessors(&BB));
2616 SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
2617 llvm::sort(Preds);
2618 for (const PHINode &PN : BB.phis()) {
2619 Assert(PN.getNumIncomingValues() == Preds.size(),do { if (!(PN.getNumIncomingValues() == Preds.size())) { CheckFailed
("PHINode should have one entry for each predecessor of its "
"parent basic block!", &PN); return; } } while (false)
2620 "PHINode should have one entry for each predecessor of its "do { if (!(PN.getNumIncomingValues() == Preds.size())) { CheckFailed
("PHINode should have one entry for each predecessor of its "
"parent basic block!", &PN); return; } } while (false)
2621 "parent basic block!",do { if (!(PN.getNumIncomingValues() == Preds.size())) { CheckFailed
("PHINode should have one entry for each predecessor of its "
"parent basic block!", &PN); return; } } while (false)
2622 &PN)do { if (!(PN.getNumIncomingValues() == Preds.size())) { CheckFailed
("PHINode should have one entry for each predecessor of its "
"parent basic block!", &PN); return; } } while (false)
;
2623
2624 // Get and sort all incoming values in the PHI node...
2625 Values.clear();
2626 Values.reserve(PN.getNumIncomingValues());
2627 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
2628 Values.push_back(
2629 std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));
2630 llvm::sort(Values);
2631
2632 for (unsigned i = 0, e = Values.size(); i != e; ++i) {
2633 // Check to make sure that if there is more than one entry for a
2634 // particular basic block in this PHI node, that the incoming values are
2635 // all identical.
2636 //
2637 Assert(i == 0 || Values[i].first != Values[i - 1].first ||do { if (!(i == 0 || Values[i].first != Values[i - 1].first ||
Values[i].second == Values[i - 1].second)) { CheckFailed("PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first, Values
[i].second, Values[i - 1].second); return; } } while (false)
2638 Values[i].second == Values[i - 1].second,do { if (!(i == 0 || Values[i].first != Values[i - 1].first ||
Values[i].second == Values[i - 1].second)) { CheckFailed("PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first, Values
[i].second, Values[i - 1].second); return; } } while (false)
2639 "PHI node has multiple entries for the same basic block with "do { if (!(i == 0 || Values[i].first != Values[i - 1].first ||
Values[i].second == Values[i - 1].second)) { CheckFailed("PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first, Values
[i].second, Values[i - 1].second); return; } } while (false)
2640 "different incoming values!",do { if (!(i == 0 || Values[i].first != Values[i - 1].first ||
Values[i].second == Values[i - 1].second)) { CheckFailed("PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first, Values
[i].second, Values[i - 1].second); return; } } while (false)
2641 &PN, Values[i].first, Values[i].second, Values[i - 1].second)do { if (!(i == 0 || Values[i].first != Values[i - 1].first ||
Values[i].second == Values[i - 1].second)) { CheckFailed("PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first, Values
[i].second, Values[i - 1].second); return; } } while (false)
;
2642
2643 // Check to make sure that the predecessors and PHI node entries are
2644 // matched up.
2645 Assert(Values[i].first == Preds[i],do { if (!(Values[i].first == Preds[i])) { CheckFailed("PHI node entries do not match predecessors!"
, &PN, Values[i].first, Preds[i]); return; } } while (false
)
2646 "PHI node entries do not match predecessors!", &PN,do { if (!(Values[i].first == Preds[i])) { CheckFailed("PHI node entries do not match predecessors!"
, &PN, Values[i].first, Preds[i]); return; } } while (false
)
2647 Values[i].first, Preds[i])do { if (!(Values[i].first == Preds[i])) { CheckFailed("PHI node entries do not match predecessors!"
, &PN, Values[i].first, Preds[i]); return; } } while (false
)
;
2648 }
2649 }
2650 }
2651
2652 // Check that all instructions have their parent pointers set up correctly.
2653 for (auto &I : BB)
2654 {
2655 Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!")do { if (!(I.getParent() == &BB)) { CheckFailed("Instruction has bogus parent pointer!"
); return; } } while (false)
;
2656 }
2657}
2658
2659void Verifier::visitTerminator(Instruction &I) {
2660 // Ensure that terminators only exist at the end of the basic block.
2661 Assert(&I == I.getParent()->getTerminator(),do { if (!(&I == I.getParent()->getTerminator())) { CheckFailed
("Terminator found in the middle of a basic block!", I.getParent
()); return; } } while (false)
2662 "Terminator found in the middle of a basic block!", I.getParent())do { if (!(&I == I.getParent()->getTerminator())) { CheckFailed
("Terminator found in the middle of a basic block!", I.getParent
()); return; } } while (false)
;
2663 visitInstruction(I);
2664}
2665
2666void Verifier::visitBranchInst(BranchInst &BI) {
2667 if (BI.isConditional()) {
2668 Assert(BI.getCondition()->getType()->isIntegerTy(1),do { if (!(BI.getCondition()->getType()->isIntegerTy(1)
)) { CheckFailed("Branch condition is not 'i1' type!", &BI
, BI.getCondition()); return; } } while (false)
2669 "Branch condition is not 'i1' type!", &BI, BI.getCondition())do { if (!(BI.getCondition()->getType()->isIntegerTy(1)
)) { CheckFailed("Branch condition is not 'i1' type!", &BI
, BI.getCondition()); return; } } while (false)
;
2670 }
2671 visitTerminator(BI);
2672}
2673
2674void Verifier::visitReturnInst(ReturnInst &RI) {
2675 Function *F = RI.getParent()->getParent();
2676 unsigned N = RI.getNumOperands();
2677 if (F->getReturnType()->isVoidTy())
2678 Assert(N == 0,do { if (!(N == 0)) { CheckFailed("Found return instr that returns non-void in Function of void "
"return type!", &RI, F->getReturnType()); return; } }
while (false)
2679 "Found return instr that returns non-void in Function of void "do { if (!(N == 0)) { CheckFailed("Found return instr that returns non-void in Function of void "
"return type!", &RI, F->getReturnType()); return; } }
while (false)
2680 "return type!",do { if (!(N == 0)) { CheckFailed("Found return instr that returns non-void in Function of void "
"return type!", &RI, F->getReturnType()); return; } }
while (false)
2681 &RI, F->getReturnType())do { if (!(N == 0)) { CheckFailed("Found return instr that returns non-void in Function of void "
"return type!", &RI, F->getReturnType()); return; } }
while (false)
;
2682 else
2683 Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),do { if (!(N == 1 && F->getReturnType() == RI.getOperand
(0)->getType())) { CheckFailed("Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType()); return
; } } while (false)
2684 "Function return type does not match operand "do { if (!(N == 1 && F->getReturnType() == RI.getOperand
(0)->getType())) { CheckFailed("Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType()); return
; } } while (false)
2685 "type of return inst!",do { if (!(N == 1 && F->getReturnType() == RI.getOperand
(0)->getType())) { CheckFailed("Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType()); return
; } } while (false)
2686 &RI, F->getReturnType())do { if (!(N == 1 && F->getReturnType() == RI.getOperand
(0)->getType())) { CheckFailed("Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType()); return
; } } while (false)
;
2687
2688 // Check to make sure that the return value has necessary properties for
2689 // terminators...
2690 visitTerminator(RI);
2691}
2692
2693void Verifier::visitSwitchInst(SwitchInst &SI) {
2694 Assert(SI.getType()->isVoidTy(), "Switch must have void result type!", &SI)do { if (!(SI.getType()->isVoidTy())) { CheckFailed("Switch must have void result type!"
, &SI); return; } } while (false)
;
2695 // Check to make sure that all of the constants in the switch instruction
2696 // have the same type as the switched-on value.
2697 Type *SwitchTy = SI.getCondition()->getType();
2698 SmallPtrSet<ConstantInt*, 32> Constants;
2699 for (auto &Case : SI.cases()) {
2700 Assert(Case.getCaseValue()->getType() == SwitchTy,do { if (!(Case.getCaseValue()->getType() == SwitchTy)) { CheckFailed
("Switch constants must all be same type as switch value!", &
SI); return; } } while (false)
2701 "Switch constants must all be same type as switch value!", &SI)do { if (!(Case.getCaseValue()->getType() == SwitchTy)) { CheckFailed
("Switch constants must all be same type as switch value!", &
SI); return; } } while (false)
;
2702 Assert(Constants.insert(Case.getCaseValue()).second,do { if (!(Constants.insert(Case.getCaseValue()).second)) { CheckFailed
("Duplicate integer as switch case", &SI, Case.getCaseValue
()); return; } } while (false)
2703 "Duplicate integer as switch case", &SI, Case.getCaseValue())do { if (!(Constants.insert(Case.getCaseValue()).second)) { CheckFailed
("Duplicate integer as switch case", &SI, Case.getCaseValue
()); return; } } while (false)
;
2704 }
2705
2706 visitTerminator(SI);
2707}
2708
2709void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
2710 Assert(BI.getAddress()->getType()->isPointerTy(),do { if (!(BI.getAddress()->getType()->isPointerTy())) {
CheckFailed("Indirectbr operand must have pointer type!", &
BI); return; } } while (false)
2711 "Indirectbr operand must have pointer type!", &BI)do { if (!(BI.getAddress()->getType()->isPointerTy())) {
CheckFailed("Indirectbr operand must have pointer type!", &
BI); return; } } while (false)
;
2712 for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
2713 Assert(BI.getDestination(i)->getType()->isLabelTy(),do { if (!(BI.getDestination(i)->getType()->isLabelTy()
)) { CheckFailed("Indirectbr destinations must all have pointer type!"
, &BI); return; } } while (false)
2714 "Indirectbr destinations must all have pointer type!", &BI)do { if (!(BI.getDestination(i)->getType()->isLabelTy()
)) { CheckFailed("Indirectbr destinations must all have pointer type!"
, &BI); return; } } while (false)
;
2715
2716 visitTerminator(BI);
2717}
2718
2719void Verifier::visitCallBrInst(CallBrInst &CBI) {
2720 Assert(CBI.isInlineAsm(), "Callbr is currently only used for asm-goto!",do { if (!(CBI.isInlineAsm())) { CheckFailed("Callbr is currently only used for asm-goto!"
, &CBI); return; } } while (false)
2721 &CBI)do { if (!(CBI.isInlineAsm())) { CheckFailed("Callbr is currently only used for asm-goto!"
, &CBI); return; } } while (false)
;
2722 const InlineAsm *IA = cast<InlineAsm>(CBI.getCalledOperand());
2723 Assert(!IA->canThrow(), "Unwinding from Callbr is not allowed")do { if (!(!IA->canThrow())) { CheckFailed("Unwinding from Callbr is not allowed"
); return; } } while (false)
;
2724 for (unsigned i = 0, e = CBI.getNumSuccessors(); i != e; ++i)
2725 Assert(CBI.getSuccessor(i)->getType()->isLabelTy(),do { if (!(CBI.getSuccessor(i)->getType()->isLabelTy())
) { CheckFailed("Callbr successors must all have pointer type!"
, &CBI); return; } } while (false)
2726 "Callbr successors must all have pointer type!", &CBI)do { if (!(CBI.getSuccessor(i)->getType()->isLabelTy())
) { CheckFailed("Callbr successors must all have pointer type!"
, &CBI); return; } } while (false)
;
2727 for (unsigned i = 0, e = CBI.getNumOperands(); i != e; ++i) {
2728 Assert(i >= CBI.getNumArgOperands() || !isa<BasicBlock>(CBI.getOperand(i)),do { if (!(i >= CBI.getNumArgOperands() || !isa<BasicBlock
>(CBI.getOperand(i)))) { CheckFailed("Using an unescaped label as a callbr argument!"
, &CBI); return; } } while (false)
2729 "Using an unescaped label as a callbr argument!", &CBI)do { if (!(i >= CBI.getNumArgOperands() || !isa<BasicBlock
>(CBI.getOperand(i)))) { CheckFailed("Using an unescaped label as a callbr argument!"
, &CBI); return; } } while (false)
;
2730 if (isa<BasicBlock>(CBI.getOperand(i)))
2731 for (unsigned j = i + 1; j != e; ++j)
2732 Assert(CBI.getOperand(i) != CBI.getOperand(j),do { if (!(CBI.getOperand(i) != CBI.getOperand(j))) { CheckFailed
("Duplicate callbr destination!", &CBI); return; } } while
(false)
2733 "Duplicate callbr destination!", &CBI)do { if (!(CBI.getOperand(i) != CBI.getOperand(j))) { CheckFailed
("Duplicate callbr destination!", &CBI); return; } } while
(false)
;
2734 }
2735 {
2736 SmallPtrSet<BasicBlock *, 4> ArgBBs;
2737 for (Value *V : CBI.args())
2738 if (auto *BA = dyn_cast<BlockAddress>(V))
2739 ArgBBs.insert(BA->getBasicBlock());
2740 for (BasicBlock *BB : CBI.getIndirectDests())
2741 Assert(ArgBBs.count(BB), "Indirect label missing from arglist.", &CBI)do { if (!(ArgBBs.count(BB))) { CheckFailed("Indirect label missing from arglist."
, &CBI); return; } } while (false)
;
2742 }
2743
2744 visitTerminator(CBI);
2745}
2746
2747void Verifier::visitSelectInst(SelectInst &SI) {
2748 Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),do { if (!(!SelectInst::areInvalidOperands(SI.getOperand(0), SI
.getOperand(1), SI.getOperand(2)))) { CheckFailed("Invalid operands for select instruction!"
, &SI); return; } } while (false)
2749 SI.getOperand(2)),do { if (!(!SelectInst::areInvalidOperands(SI.getOperand(0), SI
.getOperand(1), SI.getOperand(2)))) { CheckFailed("Invalid operands for select instruction!"
, &SI); return; } } while (false)
2750 "Invalid operands for select instruction!", &SI)do { if (!(!SelectInst::areInvalidOperands(SI.getOperand(0), SI
.getOperand(1), SI.getOperand(2)))) { CheckFailed("Invalid operands for select instruction!"
, &SI); return; } } while (false)
;
2751
2752 Assert(SI.getTrueValue()->getType() == SI.getType(),do { if (!(SI.getTrueValue()->getType() == SI.getType())) {
CheckFailed("Select values must have same type as select instruction!"
, &SI); return; } } while (false)
2753 "Select values must have same type as select instruction!", &SI)do { if (!(SI.getTrueValue()->getType() == SI.getType())) {
CheckFailed("Select values must have same type as select instruction!"
, &SI); return; } } while (false)
;
2754 visitInstruction(SI);
2755}
2756
2757/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
2758/// a pass, if any exist, it's an error.
2759///
2760void Verifier::visitUserOp1(Instruction &I) {
2761 Assert(false, "User-defined operators should not live outside of a pass!", &I)do { if (!(false)) { CheckFailed("User-defined operators should not live outside of a pass!"
, &I); return; } } while (false)
;
2762}
2763
2764void Verifier::visitTruncInst(TruncInst &I) {
2765 // Get the source and destination types
2766 Type *SrcTy = I.getOperand(0)->getType();
2767 Type *DestTy = I.getType();
2768
2769 // Get the size of the types in bits, we'll need this later
2770 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2771 unsigned DestBitSize = DestTy->getScalarSizeInBits();
2772
2773 Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("Trunc only operates on integer"
, &I); return; } } while (false)
;
2774 Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("Trunc only produces integer"
, &I); return; } } while (false)
;
2775 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("trunc source and destination must both be a vector or neither"
, &I); return; } } while (false)
2776 "trunc source and destination must both be a vector or neither", &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("trunc source and destination must both be a vector or neither"
, &I); return; } } while (false)
;
2777 Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I)do { if (!(SrcBitSize > DestBitSize)) { CheckFailed("DestTy too big for Trunc"
, &I); return; } } while (false)
;
2778
2779 visitInstruction(I);
2780}
2781
2782void Verifier::visitZExtInst(ZExtInst &I) {
2783 // Get the source and destination types
2784 Type *SrcTy = I.getOperand(0)->getType();
2785 Type *DestTy = I.getType();
2786
2787 // Get the size of the types in bits, we'll need this later
2788 Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("ZExt only operates on integer"
, &I); return; } } while (false)
;
2789 Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("ZExt only produces an integer"
, &I); return; } } while (false)
;
2790 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("zext source and destination must both be a vector or neither"
, &I); return; } } while (false)
2791 "zext source and destination must both be a vector or neither", &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("zext source and destination must both be a vector or neither"
, &I); return; } } while (false)
;
2792 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2793 unsigned DestBitSize = DestTy->getScalarSizeInBits();
2794
2795 Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I)do { if (!(SrcBitSize < DestBitSize)) { CheckFailed("Type too small for ZExt"
, &I); return; } } while (false)
;
2796
2797 visitInstruction(I);
2798}
2799
2800void Verifier::visitSExtInst(SExtInst &I) {
2801 // Get the source and destination types
2802 Type *SrcTy = I.getOperand(0)->getType();
2803 Type *DestTy = I.getType();
2804
2805 // Get the size of the types in bits, we'll need this later
2806 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2807 unsigned DestBitSize = DestTy->getScalarSizeInBits();
2808
2809 Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("SExt only operates on integer"
, &I); return; } } while (false)
;
2810 Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("SExt only produces an integer"
, &I); return; } } while (false)
;
2811 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("sext source and destination must both be a vector or neither"
, &I); return; } } while (false)
2812 "sext source and destination must both be a vector or neither", &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("sext source and destination must both be a vector or neither"
, &I); return; } } while (false)
;
2813 Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I)do { if (!(SrcBitSize < DestBitSize)) { CheckFailed("Type too small for SExt"
, &I); return; } } while (false)
;
2814
2815 visitInstruction(I);
2816}
2817
2818void Verifier::visitFPTruncInst(FPTruncInst &I) {
2819 // Get the source and destination types
2820 Type *SrcTy = I.getOperand(0)->getType();
2821 Type *DestTy = I.getType();
2822 // Get the size of the types in bits, we'll need this later
2823 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2824 unsigned DestBitSize = DestTy->getScalarSizeInBits();
2825
2826 Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I)do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPTrunc only operates on FP"
, &I); return; } } while (false)
;
2827 Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I)do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("FPTrunc only produces an FP"
, &I); return; } } while (false)
;
2828 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("fptrunc source and destination must both be a vector or neither"
, &I); return; } } while (false)
2829 "fptrunc source and destination must both be a vector or neither", &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("fptrunc source and destination must both be a vector or neither"
, &I); return; } } while (false)
;
2830 Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I)do { if (!(SrcBitSize > DestBitSize)) { CheckFailed("DestTy too big for FPTrunc"
, &I); return; } } while (false)
;
2831
2832 visitInstruction(I);
2833}
2834
2835void Verifier::visitFPExtInst(FPExtInst &I) {
2836 // Get the source and destination types
2837 Type *SrcTy = I.getOperand(0)->getType();
2838 Type *DestTy = I.getType();
2839
2840 // Get the size of the types in bits, we'll need this later
2841 unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2842 unsigned DestBitSize = DestTy->getScalarSizeInBits();
2843
2844 Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I)do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPExt only operates on FP"
, &I); return; } } while (false)
;
2845 Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I)do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("FPExt only produces an FP"
, &I); return; } } while (false)
;
2846 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("fpext source and destination must both be a vector or neither"
, &I); return; } } while (false)
2847 "fpext source and destination must both be a vector or neither", &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("fpext source and destination must both be a vector or neither"
, &I); return; } } while (false)
;
2848 Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I)do { if (!(SrcBitSize < DestBitSize)) { CheckFailed("DestTy too small for FPExt"
, &I); return; } } while (false)
;
2849
2850 visitInstruction(I);
2851}
2852
2853void Verifier::visitUIToFPInst(UIToFPInst &I) {
2854 // Get the source and destination types
2855 Type *SrcTy = I.getOperand(0)->getType();
2856 Type *DestTy = I.getType();
2857
2858 bool SrcVec = SrcTy->isVectorTy();
2859 bool DstVec = DestTy->isVectorTy();
2860
2861 Assert(SrcVec == DstVec,do { if (!(SrcVec == DstVec)) { CheckFailed("UIToFP source and dest must both be vector or scalar"
, &I); return; } } while (false)
2862 "UIToFP source and dest must both be vector or scalar", &I)do { if (!(SrcVec == DstVec)) { CheckFailed("UIToFP source and dest must both be vector or scalar"
, &I); return; } } while (false)
;
2863 Assert(SrcTy->isIntOrIntVectorTy(),do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("UIToFP source must be integer or integer vector"
, &I); return; } } while (false)
2864 "UIToFP source must be integer or integer vector", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("UIToFP source must be integer or integer vector"
, &I); return; } } while (false)
;
2865 Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("UIToFP result must be FP or FP vector"
, &I); return; } } while (false)
2866 &I)do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("UIToFP result must be FP or FP vector"
, &I); return; } } while (false)
;
2867
2868 if (SrcVec && DstVec)
2869 Assert(cast<VectorType>(SrcTy)->getElementCount() ==do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("UIToFP source and dest vector length mismatch",
&I); return; } } while (false)
2870 cast<VectorType>(DestTy)->getElementCount(),do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("UIToFP source and dest vector length mismatch",
&I); return; } } while (false)
2871 "UIToFP source and dest vector length mismatch", &I)do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("UIToFP source and dest vector length mismatch",
&I); return; } } while (false)
;
2872
2873 visitInstruction(I);
2874}
2875
2876void Verifier::visitSIToFPInst(SIToFPInst &I) {
2877 // Get the source and destination types
2878 Type *SrcTy = I.getOperand(0)->getType();
2879 Type *DestTy = I.getType();
2880
2881 bool SrcVec = SrcTy->isVectorTy();
2882 bool DstVec = DestTy->isVectorTy();
2883
2884 Assert(SrcVec == DstVec,do { if (!(SrcVec == DstVec)) { CheckFailed("SIToFP source and dest must both be vector or scalar"
, &I); return; } } while (false)
2885 "SIToFP source and dest must both be vector or scalar", &I)do { if (!(SrcVec == DstVec)) { CheckFailed("SIToFP source and dest must both be vector or scalar"
, &I); return; } } while (false)
;
2886 Assert(SrcTy->isIntOrIntVectorTy(),do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("SIToFP source must be integer or integer vector"
, &I); return; } } while (false)
2887 "SIToFP source must be integer or integer vector", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("SIToFP source must be integer or integer vector"
, &I); return; } } while (false)
;
2888 Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("SIToFP result must be FP or FP vector"
, &I); return; } } while (false)
2889 &I)do { if (!(DestTy->isFPOrFPVectorTy())) { CheckFailed("SIToFP result must be FP or FP vector"
, &I); return; } } while (false)
;
2890
2891 if (SrcVec && DstVec)
2892 Assert(cast<VectorType>(SrcTy)->getElementCount() ==do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("SIToFP source and dest vector length mismatch",
&I); return; } } while (false)
2893 cast<VectorType>(DestTy)->getElementCount(),do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("SIToFP source and dest vector length mismatch",
&I); return; } } while (false)
2894 "SIToFP source and dest vector length mismatch", &I)do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("SIToFP source and dest vector length mismatch",
&I); return; } } while (false)
;
2895
2896 visitInstruction(I);
2897}
2898
2899void Verifier::visitFPToUIInst(FPToUIInst &I) {
2900 // Get the source and destination types
2901 Type *SrcTy = I.getOperand(0)->getType();
2902 Type *DestTy = I.getType();
2903
2904 bool SrcVec = SrcTy->isVectorTy();
2905 bool DstVec = DestTy->isVectorTy();
2906
2907 Assert(SrcVec == DstVec,do { if (!(SrcVec == DstVec)) { CheckFailed("FPToUI source and dest must both be vector or scalar"
, &I); return; } } while (false)
2908 "FPToUI source and dest must both be vector or scalar", &I)do { if (!(SrcVec == DstVec)) { CheckFailed("FPToUI source and dest must both be vector or scalar"
, &I); return; } } while (false)
;
2909 Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPToUI source must be FP or FP vector"
, &I); return; } } while (false)
2910 &I)do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPToUI source must be FP or FP vector"
, &I); return; } } while (false)
;
2911 Assert(DestTy->isIntOrIntVectorTy(),do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("FPToUI result must be integer or integer vector"
, &I); return; } } while (false)
2912 "FPToUI result must be integer or integer vector", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("FPToUI result must be integer or integer vector"
, &I); return; } } while (false)
;
2913
2914 if (SrcVec && DstVec)
2915 Assert(cast<VectorType>(SrcTy)->getElementCount() ==do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToUI source and dest vector length mismatch",
&I); return; } } while (false)
2916 cast<VectorType>(DestTy)->getElementCount(),do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToUI source and dest vector length mismatch",
&I); return; } } while (false)
2917 "FPToUI source and dest vector length mismatch", &I)do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToUI source and dest vector length mismatch",
&I); return; } } while (false)
;
2918
2919 visitInstruction(I);
2920}
2921
2922void Verifier::visitFPToSIInst(FPToSIInst &I) {
2923 // Get the source and destination types
2924 Type *SrcTy = I.getOperand(0)->getType();
2925 Type *DestTy = I.getType();
2926
2927 bool SrcVec = SrcTy->isVectorTy();
2928 bool DstVec = DestTy->isVectorTy();
2929
2930 Assert(SrcVec == DstVec,do { if (!(SrcVec == DstVec)) { CheckFailed("FPToSI source and dest must both be vector or scalar"
, &I); return; } } while (false)
2931 "FPToSI source and dest must both be vector or scalar", &I)do { if (!(SrcVec == DstVec)) { CheckFailed("FPToSI source and dest must both be vector or scalar"
, &I); return; } } while (false)
;
2932 Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPToSI source must be FP or FP vector"
, &I); return; } } while (false)
2933 &I)do { if (!(SrcTy->isFPOrFPVectorTy())) { CheckFailed("FPToSI source must be FP or FP vector"
, &I); return; } } while (false)
;
2934 Assert(DestTy->isIntOrIntVectorTy(),do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("FPToSI result must be integer or integer vector"
, &I); return; } } while (false)
2935 "FPToSI result must be integer or integer vector", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("FPToSI result must be integer or integer vector"
, &I); return; } } while (false)
;
2936
2937 if (SrcVec && DstVec)
2938 Assert(cast<VectorType>(SrcTy)->getElementCount() ==do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToSI source and dest vector length mismatch",
&I); return; } } while (false)
2939 cast<VectorType>(DestTy)->getElementCount(),do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToSI source and dest vector length mismatch",
&I); return; } } while (false)
2940 "FPToSI source and dest vector length mismatch", &I)do { if (!(cast<VectorType>(SrcTy)->getElementCount(
) == cast<VectorType>(DestTy)->getElementCount())) {
CheckFailed("FPToSI source and dest vector length mismatch",
&I); return; } } while (false)
;
2941
2942 visitInstruction(I);
2943}
2944
2945void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
2946 // Get the source and destination types
2947 Type *SrcTy = I.getOperand(0)->getType();
2948 Type *DestTy = I.getType();
2949
2950 Assert(SrcTy->isPtrOrPtrVectorTy(), "PtrToInt source must be pointer", &I)do { if (!(SrcTy->isPtrOrPtrVectorTy())) { CheckFailed("PtrToInt source must be pointer"
, &I); return; } } while (false)
;
2951
2952 Assert(DestTy->isIntOrIntVectorTy(), "PtrToInt result must be integral", &I)do { if (!(DestTy->isIntOrIntVectorTy())) { CheckFailed("PtrToInt result must be integral"
, &I); return; } } while (false)
;
2953 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("PtrToInt type mismatch", &I); return; } }
while (false)
2954 &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("PtrToInt type mismatch", &I); return; } }
while (false)
;
2955
2956 if (SrcTy->isVectorTy()) {
2957 auto *VSrc = cast<VectorType>(SrcTy);
2958 auto *VDest = cast<VectorType>(DestTy);
2959 Assert(VSrc->getElementCount() == VDest->getElementCount(),do { if (!(VSrc->getElementCount() == VDest->getElementCount
())) { CheckFailed("PtrToInt Vector width mismatch", &I);
return; } } while (false)
2960 "PtrToInt Vector width mismatch", &I)do { if (!(VSrc->getElementCount() == VDest->getElementCount
())) { CheckFailed("PtrToInt Vector width mismatch", &I);
return; } } while (false)
;
2961 }
2962
2963 visitInstruction(I);
2964}
2965
2966void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
2967 // Get the source and destination types
2968 Type *SrcTy = I.getOperand(0)->getType();
2969 Type *DestTy = I.getType();
2970
2971 Assert(SrcTy->isIntOrIntVectorTy(),do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("IntToPtr source must be an integral"
, &I); return; } } while (false)
2972 "IntToPtr source must be an integral", &I)do { if (!(SrcTy->isIntOrIntVectorTy())) { CheckFailed("IntToPtr source must be an integral"
, &I); return; } } while (false)
;
2973 Assert(DestTy->isPtrOrPtrVectorTy(), "IntToPtr result must be a pointer", &I)do { if (!(DestTy->isPtrOrPtrVectorTy())) { CheckFailed("IntToPtr result must be a pointer"
, &I); return; } } while (false)
;
2974
2975 Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("IntToPtr type mismatch", &I); return; } }
while (false)
2976 &I)do { if (!(SrcTy->isVectorTy() == DestTy->isVectorTy())
) { CheckFailed("IntToPtr type mismatch", &I); return; } }
while (false)
;
2977 if (SrcTy->isVectorTy()) {
2978 auto *VSrc = cast<VectorType>(SrcTy);
2979 auto *VDest = cast<VectorType>(DestTy);
2980 Assert(VSrc->getElementCount() == VDest->getElementCount(),do { if (!(VSrc->getElementCount() == VDest->getElementCount
())) { CheckFailed("IntToPtr Vector width mismatch", &I);
return; } } while (false)
2981 "IntToPtr Vector width mismatch", &I)do { if (!(VSrc->getElementCount() == VDest->getElementCount
())) { CheckFailed("IntToPtr Vector width mismatch", &I);
return; } } while (false)
;
2982 }
2983 visitInstruction(I);
2984}
2985
2986void Verifier::visitBitCastInst(BitCastInst &I) {
2987 Assert(do { if (!(CastInst::castIsValid(Instruction::BitCast, I.getOperand
(0), I.getType()))) { CheckFailed("Invalid bitcast", &I);
return; } } while (false)
2988 CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),do { if (!(CastInst::castIsValid(Instruction::BitCast, I.getOperand
(0), I.getType()))) { CheckFailed("Invalid bitcast", &I);
return; } } while (false)
2989 "Invalid bitcast", &I)do { if (!(CastInst::castIsValid(Instruction::BitCast, I.getOperand
(0), I.getType()))) { CheckFailed("Invalid bitcast", &I);
return; } } while (false)
;
2990 visitInstruction(I);
2991}
2992
2993void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
2994 Type *SrcTy = I.getOperand(0)->getType();
2995 Type *DestTy = I.getType();
2996
2997 Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",do { if (!(SrcTy->isPtrOrPtrVectorTy())) { CheckFailed("AddrSpaceCast source must be a pointer"
, &I); return; } } while (false)
2998 &I)do { if (!(SrcTy->isPtrOrPtrVectorTy())) { CheckFailed("AddrSpaceCast source must be a pointer"
, &I); return; } } while (false)
;
2999 Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",do { if (!(DestTy->isPtrOrPtrVectorTy())) { CheckFailed("AddrSpaceCast result must be a pointer"
, &I); return; } } while (false)
3000 &I)do { if (!(DestTy->isPtrOrPtrVectorTy())) { CheckFailed("AddrSpaceCast result must be a pointer"
, &I); return; } } while (false)
;
3001 Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),do { if (!(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace
())) { CheckFailed("AddrSpaceCast must be between different address spaces"
, &I); return; } } while (false)
3002 "AddrSpaceCast must be between different address spaces", &I)do { if (!(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace
())) { CheckFailed("AddrSpaceCast must be between different address spaces"
, &I); return; } } while (false)
;
3003 if (auto *SrcVTy = dyn_cast<VectorType>(SrcTy))
3004 Assert(SrcVTy->getElementCount() ==do { if (!(SrcVTy->getElementCount() == cast<VectorType
>(DestTy)->getElementCount())) { CheckFailed("AddrSpaceCast vector pointer number of elements mismatch"
, &I); return; } } while (false)
3005 cast<VectorType>(DestTy)->getElementCount(),do { if (!(SrcVTy->getElementCount() == cast<VectorType
>(DestTy)->getElementCount())) { CheckFailed("AddrSpaceCast vector pointer number of elements mismatch"
, &I); return; } } while (false)
3006 "AddrSpaceCast vector pointer number of elements mismatch", &I)do { if (!(SrcVTy->getElementCount() == cast<VectorType
>(DestTy)->getElementCount())) { CheckFailed("AddrSpaceCast vector pointer number of elements mismatch"
, &I); return; } } while (false)
;
3007 visitInstruction(I);
3008}
3009
3010/// visitPHINode - Ensure that a PHI node is well formed.
3011///
3012void Verifier::visitPHINode(PHINode &PN) {
3013 // Ensure that the PHI nodes are all grouped together at the top of the block.
3014 // This can be tested by checking whether the instruction before this is
3015 // either nonexistent (because this is begin()) or is a PHI node. If not,
3016 // then there is some other instruction before a PHI.
3017 Assert(&PN == &PN.getParent()->front() ||do { if (!(&PN == &PN.getParent()->front() || isa<
PHINode>(--BasicBlock::iterator(&PN)))) { CheckFailed(
"PHI nodes not grouped at top of basic block!", &PN, PN.getParent
()); return; } } while (false)
3018 isa<PHINode>(--BasicBlock::iterator(&PN)),do { if (!(&PN == &PN.getParent()->front() || isa<
PHINode>(--BasicBlock::iterator(&PN)))) { CheckFailed(
"PHI nodes not grouped at top of basic block!", &PN, PN.getParent
()); return; } } while (false)
3019 "PHI nodes not grouped at top of basic block!", &PN, PN.getParent())do { if (!(&PN == &PN.getParent()->front() || isa<
PHINode>(--BasicBlock::iterator(&PN)))) { CheckFailed(
"PHI nodes not grouped at top of basic block!", &PN, PN.getParent
()); return; } } while (false)
;
3020
3021 // Check that a PHI doesn't yield a Token.
3022 Assert(!PN.getType()->isTokenTy(), "PHI nodes cannot have token type!")do { if (!(!PN.getType()->isTokenTy())) { CheckFailed("PHI nodes cannot have token type!"
); return; } } while (false)
;
3023
3024 // Check that all of the values of the PHI node have the same type as the
3025 // result, and that the incoming blocks are really basic blocks.
3026 for (Value *IncValue : PN.incoming_values()) {
3027 Assert(PN.getType() == IncValue->getType(),do { if (!(PN.getType() == IncValue->getType())) { CheckFailed
("PHI node operands are not the same type as the result!", &
PN); return; } } while (false)
3028 "PHI node operands are not the same type as the result!", &PN)do { if (!(PN.getType() == IncValue->getType())) { CheckFailed
("PHI node operands are not the same type as the result!", &
PN); return; } } while (false)
;
3029 }
3030
3031 // All other PHI node constraints are checked in the visitBasicBlock method.
3032
3033 visitInstruction(PN);
3034}
3035
3036void Verifier::visitCallBase(CallBase &Call) {
3037 Assert(Call.getCalledOperand()->getType()->isPointerTy(),do { if (!(Call.getCalledOperand()->getType()->isPointerTy
())) { CheckFailed("Called function must be a pointer!", Call
); return; } } while (false)
3038 "Called function must be a pointer!", Call)do { if (!(Call.getCalledOperand()->getType()->isPointerTy
())) { CheckFailed("Called function must be a pointer!", Call
); return; } } while (false)
;
3039 PointerType *FPTy = cast<PointerType>(Call.getCalledOperand()->getType());
3040
3041 Assert(FPTy->isOpaqueOrPointeeTypeMatches(Call.getFunctionType()),do { if (!(FPTy->isOpaqueOrPointeeTypeMatches(Call.getFunctionType
()))) { CheckFailed("Called function is not the same type as the call!"
, Call); return; } } while (false)
3042 "Called function is not the same type as the call!", Call)do { if (!(FPTy->isOpaqueOrPointeeTypeMatches(Call.getFunctionType
()))) { CheckFailed("Called function is not the same type as the call!"
, Call); return; } } while (false)
;
3043
3044 FunctionType *FTy = Call.getFunctionType();
3045
3046 // Verify that the correct number of arguments are being passed
3047 if (FTy->isVarArg())
3048 Assert(Call.arg_size() >= FTy->getNumParams(),do { if (!(Call.arg_size() >= FTy->getNumParams())) { CheckFailed
("Called function requires more parameters than were provided!"
, Call); return; } } while (false)
3049 "Called function requires more parameters than were provided!",do { if (!(Call.arg_size() >= FTy->getNumParams())) { CheckFailed
("Called function requires more parameters than were provided!"
, Call); return; } } while (false)
3050 Call)do { if (!(Call.arg_size() >= FTy->getNumParams())) { CheckFailed
("Called function requires more parameters than were provided!"
, Call); return; } } while (false)
;
3051 else
3052 Assert(Call.arg_size() == FTy->getNumParams(),do { if (!(Call.arg_size() == FTy->getNumParams())) { CheckFailed
("Incorrect number of arguments passed to called function!", Call
); return; } } while (false)
3053 "Incorrect number of arguments passed to called function!", Call)do { if (!(Call.arg_size() == FTy->getNumParams())) { CheckFailed
("Incorrect number of arguments passed to called function!", Call
); return; } } while (false)
;
3054
3055 // Verify that all arguments to the call match the function type.
3056 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
3057 Assert(Call.getArgOperand(i)->getType() == FTy->getParamType(i),do { if (!(Call.getArgOperand(i)->getType() == FTy->getParamType
(i))) { CheckFailed("Call parameter type does not match function signature!"
, Call.getArgOperand(i), FTy->getParamType(i), Call); return
; } } while (false)
3058 "Call parameter type does not match function signature!",do { if (!(Call.getArgOperand(i)->getType() == FTy->getParamType
(i))) { CheckFailed("Call parameter type does not match function signature!"
, Call.getArgOperand(i), FTy->getParamType(i), Call); return
; } } while (false)
3059 Call.getArgOperand(i), FTy->getParamType(i), Call)do { if (!(Call.getArgOperand(i)->getType() == FTy->getParamType
(i))) { CheckFailed("Call parameter type does not match function signature!"
, Call.getArgOperand(i), FTy->getParamType(i), Call); return
; } } while (false)
;
3060
3061 AttributeList Attrs = Call.getAttributes();
3062
3063 Assert(verifyAttributeCount(Attrs, Call.arg_size()),do { if (!(verifyAttributeCount(Attrs, Call.arg_size()))) { CheckFailed
("Attribute after last parameter!", Call); return; } } while (
false)
3064 "Attribute after last parameter!", Call)do { if (!(verifyAttributeCount(Attrs, Call.arg_size()))) { CheckFailed
("Attribute after last parameter!", Call); return; } } while (
false)
;
3065
3066 Function *Callee =
3067 dyn_cast<Function>(Call.getCalledOperand()->stripPointerCasts());
3068 bool IsIntrinsic = Callee && Callee->isIntrinsic();
3069 if (IsIntrinsic)
3070 Assert(Callee->getValueType() == FTy,do { if (!(Callee->getValueType() == FTy)) { CheckFailed("Intrinsic called with incompatible signature"
, Call); return; } } while (false)
3071 "Intrinsic called with incompatible signature", Call)do { if (!(Callee->getValueType() == FTy)) { CheckFailed("Intrinsic called with incompatible signature"
, Call); return; } } while (false)
;
3072
3073 if (Attrs.hasFnAttr(Attribute::Speculatable)) {
3074 // Don't allow speculatable on call sites, unless the underlying function
3075 // declaration is also speculatable.
3076 Assert(Callee && Callee->isSpeculatable(),do { if (!(Callee && Callee->isSpeculatable())) { CheckFailed
("speculatable attribute may not apply to call sites", Call);
return; } } while (false)
3077 "speculatable attribute may not apply to call sites", Call)do { if (!(Callee && Callee->isSpeculatable())) { CheckFailed
("speculatable attribute may not apply to call sites", Call);
return; } } while (false)
;
3078 }
3079
3080 if (Attrs.hasFnAttr(Attribute::Preallocated)) {
3081 Assert(Call.getCalledFunction()->getIntrinsicID() ==do { if (!(Call.getCalledFunction()->getIntrinsicID() == Intrinsic
::call_preallocated_arg)) { CheckFailed("preallocated as a call site attribute can only be on "
"llvm.call.preallocated.arg"); return; } } while (false)
3082 Intrinsic::call_preallocated_arg,do { if (!(Call.getCalledFunction()->getIntrinsicID() == Intrinsic
::call_preallocated_arg)) { CheckFailed("preallocated as a call site attribute can only be on "
"llvm.call.preallocated.arg"); return; } } while (false)
3083 "preallocated as a call site attribute can only be on "do { if (!(Call.getCalledFunction()->getIntrinsicID() == Intrinsic
::call_preallocated_arg)) { CheckFailed("preallocated as a call site attribute can only be on "
"llvm.call.preallocated.arg"); return; } } while (false)
3084 "llvm.call.preallocated.arg")do { if (!(Call.getCalledFunction()->getIntrinsicID() == Intrinsic
::call_preallocated_arg)) { CheckFailed("preallocated as a call site attribute can only be on "
"llvm.call.preallocated.arg"); return; } } while (false)
;
3085 }
3086
3087 // Verify call attributes.
3088 verifyFunctionAttrs(FTy, Attrs, &Call, IsIntrinsic);
3089
3090 // Conservatively check the inalloca argument.
3091 // We have a bug if we can find that there is an underlying alloca without
3092 // inalloca.
3093 if (Call.hasInAllocaArgument()) {
3094 Value *InAllocaArg = Call.getArgOperand(FTy->getNumParams() - 1);
3095 if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
3096 Assert(AI->isUsedWithInAlloca(),do { if (!(AI->isUsedWithInAlloca())) { CheckFailed("inalloca argument for call has mismatched alloca"
, AI, Call); return; } } while (false)
3097 "inalloca argument for call has mismatched alloca", AI, Call)do { if (!(AI->isUsedWithInAlloca())) { CheckFailed("inalloca argument for call has mismatched alloca"
, AI, Call); return; } } while (false)
;
3098 }
3099
3100 // For each argument of the callsite, if it has the swifterror argument,
3101 // make sure the underlying alloca/parameter it comes from has a swifterror as
3102 // well.
3103 for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
3104 if (Call.paramHasAttr(i, Attribute::SwiftError)) {
3105 Value *SwiftErrorArg = Call.getArgOperand(i);
3106 if (auto AI = dyn_cast<AllocaInst>(SwiftErrorArg->stripInBoundsOffsets())) {
3107 Assert(AI->isSwiftError(),do { if (!(AI->isSwiftError())) { CheckFailed("swifterror argument for call has mismatched alloca"
, AI, Call); return; } } while (false)
3108 "swifterror argument for call has mismatched alloca", AI, Call)do { if (!(AI->isSwiftError())) { CheckFailed("swifterror argument for call has mismatched alloca"
, AI, Call); return; } } while (false)
;
3109 continue;
3110 }
3111 auto ArgI = dyn_cast<Argument>(SwiftErrorArg);
3112 Assert(ArgI,do { if (!(ArgI)) { CheckFailed("swifterror argument should come from an alloca or parameter"
, SwiftErrorArg, Call); return; } } while (false)
3113 "swifterror argument should come from an alloca or parameter",do { if (!(ArgI)) { CheckFailed("swifterror argument should come from an alloca or parameter"
, SwiftErrorArg, Call); return; } } while (false)
3114 SwiftErrorArg, Call)do { if (!(ArgI)) { CheckFailed("swifterror argument should come from an alloca or parameter"
, SwiftErrorArg, Call); return; } } while (false)
;
3115 Assert(ArgI->hasSwiftErrorAttr(),do { if (!(ArgI->hasSwiftErrorAttr())) { CheckFailed("swifterror argument for call has mismatched parameter"
, ArgI, Call); return; } } while (false)
3116 "swifterror argument for call has mismatched parameter", ArgI,do { if (!(ArgI->hasSwiftErrorAttr())) { CheckFailed("swifterror argument for call has mismatched parameter"
, ArgI, Call); return; } } while (false)
3117 Call)do { if (!(ArgI->hasSwiftErrorAttr())) { CheckFailed("swifterror argument for call has mismatched parameter"
, ArgI, Call); return; } } while (false)
;
3118 }
3119
3120 if (Attrs.hasParamAttr(i, Attribute::ImmArg)) {
3121 // Don't allow immarg on call sites, unless the underlying declaration
3122 // also has the matching immarg.
3123 Assert(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),do { if (!(Callee && Callee->hasParamAttribute(i, Attribute
::ImmArg))) { CheckFailed("immarg may not apply only to call sites"
, Call.getArgOperand(i), Call); return; } } while (false)
3124 "immarg may not apply only to call sites",do { if (!(Callee && Callee->hasParamAttribute(i, Attribute
::ImmArg))) { CheckFailed("immarg may not apply only to call sites"
, Call.getArgOperand(i), Call); return; } } while (false)
3125 Call.getArgOperand(i), Call)do { if (!(Callee && Callee->hasParamAttribute(i, Attribute
::ImmArg))) { CheckFailed("immarg may not apply only to call sites"
, Call.getArgOperand(i), Call); return; } } while (false)
;
3126 }
3127
3128 if (Call.paramHasAttr(i, Attribute::ImmArg)) {
3129 Value *ArgVal = Call.getArgOperand(i);
3130 Assert(isa<ConstantInt>(ArgVal) || isa<ConstantFP>(ArgVal),do { if (!(isa<ConstantInt>(ArgVal) || isa<ConstantFP
>(ArgVal))) { CheckFailed("immarg operand has non-immediate parameter"
, ArgVal, Call); return; } } while (false)
3131 "immarg operand has non-immediate parameter", ArgVal, Call)do { if (!(isa<ConstantInt>(ArgVal) || isa<ConstantFP
>(ArgVal))) { CheckFailed("immarg operand has non-immediate parameter"
, ArgVal, Call); return; } } while (false)
;
3132 }
3133
3134 if (Call.paramHasAttr(i, Attribute::Preallocated)) {
3135 Value *ArgVal = Call.getArgOperand(i);
3136 bool hasOB =
3137 Call.countOperandBundlesOfType(LLVMContext::OB_preallocated) != 0;
3138 bool isMustTail = Call.isMustTailCall();
3139 Assert(hasOB != isMustTail,do { if (!(hasOB != isMustTail)) { CheckFailed("preallocated operand either requires a preallocated bundle or "
"the call to be musttail (but not both)", ArgVal, Call); return
; } } while (false)
3140 "preallocated operand either requires a preallocated bundle or "do { if (!(hasOB != isMustTail)) { CheckFailed("preallocated operand either requires a preallocated bundle or "
"the call to be musttail (but not both)", ArgVal, Call); return
; } } while (false)
3141 "the call to be musttail (but not both)",do { if (!(hasOB != isMustTail)) { CheckFailed("preallocated operand either requires a preallocated bundle or "
"the call to be musttail (but not both)", ArgVal, Call); return
; } } while (false)
3142 ArgVal, Call)do { if (!(hasOB != isMustTail)) { CheckFailed("preallocated operand either requires a preallocated bundle or "
"the call to be musttail (but not both)", ArgVal, Call); return
; } } while (false)
;
3143 }
3144 }
3145
3146 if (FTy->isVarArg()) {
3147 // FIXME? is 'nest' even legal here?
3148 bool SawNest = false;
3149 bool SawReturned = false;
3150
3151 for (unsigned Idx = 0; Idx < FTy->getNumParams(); ++Idx) {
3152 if (Attrs.hasParamAttr(Idx, Attribute::Nest))
3153 SawNest = true;
3154 if (Attrs.hasParamAttr(Idx, Attribute::Returned))
3155 SawReturned = true;
3156 }
3157
3158 // Check attributes on the varargs part.
3159 for (unsigned Idx = FTy->getNumParams(); Idx < Call.arg_size(); ++Idx) {
3160 Type *Ty = Call.getArgOperand(Idx)->getType();
3161 AttributeSet ArgAttrs = Attrs.getParamAttrs(Idx);
3162 verifyParameterAttrs(ArgAttrs, Ty, &Call);
3163
3164 if (ArgAttrs.hasAttribute(Attribute::Nest)) {
3165 Assert(!SawNest, "More than one parameter has attribute nest!", Call)do { if (!(!SawNest)) { CheckFailed("More than one parameter has attribute nest!"
, Call); return; } } while (false)
;
3166 SawNest = true;
3167 }
3168
3169 if (ArgAttrs.hasAttribute(Attribute::Returned)) {
3170 Assert(!SawReturned, "More than one parameter has attribute returned!",do { if (!(!SawReturned)) { CheckFailed("More than one parameter has attribute returned!"
, Call); return; } } while (false)
3171 Call)do { if (!(!SawReturned)) { CheckFailed("More than one parameter has attribute returned!"
, Call); return; } } while (false)
;
3172 Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),do { if (!(Ty->canLosslesslyBitCastTo(FTy->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' "
"attribute", Call); return; } } while (false)
3173 "Incompatible argument and return types for 'returned' "do { if (!(Ty->canLosslesslyBitCastTo(FTy->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' "
"attribute", Call); return; } } while (false)
3174 "attribute",do { if (!(Ty->canLosslesslyBitCastTo(FTy->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' "
"attribute", Call); return; } } while (false)
3175 Call)do { if (!(Ty->canLosslesslyBitCastTo(FTy->getReturnType
()))) { CheckFailed("Incompatible argument and return types for 'returned' "
"attribute", Call); return; } } while (false)
;
3176 SawReturned = true;
3177 }
3178
3179 // Statepoint intrinsic is vararg but the wrapped function may be not.
3180 // Allow sret here and check the wrapped function in verifyStatepoint.
3181 if (!Call.getCalledFunction() ||
3182 Call.getCalledFunction()->getIntrinsicID() !=
3183 Intrinsic::experimental_gc_statepoint)
3184 Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
3185 "Attribute 'sret' cannot be used for vararg call arguments!",do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
3186 Call)do { if (!(!ArgAttrs.hasAttribute(Attribute::StructRet))) { CheckFailed
("Attribute 'sret' cannot be used for vararg call arguments!"
, Call); return; } } while (false)
;
3187
3188 if (ArgAttrs.hasAttribute(Attribute::InAlloca))
3189 Assert(Idx == Call.arg_size() - 1,do { if (!(Idx == Call.arg_size() - 1)) { CheckFailed("inalloca isn't on the last argument!"
, Call); return; } } while (false)
3190 "inalloca isn't on the last argument!", Call)do { if (!(Idx == Call.arg_size() - 1)) { CheckFailed("inalloca isn't on the last argument!"
, Call); return; } } while (false)
;
3191 }
3192 }
3193
3194 // Verify that there's no metadata unless it's a direct call to an intrinsic.
3195 if (!IsIntrinsic) {
3196 for (Type *ParamTy : FTy->params()) {
3197 Assert(!ParamTy->isMetadataTy(),do { if (!(!ParamTy->isMetadataTy())) { CheckFailed("Function has metadata parameter but isn't an intrinsic"
, Call); return; } } while (false)
3198 "Function has metadata parameter but isn't an intrinsic", Call)do { if (!(!ParamTy->isMetadataTy())) { CheckFailed("Function has metadata parameter but isn't an intrinsic"
, Call); return; } } while (false)
;
3199 Assert(!ParamTy->isTokenTy(),do { if (!(!ParamTy->isTokenTy())) { CheckFailed("Function has token parameter but isn't an intrinsic"
, Call); return; } } while (false)
3200 "Function has token parameter but isn't an intrinsic", Call)do { if (!(!ParamTy->isTokenTy())) { CheckFailed("Function has token parameter but isn't an intrinsic"
, Call); return; } } while (false)
;
3201 }
3202 }
3203
3204 // Verify that indirect calls don't return tokens.
3205 if (!Call.getCalledFunction()) {
3206 Assert(!FTy->getReturnType()->isTokenTy(),do { if (!(!FTy->getReturnType()->isTokenTy())) { CheckFailed
("Return type cannot be token for indirect call!"); return; }
} while (false)
3207 "Return type cannot be token for indirect call!")do { if (!(!FTy->getReturnType()->isTokenTy())) { CheckFailed
("Return type cannot be token for indirect call!"); return; }
} while (false)
;
3208 Assert(!FTy->getReturnType()->isX86_AMXTy(),do { if (!(!FTy->getReturnType()->isX86_AMXTy())) { CheckFailed
("Return type cannot be x86_amx for indirect call!"); return;
} } while (false)
3209 "Return type cannot be x86_amx for indirect call!")do { if (!(!FTy->getReturnType()->isX86_AMXTy())) { CheckFailed
("Return type cannot be x86_amx for indirect call!"); return;
} } while (false)
;
3210 }
3211
3212 if (Function *F = Call.getCalledFunction())
3213 if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
3214 visitIntrinsicCall(ID, Call);
3215
3216 // Verify that a callsite has at most one "deopt", at most one "funclet", at
3217 // most one "gc-transition", at most one "cfguardtarget",
3218 // and at most one "preallocated" operand bundle.
3219 bool FoundDeoptBundle = false, FoundFuncletBundle = false,
3220 FoundGCTransitionBundle = false, FoundCFGuardTargetBundle = false,
3221 FoundPreallocatedBundle = false, FoundGCLiveBundle = false,
3222 FoundAttachedCallBundle = false;
3223 for (unsigned i = 0, e = Call.getNumOperandBundles(); i < e; ++i) {
3224 OperandBundleUse BU = Call.getOperandBundleAt(i);
3225 uint32_t Tag = BU.getTagID();
3226 if (Tag == LLVMContext::OB_deopt) {
3227 Assert(!FoundDeoptBundle, "Multiple deopt operand bundles", Call)do { if (!(!FoundDeoptBundle)) { CheckFailed("Multiple deopt operand bundles"
, Call); return; } } while (false)
;
3228 FoundDeoptBundle = true;
3229 } else if (Tag == LLVMContext::OB_gc_transition) {
3230 Assert(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",do { if (!(!FoundGCTransitionBundle)) { CheckFailed("Multiple gc-transition operand bundles"
, Call); return; } } while (false)
3231 Call)do { if (!(!FoundGCTransitionBundle)) { CheckFailed("Multiple gc-transition operand bundles"
, Call); return; } } while (false)
;
3232 FoundGCTransitionBundle = true;
3233 } else if (Tag == LLVMContext::OB_funclet) {
3234 Assert(!FoundFuncletBundle, "Multiple funclet operand bundles", Call)do { if (!(!FoundFuncletBundle)) { CheckFailed("Multiple funclet operand bundles"
, Call); return; } } while (false)
;
3235 FoundFuncletBundle = true;
3236 Assert(BU.Inputs.size() == 1,do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one funclet bundle operand"
, Call); return; } } while (false)
3237 "Expected exactly one funclet bundle operand", Call)do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one funclet bundle operand"
, Call); return; } } while (false)
;
3238 Assert(isa<FuncletPadInst>(BU.Inputs.front()),do { if (!(isa<FuncletPadInst>(BU.Inputs.front()))) { CheckFailed
("Funclet bundle operands should correspond to a FuncletPadInst"
, Call); return; } } while (false)
3239 "Funclet bundle operands should correspond to a FuncletPadInst",do { if (!(isa<FuncletPadInst>(BU.Inputs.front()))) { CheckFailed
("Funclet bundle operands should correspond to a FuncletPadInst"
, Call); return; } } while (false)
3240 Call)do { if (!(isa<FuncletPadInst>(BU.Inputs.front()))) { CheckFailed
("Funclet bundle operands should correspond to a FuncletPadInst"
, Call); return; } } while (false)
;
3241 } else if (Tag == LLVMContext::OB_cfguardtarget) {
3242 Assert(!FoundCFGuardTargetBundle,do { if (!(!FoundCFGuardTargetBundle)) { CheckFailed("Multiple CFGuardTarget operand bundles"
, Call); return; } } while (false)
3243 "Multiple CFGuardTarget operand bundles", Call)do { if (!(!FoundCFGuardTargetBundle)) { CheckFailed("Multiple CFGuardTarget operand bundles"
, Call); return; } } while (false)
;
3244 FoundCFGuardTargetBundle = true;
3245 Assert(BU.Inputs.size() == 1,do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one cfguardtarget bundle operand"
, Call); return; } } while (false)
3246 "Expected exactly one cfguardtarget bundle operand", Call)do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one cfguardtarget bundle operand"
, Call); return; } } while (false)
;
3247 } else if (Tag == LLVMContext::OB_preallocated) {
3248 Assert(!FoundPreallocatedBundle, "Multiple preallocated operand bundles",do { if (!(!FoundPreallocatedBundle)) { CheckFailed("Multiple preallocated operand bundles"
, Call); return; } } while (false)
3249 Call)do { if (!(!FoundPreallocatedBundle)) { CheckFailed("Multiple preallocated operand bundles"
, Call); return; } } while (false)
;
3250 FoundPreallocatedBundle = true;
3251 Assert(BU.Inputs.size() == 1,do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one preallocated bundle operand"
, Call); return; } } while (false)
3252 "Expected exactly one preallocated bundle operand", Call)do { if (!(BU.Inputs.size() == 1)) { CheckFailed("Expected exactly one preallocated bundle operand"
, Call); return; } } while (false)
;
3253 auto Input = dyn_cast<IntrinsicInst>(BU.Inputs.front());
3254 Assert(Input &&do { if (!(Input && Input->getIntrinsicID() == Intrinsic
::call_preallocated_setup)) { CheckFailed("\"preallocated\" argument must be a token from "
"llvm.call.preallocated.setup", Call); return; } } while (false
)
3255 Input->getIntrinsicID() == Intrinsic::call_preallocated_setup,do { if (!(Input && Input->getIntrinsicID() == Intrinsic
::call_preallocated_setup)) { CheckFailed("\"preallocated\" argument must be a token from "
"llvm.call.preallocated.setup", Call); return; } } while (false
)
3256 "\"preallocated\" argument must be a token from "do { if (!(Input && Input->getIntrinsicID() == Intrinsic
::call_preallocated_setup)) { CheckFailed("\"preallocated\" argument must be a token from "
"llvm.call.preallocated.setup", Call); return; } } while (false
)
3257 "llvm.call.preallocated.setup",do { if (!(Input && Input->getIntrinsicID() == Intrinsic
::call_preallocated_setup)) { CheckFailed("\"preallocated\" argument must be a token from "
"llvm.call.preallocated.setup", Call); return; } } while (false
)
3258 Call)do { if (!(Input && Input->getIntrinsicID() == Intrinsic
::call_preallocated_setup)) { CheckFailed("\"preallocated\" argument must be a token from "
"llvm.call.preallocated.setup", Call); return; } } while (false
)
;
3259 } else if (Tag == LLVMContext::OB_gc_live) {
3260 Assert(!FoundGCLiveBundle, "Multiple gc-live operand bundles",do { if (!(!FoundGCLiveBundle)) { CheckFailed("Multiple gc-live operand bundles"
, Call); return; } } while (false)
3261 Call)do { if (!(!FoundGCLiveBundle)) { CheckFailed("Multiple gc-live operand bundles"
, Call); return; } } while (false)
;
3262 FoundGCLiveBundle = true;
3263 } else if (Tag == LLVMContext::OB_clang_arc_attachedcall) {
3264 Assert(!FoundAttachedCallBundle,do { if (!(!FoundAttachedCallBundle)) { CheckFailed("Multiple \"clang.arc.attachedcall\" operand bundles"
, Call); return; } } while (false)
3265 "Multiple \"clang.arc.attachedcall\" operand bundles", Call)do { if (!(!FoundAttachedCallBundle)) { CheckFailed("Multiple \"clang.arc.attachedcall\" operand bundles"
, Call); return; } } while (false)
;
3266 FoundAttachedCallBundle = true;
3267 }
3268 }
3269
3270 if (FoundAttachedCallBundle)
3271 Assert((FTy->getReturnType()->isPointerTy() ||do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
3272 (Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
3273 "a call with operand bundle \"clang.arc.attachedcall\" must call a "do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
3274 "function returning a pointer or a non-returning function that has "do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
3275 "a void return type",do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
3276 Call)do { if (!((FTy->getReturnType()->isPointerTy() || (Call
.doesNotReturn() && FTy->getReturnType()->isVoidTy
())))) { CheckFailed("a call with operand bundle \"clang.arc.attachedcall\" must call a "
"function returning a pointer or a non-returning function that has "
"a void return type", Call); return; } } while (false)
;
3277
3278 // Verify that each inlinable callsite of a debug-info-bearing function in a
3279 // debug-info-bearing function has a debug location attached to it. Failure to
3280 // do so causes assertion failures when the inliner sets up inline scope info.
3281 if (Call.getFunction()->getSubprogram() && Call.getCalledFunction() &&
3282 Call.getCalledFunction()->getSubprogram())
3283 AssertDI(Call.getDebugLoc(),do { if (!(Call.getDebugLoc())) { DebugInfoCheckFailed("inlinable function call in a function with "
"debug info must have a !dbg location", Call); return; } } while
(false)
3284 "inlinable function call in a function with "do { if (!(Call.getDebugLoc())) { DebugInfoCheckFailed("inlinable function call in a function with "
"debug info must have a !dbg location", Call); return; } } while
(false)
3285 "debug info must have a !dbg location",do { if (!(Call.getDebugLoc())) { DebugInfoCheckFailed("inlinable function call in a function with "
"debug info must have a !dbg location", Call); return; } } while
(false)
3286 Call)do { if (!(Call.getDebugLoc())) { DebugInfoCheckFailed("inlinable function call in a function with "
"debug info must have a !dbg location", Call); return; } } while
(false)
;
3287
3288 visitInstruction(Call);
3289}
3290
3291void Verifier::verifyTailCCMustTailAttrs(AttrBuilder Attrs,
3292 StringRef Context) {
3293 Assert(!Attrs.contains(Attribute::InAlloca),do { if (!(!Attrs.contains(Attribute::InAlloca))) { CheckFailed
(Twine("inalloca attribute not allowed in ") + Context); return
; } } while (false)
3294 Twine("inalloca attribute not allowed in ") + Context)do { if (!(!Attrs.contains(Attribute::InAlloca))) { CheckFailed
(Twine("inalloca attribute not allowed in ") + Context); return
; } } while (false)
;
3295 Assert(!Attrs.contains(Attribute::InReg),do { if (!(!Attrs.contains(Attribute::InReg))) { CheckFailed(
Twine("inreg attribute not allowed in ") + Context); return; }
} while (false)
3296 Twine("inreg attribute not allowed in ") + Context)do { if (!(!Attrs.contains(Attribute::InReg))) { CheckFailed(
Twine("inreg attribute not allowed in ") + Context); return; }
} while (false)
;
3297 Assert(!Attrs.contains(Attribute::SwiftError),do { if (!(!Attrs.contains(Attribute::SwiftError))) { CheckFailed
(Twine("swifterror attribute not allowed in ") + Context); return
; } } while (false)
3298 Twine("swifterror attribute not allowed in ") + Context)do { if (!(!Attrs.contains(Attribute::SwiftError))) { CheckFailed
(Twine("swifterror attribute not allowed in ") + Context); return
; } } while (false)
;
3299 Assert(!Attrs.contains(Attribute::Preallocated),do { if (!(!Attrs.contains(Attribute::Preallocated))) { CheckFailed
(Twine("preallocated attribute not allowed in ") + Context); return
; } } while (false)
3300 Twine("preallocated attribute not allowed in ") + Context)do { if (!(!Attrs.contains(Attribute::Preallocated))) { CheckFailed
(Twine("preallocated attribute not allowed in ") + Context); return
; } } while (false)
;
3301 Assert(!Attrs.contains(Attribute::ByRef),do { if (!(!Attrs.contains(Attribute::ByRef))) { CheckFailed(
Twine("byref attribute not allowed in ") + Context); return; }
} while (false)
3302 Twine("byref attribute not allowed in ") + Context)do { if (!(!Attrs.contains(Attribute::ByRef))) { CheckFailed(
Twine("byref attribute not allowed in ") + Context); return; }
} while (false)
;
3303}
3304
3305/// Two types are "congruent" if they are identical, or if they are both pointer
3306/// types with different pointee types and the same address space.
3307static bool isTypeCongruent(Type *L, Type *R) {
3308 if (L == R)
3309 return true;
3310 PointerType *PL = dyn_cast<PointerType>(L);
3311 PointerType *PR = dyn_cast<PointerType>(R);
3312 if (!PL || !PR)
3313 return false;
3314 return PL->getAddressSpace() == PR->getAddressSpace();
3315}
3316
3317static AttrBuilder getParameterABIAttributes(int I, AttributeList Attrs) {
3318 static const Attribute::AttrKind ABIAttrs[] = {
3319 Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
3320 Attribute::InReg, Attribute::StackAlignment, Attribute::SwiftSelf,
3321 Attribute::SwiftAsync, Attribute::SwiftError, Attribute::Preallocated,
3322 Attribute::ByRef};
3323 AttrBuilder Copy;
3324 for (auto AK : ABIAttrs) {
3325 Attribute Attr = Attrs.getParamAttrs(I).getAttribute(AK);
3326 if (Attr.isValid())
3327 Copy.addAttribute(Attr);
3328 }
3329
3330 // `align` is ABI-affecting only in combination with `byval` or `byref`.
3331 if (Attrs.hasParamAttr(I, Attribute::Alignment) &&
3332 (Attrs.hasParamAttr(I, Attribute::ByVal) ||
3333 Attrs.hasParamAttr(I, Attribute::ByRef)))
3334 Copy.addAlignmentAttr(Attrs.getParamAlignment(I));
3335 return Copy;
3336}
3337
3338void Verifier::verifyMustTailCall(CallInst &CI) {
3339 Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI)do { if (!(!CI.isInlineAsm())) { CheckFailed("cannot use musttail call with inline asm"
, &CI); return; } } while (false)
;
3340
3341 Function *F = CI.getParent()->getParent();
3342 FunctionType *CallerTy = F->getFunctionType();
3343 FunctionType *CalleeTy = CI.getFunctionType();
3344 Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),do { if (!(CallerTy->isVarArg() == CalleeTy->isVarArg()
)) { CheckFailed("cannot guarantee tail call due to mismatched varargs"
, &CI); return; } } while (false)
3345 "cannot guarantee tail call due to mismatched varargs", &CI)do { if (!(CallerTy->isVarArg() == CalleeTy->isVarArg()
)) { CheckFailed("cannot guarantee tail call due to mismatched varargs"
, &CI); return; } } while (false)
;
3346 Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),do { if (!(isTypeCongruent(CallerTy->getReturnType(), CalleeTy
->getReturnType()))) { CheckFailed("cannot guarantee tail call due to mismatched return types"
, &CI); return; } } while (false)
3347 "cannot guarantee tail call due to mismatched return types", &CI)do { if (!(isTypeCongruent(CallerTy->getReturnType(), CalleeTy
->getReturnType()))) { CheckFailed("cannot guarantee tail call due to mismatched return types"
, &CI); return; } } while (false)
;
3348
3349 // - The calling conventions of the caller and callee must match.
3350 Assert(F->getCallingConv() == CI.getCallingConv(),do { if (!(F->getCallingConv() == CI.getCallingConv())) { CheckFailed
("cannot guarantee tail call due to mismatched calling conv",
&CI); return; } } while (false)
3351 "cannot guarantee tail call due to mismatched calling conv", &CI)do { if (!(F->getCallingConv() == CI.getCallingConv())) { CheckFailed
("cannot guarantee tail call due to mismatched calling conv",
&CI); return; } } while (false)
;
3352
3353 // - The call must immediately precede a :ref:`ret <i_ret>` instruction,
3354 // or a pointer bitcast followed by a ret instruction.
3355 // - The ret instruction must return the (possibly bitcasted) value
3356 // produced by the call or void.
3357 Value *RetVal = &CI;
3358 Instruction *Next = CI.getNextNode();
3359
3360 // Handle the optional bitcast.
3361 if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
3362 Assert(BI->getOperand(0) == RetVal,do { if (!(BI->getOperand(0) == RetVal)) { CheckFailed("bitcast following musttail call must use the call"
, BI); return; } } while (false)
3363 "bitcast following musttail call must use the call", BI)do { if (!(BI->getOperand(0) == RetVal)) { CheckFailed("bitcast following musttail call must use the call"
, BI); return; } } while (false)
;
3364 RetVal = BI;
3365 Next = BI->getNextNode();
3366 }
3367
3368 // Check the return.
3369 ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
3370 Assert(Ret, "musttail call must precede a ret with an optional bitcast",do { if (!(Ret)) { CheckFailed("musttail call must precede a ret with an optional bitcast"
, &CI); return; } } while (false)
3371 &CI)do { if (!(Ret)) { CheckFailed("musttail call must precede a ret with an optional bitcast"
, &CI); return; } } while (false)
;
3372 Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal ||do { if (!(!Ret->getReturnValue() || Ret->getReturnValue
() == RetVal || isa<UndefValue>(Ret->getReturnValue(
)))) { CheckFailed("musttail call result must be returned", Ret
); return; } } while (false)
3373 isa<UndefValue>(Ret->getReturnValue()),do { if (!(!Ret->getReturnValue() || Ret->getReturnValue
() == RetVal || isa<UndefValue>(Ret->getReturnValue(
)))) { CheckFailed("musttail call result must be returned", Ret
); return; } } while (false)
3374 "musttail call result must be returned", Ret)do { if (!(!Ret->getReturnValue() || Ret->getReturnValue
() == RetVal || isa<UndefValue>(Ret->getReturnValue(
)))) { CheckFailed("musttail call result must be returned", Ret
); return; } } while (false)
;
3375
3376 AttributeList CallerAttrs = F->getAttributes();
3377 AttributeList CalleeAttrs = CI.getAttributes();
3378 if (CI.getCallingConv() == CallingConv::SwiftTail ||
3379 CI.getCallingConv() == CallingConv::Tail) {
3380 StringRef CCName =
3381 CI.getCallingConv() == CallingConv::Tail ? "tailcc" : "swifttailcc";
3382
3383 // - Only sret, byval, swiftself, and swiftasync ABI-impacting attributes
3384 // are allowed in swifttailcc call
3385 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
3386 AttrBuilder ABIAttrs = getParameterABIAttributes(I, CallerAttrs);
3387 SmallString<32> Context{CCName, StringRef(" musttail caller")};
3388 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3389 }
3390 for (int I = 0, E = CalleeTy->getNumParams(); I != E; ++I) {
3391 AttrBuilder ABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
3392 SmallString<32> Context{CCName, StringRef(" musttail callee")};
3393 verifyTailCCMustTailAttrs(ABIAttrs, Context);
3394 }
3395 // - Varargs functions are not allowed
3396 Assert(!CallerTy->isVarArg(), Twine("cannot guarantee ") + CCName +do { if (!(!CallerTy->isVarArg())) { CheckFailed(Twine("cannot guarantee "
) + CCName + " tail call for varargs function"); return; } } while
(false)
3397 " tail call for varargs function")do { if (!(!CallerTy->isVarArg())) { CheckFailed(Twine("cannot guarantee "
) + CCName + " tail call for varargs function"); return; } } while
(false)
;
3398 return;
3399 }
3400
3401 // - The caller and callee prototypes must match. Pointer types of
3402 // parameters or return types may differ in pointee type, but not
3403 // address space.
3404 if (!CI.getCalledFunction() || !CI.getCalledFunction()->isIntrinsic()) {
3405 Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),do { if (!(CallerTy->getNumParams() == CalleeTy->getNumParams
())) { CheckFailed("cannot guarantee tail call due to mismatched parameter counts"
, &CI); return; } } while (false)
3406 "cannot guarantee tail call due to mismatched parameter counts",do { if (!(CallerTy->getNumParams() == CalleeTy->getNumParams
())) { CheckFailed("cannot guarantee tail call due to mismatched parameter counts"
, &CI); return; } } while (false)
3407 &CI)do { if (!(CallerTy->getNumParams() == CalleeTy->getNumParams
())) { CheckFailed("cannot guarantee tail call due to mismatched parameter counts"
, &CI); return; } } while (false)
;
3408 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
3409 Assert(do { if (!(isTypeCongruent(CallerTy->getParamType(I), CalleeTy
->getParamType(I)))) { CheckFailed("cannot guarantee tail call due to mismatched parameter types"
, &CI); return; } } while (false)
3410 isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),do { if (!(isTypeCongruent(CallerTy->getParamType(I), CalleeTy
->getParamType(I)))) { CheckFailed("cannot guarantee tail call due to mismatched parameter types"
, &CI); return; } } while (false)
3411 "cannot guarantee tail call due to mismatched parameter types", &CI)do { if (!(isTypeCongruent(CallerTy->getParamType(I), CalleeTy
->getParamType(I)))) { CheckFailed("cannot guarantee tail call due to mismatched parameter types"
, &CI); return; } } while (false)
;
3412 }
3413 }
3414
3415 // - All ABI-impacting function attributes, such as sret, byval, inreg,
3416 // returned, preallocated, and inalloca, must match.
3417 for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
3418 AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
3419 AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
3420 Assert(CallerABIAttrs == CalleeABIAttrs,do { if (!(CallerABIAttrs == CalleeABIAttrs)) { CheckFailed("cannot guarantee tail call due to mismatched ABI impacting "
"function attributes", &CI, CI.getOperand(I)); return; }
} while (false)
3421 "cannot guarantee tail call due to mismatched ABI impacting "do { if (!(CallerABIAttrs == CalleeABIAttrs)) { CheckFailed("cannot guarantee tail call due to mismatched ABI impacting "
"function attributes", &CI, CI.getOperand(I)); return; }
} while (false)
3422 "function attributes",do { if (!(CallerABIAttrs == CalleeABIAttrs)) { CheckFailed("cannot guarantee tail call due to mismatched ABI impacting "
"function attributes", &CI, CI.getOperand(I)); return; }
} while (false)
3423 &CI, CI.getOperand(I))do { if (!(CallerABIAttrs == CalleeABIAttrs)) { CheckFailed("cannot guarantee tail call due to mismatched ABI impacting "
"function attributes", &CI, CI.getOperand(I)); return; }
} while (false)
;
3424 }
3425}
3426
3427void Verifier::visitCallInst(CallInst &CI) {
3428 visitCallBase(CI);
3429
3430 if (CI.isMustTailCall())
3431 verifyMustTailCall(CI);
3432}
3433
3434void Verifier::visitInvokeInst(InvokeInst &II) {
3435 visitCallBase(II);
3436
3437 // Verify that the first non-PHI instruction of the unwind destination is an
3438 // exception handling instruction.
3439 Assert(do { if (!(II.getUnwindDest()->isEHPad())) { CheckFailed("The unwind destination does not have an exception handling instruction!"
, &II); return; } } while (false)
3440 II.getUnwindDest()->isEHPad(),do { if (!(II.getUnwindDest()->isEHPad())) { CheckFailed("The unwind destination does not have an exception handling instruction!"
, &II); return; } } while (false)
3441 "The unwind destination does not have an exception handling instruction!",do { if (!(II.getUnwindDest()->isEHPad())) { CheckFailed("The unwind destination does not have an exception handling instruction!"
, &II); return; } } while (false)
3442 &II)do { if (!(II.getUnwindDest()->isEHPad())) { CheckFailed("The unwind destination does not have an exception handling instruction!"
, &II); return; } } while (false)
;
3443
3444 visitTerminator(II);
3445}
3446
3447/// visitUnaryOperator - Check the argument to the unary operator.
3448///
3449void Verifier::visitUnaryOperator(UnaryOperator &U) {
3450 Assert(U.getType() == U.getOperand(0)->getType(),do { if (!(U.getType() == U.getOperand(0)->getType())) { CheckFailed
("Unary operators must have same type for" "operands and result!"
, &U); return; } } while (false)
3451 "Unary operators must have same type for"do { if (!(U.getType() == U.getOperand(0)->getType())) { CheckFailed
("Unary operators must have same type for" "operands and result!"
, &U); return; } } while (false)
3452 "operands and result!",do { if (!(U.getType() == U.getOperand(0)->getType())) { CheckFailed
("Unary operators must have same type for" "operands and result!"
, &U); return; } } while (false)
3453 &U)do { if (!(U.getType() == U.getOperand(0)->getType())) { CheckFailed
("Unary operators must have same type for" "operands and result!"
, &U); return; } } while (false)
;
3454
3455 switch (U.getOpcode()) {
3456 // Check that floating-point arithmetic operators are only used with
3457 // floating-point operands.
3458 case Instruction::FNeg:
3459 Assert(U.getType()->isFPOrFPVectorTy(),do { if (!(U.getType()->isFPOrFPVectorTy())) { CheckFailed
("FNeg operator only works with float types!", &U); return
; } } while (false)
3460 "FNeg operator only works with float types!", &U)do { if (!(U.getType()->isFPOrFPVectorTy())) { CheckFailed
("FNeg operator only works with float types!", &U); return
; } } while (false)
;
3461 break;
3462 default:
3463 llvm_unreachable("Unknown UnaryOperator opcode!")__builtin_unreachable();
3464 }
3465
3466 visitInstruction(U);
3467}
3468
3469/// visitBinaryOperator - Check that both arguments to the binary operator are
3470/// of the same type!
3471///
3472void Verifier::visitBinaryOperator(BinaryOperator &B) {
3473 Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),do { if (!(B.getOperand(0)->getType() == B.getOperand(1)->
getType())) { CheckFailed("Both operands to a binary operator are not of the same type!"
, &B); return; } } while (false)
3474 "Both operands to a binary operator are not of the same type!", &B)do { if (!(B.getOperand(0)->getType() == B.getOperand(1)->
getType())) { CheckFailed("Both operands to a binary operator are not of the same type!"
, &B); return; } } while (false)
;
3475
3476 switch (B.getOpcode()) {
3477 // Check that integer arithmetic operators are only used with
3478 // integral operands.
3479 case Instruction::Add:
3480 case Instruction::Sub:
3481 case Instruction::Mul:
3482 case Instruction::SDiv:
3483 case Instruction::UDiv:
3484 case Instruction::SRem:
3485 case Instruction::URem:
3486 Assert(B.getType()->isIntOrIntVectorTy(),do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Integer arithmetic operators only work with integral types!"
, &B); return; } } while (false)
3487 "Integer arithmetic operators only work with integral types!", &B)do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Integer arithmetic operators only work with integral types!"
, &B); return; } } while (false)
;
3488 Assert(B.getType() == B.getOperand(0)->getType(),do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Integer arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3489 "Integer arithmetic operators must have same type "do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Integer arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3490 "for operands and result!",do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Integer arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3491 &B)do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Integer arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
;
3492 break;
3493 // Check that floating-point arithmetic operators are only used with
3494 // floating-point operands.
3495 case Instruction::FAdd:
3496 case Instruction::FSub:
3497 case Instruction::FMul:
3498 case Instruction::FDiv:
3499 case Instruction::FRem:
3500 Assert(B.getType()->isFPOrFPVectorTy(),do { if (!(B.getType()->isFPOrFPVectorTy())) { CheckFailed
("Floating-point arithmetic operators only work with " "floating-point types!"
, &B); return; } } while (false)
3501 "Floating-point arithmetic operators only work with "do { if (!(B.getType()->isFPOrFPVectorTy())) { CheckFailed
("Floating-point arithmetic operators only work with " "floating-point types!"
, &B); return; } } while (false)
3502 "floating-point types!",do { if (!(B.getType()->isFPOrFPVectorTy())) { CheckFailed
("Floating-point arithmetic operators only work with " "floating-point types!"
, &B); return; } } while (false)
3503 &B)do { if (!(B.getType()->isFPOrFPVectorTy())) { CheckFailed
("Floating-point arithmetic operators only work with " "floating-point types!"
, &B); return; } } while (false)
;
3504 Assert(B.getType() == B.getOperand(0)->getType(),do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Floating-point arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3505 "Floating-point arithmetic operators must have same type "do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Floating-point arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3506 "for operands and result!",do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Floating-point arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
3507 &B)do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Floating-point arithmetic operators must have same type " "for operands and result!"
, &B); return; } } while (false)
;
3508 break;
3509 // Check that logical operators are only used with integral operands.
3510 case Instruction::And:
3511 case Instruction::Or:
3512 case Instruction::Xor:
3513 Assert(B.getType()->isIntOrIntVectorTy(),do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Logical operators only work with integral types!", &B);
return; } } while (false)
3514 "Logical operators only work with integral types!", &B)do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Logical operators only work with integral types!", &B);
return; } } while (false)
;
3515 Assert(B.getType() == B.getOperand(0)->getType(),do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Logical operators must have same type for operands and result!"
, &B); return; } } while (false)
3516 "Logical operators must have same type for operands and result!",do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Logical operators must have same type for operands and result!"
, &B); return; } } while (false)
3517 &B)do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Logical operators must have same type for operands and result!"
, &B); return; } } while (false)
;
3518 break;
3519 case Instruction::Shl:
3520 case Instruction::LShr:
3521 case Instruction::AShr:
3522 Assert(B.getType()->isIntOrIntVectorTy(),do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Shifts only work with integral types!", &B); return; } }
while (false)
3523 "Shifts only work with integral types!", &B)do { if (!(B.getType()->isIntOrIntVectorTy())) { CheckFailed
("Shifts only work with integral types!", &B); return; } }
while (false)
;
3524 Assert(B.getType() == B.getOperand(0)->getType(),do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Shift return type must be same as operands!", &B); return
; } } while (false)
3525 "Shift return type must be same as operands!", &B)do { if (!(B.getType() == B.getOperand(0)->getType())) { CheckFailed
("Shift return type must be same as operands!", &B); return
; } } while (false)
;
3526 break;
3527 default:
3528 llvm_unreachable("Unknown BinaryOperator opcode!")__builtin_unreachable();
3529 }
3530
3531 visitInstruction(B);
3532}
3533
3534void Verifier::visitICmpInst(ICmpInst &IC) {
3535 // Check that the operands are the same type
3536 Type *Op0Ty = IC.getOperand(0)->getType();
3537 Type *Op1Ty = IC.getOperand(1)->getType();
3538 Assert(Op0Ty == Op1Ty,do { if (!(Op0Ty == Op1Ty)) { CheckFailed("Both operands to ICmp instruction are not of the same type!"
, &IC); return; } } while (false)
3539 "Both operands to ICmp instruction are not of the same type!", &IC)do { if (!(Op0Ty == Op1Ty)) { CheckFailed("Both operands to ICmp instruction are not of the same type!"
, &IC); return; } } while (false)
;
3540 // Check that the operands are the right type
3541 Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy(),do { if (!(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy
())) { CheckFailed("Invalid operand types for ICmp instruction"
, &IC); return; } } while (false)
3542 "Invalid operand types for ICmp instruction", &IC)do { if (!(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPtrOrPtrVectorTy
())) { CheckFailed("Invalid operand types for ICmp instruction"
, &IC); return; } } while (false)
;
3543 // Check that the predicate is valid.
3544 Assert(IC.isIntPredicate(),do { if (!(IC.isIntPredicate())) { CheckFailed("Invalid predicate in ICmp instruction!"
, &IC); return; } } while (false)
3545 "Invalid predicate in ICmp instruction!", &IC)do { if (!(IC.isIntPredicate())) { CheckFailed("Invalid predicate in ICmp instruction!"
, &IC); return; } } while (false)
;
3546
3547 visitInstruction(IC);
3548}
3549
3550void Verifier::visitFCmpInst(FCmpInst &FC) {
3551 // Check that the operands are the same type
3552 Type *Op0Ty = FC.getOperand(0)->getType();
3553 Type *Op1Ty = FC.getOperand(1)->getType();
3554 Assert(Op0Ty == Op1Ty,do { if (!(Op0Ty == Op1Ty)) { CheckFailed("Both operands to FCmp instruction are not of the same type!"
, &FC); return; } } while (false)
3555 "Both operands to FCmp instruction are not of the same type!", &FC)do { if (!(Op0Ty == Op1Ty)) { CheckFailed("Both operands to FCmp instruction are not of the same type!"
, &FC); return; } } while (false)
;
3556 // Check that the operands are the right type
3557 Assert(Op0Ty->isFPOrFPVectorTy(),do { if (!(Op0Ty->isFPOrFPVectorTy())) { CheckFailed("Invalid operand types for FCmp instruction"
, &FC); return; } } while (false)
3558 "Invalid operand types for FCmp instruction", &FC)do { if (!(Op0Ty->isFPOrFPVectorTy())) { CheckFailed("Invalid operand types for FCmp instruction"
, &FC); return; } } while (false)
;
3559 // Check that the predicate is valid.
3560 Assert(FC.isFPPredicate(),do { if (!(FC.isFPPredicate())) { CheckFailed("Invalid predicate in FCmp instruction!"
, &FC); return; } } while (false)
3561 "Invalid predicate in FCmp instruction!", &FC)do { if (!(FC.isFPPredicate())) { CheckFailed("Invalid predicate in FCmp instruction!"
, &FC); return; } } while (false)
;
3562
3563 visitInstruction(FC);
3564}
3565
3566void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
3567 Assert(do { if (!(ExtractElementInst::isValidOperands(EI.getOperand(
0), EI.getOperand(1)))) { CheckFailed("Invalid extractelement operands!"
, &EI); return; } } while (false)
3568 ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),do { if (!(ExtractElementInst::isValidOperands(EI.getOperand(
0), EI.getOperand(1)))) { CheckFailed("Invalid extractelement operands!"
, &EI); return; } } while (false)
3569 "Invalid extractelement operands!", &EI)do { if (!(ExtractElementInst::isValidOperands(EI.getOperand(
0), EI.getOperand(1)))) { CheckFailed("Invalid extractelement operands!"
, &EI); return; } } while (false)
;
3570 visitInstruction(EI);
3571}
3572
3573void Verifier::visitInsertElementInst(InsertElementInst &IE) {
3574 Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),do { if (!(InsertElementInst::isValidOperands(IE.getOperand(0
), IE.getOperand(1), IE.getOperand(2)))) { CheckFailed("Invalid insertelement operands!"
, &IE); return; } } while (false)
3575 IE.getOperand(2)),do { if (!(InsertElementInst::isValidOperands(IE.getOperand(0
), IE.getOperand(1), IE.getOperand(2)))) { CheckFailed("Invalid insertelement operands!"
, &IE); return; } } while (false)
3576 "Invalid insertelement operands!", &IE)do { if (!(InsertElementInst::isValidOperands(IE.getOperand(0
), IE.getOperand(1), IE.getOperand(2)))) { CheckFailed("Invalid insertelement operands!"
, &IE); return; } } while (false)
;
3577 visitInstruction(IE);
3578}
3579
3580void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
3581 Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),do { if (!(ShuffleVectorInst::isValidOperands(SV.getOperand(0
), SV.getOperand(1), SV.getShuffleMask()))) { CheckFailed("Invalid shufflevector operands!"
, &SV); return; } } while (false)
3582 SV.getShuffleMask()),do { if (!(ShuffleVectorInst::isValidOperands(SV.getOperand(0
), SV.getOperand(1), SV.getShuffleMask()))) { CheckFailed("Invalid shufflevector operands!"
, &SV); return; } } while (false)
3583 "Invalid shufflevector operands!", &SV)do { if (!(ShuffleVectorInst::isValidOperands(SV.getOperand(0
), SV.getOperand(1), SV.getShuffleMask()))) { CheckFailed("Invalid shufflevector operands!"
, &SV); return; } } while (false)
;
3584 visitInstruction(SV);
3585}
3586
3587void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
3588 Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
3589
3590 Assert(isa<PointerType>(TargetTy),do { if (!(isa<PointerType>(TargetTy))) { CheckFailed("GEP base pointer is not a vector or a vector of pointers"
, &GEP); return; } } while (false)
3591 "GEP base pointer is not a vector or a vector of pointers", &GEP)do { if (!(isa<PointerType>(TargetTy))) { CheckFailed("GEP base pointer is not a vector or a vector of pointers"
, &GEP); return; } } while (false)
;
3592 Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP)do { if (!(GEP.getSourceElementType()->isSized())) { CheckFailed
("GEP into unsized type!", &GEP); return; } } while (false
)
;
3593
3594 SmallVector<Value *, 16> Idxs(GEP.indices());
3595 Assert(all_of(do { if (!(all_of( Idxs, [](Value* V) { return V->getType(
)->isIntOrIntVectorTy(); }))) { CheckFailed("GEP indexes must be integers"
, &GEP); return; } } while (false)
3596 Idxs, [](Value* V) { return V->getType()->isIntOrIntVectorTy(); }),do { if (!(all_of( Idxs, [](Value* V) { return V->getType(
)->isIntOrIntVectorTy(); }))) { CheckFailed("GEP indexes must be integers"
, &GEP); return; } } while (false)
3597 "GEP indexes must be integers", &GEP)do { if (!(all_of( Idxs, [](Value* V) { return V->getType(
)->isIntOrIntVectorTy(); }))) { CheckFailed("GEP indexes must be integers"
, &GEP); return; } } while (false)
;
3598 Type *ElTy =
3599 GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs);
3600 Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP)do { if (!(ElTy)) { CheckFailed("Invalid indices for GEP pointer type!"
, &GEP); return; } } while (false)
;
3601
3602 Assert(GEP.getType()->isPtrOrPtrVectorTy() &&do { if (!(GEP.getType()->isPtrOrPtrVectorTy() && GEP
.getResultElementType() == ElTy)) { CheckFailed("GEP is not of right type for indices!"
, &GEP, ElTy); return; } } while (false)
3603 GEP.getResultElementType() == ElTy,do { if (!(GEP.getType()->isPtrOrPtrVectorTy() && GEP
.getResultElementType() == ElTy)) { CheckFailed("GEP is not of right type for indices!"
, &GEP, ElTy); return; } } while (false)
3604 "GEP is not of right type for indices!", &GEP, ElTy)do { if (!(GEP.getType()->isPtrOrPtrVectorTy() && GEP
.getResultElementType() == ElTy)) { CheckFailed("GEP is not of right type for indices!"
, &GEP, ElTy); return; } } while (false)
;
3605
3606 if (auto *GEPVTy = dyn_cast<VectorType>(GEP.getType())) {
3607 // Additional checks for vector GEPs.
3608 ElementCount GEPWidth = GEPVTy->getElementCount();
3609 if (GEP.getPointerOperandType()->isVectorTy())
3610 Assert(do { if (!(GEPWidth == cast<VectorType>(GEP.getPointerOperandType
())->getElementCount())) { CheckFailed("Vector GEP result width doesn't match operand's"
, &GEP); return; } } while (false)
3611 GEPWidth ==do { if (!(GEPWidth == cast<VectorType>(GEP.getPointerOperandType
())->getElementCount())) { CheckFailed("Vector GEP result width doesn't match operand's"
, &GEP); return; } } while (false)
3612 cast<VectorType>(GEP.getPointerOperandType())->getElementCount(),do { if (!(GEPWidth == cast<VectorType>(GEP.getPointerOperandType
())->getElementCount())) { CheckFailed("Vector GEP result width doesn't match operand's"
, &GEP); return; } } while (false)
3613 "Vector GEP result width doesn't match operand's", &GEP)do { if (!(GEPWidth == cast<VectorType>(GEP.getPointerOperandType
())->getElementCount())) { CheckFailed("Vector GEP result width doesn't match operand's"
, &GEP); return; } } while (false)
;
3614 for (Value *Idx : Idxs) {
3615 Type *IndexTy = Idx->getType();
3616 if (auto *IndexVTy = dyn_cast<VectorType>(IndexTy)) {
3617 ElementCount IndexWidth = IndexVTy->getElementCount();
3618 Assert(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP)do { if (!(IndexWidth == GEPWidth)) { CheckFailed("Invalid GEP index vector width"
, &GEP); return; } } while (false)
;
3619 }
3620 Assert(IndexTy->isIntOrIntVectorTy(),do { if (!(IndexTy->isIntOrIntVectorTy())) { CheckFailed("All GEP indices should be of integer type"
); return; } } while (false)
3621 "All GEP indices should be of integer type")do { if (!(IndexTy->isIntOrIntVectorTy())) { CheckFailed("All GEP indices should be of integer type"
); return; } } while (false)
;
3622 }
3623 }
3624
3625 if (auto *PTy = dyn_cast<PointerType>(GEP.getType())) {
3626 Assert(GEP.getAddressSpace() == PTy->getAddressSpace(),do { if (!(GEP.getAddressSpace() == PTy->getAddressSpace()
)) { CheckFailed("GEP address space doesn't match type", &
GEP); return; } } while (false)
3627 "GEP address space doesn't match type", &GEP)do { if (!(GEP.getAddressSpace() == PTy->getAddressSpace()
)) { CheckFailed("GEP address space doesn't match type", &
GEP); return; } } while (false)
;
3628 }
3629
3630 visitInstruction(GEP);
3631}
3632
3633static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
3634 return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
3635}
3636
3637void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
3638 assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&(static_cast<void> (0))
3639 "precondition violation")(static_cast<void> (0));
3640
3641 unsigned NumOperands = Range->getNumOperands();
3642 Assert(NumOperands % 2 == 0, "Unfinished range!", Range)do { if (!(NumOperands % 2 == 0)) { CheckFailed("Unfinished range!"
, Range); return; } } while (false)
;
3643 unsigned NumRanges = NumOperands / 2;
3644 Assert(NumRanges >= 1, "It should have at least one range!", Range)do { if (!(NumRanges >= 1)) { CheckFailed("It should have at least one range!"
, Range); return; } } while (false)
;
3645
3646 ConstantRange LastRange(1, true); // Dummy initial value
3647 for (unsigned i = 0; i < NumRanges; ++i) {
3648 ConstantInt *Low =
3649 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
3650 Assert(Low, "The lower limit must be an integer!", Low)do { if (!(Low)) { CheckFailed("The lower limit must be an integer!"
, Low); return; } } while (false)
;
3651 ConstantInt *High =
3652 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
3653 Assert(High, "The upper limit must be an integer!", High)do { if (!(High)) { CheckFailed("The upper limit must be an integer!"
, High); return; } } while (false)
;
3654 Assert(High->getType() == Low->getType() && High->getType() == Ty,do { if (!(High->getType() == Low->getType() &&
High->getType() == Ty)) { CheckFailed("Range types must match instruction type!"
, &I); return; } } while (false)
3655 "Range types must match instruction type!", &I)do { if (!(High->getType() == Low->getType() &&
High->getType() == Ty)) { CheckFailed("Range types must match instruction type!"
, &I); return; } } while (false)
;
3656
3657 APInt HighV = High->getValue();
3658 APInt LowV = Low->getValue();
3659 ConstantRange CurRange(LowV, HighV);
3660 Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),do { if (!(!CurRange.isEmptySet() && !CurRange.isFullSet
())) { CheckFailed("Range must not be empty!", Range); return
; } } while (false)
3661 "Range must not be empty!", Range)do { if (!(!CurRange.isEmptySet() && !CurRange.isFullSet
())) { CheckFailed("Range must not be empty!", Range); return
; } } while (false)
;
3662 if (i != 0) {
3663 Assert(CurRange.intersectWith(LastRange).isEmptySet(),do { if (!(CurRange.intersectWith(LastRange).isEmptySet())) {
CheckFailed("Intervals are overlapping", Range); return; } }
while (false)
3664 "Intervals are overlapping", Range)do { if (!(CurRange.intersectWith(LastRange).isEmptySet())) {
CheckFailed("Intervals are overlapping", Range); return; } }
while (false)
;
3665 Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",do { if (!(LowV.sgt(LastRange.getLower()))) { CheckFailed("Intervals are not in order"
, Range); return; } } while (false)
3666 Range)do { if (!(LowV.sgt(LastRange.getLower()))) { CheckFailed("Intervals are not in order"
, Range); return; } } while (false)
;
3667 Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",do { if (!(!isContiguous(CurRange, LastRange))) { CheckFailed
("Intervals are contiguous", Range); return; } } while (false
)
3668 Range)do { if (!(!isContiguous(CurRange, LastRange))) { CheckFailed
("Intervals are contiguous", Range); return; } } while (false
)
;
3669 }
3670 LastRange = ConstantRange(LowV, HighV);
3671 }
3672 if (NumRanges > 2) {
3673 APInt FirstLow =
3674 mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
3675 APInt FirstHigh =
3676 mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
3677 ConstantRange FirstRange(FirstLow, FirstHigh);
3678 Assert(FirstRange.intersectWith(LastRange).isEmptySet(),do { if (!(FirstRange.intersectWith(LastRange).isEmptySet()))
{ CheckFailed("Intervals are overlapping", Range); return; }
} while (false)
3679 "Intervals are overlapping", Range)do { if (!(FirstRange.intersectWith(LastRange).isEmptySet()))
{ CheckFailed("Intervals are overlapping", Range); return; }
} while (false)
;
3680 Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",do { if (!(!isContiguous(FirstRange, LastRange))) { CheckFailed
("Intervals are contiguous", Range); return; } } while (false
)
3681 Range)do { if (!(!isContiguous(FirstRange, LastRange))) { CheckFailed
("Intervals are contiguous", Range); return; } } while (false
)
;
3682 }
3683}
3684
3685void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
3686 unsigned Size = DL.getTypeSizeInBits(Ty);
3687 Assert(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I)do { if (!(Size >= 8)) { CheckFailed("atomic memory access' size must be byte-sized"
, Ty, I); return; } } while (false)
;
3688 Assert(!(Size & (Size - 1)),do { if (!(!(Size & (Size - 1)))) { CheckFailed("atomic memory access' operand must have a power-of-two size"
, Ty, I); return; } } while (false)
3689 "atomic memory access' operand must have a power-of-two size", Ty, I)do { if (!(!(Size & (Size - 1)))) { CheckFailed("atomic memory access' operand must have a power-of-two size"
, Ty, I); return; } } while (false)
;
3690}
3691
3692void Verifier::visitLoadInst(LoadInst &LI) {
3693 PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
3694 Assert(PTy, "Load operand must be a pointer.", &LI)do { if (!(PTy)) { CheckFailed("Load operand must be a pointer."
, &LI); return; } } while (false)
;
3695 Type *ElTy = LI.getType();
3696 Assert(LI.getAlignment() <= Value::MaximumAlignment,do { if (!(LI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &LI
); return; } } while (false)
3697 "huge alignment values are unsupported", &LI)do { if (!(LI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &LI
); return; } } while (false)
;
3698 Assert(ElTy->isSized(), "loading unsized types is not allowed", &LI)do { if (!(ElTy->isSized())) { CheckFailed("loading unsized types is not allowed"
, &LI); return; } } while (false)
;
3699 if (LI.isAtomic()) {
3700 Assert(LI.getOrdering() != AtomicOrdering::Release &&do { if (!(LI.getOrdering() != AtomicOrdering::Release &&
LI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Load cannot have Release ordering", &LI); return; } } while
(false)
3701 LI.getOrdering() != AtomicOrdering::AcquireRelease,do { if (!(LI.getOrdering() != AtomicOrdering::Release &&
LI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Load cannot have Release ordering", &LI); return; } } while
(false)
3702 "Load cannot have Release ordering", &LI)do { if (!(LI.getOrdering() != AtomicOrdering::Release &&
LI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Load cannot have Release ordering", &LI); return; } } while
(false)
;
3703 Assert(LI.getAlignment() != 0,do { if (!(LI.getAlignment() != 0)) { CheckFailed("Atomic load must specify explicit alignment"
, &LI); return; } } while (false)
3704 "Atomic load must specify explicit alignment", &LI)do { if (!(LI.getAlignment() != 0)) { CheckFailed("Atomic load must specify explicit alignment"
, &LI); return; } } while (false)
;
3705 Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic load operand must have integer, pointer, or floating point "
"type!", ElTy, &LI); return; } } while (false)
3706 "atomic load operand must have integer, pointer, or floating point "do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic load operand must have integer, pointer, or floating point "
"type!", ElTy, &LI); return; } } while (false)
3707 "type!",do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic load operand must have integer, pointer, or floating point "
"type!", ElTy, &LI); return; } } while (false)
3708 ElTy, &LI)do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic load operand must have integer, pointer, or floating point "
"type!", ElTy, &LI); return; } } while (false)
;
3709 checkAtomicMemAccessSize(ElTy, &LI);
3710 } else {
3711 Assert(LI.getSyncScopeID() == SyncScope::System,do { if (!(LI.getSyncScopeID() == SyncScope::System)) { CheckFailed
("Non-atomic load cannot have SynchronizationScope specified"
, &LI); return; } } while (false)
3712 "Non-atomic load cannot have SynchronizationScope specified", &LI)do { if (!(LI.getSyncScopeID() == SyncScope::System)) { CheckFailed
("Non-atomic load cannot have SynchronizationScope specified"
, &LI); return; } } while (false)
;
3713 }
3714
3715 visitInstruction(LI);
3716}
3717
3718void Verifier::visitStoreInst(StoreInst &SI) {
3719 PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
3720 Assert(PTy, "Store operand must be a pointer.", &SI)do { if (!(PTy)) { CheckFailed("Store operand must be a pointer."
, &SI); return; } } while (false)
;
3721 Type *ElTy = SI.getOperand(0)->getType();
3722 Assert(PTy->isOpaqueOrPointeeTypeMatches(ElTy),do { if (!(PTy->isOpaqueOrPointeeTypeMatches(ElTy))) { CheckFailed
("Stored value type does not match pointer operand type!", &
SI, ElTy); return; } } while (false)
3723 "Stored value type does not match pointer operand type!", &SI, ElTy)do { if (!(PTy->isOpaqueOrPointeeTypeMatches(ElTy))) { CheckFailed
("Stored value type does not match pointer operand type!", &
SI, ElTy); return; } } while (false)
;
3724 Assert(SI.getAlignment() <= Value::MaximumAlignment,do { if (!(SI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &SI
); return; } } while (false)
3725 "huge alignment values are unsupported", &SI)do { if (!(SI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &SI
); return; } } while (false)
;
3726 Assert(ElTy->isSized(), "storing unsized types is not allowed", &SI)do { if (!(ElTy->isSized())) { CheckFailed("storing unsized types is not allowed"
, &SI); return; } } while (false)
;
3727 if (SI.isAtomic()) {
3728 Assert(SI.getOrdering() != AtomicOrdering::Acquire &&do { if (!(SI.getOrdering() != AtomicOrdering::Acquire &&
SI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Store cannot have Acquire ordering", &SI); return; } } while
(false)
3729 SI.getOrdering() != AtomicOrdering::AcquireRelease,do { if (!(SI.getOrdering() != AtomicOrdering::Acquire &&
SI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Store cannot have Acquire ordering", &SI); return; } } while
(false)
3730 "Store cannot have Acquire ordering", &SI)do { if (!(SI.getOrdering() != AtomicOrdering::Acquire &&
SI.getOrdering() != AtomicOrdering::AcquireRelease)) { CheckFailed
("Store cannot have Acquire ordering", &SI); return; } } while
(false)
;
3731 Assert(SI.getAlignment() != 0,do { if (!(SI.getAlignment() != 0)) { CheckFailed("Atomic store must specify explicit alignment"
, &SI); return; } } while (false)
3732 "Atomic store must specify explicit alignment", &SI)do { if (!(SI.getAlignment() != 0)) { CheckFailed("Atomic store must specify explicit alignment"
, &SI); return; } } while (false)
;
3733 Assert(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic store operand must have integer, pointer, or floating point "
"type!", ElTy, &SI); return; } } while (false)
3734 "atomic store operand must have integer, pointer, or floating point "do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic store operand must have integer, pointer, or floating point "
"type!", ElTy, &SI); return; } } while (false)
3735 "type!",do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic store operand must have integer, pointer, or floating point "
"type!", ElTy, &SI); return; } } while (false)
3736 ElTy, &SI)do { if (!(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomic store operand must have integer, pointer, or floating point "
"type!", ElTy, &SI); return; } } while (false)
;
3737 checkAtomicMemAccessSize(ElTy, &SI);
3738 } else {
3739 Assert(SI.getSyncScopeID() == SyncScope::System,do { if (!(SI.getSyncScopeID() == SyncScope::System)) { CheckFailed
("Non-atomic store cannot have SynchronizationScope specified"
, &SI); return; } } while (false)
3740 "Non-atomic store cannot have SynchronizationScope specified", &SI)do { if (!(SI.getSyncScopeID() == SyncScope::System)) { CheckFailed
("Non-atomic store cannot have SynchronizationScope specified"
, &SI); return; } } while (false)
;
3741 }
3742 visitInstruction(SI);
3743}
3744
3745/// Check that SwiftErrorVal is used as a swifterror argument in CS.
3746void Verifier::verifySwiftErrorCall(CallBase &Call,
3747 const Value *SwiftErrorVal) {
3748 for (const auto &I : llvm::enumerate(Call.args())) {
3749 if (I.value() == SwiftErrorVal) {
3750 Assert(Call.paramHasAttr(I.index(), Attribute::SwiftError),do { if (!(Call.paramHasAttr(I.index(), Attribute::SwiftError
))) { CheckFailed("swifterror value when used in a callsite should be marked "
"with swifterror attribute", SwiftErrorVal, Call); return; }
} while (false)
3751 "swifterror value when used in a callsite should be marked "do { if (!(Call.paramHasAttr(I.index(), Attribute::SwiftError
))) { CheckFailed("swifterror value when used in a callsite should be marked "
"with swifterror attribute", SwiftErrorVal, Call); return; }
} while (false)
3752 "with swifterror attribute",do { if (!(Call.paramHasAttr(I.index(), Attribute::SwiftError
))) { CheckFailed("swifterror value when used in a callsite should be marked "
"with swifterror attribute", SwiftErrorVal, Call); return; }
} while (false)
3753 SwiftErrorVal, Call)do { if (!(Call.paramHasAttr(I.index(), Attribute::SwiftError
))) { CheckFailed("swifterror value when used in a callsite should be marked "
"with swifterror attribute", SwiftErrorVal, Call); return; }
} while (false)
;
3754 }
3755 }
3756}
3757
3758void Verifier::verifySwiftErrorValue(const Value *SwiftErrorVal) {
3759 // Check that swifterror value is only used by loads, stores, or as
3760 // a swifterror argument.
3761 for (const User *U : SwiftErrorVal->users()) {
3762 Assert(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||do { if (!(isa<LoadInst>(U) || isa<StoreInst>(U) ||
isa<CallInst>(U) || isa<InvokeInst>(U))) { CheckFailed
("swifterror value can only be loaded and stored from, or " "as a swifterror argument!"
, SwiftErrorVal, U); return; } } while (false)
3763 isa<InvokeInst>(U),do { if (!(isa<LoadInst>(U) || isa<StoreInst>(U) ||
isa<CallInst>(U) || isa<InvokeInst>(U))) { CheckFailed
("swifterror value can only be loaded and stored from, or " "as a swifterror argument!"
, SwiftErrorVal, U); return; } } while (false)
3764 "swifterror value can only be loaded and stored from, or "do { if (!(isa<LoadInst>(U) || isa<StoreInst>(U) ||
isa<CallInst>(U) || isa<InvokeInst>(U))) { CheckFailed
("swifterror value can only be loaded and stored from, or " "as a swifterror argument!"
, SwiftErrorVal, U); return; } } while (false)
3765 "as a swifterror argument!",do { if (!(isa<LoadInst>(U) || isa<StoreInst>(U) ||
isa<CallInst>(U) || isa<InvokeInst>(U))) { CheckFailed
("swifterror value can only be loaded and stored from, or " "as a swifterror argument!"
, SwiftErrorVal, U); return; } } while (false)
3766 SwiftErrorVal, U)do { if (!(isa<LoadInst>(U) || isa<StoreInst>(U) ||
isa<CallInst>(U) || isa<InvokeInst>(U))) { CheckFailed
("swifterror value can only be loaded and stored from, or " "as a swifterror argument!"
, SwiftErrorVal, U); return; } } while (false)
;
3767 // If it is used by a store, check it is the second operand.
3768 if (auto StoreI = dyn_cast<StoreInst>(U))
3769 Assert(StoreI->getOperand(1) == SwiftErrorVal,do { if (!(StoreI->getOperand(1) == SwiftErrorVal)) { CheckFailed
("swifterror value should be the second operand when used " "by stores"
, SwiftErrorVal, U); return; } } while (false)
3770 "swifterror value should be the second operand when used "do { if (!(StoreI->getOperand(1) == SwiftErrorVal)) { CheckFailed
("swifterror value should be the second operand when used " "by stores"
, SwiftErrorVal, U); return; } } while (false)
3771 "by stores", SwiftErrorVal, U)do { if (!(StoreI->getOperand(1) == SwiftErrorVal)) { CheckFailed
("swifterror value should be the second operand when used " "by stores"
, SwiftErrorVal, U); return; } } while (false)
;
3772 if (auto *Call = dyn_cast<CallBase>(U))
3773 verifySwiftErrorCall(*const_cast<CallBase *>(Call), SwiftErrorVal);
3774 }
3775}
3776
3777void Verifier::visitAllocaInst(AllocaInst &AI) {
3778 SmallPtrSet<Type*, 4> Visited;
3779 Assert(AI.getAllocatedType()->isSized(&Visited),do { if (!(AI.getAllocatedType()->isSized(&Visited))) {
CheckFailed("Cannot allocate unsized type", &AI); return
; } } while (false)
3780 "Cannot allocate unsized type", &AI)do { if (!(AI.getAllocatedType()->isSized(&Visited))) {
CheckFailed("Cannot allocate unsized type", &AI); return
; } } while (false)
;
3781 Assert(AI.getArraySize()->getType()->isIntegerTy(),do { if (!(AI.getArraySize()->getType()->isIntegerTy())
) { CheckFailed("Alloca array size must have integer type", &
AI); return; } } while (false)
3782 "Alloca array size must have integer type", &AI)do { if (!(AI.getArraySize()->getType()->isIntegerTy())
) { CheckFailed("Alloca array size must have integer type", &
AI); return; } } while (false)
;
3783 Assert(AI.getAlignment() <= Value::MaximumAlignment,do { if (!(AI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &AI
); return; } } while (false)
3784 "huge alignment values are unsupported", &AI)do { if (!(AI.getAlignment() <= Value::MaximumAlignment)) {
CheckFailed("huge alignment values are unsupported", &AI
); return; } } while (false)
;
3785
3786 if (AI.isSwiftError()) {
3787 verifySwiftErrorValue(&AI);
3788 }
3789
3790 visitInstruction(AI);
3791}
3792
3793void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
3794 Type *ElTy = CXI.getOperand(1)->getType();
3795 Assert(ElTy->isIntOrPtrTy(),do { if (!(ElTy->isIntOrPtrTy())) { CheckFailed("cmpxchg operand must have integer or pointer type"
, ElTy, &CXI); return; } } while (false)
3796 "cmpxchg operand must have integer or pointer type", ElTy, &CXI)do { if (!(ElTy->isIntOrPtrTy())) { CheckFailed("cmpxchg operand must have integer or pointer type"
, ElTy, &CXI); return; } } while (false)
;
3797 checkAtomicMemAccessSize(ElTy, &CXI);
3798 visitInstruction(CXI);
3799}
3800
3801void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
3802 Assert(RMWI.getOrdering() != AtomicOrdering::Unordered,do { if (!(RMWI.getOrdering() != AtomicOrdering::Unordered)) {
CheckFailed("atomicrmw instructions cannot be unordered.", &
RMWI); return; } } while (false)
3803 "atomicrmw instructions cannot be unordered.", &RMWI)do { if (!(RMWI.getOrdering() != AtomicOrdering::Unordered)) {
CheckFailed("atomicrmw instructions cannot be unordered.", &
RMWI); return; } } while (false)
;
3804 auto Op = RMWI.getOperation();
3805 Type *ElTy = RMWI.getOperand(1)->getType();
3806 if (Op == AtomicRMWInst::Xchg) {
3807 Assert(ElTy->isIntegerTy() || ElTy->isFloatingPointTy(), "atomicrmw " +do { if (!(ElTy->isIntegerTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomicrmw " + AtomicRMWInst::getOperationName
(Op) + " operand must have integer or floating point type!", &
RMWI, ElTy); return; } } while (false)
3808 AtomicRMWInst::getOperationName(Op) +do { if (!(ElTy->isIntegerTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomicrmw " + AtomicRMWInst::getOperationName
(Op) + " operand must have integer or floating point type!", &
RMWI, ElTy); return; } } while (false)
3809 " operand must have integer or floating point type!",do { if (!(ElTy->isIntegerTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomicrmw " + AtomicRMWInst::getOperationName
(Op) + " operand must have integer or floating point type!", &
RMWI, ElTy); return; } } while (false)
3810 &RMWI, ElTy)do { if (!(ElTy->isIntegerTy() || ElTy->isFloatingPointTy
())) { CheckFailed("atomicrmw " + AtomicRMWInst::getOperationName
(Op) + " operand must have integer or floating point type!", &
RMWI, ElTy); return; } } while (false)
;
3811 } else if (AtomicRMWInst::isFPOperation(Op)) {
3812 Assert(ElTy->isFloatingPointTy(), "atomicrmw " +do { if (!(ElTy->isFloatingPointTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have floating point type!"
, &RMWI, ElTy); return; } } while (false)
3813 AtomicRMWInst::getOperationName(Op) +do { if (!(ElTy->isFloatingPointTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have floating point type!"
, &RMWI, ElTy); return; } } while (false)
3814 " operand must have floating point type!",do { if (!(ElTy->isFloatingPointTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have floating point type!"
, &RMWI, ElTy); return; } } while (false)
3815 &RMWI, ElTy)do { if (!(ElTy->isFloatingPointTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have floating point type!"
, &RMWI, ElTy); return; } } while (false)
;
3816 } else {
3817 Assert(ElTy->isIntegerTy(), "atomicrmw " +do { if (!(ElTy->isIntegerTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have integer type!"
, &RMWI, ElTy); return; } } while (false)
3818 AtomicRMWInst::getOperationName(Op) +do { if (!(ElTy->isIntegerTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have integer type!"
, &RMWI, ElTy); return; } } while (false)
3819 " operand must have integer type!",do { if (!(ElTy->isIntegerTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have integer type!"
, &RMWI, ElTy); return; } } while (false)
3820 &RMWI, ElTy)do { if (!(ElTy->isIntegerTy())) { CheckFailed("atomicrmw "
+ AtomicRMWInst::getOperationName(Op) + " operand must have integer type!"
, &RMWI, ElTy); return; } } while (false)
;
3821 }
3822 checkAtomicMemAccessSize(ElTy, &RMWI);
3823 Assert(AtomicRMWInst::FIRST_BINOP <= Op && Op <= AtomicRMWInst::LAST_BINOP,do { if (!(AtomicRMWInst::FIRST_BINOP <= Op && Op <=
AtomicRMWInst::LAST_BINOP)) { CheckFailed("Invalid binary operation!"
, &RMWI); return; } } while (false)
3824 "Invalid binary operation!", &RMWI)do { if (!(AtomicRMWInst::FIRST_BINOP <= Op && Op <=
AtomicRMWInst::LAST_BINOP)) { CheckFailed("Invalid binary operation!"
, &RMWI); return; } } while (false)
;
3825 visitInstruction(RMWI);
3826}
3827
3828void Verifier::visitFenceInst(FenceInst &FI) {
3829 const AtomicOrdering Ordering = FI.getOrdering();
3830 Assert(Ordering == AtomicOrdering::Acquire ||do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3831 Ordering == AtomicOrdering::Release ||do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3832 Ordering == AtomicOrdering::AcquireRelease ||do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3833 Ordering == AtomicOrdering::SequentiallyConsistent,do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3834 "fence instructions may only have acquire, release, acq_rel, or "do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3835 "seq_cst ordering.",do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
3836 &FI)do { if (!(Ordering == AtomicOrdering::Acquire || Ordering ==
AtomicOrdering::Release || Ordering == AtomicOrdering::AcquireRelease
|| Ordering == AtomicOrdering::SequentiallyConsistent)) { CheckFailed
("fence instructions may only have acquire, release, acq_rel, or "
"seq_cst ordering.", &FI); return; } } while (false)
;
3837 visitInstruction(FI);
3838}
3839
3840void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
3841 Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),do { if (!(ExtractValueInst::getIndexedType(EVI.getAggregateOperand
()->getType(), EVI.getIndices()) == EVI.getType())) { CheckFailed
("Invalid ExtractValueInst operands!", &EVI); return; } }
while (false)
3842 EVI.getIndices()) == EVI.getType(),do { if (!(ExtractValueInst::getIndexedType(EVI.getAggregateOperand
()->getType(), EVI.getIndices()) == EVI.getType())) { CheckFailed
("Invalid ExtractValueInst operands!", &EVI); return; } }
while (false)
3843 "Invalid ExtractValueInst operands!", &EVI)do { if (!(ExtractValueInst::getIndexedType(EVI.getAggregateOperand
()->getType(), EVI.getIndices()) == EVI.getType())) { CheckFailed
("Invalid ExtractValueInst operands!", &EVI); return; } }
while (false)
;
3844
3845 visitInstruction(EVI);
3846}
3847
3848void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
3849 Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),do { if (!(ExtractValueInst::getIndexedType(IVI.getAggregateOperand
()->getType(), IVI.getIndices()) == IVI.getOperand(1)->
getType())) { CheckFailed("Invalid InsertValueInst operands!"
, &IVI); return; } } while (false)
3850 IVI.getIndices()) ==do { if (!(ExtractValueInst::getIndexedType(IVI.getAggregateOperand
()->getType(), IVI.getIndices()) == IVI.getOperand(1)->
getType())) { CheckFailed("Invalid InsertValueInst operands!"
, &IVI); return; } } while (false)
3851 IVI.getOperand(1)->getType(),do { if (!(ExtractValueInst::getIndexedType(IVI.getAggregateOperand
()->getType(), IVI.getIndices()) == IVI.getOperand(1)->
getType())) { CheckFailed("Invalid InsertValueInst operands!"
, &IVI); return; } } while (false)
3852 "Invalid InsertValueInst operands!", &IVI)do { if (!(ExtractValueInst::getIndexedType(IVI.getAggregateOperand
()->getType(), IVI.getIndices()) == IVI.getOperand(1)->
getType())) { CheckFailed("Invalid InsertValueInst operands!"
, &IVI); return; } } while (false)
;
3853
3854 visitInstruction(IVI);
3855}
3856
3857static Value *getParentPad(Value *EHPad) {
3858 if (auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
3859 return FPI->getParentPad();
3860
3861 return cast<CatchSwitchInst>(EHPad)->getParentPad();
3862}
3863
3864void Verifier::visitEHPadPredecessors(Instruction &I) {
3865 assert(I.isEHPad())(static_cast<void> (0));
3866
3867 BasicBlock *BB = I.getParent();
3868 Function *F = BB->getParent();
3869
3870 Assert(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I)do { if (!(BB != &F->getEntryBlock())) { CheckFailed("EH pad cannot be in entry block."
, &I); return; } } while (false)
;
3871
3872 if (auto *LPI = dyn_cast<LandingPadInst>(&I)) {
3873 // The landingpad instruction defines its parent as a landing pad block. The
3874 // landing pad block may be branched to only by the unwind edge of an
3875 // invoke.
3876 for (BasicBlock *PredBB : predecessors(BB)) {
3877 const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator());
3878 Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,do { if (!(II && II->getUnwindDest() == BB &&
II->getNormalDest() != BB)) { CheckFailed("Block containing LandingPadInst must be jumped to "
"only by the unwind edge of an invoke.", LPI); return; } } while
(false)
3879 "Block containing LandingPadInst must be jumped to "do { if (!(II && II->getUnwindDest() == BB &&
II->getNormalDest() != BB)) { CheckFailed("Block containing LandingPadInst must be jumped to "
"only by the unwind edge of an invoke.", LPI); return; } } while
(false)
3880 "only by the unwind edge of an invoke.",do { if (!(II && II->getUnwindDest() == BB &&
II->getNormalDest() != BB)) { CheckFailed("Block containing LandingPadInst must be jumped to "
"only by the unwind edge of an invoke.", LPI); return; } } while
(false)
3881 LPI)do { if (!(II && II->getUnwindDest() == BB &&
II->getNormalDest() != BB)) { CheckFailed("Block containing LandingPadInst must be jumped to "
"only by the unwind edge of an invoke.", LPI); return; } } while
(false)
;
3882 }
3883 return;
3884 }
3885 if (auto *CPI = dyn_cast<CatchPadInst>(&I)) {
3886 if (!pred_empty(BB))
3887 Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),do { if (!(BB->getUniquePredecessor() == CPI->getCatchSwitch
()->getParent())) { CheckFailed("Block containg CatchPadInst must be jumped to "
"only by its catchswitch.", CPI); return; } } while (false)
3888 "Block containg CatchPadInst must be jumped to "do { if (!(BB->getUniquePredecessor() == CPI->getCatchSwitch
()->getParent())) { CheckFailed("Block containg CatchPadInst must be jumped to "
"only by its catchswitch.", CPI); return; } } while (false)
3889 "only by its catchswitch.",do { if (!(BB->getUniquePredecessor() == CPI->getCatchSwitch
()->getParent())) { CheckFailed("Block containg CatchPadInst must be jumped to "
"only by its catchswitch.", CPI); return; } } while (false)
3890 CPI)do { if (!(BB->getUniquePredecessor() == CPI->getCatchSwitch
()->getParent())) { CheckFailed("Block containg CatchPadInst must be jumped to "
"only by its catchswitch.", CPI); return; } } while (false)
;
3891 Assert(BB != CPI->getCatchSwitch()->getUnwindDest(),do { if (!(BB != CPI->getCatchSwitch()->getUnwindDest()
)) { CheckFailed("Catchswitch cannot unwind to one of its catchpads"
, CPI->getCatchSwitch(), CPI); return; } } while (false)
3892 "Catchswitch cannot unwind to one of its catchpads",do { if (!(BB != CPI->getCatchSwitch()->getUnwindDest()
)) { CheckFailed("Catchswitch cannot unwind to one of its catchpads"
, CPI->getCatchSwitch(), CPI); return; } } while (false)
3893 CPI->getCatchSwitch(), CPI)do { if (!(BB != CPI->getCatchSwitch()->getUnwindDest()
)) { CheckFailed("Catchswitch cannot unwind to one of its catchpads"
, CPI->getCatchSwitch(), CPI); return; } } while (false)
;
3894 return;
3895 }
3896
3897 // Verify that each pred has a legal terminator with a legal to/from EH
3898 // pad relationship.
3899 Instruction *ToPad = &I;
3900 Value *ToPadParent = getParentPad(ToPad);
3901 for (BasicBlock *PredBB : predecessors(BB)) {
3902 Instruction *TI = PredBB->getTerminator();
3903 Value *FromPad;
3904 if (auto *II = dyn_cast<InvokeInst>(TI)) {
3905 Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB,do { if (!(II->getUnwindDest() == BB && II->getNormalDest
() != BB)) { CheckFailed("EH pad must be jumped to via an unwind edge"
, ToPad, II); return; } } while (false)
3906 "EH pad must be jumped to via an unwind edge", ToPad, II)do { if (!(II->getUnwindDest() == BB && II->getNormalDest
() != BB)) { CheckFailed("EH pad must be jumped to via an unwind edge"
, ToPad, II); return; } } while (false)
;
3907 if (auto Bundle = II->getOperandBundle(LLVMContext::OB_funclet))
3908 FromPad = Bundle->Inputs[0];
3909 else
3910 FromPad = ConstantTokenNone::get(II->getContext());
3911 } else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
3912 FromPad = CRI->getOperand(0);
3913 Assert(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI)do { if (!(FromPad != ToPadParent)) { CheckFailed("A cleanupret must exit its cleanup"
, CRI); return; } } while (false)
;
3914 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
3915 FromPad = CSI;
3916 } else {
3917 Assert(false, "EH pad must be jumped to via an unwind edge", ToPad, TI)do { if (!(false)) { CheckFailed("EH pad must be jumped to via an unwind edge"
, ToPad, TI); return; } } while (false)
;
3918 }
3919
3920 // The edge may exit from zero or more nested pads.
3921 SmallSet<Value *, 8> Seen;
3922 for (;; FromPad = getParentPad(FromPad)) {
3923 Assert(FromPad != ToPad,do { if (!(FromPad != ToPad)) { CheckFailed("EH pad cannot handle exceptions raised within it"
, FromPad, TI); return; } } while (false)
3924 "EH pad cannot handle exceptions raised within it", FromPad, TI)do { if (!(FromPad != ToPad)) { CheckFailed("EH pad cannot handle exceptions raised within it"
, FromPad, TI); return; } } while (false)
;
3925 if (FromPad == ToPadParent) {
3926 // This is a legal unwind edge.
3927 break;
3928 }
3929 Assert(!isa<ConstantTokenNone>(FromPad),do { if (!(!isa<ConstantTokenNone>(FromPad))) { CheckFailed
("A single unwind edge may only enter one EH pad", TI); return
; } } while (false)
3930 "A single unwind edge may only enter one EH pad", TI)do { if (!(!isa<ConstantTokenNone>(FromPad))) { CheckFailed
("A single unwind edge may only enter one EH pad", TI); return
; } } while (false)
;
3931 Assert(Seen.insert(FromPad).second,do { if (!(Seen.insert(FromPad).second)) { CheckFailed("EH pad jumps through a cycle of pads"
, FromPad); return; } } while (false)
3932 "EH pad jumps through a cycle of pads", FromPad)do { if (!(Seen.insert(FromPad).second)) { CheckFailed("EH pad jumps through a cycle of pads"
, FromPad); return; } } while (false)
;
3933 }
3934 }
3935}
3936
3937void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
3938 // The landingpad instruction is ill-formed if it doesn't have any clauses and
3939 // isn't a cleanup.
3940 Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),do { if (!(LPI.getNumClauses() > 0 || LPI.isCleanup())) { CheckFailed
("LandingPadInst needs at least one clause or to be a cleanup."
, &LPI); return; } } while (false)
3941 "LandingPadInst needs at least one clause or to be a cleanup.", &LPI)do { if (!(LPI.getNumClauses() > 0 || LPI.isCleanup())) { CheckFailed
("LandingPadInst needs at least one clause or to be a cleanup."
, &LPI); return; } } while (false)
;
3942
3943 visitEHPadPredecessors(LPI);
3944
3945 if (!LandingPadResultTy)
3946 LandingPadResultTy = LPI.getType();
3947 else
3948 Assert(LandingPadResultTy == LPI.getType(),do { if (!(LandingPadResultTy == LPI.getType())) { CheckFailed
("The landingpad instruction should have a consistent result type "
"inside a function.", &LPI); return; } } while (false)
3949 "The landingpad instruction should have a consistent result type "do { if (!(LandingPadResultTy == LPI.getType())) { CheckFailed
("The landingpad instruction should have a consistent result type "
"inside a function.", &LPI); return; } } while (false)
3950 "inside a function.",do { if (!(LandingPadResultTy == LPI.getType())) { CheckFailed
("The landingpad instruction should have a consistent result type "
"inside a function.", &LPI); return; } } while (false)
3951 &LPI)do { if (!(LandingPadResultTy == LPI.getType())) { CheckFailed
("The landingpad instruction should have a consistent result type "
"inside a function.", &LPI); return; } } while (false)
;
3952
3953 Function *F = LPI.getParent()->getParent();
3954 Assert(F->hasPersonalityFn(),do { if (!(F->hasPersonalityFn())) { CheckFailed("LandingPadInst needs to be in a function with a personality."
, &LPI); return; } } while (false)
3955 "LandingPadInst needs to be in a function with a personality.", &LPI)do { if (!(F->hasPersonalityFn())) { CheckFailed("LandingPadInst needs to be in a function with a personality."
, &LPI); return; } } while (false)
;
3956
3957 // The landingpad instruction must be the first non-PHI instruction in the
3958 // block.
3959 Assert(LPI.getParent()->getLandingPadInst() == &LPI,do { if (!(LPI.getParent()->getLandingPadInst() == &LPI
)) { CheckFailed("LandingPadInst not the first non-PHI instruction in the block."
, &LPI); return; } } while (false)
3960 "LandingPadInst not the first non-PHI instruction in the block.",do { if (!(LPI.getParent()->getLandingPadInst() == &LPI
)) { CheckFailed("LandingPadInst not the first non-PHI instruction in the block."
, &LPI); return; } } while (false)
3961 &LPI)do { if (!(LPI.getParent()->getLandingPadInst() == &LPI
)) { CheckFailed("LandingPadInst not the first non-PHI instruction in the block."
, &LPI); return; } } while (false)
;
3962
3963 for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
3964 Constant *Clause = LPI.getClause(i);
3965 if (LPI.isCatch(i)) {
3966 Assert(isa<PointerType>(Clause->getType()),do { if (!(isa<PointerType>(Clause->getType()))) { CheckFailed
("Catch operand does not have pointer type!", &LPI); return
; } } while (false)
3967 "Catch operand does not have pointer type!", &LPI)do { if (!(isa<PointerType>(Clause->getType()))) { CheckFailed
("Catch operand does not have pointer type!", &LPI); return
; } } while (false)
;
3968 } else {
3969 Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI)do { if (!(LPI.isFilter(i))) { CheckFailed("Clause is neither catch nor filter!"
, &LPI); return; } } while (false)
;
3970 Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),do { if (!(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero
>(Clause))) { CheckFailed("Filter operand is not an array of constants!"
, &LPI); return; } } while (false)
3971 "Filter operand is not an array of constants!", &LPI)do { if (!(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero
>(Clause))) { CheckFailed("Filter operand is not an array of constants!"
, &LPI); return; } } while (false)
;
3972 }
3973 }
3974
3975 visitInstruction(LPI);
3976}
3977
3978void Verifier::visitResumeInst(ResumeInst &RI) {
3979 Assert(RI.getFunction()->hasPersonalityFn(),do { if (!(RI.getFunction()->hasPersonalityFn())) { CheckFailed
("ResumeInst needs to be in a function with a personality.", &
RI); return; } } while (false)
3980 "ResumeInst needs to be in a function with a personality.", &RI)do { if (!(RI.getFunction()->hasPersonalityFn())) { CheckFailed
("ResumeInst needs to be in a function with a personality.", &
RI); return; } } while (false)
;
3981
3982 if (!LandingPadResultTy)
3983 LandingPadResultTy = RI.getValue()->getType();
3984 else
3985 Assert(LandingPadResultTy == RI.getValue()->getType(),do { if (!(LandingPadResultTy == RI.getValue()->getType())
) { CheckFailed("The resume instruction should have a consistent result type "
"inside a function.", &RI); return; } } while (false)
3986 "The resume instruction should have a consistent result type "do { if (!(LandingPadResultTy == RI.getValue()->getType())
) { CheckFailed("The resume instruction should have a consistent result type "
"inside a function.", &RI); return; } } while (false)
3987 "inside a function.",do { if (!(LandingPadResultTy == RI.getValue()->getType())
) { CheckFailed("The resume instruction should have a consistent result type "
"inside a function.", &RI); return; } } while (false)
3988 &RI)do { if (!(LandingPadResultTy == RI.getValue()->getType())
) { CheckFailed("The resume instruction should have a consistent result type "
"inside a function.", &RI); return; } } while (false)
;
3989
3990 visitTerminator(RI);
3991}
3992
3993void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
3994 BasicBlock *BB = CPI.getParent();
3995
3996 Function *F = BB->getParent();
3997 Assert(F->hasPersonalityFn(),do { if (!(F->hasPersonalityFn())) { CheckFailed("CatchPadInst needs to be in a function with a personality."
, &CPI); return; } } while (false)
3998 "CatchPadInst needs to be in a function with a personality.", &CPI)do { if (!(F->hasPersonalityFn())) { CheckFailed("CatchPadInst needs to be in a function with a personality."
, &CPI); return; } } while (false)
;
3999
4000 Assert(isa<CatchSwitchInst>(CPI.getParentPad()),do { if (!(isa<CatchSwitchInst>(CPI.getParentPad()))) {
CheckFailed("CatchPadInst needs to be directly nested in a CatchSwitchInst."
, CPI.getParentPad()); return; } } while (false)
4001 "CatchPadInst needs to be directly nested in a CatchSwitchInst.",do { if (!(isa<CatchSwitchInst>(CPI.getParentPad()))) {
CheckFailed("CatchPadInst needs to be directly nested in a CatchSwitchInst."
, CPI.getParentPad()); return; } } while (false)
4002 CPI.getParentPad())do { if (!(isa<CatchSwitchInst>(CPI.getParentPad()))) {
CheckFailed("CatchPadInst needs to be directly nested in a CatchSwitchInst."
, CPI.getParentPad()); return; } } while (false)
;
4003
4004 // The catchpad instruction must be the first non-PHI instruction in the
4005 // block.
4006 Assert(BB->getFirstNonPHI() == &CPI,do { if (!(BB->getFirstNonPHI() == &CPI)) { CheckFailed
("CatchPadInst not the first non-PHI instruction in the block."
, &CPI); return; } } while (false)
4007 "CatchPadInst not the first non-PHI instruction in the block.", &CPI)do { if (!(BB->getFirstNonPHI() == &CPI)) { CheckFailed
("CatchPadInst not the first non-PHI instruction in the block."
, &CPI); return; } } while (false)
;
4008
4009 visitEHPadPredecessors(CPI);
4010 visitFuncletPadInst(CPI);
4011}
4012
4013void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
4014 Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)),do { if (!(isa<CatchPadInst>(CatchReturn.getOperand(0))
)) { CheckFailed("CatchReturnInst needs to be provided a CatchPad"
, &CatchReturn, CatchReturn.getOperand(0)); return; } } while
(false)
4015 "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,do { if (!(isa<CatchPadInst>(CatchReturn.getOperand(0))
)) { CheckFailed("CatchReturnInst needs to be provided a CatchPad"
, &CatchReturn, CatchReturn.getOperand(0)); return; } } while
(false)
4016 CatchReturn.getOperand(0))do { if (!(isa<CatchPadInst>(CatchReturn.getOperand(0))
)) { CheckFailed("CatchReturnInst needs to be provided a CatchPad"
, &CatchReturn, CatchReturn.getOperand(0)); return; } } while
(false)
;
4017
4018 visitTerminator(CatchReturn);
4019}
4020
4021void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
4022 BasicBlock *BB = CPI.getParent();
4023
4024 Function *F = BB->getParent();
4025 Assert(F->hasPersonalityFn(),do { if (!(F->hasPersonalityFn())) { CheckFailed("CleanupPadInst needs to be in a function with a personality."
, &CPI); return; } } while (false)
4026 "CleanupPadInst needs to be in a function with a personality.", &CPI)do { if (!(F->hasPersonalityFn())) { CheckFailed("CleanupPadInst needs to be in a function with a personality."
, &CPI); return; } } while (false)
;
4027
4028 // The cleanuppad instruction must be the first non-PHI instruction in the
4029 // block.
4030 Assert(BB->getFirstNonPHI() == &CPI,do { if (!(BB->getFirstNonPHI() == &CPI)) { CheckFailed
("CleanupPadInst not the first non-PHI instruction in the block."
, &CPI); return; } } while (false)
4031 "CleanupPadInst not the first non-PHI instruction in the block.",do { if (!(BB->getFirstNonPHI() == &CPI)) { CheckFailed
("CleanupPadInst not the first non-PHI instruction in the block."
, &CPI); return; } } while (false)
4032 &CPI)do { if (!(BB->getFirstNonPHI() == &CPI)) { CheckFailed
("CleanupPadInst not the first non-PHI instruction in the block."
, &CPI); return; } } while (false)
;
4033
4034 auto *ParentPad = CPI.getParentPad();
4035 Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),do { if (!(isa<ConstantTokenNone>(ParentPad) || isa<
FuncletPadInst>(ParentPad))) { CheckFailed("CleanupPadInst has an invalid parent."
, &CPI); return; } } while (false)
4036 "CleanupPadInst has an invalid parent.", &CPI)do { if (!(isa<ConstantTokenNone>(ParentPad) || isa<
FuncletPadInst>(ParentPad))) { CheckFailed("CleanupPadInst has an invalid parent."
, &CPI); return; } } while (false)
;
4037
4038 visitEHPadPredecessors(CPI);
4039 visitFuncletPadInst(CPI);
4040}
4041
4042void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
4043 User *FirstUser = nullptr;
4044 Value *FirstUnwindPad = nullptr;
4045 SmallVector<FuncletPadInst *, 8> Worklist({&FPI});
4046 SmallSet<FuncletPadInst *, 8> Seen;
4047
4048 while (!Worklist.empty()) {
4049 FuncletPadInst *CurrentPad = Worklist.pop_back_val();
4050 Assert(Seen.insert(CurrentPad).second,do { if (!(Seen.insert(CurrentPad).second)) { CheckFailed("FuncletPadInst must not be nested within itself"
, CurrentPad); return; } } while (false)
4051 "FuncletPadInst must not be nested within itself", CurrentPad)do { if (!(Seen.insert(CurrentPad).second)) { CheckFailed("FuncletPadInst must not be nested within itself"
, CurrentPad); return; } } while (false)
;
4052 Value *UnresolvedAncestorPad = nullptr;
4053 for (User *U : CurrentPad->users()) {
4054 BasicBlock *UnwindDest;
4055 if (auto *CRI = dyn_cast<CleanupReturnInst>(U)) {
4056 UnwindDest = CRI->getUnwindDest();
4057 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(U)) {
4058 // We allow catchswitch unwind to caller to nest
4059 // within an outer pad that unwinds somewhere else,
4060 // because catchswitch doesn't have a nounwind variant.
4061 // See e.g. SimplifyCFGOpt::SimplifyUnreachable.
4062 if (CSI->unwindsToCaller())
4063 continue;
4064 UnwindDest = CSI->getUnwindDest();
4065 } else if (auto *II = dyn_cast<InvokeInst>(U)) {
4066 UnwindDest = II->getUnwindDest();
4067 } else if (isa<CallInst>(U)) {
4068 // Calls which don't unwind may be found inside funclet
4069 // pads that unwind somewhere else. We don't *require*
4070 // such calls to be annotated nounwind.
4071 continue;
4072 } else if (auto *CPI = dyn_cast<CleanupPadInst>(U)) {
4073 // The unwind dest for a cleanup can only be found by
4074 // recursive search. Add it to the worklist, and we'll
4075 // search for its first use that determines where it unwinds.
4076 Worklist.push_back(CPI);
4077 continue;
4078 } else {
4079 Assert(isa<CatchReturnInst>(U), "Bogus funclet pad use", U)do { if (!(isa<CatchReturnInst>(U))) { CheckFailed("Bogus funclet pad use"
, U); return; } } while (false)
;
4080 continue;
4081 }
4082
4083 Value *UnwindPad;
4084 bool ExitsFPI;
4085 if (UnwindDest) {
4086 UnwindPad = UnwindDest->getFirstNonPHI();
4087 if (!cast<Instruction>(UnwindPad)->isEHPad())
4088 continue;
4089 Value *UnwindParent = getParentPad(UnwindPad);
4090 // Ignore unwind edges that don't exit CurrentPad.
4091 if (UnwindParent == CurrentPad)
4092 continue;
4093 // Determine whether the original funclet pad is exited,
4094 // and if we are scanning nested pads determine how many
4095 // of them are exited so we can stop searching their
4096 // children.
4097 Value *ExitedPad = CurrentPad;
4098 ExitsFPI = false;
4099 do {
4100 if (ExitedPad == &FPI) {
4101 ExitsFPI = true;
4102 // Now we can resolve any ancestors of CurrentPad up to
4103 // FPI, but not including FPI since we need to make sure
4104 // to check all direct users of FPI for consistency.
4105 UnresolvedAncestorPad = &FPI;
4106 break;
4107 }