LLVM  4.0.0
Verifier.cpp
Go to the documentation of this file.
1 //===-- Verifier.cpp - Implement the Module Verifier -----------------------==//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the function verifier interface, that can be used for some
11 // sanity checking of input to the system.
12 //
13 // Note that this does not provide full `Java style' security and verifications,
14 // instead it just tries to ensure that code is well-formed.
15 //
16 // * Both of a binary operator's parameters are of the same type
17 // * Verify that the indices of mem access instructions match other operands
18 // * Verify that arithmetic and other things are only performed on first-class
19 // types. Verify that shifts & logicals only happen on integrals f.e.
20 // * All of the constants in a switch statement are of the correct type
21 // * The code is in valid SSA form
22 // * It should be illegal to put a label into any other type (like a structure)
23 // or to return one. [except constant arrays!]
24 // * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad
25 // * PHI nodes must have an entry for each predecessor, with no extras.
26 // * PHI nodes must be the first thing in a basic block, all grouped together
27 // * PHI nodes must have at least one entry
28 // * All basic blocks should only end with terminator insts, not contain them
29 // * The entry node to a function must not have predecessors
30 // * All Instructions must be embedded into a basic block
31 // * Functions cannot take a void-typed parameter
32 // * Verify that a function's argument list agrees with it's declared type.
33 // * It is illegal to specify a name for a void value.
34 // * It is illegal to have a internal global value with no initializer
35 // * It is illegal to have a ret instruction that returns a value that does not
36 // agree with the function return value type.
37 // * Function call argument types match the function prototype
38 // * A landing pad is defined by a landingpad instruction, and can be jumped to
39 // only by the unwind edge of an invoke instruction.
40 // * A landingpad instruction must be the first non-PHI instruction in the
41 // block.
42 // * Landingpad instructions must be in a function with a personality function.
43 // * All other things that are tested by asserts spread about the code...
44 //
45 //===----------------------------------------------------------------------===//
46 
47 #include "llvm/IR/Verifier.h"
48 #include "llvm/ADT/APFloat.h"
49 #include "llvm/ADT/APInt.h"
50 #include "llvm/ADT/ArrayRef.h"
51 #include "llvm/ADT/DenseMap.h"
52 #include "llvm/ADT/ilist.h"
53 #include "llvm/ADT/MapVector.h"
54 #include "llvm/ADT/Optional.h"
55 #include "llvm/ADT/STLExtras.h"
56 #include "llvm/ADT/SmallPtrSet.h"
57 #include "llvm/ADT/SmallSet.h"
58 #include "llvm/ADT/SmallVector.h"
59 #include "llvm/ADT/StringMap.h"
60 #include "llvm/ADT/StringRef.h"
61 #include "llvm/ADT/Twine.h"
62 #include "llvm/IR/Argument.h"
63 #include "llvm/IR/Attributes.h"
64 #include "llvm/IR/BasicBlock.h"
65 #include "llvm/IR/CFG.h"
66 #include "llvm/IR/CallSite.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"
75 #include "llvm/IR/DebugLoc.h"
76 #include "llvm/IR/DerivedTypes.h"
77 #include "llvm/IR/DiagnosticInfo.h"
78 #include "llvm/IR/Dominators.h"
79 #include "llvm/IR/Function.h"
80 #include "llvm/IR/GlobalAlias.h"
81 #include "llvm/IR/GlobalValue.h"
82 #include "llvm/IR/GlobalVariable.h"
83 #include "llvm/IR/InlineAsm.h"
84 #include "llvm/IR/InstrTypes.h"
85 #include "llvm/IR/Instruction.h"
86 #include "llvm/IR/Instructions.h"
87 #include "llvm/IR/InstVisitor.h"
88 #include "llvm/IR/IntrinsicInst.h"
89 #include "llvm/IR/Intrinsics.h"
90 #include "llvm/IR/LLVMContext.h"
91 #include "llvm/IR/Metadata.h"
92 #include "llvm/IR/Module.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/Pass.h"
102 #include "llvm/Support/Casting.h"
104 #include "llvm/Support/Debug.h"
105 #include "llvm/Support/Dwarf.h"
107 #include "llvm/Support/MathExtras.h"
109 #include <algorithm>
110 #include <cassert>
111 #include <cstdint>
112 #include <memory>
113 #include <string>
114 #include <utility>
115 
116 using namespace llvm;
117 
118 static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true));
119 
120 namespace llvm {
121 
124  const Module &M;
126  const DataLayout &DL;
128 
129  /// Track the brokenness of the module while recursively visiting.
130  bool Broken = false;
131  /// Broken debug info can be "recovered" from by stripping the debug info.
132  bool BrokenDebugInfo = false;
133  /// Whether to treat broken debug info as an error.
135 
136  explicit VerifierSupport(raw_ostream *OS, const Module &M)
137  : OS(OS), M(M), MST(&M), DL(M.getDataLayout()), Context(M.getContext()) {}
138 
139 private:
140  void Write(const Module *M) {
141  *OS << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
142  }
143 
144  void Write(const Value *V) {
145  if (!V)
146  return;
147  if (isa<Instruction>(V)) {
148  V->print(*OS, MST);
149  *OS << '\n';
150  } else {
151  V->printAsOperand(*OS, true, MST);
152  *OS << '\n';
153  }
154  }
155 
156  void Write(ImmutableCallSite CS) {
157  Write(CS.getInstruction());
158  }
159 
160  void Write(const Metadata *MD) {
161  if (!MD)
162  return;
163  MD->print(*OS, MST, &M);
164  *OS << '\n';
165  }
166 
167  template <class T> void Write(const MDTupleTypedArrayWrapper<T> &MD) {
168  Write(MD.get());
169  }
170 
171  void Write(const NamedMDNode *NMD) {
172  if (!NMD)
173  return;
174  NMD->print(*OS, MST);
175  *OS << '\n';
176  }
177 
178  void Write(Type *T) {
179  if (!T)
180  return;
181  *OS << ' ' << *T;
182  }
183 
184  void Write(const Comdat *C) {
185  if (!C)
186  return;
187  *OS << *C;
188  }
189 
190  void Write(const APInt *AI) {
191  if (!AI)
192  return;
193  *OS << *AI << '\n';
194  }
195 
196  void Write(const unsigned i) { *OS << i << '\n'; }
197 
198  template <typename T> void Write(ArrayRef<T> Vs) {
199  for (const T &V : Vs)
200  Write(V);
201  }
202 
203  template <typename T1, typename... Ts>
204  void WriteTs(const T1 &V1, const Ts &... Vs) {
205  Write(V1);
206  WriteTs(Vs...);
207  }
208 
209  template <typename... Ts> void WriteTs() {}
210 
211 public:
212  /// \brief A check failed, so printout out the condition and the message.
213  ///
214  /// This provides a nice place to put a breakpoint if you want to see why
215  /// something is not correct.
216  void CheckFailed(const Twine &Message) {
217  if (OS)
218  *OS << Message << '\n';
219  Broken = true;
220  }
221 
222  /// \brief A check failed (with values to print).
223  ///
224  /// This calls the Message-only version so that the above is easier to set a
225  /// breakpoint on.
226  template <typename T1, typename... Ts>
227  void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) {
228  CheckFailed(Message);
229  if (OS)
230  WriteTs(V1, Vs...);
231  }
232 
233  /// A debug info check failed.
234  void DebugInfoCheckFailed(const Twine &Message) {
235  if (OS)
236  *OS << Message << '\n';
238  BrokenDebugInfo = true;
239  }
240 
241  /// A debug info check failed (with values to print).
242  template <typename T1, typename... Ts>
243  void DebugInfoCheckFailed(const Twine &Message, const T1 &V1,
244  const Ts &... Vs) {
245  DebugInfoCheckFailed(Message);
246  if (OS)
247  WriteTs(V1, Vs...);
248  }
249 };
250 
251 } // namespace llvm
252 
253 namespace {
254 
255 class Verifier : public InstVisitor<Verifier>, VerifierSupport {
256  friend class InstVisitor<Verifier>;
257 
258  DominatorTree DT;
259 
260  /// \brief When verifying a basic block, keep track of all of the
261  /// instructions we have seen so far.
262  ///
263  /// This allows us to do efficient dominance checks for the case when an
264  /// instruction has an operand that is an instruction in the same block.
265  SmallPtrSet<Instruction *, 16> InstsInThisBlock;
266 
267  /// \brief Keep track of the metadata nodes that have been checked already.
269 
270  /// Track all DICompileUnits visited.
272 
273  /// \brief The result type for a landingpad.
274  Type *LandingPadResultTy;
275 
276  /// \brief Whether we've seen a call to @llvm.localescape in this function
277  /// already.
278  bool SawFrameEscape;
279 
280  /// Stores the count of how many objects were passed to llvm.localescape for a
281  /// given function and the largest index passed to llvm.localrecover.
283 
284  // Maps catchswitches and cleanuppads that unwind to siblings to the
285  // terminators that indicate the unwind, used to detect cycles therein.
287 
288  /// Cache of constants visited in search of ConstantExprs.
289  SmallPtrSet<const Constant *, 32> ConstantExprVisited;
290 
291  /// Cache of declarations of the llvm.experimental.deoptimize.<ty> intrinsic.
292  SmallVector<const Function *, 4> DeoptimizeDeclarations;
293 
294  // Verify that this GlobalValue is only used in this module.
295  // This map is used to avoid visiting uses twice. We can arrive at a user
296  // twice, if they have multiple operands. In particular for very large
297  // constant expressions, we can arrive at a particular user many times.
298  SmallPtrSet<const Value *, 32> GlobalValueVisited;
299 
300  TBAAVerifier TBAAVerifyHelper;
301 
302  void checkAtomicMemAccessSize(Type *Ty, const Instruction *I);
303 
304 public:
305  explicit Verifier(raw_ostream *OS, bool ShouldTreatBrokenDebugInfoAsError,
306  const Module &M)
307  : VerifierSupport(OS, M), LandingPadResultTy(nullptr),
308  SawFrameEscape(false), TBAAVerifyHelper(this) {
309  TreatBrokenDebugInfoAsError = ShouldTreatBrokenDebugInfoAsError;
310  }
311 
312  bool hasBrokenDebugInfo() const { return BrokenDebugInfo; }
313 
314  bool verify(const Function &F) {
315  assert(F.getParent() == &M &&
316  "An instance of this class only works with a specific module!");
317 
318  // First ensure the function is well-enough formed to compute dominance
319  // information, and directly compute a dominance tree. We don't rely on the
320  // pass manager to provide this as it isolates us from a potentially
321  // out-of-date dominator tree and makes it significantly more complex to run
322  // this code outside of a pass manager.
323  // FIXME: It's really gross that we have to cast away constness here.
324  if (!F.empty())
325  DT.recalculate(const_cast<Function &>(F));
326 
327  for (const BasicBlock &BB : F) {
328  if (!BB.empty() && BB.back().isTerminator())
329  continue;
330 
331  if (OS) {
332  *OS << "Basic Block in function '" << F.getName()
333  << "' does not have terminator!\n";
334  BB.printAsOperand(*OS, true, MST);
335  *OS << "\n";
336  }
337  return false;
338  }
339 
340  Broken = false;
341  // FIXME: We strip const here because the inst visitor strips const.
342  visit(const_cast<Function &>(F));
343  verifySiblingFuncletUnwinds();
344  InstsInThisBlock.clear();
345  LandingPadResultTy = nullptr;
346  SawFrameEscape = false;
347  SiblingFuncletInfo.clear();
348 
349  return !Broken;
350  }
351 
352  /// Verify the module that this instance of \c Verifier was initialized with.
353  bool verify() {
354  Broken = false;
355 
356  // Collect all declarations of the llvm.experimental.deoptimize intrinsic.
357  for (const Function &F : M)
358  if (F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
359  DeoptimizeDeclarations.push_back(&F);
360 
361  // Now that we've visited every function, verify that we never asked to
362  // recover a frame index that wasn't escaped.
363  verifyFrameRecoverIndices();
364  for (const GlobalVariable &GV : M.globals())
365  visitGlobalVariable(GV);
366 
367  for (const GlobalAlias &GA : M.aliases())
368  visitGlobalAlias(GA);
369 
370  for (const NamedMDNode &NMD : M.named_metadata())
371  visitNamedMDNode(NMD);
372 
373  for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable())
374  visitComdat(SMEC.getValue());
375 
376  visitModuleFlags(M);
377  visitModuleIdents(M);
378 
379  verifyCompileUnits();
380 
381  verifyDeoptimizeCallingConvs();
382 
383  return !Broken;
384  }
385 
386 private:
387  // Verification methods...
388  void visitGlobalValue(const GlobalValue &GV);
389  void visitGlobalVariable(const GlobalVariable &GV);
390  void visitGlobalAlias(const GlobalAlias &GA);
391  void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C);
392  void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited,
393  const GlobalAlias &A, const Constant &C);
394  void visitNamedMDNode(const NamedMDNode &NMD);
395  void visitMDNode(const MDNode &MD);
396  void visitMetadataAsValue(const MetadataAsValue &MD, Function *F);
397  void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F);
398  void visitComdat(const Comdat &C);
399  void visitModuleIdents(const Module &M);
400  void visitModuleFlags(const Module &M);
401  void visitModuleFlag(const MDNode *Op,
403  SmallVectorImpl<const MDNode *> &Requirements);
404  void visitFunction(const Function &F);
405  void visitBasicBlock(BasicBlock &BB);
406  void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
407  void visitDereferenceableMetadata(Instruction &I, MDNode *MD);
408 
409  template <class Ty> bool isValidMetadataArray(const MDTuple &N);
410 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
411 #include "llvm/IR/Metadata.def"
412  void visitDIScope(const DIScope &N);
413  void visitDIVariable(const DIVariable &N);
414  void visitDILexicalBlockBase(const DILexicalBlockBase &N);
415  void visitDITemplateParameter(const DITemplateParameter &N);
416 
417  void visitTemplateParams(const MDNode &N, const Metadata &RawParams);
418 
419  // InstVisitor overrides...
421  void visit(Instruction &I);
422 
423  void visitTruncInst(TruncInst &I);
424  void visitZExtInst(ZExtInst &I);
425  void visitSExtInst(SExtInst &I);
426  void visitFPTruncInst(FPTruncInst &I);
427  void visitFPExtInst(FPExtInst &I);
428  void visitFPToUIInst(FPToUIInst &I);
429  void visitFPToSIInst(FPToSIInst &I);
430  void visitUIToFPInst(UIToFPInst &I);
431  void visitSIToFPInst(SIToFPInst &I);
432  void visitIntToPtrInst(IntToPtrInst &I);
433  void visitPtrToIntInst(PtrToIntInst &I);
434  void visitBitCastInst(BitCastInst &I);
435  void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
436  void visitPHINode(PHINode &PN);
437  void visitBinaryOperator(BinaryOperator &B);
438  void visitICmpInst(ICmpInst &IC);
439  void visitFCmpInst(FCmpInst &FC);
440  void visitExtractElementInst(ExtractElementInst &EI);
441  void visitInsertElementInst(InsertElementInst &EI);
442  void visitShuffleVectorInst(ShuffleVectorInst &EI);
443  void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); }
444  void visitCallInst(CallInst &CI);
445  void visitInvokeInst(InvokeInst &II);
446  void visitGetElementPtrInst(GetElementPtrInst &GEP);
447  void visitLoadInst(LoadInst &LI);
448  void visitStoreInst(StoreInst &SI);
449  void verifyDominatesUse(Instruction &I, unsigned i);
450  void visitInstruction(Instruction &I);
451  void visitTerminatorInst(TerminatorInst &I);
452  void visitBranchInst(BranchInst &BI);
453  void visitReturnInst(ReturnInst &RI);
454  void visitSwitchInst(SwitchInst &SI);
455  void visitIndirectBrInst(IndirectBrInst &BI);
456  void visitSelectInst(SelectInst &SI);
457  void visitUserOp1(Instruction &I);
458  void visitUserOp2(Instruction &I) { visitUserOp1(I); }
459  void visitIntrinsicCallSite(Intrinsic::ID ID, CallSite CS);
460  template <class DbgIntrinsicTy>
461  void visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII);
462  void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
463  void visitAtomicRMWInst(AtomicRMWInst &RMWI);
464  void visitFenceInst(FenceInst &FI);
465  void visitAllocaInst(AllocaInst &AI);
466  void visitExtractValueInst(ExtractValueInst &EVI);
467  void visitInsertValueInst(InsertValueInst &IVI);
468  void visitEHPadPredecessors(Instruction &I);
469  void visitLandingPadInst(LandingPadInst &LPI);
470  void visitResumeInst(ResumeInst &RI);
471  void visitCatchPadInst(CatchPadInst &CPI);
472  void visitCatchReturnInst(CatchReturnInst &CatchReturn);
473  void visitCleanupPadInst(CleanupPadInst &CPI);
474  void visitFuncletPadInst(FuncletPadInst &FPI);
475  void visitCatchSwitchInst(CatchSwitchInst &CatchSwitch);
476  void visitCleanupReturnInst(CleanupReturnInst &CRI);
477 
478  void verifyCallSite(CallSite CS);
479  void verifySwiftErrorCallSite(CallSite CS, const Value *SwiftErrorVal);
480  void verifySwiftErrorValue(const Value *SwiftErrorVal);
481  void verifyMustTailCall(CallInst &CI);
482  bool performTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
483  unsigned ArgNo, std::string &Suffix);
484  bool verifyAttributeCount(AttributeSet Attrs, unsigned Params);
485  void verifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction,
486  const Value *V);
487  void verifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
488  bool isReturnValue, const Value *V);
489  void verifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
490  const Value *V);
491  void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
492 
493  void visitConstantExprsRecursively(const Constant *EntryC);
494  void visitConstantExpr(const ConstantExpr *CE);
495  void verifyStatepoint(ImmutableCallSite CS);
496  void verifyFrameRecoverIndices();
497  void verifySiblingFuncletUnwinds();
498 
499  void verifyFragmentExpression(const DbgInfoIntrinsic &I);
500 
501  /// Module-level debug info verification...
502  void verifyCompileUnits();
503 
504  /// Module-level verification that all @llvm.experimental.deoptimize
505  /// declarations share the same calling convention.
506  void verifyDeoptimizeCallingConvs();
507 };
508 
509 } // end anonymous namespace
510 
511 /// We know that cond should be true, if not print an error message.
512 #define Assert(C, ...) \
513  do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (false)
514 
515 /// We know that a debug info condition should be true, if not print
516 /// an error message.
517 #define AssertDI(C, ...) \
518  do { if (!(C)) { DebugInfoCheckFailed(__VA_ARGS__); return; } } while (false)
519 
520 void Verifier::visit(Instruction &I) {
521  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
522  Assert(I.getOperand(i) != nullptr, "Operand is null", &I);
524 }
525 
526 // Helper to recursively iterate over indirect users. By
527 // returning false, the callback can ask to stop recursing
528 // further.
529 static void forEachUser(const Value *User,
531  llvm::function_ref<bool(const Value *)> Callback) {
532  if (!Visited.insert(User).second)
533  return;
534  for (const Value *TheNextUser : User->materialized_users())
535  if (Callback(TheNextUser))
536  forEachUser(TheNextUser, Visited, Callback);
537 }
538 
539 void Verifier::visitGlobalValue(const GlobalValue &GV) {
541  "Global is external, but doesn't have external or weak linkage!", &GV);
542 
544  "huge alignment values are unsupported", &GV);
545  Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
546  "Only global variables can have appending linkage!", &GV);
547 
548  if (GV.hasAppendingLinkage()) {
549  const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
550  Assert(GVar && GVar->getValueType()->isArrayTy(),
551  "Only global arrays can have appending linkage!", GVar);
552  }
553 
554  if (GV.isDeclarationForLinker())
555  Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
556 
557  forEachUser(&GV, GlobalValueVisited, [&](const Value *V) -> bool {
558  if (const Instruction *I = dyn_cast<Instruction>(V)) {
559  if (!I->getParent() || !I->getParent()->getParent())
560  CheckFailed("Global is referenced by parentless instruction!", &GV, &M,
561  I);
562  else if (I->getParent()->getParent()->getParent() != &M)
563  CheckFailed("Global is referenced in a different module!", &GV, &M, I,
564  I->getParent()->getParent(),
565  I->getParent()->getParent()->getParent());
566  return false;
567  } else if (const Function *F = dyn_cast<Function>(V)) {
568  if (F->getParent() != &M)
569  CheckFailed("Global is used by function in a different module", &GV, &M,
570  F, F->getParent());
571  return false;
572  }
573  return true;
574  });
575 }
576 
577 void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
578  if (GV.hasInitializer()) {
579  Assert(GV.getInitializer()->getType() == GV.getValueType(),
580  "Global variable initializer type does not match global "
581  "variable type!",
582  &GV);
583  // If the global has common linkage, it must have a zero initializer and
584  // cannot be constant.
585  if (GV.hasCommonLinkage()) {
587  "'common' global must have a zero initializer!", &GV);
588  Assert(!GV.isConstant(), "'common' global may not be marked constant!",
589  &GV);
590  Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
591  }
592  }
593 
594  if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
595  GV.getName() == "llvm.global_dtors")) {
597  "invalid linkage for intrinsic global variable", &GV);
598  // Don't worry about emitting an error for it not being an array,
599  // visitGlobalValue will complain on appending non-array.
600  if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
601  StructType *STy = dyn_cast<StructType>(ATy->getElementType());
602  PointerType *FuncPtrTy =
604  // FIXME: Reject the 2-field form in LLVM 4.0.
605  Assert(STy &&
606  (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
607  STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
608  STy->getTypeAtIndex(1) == FuncPtrTy,
609  "wrong type for intrinsic global variable", &GV);
610  if (STy->getNumElements() == 3) {
611  Type *ETy = STy->getTypeAtIndex(2);
612  Assert(ETy->isPointerTy() &&
613  cast<PointerType>(ETy)->getElementType()->isIntegerTy(8),
614  "wrong type for intrinsic global variable", &GV);
615  }
616  }
617  }
618 
619  if (GV.hasName() && (GV.getName() == "llvm.used" ||
620  GV.getName() == "llvm.compiler.used")) {
622  "invalid linkage for intrinsic global variable", &GV);
623  Type *GVType = GV.getValueType();
624  if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
625  PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
626  Assert(PTy, "wrong type for intrinsic global variable", &GV);
627  if (GV.hasInitializer()) {
628  const Constant *Init = GV.getInitializer();
629  const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
630  Assert(InitArray, "wrong initalizer for intrinsic global variable",
631  Init);
632  for (Value *Op : InitArray->operands()) {
633  Value *V = Op->stripPointerCastsNoFollowAliases();
634  Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
635  isa<GlobalAlias>(V),
636  "invalid llvm.used member", V);
637  Assert(V->hasName(), "members of llvm.used must be named", V);
638  }
639  }
640  }
641  }
642 
644  (GV.isDeclaration() && GV.hasExternalLinkage()) ||
646  "Global is marked as dllimport, but not external", &GV);
647 
648  // Visit any debug info attachments.
651  for (auto *MD : MDs) {
652  if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
653  visitDIGlobalVariableExpression(*GVE);
654  else
655  AssertDI(false, "!dbg attachment of global variable must be a DIGlobalVariableExpression");
656  }
657 
658  if (!GV.hasInitializer()) {
659  visitGlobalValue(GV);
660  return;
661  }
662 
663  // Walk any aggregate initializers looking for bitcasts between address spaces
664  visitConstantExprsRecursively(GV.getInitializer());
665 
666  visitGlobalValue(GV);
667 }
668 
669 void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
671  Visited.insert(&GA);
672  visitAliaseeSubExpr(Visited, GA, C);
673 }
674 
675 void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
676  const GlobalAlias &GA, const Constant &C) {
677  if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
678  Assert(!GV->isDeclarationForLinker(), "Alias must point to a definition",
679  &GA);
680 
681  if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
682  Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
683 
684  Assert(!GA2->isInterposable(), "Alias cannot point to an interposable alias",
685  &GA);
686  } else {
687  // Only continue verifying subexpressions of GlobalAliases.
688  // Do not recurse into global initializers.
689  return;
690  }
691  }
692 
693  if (const auto *CE = dyn_cast<ConstantExpr>(&C))
694  visitConstantExprsRecursively(CE);
695 
696  for (const Use &U : C.operands()) {
697  Value *V = &*U;
698  if (const auto *GA2 = dyn_cast<GlobalAlias>(V))
699  visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
700  else if (const auto *C2 = dyn_cast<Constant>(V))
701  visitAliaseeSubExpr(Visited, GA, *C2);
702  }
703 }
704 
705 void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
707  "Alias should have private, internal, linkonce, weak, linkonce_odr, "
708  "weak_odr, or external linkage!",
709  &GA);
710  const Constant *Aliasee = GA.getAliasee();
711  Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
712  Assert(GA.getType() == Aliasee->getType(),
713  "Alias and aliasee types should match!", &GA);
714 
715  Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
716  "Aliasee should be either GlobalValue or ConstantExpr", &GA);
717 
718  visitAliaseeSubExpr(GA, *Aliasee);
719 
720  visitGlobalValue(GA);
721 }
722 
723 void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
724  // There used to be various other llvm.dbg.* nodes, but we don't support
725  // upgrading them and we want to reserve the namespace for future uses.
726  if (NMD.getName().startswith("llvm.dbg."))
727  AssertDI(NMD.getName() == "llvm.dbg.cu",
728  "unrecognized named metadata node in the llvm.dbg namespace",
729  &NMD);
730  for (const MDNode *MD : NMD.operands()) {
731  if (NMD.getName() == "llvm.dbg.cu")
732  AssertDI(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD);
733 
734  if (!MD)
735  continue;
736 
737  visitMDNode(*MD);
738  }
739 }
740 
741 void Verifier::visitMDNode(const MDNode &MD) {
742  // Only visit each node once. Metadata can be mutually recursive, so this
743  // avoids infinite recursion here, as well as being an optimization.
744  if (!MDNodes.insert(&MD).second)
745  return;
746 
747  switch (MD.getMetadataID()) {
748  default:
749  llvm_unreachable("Invalid MDNode subclass");
750  case Metadata::MDTupleKind:
751  break;
752 #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
753  case Metadata::CLASS##Kind: \
754  visit##CLASS(cast<CLASS>(MD)); \
755  break;
756 #include "llvm/IR/Metadata.def"
757  }
758 
759  for (const Metadata *Op : MD.operands()) {
760  if (!Op)
761  continue;
762  Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
763  &MD, Op);
764  if (auto *N = dyn_cast<MDNode>(Op)) {
765  visitMDNode(*N);
766  continue;
767  }
768  if (auto *V = dyn_cast<ValueAsMetadata>(Op)) {
769  visitValueAsMetadata(*V, nullptr);
770  continue;
771  }
772  }
773 
774  // Check these last, so we diagnose problems in operands first.
775  Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD);
776  Assert(MD.isResolved(), "All nodes should be resolved!", &MD);
777 }
778 
779 void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
780  Assert(MD.getValue(), "Expected valid value", &MD);
781  Assert(!MD.getValue()->getType()->isMetadataTy(),
782  "Unexpected metadata round-trip through values", &MD, MD.getValue());
783 
784  auto *L = dyn_cast<LocalAsMetadata>(&MD);
785  if (!L)
786  return;
787 
788  Assert(F, "function-local metadata used outside a function", L);
789 
790  // If this was an instruction, bb, or argument, verify that it is in the
791  // function that we expect.
792  Function *ActualF = nullptr;
793  if (Instruction *I = dyn_cast<Instruction>(L->getValue())) {
794  Assert(I->getParent(), "function-local metadata not in basic block", L, I);
795  ActualF = I->getParent()->getParent();
796  } else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue()))
797  ActualF = BB->getParent();
798  else if (Argument *A = dyn_cast<Argument>(L->getValue()))
799  ActualF = A->getParent();
800  assert(ActualF && "Unimplemented function local metadata case!");
801 
802  Assert(ActualF == F, "function-local metadata used in wrong function", L);
803 }
804 
805 void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
806  Metadata *MD = MDV.getMetadata();
807  if (auto *N = dyn_cast<MDNode>(MD)) {
808  visitMDNode(*N);
809  return;
810  }
811 
812  // Only visit each node once. Metadata can be mutually recursive, so this
813  // avoids infinite recursion here, as well as being an optimization.
814  if (!MDNodes.insert(MD).second)
815  return;
816 
817  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
818  visitValueAsMetadata(*V, F);
819 }
820 
821 static bool isType(const Metadata *MD) { return !MD || isa<DIType>(MD); }
822 static bool isScope(const Metadata *MD) { return !MD || isa<DIScope>(MD); }
823 static bool isDINode(const Metadata *MD) { return !MD || isa<DINode>(MD); }
824 
825 template <class Ty>
826 static bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull) {
827  for (Metadata *MD : N.operands()) {
828  if (MD) {
829  if (!isa<Ty>(MD))
830  return false;
831  } else {
832  if (!AllowNull)
833  return false;
834  }
835  }
836  return true;
837 }
838 
839 template <class Ty> static bool isValidMetadataArray(const MDTuple &N) {
840  return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ false);
841 }
842 
843 template <class Ty> static bool isValidMetadataNullArray(const MDTuple &N) {
844  return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ true);
845 }
846 
847 void Verifier::visitDILocation(const DILocation &N) {
848  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
849  "location requires a valid scope", &N, N.getRawScope());
850  if (auto *IA = N.getRawInlinedAt())
851  AssertDI(isa<DILocation>(IA), "inlined-at should be a location", &N, IA);
852 }
853 
854 void Verifier::visitGenericDINode(const GenericDINode &N) {
855  AssertDI(N.getTag(), "invalid tag", &N);
856 }
857 
858 void Verifier::visitDIScope(const DIScope &N) {
859  if (auto *F = N.getRawFile())
860  AssertDI(isa<DIFile>(F), "invalid file", &N, F);
861 }
862 
863 void Verifier::visitDISubrange(const DISubrange &N) {
864  AssertDI(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
865  AssertDI(N.getCount() >= -1, "invalid subrange count", &N);
866 }
867 
868 void Verifier::visitDIEnumerator(const DIEnumerator &N) {
869  AssertDI(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
870 }
871 
872 void Verifier::visitDIBasicType(const DIBasicType &N) {
873  AssertDI(N.getTag() == dwarf::DW_TAG_base_type ||
874  N.getTag() == dwarf::DW_TAG_unspecified_type,
875  "invalid tag", &N);
876 }
877 
878 void Verifier::visitDIDerivedType(const DIDerivedType &N) {
879  // Common scope checks.
880  visitDIScope(N);
881 
882  AssertDI(N.getTag() == dwarf::DW_TAG_typedef ||
883  N.getTag() == dwarf::DW_TAG_pointer_type ||
884  N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
885  N.getTag() == dwarf::DW_TAG_reference_type ||
886  N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
887  N.getTag() == dwarf::DW_TAG_const_type ||
888  N.getTag() == dwarf::DW_TAG_volatile_type ||
889  N.getTag() == dwarf::DW_TAG_restrict_type ||
890  N.getTag() == dwarf::DW_TAG_atomic_type ||
891  N.getTag() == dwarf::DW_TAG_member ||
892  N.getTag() == dwarf::DW_TAG_inheritance ||
893  N.getTag() == dwarf::DW_TAG_friend,
894  "invalid tag", &N);
895  if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
896  AssertDI(isType(N.getRawExtraData()), "invalid pointer to member type", &N,
897  N.getRawExtraData());
898  }
899 
900  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
901  AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,
902  N.getRawBaseType());
903 }
904 
905 static bool hasConflictingReferenceFlags(unsigned Flags) {
906  return (Flags & DINode::FlagLValueReference) &&
907  (Flags & DINode::FlagRValueReference);
908 }
909 
910 void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
911  auto *Params = dyn_cast<MDTuple>(&RawParams);
912  AssertDI(Params, "invalid template params", &N, &RawParams);
913  for (Metadata *Op : Params->operands()) {
914  AssertDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
915  &N, Params, Op);
916  }
917 }
918 
919 void Verifier::visitDICompositeType(const DICompositeType &N) {
920  // Common scope checks.
921  visitDIScope(N);
922 
923  AssertDI(N.getTag() == dwarf::DW_TAG_array_type ||
924  N.getTag() == dwarf::DW_TAG_structure_type ||
925  N.getTag() == dwarf::DW_TAG_union_type ||
926  N.getTag() == dwarf::DW_TAG_enumeration_type ||
927  N.getTag() == dwarf::DW_TAG_class_type,
928  "invalid tag", &N);
929 
930  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
931  AssertDI(isType(N.getRawBaseType()), "invalid base type", &N,
932  N.getRawBaseType());
933 
934  AssertDI(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
935  "invalid composite elements", &N, N.getRawElements());
936  AssertDI(isType(N.getRawVTableHolder()), "invalid vtable holder", &N,
937  N.getRawVTableHolder());
939  "invalid reference flags", &N);
940  if (auto *Params = N.getRawTemplateParams())
941  visitTemplateParams(N, *Params);
942 
943  if (N.getTag() == dwarf::DW_TAG_class_type ||
944  N.getTag() == dwarf::DW_TAG_union_type) {
945  AssertDI(N.getFile() && !N.getFile()->getFilename().empty(),
946  "class/union requires a filename", &N, N.getFile());
947  }
948 }
949 
950 void Verifier::visitDISubroutineType(const DISubroutineType &N) {
951  AssertDI(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
952  if (auto *Types = N.getRawTypeArray()) {
953  AssertDI(isa<MDTuple>(Types), "invalid composite elements", &N, Types);
954  for (Metadata *Ty : N.getTypeArray()->operands()) {
955  AssertDI(isType(Ty), "invalid subroutine type ref", &N, Types, Ty);
956  }
957  }
959  "invalid reference flags", &N);
960 }
961 
962 void Verifier::visitDIFile(const DIFile &N) {
963  AssertDI(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
965  N.getChecksum().empty()), "invalid checksum kind", &N);
966 }
967 
968 void Verifier::visitDICompileUnit(const DICompileUnit &N) {
969  AssertDI(N.isDistinct(), "compile units must be distinct", &N);
970  AssertDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
971 
972  // Don't bother verifying the compilation directory or producer string
973  // as those could be empty.
974  AssertDI(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N,
975  N.getRawFile());
976  AssertDI(!N.getFile()->getFilename().empty(), "invalid filename", &N,
977  N.getFile());
978 
980  "invalid emission kind", &N);
981 
982  if (auto *Array = N.getRawEnumTypes()) {
983  AssertDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
984  for (Metadata *Op : N.getEnumTypes()->operands()) {
985  auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
986  AssertDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
987  "invalid enum type", &N, N.getEnumTypes(), Op);
988  }
989  }
990  if (auto *Array = N.getRawRetainedTypes()) {
991  AssertDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
992  for (Metadata *Op : N.getRetainedTypes()->operands()) {
993  AssertDI(Op && (isa<DIType>(Op) ||
994  (isa<DISubprogram>(Op) &&
995  !cast<DISubprogram>(Op)->isDefinition())),
996  "invalid retained type", &N, Op);
997  }
998  }
999  if (auto *Array = N.getRawGlobalVariables()) {
1000  AssertDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
1001  for (Metadata *Op : N.getGlobalVariables()->operands()) {
1002  AssertDI(Op && (isa<DIGlobalVariableExpression>(Op)),
1003  "invalid global variable ref", &N, Op);
1004  }
1005  }
1006  if (auto *Array = N.getRawImportedEntities()) {
1007  AssertDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
1008  for (Metadata *Op : N.getImportedEntities()->operands()) {
1009  AssertDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",
1010  &N, Op);
1011  }
1012  }
1013  if (auto *Array = N.getRawMacros()) {
1014  AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
1015  for (Metadata *Op : N.getMacros()->operands()) {
1016  AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
1017  }
1018  }
1019  CUVisited.insert(&N);
1020 }
1021 
1022 void Verifier::visitDISubprogram(const DISubprogram &N) {
1023  AssertDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
1024  AssertDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
1025  if (auto *F = N.getRawFile())
1026  AssertDI(isa<DIFile>(F), "invalid file", &N, F);
1027  if (auto *T = N.getRawType())
1028  AssertDI(isa<DISubroutineType>(T), "invalid subroutine type", &N, T);
1029  AssertDI(isType(N.getRawContainingType()), "invalid containing type", &N,
1030  N.getRawContainingType());
1031  if (auto *Params = N.getRawTemplateParams())
1032  visitTemplateParams(N, *Params);
1033  if (auto *S = N.getRawDeclaration())
1034  AssertDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
1035  "invalid subprogram declaration", &N, S);
1036  if (auto *RawVars = N.getRawVariables()) {
1037  auto *Vars = dyn_cast<MDTuple>(RawVars);
1038  AssertDI(Vars, "invalid variable list", &N, RawVars);
1039  for (Metadata *Op : Vars->operands()) {
1040  AssertDI(Op && isa<DILocalVariable>(Op), "invalid local variable", &N,
1041  Vars, Op);
1042  }
1043  }
1044  AssertDI(!hasConflictingReferenceFlags(N.getFlags()),
1045  "invalid reference flags", &N);
1046 
1047  auto *Unit = N.getRawUnit();
1048  if (N.isDefinition()) {
1049  // Subprogram definitions (not part of the type hierarchy).
1050  AssertDI(N.isDistinct(), "subprogram definitions must be distinct", &N);
1051  AssertDI(Unit, "subprogram definitions must have a compile unit", &N);
1052  AssertDI(isa<DICompileUnit>(Unit), "invalid unit type", &N, Unit);
1053  } else {
1054  // Subprogram declarations (part of the type hierarchy).
1055  AssertDI(!Unit, "subprogram declarations must not have a compile unit", &N);
1056  }
1057 }
1058 
1059 void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
1060  AssertDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
1061  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1062  "invalid local scope", &N, N.getRawScope());
1063 }
1064 
1065 void Verifier::visitDILexicalBlock(const DILexicalBlock &N) {
1066  visitDILexicalBlockBase(N);
1067 
1068  AssertDI(N.getLine() || !N.getColumn(),
1069  "cannot have column info without line info", &N);
1070 }
1071 
1072 void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) {
1073  visitDILexicalBlockBase(N);
1074 }
1075 
1076 void Verifier::visitDINamespace(const DINamespace &N) {
1077  AssertDI(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
1078  if (auto *S = N.getRawScope())
1079  AssertDI(isa<DIScope>(S), "invalid scope ref", &N, S);
1080 }
1081 
1082 void Verifier::visitDIMacro(const DIMacro &N) {
1085  "invalid macinfo type", &N);
1086  AssertDI(!N.getName().empty(), "anonymous macro", &N);
1087  if (!N.getValue().empty()) {
1088  assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix");
1089  }
1090 }
1091 
1092 void Verifier::visitDIMacroFile(const DIMacroFile &N) {
1094  "invalid macinfo type", &N);
1095  if (auto *F = N.getRawFile())
1096  AssertDI(isa<DIFile>(F), "invalid file", &N, F);
1097 
1098  if (auto *Array = N.getRawElements()) {
1099  AssertDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
1100  for (Metadata *Op : N.getElements()->operands()) {
1101  AssertDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
1102  }
1103  }
1104 }
1105 
1106 void Verifier::visitDIModule(const DIModule &N) {
1107  AssertDI(N.getTag() == dwarf::DW_TAG_module, "invalid tag", &N);
1108  AssertDI(!N.getName().empty(), "anonymous module", &N);
1109 }
1110 
1111 void Verifier::visitDITemplateParameter(const DITemplateParameter &N) {
1112  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
1113 }
1114 
1115 void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) {
1116  visitDITemplateParameter(N);
1117 
1118  AssertDI(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
1119  &N);
1120 }
1121 
1122 void Verifier::visitDITemplateValueParameter(
1123  const DITemplateValueParameter &N) {
1124  visitDITemplateParameter(N);
1125 
1126  AssertDI(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
1127  N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
1128  N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
1129  "invalid tag", &N);
1130 }
1131 
1132 void Verifier::visitDIVariable(const DIVariable &N) {
1133  if (auto *S = N.getRawScope())
1134  AssertDI(isa<DIScope>(S), "invalid scope", &N, S);
1135  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
1136  if (auto *F = N.getRawFile())
1137  AssertDI(isa<DIFile>(F), "invalid file", &N, F);
1138 }
1139 
1140 void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) {
1141  // Checks common to all variables.
1142  visitDIVariable(N);
1143 
1144  AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
1145  AssertDI(!N.getName().empty(), "missing global variable name", &N);
1146  if (auto *Member = N.getRawStaticDataMemberDeclaration()) {
1147  AssertDI(isa<DIDerivedType>(Member),
1148  "invalid static data member declaration", &N, Member);
1149  }
1150 }
1151 
1152 void Verifier::visitDILocalVariable(const DILocalVariable &N) {
1153  // Checks common to all variables.
1154  visitDIVariable(N);
1155 
1156  AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
1157  AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
1158  "local variable requires a valid scope", &N, N.getRawScope());
1159 }
1160 
1161 void Verifier::visitDIExpression(const DIExpression &N) {
1162  AssertDI(N.isValid(), "invalid expression", &N);
1163 }
1164 
1165 void Verifier::visitDIGlobalVariableExpression(
1166  const DIGlobalVariableExpression &GVE) {
1167  AssertDI(GVE.getVariable(), "missing variable");
1168  if (auto *Var = GVE.getVariable())
1169  visitDIGlobalVariable(*Var);
1170  if (auto *Expr = GVE.getExpression())
1171  visitDIExpression(*Expr);
1172 }
1173 
1174 void Verifier::visitDIObjCProperty(const DIObjCProperty &N) {
1175  AssertDI(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
1176  if (auto *T = N.getRawType())
1177  AssertDI(isType(T), "invalid type ref", &N, T);
1178  if (auto *F = N.getRawFile())
1179  AssertDI(isa<DIFile>(F), "invalid file", &N, F);
1180 }
1181 
1182 void Verifier::visitDIImportedEntity(const DIImportedEntity &N) {
1183  AssertDI(N.getTag() == dwarf::DW_TAG_imported_module ||
1184  N.getTag() == dwarf::DW_TAG_imported_declaration,
1185  "invalid tag", &N);
1186  if (auto *S = N.getRawScope())
1187  AssertDI(isa<DIScope>(S), "invalid scope for imported entity", &N, S);
1188  AssertDI(isDINode(N.getRawEntity()), "invalid imported entity", &N,
1189  N.getRawEntity());
1190 }
1191 
1192 void Verifier::visitComdat(const Comdat &C) {
1193  // The Module is invalid if the GlobalValue has private linkage. Entities
1194  // with private linkage don't have entries in the symbol table.
1195  if (const GlobalValue *GV = M.getNamedValue(C.getName()))
1196  Assert(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
1197  GV);
1198 }
1199 
1200 void Verifier::visitModuleIdents(const Module &M) {
1201  const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident");
1202  if (!Idents)
1203  return;
1204 
1205  // llvm.ident takes a list of metadata entry. Each entry has only one string.
1206  // Scan each llvm.ident entry and make sure that this requirement is met.
1207  for (const MDNode *N : Idents->operands()) {
1208  Assert(N->getNumOperands() == 1,
1209  "incorrect number of operands in llvm.ident metadata", N);
1210  Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
1211  ("invalid value for llvm.ident metadata entry operand"
1212  "(the operand should be a string)"),
1213  N->getOperand(0));
1214  }
1215 }
1216 
1217 void Verifier::visitModuleFlags(const Module &M) {
1219  if (!Flags) return;
1220 
1221  // Scan each flag, and track the flags and requirements.
1223  SmallVector<const MDNode*, 16> Requirements;
1224  for (const MDNode *MDN : Flags->operands())
1225  visitModuleFlag(MDN, SeenIDs, Requirements);
1226 
1227  // Validate that the requirements in the module are valid.
1228  for (const MDNode *Requirement : Requirements) {
1229  const MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1230  const Metadata *ReqValue = Requirement->getOperand(1);
1231 
1232  const MDNode *Op = SeenIDs.lookup(Flag);
1233  if (!Op) {
1234  CheckFailed("invalid requirement on flag, flag is not present in module",
1235  Flag);
1236  continue;
1237  }
1238 
1239  if (Op->getOperand(2) != ReqValue) {
1240  CheckFailed(("invalid requirement on flag, "
1241  "flag does not have the required value"),
1242  Flag);
1243  continue;
1244  }
1245  }
1246 }
1247 
1248 void
1249 Verifier::visitModuleFlag(const MDNode *Op,
1251  SmallVectorImpl<const MDNode *> &Requirements) {
1252  // Each module flag should have three arguments, the merge behavior (a
1253  // constant int), the flag ID (an MDString), and the value.
1254  Assert(Op->getNumOperands() == 3,
1255  "incorrect number of operands in module flag", Op);
1257  if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
1258  Assert(
1259  mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
1260  "invalid behavior operand in module flag (expected constant integer)",
1261  Op->getOperand(0));
1262  Assert(false,
1263  "invalid behavior operand in module flag (unexpected constant)",
1264  Op->getOperand(0));
1265  }
1266  MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
1267  Assert(ID, "invalid ID operand in module flag (expected metadata string)",
1268  Op->getOperand(1));
1269 
1270  // Sanity check the values for behaviors with additional requirements.
1271  switch (MFB) {
1272  case Module::Error:
1273  case Module::Warning:
1274  case Module::Override:
1275  // These behavior types accept any value.
1276  break;
1277 
1278  case Module::Require: {
1279  // The value should itself be an MDNode with two operands, a flag ID (an
1280  // MDString), and a value.
1281  MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
1282  Assert(Value && Value->getNumOperands() == 2,
1283  "invalid value for 'require' module flag (expected metadata pair)",
1284  Op->getOperand(2));
1285  Assert(isa<MDString>(Value->getOperand(0)),
1286  ("invalid value for 'require' module flag "
1287  "(first value operand should be a string)"),
1288  Value->getOperand(0));
1289 
1290  // Append it to the list of requirements, to check once all module flags are
1291  // scanned.
1292  Requirements.push_back(Value);
1293  break;
1294  }
1295 
1296  case Module::Append:
1297  case Module::AppendUnique: {
1298  // These behavior types require the operand be an MDNode.
1299  Assert(isa<MDNode>(Op->getOperand(2)),
1300  "invalid value for 'append'-type module flag "
1301  "(expected a metadata node)",
1302  Op->getOperand(2));
1303  break;
1304  }
1305  }
1306 
1307  // Unless this is a "requires" flag, check the ID is unique.
1308  if (MFB != Module::Require) {
1309  bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
1310  Assert(Inserted,
1311  "module flag identifiers must be unique (or of 'require' type)", ID);
1312  }
1313 }
1314 
1315 void Verifier::verifyAttributeTypes(AttributeSet Attrs, unsigned Idx,
1316  bool isFunction, const Value *V) {
1317  unsigned Slot = ~0U;
1318  for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I)
1319  if (Attrs.getSlotIndex(I) == Idx) {
1320  Slot = I;
1321  break;
1322  }
1323 
1324  assert(Slot != ~0U && "Attribute set inconsistency!");
1325 
1326  for (AttributeSet::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot);
1327  I != E; ++I) {
1328  if (I->isStringAttribute())
1329  continue;
1330 
1331  if (I->getKindAsEnum() == Attribute::NoReturn ||
1332  I->getKindAsEnum() == Attribute::NoUnwind ||
1333  I->getKindAsEnum() == Attribute::NoInline ||
1334  I->getKindAsEnum() == Attribute::AlwaysInline ||
1335  I->getKindAsEnum() == Attribute::OptimizeForSize ||
1336  I->getKindAsEnum() == Attribute::StackProtect ||
1337  I->getKindAsEnum() == Attribute::StackProtectReq ||
1338  I->getKindAsEnum() == Attribute::StackProtectStrong ||
1339  I->getKindAsEnum() == Attribute::SafeStack ||
1340  I->getKindAsEnum() == Attribute::NoRedZone ||
1341  I->getKindAsEnum() == Attribute::NoImplicitFloat ||
1342  I->getKindAsEnum() == Attribute::Naked ||
1343  I->getKindAsEnum() == Attribute::InlineHint ||
1344  I->getKindAsEnum() == Attribute::StackAlignment ||
1345  I->getKindAsEnum() == Attribute::UWTable ||
1346  I->getKindAsEnum() == Attribute::NonLazyBind ||
1347  I->getKindAsEnum() == Attribute::ReturnsTwice ||
1348  I->getKindAsEnum() == Attribute::SanitizeAddress ||
1349  I->getKindAsEnum() == Attribute::SanitizeThread ||
1350  I->getKindAsEnum() == Attribute::SanitizeMemory ||
1351  I->getKindAsEnum() == Attribute::MinSize ||
1352  I->getKindAsEnum() == Attribute::NoDuplicate ||
1353  I->getKindAsEnum() == Attribute::Builtin ||
1354  I->getKindAsEnum() == Attribute::NoBuiltin ||
1355  I->getKindAsEnum() == Attribute::Cold ||
1356  I->getKindAsEnum() == Attribute::OptimizeNone ||
1357  I->getKindAsEnum() == Attribute::JumpTable ||
1358  I->getKindAsEnum() == Attribute::Convergent ||
1359  I->getKindAsEnum() == Attribute::ArgMemOnly ||
1360  I->getKindAsEnum() == Attribute::NoRecurse ||
1361  I->getKindAsEnum() == Attribute::InaccessibleMemOnly ||
1362  I->getKindAsEnum() == Attribute::InaccessibleMemOrArgMemOnly ||
1363  I->getKindAsEnum() == Attribute::AllocSize) {
1364  if (!isFunction) {
1365  CheckFailed("Attribute '" + I->getAsString() +
1366  "' only applies to functions!", V);
1367  return;
1368  }
1369  } else if (I->getKindAsEnum() == Attribute::ReadOnly ||
1370  I->getKindAsEnum() == Attribute::WriteOnly ||
1371  I->getKindAsEnum() == Attribute::ReadNone) {
1372  if (Idx == 0) {
1373  CheckFailed("Attribute '" + I->getAsString() +
1374  "' does not apply to function returns");
1375  return;
1376  }
1377  } else if (isFunction) {
1378  CheckFailed("Attribute '" + I->getAsString() +
1379  "' does not apply to functions!", V);
1380  return;
1381  }
1382  }
1383 }
1384 
1385 // VerifyParameterAttrs - Check the given attributes for an argument or return
1386 // value of the specified type. The value V is printed in error messages.
1387 void Verifier::verifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
1388  bool isReturnValue, const Value *V) {
1389  if (!Attrs.hasAttributes(Idx))
1390  return;
1391 
1392  verifyAttributeTypes(Attrs, Idx, false, V);
1393 
1394  if (isReturnValue)
1395  Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
1396  !Attrs.hasAttribute(Idx, Attribute::Nest) &&
1397  !Attrs.hasAttribute(Idx, Attribute::StructRet) &&
1398  !Attrs.hasAttribute(Idx, Attribute::NoCapture) &&
1399  !Attrs.hasAttribute(Idx, Attribute::Returned) &&
1400  !Attrs.hasAttribute(Idx, Attribute::InAlloca) &&
1401  !Attrs.hasAttribute(Idx, Attribute::SwiftSelf) &&
1402  !Attrs.hasAttribute(Idx, Attribute::SwiftError),
1403  "Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', "
1404  "'returned', 'swiftself', and 'swifterror' do not apply to return "
1405  "values!",
1406  V);
1407 
1408  // Check for mutually incompatible attributes. Only inreg is compatible with
1409  // sret.
1410  unsigned AttrCount = 0;
1411  AttrCount += Attrs.hasAttribute(Idx, Attribute::ByVal);
1412  AttrCount += Attrs.hasAttribute(Idx, Attribute::InAlloca);
1413  AttrCount += Attrs.hasAttribute(Idx, Attribute::StructRet) ||
1414  Attrs.hasAttribute(Idx, Attribute::InReg);
1415  AttrCount += Attrs.hasAttribute(Idx, Attribute::Nest);
1416  Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', "
1417  "and 'sret' are incompatible!",
1418  V);
1419 
1420  Assert(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) &&
1421  Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
1422  "Attributes "
1423  "'inalloca and readonly' are incompatible!",
1424  V);
1425 
1426  Assert(!(Attrs.hasAttribute(Idx, Attribute::StructRet) &&
1427  Attrs.hasAttribute(Idx, Attribute::Returned)),
1428  "Attributes "
1429  "'sret and returned' are incompatible!",
1430  V);
1431 
1432  Assert(!(Attrs.hasAttribute(Idx, Attribute::ZExt) &&
1433  Attrs.hasAttribute(Idx, Attribute::SExt)),
1434  "Attributes "
1435  "'zeroext and signext' are incompatible!",
1436  V);
1437 
1438  Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) &&
1439  Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
1440  "Attributes "
1441  "'readnone and readonly' are incompatible!",
1442  V);
1443 
1444  Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) &&
1445  Attrs.hasAttribute(Idx, Attribute::WriteOnly)),
1446  "Attributes "
1447  "'readnone and writeonly' are incompatible!",
1448  V);
1449 
1450  Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadOnly) &&
1451  Attrs.hasAttribute(Idx, Attribute::WriteOnly)),
1452  "Attributes "
1453  "'readonly and writeonly' are incompatible!",
1454  V);
1455 
1456  Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) &&
1457  Attrs.hasAttribute(Idx, Attribute::AlwaysInline)),
1458  "Attributes "
1459  "'noinline and alwaysinline' are incompatible!",
1460  V);
1461 
1462  Assert(
1463  !AttrBuilder(Attrs, Idx).overlaps(AttributeFuncs::typeIncompatible(Ty)),
1464  "Wrong types for attribute: " +
1465  AttributeSet::get(Context, Idx, AttributeFuncs::typeIncompatible(Ty))
1466  .getAsString(Idx),
1467  V);
1468 
1469  if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
1470  SmallPtrSet<Type*, 4> Visited;
1471  if (!PTy->getElementType()->isSized(&Visited)) {
1472  Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
1473  !Attrs.hasAttribute(Idx, Attribute::InAlloca),
1474  "Attributes 'byval' and 'inalloca' do not support unsized types!",
1475  V);
1476  }
1477  if (!isa<PointerType>(PTy->getElementType()))
1478  Assert(!Attrs.hasAttribute(Idx, Attribute::SwiftError),
1479  "Attribute 'swifterror' only applies to parameters "
1480  "with pointer to pointer type!",
1481  V);
1482  } else {
1483  Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal),
1484  "Attribute 'byval' only applies to parameters with pointer type!",
1485  V);
1486  Assert(!Attrs.hasAttribute(Idx, Attribute::SwiftError),
1487  "Attribute 'swifterror' only applies to parameters "
1488  "with pointer type!",
1489  V);
1490  }
1491 }
1492 
1493 // Check parameter attributes against a function type.
1494 // The value V is printed in error messages.
1495 void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
1496  const Value *V) {
1497  if (Attrs.isEmpty())
1498  return;
1499 
1500  bool SawNest = false;
1501  bool SawReturned = false;
1502  bool SawSRet = false;
1503  bool SawSwiftSelf = false;
1504  bool SawSwiftError = false;
1505 
1506  for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
1507  unsigned Idx = Attrs.getSlotIndex(i);
1508 
1509  Type *Ty;
1510  if (Idx == 0)
1511  Ty = FT->getReturnType();
1512  else if (Idx-1 < FT->getNumParams())
1513  Ty = FT->getParamType(Idx-1);
1514  else
1515  break; // VarArgs attributes, verified elsewhere.
1516 
1517  verifyParameterAttrs(Attrs, Idx, Ty, Idx == 0, V);
1518 
1519  if (Idx == 0)
1520  continue;
1521 
1522  if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
1523  Assert(!SawNest, "More than one parameter has attribute nest!", V);
1524  SawNest = true;
1525  }
1526 
1527  if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
1528  Assert(!SawReturned, "More than one parameter has attribute returned!",
1529  V);
1531  "Incompatible "
1532  "argument and return types for 'returned' attribute",
1533  V);
1534  SawReturned = true;
1535  }
1536 
1537  if (Attrs.hasAttribute(Idx, Attribute::StructRet)) {
1538  Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
1539  Assert(Idx == 1 || Idx == 2,
1540  "Attribute 'sret' is not on first or second parameter!", V);
1541  SawSRet = true;
1542  }
1543 
1544  if (Attrs.hasAttribute(Idx, Attribute::SwiftSelf)) {
1545  Assert(!SawSwiftSelf, "Cannot have multiple 'swiftself' parameters!", V);
1546  SawSwiftSelf = true;
1547  }
1548 
1549  if (Attrs.hasAttribute(Idx, Attribute::SwiftError)) {
1550  Assert(!SawSwiftError, "Cannot have multiple 'swifterror' parameters!",
1551  V);
1552  SawSwiftError = true;
1553  }
1554 
1555  if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) {
1556  Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!",
1557  V);
1558  }
1559  }
1560 
1562  return;
1563 
1564  verifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V);
1565 
1566  Assert(
1567  !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
1569  "Attributes 'readnone and readonly' are incompatible!", V);
1570 
1571  Assert(
1572  !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
1574  "Attributes 'readnone and writeonly' are incompatible!", V);
1575 
1576  Assert(
1579  "Attributes 'readonly and writeonly' are incompatible!", V);
1580 
1581  Assert(
1582  !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
1584  Attribute::InaccessibleMemOrArgMemOnly)),
1585  "Attributes 'readnone and inaccessiblemem_or_argmemonly' are incompatible!", V);
1586 
1587  Assert(
1588  !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
1590  Attribute::InaccessibleMemOnly)),
1591  "Attributes 'readnone and inaccessiblememonly' are incompatible!", V);
1592 
1593  Assert(
1594  !(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) &&
1596  Attribute::AlwaysInline)),
1597  "Attributes 'noinline and alwaysinline' are incompatible!", V);
1598 
1600  Attribute::OptimizeNone)) {
1601  Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline),
1602  "Attribute 'optnone' requires 'noinline'!", V);
1603 
1605  Attribute::OptimizeForSize),
1606  "Attributes 'optsize and optnone' are incompatible!", V);
1607 
1608  Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize),
1609  "Attributes 'minsize and optnone' are incompatible!", V);
1610  }
1611 
1614  const GlobalValue *GV = cast<GlobalValue>(V);
1616  "Attribute 'jumptable' requires 'unnamed_addr'", V);
1617  }
1618 
1619  if (Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::AllocSize)) {
1620  std::pair<unsigned, Optional<unsigned>> Args =
1622 
1623  auto CheckParam = [&](StringRef Name, unsigned ParamNo) {
1624  if (ParamNo >= FT->getNumParams()) {
1625  CheckFailed("'allocsize' " + Name + " argument is out of bounds", V);
1626  return false;
1627  }
1628 
1629  if (!FT->getParamType(ParamNo)->isIntegerTy()) {
1630  CheckFailed("'allocsize' " + Name +
1631  " argument must refer to an integer parameter",
1632  V);
1633  return false;
1634  }
1635 
1636  return true;
1637  };
1638 
1639  if (!CheckParam("element size", Args.first))
1640  return;
1641 
1642  if (Args.second && !CheckParam("number of elements", *Args.second))
1643  return;
1644  }
1645 }
1646 
1647 void Verifier::verifyFunctionMetadata(
1648  ArrayRef<std::pair<unsigned, MDNode *>> MDs) {
1649  for (const auto &Pair : MDs) {
1650  if (Pair.first == LLVMContext::MD_prof) {
1651  MDNode *MD = Pair.second;
1652  Assert(MD->getNumOperands() == 2,
1653  "!prof annotations should have exactly 2 operands", MD);
1654 
1655  // Check first operand.
1656  Assert(MD->getOperand(0) != nullptr, "first operand should not be null",
1657  MD);
1658  Assert(isa<MDString>(MD->getOperand(0)),
1659  "expected string with name of the !prof annotation", MD);
1660  MDString *MDS = cast<MDString>(MD->getOperand(0));
1661  StringRef ProfName = MDS->getString();
1662  Assert(ProfName.equals("function_entry_count"),
1663  "first operand should be 'function_entry_count'", MD);
1664 
1665  // Check second operand.
1666  Assert(MD->getOperand(1) != nullptr, "second operand should not be null",
1667  MD);
1668  Assert(isa<ConstantAsMetadata>(MD->getOperand(1)),
1669  "expected integer argument to function_entry_count", MD);
1670  }
1671  }
1672 }
1673 
1674 void Verifier::visitConstantExprsRecursively(const Constant *EntryC) {
1675  if (!ConstantExprVisited.insert(EntryC).second)
1676  return;
1677 
1679  Stack.push_back(EntryC);
1680 
1681  while (!Stack.empty()) {
1682  const Constant *C = Stack.pop_back_val();
1683 
1684  // Check this constant expression.
1685  if (const auto *CE = dyn_cast<ConstantExpr>(C))
1686  visitConstantExpr(CE);
1687 
1688  if (const auto *GV = dyn_cast<GlobalValue>(C)) {
1689  // Global Values get visited separately, but we do need to make sure
1690  // that the global value is in the correct module
1691  Assert(GV->getParent() == &M, "Referencing global in another module!",
1692  EntryC, &M, GV, GV->getParent());
1693  continue;
1694  }
1695 
1696  // Visit all sub-expressions.
1697  for (const Use &U : C->operands()) {
1698  const auto *OpC = dyn_cast<Constant>(U);
1699  if (!OpC)
1700  continue;
1701  if (!ConstantExprVisited.insert(OpC).second)
1702  continue;
1703  Stack.push_back(OpC);
1704  }
1705  }
1706 }
1707 
1708 void Verifier::visitConstantExpr(const ConstantExpr *CE) {
1709  if (CE->getOpcode() == Instruction::BitCast)
1710  Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
1711  CE->getType()),
1712  "Invalid bitcast", CE);
1713 
1714  if (CE->getOpcode() == Instruction::IntToPtr ||
1715  CE->getOpcode() == Instruction::PtrToInt) {
1716  auto *PtrTy = CE->getOpcode() == Instruction::IntToPtr
1717  ? CE->getType()
1718  : CE->getOperand(0)->getType();
1719  StringRef Msg = CE->getOpcode() == Instruction::IntToPtr
1720  ? "inttoptr not supported for non-integral pointers"
1721  : "ptrtoint not supported for non-integral pointers";
1722  Assert(
1723  !DL.isNonIntegralPointerType(cast<PointerType>(PtrTy->getScalarType())),
1724  Msg);
1725  }
1726 }
1727 
1728 bool Verifier::verifyAttributeCount(AttributeSet Attrs, unsigned Params) {
1729  if (Attrs.getNumSlots() == 0)
1730  return true;
1731 
1732  unsigned LastSlot = Attrs.getNumSlots() - 1;
1733  unsigned LastIndex = Attrs.getSlotIndex(LastSlot);
1734  if (LastIndex <= Params
1735  || (LastIndex == AttributeSet::FunctionIndex
1736  && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params)))
1737  return true;
1738 
1739  return false;
1740 }
1741 
1742 /// Verify that statepoint intrinsic is well formed.
1743 void Verifier::verifyStatepoint(ImmutableCallSite CS) {
1744  assert(CS.getCalledFunction() &&
1746  Intrinsic::experimental_gc_statepoint);
1747 
1748  const Instruction &CI = *CS.getInstruction();
1749 
1750  Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory() &&
1751  !CS.onlyAccessesArgMemory(),
1752  "gc.statepoint must read and write all memory to preserve "
1753  "reordering restrictions required by safepoint semantics",
1754  &CI);
1755 
1756  const Value *IDV = CS.getArgument(0);
1757  Assert(isa<ConstantInt>(IDV), "gc.statepoint ID must be a constant integer",
1758  &CI);
1759 
1760  const Value *NumPatchBytesV = CS.getArgument(1);
1761  Assert(isa<ConstantInt>(NumPatchBytesV),
1762  "gc.statepoint number of patchable bytes must be a constant integer",
1763  &CI);
1764  const int64_t NumPatchBytes =
1765  cast<ConstantInt>(NumPatchBytesV)->getSExtValue();
1766  assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!");
1767  Assert(NumPatchBytes >= 0, "gc.statepoint number of patchable bytes must be "
1768  "positive",
1769  &CI);
1770 
1771  const Value *Target = CS.getArgument(2);
1772  auto *PT = dyn_cast<PointerType>(Target->getType());
1773  Assert(PT && PT->getElementType()->isFunctionTy(),
1774  "gc.statepoint callee must be of function pointer type", &CI, Target);
1775  FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
1776 
1777  const Value *NumCallArgsV = CS.getArgument(3);
1778  Assert(isa<ConstantInt>(NumCallArgsV),
1779  "gc.statepoint number of arguments to underlying call "
1780  "must be constant integer",
1781  &CI);
1782  const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();
1783  Assert(NumCallArgs >= 0,
1784  "gc.statepoint number of arguments to underlying call "
1785  "must be positive",
1786  &CI);
1787  const int NumParams = (int)TargetFuncType->getNumParams();
1788  if (TargetFuncType->isVarArg()) {
1789  Assert(NumCallArgs >= NumParams,
1790  "gc.statepoint mismatch in number of vararg call args", &CI);
1791 
1792  // TODO: Remove this limitation
1793  Assert(TargetFuncType->getReturnType()->isVoidTy(),
1794  "gc.statepoint doesn't support wrapping non-void "
1795  "vararg functions yet",
1796  &CI);
1797  } else
1798  Assert(NumCallArgs == NumParams,
1799  "gc.statepoint mismatch in number of call args", &CI);
1800 
1801  const Value *FlagsV = CS.getArgument(4);
1802  Assert(isa<ConstantInt>(FlagsV),
1803  "gc.statepoint flags must be constant integer", &CI);
1804  const uint64_t Flags = cast<ConstantInt>(FlagsV)->getZExtValue();
1805  Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
1806  "unknown flag used in gc.statepoint flags argument", &CI);
1807 
1808  // Verify that the types of the call parameter arguments match
1809  // the type of the wrapped callee.
1810  for (int i = 0; i < NumParams; i++) {
1811  Type *ParamType = TargetFuncType->getParamType(i);
1812  Type *ArgType = CS.getArgument(5 + i)->getType();
1813  Assert(ArgType == ParamType,
1814  "gc.statepoint call argument does not match wrapped "
1815  "function type",
1816  &CI);
1817  }
1818 
1819  const int EndCallArgsInx = 4 + NumCallArgs;
1820 
1821  const Value *NumTransitionArgsV = CS.getArgument(EndCallArgsInx+1);
1822  Assert(isa<ConstantInt>(NumTransitionArgsV),
1823  "gc.statepoint number of transition arguments "
1824  "must be constant integer",
1825  &CI);
1826  const int NumTransitionArgs =
1827  cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
1828  Assert(NumTransitionArgs >= 0,
1829  "gc.statepoint number of transition arguments must be positive", &CI);
1830  const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;
1831 
1832  const Value *NumDeoptArgsV = CS.getArgument(EndTransitionArgsInx+1);
1833  Assert(isa<ConstantInt>(NumDeoptArgsV),
1834  "gc.statepoint number of deoptimization arguments "
1835  "must be constant integer",
1836  &CI);
1837  const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
1838  Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments "
1839  "must be positive",
1840  &CI);
1841 
1842  const int ExpectedNumArgs =
1843  7 + NumCallArgs + NumTransitionArgs + NumDeoptArgs;
1844  Assert(ExpectedNumArgs <= (int)CS.arg_size(),
1845  "gc.statepoint too few arguments according to length fields", &CI);
1846 
1847  // Check that the only uses of this gc.statepoint are gc.result or
1848  // gc.relocate calls which are tied to this statepoint and thus part
1849  // of the same statepoint sequence
1850  for (const User *U : CI.users()) {
1851  const CallInst *Call = dyn_cast<const CallInst>(U);
1852  Assert(Call, "illegal use of statepoint token", &CI, U);
1853  if (!Call) continue;
1854  Assert(isa<GCRelocateInst>(Call) || isa<GCResultInst>(Call),
1855  "gc.result or gc.relocate are the only value uses "
1856  "of a gc.statepoint",
1857  &CI, U);
1858  if (isa<GCResultInst>(Call)) {
1859  Assert(Call->getArgOperand(0) == &CI,
1860  "gc.result connected to wrong gc.statepoint", &CI, Call);
1861  } else if (isa<GCRelocateInst>(Call)) {
1862  Assert(Call->getArgOperand(0) == &CI,
1863  "gc.relocate connected to wrong gc.statepoint", &CI, Call);
1864  }
1865  }
1866 
1867  // Note: It is legal for a single derived pointer to be listed multiple
1868  // times. It's non-optimal, but it is legal. It can also happen after
1869  // insertion if we strip a bitcast away.
1870  // Note: It is really tempting to check that each base is relocated and
1871  // that a derived pointer is never reused as a base pointer. This turns
1872  // out to be problematic since optimizations run after safepoint insertion
1873  // can recognize equality properties that the insertion logic doesn't know
1874  // about. See example statepoint.ll in the verifier subdirectory
1875 }
1876 
1877 void Verifier::verifyFrameRecoverIndices() {
1878  for (auto &Counts : FrameEscapeInfo) {
1879  Function *F = Counts.first;
1880  unsigned EscapedObjectCount = Counts.second.first;
1881  unsigned MaxRecoveredIndex = Counts.second.second;
1882  Assert(MaxRecoveredIndex <= EscapedObjectCount,
1883  "all indices passed to llvm.localrecover must be less than the "
1884  "number of arguments passed ot llvm.localescape in the parent "
1885  "function",
1886  F);
1887  }
1888 }
1889 
1891  BasicBlock *UnwindDest;
1892  if (auto *II = dyn_cast<InvokeInst>(Terminator))
1893  UnwindDest = II->getUnwindDest();
1894  else if (auto *CSI = dyn_cast<CatchSwitchInst>(Terminator))
1895  UnwindDest = CSI->getUnwindDest();
1896  else
1897  UnwindDest = cast<CleanupReturnInst>(Terminator)->getUnwindDest();
1898  return UnwindDest->getFirstNonPHI();
1899 }
1900 
1901 void Verifier::verifySiblingFuncletUnwinds() {
1904  for (const auto &Pair : SiblingFuncletInfo) {
1905  Instruction *PredPad = Pair.first;
1906  if (Visited.count(PredPad))
1907  continue;
1908  Active.insert(PredPad);
1909  TerminatorInst *Terminator = Pair.second;
1910  do {
1911  Instruction *SuccPad = getSuccPad(Terminator);
1912  if (Active.count(SuccPad)) {
1913  // Found a cycle; report error
1914  Instruction *CyclePad = SuccPad;
1915  SmallVector<Instruction *, 8> CycleNodes;
1916  do {
1917  CycleNodes.push_back(CyclePad);
1918  TerminatorInst *CycleTerminator = SiblingFuncletInfo[CyclePad];
1919  if (CycleTerminator != CyclePad)
1920  CycleNodes.push_back(CycleTerminator);
1921  CyclePad = getSuccPad(CycleTerminator);
1922  } while (CyclePad != SuccPad);
1923  Assert(false, "EH pads can't handle each other's exceptions",
1924  ArrayRef<Instruction *>(CycleNodes));
1925  }
1926  // Don't re-walk a node we've already checked
1927  if (!Visited.insert(SuccPad).second)
1928  break;
1929  // Walk to this successor if it has a map entry.
1930  PredPad = SuccPad;
1931  auto TermI = SiblingFuncletInfo.find(PredPad);
1932  if (TermI == SiblingFuncletInfo.end())
1933  break;
1934  Terminator = TermI->second;
1935  Active.insert(PredPad);
1936  } while (true);
1937  // Each node only has one successor, so we've walked all the active
1938  // nodes' successors.
1939  Active.clear();
1940  }
1941 }
1942 
1943 // visitFunction - Verify that a function is ok.
1944 //
1945 void Verifier::visitFunction(const Function &F) {
1946  visitGlobalValue(F);
1947 
1948  // Check function arguments.
1949  FunctionType *FT = F.getFunctionType();
1950  unsigned NumArgs = F.arg_size();
1951 
1952  Assert(&Context == &F.getContext(),
1953  "Function context does not match Module context!", &F);
1954 
1955  Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
1956  Assert(FT->getNumParams() == NumArgs,
1957  "# formal arguments must match # of arguments for function type!", &F,
1958  FT);
1959  Assert(F.getReturnType()->isFirstClassType() ||
1960  F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
1961  "Functions cannot return aggregate values!", &F);
1962 
1963  Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
1964  "Invalid struct return type!", &F);
1965 
1966  AttributeSet Attrs = F.getAttributes();
1967 
1968  Assert(verifyAttributeCount(Attrs, FT->getNumParams()),
1969  "Attribute after last parameter!", &F);
1970 
1971  // Check function attributes.
1972  verifyFunctionAttrs(FT, Attrs, &F);
1973 
1974  // On function declarations/definitions, we do not support the builtin
1975  // attribute. We do not check this in VerifyFunctionAttrs since that is
1976  // checking for Attributes that can/can not ever be on functions.
1977  Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin),
1978  "Attribute 'builtin' can only be applied to a callsite.", &F);
1979 
1980  // Check that this function meets the restrictions on this calling convention.
1981  // Sometimes varargs is used for perfectly forwarding thunks, so some of these
1982  // restrictions can be lifted.
1983  switch (F.getCallingConv()) {
1984  default:
1985  case CallingConv::C:
1986  break;
1987  case CallingConv::Fast:
1988  case CallingConv::Cold:
1992  Assert(!F.isVarArg(), "Calling convention does not support varargs or "
1993  "perfect forwarding!",
1994  &F);
1995  break;
1996  }
1997 
1998  bool isLLVMdotName = F.getName().size() >= 5 &&
1999  F.getName().substr(0, 5) == "llvm.";
2000 
2001  // Check that the argument values match the function type for this function...
2002  unsigned i = 0;
2003  for (const Argument &Arg : F.args()) {
2004  Assert(Arg.getType() == FT->getParamType(i),
2005  "Argument value does not match function argument type!", &Arg,
2006  FT->getParamType(i));
2007  Assert(Arg.getType()->isFirstClassType(),
2008  "Function arguments must have first-class types!", &Arg);
2009  if (!isLLVMdotName) {
2010  Assert(!Arg.getType()->isMetadataTy(),
2011  "Function takes metadata but isn't an intrinsic", &Arg, &F);
2012  Assert(!Arg.getType()->isTokenTy(),
2013  "Function takes token but isn't an intrinsic", &Arg, &F);
2014  }
2015 
2016  // Check that swifterror argument is only used by loads and stores.
2017  if (Attrs.hasAttribute(i+1, Attribute::SwiftError)) {
2018  verifySwiftErrorValue(&Arg);
2019  }
2020  ++i;
2021  }
2022 
2023  if (!isLLVMdotName)
2024  Assert(!F.getReturnType()->isTokenTy(),
2025  "Functions returns a token but isn't an intrinsic", &F);
2026 
2027  // Get the function metadata attachments.
2029  F.getAllMetadata(MDs);
2030  assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync");
2031  verifyFunctionMetadata(MDs);
2032 
2033  // Check validity of the personality function
2034  if (F.hasPersonalityFn()) {
2035  auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
2036  if (Per)
2037  Assert(Per->getParent() == F.getParent(),
2038  "Referencing personality function in another module!",
2039  &F, F.getParent(), Per, Per->getParent());
2040  }
2041 
2042  if (F.isMaterializable()) {
2043  // Function has a body somewhere we can't see.
2044  Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
2045  MDs.empty() ? nullptr : MDs.front().second);
2046  } else if (F.isDeclaration()) {
2047  for (const auto &I : MDs) {
2048  AssertDI(I.first != LLVMContext::MD_dbg,
2049  "function declaration may not have a !dbg attachment", &F);
2050  Assert(I.first != LLVMContext::MD_prof,
2051  "function declaration may not have a !prof attachment", &F);
2052 
2053  // Verify the metadata itself.
2054  visitMDNode(*I.second);
2055  }
2056  Assert(!F.hasPersonalityFn(),
2057  "Function declaration shouldn't have a personality routine", &F);
2058  } else {
2059  // Verify that this function (which has a body) is not named "llvm.*". It
2060  // is not legal to define intrinsics.
2061  Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
2062 
2063  // Check the entry node
2064  const BasicBlock *Entry = &F.getEntryBlock();
2065  Assert(pred_empty(Entry),
2066  "Entry block to function must not have predecessors!", Entry);
2067 
2068  // The address of the entry block cannot be taken, unless it is dead.
2069  if (Entry->hasAddressTaken()) {
2070  Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),
2071  "blockaddress may not be used with the entry block!", Entry);
2072  }
2073 
2074  unsigned NumDebugAttachments = 0, NumProfAttachments = 0;
2075  // Visit metadata attachments.
2076  for (const auto &I : MDs) {
2077  // Verify that the attachment is legal.
2078  switch (I.first) {
2079  default:
2080  break;
2081  case LLVMContext::MD_dbg:
2082  ++NumDebugAttachments;
2083  AssertDI(NumDebugAttachments == 1,
2084  "function must have a single !dbg attachment", &F, I.second);
2085  AssertDI(isa<DISubprogram>(I.second),
2086  "function !dbg attachment must be a subprogram", &F, I.second);
2087  break;
2088  case LLVMContext::MD_prof:
2089  ++NumProfAttachments;
2090  Assert(NumProfAttachments == 1,
2091  "function must have a single !prof attachment", &F, I.second);
2092  break;
2093  }
2094 
2095  // Verify the metadata itself.
2096  visitMDNode(*I.second);
2097  }
2098  }
2099 
2100  // If this function is actually an intrinsic, verify that it is only used in
2101  // direct call/invokes, never having its "address taken".
2102  // Only do this if the module is materialized, otherwise we don't have all the
2103  // uses.
2104  if (F.getIntrinsicID() && F.getParent()->isMaterialized()) {
2105  const User *U;
2106  if (F.hasAddressTaken(&U))
2107  Assert(false, "Invalid user of intrinsic instruction!", U);
2108  }
2109 
2110  Assert(!F.hasDLLImportStorageClass() ||
2111  (F.isDeclaration() && F.hasExternalLinkage()) ||
2112  F.hasAvailableExternallyLinkage(),
2113  "Function is marked as dllimport, but not external.", &F);
2114 
2115  auto *N = F.getSubprogram();
2116  if (!N)
2117  return;
2118 
2119  visitDISubprogram(*N);
2120 
2121  // Check that all !dbg attachments lead to back to N (or, at least, another
2122  // subprogram that describes the same function).
2123  //
2124  // FIXME: Check this incrementally while visiting !dbg attachments.
2125  // FIXME: Only check when N is the canonical subprogram for F.
2127  for (auto &BB : F)
2128  for (auto &I : BB) {
2129  // Be careful about using DILocation here since we might be dealing with
2130  // broken code (this is the Verifier after all).
2131  DILocation *DL =
2132  dyn_cast_or_null<DILocation>(I.getDebugLoc().getAsMDNode());
2133  if (!DL)
2134  continue;
2135  if (!Seen.insert(DL).second)
2136  continue;
2137 
2138  DILocalScope *Scope = DL->getInlinedAtScope();
2139  if (Scope && !Seen.insert(Scope).second)
2140  continue;
2141 
2142  DISubprogram *SP = Scope ? Scope->getSubprogram() : nullptr;
2143 
2144  // Scope and SP could be the same MDNode and we don't want to skip
2145  // validation in that case
2146  if (SP && ((Scope != SP) && !Seen.insert(SP).second))
2147  continue;
2148 
2149  // FIXME: Once N is canonical, check "SP == &N".
2150  AssertDI(SP->describes(&F),
2151  "!dbg attachment points at wrong subprogram for function", N, &F,
2152  &I, DL, Scope, SP);
2153  }
2154 }
2155 
2156 // verifyBasicBlock - Verify that a basic block is well formed...
2157 //
2158 void Verifier::visitBasicBlock(BasicBlock &BB) {
2159  InstsInThisBlock.clear();
2160 
2161  // Ensure that basic blocks have terminators!
2162  Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
2163 
2164  // Check constraints that this basic block imposes on all of the PHI nodes in
2165  // it.
2166  if (isa<PHINode>(BB.front())) {
2169  std::sort(Preds.begin(), Preds.end());
2170  PHINode *PN;
2171  for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) {
2172  // Ensure that PHI nodes have at least one entry!
2173  Assert(PN->getNumIncomingValues() != 0,
2174  "PHI nodes must have at least one entry. If the block is dead, "
2175  "the PHI should be removed!",
2176  PN);
2177  Assert(PN->getNumIncomingValues() == Preds.size(),
2178  "PHINode should have one entry for each predecessor of its "
2179  "parent basic block!",
2180  PN);
2181 
2182  // Get and sort all incoming values in the PHI node...
2183  Values.clear();
2184  Values.reserve(PN->getNumIncomingValues());
2185  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
2186  Values.push_back(std::make_pair(PN->getIncomingBlock(i),
2187  PN->getIncomingValue(i)));
2188  std::sort(Values.begin(), Values.end());
2189 
2190  for (unsigned i = 0, e = Values.size(); i != e; ++i) {
2191  // Check to make sure that if there is more than one entry for a
2192  // particular basic block in this PHI node, that the incoming values are
2193  // all identical.
2194  //
2195  Assert(i == 0 || Values[i].first != Values[i - 1].first ||
2196  Values[i].second == Values[i - 1].second,
2197  "PHI node has multiple entries for the same basic block with "
2198  "different incoming values!",
2199  PN, Values[i].first, Values[i].second, Values[i - 1].second);
2200 
2201  // Check to make sure that the predecessors and PHI node entries are
2202  // matched up.
2203  Assert(Values[i].first == Preds[i],
2204  "PHI node entries do not match predecessors!", PN,
2205  Values[i].first, Preds[i]);
2206  }
2207  }
2208  }
2209 
2210  // Check that all instructions have their parent pointers set up correctly.
2211  for (auto &I : BB)
2212  {
2213  Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!");
2214  }
2215 }
2216 
2217 void Verifier::visitTerminatorInst(TerminatorInst &I) {
2218  // Ensure that terminators only exist at the end of the basic block.
2219  Assert(&I == I.getParent()->getTerminator(),
2220  "Terminator found in the middle of a basic block!", I.getParent());
2221  visitInstruction(I);
2222 }
2223 
2224 void Verifier::visitBranchInst(BranchInst &BI) {
2225  if (BI.isConditional()) {
2226  Assert(BI.getCondition()->getType()->isIntegerTy(1),
2227  "Branch condition is not 'i1' type!", &BI, BI.getCondition());
2228  }
2229  visitTerminatorInst(BI);
2230 }
2231 
2232 void Verifier::visitReturnInst(ReturnInst &RI) {
2233  Function *F = RI.getParent()->getParent();
2234  unsigned N = RI.getNumOperands();
2235  if (F->getReturnType()->isVoidTy())
2236  Assert(N == 0,
2237  "Found return instr that returns non-void in Function of void "
2238  "return type!",
2239  &RI, F->getReturnType());
2240  else
2241  Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
2242  "Function return type does not match operand "
2243  "type of return inst!",
2244  &RI, F->getReturnType());
2245 
2246  // Check to make sure that the return value has necessary properties for
2247  // terminators...
2248  visitTerminatorInst(RI);
2249 }
2250 
2251 void Verifier::visitSwitchInst(SwitchInst &SI) {
2252  // Check to make sure that all of the constants in the switch instruction
2253  // have the same type as the switched-on value.
2254  Type *SwitchTy = SI.getCondition()->getType();
2256  for (auto &Case : SI.cases()) {
2257  Assert(Case.getCaseValue()->getType() == SwitchTy,
2258  "Switch constants must all be same type as switch value!", &SI);
2259  Assert(Constants.insert(Case.getCaseValue()).second,
2260  "Duplicate integer as switch case", &SI, Case.getCaseValue());
2261  }
2262 
2263  visitTerminatorInst(SI);
2264 }
2265 
2266 void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
2267  Assert(BI.getAddress()->getType()->isPointerTy(),
2268  "Indirectbr operand must have pointer type!", &BI);
2269  for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
2270  Assert(BI.getDestination(i)->getType()->isLabelTy(),
2271  "Indirectbr destinations must all have pointer type!", &BI);
2272 
2273  visitTerminatorInst(BI);
2274 }
2275 
2276 void Verifier::visitSelectInst(SelectInst &SI) {
2278  SI.getOperand(2)),
2279  "Invalid operands for select instruction!", &SI);
2280 
2281  Assert(SI.getTrueValue()->getType() == SI.getType(),
2282  "Select values must have same type as select instruction!", &SI);
2283  visitInstruction(SI);
2284 }
2285 
2286 /// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
2287 /// a pass, if any exist, it's an error.
2288 ///
2289 void Verifier::visitUserOp1(Instruction &I) {
2290  Assert(false, "User-defined operators should not live outside of a pass!", &I);
2291 }
2292 
2293 void Verifier::visitTruncInst(TruncInst &I) {
2294  // Get the source and destination types
2295  Type *SrcTy = I.getOperand(0)->getType();
2296  Type *DestTy = I.getType();
2297 
2298  // Get the size of the types in bits, we'll need this later
2299  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2300  unsigned DestBitSize = DestTy->getScalarSizeInBits();
2301 
2302  Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
2303  Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
2304  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
2305  "trunc source and destination must both be a vector or neither", &I);
2306  Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
2307 
2308  visitInstruction(I);
2309 }
2310 
2311 void Verifier::visitZExtInst(ZExtInst &I) {
2312  // Get the source and destination types
2313  Type *SrcTy = I.getOperand(0)->getType();
2314  Type *DestTy = I.getType();
2315 
2316  // Get the size of the types in bits, we'll need this later
2317  Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
2318  Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
2319  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
2320  "zext source and destination must both be a vector or neither", &I);
2321  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2322  unsigned DestBitSize = DestTy->getScalarSizeInBits();
2323 
2324  Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
2325 
2326  visitInstruction(I);
2327 }
2328 
2329 void Verifier::visitSExtInst(SExtInst &I) {
2330  // Get the source and destination types
2331  Type *SrcTy = I.getOperand(0)->getType();
2332  Type *DestTy = I.getType();
2333 
2334  // Get the size of the types in bits, we'll need this later
2335  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2336  unsigned DestBitSize = DestTy->getScalarSizeInBits();
2337 
2338  Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
2339  Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
2340  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
2341  "sext source and destination must both be a vector or neither", &I);
2342  Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
2343 
2344  visitInstruction(I);
2345 }
2346 
2347 void Verifier::visitFPTruncInst(FPTruncInst &I) {
2348  // Get the source and destination types
2349  Type *SrcTy = I.getOperand(0)->getType();
2350  Type *DestTy = I.getType();
2351  // Get the size of the types in bits, we'll need this later
2352  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2353  unsigned DestBitSize = DestTy->getScalarSizeInBits();
2354 
2355  Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
2356  Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
2357  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
2358  "fptrunc source and destination must both be a vector or neither", &I);
2359  Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
2360 
2361  visitInstruction(I);
2362 }
2363 
2364 void Verifier::visitFPExtInst(FPExtInst &I) {
2365  // Get the source and destination types
2366  Type *SrcTy = I.getOperand(0)->getType();
2367  Type *DestTy = I.getType();
2368 
2369  // Get the size of the types in bits, we'll need this later
2370  unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
2371  unsigned DestBitSize = DestTy->getScalarSizeInBits();
2372 
2373  Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
2374  Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
2375  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
2376  "fpext source and destination must both be a vector or neither", &I);
2377  Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
2378 
2379  visitInstruction(I);
2380 }
2381 
2382 void Verifier::visitUIToFPInst(UIToFPInst &I) {
2383  // Get the source and destination types
2384  Type *SrcTy = I.getOperand(0)->getType();
2385  Type *DestTy = I.getType();
2386 
2387  bool SrcVec = SrcTy->isVectorTy();
2388  bool DstVec = DestTy->isVectorTy();
2389 
2390  Assert(SrcVec == DstVec,
2391  "UIToFP source and dest must both be vector or scalar", &I);
2392  Assert(SrcTy->isIntOrIntVectorTy(),
2393  "UIToFP source must be integer or integer vector", &I);
2394  Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
2395  &I);
2396 
2397  if (SrcVec && DstVec)
2398  Assert(cast<VectorType>(SrcTy)->getNumElements() ==
2399  cast<VectorType>(DestTy)->getNumElements(),
2400  "UIToFP source and dest vector length mismatch", &I);
2401 
2402  visitInstruction(I);
2403 }
2404 
2405 void Verifier::visitSIToFPInst(SIToFPInst &I) {
2406  // Get the source and destination types
2407  Type *SrcTy = I.getOperand(0)->getType();
2408  Type *DestTy = I.getType();
2409 
2410  bool SrcVec = SrcTy->isVectorTy();
2411  bool DstVec = DestTy->isVectorTy();
2412 
2413  Assert(SrcVec == DstVec,
2414  "SIToFP source and dest must both be vector or scalar", &I);
2415  Assert(SrcTy->isIntOrIntVectorTy(),
2416  "SIToFP source must be integer or integer vector", &I);
2417  Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
2418  &I);
2419 
2420  if (SrcVec && DstVec)
2421  Assert(cast<VectorType>(SrcTy)->getNumElements() ==
2422  cast<VectorType>(DestTy)->getNumElements(),
2423  "SIToFP source and dest vector length mismatch", &I);
2424 
2425  visitInstruction(I);
2426 }
2427 
2428 void Verifier::visitFPToUIInst(FPToUIInst &I) {
2429  // Get the source and destination types
2430  Type *SrcTy = I.getOperand(0)->getType();
2431  Type *DestTy = I.getType();
2432 
2433  bool SrcVec = SrcTy->isVectorTy();
2434  bool DstVec = DestTy->isVectorTy();
2435 
2436  Assert(SrcVec == DstVec,
2437  "FPToUI source and dest must both be vector or scalar", &I);
2438  Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
2439  &I);
2440  Assert(DestTy->isIntOrIntVectorTy(),
2441  "FPToUI result must be integer or integer vector", &I);
2442 
2443  if (SrcVec && DstVec)
2444  Assert(cast<VectorType>(SrcTy)->getNumElements() ==
2445  cast<VectorType>(DestTy)->getNumElements(),
2446  "FPToUI source and dest vector length mismatch", &I);
2447 
2448  visitInstruction(I);
2449 }
2450 
2451 void Verifier::visitFPToSIInst(FPToSIInst &I) {
2452  // Get the source and destination types
2453  Type *SrcTy = I.getOperand(0)->getType();
2454  Type *DestTy = I.getType();
2455 
2456  bool SrcVec = SrcTy->isVectorTy();
2457  bool DstVec = DestTy->isVectorTy();
2458 
2459  Assert(SrcVec == DstVec,
2460  "FPToSI source and dest must both be vector or scalar", &I);
2461  Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",
2462  &I);
2463  Assert(DestTy->isIntOrIntVectorTy(),
2464  "FPToSI result must be integer or integer vector", &I);
2465 
2466  if (SrcVec && DstVec)
2467  Assert(cast<VectorType>(SrcTy)->getNumElements() ==
2468  cast<VectorType>(DestTy)->getNumElements(),
2469  "FPToSI source and dest vector length mismatch", &I);
2470 
2471  visitInstruction(I);
2472 }
2473 
2474 void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
2475  // Get the source and destination types
2476  Type *SrcTy = I.getOperand(0)->getType();
2477  Type *DestTy = I.getType();
2478 
2479  Assert(SrcTy->getScalarType()->isPointerTy(),
2480  "PtrToInt source must be pointer", &I);
2481 
2482  if (auto *PTy = dyn_cast<PointerType>(SrcTy->getScalarType()))
2483  Assert(!DL.isNonIntegralPointerType(PTy),
2484  "ptrtoint not supported for non-integral pointers");
2485 
2486  Assert(DestTy->getScalarType()->isIntegerTy(),
2487  "PtrToInt result must be integral", &I);
2488  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
2489  &I);
2490 
2491  if (SrcTy->isVectorTy()) {
2492  VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
2493  VectorType *VDest = dyn_cast<VectorType>(DestTy);
2494  Assert(VSrc->getNumElements() == VDest->getNumElements(),
2495  "PtrToInt Vector width mismatch", &I);
2496  }
2497 
2498  visitInstruction(I);
2499 }
2500 
2501 void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
2502  // Get the source and destination types
2503  Type *SrcTy = I.getOperand(0)->getType();
2504  Type *DestTy = I.getType();
2505 
2506  Assert(SrcTy->getScalarType()->isIntegerTy(),
2507  "IntToPtr source must be an integral", &I);
2508  Assert(DestTy->getScalarType()->isPointerTy(),
2509  "IntToPtr result must be a pointer", &I);
2510 
2511  if (auto *PTy = dyn_cast<PointerType>(DestTy->getScalarType()))
2512  Assert(!DL.isNonIntegralPointerType(PTy),
2513  "inttoptr not supported for non-integral pointers");
2514 
2515  Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
2516  &I);
2517  if (SrcTy->isVectorTy()) {
2518  VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
2519  VectorType *VDest = dyn_cast<VectorType>(DestTy);
2520  Assert(VSrc->getNumElements() == VDest->getNumElements(),
2521  "IntToPtr Vector width mismatch", &I);
2522  }
2523  visitInstruction(I);
2524 }
2525 
2526 void Verifier::visitBitCastInst(BitCastInst &I) {
2527  Assert(
2528  CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
2529  "Invalid bitcast", &I);
2530  visitInstruction(I);
2531 }
2532 
2533 void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
2534  Type *SrcTy = I.getOperand(0)->getType();
2535  Type *DestTy = I.getType();
2536 
2537  Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
2538  &I);
2539  Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
2540  &I);
2542  "AddrSpaceCast must be between different address spaces", &I);
2543  if (SrcTy->isVectorTy())
2544  Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(),
2545  "AddrSpaceCast vector pointer number of elements mismatch", &I);
2546  visitInstruction(I);
2547 }
2548 
2549 /// visitPHINode - Ensure that a PHI node is well formed.
2550 ///
2551 void Verifier::visitPHINode(PHINode &PN) {
2552  // Ensure that the PHI nodes are all grouped together at the top of the block.
2553  // This can be tested by checking whether the instruction before this is
2554  // either nonexistent (because this is begin()) or is a PHI node. If not,
2555  // then there is some other instruction before a PHI.
2556  Assert(&PN == &PN.getParent()->front() ||
2557  isa<PHINode>(--BasicBlock::iterator(&PN)),
2558  "PHI nodes not grouped at top of basic block!", &PN, PN.getParent());
2559 
2560  // Check that a PHI doesn't yield a Token.
2561  Assert(!PN.getType()->isTokenTy(), "PHI nodes cannot have token type!");
2562 
2563  // Check that all of the values of the PHI node have the same type as the
2564  // result, and that the incoming blocks are really basic blocks.
2565  for (Value *IncValue : PN.incoming_values()) {
2566  Assert(PN.getType() == IncValue->getType(),
2567  "PHI node operands are not the same type as the result!", &PN);
2568  }
2569 
2570  // All other PHI node constraints are checked in the visitBasicBlock method.
2571 
2572  visitInstruction(PN);
2573 }
2574 
2575 void Verifier::verifyCallSite(CallSite CS) {
2576  Instruction *I = CS.getInstruction();
2577 
2579  "Called function must be a pointer!", I);
2580  PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType());
2581 
2582  Assert(FPTy->getElementType()->isFunctionTy(),
2583  "Called function is not pointer to function type!", I);
2584 
2585  Assert(FPTy->getElementType() == CS.getFunctionType(),
2586  "Called function is not the same type as the call!", I);
2587 
2588  FunctionType *FTy = CS.getFunctionType();
2589 
2590  // Verify that the correct number of arguments are being passed
2591  if (FTy->isVarArg())
2592  Assert(CS.arg_size() >= FTy->getNumParams(),
2593  "Called function requires more parameters than were provided!", I);
2594  else
2595  Assert(CS.arg_size() == FTy->getNumParams(),
2596  "Incorrect number of arguments passed to called function!", I);
2597 
2598  // Verify that all arguments to the call match the function type.
2599  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2600  Assert(CS.getArgument(i)->getType() == FTy->getParamType(i),
2601  "Call parameter type does not match function signature!",
2602  CS.getArgument(i), FTy->getParamType(i), I);
2603 
2604  AttributeSet Attrs = CS.getAttributes();
2605 
2606  Assert(verifyAttributeCount(Attrs, CS.arg_size()),
2607  "Attribute after last parameter!", I);
2608 
2609  // Verify call attributes.
2610  verifyFunctionAttrs(FTy, Attrs, I);
2611 
2612  // Conservatively check the inalloca argument.
2613  // We have a bug if we can find that there is an underlying alloca without
2614  // inalloca.
2615  if (CS.hasInAllocaArgument()) {
2616  Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1);
2617  if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
2618  Assert(AI->isUsedWithInAlloca(),
2619  "inalloca argument for call has mismatched alloca", AI, I);
2620  }
2621 
2622  // For each argument of the callsite, if it has the swifterror argument,
2623  // make sure the underlying alloca/parameter it comes from has a swifterror as
2624  // well.
2625  for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
2626  if (CS.paramHasAttr(i+1, Attribute::SwiftError)) {
2627  Value *SwiftErrorArg = CS.getArgument(i);
2628  if (auto AI = dyn_cast<AllocaInst>(SwiftErrorArg->stripInBoundsOffsets())) {
2629  Assert(AI->isSwiftError(),
2630  "swifterror argument for call has mismatched alloca", AI, I);
2631  continue;
2632  }
2633  auto ArgI = dyn_cast<Argument>(SwiftErrorArg);
2634  Assert(ArgI, "swifterror argument should come from an alloca or parameter", SwiftErrorArg, I);
2635  Assert(ArgI->hasSwiftErrorAttr(),
2636  "swifterror argument for call has mismatched parameter", ArgI, I);
2637  }
2638 
2639  if (FTy->isVarArg()) {
2640  // FIXME? is 'nest' even legal here?
2641  bool SawNest = false;
2642  bool SawReturned = false;
2643 
2644  for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) {
2645  if (Attrs.hasAttribute(Idx, Attribute::Nest))
2646  SawNest = true;
2647  if (Attrs.hasAttribute(Idx, Attribute::Returned))
2648  SawReturned = true;
2649  }
2650 
2651  // Check attributes on the varargs part.
2652  for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) {
2653  Type *Ty = CS.getArgument(Idx-1)->getType();
2654  verifyParameterAttrs(Attrs, Idx, Ty, false, I);
2655 
2656  if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
2657  Assert(!SawNest, "More than one parameter has attribute nest!", I);
2658  SawNest = true;
2659  }
2660 
2661  if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
2662  Assert(!SawReturned, "More than one parameter has attribute returned!",
2663  I);
2664  Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
2665  "Incompatible argument and return types for 'returned' "
2666  "attribute",
2667  I);
2668  SawReturned = true;
2669  }
2670 
2671  Assert(!Attrs.hasAttribute(Idx, Attribute::StructRet),
2672  "Attribute 'sret' cannot be used for vararg call arguments!", I);
2673 
2674  if (Attrs.hasAttribute(Idx, Attribute::InAlloca))
2675  Assert(Idx == CS.arg_size(), "inalloca isn't on the last argument!", I);
2676  }
2677  }
2678 
2679  // Verify that there's no metadata unless it's a direct call to an intrinsic.
2680  if (CS.getCalledFunction() == nullptr ||
2681  !CS.getCalledFunction()->getName().startswith("llvm.")) {
2682  for (Type *ParamTy : FTy->params()) {
2683  Assert(!ParamTy->isMetadataTy(),
2684  "Function has metadata parameter but isn't an intrinsic", I);
2685  Assert(!ParamTy->isTokenTy(),
2686  "Function has token parameter but isn't an intrinsic", I);
2687  }
2688  }
2689 
2690  // Verify that indirect calls don't return tokens.
2691  if (CS.getCalledFunction() == nullptr)
2692  Assert(!FTy->getReturnType()->isTokenTy(),
2693  "Return type cannot be token for indirect call!");
2694 
2695  if (Function *F = CS.getCalledFunction())
2697  visitIntrinsicCallSite(ID, CS);
2698 
2699  // Verify that a callsite has at most one "deopt", at most one "funclet" and
2700  // at most one "gc-transition" operand bundle.
2701  bool FoundDeoptBundle = false, FoundFuncletBundle = false,
2702  FoundGCTransitionBundle = false;
2703  for (unsigned i = 0, e = CS.getNumOperandBundles(); i < e; ++i) {
2705  uint32_t Tag = BU.getTagID();
2706  if (Tag == LLVMContext::OB_deopt) {
2707  Assert(!FoundDeoptBundle, "Multiple deopt operand bundles", I);
2708  FoundDeoptBundle = true;
2709  } else if (Tag == LLVMContext::OB_gc_transition) {
2710  Assert(!FoundGCTransitionBundle, "Multiple gc-transition operand bundles",
2711  I);
2712  FoundGCTransitionBundle = true;
2713  } else if (Tag == LLVMContext::OB_funclet) {
2714  Assert(!FoundFuncletBundle, "Multiple funclet operand bundles", I);
2715  FoundFuncletBundle = true;
2716  Assert(BU.Inputs.size() == 1,
2717  "Expected exactly one funclet bundle operand", I);
2718  Assert(isa<FuncletPadInst>(BU.Inputs.front()),
2719  "Funclet bundle operands should correspond to a FuncletPadInst",
2720  I);
2721  }
2722  }
2723 
2724  // Verify that each inlinable callsite of a debug-info-bearing function in a
2725  // debug-info-bearing function has a debug location attached to it. Failure to
2726  // do so causes assertion failures when the inliner sets up inline scope info.
2727  if (I->getFunction()->getSubprogram() && CS.getCalledFunction() &&
2729  Assert(I->getDebugLoc(), "inlinable function call in a function with debug "
2730  "info must have a !dbg location",
2731  I);
2732 
2733  visitInstruction(*I);
2734 }
2735 
2736 /// Two types are "congruent" if they are identical, or if they are both pointer
2737 /// types with different pointee types and the same address space.
2738 static bool isTypeCongruent(Type *L, Type *R) {
2739  if (L == R)
2740  return true;
2742  PointerType *PR = dyn_cast<PointerType>(R);
2743  if (!PL || !PR)
2744  return false;
2745  return PL->getAddressSpace() == PR->getAddressSpace();
2746 }
2747 
2749  static const Attribute::AttrKind ABIAttrs[] = {
2750  Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
2751  Attribute::InReg, Attribute::Returned, Attribute::SwiftSelf,
2752  Attribute::SwiftError};
2753  AttrBuilder Copy;
2754  for (auto AK : ABIAttrs) {
2755  if (Attrs.hasAttribute(I + 1, AK))
2756  Copy.addAttribute(AK);
2757  }
2758  if (Attrs.hasAttribute(I + 1, Attribute::Alignment))
2759  Copy.addAlignmentAttr(Attrs.getParamAlignment(I + 1));
2760  return Copy;
2761 }
2762 
2763 void Verifier::verifyMustTailCall(CallInst &CI) {
2764  Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
2765 
2766  // - The caller and callee prototypes must match. Pointer types of
2767  // parameters or return types may differ in pointee type, but not
2768  // address space.
2769  Function *F = CI.getParent()->getParent();
2770  FunctionType *CallerTy = F->getFunctionType();
2771  FunctionType *CalleeTy = CI.getFunctionType();
2772  Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
2773  "cannot guarantee tail call due to mismatched parameter counts", &CI);
2774  Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),
2775  "cannot guarantee tail call due to mismatched varargs", &CI);
2776  Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
2777  "cannot guarantee tail call due to mismatched return types", &CI);
2778  for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
2779  Assert(
2780  isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),
2781  "cannot guarantee tail call due to mismatched parameter types", &CI);
2782  }
2783 
2784  // - The calling conventions of the caller and callee must match.
2785  Assert(F->getCallingConv() == CI.getCallingConv(),
2786  "cannot guarantee tail call due to mismatched calling conv", &CI);
2787 
2788  // - All ABI-impacting function attributes, such as sret, byval, inreg,
2789  // returned, and inalloca, must match.
2790  AttributeSet CallerAttrs = F->getAttributes();
2791  AttributeSet CalleeAttrs = CI.getAttributes();
2792  for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
2793  AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
2794  AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
2795  Assert(CallerABIAttrs == CalleeABIAttrs,
2796  "cannot guarantee tail call due to mismatched ABI impacting "
2797  "function attributes",
2798  &CI, CI.getOperand(I));
2799  }
2800 
2801  // - The call must immediately precede a :ref:`ret <i_ret>` instruction,
2802  // or a pointer bitcast followed by a ret instruction.
2803  // - The ret instruction must return the (possibly bitcasted) value
2804  // produced by the call or void.
2805  Value *RetVal = &CI;
2806  Instruction *Next = CI.getNextNode();
2807 
2808  // Handle the optional bitcast.
2809  if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
2810  Assert(BI->getOperand(0) == RetVal,
2811  "bitcast following musttail call must use the call", BI);
2812  RetVal = BI;
2813  Next = BI->getNextNode();
2814  }
2815 
2816  // Check the return.
2817  ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
2818  Assert(Ret, "musttail call must be precede a ret with an optional bitcast",
2819  &CI);
2820  Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal,
2821  "musttail call result must be returned", Ret);
2822 }
2823 
2824 void Verifier::visitCallInst(CallInst &CI) {
2825  verifyCallSite(&CI);
2826 
2827  if (CI.isMustTailCall())
2828  verifyMustTailCall(CI);
2829 }
2830 
2831 void Verifier::visitInvokeInst(InvokeInst &II) {
2832  verifyCallSite(&II);
2833 
2834  // Verify that the first non-PHI instruction of the unwind destination is an
2835  // exception handling instruction.
2836  Assert(
2837  II.getUnwindDest()->isEHPad(),
2838  "The unwind destination does not have an exception handling instruction!",
2839  &II);
2840 
2841  visitTerminatorInst(II);
2842 }
2843 
2844 /// visitBinaryOperator - Check that both arguments to the binary operator are
2845 /// of the same type!
2846 ///
2847 void Verifier::visitBinaryOperator(BinaryOperator &B) {
2848  Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
2849  "Both operands to a binary operator are not of the same type!", &B);
2850 
2851  switch (B.getOpcode()) {
2852  // Check that integer arithmetic operators are only used with
2853  // integral operands.
2854  case Instruction::Add:
2855  case Instruction::Sub:
2856  case Instruction::Mul:
2857  case Instruction::SDiv:
2858  case Instruction::UDiv:
2859  case Instruction::SRem:
2860  case Instruction::URem:
2862  "Integer arithmetic operators only work with integral types!", &B);
2863  Assert(B.getType() == B.getOperand(0)->getType(),
2864  "Integer arithmetic operators must have same type "
2865  "for operands and result!",
2866  &B);
2867  break;
2868  // Check that floating-point arithmetic operators are only used with
2869  // floating-point operands.
2870  case Instruction::FAdd:
2871  case Instruction::FSub:
2872  case Instruction::FMul:
2873  case Instruction::FDiv:
2874  case Instruction::FRem:
2876  "Floating-point arithmetic operators only work with "
2877  "floating-point types!",
2878  &B);
2879  Assert(B.getType() == B.getOperand(0)->getType(),
2880  "Floating-point arithmetic operators must have same type "
2881  "for operands and result!",
2882  &B);
2883  break;
2884  // Check that logical operators are only used with integral operands.
2885  case Instruction::And:
2886  case Instruction::Or:
2887  case Instruction::Xor:
2889  "Logical operators only work with integral types!", &B);
2890  Assert(B.getType() == B.getOperand(0)->getType(),
2891  "Logical operators must have same type for operands and result!",
2892  &B);
2893  break;
2894  case Instruction::Shl:
2895  case Instruction::LShr:
2896  case Instruction::AShr:
2898  "Shifts only work with integral types!", &B);
2899  Assert(B.getType() == B.getOperand(0)->getType(),
2900  "Shift return type must be same as operands!", &B);
2901  break;
2902  default:
2903  llvm_unreachable("Unknown BinaryOperator opcode!");
2904  }
2905 
2906  visitInstruction(B);
2907 }
2908 
2909 void Verifier::visitICmpInst(ICmpInst &IC) {
2910  // Check that the operands are the same type
2911  Type *Op0Ty = IC.getOperand(0)->getType();
2912  Type *Op1Ty = IC.getOperand(1)->getType();
2913  Assert(Op0Ty == Op1Ty,
2914  "Both operands to ICmp instruction are not of the same type!", &IC);
2915  // Check that the operands are the right type
2916  Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(),
2917  "Invalid operand types for ICmp instruction", &IC);
2918  // Check that the predicate is valid.
2921  "Invalid predicate in ICmp instruction!", &IC);
2922 
2923  visitInstruction(IC);
2924 }
2925 
2926 void Verifier::visitFCmpInst(FCmpInst &FC) {
2927  // Check that the operands are the same type
2928  Type *Op0Ty = FC.getOperand(0)->getType();
2929  Type *Op1Ty = FC.getOperand(1)->getType();
2930  Assert(Op0Ty == Op1Ty,
2931  "Both operands to FCmp instruction are not of the same type!", &FC);
2932  // Check that the operands are the right type
2933  Assert(Op0Ty->isFPOrFPVectorTy(),
2934  "Invalid operand types for FCmp instruction", &FC);
2935  // Check that the predicate is valid.
2938  "Invalid predicate in FCmp instruction!", &FC);
2939 
2940  visitInstruction(FC);
2941 }
2942 
2943 void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
2944  Assert(
2946  "Invalid extractelement operands!", &EI);
2947  visitInstruction(EI);
2948 }
2949 
2950 void Verifier::visitInsertElementInst(InsertElementInst &IE) {
2952  IE.getOperand(2)),
2953  "Invalid insertelement operands!", &IE);
2954  visitInstruction(IE);
2955 }
2956 
2957 void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
2959  SV.getOperand(2)),
2960  "Invalid shufflevector operands!", &SV);
2961  visitInstruction(SV);
2962 }
2963 
2964 void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
2965  Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
2966 
2967  Assert(isa<PointerType>(TargetTy),
2968  "GEP base pointer is not a vector or a vector of pointers", &GEP);
2969  Assert(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
2970  SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
2971  Type *ElTy =
2973  Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP);
2974 
2975  Assert(GEP.getType()->getScalarType()->isPointerTy() &&
2976  GEP.getResultElementType() == ElTy,
2977  "GEP is not of right type for indices!", &GEP, ElTy);
2978 
2979  if (GEP.getType()->isVectorTy()) {
2980  // Additional checks for vector GEPs.
2981  unsigned GEPWidth = GEP.getType()->getVectorNumElements();
2982  if (GEP.getPointerOperandType()->isVectorTy())
2983  Assert(GEPWidth == GEP.getPointerOperandType()->getVectorNumElements(),
2984  "Vector GEP result width doesn't match operand's", &GEP);
2985  for (Value *Idx : Idxs) {
2986  Type *IndexTy = Idx->getType();
2987  if (IndexTy->isVectorTy()) {
2988  unsigned IndexWidth = IndexTy->getVectorNumElements();
2989  Assert(IndexWidth == GEPWidth, "Invalid GEP index vector width", &GEP);
2990  }
2991  Assert(IndexTy->getScalarType()->isIntegerTy(),
2992  "All GEP indices should be of integer type");
2993  }
2994  }
2995  visitInstruction(GEP);
2996 }
2997 
2998 static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
2999  return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
3000 }
3001 
3002 void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
3003  assert(Range && Range == I.getMetadata(LLVMContext::MD_range) &&
3004  "precondition violation");
3005 
3006  unsigned NumOperands = Range->getNumOperands();
3007  Assert(NumOperands % 2 == 0, "Unfinished range!", Range);
3008  unsigned NumRanges = NumOperands / 2;
3009  Assert(NumRanges >= 1, "It should have at least one range!", Range);
3010 
3011  ConstantRange LastRange(1); // Dummy initial value
3012  for (unsigned i = 0; i < NumRanges; ++i) {
3013  ConstantInt *Low =
3014  mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
3015  Assert(Low, "The lower limit must be an integer!", Low);
3016  ConstantInt *High =
3017  mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
3018  Assert(High, "The upper limit must be an integer!", High);
3019  Assert(High->getType() == Low->getType() && High->getType() == Ty,
3020  "Range types must match instruction type!", &I);
3021 
3022  APInt HighV = High->getValue();
3023  APInt LowV = Low->getValue();
3024  ConstantRange CurRange(LowV, HighV);
3025  Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),
3026  "Range must not be empty!", Range);
3027  if (i != 0) {
3028  Assert(CurRange.intersectWith(LastRange).isEmptySet(),
3029  "Intervals are overlapping", Range);
3030  Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
3031  Range);
3032  Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
3033  Range);
3034  }
3035  LastRange = ConstantRange(LowV, HighV);
3036  }
3037  if (NumRanges > 2) {
3038  APInt FirstLow =
3039  mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
3040  APInt FirstHigh =
3041  mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
3042  ConstantRange FirstRange(FirstLow, FirstHigh);
3043  Assert(FirstRange.intersectWith(LastRange).isEmptySet(),
3044  "Intervals are overlapping", Range);
3045  Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
3046  Range);
3047  }
3048 }
3049 
3050 void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
3051  unsigned Size = DL.getTypeSizeInBits(Ty);
3052  Assert(Size >= 8, "atomic memory access' size must be byte-sized", Ty, I);
3053  Assert(!(Size & (Size - 1)),
3054  "atomic memory access' operand must have a power-of-two size", Ty, I);
3055 }
3056 
3057 void Verifier::visitLoadInst(LoadInst &LI) {
3059  Assert(PTy, "Load operand must be a pointer.", &LI);
3060  Type *ElTy = LI.getType();
3062  "huge alignment values are unsupported", &LI);
3063  Assert(ElTy->isSized(), "loading unsized types is not allowed", &LI);
3064  if (LI.isAtomic()) {
3067  "Load cannot have Release ordering", &LI);
3068  Assert(LI.getAlignment() != 0,
3069  "Atomic load must specify explicit alignment", &LI);
3070  Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() ||
3071  ElTy->isFloatingPointTy(),
3072  "atomic load operand must have integer, pointer, or floating point "
3073  "type!",
3074  ElTy, &LI);
3075  checkAtomicMemAccessSize(ElTy, &LI);
3076  } else {
3078  "Non-atomic load cannot have SynchronizationScope specified", &LI);
3079  }
3080 
3081  visitInstruction(LI);
3082 }
3083 
3084 void Verifier::visitStoreInst(StoreInst &SI) {
3086  Assert(PTy, "Store operand must be a pointer.", &SI);
3087  Type *ElTy = PTy->getElementType();
3088  Assert(ElTy == SI.getOperand(0)->getType(),
3089  "Stored value type does not match pointer operand type!", &SI, ElTy);
3091  "huge alignment values are unsupported", &SI);
3092  Assert(ElTy->isSized(), "storing unsized types is not allowed", &SI);
3093  if (SI.isAtomic()) {
3096  "Store cannot have Acquire ordering", &SI);
3097  Assert(SI.getAlignment() != 0,
3098  "Atomic store must specify explicit alignment", &SI);
3099  Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() ||
3100  ElTy->isFloatingPointTy(),
3101  "atomic store operand must have integer, pointer, or floating point "
3102  "type!",
3103  ElTy, &SI);
3104  checkAtomicMemAccessSize(ElTy, &SI);
3105  } else {
3107  "Non-atomic store cannot have SynchronizationScope specified", &SI);
3108  }
3109  visitInstruction(SI);
3110 }
3111 
3112 /// Check that SwiftErrorVal is used as a swifterror argument in CS.
3113 void Verifier::verifySwiftErrorCallSite(CallSite CS,
3114  const Value *SwiftErrorVal) {
3115  unsigned Idx = 0;
3116  for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
3117  I != E; ++I, ++Idx) {
3118  if (*I == SwiftErrorVal) {
3119  Assert(CS.paramHasAttr(Idx+1, Attribute::SwiftError),
3120  "swifterror value when used in a callsite should be marked "
3121  "with swifterror attribute",
3122  SwiftErrorVal, CS);
3123  }
3124  }
3125 }
3126 
3127 void Verifier::verifySwiftErrorValue(const Value *SwiftErrorVal) {
3128  // Check that swifterror value is only used by loads, stores, or as
3129  // a swifterror argument.
3130  for (const User *U : SwiftErrorVal->users()) {
3131  Assert(isa<LoadInst>(U) || isa<StoreInst>(U) || isa<CallInst>(U) ||
3132  isa<InvokeInst>(U),
3133  "swifterror value can only be loaded and stored from, or "
3134  "as a swifterror argument!",
3135  SwiftErrorVal, U);
3136  // If it is used by a store, check it is the second operand.
3137  if (auto StoreI = dyn_cast<StoreInst>(U))
3138  Assert(StoreI->getOperand(1) == SwiftErrorVal,
3139  "swifterror value should be the second operand when used "
3140  "by stores", SwiftErrorVal, U);
3141  if (auto CallI = dyn_cast<CallInst>(U))
3142  verifySwiftErrorCallSite(const_cast<CallInst*>(CallI), SwiftErrorVal);
3143  if (auto II = dyn_cast<InvokeInst>(U))
3144  verifySwiftErrorCallSite(const_cast<InvokeInst*>(II), SwiftErrorVal);
3145  }
3146 }
3147 
3148 void Verifier::visitAllocaInst(AllocaInst &AI) {
3149  SmallPtrSet<Type*, 4> Visited;
3150  PointerType *PTy = AI.getType();
3151  Assert(PTy->getAddressSpace() == 0,
3152  "Allocation instruction pointer not in the generic address space!",
3153  &AI);
3154  Assert(AI.getAllocatedType()->isSized(&Visited),
3155  "Cannot allocate unsized type", &AI);
3157  "Alloca array size must have integer type", &AI);
3159  "huge alignment values are unsupported", &AI);
3160 
3161  if (AI.isSwiftError()) {
3162  verifySwiftErrorValue(&AI);
3163  }
3164 
3165  visitInstruction(AI);
3166 }
3167 
3168 void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
3169 
3170  // FIXME: more conditions???
3172  "cmpxchg instructions must be atomic.", &CXI);
3174  "cmpxchg instructions must be atomic.", &CXI);
3176  "cmpxchg instructions cannot be unordered.", &CXI);
3178  "cmpxchg instructions cannot be unordered.", &CXI);
3180  "cmpxchg instructions failure argument shall be no stronger than the "
3181  "success argument",
3182  &CXI);
3185  "cmpxchg failure ordering cannot include release semantics", &CXI);
3186 
3187  PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
3188  Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI);
3189  Type *ElTy = PTy->getElementType();
3190  Assert(ElTy->isIntegerTy() || ElTy->isPointerTy(),
3191  "cmpxchg operand must have integer or pointer type",
3192  ElTy, &CXI);
3193  checkAtomicMemAccessSize(ElTy, &CXI);
3194  Assert(ElTy == CXI.getOperand(1)->getType(),
3195  "Expected value type does not match pointer operand type!", &CXI,
3196  ElTy);
3197  Assert(ElTy == CXI.getOperand(2)->getType(),
3198  "Stored value type does not match pointer operand type!", &CXI, ElTy);
3199  visitInstruction(CXI);
3200 }
3201 
3202 void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
3204  "atomicrmw instructions must be atomic.", &RMWI);
3206  "atomicrmw instructions cannot be unordered.", &RMWI);
3207  PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
3208  Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
3209  Type *ElTy = PTy->getElementType();
3210  Assert(ElTy->isIntegerTy(), "atomicrmw operand must have integer type!",
3211  &RMWI, ElTy);
3212  checkAtomicMemAccessSize(ElTy, &RMWI);
3213  Assert(ElTy == RMWI.getOperand(1)->getType(),
3214  "Argument value type does not match pointer operand type!", &RMWI,
3215  ElTy);
3218  "Invalid binary operation!", &RMWI);
3219  visitInstruction(RMWI);
3220 }
3221 
3222 void Verifier::visitFenceInst(FenceInst &FI) {
3223  const AtomicOrdering Ordering = FI.getOrdering();
3224  Assert(Ordering == AtomicOrdering::Acquire ||
3225  Ordering == AtomicOrdering::Release ||
3226  Ordering == AtomicOrdering::AcquireRelease ||
3228  "fence instructions may only have acquire, release, acq_rel, or "
3229  "seq_cst ordering.",
3230  &FI);
3231  visitInstruction(FI);
3232 }
3233 
3234 void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
3236  EVI.getIndices()) == EVI.getType(),
3237  "Invalid ExtractValueInst operands!", &EVI);
3238 
3239  visitInstruction(EVI);
3240 }
3241 
3242 void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
3244  IVI.getIndices()) ==
3245  IVI.getOperand(1)->getType(),
3246  "Invalid InsertValueInst operands!", &IVI);
3247 
3248  visitInstruction(IVI);
3249 }
3250 
3251 static Value *getParentPad(Value *EHPad) {
3252  if (auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
3253  return FPI->getParentPad();
3254 
3255  return cast<CatchSwitchInst>(EHPad)->getParentPad();
3256 }
3257 
3258 void Verifier::visitEHPadPredecessors(Instruction &I) {
3259  assert(I.isEHPad());
3260 
3261  BasicBlock *BB = I.getParent();
3262  Function *F = BB->getParent();
3263 
3264  Assert(BB != &F->getEntryBlock(), "EH pad cannot be in entry block.", &I);
3265 
3266  if (auto *LPI = dyn_cast<LandingPadInst>(&I)) {
3267  // The landingpad instruction defines its parent as a landing pad block. The
3268  // landing pad block may be branched to only by the unwind edge of an
3269  // invoke.
3270  for (BasicBlock *PredBB : predecessors(BB)) {
3271  const auto *II = dyn_cast<InvokeInst>(PredBB->getTerminator());
3272  Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
3273  "Block containing LandingPadInst must be jumped to "
3274  "only by the unwind edge of an invoke.",
3275  LPI);
3276  }
3277  return;
3278  }
3279  if (auto *CPI = dyn_cast<CatchPadInst>(&I)) {
3280  if (!pred_empty(BB))
3281  Assert(BB->getUniquePredecessor() == CPI->getCatchSwitch()->getParent(),
3282  "Block containg CatchPadInst must be jumped to "
3283  "only by its catchswitch.",
3284  CPI);
3285  Assert(BB != CPI->getCatchSwitch()->getUnwindDest(),
3286  "Catchswitch cannot unwind to one of its catchpads",
3287  CPI->getCatchSwitch(), CPI);
3288  return;
3289  }
3290 
3291  // Verify that each pred has a legal terminator with a legal to/from EH
3292  // pad relationship.
3293  Instruction *ToPad = &I;
3294  Value *ToPadParent = getParentPad(ToPad);
3295  for (BasicBlock *PredBB : predecessors(BB)) {
3296  TerminatorInst *TI = PredBB->getTerminator();
3297  Value *FromPad;
3298  if (auto *II = dyn_cast<InvokeInst>(TI)) {
3299  Assert(II->getUnwindDest() == BB && II->getNormalDest() != BB,
3300  "EH pad must be jumped to via an unwind edge", ToPad, II);
3301  if (auto Bundle = II->getOperandBundle(LLVMContext::OB_funclet))
3302  FromPad = Bundle->Inputs[0];
3303  else
3304  FromPad = ConstantTokenNone::get(II->getContext());
3305  } else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
3306  FromPad = CRI->getOperand(0);
3307  Assert(FromPad != ToPadParent, "A cleanupret must exit its cleanup", CRI);
3308  } else if (auto *CSI = dyn_cast<CatchSwitchInst>(TI)) {
3309  FromPad = CSI;
3310  } else {
3311  Assert(false, "EH pad must be jumped to via an unwind edge", ToPad, TI);
3312  }
3313 
3314  // The edge may exit from zero or more nested pads.
3315  SmallSet<Value *, 8> Seen;
3316  for (;; FromPad = getParentPad(FromPad)) {
3317  Assert(FromPad != ToPad,
3318  "EH pad cannot handle exceptions raised within it", FromPad, TI);
3319  if (FromPad == ToPadParent) {
3320  // This is a legal unwind edge.
3321  break;
3322  }
3323  Assert(!isa<ConstantTokenNone>(FromPad),
3324  "A single unwind edge may only enter one EH pad", TI);
3325  Assert(Seen.insert(FromPad).second,
3326  "EH pad jumps through a cycle of pads", FromPad);
3327  }
3328  }
3329 }
3330 
3331 void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
3332  // The landingpad instruction is ill-formed if it doesn't have any clauses and
3333  // isn't a cleanup.
3334  Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
3335  "LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
3336 
3337  visitEHPadPredecessors(LPI);
3338 
3339  if (!LandingPadResultTy)
3340  LandingPadResultTy = LPI.getType();
3341  else
3342  Assert(LandingPadResultTy == LPI.getType(),
3343  "The landingpad instruction should have a consistent result type "
3344  "inside a function.",
3345  &LPI);
3346 
3347  Function *F = LPI.getParent()->getParent();
3348  Assert(F->hasPersonalityFn(),
3349  "LandingPadInst needs to be in a function with a personality.", &LPI);
3350 
3351  // The landingpad instruction must be the first non-PHI instruction in the
3352  // block.
3353  Assert(LPI.getParent()->getLandingPadInst() == &LPI,
3354  "LandingPadInst not the first non-PHI instruction in the block.",
3355  &LPI);
3356 
3357  for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
3358  Constant *Clause = LPI.getClause(i);
3359  if (LPI.isCatch(i)) {
3360  Assert(isa<PointerType>(Clause->getType()),
3361  "Catch operand does not have pointer type!", &LPI);
3362  } else {
3363  Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
3364  Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
3365  "Filter operand is not an array of constants!", &LPI);
3366  }
3367  }
3368 
3369  visitInstruction(LPI);
3370 }
3371 
3372 void Verifier::visitResumeInst(ResumeInst &RI) {
3374  "ResumeInst needs to be in a function with a personality.", &RI);
3375 
3376  if (!LandingPadResultTy)
3377  LandingPadResultTy = RI.getValue()->getType();
3378  else
3379  Assert(LandingPadResultTy == RI.getValue()->getType(),
3380  "The resume instruction should have a consistent result type "
3381  "inside a function.",
3382  &RI);
3383 
3384  visitTerminatorInst(RI);
3385 }
3386 
3387 void Verifier::visitCatchPadInst(CatchPadInst &CPI) {
3388  BasicBlock *BB = CPI.getParent();
3389 
3390  Function *F = BB->getParent();
3391  Assert(F->hasPersonalityFn(),
3392  "CatchPadInst needs to be in a function with a personality.", &CPI);
3393 
3394  Assert(isa<CatchSwitchInst>(CPI.getParentPad()),
3395  "CatchPadInst needs to be directly nested in a CatchSwitchInst.",
3396  CPI.getParentPad());
3397 
3398  // The catchpad instruction must be the first non-PHI instruction in the
3399  // block.
3400  Assert(BB->getFirstNonPHI() == &CPI,
3401  "CatchPadInst not the first non-PHI instruction in the block.", &CPI);
3402 
3403  visitEHPadPredecessors(CPI);
3404  visitFuncletPadInst(CPI);
3405 }
3406 
3407 void Verifier::visitCatchReturnInst(CatchReturnInst &CatchReturn) {
3408  Assert(isa<CatchPadInst>(CatchReturn.getOperand(0)),
3409  "CatchReturnInst needs to be provided a CatchPad", &CatchReturn,
3410  CatchReturn.getOperand(0));
3411 
3412  visitTerminatorInst(CatchReturn);
3413 }
3414 
3415 void Verifier::visitCleanupPadInst(CleanupPadInst &CPI) {
3416  BasicBlock *BB = CPI.getParent();
3417 
3418  Function *F = BB->getParent();
3419  Assert(F->hasPersonalityFn(),
3420  "CleanupPadInst needs to be in a function with a personality.", &CPI);
3421 
3422  // The cleanuppad instruction must be the first non-PHI instruction in the
3423  // block.
3424  Assert(BB->getFirstNonPHI() == &CPI,
3425  "CleanupPadInst not the first non-PHI instruction in the block.",
3426  &CPI);
3427 
3428  auto *ParentPad = CPI.getParentPad();
3429  Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
3430  "CleanupPadInst has an invalid parent.", &CPI);
3431 
3432  visitEHPadPredecessors(CPI);
3433  visitFuncletPadInst(CPI);
3434 }
3435 
3436 void Verifier::visitFuncletPadInst(FuncletPadInst &FPI) {
3437  User *FirstUser = nullptr;
3438  Value *FirstUnwindPad = nullptr;
3439  SmallVector<FuncletPadInst *, 8> Worklist({&FPI});
3441 
3442  while (!Worklist.empty()) {
3443  FuncletPadInst *CurrentPad = Worklist.pop_back_val();
3444  Assert(Seen.insert(CurrentPad).second,
3445  "FuncletPadInst must not be nested within itself", CurrentPad);
3446  Value *UnresolvedAncestorPad = nullptr;
3447  for (User *U : CurrentPad->users()) {
3448  BasicBlock *UnwindDest;
3449  if (auto *CRI = dyn_cast<CleanupReturnInst>(U)) {
3450  UnwindDest = CRI->getUnwindDest();
3451  } else if (auto *CSI = dyn_cast<CatchSwitchInst>(U)) {
3452  // We allow catchswitch unwind to caller to nest
3453  // within an outer pad that unwinds somewhere else,
3454  // because catchswitch doesn't have a nounwind variant.
3455  // See e.g. SimplifyCFGOpt::SimplifyUnreachable.
3456  if (CSI->unwindsToCaller())
3457  continue;
3458  UnwindDest = CSI->getUnwindDest();
3459  } else if (auto *II = dyn_cast<InvokeInst>(U)) {
3460  UnwindDest = II->getUnwindDest();
3461  } else if (isa<CallInst>(U)) {
3462  // Calls which don't unwind may be found inside funclet
3463  // pads that unwind somewhere else. We don't *require*
3464  // such calls to be annotated nounwind.
3465  continue;
3466  } else if (auto *CPI = dyn_cast<CleanupPadInst>(U)) {
3467  // The unwind dest for a cleanup can only be found by
3468  // recursive search. Add it to the worklist, and we'll
3469  // search for its first use that determines where it unwinds.
3470  Worklist.push_back(CPI);
3471  continue;
3472  } else {
3473  Assert(isa<CatchReturnInst>(U), "Bogus funclet pad use", U);
3474  continue;
3475  }
3476 
3477  Value *UnwindPad;
3478  bool ExitsFPI;
3479  if (UnwindDest) {
3480  UnwindPad = UnwindDest->getFirstNonPHI();
3481  if (!cast<Instruction>(UnwindPad)->isEHPad())
3482  continue;
3483  Value *UnwindParent = getParentPad(UnwindPad);
3484  // Ignore unwind edges that don't exit CurrentPad.
3485  if (UnwindParent == CurrentPad)
3486  continue;
3487  // Determine whether the original funclet pad is exited,
3488  // and if we are scanning nested pads determine how many
3489  // of them are exited so we can stop searching their
3490  // children.
3491  Value *ExitedPad = CurrentPad;
3492  ExitsFPI = false;
3493  do {
3494  if (ExitedPad == &FPI) {
3495  ExitsFPI = true;
3496  // Now we can resolve any ancestors of CurrentPad up to
3497  // FPI, but not including FPI since we need to make sure
3498  // to check all direct users of FPI for consistency.
3499  UnresolvedAncestorPad = &FPI;
3500  break;
3501  }
3502  Value *ExitedParent = getParentPad(ExitedPad);
3503  if (ExitedParent == UnwindParent) {
3504  // ExitedPad is the ancestor-most pad which this unwind
3505  // edge exits, so we can resolve up to it, meaning that
3506  // ExitedParent is the first ancestor still unresolved.
3507  UnresolvedAncestorPad = ExitedParent;
3508  break;
3509  }
3510  ExitedPad = ExitedParent;
3511  } while (!isa<ConstantTokenNone>(ExitedPad));
3512  } else {
3513  // Unwinding to caller exits all pads.
3514  UnwindPad = ConstantTokenNone::get(FPI.getContext());
3515  ExitsFPI = true;
3516  UnresolvedAncestorPad = &FPI;
3517  }
3518 
3519  if (ExitsFPI) {
3520  // This unwind edge exits FPI. Make sure it agrees with other
3521  // such edges.
3522  if (FirstUser) {
3523  Assert(UnwindPad == FirstUnwindPad, "Unwind edges out of a funclet "
3524  "pad must have the same unwind "
3525  "dest",
3526  &FPI, U, FirstUser);
3527  } else {
3528  FirstUser = U;
3529  FirstUnwindPad = UnwindPad;
3530  // Record cleanup sibling unwinds for verifySiblingFuncletUnwinds
3531  if (isa<CleanupPadInst>(&FPI) && !isa<ConstantTokenNone>(UnwindPad) &&
3532  getParentPad(UnwindPad) == getParentPad(&FPI))
3533  SiblingFuncletInfo[&FPI] = cast<TerminatorInst>(U);
3534  }
3535  }
3536  // Make sure we visit all uses of FPI, but for nested pads stop as
3537  // soon as we know where they unwind to.
3538  if (CurrentPad != &FPI)
3539  break;
3540  }
3541  if (UnresolvedAncestorPad) {
3542  if (CurrentPad == UnresolvedAncestorPad) {
3543  // When CurrentPad is FPI itself, we don't mark it as resolved even if
3544  // we've found an unwind edge that exits it, because we need to verify
3545  // all direct uses of FPI.
3546  assert(CurrentPad == &FPI);
3547  continue;
3548  }
3549  // Pop off the worklist any nested pads that we've found an unwind
3550  // destination for. The pads on the worklist are the uncles,
3551  // great-uncles, etc. of CurrentPad. We've found an unwind destination
3552  // for all ancestors of CurrentPad up to but not including
3553  // UnresolvedAncestorPad.
3554  Value *ResolvedPad = CurrentPad;
3555  while (!Worklist.empty()) {
3556  Value *UnclePad = Worklist.back();
3557  Value *AncestorPad = getParentPad(UnclePad);
3558  // Walk ResolvedPad up the ancestor list until we either find the
3559  // uncle's parent or the last resolved ancestor.
3560  while (ResolvedPad != AncestorPad) {
3561  Value *ResolvedParent = getParentPad(ResolvedPad);
3562  if (ResolvedParent == UnresolvedAncestorPad) {
3563  break;
3564  }
3565  ResolvedPad = ResolvedParent;
3566  }
3567  // If the resolved ancestor search didn't find the uncle's parent,
3568  // then the uncle is not yet resolved.
3569  if (ResolvedPad != AncestorPad)
3570  break;
3571  // This uncle is resolved, so pop it from the worklist.
3572  Worklist.pop_back();
3573  }
3574  }
3575  }
3576 
3577  if (FirstUnwindPad) {
3578  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(FPI.getParentPad())) {
3579  BasicBlock *SwitchUnwindDest = CatchSwitch->getUnwindDest();
3580  Value *SwitchUnwindPad;
3581  if (SwitchUnwindDest)
3582  SwitchUnwindPad = SwitchUnwindDest->getFirstNonPHI();
3583  else
3584  SwitchUnwindPad = ConstantTokenNone::get(FPI.getContext());
3585  Assert(SwitchUnwindPad == FirstUnwindPad,
3586  "Unwind edges out of a catch must have the same unwind dest as "
3587  "the parent catchswitch",
3588  &FPI, FirstUser, CatchSwitch);
3589  }
3590  }
3591 
3592  visitInstruction(FPI);
3593 }
3594 
3595 void Verifier::visitCatchSwitchInst(CatchSwitchInst &CatchSwitch) {
3596  BasicBlock *BB = CatchSwitch.getParent();
3597 
3598  Function *F = BB->getParent();
3599  Assert(F->hasPersonalityFn(),
3600  "CatchSwitchInst needs to be in a function with a personality.",
3601  &CatchSwitch);
3602 
3603  // The catchswitch instruction must be the first non-PHI instruction in the
3604  // block.
3605  Assert(BB->getFirstNonPHI() == &CatchSwitch,
3606  "CatchSwitchInst not the first non-PHI instruction in the block.",
3607  &CatchSwitch);
3608 
3609  auto *ParentPad = CatchSwitch.getParentPad();
3610  Assert(isa<ConstantTokenNone>(ParentPad) || isa<FuncletPadInst>(ParentPad),
3611  "CatchSwitchInst has an invalid parent.", ParentPad);
3612 
3613  if (BasicBlock *UnwindDest = CatchSwitch.getUnwindDest()) {
3614  Instruction *I = UnwindDest->getFirstNonPHI();
3615  Assert(I->isEHPad() && !isa<LandingPadInst>(I),
3616  "CatchSwitchInst must unwind to an EH block which is not a "
3617  "landingpad.",
3618  &CatchSwitch);
3619 
3620  // Record catchswitch sibling unwinds for verifySiblingFuncletUnwinds
3621  if (getParentPad(I) == ParentPad)
3622  SiblingFuncletInfo[&CatchSwitch] = &CatchSwitch;
3623  }
3624 
3625  Assert(CatchSwitch.getNumHandlers() != 0,
3626  "CatchSwitchInst cannot have empty handler list", &CatchSwitch);
3627 
3628  for (BasicBlock *Handler : CatchSwitch.handlers()) {
3629  Assert(isa<CatchPadInst>(Handler->getFirstNonPHI()),
3630  "CatchSwitchInst handlers must be catchpads", &CatchSwitch, Handler);
3631  }
3632 
3633  visitEHPadPredecessors(CatchSwitch);
3634  visitTerminatorInst(CatchSwitch);
3635 }
3636 
3637 void Verifier::visitCleanupReturnInst(CleanupReturnInst &CRI) {
3638  Assert(isa<CleanupPadInst>(CRI.getOperand(0)),
3639  "CleanupReturnInst needs to be provided a CleanupPad", &CRI,
3640  CRI.getOperand(0));
3641 
3642  if (BasicBlock *UnwindDest = CRI.getUnwindDest()) {
3643  Instruction *I = UnwindDest->getFirstNonPHI();
3644  Assert(I->isEHPad() && !isa<LandingPadInst>(I),
3645  "CleanupReturnInst must unwind to an EH block which is not a "
3646  "landingpad.",
3647  &CRI);
3648  }
3649 
3650  visitTerminatorInst(CRI);
3651 }
3652 
3653 void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
3654  Instruction *Op = cast<Instruction>(I.getOperand(i));
3655  // If the we have an invalid invoke, don't try to compute the dominance.
3656  // We already reject it in the invoke specific checks and the dominance
3657  // computation doesn't handle multiple edges.
3658  if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) {
3659  if (II->getNormalDest() == II->getUnwindDest())
3660  return;
3661  }
3662 
3663  // Quick check whether the def has already been encountered in the same block.
3664  // PHI nodes are not checked to prevent accepting preceeding PHIs, because PHI
3665  // uses are defined to happen on the incoming edge, not at the instruction.
3666  //
3667  // FIXME: If this operand is a MetadataAsValue (wrapping a LocalAsMetadata)
3668  // wrapping an SSA value, assert that we've already encountered it. See
3669  // related FIXME in Mapper::mapLocalAsMetadata in ValueMapper.cpp.
3670  if (!isa<PHINode>(I) && InstsInThisBlock.count(Op))
3671  return;
3672 
3673  const Use &U = I.getOperandUse(i);
3674  Assert(DT.dominates(Op, U),
3675  "Instruction does not dominate all uses!", Op, &I);
3676 }
3677 
3678 void Verifier::visitDereferenceableMetadata(Instruction& I, MDNode* MD) {
3679  Assert(I.getType()->isPointerTy(), "dereferenceable, dereferenceable_or_null "
3680  "apply only to pointer types", &I);
3681  Assert(isa<LoadInst>(I),
3682  "dereferenceable, dereferenceable_or_null apply only to load"
3683  " instructions, use attributes for calls or invokes", &I);
3684  Assert(MD->getNumOperands() == 1, "dereferenceable, dereferenceable_or_null "
3685  "take one operand!", &I);
3686  ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
3687  Assert(CI && CI->getType()->isIntegerTy(64), "dereferenceable, "
3688  "dereferenceable_or_null metadata value must be an i64!", &I);
3689 }
3690 
3691 /// verifyInstruction - Verify that an instruction is well formed.
3692 ///
3693 void Verifier::visitInstruction(Instruction &I) {
3694  BasicBlock *BB = I.getParent();
3695  Assert(BB, "Instruction not embedded in basic block!", &I);
3696 
3697  if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential
3698  for (User *U : I.users()) {
3699  Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
3700  "Only PHI nodes may reference their own value!", &I);
3701  }
3702  }
3703 
3704  // Check that void typed values don't have names
3705  Assert(!I.getType()->isVoidTy() || !I.hasName(),
3706  "Instruction has a name, but provides a void value!", &I);
3707 
3708  // Check that the return value of the instruction is either void or a legal
3709  // value type.
3710  Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
3711  "Instruction returns a non-scalar type!", &I);
3712 
3713  // Check that the instruction doesn't produce metadata. Calls are already
3714  // checked against the callee type.
3715  Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
3716  "Invalid use of metadata!", &I);
3717 
3718  // Check that all uses of the instruction, if they are instructions
3719  // themselves, actually have parent basic blocks. If the use is not an
3720  // instruction, it is an error!
3721  for (Use &U : I.uses()) {
3722  if (Instruction *Used = dyn_cast<Instruction>(U.getUser()))
3723  Assert(Used->getParent() != nullptr,
3724  "Instruction referencing"
3725  " instruction not embedded in a basic block!",
3726  &I, Used);
3727  else {
3728  CheckFailed("Use of instruction is not an instruction!", U);
3729  return;
3730  }
3731  }
3732 
3733  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
3734  Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
3735 
3736  // Check to make sure that only first-class-values are operands to
3737  // instructions.
3738  if (!I.getOperand(i)->getType()->isFirstClassType()) {
3739  Assert(false, "Instruction operands must be first-class values!", &I);
3740  }
3741 
3742  if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
3743  // Check to make sure that the "address of" an intrinsic function is never
3744  // taken.
3745  Assert(
3746  !F->isIntrinsic() ||
3747  i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0),
3748  "Cannot take the address of an intrinsic!", &I);
3749  Assert(
3750  !F->isIntrinsic() || isa<CallInst>(I) ||
3751  F->getIntrinsicID() == Intrinsic::donothing ||
3752  F->getIntrinsicID() == Intrinsic::coro_resume ||
3753  F->getIntrinsicID() == Intrinsic::coro_destroy ||
3754  F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
3755  F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
3756  F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
3757  "Cannot invoke an intrinsic other than donothing, patchpoint, "
3758  "statepoint, coro_resume or coro_destroy",
3759  &I);
3760  Assert(F->getParent() == &M, "Referencing function in another module!",
3761  &I, &M, F, F->getParent());
3762  } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
3763  Assert(OpBB->getParent() == BB->getParent(),
3764  "Referring to a basic block in another function!", &I);
3765  } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
3766  Assert(OpArg->getParent() == BB->getParent(),
3767  "Referring to an argument in another function!", &I);
3768  } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
3769  Assert(GV->getParent() == &M, "Referencing global in another module!", &I,
3770  &M, GV, GV->getParent());
3771  } else if (isa<Instruction>(I.getOperand(i))) {
3772  verifyDominatesUse(I, i);
3773  } else if (isa<InlineAsm>(I.getOperand(i))) {
3774  Assert((i + 1 == e && isa<CallInst>(I)) ||
3775  (i + 3 == e && isa<InvokeInst>(I)),
3776  "Cannot take the address of an inline asm!", &I);
3777  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
3778  if (CE->getType()->isPtrOrPtrVectorTy() ||
3779  !DL.getNonIntegralAddressSpaces().empty()) {
3780  // If we have a ConstantExpr pointer, we need to see if it came from an
3781  // illegal bitcast. If the datalayout string specifies non-integral
3782  // address spaces then we also need to check for illegal ptrtoint and
3783  // inttoptr expressions.
3784  visitConstantExprsRecursively(CE);
3785  }
3786  }
3787  }
3788 
3789  if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
3790  Assert(I.getType()->isFPOrFPVectorTy(),
3791  "fpmath requires a floating point result!", &I);
3792  Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
3793  if (ConstantFP *CFP0 =
3794  mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) {
3795  const APFloat &Accuracy = CFP0->getValueAPF();
3796  Assert(&Accuracy.getSemantics() == &APFloat::IEEEsingle(),
3797  "fpmath accuracy must have float type", &I);
3798  Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
3799  "fpmath accuracy not a positive number!", &I);
3800  } else {
3801  Assert(false, "invalid fpmath accuracy!", &I);
3802  }
3803  }
3804 
3805  if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
3806  Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
3807  "Ranges are only for loads, calls and invokes!", &I);
3808  visitRangeMetadata(I, Range, I.getType());
3809  }
3810 
3811  if (I.getMetadata(LLVMContext::MD_nonnull)) {
3812  Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
3813  &I);
3814  Assert(isa<LoadInst>(I),
3815  "nonnull applies only to load instructions, use attributes"
3816  " for calls or invokes",
3817  &I);
3818  }
3819 
3820  if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable))
3821  visitDereferenceableMetadata(I, MD);
3822 
3823  if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
3824  visitDereferenceableMetadata(I, MD);
3825 
3826  if (MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa))
3827  TBAAVerifyHelper.visitTBAAMetadata(I, TBAA);
3828 
3829  if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) {
3830  Assert(I.getType()->isPointerTy(), "align applies only to pointer types",
3831  &I);
3832  Assert(isa<LoadInst>(I), "align applies only to load instructions, "
3833  "use attributes for calls or invokes", &I);
3834  Assert(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
3835  ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
3836  Assert(CI && CI->getType()->isIntegerTy(64),
3837  "align metadata value must be an i64!", &I);
3838  uint64_t Align = CI->getZExtValue();
3839  Assert(isPowerOf2_64(Align),
3840  "align metadata value must be a power of 2!", &I);
3842  "alignment is larger that implementation defined limit", &I);
3843  }
3844 
3845  if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
3846  AssertDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
3847  visitMDNode(*N);
3848  }
3849 
3850  if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I))
3851  verifyFragmentExpression(*DII);
3852 
3853  InstsInThisBlock.insert(&I);
3854 }
3855 
3856 /// Allow intrinsics to be verified in different ways.
3857 void Verifier::visitIntrinsicCallSite(Intrinsic::ID ID, CallSite CS) {
3858  Function *IF = CS.getCalledFunction();
3859  Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!",
3860  IF);
3861 
3862  // Verify that the intrinsic prototype lines up with what the .td files
3863  // describe.
3864  FunctionType *IFTy = IF->getFunctionType();
3865  bool IsVarArg = IFTy->isVarArg();
3866 
3868  getIntrinsicInfoTableEntries(ID, Table);
3869  ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
3870 
3871  SmallVector<Type *, 4> ArgTys;
3872  Assert(!Intrinsic::matchIntrinsicType(IFTy->getReturnType(),
3873  TableRef, ArgTys),
3874  "Intrinsic has incorrect return type!", IF);
3875  for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i)
3876  Assert(!Intrinsic::matchIntrinsicType(IFTy->getParamType(i),
3877  TableRef, ArgTys),
3878  "Intrinsic has incorrect argument type!", IF);
3879 
3880  // Verify if the intrinsic call matches the vararg property.
3881  if (IsVarArg)
3882  Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
3883  "Intrinsic was not defined with variable arguments!", IF);
3884  else
3885  Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
3886  "Callsite was not defined with variable arguments!", IF);
3887 
3888  // All descriptors should be absorbed by now.
3889  Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
3890 
3891  // Now that we have the intrinsic ID and the actual argument types (and we
3892  // know they are legal for the intrinsic!) get the intrinsic name through the
3893  // usual means. This allows us to verify the mangling of argument types into
3894  // the name.
3895  const std::string ExpectedName = Intrinsic::getName(ID, ArgTys);
3896  Assert(ExpectedName == IF->getName(),
3897  "Intrinsic name not mangled correctly for type arguments! "
3898  "Should be: " +
3899  ExpectedName,
3900  IF);
3901 
3902  // If the intrinsic takes MDNode arguments, verify that they are either global
3903  // or are local to *this* function.
3904  for (Value *V : CS.args())
3905  if (auto *MD = dyn_cast<MetadataAsValue>(V))
3906  visitMetadataAsValue(*MD, CS.getCaller());
3907 
3908  switch (ID) {
3909  default:
3910  break;
3911  case Intrinsic::coro_id: {
3912  auto *InfoArg = CS.getArgOperand(3)->stripPointerCasts();
3913  if (isa<ConstantPointerNull>(InfoArg))
3914  break;
3915  auto *GV = dyn_cast<GlobalVariable>(InfoArg);
3916  Assert(GV && GV->isConstant() && GV->hasDefinitiveInitializer(),
3917  "info argument of llvm.coro.begin must refer to an initialized "
3918  "constant");
3919  Constant *Init = GV->getInitializer();
3920  Assert(isa<ConstantStruct>(Init) || isa<ConstantArray>(Init),
3921  "info argument of llvm.coro.begin must refer to either a struct or "
3922  "an array");
3923  break;
3924  }
3925  case Intrinsic::ctlz: // llvm.ctlz
3926  case Intrinsic::cttz: // llvm.cttz
3927  Assert(isa<ConstantInt>(CS.getArgOperand(1)),
3928  "is_zero_undef argument of bit counting intrinsics must be a "
3929  "constant int",
3930  CS);
3931  break;
3932  case Intrinsic::dbg_declare: // llvm.dbg.declare
3933  Assert(isa<MetadataAsValue>(CS.getArgOperand(0)),
3934  "invalid llvm.dbg.declare intrinsic call 1", CS);
3935  visitDbgIntrinsic("declare", cast<DbgDeclareInst>(*CS.getInstruction()));
3936  break;
3937  case Intrinsic::dbg_value: // llvm.dbg.value
3938  visitDbgIntrinsic("value", cast<DbgValueInst>(*CS.getInstruction()));
3939  break;
3940  case Intrinsic::memcpy:
3941  case Intrinsic::memmove:
3942  case Intrinsic::memset: {
3943  ConstantInt *AlignCI = dyn_cast<ConstantInt>(CS.getArgOperand(3));
3944  Assert(AlignCI,
3945  "alignment argument of memory intrinsics must be a constant int",
3946  CS);
3947  const APInt &AlignVal = AlignCI->getValue();
3948  Assert(AlignCI->isZero() || AlignVal.isPowerOf2(),
3949  "alignment argument of memory intrinsics must be a power of 2", CS);
3950  Assert(isa<ConstantInt>(CS.getArgOperand(4)),
3951  "isvolatile argument of memory intrinsics must be a constant int",
3952  CS);
3953  break;
3954  }
3955  case Intrinsic::memcpy_element_atomic: {
3956  ConstantInt *ElementSizeCI = dyn_cast<ConstantInt>(CS.getArgOperand(3));
3957  Assert(ElementSizeCI, "element size of the element-wise atomic memory "
3958  "intrinsic must be a constant int",
3959  CS);
3960  const APInt &ElementSizeVal = ElementSizeCI->getValue();
3961  Assert(ElementSizeVal.isPowerOf2(),
3962  "element size of the element-wise atomic memory intrinsic "
3963  "must be a power of 2",
3964  CS);
3965 
3966  auto IsValidAlignment = [&](uint64_t Alignment) {
3967  return isPowerOf2_64(Alignment) && ElementSizeVal.ule(Alignment);
3968  };
3969 
3970  uint64_t DstAlignment = CS.getParamAlignment(1),
3971  SrcAlignment = CS.getParamAlignment(2);
3972 
3973  Assert(IsValidAlignment(DstAlignment),
3974  "incorrect alignment of the destination argument",
3975  CS);
3976  Assert(IsValidAlignment(SrcAlignment),
3977  "incorrect alignment of the source argument",
3978  CS);
3979  break;
3980  }
3981  case Intrinsic::gcroot:
3982  case Intrinsic::gcwrite:
3983  case Intrinsic::gcread:
3984  if (ID == Intrinsic::gcroot) {
3985  AllocaInst *AI =
3987  Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", CS);
3988  Assert(isa<Constant>(CS.getArgOperand(1)),
3989  "llvm.gcroot parameter #2 must be a constant.", CS);
3990  if (!AI->getAllocatedType()->isPointerTy()) {
3991  Assert(!isa<ConstantPointerNull>(CS.getArgOperand(1)),
3992  "llvm.gcroot parameter #1 must either be a pointer alloca, "
3993  "or argument #2 must be a non-null constant.",
3994  CS);
3995  }
3996  }
3997 
3998  Assert(CS.getParent()->getParent()->hasGC(),
3999  "Enclosing function does not use GC.", CS);
4000  break;
4001  case Intrinsic::init_trampoline:
4002  Assert(isa<Function>(CS.getArgOperand(1)->stripPointerCasts()),
4003  "llvm.init_trampoline parameter #2 must resolve to a function.",
4004  CS);
4005  break;
4006  case Intrinsic::prefetch:
4007  Assert(isa<ConstantInt>(CS.getArgOperand(1)) &&
4008  isa<ConstantInt>(CS.getArgOperand(2)) &&
4009  cast<ConstantInt>(CS.getArgOperand(1))->getZExtValue() < 2 &&
4010  cast<ConstantInt>(CS.getArgOperand(2))->getZExtValue() < 4,
4011  "invalid arguments to llvm.prefetch", CS);
4012  break;
4013  case Intrinsic::stackprotector:
4014  Assert(isa<AllocaInst>(CS.getArgOperand(1)->stripPointerCasts()),
4015  "llvm.stackprotector parameter #2 must resolve to an alloca.", CS);
4016  break;
4017  case Intrinsic::lifetime_start:
4018  case Intrinsic::lifetime_end:
4019  case Intrinsic::invariant_start:
4020  Assert(isa<ConstantInt>(CS.getArgOperand(0)),
4021  "size argument of memory use markers must be a constant integer",
4022  CS);
4023  break;
4024  case Intrinsic::invariant_end:
4025  Assert(isa<ConstantInt>(CS.getArgOperand(1)),
4026  "llvm.invariant.end parameter #2 must be a constant integer", CS);
4027  break;
4028 
4029  case Intrinsic::localescape: {
4030  BasicBlock *BB = CS.getParent();
4031  Assert(BB == &BB->getParent()->front(),
4032  "llvm.localescape used outside of entry block", CS);
4033  Assert(!SawFrameEscape,
4034  "multiple calls to llvm.localescape in one function", CS);
4035  for (Value *Arg : CS.args()) {
4036  if (isa<ConstantPointerNull>(Arg))
4037  continue; // Null values are allowed as placeholders.
4038  auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
4039  Assert(AI && AI->isStaticAlloca(),
4040  "llvm.localescape only accepts static allocas", CS);
4041  }
4042  FrameEscapeInfo[BB->getParent()].first = CS.getNumArgOperands();
4043  SawFrameEscape = true;
4044  break;
4045  }
4046  case Intrinsic::localrecover: {
4047  Value *FnArg = CS.getArgOperand(0)->stripPointerCasts();
4048  Function *Fn = dyn_cast<Function>(FnArg);
4049  Assert(Fn && !Fn->isDeclaration(),
4050  "llvm.localrecover first "
4051  "argument must be function defined in this module",
4052  CS);
4053  auto *IdxArg = dyn_cast<ConstantInt>(CS.getArgOperand(2));
4054  Assert(IdxArg, "idx argument of llvm.localrecover must be a constant int",
4055  CS);
4056  auto &Entry = FrameEscapeInfo[Fn];
4057  Entry.second = unsigned(
4058  std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));
4059  break;
4060  }
4061 
4062  case Intrinsic::experimental_gc_statepoint:
4063  Assert(!CS.isInlineAsm(),
4064  "gc.statepoint support for inline assembly unimplemented", CS);
4065  Assert(CS.getParent()->getParent()->hasGC(),
4066  "Enclosing function does not use GC.", CS);
4067 
4068  verifyStatepoint(CS);
4069  break;
4070  case Intrinsic::experimental_gc_result: {
4071  Assert(CS.getParent()->getParent()->hasGC(),
4072  "Enclosing function does not use GC.", CS);
4073  // Are we tied to a statepoint properly?
4074  CallSite StatepointCS(CS.getArgOperand(0));
4075  const Function *StatepointFn =
4076  StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr;
4077  Assert(StatepointFn && StatepointFn->isDeclaration() &&
4078  StatepointFn->getIntrinsicID() ==
4079  Intrinsic::experimental_gc_statepoint,
4080  "gc.result operand #1 must be from a statepoint", CS,
4081  CS.getArgOperand(0));
4082 
4083  // Assert that result type matches wrapped callee.
4084  const Value *Target = StatepointCS.getArgument(2);
4085  auto *PT = cast<PointerType>(Target->getType());
4086  auto *TargetFuncType = cast<FunctionType>(PT->getElementType());
4087  Assert(CS.getType() == TargetFuncType->getReturnType(),
4088  "gc.result result type does not match wrapped callee", CS);
4089  break;
4090  }
4091  case Intrinsic::experimental_gc_relocate: {
4092  Assert(CS.getNumArgOperands() == 3, "wrong number of arguments", CS);
4093 
4094  Assert(isa<PointerType>(CS.getType()->getScalarType()),
4095  "gc.relocate must return a pointer or a vector of pointers", CS);
4096 
4097  // Check that this relocate is correctly tied to the statepoint
4098 
4099  // This is case for relocate on the unwinding path of an invoke statepoint
4100  if (LandingPadInst *LandingPad =
4101  dyn_cast<LandingPadInst>(CS.getArgOperand(0))) {
4102 
4103  const BasicBlock *InvokeBB =
4104  LandingPad->getParent()->getUniquePredecessor();
4105 
4106  // Landingpad relocates should have only one predecessor with invoke
4107  // statepoint terminator
4108  Assert(InvokeBB, "safepoints should have unique landingpads",
4109  LandingPad->getParent());
4110  Assert(InvokeBB->getTerminator(), "safepoint block should be well formed",
4111  InvokeBB);
4112  Assert(isStatepoint(InvokeBB->getTerminator()),
4113  "gc relocate should be linked to a statepoint", InvokeBB);
4114  }
4115  else {
4116  // In all other cases relocate should be tied to the statepoint directly.
4117  // This covers relocates on a normal return path of invoke statepoint and
4118  // relocates of a call statepoint.
4119  auto Token = CS.getArgOperand(0);
4120  Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)),
4121  "gc relocate is incorrectly tied to the statepoint", CS, Token);
4122  }
4123 
4124  // Verify rest of the relocate arguments.
4125 
4126  ImmutableCallSite StatepointCS(
4127  cast<GCRelocateInst>(*CS.getInstruction()).getStatepoint());
4128 
4129  // Both the base and derived must be piped through the safepoint.
4130  Value* Base = CS.getArgOperand(1);
4131  Assert(isa<ConstantInt>(Base),
4132  "gc.relocate operand #2 must be integer offset", CS);
4133 
4134  Value* Derived = CS.getArgOperand(2);
4135  Assert(isa<ConstantInt>(Derived),
4136  "gc.relocate operand #3 must be integer offset", CS);
4137 
4138  const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue();
4139  const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
4140  // Check the bounds
4141  Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(),
4142  "gc.relocate: statepoint base index out of bounds", CS);
4143  Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(),
4144  "gc.relocate: statepoint derived index out of bounds", CS);
4145 
4146  // Check that BaseIndex and DerivedIndex fall within the 'gc parameters'
4147  // section of the statepoint's argument.
4148  Assert(StatepointCS.arg_size() > 0,
4149  "gc.statepoint: insufficient arguments");
4150  Assert(isa<ConstantInt>(StatepointCS.getArgument(3)),
4151  "gc.statement: number of call arguments must be constant integer");
4152  const unsigned NumCallArgs =
4153  cast<ConstantInt>(StatepointCS.getArgument(3))->getZExtValue();
4154  Assert(StatepointCS.arg_size() > NumCallArgs + 5,
4155  "gc.statepoint: mismatch in number of call arguments");
4156  Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5)),
4157  "gc.statepoint: number of transition arguments must be "
4158  "a constant integer");
4159  const int NumTransitionArgs =
4160  cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5))
4161  ->getZExtValue();
4162  const int DeoptArgsStart = 4 + NumCallArgs + 1 + NumTransitionArgs + 1;
4163  Assert(isa<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart)),
4164  "gc.statepoint: number of deoptimization arguments must be "
4165  "a constant integer");
4166  const int NumDeoptArgs =
4167  cast<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart))
4168  ->getZExtValue();
4169  const int GCParamArgsStart = DeoptArgsStart + 1 + NumDeoptArgs;
4170  const int GCParamArgsEnd = StatepointCS.arg_size();
4171  Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,
4172  "gc.relocate: statepoint base index doesn't fall within the "
4173  "'gc parameters' section of the statepoint call",
4174  CS);
4175  Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd,
4176  "gc.relocate: statepoint derived index doesn't fall within the "
4177  "'gc parameters' section of the statepoint call",
4178  CS);
4179 
4180  // Relocated value must be either a pointer type or vector-of-pointer type,
4181  // but gc_relocate does not need to return the same pointer type as the
4182  // relocated pointer. It can be casted to the correct type later if it's
4183  // desired. However, they must have the same address space and 'vectorness'
4184  GCRelocateInst &Relocate = cast<GCRelocateInst>(*CS.getInstruction());
4186  "gc.relocate: relocated value must be a gc pointer", CS);
4187 
4188  auto ResultType = CS.getType();
4189  auto DerivedType = Relocate.getDerivedPtr()->getType();
4190  Assert(ResultType->isVectorTy() == DerivedType->isVectorTy(),
4191  "gc.relocate: vector relocates to vector and pointer to pointer",
4192  CS);
4193  Assert(
4194  ResultType->getPointerAddressSpace() ==
4195  DerivedType->getPointerAddressSpace(),
4196  "gc.relocate: relocating a pointer shouldn't change its address space",
4197  CS);
4198  break;
4199  }
4200  case Intrinsic::eh_exceptioncode:
4201  case Intrinsic::eh_exceptionpointer: {
4202  Assert(isa<CatchPadInst>(CS.getArgOperand(0)),
4203  "eh.exceptionpointer argument must be a catchpad", CS);
4204  break;
4205  }
4206  case Intrinsic::masked_load: {
4207  Assert(CS.getType()->isVectorTy(), "masked_load: must return a vector", CS);
4208 
4209  Value *Ptr = CS.getArgOperand(0);
4210  //Value *Alignment = CS.getArgOperand(1);
4211  Value *Mask = CS.getArgOperand(2);
4212  Value *PassThru = CS.getArgOperand(3);
4213  Assert(Mask->getType()->isVectorTy(),
4214  "masked_load: mask must be vector", CS);
4215 
4216  // DataTy is the overloaded type
4217  Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
4218  Assert(DataTy == CS.getType(),
4219  "masked_load: return must match pointer type", CS);
4220  Assert(PassThru->getType() == DataTy,
4221  "masked_load: pass through and data type must match", CS);
4222  Assert(Mask->getType()->getVectorNumElements() ==
4223  DataTy->getVectorNumElements(),
4224  "masked_load: vector mask must be same length as data", CS);
4225  break;
4226  }
4227  case Intrinsic::masked_store: {
4228  Value *Val = CS.getArgOperand(0);
4229  Value *Ptr = CS.getArgOperand(1);
4230  //Value *Alignment = CS.getArgOperand(2);
4231  Value *Mask = CS.getArgOperand(3);
4232  Assert(Mask->getType()->isVectorTy(),
4233  "masked_store: mask must be vector", CS);
4234 
4235  // DataTy is the overloaded type
4236  Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
4237  Assert(DataTy == Val->getType(),
4238  "masked_store: storee must match pointer type", CS);
4239  Assert(Mask->getType()->getVectorNumElements() ==
4240  DataTy->getVectorNumElements(),
4241  "masked_store: vector mask must be same length as data", CS);
4242  break;
4243  }
4244 
4245  case Intrinsic::experimental_guard: {
4246  Assert(CS.isCall(), "experimental_guard cannot be invoked", CS);
4247  Assert(CS.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
4248  "experimental_guard must have exactly one "
4249  "\"deopt\" operand bundle");
4250  break;
4251  }
4252 
4253  case Intrinsic::experimental_deoptimize: {
4254  Assert(CS.isCall(), "experimental_deoptimize cannot be invoked", CS);
4255  Assert(CS.countOperandBundlesOfType(LLVMContext::OB_deopt) == 1,
4256  "experimental_deoptimize must have exactly one "
4257  "\"deopt\" operand bundle");
4258  Assert(CS.getType() == CS.getInstruction()->getFunction()->getReturnType(),
4259  "experimental_deoptimize return type must match caller return type");
4260 
4261  if (CS.isCall()) {
4262  auto *DeoptCI = CS.getInstruction();
4263  auto *RI = dyn_cast<ReturnInst>(DeoptCI->getNextNode());
4264  Assert(RI,
4265  "calls to experimental_deoptimize must be followed by a return");
4266 
4267  if (!CS.getType()->isVoidTy() && RI)
4268  Assert(RI->getReturnValue() == DeoptCI,
4269  "calls to experimental_deoptimize must be followed by a return "
4270  "of the value computed by experimental_deoptimize");
4271  }
4272 
4273  break;
4274  }
4275  };
4276 }
4277 
4278 /// \brief Carefully grab the subprogram from a local scope.
4279 ///
4280 /// This carefully grabs the subprogram from a local scope, avoiding the
4281 /// built-in assertions that would typically fire.
4282 static DISubprogram *getSubprogram(Metadata *LocalScope) {
4283  if (!LocalScope)
4284  return nullptr;
4285 
4286  if (auto *SP = dyn_cast<DISubprogram>(LocalScope))
4287  return SP;
4288 
4289  if (auto *LB = dyn_cast<DILexicalBlockBase>(LocalScope))
4290  return getSubprogram(LB->getRawScope());
4291 
4292  // Just return null; broken scope chains are checked elsewhere.
4293  assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope");
4294  return nullptr;
4295 }
4296 
4297 template <class DbgIntrinsicTy>
4298 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) {
4299  auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata();
4300  AssertDI(isa<ValueAsMetadata>(MD) ||
4301  (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
4302  "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
4303  AssertDI(isa<DILocalVariable>(DII.getRawVariable()),
4304  "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
4305  DII.getRawVariable());
4306  AssertDI(isa<DIExpression>(DII.getRawExpression()),
4307  "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
4308  DII.getRawExpression());
4309 
4310  // Ignore broken !dbg attachments; they're checked elsewhere.
4311  if (MDNode *N = DII.getDebugLoc().getAsMDNode())
4312  if (!isa<DILocation>(N))
4313  return;
4314 
4315  BasicBlock *BB = DII.getParent();
4316  Function *F = BB ? BB->getParent() : nullptr;
4317 
4318  // The scopes for variables and !dbg attachments must agree.
4319  DILocalVariable *Var = DII.getVariable();
4320  DILocation *Loc = DII.getDebugLoc();
4321  Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment",
4322  &DII, BB, F);
4323 
4324  DISubprogram *VarSP = getSubprogram(Var->getRawScope());
4325  DISubprogram *LocSP = getSubprogram(Loc->getRawScope());
4326  if (!VarSP || !LocSP)
4327  return; // Broken scope chains are checked elsewhere.
4328 
4329  AssertDI(VarSP == LocSP, "mismatched subprogram between llvm.dbg." + Kind +
4330  " variable and !dbg attachment",
4331  &DII, BB, F, Var, Var->getScope()->getSubprogram(), Loc,
4332  Loc->getScope()->getSubprogram());
4333 }
4334 
4335 static uint64_t getVariableSize(const DILocalVariable &V) {
4336  // Be careful of broken types (checked elsewhere).
4337  const Metadata *RawType = V.getRawType();
4338  while (RawType) {
4339  // Try to get the size directly.
4340  if (auto *T = dyn_cast<DIType>(RawType))
4341  if (uint64_t Size = T->getSizeInBits())
4342  return Size;
4343 
4344  if (auto *DT = dyn_cast<DIDerivedType>(RawType)) {
4345  // Look at the base type.
4346  RawType = DT->getRawBaseType();
4347  continue;
4348  }
4349 
4350  // Missing type or size.
4351  break;
4352  }
4353 
4354  // Fail gracefully.
4355  return 0;
4356 }
4357 
4358 void Verifier::verifyFragmentExpression(const DbgInfoIntrinsic &I) {
4359  DILocalVariable *V;
4360  DIExpression *E;
4361  if (auto *DVI = dyn_cast<DbgValueInst>(&I)) {
4362  V = dyn_cast_or_null<DILocalVariable>(DVI->getRawVariable());
4363  E = dyn_cast_or_null<DIExpression>(DVI->getRawExpression());
4364  } else {
4365  auto *DDI = cast<DbgDeclareInst>(&I);
4366  V = dyn_cast_or_null<DILocalVariable>(DDI->getRawVariable());
4367  E = dyn_cast_or_null<DIExpression>(DDI->getRawExpression());
4368  }
4369 
4370  // We don't know whether this intrinsic verified correctly.
4371  if (!V || !E || !E->isValid())
4372  return;
4373 
4374  // Nothing to do if this isn't a bit piece expression.
4375  auto Fragment = E->getFragmentInfo();
4376  if (!Fragment)
4377  return;
4378 
4379  // The frontend helps out GDB by emitting the members of local anonymous
4380  // unions as artificial local variables with shared storage. When SROA splits
4381  // the storage for artificial local variables that are smaller than the entire
4382  // union, the overhang piece will be outside of the allotted space for the
4383  // variable and this check fails.
4384  // FIXME: Remove this check as soon as clang stops doing this; it hides bugs.
4385  if (V->isArtificial())
4386  return;
4387 
4388  // If there's no size, the type is broken, but that should be checked
4389  // elsewhere.
4390  uint64_t VarSize = getVariableSize(*V);
4391  if (!VarSize)
4392  return;
4393 
4394  unsigned FragSize = Fragment->SizeInBits;
4395  unsigned FragOffset = Fragment->OffsetInBits;
4396  AssertDI(FragSize + FragOffset <= VarSize,
4397  "fragment is larger than or outside of variable", &I, V, E);
4398  AssertDI(FragSize != VarSize, "fragment covers entire variable", &I, V, E);
4399 }
4400 
4401 void Verifier::verifyCompileUnits() {
4402  auto *CUs = M.getNamedMetadata("llvm.dbg.cu");
4404  if (CUs)
4405  Listed.insert(CUs->op_begin(), CUs->op_end());
4406  AssertDI(
4407  all_of(CUVisited,
4408  [&Listed](const Metadata *CU) { return Listed.count(CU); }),
4409  "All DICompileUnits must be listed in llvm.dbg.cu");
4410  CUVisited.clear();
4411 }
4412 
4413 void Verifier::verifyDeoptimizeCallingConvs() {
4414  if (DeoptimizeDeclarations.empty())
4415  return;
4416 
4417  const Function *First = DeoptimizeDeclarations[0];
4418  for (auto *F : makeArrayRef(DeoptimizeDeclarations).slice(1)) {
4419  Assert(First->getCallingConv() == F->getCallingConv(),
4420  "All llvm.experimental.deoptimize declarations must have the same "
4421  "calling convention",
4422  First, F);
4423  }
4424 }
4425 
4426 //===----------------------------------------------------------------------===//
4427 // Implement the public interfaces to this file...
4428 //===----------------------------------------------------------------------===//
4429 
4431  Function &F = const_cast<Function &>(f);
4432 
4433  // Don't use a raw_null_ostream. Printing IR is expensive.
4434  Verifier V(OS, /*ShouldTreatBrokenDebugInfoAsError=*/true, *f.getParent());
4435 
4436  // Note that this function's return value is inverted from what you would
4437  // expect of a function called "verify".
4438  return !V.verify(F);
4439 }
4440 
4442  bool *BrokenDebugInfo) {
4443  // Don't use a raw_null_ostream. Printing IR is expensive.
4444  Verifier V(OS, /*ShouldTreatBrokenDebugInfoAsError=*/!BrokenDebugInfo, M);
4445 
4446  bool Broken = false;
4447  for (const Function &F : M)
4448  Broken |= !V.verify(F);
4449 
4450  Broken |= !V.verify();
4451  if (BrokenDebugInfo)
4452  *BrokenDebugInfo = V.hasBrokenDebugInfo();
4453  // Note that this function's return value is inverted from what you would
4454  // expect of a function called "verify".
4455  return Broken;
4456 }
4457 
4458 namespace {
4459 
4460 struct VerifierLegacyPass : public FunctionPass {
4461  static char ID;
4462 
4463  std::unique_ptr<Verifier> V;
4464  bool FatalErrors = true;
4465 
4466  VerifierLegacyPass() : FunctionPass(ID) {
4468  }
4469  explicit VerifierLegacyPass(bool FatalErrors)
4470  : FunctionPass(ID),
4471  FatalErrors(FatalErrors) {
4473  }
4474 
4475  bool doInitialization(Module &M) override {
4476  V = llvm::make_unique<Verifier>(
4477  &dbgs(), /*ShouldTreatBrokenDebugInfoAsError=*/false, M);
4478  return false;
4479  }
4480 
4481  bool runOnFunction(Function &F) override {
4482  if (!V->verify(F) && FatalErrors)
4483  report_fatal_error("Broken function found, compilation aborted!");
4484 
4485  return false;
4486  }
4487 
4488  bool doFinalization(Module &M) override {
4489  bool HasErrors = false;
4490  for (Function &F : M)
4491  if (F.isDeclaration())
4492  HasErrors |= !V->verify(F);
4493 
4494  HasErrors |= !V->verify();
4495  if (FatalErrors) {
4496  if (HasErrors)
4497  report_fatal_error("Broken module found, compilation aborted!");
4498  assert(!V->hasBrokenDebugInfo() && "Module contains invalid debug info");
4499  }
4500 
4501  // Strip broken debug info.
4502  if (V->hasBrokenDebugInfo()) {
4504  M.getContext().diagnose(DiagInvalid);
4505  if (!StripDebugInfo(M))
4506  report_fatal_error("Failed to strip malformed debug info");
4507  }
4508  return false;
4509  }
4510 
4511  void getAnalysisUsage(AnalysisUsage &AU) const override {
4512  AU.setPreservesAll();
4513  }
4514 };
4515 
4516 } // end anonymous namespace
4517 
4518 /// Helper to issue failure from the TBAA verification
4519 template <typename... Tys> void TBAAVerifier::CheckFailed(Tys &&... Args) {
4520  if (Diagnostic)
4521  return Diagnostic->CheckFailed(Args...);
4522 }
4523 
4524 #define AssertTBAA(C, ...) \
4525  do { \
4526  if (!(C)) { \
4527  CheckFailed(__VA_ARGS__); \
4528  return false; \
4529  } \
4530  } while (false)
4531 
4532 /// Verify that \p BaseNode can be used as the "base type" in the struct-path
4533 /// TBAA scheme. This means \p BaseNode is either a scalar node, or a
4534 /// struct-type node describing an aggregate data structure (like a struct).
4535 TBAAVerifier::TBAABaseNodeSummary
4536 TBAAVerifier::verifyTBAABaseNode(Instruction &I, const MDNode *BaseNode) {
4537  if (BaseNode->getNumOperands() < 2) {
4538  CheckFailed("Base nodes must have at least two operands", &I, BaseNode);
4539  return {true, ~0u};
4540  }
4541 
4542  auto Itr = TBAABaseNodes.find(BaseNode);
4543  if (Itr != TBAABaseNodes.end())
4544  return Itr->second;
4545 
4546  auto Result = verifyTBAABaseNodeImpl(I, BaseNode);
4547  auto InsertResult = TBAABaseNodes.insert({BaseNode, Result});
4548  (void)InsertResult;
4549  assert(InsertResult.second && "We just checked!");
4550  return Result;
4551 }
4552 
4553 TBAAVerifier::TBAABaseNodeSummary
4554 TBAAVerifier::verifyTBAABaseNodeImpl(Instruction &I, const MDNode *BaseNode) {
4555  const TBAAVerifier::TBAABaseNodeSummary InvalidNode = {true, ~0u};
4556 
4557  if (BaseNode->getNumOperands() == 2) {
4558  // Scalar nodes can only be accessed at offset 0.
4559  return isValidScalarTBAANode(BaseNode)
4560  ? TBAAVerifier::TBAABaseNodeSummary({false, 0})
4561  : InvalidNode;
4562  }
4563 
4564  if (BaseNode->getNumOperands() % 2 != 1) {
4565  CheckFailed("Struct tag nodes must have an odd number of operands!",
4566  BaseNode);
4567  return InvalidNode;
4568  }
4569 
4570  if (!isa<MDString>(BaseNode->getOperand(0))) {
4571  CheckFailed("Struct tag nodes have a string as their first operand",
4572  BaseNode);
4573  return InvalidNode;
4574  }
4575 
4576  bool Failed = false;
4577 
4578  Optional<APInt> PrevOffset;
4579  unsigned BitWidth = ~0u;
4580 
4581  // We've already checked that BaseNode is not a degenerate root node with one
4582  // operand in \c verifyTBAABaseNode, so this loop should run at least once.
4583  for (unsigned Idx = 1; Idx < BaseNode->getNumOperands(); Idx += 2) {
4584  const MDOperand &FieldTy = BaseNode->getOperand(Idx);
4585  const MDOperand &FieldOffset = BaseNode->getOperand(Idx + 1);
4586  if (!isa<MDNode>(FieldTy)) {
4587  CheckFailed("Incorrect field entry in struct type node!", &I, BaseNode);
4588  Failed = true;
4589  continue;
4590  }
4591 
4592  auto *OffsetEntryCI =
4593  mdconst::dyn_extract_or_null<ConstantInt>(FieldOffset);
4594  if (!OffsetEntryCI) {
4595  CheckFailed("Offset entries must be constants!", &I, BaseNode);
4596  Failed = true;
4597  continue;
4598  }
4599 
4600  if (BitWidth == ~0u)
4601  BitWidth = OffsetEntryCI->getBitWidth();
4602 
4603  if (OffsetEntryCI->getBitWidth() != BitWidth) {
4604  CheckFailed(
4605  "Bitwidth between the offsets and struct type entries must match", &I,
4606  BaseNode);
4607  Failed = true;
4608  continue;
4609  }
4610 
4611  // NB! As far as I can tell, we generate a non-strictly increasing offset
4612  // sequence only from structs that have zero size bit fields. When
4613  // recursing into a contained struct in \c getFieldNodeFromTBAABaseNode we
4614  // pick the field lexically the latest in struct type metadata node. This
4615  // mirrors the actual behavior of the alias analysis implementation.
4616  bool IsAscending =
4617  !PrevOffset || PrevOffset->ule(OffsetEntryCI->getValue());
4618 
4619  if (!IsAscending) {
4620  CheckFailed("Offsets must be increasing!", &I, BaseNode);
4621  Failed = true;
4622  }
4623 
4624  PrevOffset = OffsetEntryCI->getValue();
4625  }
4626 
4627  return Failed ? InvalidNode
4628  : TBAAVerifier::TBAABaseNodeSummary(false, BitWidth);
4629 }
4630 
4631 static bool IsRootTBAANode(const MDNode *MD) {
4632  return MD->getNumOperands() < 2;
4633 }
4634 
4635 static bool IsScalarTBAANodeImpl(const MDNode *MD,
4637  if (MD->getNumOperands() != 2 && MD->getNumOperands() != 3)
4638  return false;
4639 
4640  if (!isa<MDString>(MD->getOperand(0)))
4641  return false;
4642 
4643  if (MD->getNumOperands() == 3) {
4644  auto *Offset = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
4645  if (!(Offset && Offset->isZero() && isa<MDString>(MD->getOperand(0))))
4646  return false;
4647  }
4648 
4649  auto *Parent = dyn_cast_or_null<MDNode>(MD->getOperand(1));
4650  return Parent && Visited.insert(Parent).second &&
4651  (IsRootTBAANode(Parent) || IsScalarTBAANodeImpl(Parent, Visited));
4652 }
4653 
4654 bool TBAAVerifier::isValidScalarTBAANode(const MDNode *MD) {
4655  auto ResultIt = TBAAScalarNodes.find(MD);
4656  if (ResultIt != TBAAScalarNodes.end())
4657  return ResultIt->second;
4658 
4660  bool Result = IsScalarTBAANodeImpl(MD, Visited);
4661  auto InsertResult = TBAAScalarNodes.insert({MD, Result});
4662  (void)InsertResult;
4663  assert(InsertResult.second && "Just checked!");
4664 
4665  return Result;
4666 }
4667 
4668 /// Returns the field node at the offset \p Offset in \p BaseNode. Update \p
4669 /// Offset in place to be the offset within the field node returned.
4670 ///
4671 /// We assume we've okayed \p BaseNode via \c verifyTBAABaseNode.
4672 MDNode *TBAAVerifier::getFieldNodeFromTBAABaseNode(Instruction &I,
4673  const MDNode *BaseNode,
4674  APInt &Offset) {
4675  assert(BaseNode->getNumOperands() >= 2 && "Invalid base node!");
4676 
4677  // Scalar nodes have only one possible "field" -- their parent in the access
4678  // hierarchy. Offset must be zero at this point, but our caller is supposed
4679  // to Assert that.
4680  if (BaseNode->getNumOperands() == 2)
4681  return cast<MDNode>(BaseNode->getOperand(1));
4682 
4683  for (unsigned Idx = 1; Idx < BaseNode->getNumOperands(); Idx += 2) {
4684  auto *OffsetEntryCI =
4685  mdconst::extract<ConstantInt>(BaseNode->getOperand(Idx + 1));
4686  if (OffsetEntryCI->getValue().ugt(Offset)) {
4687  if (Idx == 1) {
4688  CheckFailed("Could not find TBAA parent in struct type node", &I,
4689  BaseNode, &Offset);
4690  return nullptr;
4691  }
4692 
4693  auto *PrevOffsetEntryCI =
4694  mdconst::extract<ConstantInt>(BaseNode->getOperand(Idx - 1));
4695  Offset -= PrevOffsetEntryCI->getValue();
4696  return cast<MDNode>(BaseNode->getOperand(Idx - 2));
4697  }
4698  }
4699 
4700  auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
4701  BaseNode->getOperand(BaseNode->getNumOperands() - 1));
4702 
4703  Offset -= LastOffsetEntryCI->getValue();
4704  return cast<MDNode>(BaseNode->getOperand(BaseNode->getNumOperands() - 2));
4705 }
4706 
4708  AssertTBAA(isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
4709  isa<VAArgInst>(I) || isa<AtomicRMWInst>(I) ||
4710  isa<AtomicCmpXchgInst>(I),
4711  "TBAA is only for loads, stores and calls!", &I);
4712 
4713  bool IsStructPathTBAA =
4714  isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3;
4715 
4716  AssertTBAA(
4717  IsStructPathTBAA,
4718  "Old-style TBAA is no longer allowed, use struct-path TBAA instead", &I);
4719 
4720  AssertTBAA(MD->getNumOperands() < 5,
4721  "Struct tag metadata must have either 3 or 4 operands", &I, MD);
4722 
4723  MDNode *BaseNode = dyn_cast_or_null<MDNode>(MD->getOperand(0));
4724  MDNode *AccessType = dyn_cast_or_null<MDNode>(MD->getOperand(1));
4725 
4726  if (MD->getNumOperands() == 4) {
4727  auto *IsImmutableCI =
4728  mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(3));
4729  AssertTBAA(IsImmutableCI,
4730  "Immutability tag on struct tag metadata must be a constant", &I,
4731  MD);
4732  AssertTBAA(
4733  IsImmutableCI->isZero() || IsImmutableCI->isOne(),
4734  "Immutability part of the struct tag metadata must be either 0 or 1",
4735  &I, MD);
4736  }
4737 
4738  AssertTBAA(BaseNode && AccessType,
4739  "Malformed struct tag metadata: base and access-type "
4740  "should be non-null and point to Metadata nodes",
4741  &I, MD, BaseNode, AccessType);
4742 
4743  AssertTBAA(isValidScalarTBAANode(AccessType),
4744  "Access type node must be a valid scalar type", &I, MD,
4745  AccessType);
4746 
4747  auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(2));
4748  AssertTBAA(OffsetCI, "Offset must be constant integer", &I, MD);
4749 
4750  APInt Offset = OffsetCI->getValue();
4751  bool SeenAccessTypeInPath = false;
4752 
4753  SmallPtrSet<MDNode *, 4> StructPath;
4754 
4755  for (/* empty */; BaseNode && !IsRootTBAANode(BaseNode);
4756  BaseNode = getFieldNodeFromTBAABaseNode(I, BaseNode, Offset)) {
4757  if (!StructPath.insert(BaseNode).second) {
4758  CheckFailed("Cycle detected in struct path", &I, MD);
4759  return false;
4760  }
4761 
4762  bool Invalid;
4763  unsigned BaseNodeBitWidth;
4764  std::tie(Invalid, BaseNodeBitWidth) = verifyTBAABaseNode(I, BaseNode);
4765 
4766  // If the base node is invalid in itself, then we've already printed all the
4767  // errors we wanted to print.
4768  if (Invalid)
4769  return false;
4770 
4771  SeenAccessTypeInPath |= BaseNode == AccessType;
4772 
4773  if (isValidScalarTBAANode(BaseNode) || BaseNode == AccessType)
4774  AssertTBAA(Offset == 0, "Offset not zero at the point of scalar access",
4775  &I, MD, &Offset);
4776 
4777  AssertTBAA(BaseNodeBitWidth == Offset.getBitWidth() ||
4778  (BaseNodeBitWidth == 0 && Offset == 0),
4779  "Access bit-width not the same as description bit-width", &I, MD,
4780  BaseNodeBitWidth, Offset.getBitWidth());
4781  }
4782 
4783  AssertTBAA(SeenAccessTypeInPath, "Did not see access type in access path!",
4784  &I, MD);
4785  return true;
4786 }
4787 
4788 char VerifierLegacyPass::ID = 0;
4789 INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
4790 
4791 FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
4792  return new VerifierLegacyPass(FatalErrors);
4793 }
4794 
4795 AnalysisKey VerifierAnalysis::Key;
4798  Result Res;
4799  Res.IRBroken = llvm::verifyModule(M, &dbgs(), &Res.DebugInfoBroken);
4800  return Res;
4801 }
4802 
4805  return { llvm::verifyFunction(F, &dbgs()), false };
4806 }
4807 
4809  auto Res = AM.getResult<VerifierAnalysis>(M);
4810  if (FatalErrors) {
4811  if (Res.IRBroken)
4812  report_fatal_error("Broken module found, compilation aborted!");
4813  assert(!Res.DebugInfoBroken && "Module contains invalid debug info");
4814  }
4815 
4816  // Strip broken debug info.
4817  if (Res.DebugInfoBroken) {
4819  M.getContext().diagnose(DiagInvalid);
4820  if (!StripDebugInfo(M))
4821  report_fatal_error("Failed to strip malformed debug info");
4822  }
4823  return PreservedAnalyses::all();
4824 }
4825 
4827  auto res = AM.getResult<VerifierAnalysis>(F);
4828  if (res.IRBroken && FatalErrors)
4829  report_fatal_error("Broken function found, compilation aborted!");
4830 
4831  return PreservedAnalyses::all();
4832 }
MachineLoop * L
AttributeSet getAttributes() const
Return the parameter attributes for this call.
Metadata * getRawScope() const
IterTy arg_end() const
Definition: CallSite.h:532
bool matchIntrinsicType(Type *Ty, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type * > &ArgTys)
Match the specified type (which comes from an intrinsic argument or return value) with the type const...
Definition: Function.cpp:967
const Use & getOperandUse(unsigned i) const
Definition: User.h:158
Return a value (possibly void), from a function.
static bool isScope(const Metadata *MD)
Definition: Verifier.cpp:822
StringRef getName() const
Definition: Metadata.cpp:1059
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
AtomicOrdering getFailureOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:590
LinkageTypes getLinkage() const
Definition: GlobalValue.h:429
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:679
IntegerType * getType() const
getType - Specialize the getType() method to always return an IntegerType, which reduces the amount o...
Definition: Constants.h:177
unsigned getNumHandlers() const
return the number of 'handlers' in this catchswitch instruction, except the default handler ...
static Value * getParentPad(Value *EHPad)
Definition: Verifier.cpp:3251
FunTy * getCaller() const
getCaller - Return the caller function for this call site
Definition: CallSite.h:262
iterator_range< use_iterator > uses()
Definition: Value.h:326
bool hasComdat() const
Definition: GlobalObject.h:91
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
Definition: CallingConv.h:139
This instruction extracts a struct member or array element value from an aggregate value...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Metadata * getRawTemplateParams() const
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:226
iterator_range< CaseIt > cases()
Iteration adapter for range-for loops.
unsigned getNumOperandBundles() const
Definition: CallSite.h:488
LLVM Argument representation.
Definition: Argument.h:34
LLVMContext & Context
uint64_t Token
Base class for instruction visitors.
Definition: InstVisitor.h:81
Value * getAggregateOperand()
Atomic ordering constants.
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:274
Type * getSourceElementType() const
Definition: Instructions.h:928
bool hasName() const
Definition: Value.h:236
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
size_t i
SynchronizationScope getSynchScope() const
Definition: Instructions.h:366
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:162
ArrayRef< unsigned > getIndices() const
MDTuple * get() const
Definition: Metadata.h:1211
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:36
static bool isValidOperands(const Value *Vec, const Value *NewElt, const Value *Idx)
Return true if an insertelement instruction can be formed with the specified operands.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:137
static bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull)
Definition: Verifier.cpp:826
Result run(Module &M, ModuleAnalysisManager &)
Definition: Verifier.cpp:4796
AtomicOrdering getSuccessOrdering() const
Returns the ordering constraint on this cmpxchg.
Definition: Instructions.h:585
An instruction for ordering other memory operations.
Definition: Instructions.h:430
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:504
static bool isValidMetadataNullArray(const MDTuple &N)
Definition: Verifier.cpp:843
DILocalScope * getScope() const
Get the local scope for this variable.
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:167
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1040
ModuleSlotTracker MST
Definition: Verifier.cpp:125
Value * getValue() const
Convenience accessor.
int64_t getCount() const
BBTy * getParent() const
Get the basic block containing the call site.
Definition: CallSite.h:98
Metadata * getRawFile() const
Return the raw underlying file.
DIMacroNodeArray getElements() const
Type * getValueType() const
Definition: GlobalValue.h:261
This class represents a function call, abstracting a target machine's calling convention.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:151
bool hasInAllocaArgument() const
Determine if there are is an inalloca argument.
Definition: CallSite.h:572
bool hasAppendingLinkage() const
Definition: GlobalValue.h:412
Metadata * getRawType() const
This file contains the declarations for metadata subclasses.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
static uint64_t getVariableSize(const DILocalVariable &V)
Definition: Verifier.cpp:4335
FunctionPass * createVerifierPass(bool FatalErrors=true)
Definition: Verifier.cpp:4791
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
This instruction constructs a fixed permutation of two input vectors.
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:402
bool onlyReadsMemory() const
Determine if the call does not access or only reads memory.
Definition: CallSite.h:429
iterator begin(unsigned Slot) const
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:192
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
Definition: Type.h:216
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.cpp:238
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:32
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:736
bool isEHPad() const
Return true if this basic block is an exception handling block.
Definition: BasicBlock.h:315
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
unsigned getParamAlignment(unsigned Index) const
Return the alignment for the specified function parameter.
const Instruction & front() const
Definition: BasicBlock.h:240
Metadata node.
Definition: Metadata.h:830
This class represents a sign extension of integer types.
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:471
An instruction for reading from memory.
Definition: Instructions.h:164
Manage lifetime of a slot tracker for printing IR.
void CheckFailed(const Twine &Message)
A check failed, so printout out the condition and the message.
Definition: Verifier.cpp:216
Typed, array-like tuple of metadata.
Definition: Metadata.h:1187
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:669
Hexagon Common GEP
This defines the Use class.
Type * getElementType() const
Definition: DerivedTypes.h:462
void reserve(size_type N)
Definition: SmallVector.h:377
loop data prefetch
const DataLayout & DL
Definition: Verifier.cpp:126
static bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other)
Returns true if ao is stronger than other as defined by the AtomicOrdering lattice, which is based on C++'s definition.
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:994
const Module & M
Definition: Verifier.cpp:124
Metadata * getRawScope() const
const Constant * getAliasee() const
Definition: GlobalAlias.h:74
unsigned getOpcode() const
Return the opcode at the root of this constant expression.
Definition: Constants.h:1182
bool isFiniteNonZero() const
Definition: APFloat.h:1045
uint64_t High
Diagnostic information for stripping invalid debug metadata.
Tuple of metadata.
Definition: Metadata.h:1072
A scope for locals.
unsigned getColumn() const
Check a module for errors, and report separate error states for IR and debug info errors...
Definition: Verifier.h:102
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:165
unsigned arg_size() const
Definition: CallSite.h:211
Metadata * getRawType() const
size_t arg_size() const
Definition: Function.cpp:327
iterator_range< user_iterator > materialized_users()
Definition: Value.h:364
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
Adds a requirement that another module flag be present and have a specified value after linking is pe...
Definition: Module.h:116
LLVMContext & Context
Definition: Verifier.cpp:127
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: Verifier.cpp:4808
ArrayRef< unsigned > getIndices() const
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:172
raw_ostream * OS
Definition: Verifier.cpp:123
Appends the two values, which are required to be metadata nodes.
Definition: Module.h:124
Value * getDerivedPtr() const
Definition: Statepoint.h:394
A tuple of MDNodes.
Definition: Metadata.h:1282
This class represents a conversion between pointers from one address space to another.
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy)
This method can be used to determine if a cast from S to DstTy using Opcode op is valid or not...
bool hasCommonLinkage() const
Definition: GlobalValue.h:419
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
Returns the type of the element that would be extracted with an extractvalue instruction with the spe...
StringRef getName() const
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:250
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:555
This class represents the LLVM 'select' instruction.
struct fuzzer::@269 Flags
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:143
unsigned getTag() const
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:440
void CheckFailed(const Twine &Message, const T1 &V1, const Ts &...Vs)
A check failed (with values to print).
Definition: Verifier.cpp:227
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:3394
Class to represent struct types.
Definition: DerivedTypes.h:199
Array subrange.
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
ValTy * getCalledValue() const
getCalledValue - Return the pointer to function that is being called.
Definition: CallSite.h:102
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:114
Instruction * getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:180
bool canLosslesslyBitCastTo(Type *Ty) const
Return true if this type could be converted with a lossless BitCast to type 'Ty'. ...
Definition: Type.cpp:54
Metadata * getRawRetainedTypes() const
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:308
This file contains the simple types necessary to represent the attributes associated with functions a...
bool isMustTailCall() const
StringRef getFilename() const
unsigned getMacinfoType() const
StringRef getName() const
static const unsigned MaximumAlignment
Definition: Value.h:550
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:193
Type * getPointerOperandType() const
Method to return the pointer operand as a PointerType.
Definition: Instructions.h:973
StringRef getName() const
Definition: Comdat.cpp:22
BasicBlock * getDestination(unsigned i)
Return the specified destination.
DITypeRefArray getTypeArray() const
This file implements a class to represent arbitrary precision integral constant values and operations...
bool hasPrivateLinkage() const
Definition: GlobalValue.h:414
SynchronizationScope getSynchScope() const
Definition: Instructions.h:245
This class represents a cast from a pointer to an integer.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
bool hasValidDeclarationLinkage() const
Definition: GlobalValue.h:420
AtomicOrdering
Atomic ordering for LLVM's memory model.
static bool IsRootTBAANode(const MDNode *MD)
Definition: Verifier.cpp:4631
Metadata * getRawFile() const
static bool isValidOperands(const Value *V1, const Value *V2, const Value *Mask)
Return true if a shufflevector instruction can be formed with the specified operands.
void visit(Iterator Start, Iterator End)
Definition: InstVisitor.h:90
Metadata * getRawStaticDataMemberDeclaration() const
Subprogram description.
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:873
Class to represent function types.
Definition: DerivedTypes.h:102
AtomicOrdering getOrdering() const
Returns the ordering constraint on this RMW.
Definition: Instructions.h:767
#define F(x, y, z)
Definition: MD5.cpp:51
static bool isTypeCongruent(Type *L, Type *R)
Two types are "congruent" if they are identical, or if they are both pointer types with different poi...
Definition: Verifier.cpp:2738
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
bool isInlineAsm() const
Definition: CallSite.h:300
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3473
#define T
#define Assert(C,...)
We know that cond should be true, if not print an error message.
Definition: Verifier.cpp:512
Class to represent array types.
Definition: DerivedTypes.h:345
Enumeration value.
This instruction compares its operands according to the predicate given to the constructor.
Function Alias Analysis false
bool sgt(const APInt &RHS) const
Signed greather than comparison.
Definition: APInt.h:1101
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:266
bool isFirstClassType() const
Return true if the type is "first class", meaning it is a valid type for a Value. ...
Definition: Type.h:233
This class represents a no-op cast from one type to another.
op_iterator idx_begin()
Definition: Instructions.h:956
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:291
std::pair< unsigned, Optional< unsigned > > getAllocSizeArgs(unsigned Index) const
Get the allocsize argument numbers (or pair(0, 0) if unknown).
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
bool isFloatingPointTy() const
Return true if this is one of the six floating-point types.
Definition: Type.h:160
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:68
An instruction for storing to memory.
Definition: Instructions.h:300
This class represents a cast from floating point to signed integer.
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:210
Metadata * getRawEnumTypes() const
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:325
Debug location.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
handler_range handlers()
iteration adapter for range-for loops.
iterator_range< op_iterator > operands()
Definition: Metadata.h:1372
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
Type * getScalarType() const LLVM_READONLY
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.cpp:44
This class represents a truncation of integer types.
bool isAtomic() const
Return true if this instruction has an AtomicOrdering of unordered or higher.
BasicBlock * getNormalDest() const
Class to represent pointers.
Definition: DerivedTypes.h:443
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
static const fltSemantics & IEEEsingle()
Definition: APFloat.cpp:100
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:121
Metadata * getRawScope() const
static bool isValidMetadataArray(const MDTuple &N)
Definition: Verifier.cpp:839
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:254
static ChecksumKind getChecksumKind(StringRef CSKindStr)
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:830
void print(raw_ostream &OS, const Module *M=nullptr, bool IsForDebug=false) const
Print.
Definition: AsmWriter.cpp:3527
bool isFilter(unsigned Idx) const
Return 'true' if the clause and index Idx is a filter clause.
bool verify(const TargetRegisterInfo &TRI) const
Check that information hold by this instance make sense for the given TRI.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:201
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:133
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
This instruction inserts a single (scalar) element into a VectorType value.
iterator_range< IterTy > args() const
Definition: CallSite.h:207
The landingpad instruction holds all of the information necessary to generate correct exception handl...
Emits an error if two values disagree, otherwise the resulting value is that of the operands...
Definition: Module.h:103
Metadata * getRawFile() const
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:348
FunctionType * getFunctionType() const
Definition: CallSite.h:315
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
Metadata * getRawMacros() const
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
bool isTemporary() const
Definition: Metadata.h:909
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
Conditional or Unconditional Branch instruction.
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:219
This is an important base class in LLVM.
Definition: Constant.h:42
void getModuleFlagsMetadata(SmallVectorImpl< ModuleFlagEntry > &Flags) const
Returns the module flags in the provided vector.
Definition: Module.cpp:305
PointerType * getType() const
Overload to return most specific pointer type.
Definition: Instructions.h:97
Metadata * getRawType() const
void DebugInfoCheckFailed(const Twine &Message, const T1 &V1, const Ts &...Vs)
A debug info check failed (with values to print).
Definition: Verifier.cpp:243
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1207
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
Resume the propagation of an exception.
DIFile * getFile() const
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:36
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Indirect Branch Instruction.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
Base class for template parameters.
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
Definition: Module.h:100
unsigned getAlignment() const
Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:109
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:269
LandingPadInst * getLandingPadInst()
Return the landingpad instruction associated with the landing pad.
Definition: BasicBlock.cpp:441
DIFlags getFlags() const
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1952
unsigned getLine() const
Value * stripInBoundsOffsets()
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:544
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:116
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:581
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
static bool isValidLinkage(LinkageTypes L)
Definition: GlobalAlias.h:81
A pair of DIGlobalVariable and DIExpression.
Represent the analysis usage information of a pass.
constexpr bool isPowerOf2_64(uint64_t Value)
isPowerOf2_64 - This function returns true if the argument is a power of two 0 (64 bit edition...
Definition: MathExtras.h:405
This file declares a class to represent arbitrary precision floating point values and provide a varie...
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:154
uint16_t getParamAlignment(uint16_t i) const
Extract the alignment for a call or parameter (0=unknown).
Definition: CallSite.h:383
unsigned getMetadataID() const
Definition: Metadata.h:95
uint32_t Offset
bool visitTBAAMetadata(Instruction &I, const MDNode *MD)
Visit an instruction and return true if it is valid, return false if an invalid TBAA is attached...
Definition: Verifier.cpp:4707
Metadata * getRawElements() const
This instruction compares its operands according to the predicate given to the constructor.
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1255
uint64_t getNumElements() const
Definition: DerivedTypes.h:335
DIMacroNodeArray getMacros() const
User * getUser() const
Returns the User that contains this Use.
Definition: Use.cpp:41
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
Value * getOperand(unsigned i) const
Definition: User.h:145
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:119
op_range operands()
Definition: User.h:213
Base class for variables.
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:80
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:960
bool pred_empty(const BasicBlock *BB)
Definition: IR/CFG.h:107
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Definition: InstrTypes.h:1234
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:136
Metadata wrapper in the Value hierarchy.
Definition: Metadata.h:161
This class represents a cast from an integer to a pointer.
static DISubprogram * getSubprogram(Metadata *LocalScope)
Carefully grab the subprogram from a local scope.
Definition: Verifier.cpp:4282
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:183
static bool isValidOperands(const Value *Vec, const Value *Idx)
Return true if an extractelement instruction can be formed with the specified operands.
const Value * getTrueValue() const
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:391
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
User::op_iterator arg_iterator
arg_iterator - The type of iterator to use when looping over actual arguments at this call site...
Definition: CallSite.h:205
OperandBundleUse getOperandBundleAt(unsigned Index) const
Definition: CallSite.h:508
FunctionType * getFunctionType() const
An imported module (C++ using directive or similar).
Base class for scope-like contexts.
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:36
DIScopeArray getRetainedTypes() const
bool doesNotAccessMemory() const
Determine if the call does not access memory.
Definition: CallSite.h:421
BasicBlock * getUnwindDest() const
bool isConditional() const
DIExpression * getExpression() const
AttributeSet getAttributes() const
getAttributes/setAttributes - get or set the parameter attributes of the call.
Definition: CallSite.h:325
IterTy arg_begin() const
Definition: CallSite.h:528
BasicBlock * getUnwindDest() const
DIImportedEntityArray getImportedEntities() const
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
StringRef getString() const
Definition: Metadata.cpp:424
bool hasExternalLinkage() const
Definition: GlobalValue.h:401
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:247
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1034
Metadata * getRawBaseType() const
#define AssertDI(C,...)
We know that a debug info condition should be true, if not print an error message.
Definition: Verifier.cpp:517
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: CallSite.h:446
Iterator for intrusive lists based on ilist_node.
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:187
BasicBlock * getUnwindDest() const
unsigned getTag() const
AtomicOrdering getOrdering() const
Returns the ordering effect of this store.
Definition: Instructions.h:355
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
Definition: Instructions.h:132
Metadata * getMetadata() const
Definition: Metadata.h:176
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1116
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
constexpr bool isInt< 32 >(int64_t x)
Definition: MathExtras.h:274
InstrTy * getInstruction() const
Definition: CallSite.h:93
VerifierSupport(raw_ostream *OS, const Module &M)
Definition: Verifier.cpp:136
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:1406
bool isNegative() const
Definition: APFloat.h:1035
PTX_Device - Call to a PTX device function.
Definition: CallingConv.h:118
static Optional< DebugEmissionKind > getEmissionKind(StringRef Str)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:123
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:784
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:178
Metadata * getRawInlinedAt() const
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
bool isStaticAlloca() const
Return true if this alloca is in the entry block of the function and is a constant size...
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
static bool isDINode(const Metadata *MD)
Definition: Verifier.cpp:823
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB)
Checks if Metadata represents a valid ModFlagBehavior, and stores the converted result in MFB...
Definition: Module.cpp:292
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:175
iterator end(unsigned Slot) const
This class represents a range of values.
Definition: ConstantRange.h:45
This is the common base class for debug info intrinsics.
Definition: IntrinsicInst.h:67
static const char * Target
const APInt & getLower() const
Return the lower value for this range.
StringRef getName() const
This class represents a cast from floating point to unsigned integer.
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
Value * getParentPad() const
Convenience accessors.
Definition: InstrTypes.h:1172
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:234
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:198
pred_range predecessors(BasicBlock *BB)
Definition: IR/CFG.h:110
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
Metadata * getRawEntity() const
BinOp getOperation() const
Definition: Instructions.h:724
DWARF expression.
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:146
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
Uses the specified value, regardless of the behavior or value of the other module.
Definition: Module.h:121
static BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
Definition: Constants.cpp:1374
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
unsigned getNumArgOperands() const
Definition: CallSite.h:288
Class to represent vector types.
Definition: DerivedTypes.h:369
Target - Wrapper for Target specific information.
ConstantArray - Constant Array Declarations.
Definition: Constants.h:411
bool hasInitializer() const
Definitions have initializers, declarations don't.
Class for arbitrary precision integers.
Definition: APInt.h:77
DIGlobalVariableExpressionArray getGlobalVariables() const
A (clang) module that has been imported by the compile unit.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1458
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
Emits a warning if two values disagree.
Definition: Module.h:107
static Instruction * getSuccPad(TerminatorInst *Terminator)
Definition: Verifier.cpp:1890
void setPreservesAll()
Set by analyses that do not transform their input at all.
A lightweight accessor for an operand bundle meant to be passed around by value.
Definition: InstrTypes.h:1206
iterator_range< user_iterator > users()
Definition: Value.h:370
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:438
bool empty() const
Definition: Function.h:541
Generic tagged DWARF-like metadata node.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
Value * getCondition() const
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:464
bool isInlineAsm() const
Check if this call is an inline asm statement.
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1391
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
Definition: Verifier.cpp:4441
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
Value * getParentPad() const
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
Returns the type of the element that would be loaded with a load instruction with the specified param...
static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs)
Definition: Verifier.cpp:2748
bool isDistinct() const
Definition: Metadata.h:908
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:453
Type array for a subprogram.
Metadata * getRawImportedEntities() const
Metadata * getRawScope() const
Metadata * getRawScope() const
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:259
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:265
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
Value * getCondition() const
Appends the two values, which are required to be metadata nodes.
Definition: Module.h:129
AtomicOrdering getOrdering() const
Returns the ordering effect of this fence.
Definition: Instructions.h:457
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
bool BrokenDebugInfo
Broken debug info can be "recovered" from by stripping the debug info.
Definition: Verifier.cpp:132
Value * getValue() const
Definition: Metadata.h:361
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:227
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
bool isCatch(unsigned Idx) const
Return 'true' if the clause and index Idx is a catch clause.
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
bool hasComdat() const
Definition: GlobalValue.h:213
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.cpp:230
bool paramHasAttr(unsigned i, Attribute::AttrKind Kind) const
Return true if the call or the callee has the given attribute.
Definition: CallSite.h:359
DIGlobalVariable * getVariable() const
void initializeVerifierLegacyPassPass(PassRegistry &)
This class represents a cast unsigned integer to floating point.
bool verifyFunction(const Function &F, raw_ostream *OS=nullptr)
Check a function for errors, useful for use when debugging a pass.
Definition: Verifier.cpp:4430
Metadata * getRawElements() const
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
This instruction extracts a single (scalar) element from a VectorType value.
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
Definition: Constants.cpp:1045
op_range operands() const
Definition: Metadata.h:1032
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
void DebugInfoCheckFailed(const Twine &Message)
A debug info check failed.
Definition: Verifier.cpp:234
Metadata * getRawFile() const
bool isVarArg() const
Definition: DerivedTypes.h:122
Metadata * getRawScope() const
bool isStatepoint(ImmutableCallSite CS)
Definition: Statepoint.cpp:27
std::vector< uint8_t > Unit
Definition: FuzzerDefs.h:71
const unsigned Kind
Multiway switch.
This class represents a cast from signed integer to floating point.
const APInt & getUpper() const
Return the upper value for this range.
Type * getReturnType() const
Definition: DerivedTypes.h:123
unsigned getAlignment() const
Definition: Globals.cpp:72
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static void forEachUser(const Value *User, SmallPtrSet< const Value *, 32 > &Visited, llvm::function_ref< bool(const Value *)> Callback)
Definition: Verifier.cpp:529
const BasicBlock & front() const
Definition: Function.h:542
This class represents a truncation of floating point types.
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:110
DICompositeTypeArray getEnumTypes() const
Represents calls to the gc.relocate intrinsic.
Definition: Statepoint.h:367
bool isLabelTy() const
Return true if this is 'label'.
Definition: Type.h:186
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
Verify that the TBAA Metadatas are valid.
Definition: Verifier.h:36
LLVM Value Representation.
Definition: Value.h:71
static bool hasConflictingReferenceFlags(unsigned Flags)
Definition: Verifier.cpp:905
bool TreatBrokenDebugInfoAsError
Whether to treat broken debug info as an error.
Definition: Verifier.cpp:134
AttrBuilder typeIncompatible(Type *Ty)
Which attributes cannot be applied to a type.
const Value * getArraySize() const
Get the number of elements allocated.
Definition: Instructions.h:93
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
ValTy * getArgOperand(unsigned i) const
Definition: CallSite.h:292
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
Invoke instruction.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:125
void print(raw_ostream &ROS, bool IsForDebug=false) const
Definition: AsmWriter.cpp:3320
bool Broken
Track the brokenness of the module while recursively visiting.
Definition: Verifier.cpp:130
static bool IsScalarTBAANodeImpl(const MDNode *MD, SmallPtrSetImpl< const MDNode * > &Visited)
Definition: Verifier.cpp:4635
static bool isContiguous(const ConstantRange &A, const ConstantRange &B)
Definition: Verifier.cpp:2998
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:678
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
A single uniqued string.
Definition: Metadata.h:586
AttrBuilder & addAlignmentAttr(unsigned Align)
This turns an int alignment (which must be a power of 2) into the form used internally in Attribute...
A container for analyses that lazily runs them and caches their results.
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
int * Ptr
This header defines various interfaces for pass management in LLVM.
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:289
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:102
op_range incoming_values()
This class represents an extension of floating point types.
bool isResolved() const
Check if node is fully resolved.
Definition: Metadata.h:905
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
A bitmask that includes all valid flags.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:479
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
#define AssertTBAA(C,...)
Definition: Verifier.cpp:4524
Root of the metadata hierarchy.
Definition: Metadata.h:55
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1051
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:42
bool isDeclarationForLinker() const
Definition: GlobalValue.h:496
unsigned getNumDestinations() const
return the number of possible destinations in this indirectbr instruction.
const fltSemantics & getSemantics() const
Definition: APFloat.h:1043
bool isEmpty() const
Return true if there are no attributes.
Definition: Attributes.h:400
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:64
const BasicBlock * getParent() const
Definition: Instruction.h:62
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:83
Type * getResultElementType() const
Definition: Instructions.h:933
static cl::opt< bool > VerifyDebugInfo("verify-debug-info", cl::init(true))
#define T1
Type * getTypeAtIndex(const Value *V) const
Given an index value into the type, return the type of the element.
Definition: Type.cpp:554
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
an instruction to allocate memory on the stack
Definition: Instructions.h:60
This instruction inserts a struct field of array element value into an aggregate value.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:67
static bool isType(const Metadata *MD)
Definition: Verifier.cpp:821
StringRef getValue() const
Metadata * getRawGlobalVariables() const
Basic type, like 'int' or 'float'.
bool isMetadataTy() const
Return true if this is 'metadata'.
Definition: Type.h:189
Metadata * getRawTypeArray() const
static const char * areInvalidOperands(Value *Cond, Value *True, Value *False)
Return a string if the specified operands are invalid for a select operation, otherwise return null...
Metadata * getRawVTableHolder() const