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